diff --git a/base/base.pro b/base/base.pro
index 71585dbb5f..7720f58b57 100644
--- a/base/base.pro
+++ b/base/base.pro
@@ -15,6 +15,7 @@ SOURCES += base.cpp \
     string_utils.cpp \
     profiler.cpp \
     commands_queue.cpp \
+    shared_buffer_manager.cpp
 
 HEADERS += SRC_FIRST.hpp \
     assert.hpp \
@@ -51,4 +52,5 @@ HEADERS += SRC_FIRST.hpp \
     commands_queue.hpp \
     ptr_utils.hpp \
     stats.hpp \
-    monitor.hpp
+    monitor.hpp \
+    shared_buffer_manager.hpp
diff --git a/base/shared_buffer_manager.cpp b/base/shared_buffer_manager.cpp
new file mode 100644
index 0000000000..29d456a2ea
--- /dev/null
+++ b/base/shared_buffer_manager.cpp
@@ -0,0 +1,33 @@
+#include "../base/SRC_FIRST.hpp"
+#include "shared_buffer_manager.hpp"
+#include "ptr_utils.hpp"
+
+SharedBufferManager & SharedBufferManager::instance()
+{
+  static SharedBufferManager i;
+  return i;
+}
+
+SharedBufferManager::shared_buffer_ptr_t SharedBufferManager::reserveSharedBuffer(size_t s)
+{
+  threads::MutexGuard g(m_mutex);
+
+  shared_buffer_ptr_list_t l = m_sharedBuffers[s];
+
+  if (l.empty())
+    l.push_back(make_shared_ptr(new shared_buffer_t(s)));
+
+  shared_buffer_ptr_t res = l.front();
+  l.pop_front();
+
+  return res;
+}
+
+void SharedBufferManager::freeSharedBuffer(size_t s, shared_buffer_ptr_t buf)
+{
+  threads::MutexGuard g(m_mutex);
+
+  shared_buffer_ptr_list_t l = m_sharedBuffers[s];
+
+  l.push_back(buf);
+}
diff --git a/base/shared_buffer_manager.hpp b/base/shared_buffer_manager.hpp
new file mode 100644
index 0000000000..e4b57ac187
--- /dev/null
+++ b/base/shared_buffer_manager.hpp
@@ -0,0 +1,26 @@
+#pragma once
+
+#include "../base/mutex.hpp"
+#include "../std/vector.hpp"
+#include "../std/shared_ptr.hpp"
+#include "../std/list.hpp"
+#include "../std/map.hpp"
+
+class SharedBufferManager
+{
+public:
+  typedef vector<unsigned char> shared_buffer_t;
+  typedef shared_ptr<shared_buffer_t> shared_buffer_ptr_t;
+  typedef list<shared_buffer_ptr_t> shared_buffer_ptr_list_t;
+  typedef map<size_t, shared_buffer_ptr_list_t> shared_buffers_t;
+private:
+
+  threads::Mutex m_mutex;
+  shared_buffers_t m_sharedBuffers;
+
+public:
+  static SharedBufferManager & instance();
+
+  shared_buffer_ptr_t reserveSharedBuffer(size_t s);
+  void freeSharedBuffer(size_t s, shared_buffer_ptr_t buf);
+};
diff --git a/yg/managed_texture.cpp b/yg/managed_texture.cpp
index 949854fa37..f991cc4afc 100644
--- a/yg/managed_texture.cpp
+++ b/yg/managed_texture.cpp
@@ -2,48 +2,39 @@
 
 #include "internal/opengl.hpp"
 #include "managed_texture.hpp"
+#include "../base/shared_buffer_manager.hpp"
 
 namespace yg
 {
   namespace gl
   {
-    ManagedTexture::ManagedTexture(unsigned width, unsigned height)
-      : BaseTexture(width, height), m_isLocked(false)
+    ManagedTexture::ManagedTexture(unsigned width, unsigned height, size_t pixelSize)
+      : BaseTexture(width, height), m_imageSize(width * height * pixelSize), m_isLocked(false)
     {}
 
-    ManagedTexture::ManagedTexture(m2::PointU const & size)
-      : BaseTexture(size.x, size.y), m_isLocked(false)
+    ManagedTexture::ManagedTexture(m2::PointU const & size, size_t pixelSize)
+      : BaseTexture(size.x, size.y), m_imageSize(size.x * size.y * pixelSize), m_isLocked(false)
     {}
 
-    void ManagedTexture::addDirtyRect(m2::RectU const & r)
-    {
-      if (m_isLocked)
-      {
-        if (!m_isDirty && (r.SizeX() != 0) && (r.SizeY() != 0))
-        {
-          m_dirtyRect = r;
-          m_isDirty = true;
-        }
-        else
-          m_dirtyRect.Add(r);
-      }
-    }
-
     void ManagedTexture::lock()
     {
       m_isLocked = true;
-      m_isDirty = false;
+      m_auxData = SharedBufferManager::instance().reserveSharedBuffer(m_imageSize);
     }
 
     void ManagedTexture::unlock()
     {
-      m_isLocked = false;
+      SharedBufferManager::instance().freeSharedBuffer(m_imageSize, m_auxData);
 
-      if (m_isDirty)
-      {
-        updateDirty(m_dirtyRect);
-        m_isDirty = false;
-      }
+      m_auxData.reset();
+
+      m_isLocked = false;
+    }
+
+    void * ManagedTexture::auxData()
+    {
+      ASSERT(m_isLocked, ("texture is unlocked"));
+      return &(*m_auxData)[0];
     }
   }
 }
diff --git a/yg/managed_texture.hpp b/yg/managed_texture.hpp
index ea752c3c3b..9ba6c785bc 100644
--- a/yg/managed_texture.hpp
+++ b/yg/managed_texture.hpp
@@ -3,6 +3,8 @@
 #include "../geometry/rect2d.hpp"
 #include "../geometry/point2d.hpp"
 #include "base_texture.hpp"
+#include "../std/vector.hpp"
+#include "../std/shared_ptr.hpp"
 
 namespace yg
 {
@@ -11,27 +13,31 @@ namespace yg
     class ManagedTexture : public BaseTexture
     {
     private:
-      /// do we have a data to be updated on unlock?
-      bool m_isDirty;
-      /// cumulative dirty rect.
-      m2::RectU m_dirtyRect;
+
+      /// size of the allocated shared buffers
+      size_t m_imageSize;
 
     protected:
 
       /// is the texture locked
       bool m_isLocked;
 
-      virtual void updateDirty(m2::RectU const & r) = 0;
-      virtual void upload() = 0;
+      virtual void upload(void * data) = 0;
+      virtual void upload(void * data, m2::RectU const & r) = 0;
+
+      /// system memory buffer for the purpose of correct working of glTexSubImage2D.
+      /// in OpenGL ES 1.1 there are no way to specify GL_UNPACK_ROW_LENGTH so
+      /// the data supplied to glTexSubImage2D should be continous.
+      shared_ptr<vector<unsigned char> > m_auxData;
 
     public:
 
-      ManagedTexture(m2::PointU const & size);
-      ManagedTexture(unsigned width, unsigned height);
+      ManagedTexture(m2::PointU const & size, size_t pixelSize);
+      ManagedTexture(unsigned width, unsigned height, size_t pixelSize);
 
       void lock();
-      void addDirtyRect(m2::RectU const & r);
       void unlock();
+      void * auxData();
     };
   }
 }
diff --git a/yg/skin_page.cpp b/yg/skin_page.cpp
index a6c462ad0f..78cc80caad 100644
--- a/yg/skin_page.cpp
+++ b/yg/skin_page.cpp
@@ -203,14 +203,9 @@ namespace yg
       yg::PenInfo const & penInfo = m_penUploadCommands[i].m_penInfo;
       m2::RectU const & rect = m_penUploadCommands[i].m_rect;
 
-      TDynamicTexture::view_t v = gil::subimage_view
-      (
-        static_cast<TDynamicTexture*>(m_texture.get())->view(),
-        rect.minX(), rect.minY(),
-        rect.maxX(), rect.maxY()
-      );
+      TDynamicTexture * dynTexture = static_cast<TDynamicTexture*>(m_texture.get());
 
-      static_cast<gl::ManagedTexture*>(m_texture.get())->addDirtyRect(rect);
+      TDynamicTexture::view_t v = dynTexture->view(rect.SizeX(), rect.SizeY());
 
       yg::Color penInfoColor = penInfo.m_color;
 
@@ -272,6 +267,8 @@ namespace yg
           curLen += penInfo.m_pat[i];
         }
       }
+
+      dynTexture->upload(&v(0, 0), rect);
     }
     m_penUploadCommands.clear();
   }
@@ -290,12 +287,15 @@ namespace yg
       c.a /= 16;
 #endif
 
-      for (size_t y = r.minY(); y < r.maxY(); ++y)
-        for (size_t x = r.minX(); x < r.maxX(); ++x)
-          static_cast<TDynamicTexture*>(m_texture.get())->view()(x, y) =
-              TDynamicTexture::pixel_t(gil::rgba8_pixel_t(c.r, c.g, c.b, c.a));
+      TDynamicTexture * dynTexture = static_cast<TDynamicTexture*>(m_texture.get());
 
-      static_cast<gl::ManagedTexture*>(m_texture.get())->addDirtyRect(r);
+      TDynamicTexture::view_t v = dynTexture->view(r.SizeX(), r.SizeY());
+
+      for (size_t y = 0; y < r.SizeY(); ++y)
+        for (size_t x = 0; x < r.SizeX(); ++x)
+          v(x, y) = TDynamicTexture::pixel_t(gil::rgba8_pixel_t(c.r, c.g, c.b, c.a));
+
+      dynTexture->upload(&v(0, 0), r);
     }
     m_colorUploadCommands.clear();
   }
diff --git a/yg/texture.hpp b/yg/texture.hpp
index b6ecc2a464..9e85f42f46 100644
--- a/yg/texture.hpp
+++ b/yg/texture.hpp
@@ -11,11 +11,9 @@
 #include "../platform/platform.hpp"
 #include "../coding/lodepng_io.hpp"
 #include "../std/iostream.hpp"
-
 namespace gil = boost::gil;
 namespace mpl = boost::mpl;
 
-
 namespace yg
 {
   namespace gl
@@ -148,18 +146,13 @@ namespace yg
 
     private:
 
-      /// system memory copy of texture data
-      image_t m_image;
-      /// system memory buffer for the purpose of correct working of glTexSubImage2D.
-      /// in OpenGL ES 1.1 there are no way to specify GL_UNPACK_ROW_LENGTH so
-      /// the data supplied to glTexSubImage2D should be continous.
-      vector<pixel_t> m_auxData;
-
-      void upload();
       void updateDirty(m2::RectU const & r);
 
     public:
 
+      void upload(void * data);
+      void upload(void * data, m2::RectU const & r);
+
       /// Create the texture loading it from file
       Texture(string const & fileName);
       /// Create the texture with the predefined dimensions
@@ -167,10 +160,10 @@ namespace yg
       Texture(m2::RectU const & r);
 
       /// You can call this anytime, regardless the locking status of the texture.
-      const_view_t const_view() const;
+      /// const_view_t const_view() const;
       /// You can call this on locked texture only. All your changess to this view's data will be
       /// uploaded to the video memory on unlock()
-      view_t view();
+      view_t view(size_t width, size_t height);
 
       void fill(yg::Color const & c);
 
@@ -191,45 +184,48 @@ namespace yg
 
     template <typename Traits>
     Texture<Traits, true>::Texture(const m2::RectU &r)
-      : ManagedTexture(r.SizeX(), r.SizeY()), m_image(r.SizeX(), r.SizeY())
+      : ManagedTexture(r.SizeX(), r.SizeY(), sizeof(pixel_t))
     {
-      upload();
-      m_auxData.resize(width * height);
+      upload(0);
     }
 
     template <typename Traits>
     Texture<Traits, true>::Texture(size_t width, size_t height)
-      : ManagedTexture(width, height), m_image(width, height)
+      : ManagedTexture(width, height, sizeof(pixel_t))
     {
-      upload();
-      m_auxData.resize(width * height);
+      upload(0);
     }
 
     template <typename Traits>
-    Texture<Traits, true>::Texture(string const & fileName) : ManagedTexture(GetDimensions(fileName))
+    Texture<Traits, true>::Texture(string const & fileName) : ManagedTexture(GetDimensions(fileName), sizeof(pixel_t))
     {
       lock();
-      gil::lodepng_read_and_convert_image(GetPlatform().ReadPathForFile(fileName).c_str(), m_image, typename Traits::color_converter());
+      view_t v = view(width(), height());
+      gil::lodepng_read_and_convert_view((GetPlatform().ResourcesDir() + fileName).c_str(), v, typename Traits::color_converter());
+      upload(&v(0, 0));
       unlock();
-      upload();
-      m_image.recreate(0, 0);
     }
 
     template <typename Traits>
-    typename Texture<Traits, true>::view_t Texture<Traits, true>::view()
+    typename Texture<Traits, true>::view_t Texture<Traits, true>::view(size_t w, size_t h)
     {
       ASSERT(m_isLocked, ("non const access to unlocked texture!"));
-      return gil::view(m_image);
+      return gil::interleaved_view(
+          w,
+          h,
+          (pixel_t*)auxData(),
+          w * sizeof(pixel_t));
     }
 
-    template <typename Traits>
+/*    template <typename Traits>
     typename Texture<Traits, true>::const_view_t Texture<Traits, true>::const_view() const
     {
       return gil::const_view(m_image);
     }
+ */
 
     template <typename Traits>
-    void Texture<Traits, true>::upload()
+    void Texture<Traits, true>::upload(void * data)
     {
       makeCurrent();
 
@@ -241,40 +237,25 @@ namespace yg
          height(),
          0,
          GL_RGBA,
-         Traits::gl_pixel_data_type,
-         &gil::const_view(m_image)(0, 0)));
+         gl_pixel_data_type,
+         data));
     }
 
-
     template <typename Traits>
-    void Texture<Traits, true>::updateDirty(m2::RectU const & r)
+    void Texture<Traits, true>::upload(void * data, m2::RectU const & r)
     {
       makeCurrent();
-
-//      m_auxData.resize(r.SizeX() * r.SizeY());
-
-      view_t auxView = gil::interleaved_view(
-          r.SizeX(), r.SizeY(),
-          (pixel_t*)&m_auxData[0],
-          r.SizeX() * sizeof(pixel_t));
-
-      gil::copy_pixels(
-          gil::subimage_view(gil::const_view(m_image),
-                             r.minX(), r.minY(),
-                             r.SizeX(), r.SizeY()),
-          auxView);
-
+      /// Uploading texture data
       OGLCHECK(glTexSubImage2D(
-          GL_TEXTURE_2D,
-          0,
-          r.minX(),
-          r.minY(),
-          r.SizeX(),
-          r.SizeY(),
-          GL_RGBA,
-          Traits::gl_pixel_data_type,
-          &m_auxData[0]
-      ));
+         GL_TEXTURE_2D,
+         0,
+         r.minX(),
+         r.minY(),
+         r.SizeX(),
+         r.SizeY(),
+         GL_RGBA,
+         gl_pixel_data_type,
+         data));
     }
 
     template <typename Traits>
@@ -282,21 +263,20 @@ namespace yg
     {
       makeCurrent();
       lock();
-      view_t v = view();
+      view_t v = view(width(), height());
 
       for (size_t y = 0; y < height(); ++y)
         for (size_t x = 0; x < width(); ++x)
           v(x, y) = pixel_t(rand() % maxChannelVal, rand() % maxChannelVal, rand() % maxChannelVal, maxChannelVal);
 
-      addDirtyRect(m2::RectU(0, 0, width(), height()));
-
+      upload(&v(0, 0), m2::RectU(0, 0, width(), height()));
       unlock();
     }
 
     template <typename Traits>
     void Texture<Traits, true>::readback()
     {
-      makeCurrent();
+/*      makeCurrent();
 #ifndef OMIM_GL_ES
       OGLCHECK(glGetTexImage(
           GL_TEXTURE_2D,
@@ -306,7 +286,7 @@ namespace yg
           &gil::view(m_image)(0, 0)));
 #else
           ASSERT(false, ("no glGetTexImage function in OpenGL ES"));
-#endif
+#endif*/
     }
 
     template <typename Traits>
@@ -315,14 +295,14 @@ namespace yg
       readback();
       std::string const fullPath = GetPlatform().WritablePathForFile(fileName);
 #ifndef OMIM_GL_ES
-      boost::gil::lodepng_write_view(fullPath, gil::const_view(m_image));
+      boost::gil::lodepng_write_view(fullPath.c_str(), gil::const_view(m_image));
 #endif
     }
 
     template <typename Traits>
     void Texture<Traits, true>::fill(yg::Color const & c)
     {
-      makeCurrent();
+/*      makeCurrent();
       lock();
       view_t v = view();
 
@@ -337,6 +317,7 @@ namespace yg
 
       addDirtyRect(m2::RectU(0, 0, width(), height()));
       unlock();
+ */
     }
   }
 }
diff --git a/yg/yg_tests/screengl_test.cpp b/yg/yg_tests/screengl_test.cpp
index eb25ddef79..ca7175ad29 100644
--- a/yg/yg_tests/screengl_test.cpp
+++ b/yg/yg_tests/screengl_test.cpp
@@ -113,14 +113,18 @@ namespace
       vector<m2::PointD> points;
       vector<double> pattern;
 
-      int count = 20;
+      int columns = 30;
+      int rows = 6;
 
-      for (size_t i = 0; i < count; ++i)
+      for (size_t j = 0; j < rows; ++j)
       {
-        points.clear();
-        points.push_back(m2::PointD(10, i * 15 + 20));
-        points.push_back(m2::PointD(100, i * 15 + 20));
-        AddTest(points, pattern, yg::Color(0, 0, 128 + 128 / count * i, 255), 10);
+        for (size_t i = 0; i < columns; ++i)
+        {
+          points.clear();
+          points.push_back(m2::PointD(100 * j + 10, i * 15 + 20));
+          points.push_back(m2::PointD(100 * j + 100, i * 15 + 20));
+          AddTest(points, pattern, yg::Color(128 + 128 / columns * i, 128 + 128 / rows * j, 0, 255), rand() % 15);
+        }
       }
     }
   };
diff --git a/yg/yg_tests/texture_test.cpp b/yg/yg_tests/texture_test.cpp
index 8907dd46ef..582003dced 100644
--- a/yg/yg_tests/texture_test.cpp
+++ b/yg/yg_tests/texture_test.cpp
@@ -10,7 +10,7 @@ UNIT_TEST(TextureTest_Main)
   yg::gl::RGBA8Texture texture(256, 256);
   texture.makeCurrent();
   texture.lock();
-  yg::gl::RGBA8Texture::view_t view = texture.view();
+  yg::gl::RGBA8Texture::view_t view = texture.view(256, 256);
   for (size_t i = 0; i < texture.height(); ++i)
     for (size_t j = 0; j < texture.width(); ++j)
     {