diff --git a/base/base.pro b/base/base.pro
index f7e57eb011..bfa2a40e68 100644
--- a/base/base.pro
+++ b/base/base.pro
@@ -25,6 +25,7 @@ SOURCES += \
     internal/message.cpp \
     exception.cpp \
     threaded_container.cpp \
+    resource_pool.cpp \
 
 HEADERS += \
     SRC_FIRST.hpp \
@@ -68,3 +69,4 @@ HEADERS += \
     mru_cache.hpp \
     threaded_container.hpp \
     threaded_list.hpp \
+    resource_pool.hpp \
diff --git a/base/resource_pool.cpp b/base/resource_pool.cpp
new file mode 100644
index 0000000000..95eae9cab5
--- /dev/null
+++ b/base/resource_pool.cpp
@@ -0,0 +1,17 @@
+#include "../base/SRC_FIRST.hpp"
+
+#include "resource_pool.hpp"
+
+BasePoolElemFactory::BasePoolElemFactory(char const * resName, size_t elemSize)
+  : m_resName(resName), m_elemSize(elemSize)
+{}
+
+char const * BasePoolElemFactory::ResName() const
+{
+  return m_resName.c_str();
+}
+
+size_t BasePoolElemFactory::ElemSize() const
+{
+  return m_elemSize;
+}
diff --git a/base/resource_pool.hpp b/base/resource_pool.hpp
new file mode 100644
index 0000000000..89e4e172f0
--- /dev/null
+++ b/base/resource_pool.hpp
@@ -0,0 +1,134 @@
+#pragma once
+
+#include "threaded_list.hpp"
+#include "logging.hpp"
+#include "../std/bind.hpp"
+
+struct BasePoolElemFactory
+{
+  string m_resName;
+  size_t m_elemSize;
+  BasePoolElemFactory(char const * resName, size_t elemSize);
+
+  char const * ResName() const;
+  size_t ElemSize() const;
+};
+
+template <typename TElem, typename TElemFactory>
+struct BasePoolTraits
+{
+  TElemFactory m_factory;
+
+  BasePoolTraits(TElemFactory const & factory) : m_factory(factory)
+  {}
+
+  void Free(ThreadedList<TElem> & elems, TElem const & elem)
+  {
+    elems.PushBack(elem);
+  }
+};
+
+template <typename TElem, typename TElemFactory>
+struct FixedSizePoolTraits : BasePoolTraits<TElem, TElemFactory>
+{
+  typedef BasePoolTraits<TElem, TElemFactory> base_t;
+  size_t m_count;
+  bool m_isAllocated;
+
+  FixedSizePoolTraits(TElemFactory const & factory, size_t count)
+    : base_t(factory),
+      m_count(count),
+      m_isAllocated(false)
+  {}
+
+  TElem const Reserve(ThreadedList<TElem> & elems)
+  {
+    if (!m_isAllocated)
+    {
+      m_isAllocated = true;
+
+      LOG(LINFO, ("allocating ", base_t::m_factory.ElemSize() * m_count, "bytes for ", base_t::m_factory.ResName()));
+
+      for (size_t i = 0; i < m_count; ++i)
+        elems.PushBack(base_t::m_factory.Create());
+    }
+
+    return elems.Front(true);
+  }
+};
+
+template <typename TElem, typename TElemFactory>
+struct AllocateOnDemandPoolTraits : BasePoolTraits<TElem, TElemFactory>
+{
+  typedef BasePoolTraits<TElem, TElemFactory> base_t;
+
+  size_t m_poolSize;
+  AllocateOnDemandPoolTraits(TElemFactory const & factory, size_t )
+    : base_t(factory),
+      m_poolSize(0)
+  {}
+
+  void ReserveImpl(list<TElem> & l, TElem & elem)
+  {
+    if (l.empty())
+    {
+      m_poolSize += base_t::m_factory.ElemSize();
+      LOG(LINFO, ("allocating ", base_t::m_factory.ElemSize(), "bytes for ", base_t::m_factory.ResName(), " on-demand, poolSize=", m_poolSize));
+      l.push_back(base_t::m_factory.Create());
+    }
+
+    elem = l.back();
+
+    l.pop_back();
+  }
+
+  TElem const Reserve(ThreadedList<TElem> & elems)
+  {
+    TElem elem;
+    elems.ProcessList(bind(&AllocateOnDemandPoolTraits<TElem, TElemFactory>::ReserveImpl, this, _1, ref(elem)));
+    return elem;
+  }
+};
+
+// This class tracks OpenGL resources allocation in
+// a multithreaded environment.
+template <typename TElem, typename TPoolTraits>
+class ResourcePool
+{
+private:
+
+  TPoolTraits m_traits;
+  ThreadedList<TElem> m_pool;
+
+public:
+
+  ResourcePool(TPoolTraits const & traits)
+    : m_traits(traits)
+  {}
+
+  TElem const Reserve()
+  {
+    return m_traits.Reserve(m_pool);
+  }
+
+  void Free(TElem const & elem)
+  {
+    m_traits.Free(m_pool, elem);
+  }
+
+  void EnterForeground()
+  {}
+
+  void EnterBackground()
+  {}
+
+  void Cancel()
+  {
+    m_pool.Cancel();
+  }
+
+  bool IsCancelled() const
+  {
+    return m_pool.IsCancelled();
+  }
+};
diff --git a/map/tile_cache.hpp b/map/tile_cache.hpp
index 69592bd940..6a7f41e483 100644
--- a/map/tile_cache.hpp
+++ b/map/tile_cache.hpp
@@ -26,16 +26,10 @@ public:
 
   struct EntryValueTraits
   {
-    static void PushBackAndLog(list<shared_ptr<yg::gl::BaseTexture> > & l, shared_ptr<yg::gl::BaseTexture> const & t)
-    {
-      l.push_back(t);
-//      LOG(LINFO, ("eviction, list size : ", l.size()));
-    }
-
     static void Evict(Entry & val)
     {
       if (val.m_rm)
-        val.m_rm->renderTargets().ProcessList(bind(&PushBackAndLog, _1, val.m_tile.m_renderTarget));
+        val.m_rm->renderTargets()->Free(val.m_tile.m_renderTarget);
     }
   };
 
diff --git a/map/tile_renderer.cpp b/map/tile_renderer.cpp
index f5d3287dfe..d184f15a2c 100644
--- a/map/tile_renderer.cpp
+++ b/map/tile_renderer.cpp
@@ -77,7 +77,7 @@ TileRenderer::~TileRenderer()
 
 void TileRenderer::CancelThread(core::CommandsQueue::Environment const & /*env*/)
 {
-  m_resourceManager->renderTargets().Cancel();
+  m_resourceManager->renderTargets()->Cancel();
 }
 
 void TileRenderer::InitializeThreadGL(core::CommandsQueue::Environment const & env)
@@ -120,9 +120,9 @@ void TileRenderer::DrawTile(core::CommandsQueue::Environment const & env,
 
   my::Timer timer;
 
-  shared_ptr<yg::gl::BaseTexture> tileTarget = m_resourceManager->renderTargets().Front(true);
+  shared_ptr<yg::gl::BaseTexture> tileTarget = m_resourceManager->renderTargets()->Reserve();
 
-  if (m_resourceManager->renderTargets().IsCancelled())
+  if (m_resourceManager->renderTargets()->IsCancelled())
     return;
 
   drawer->screen()->setRenderTarget(tileTarget);
@@ -165,7 +165,7 @@ void TileRenderer::DrawTile(core::CommandsQueue::Environment const & env,
   double duration = timer.ElapsedSeconds();
 
   if (env.IsCancelled())
-    m_resourceManager->renderTargets().PushBack(tileTarget);
+    m_resourceManager->renderTargets()->Free(tileTarget);
   else
     AddTile(rectInfo, Tile(tileTarget, tileInfoLayer, frameScreen, rectInfo, duration));
 }
@@ -199,18 +199,12 @@ bool TileRenderer::HasTile(Tiler::RectInfo const & rectInfo)
   return res;
 }
 
-void PushBackAndLog(list<shared_ptr<yg::gl::BaseTexture> > & l, shared_ptr<yg::gl::BaseTexture> const & t)
-{
-  l.push_back(t);
-//  LOG(LINFO, ("double tile, list size : ", l.size()));
-}
-
 void TileRenderer::AddTile(Tiler::RectInfo const & rectInfo, Tile const & tile)
 {
   m_tileCache.writeLock();
   if (m_tileCache.hasTile(rectInfo))
   {
-    m_resourceManager->renderTargets().ProcessList(bind(&PushBackAndLog, _1, tile.m_renderTarget));
+    m_resourceManager->renderTargets()->Free(tile.m_renderTarget);
     m_tileCache.touchTile(rectInfo);
   }
   else
diff --git a/map/tiling_render_policy_st.cpp b/map/tiling_render_policy_st.cpp
index b929cab8c3..7118a12a9c 100644
--- a/map/tiling_render_policy_st.cpp
+++ b/map/tiling_render_policy_st.cpp
@@ -94,7 +94,7 @@ void TilingRenderPolicyST::DrawFrame(shared_ptr<PaintEvent> const & e, ScreenBas
     {
       m_tileCache.readUnlock();
       shared_ptr<PaintEvent> paintEvent(new PaintEvent(m_tileDrawer.get()));
-      shared_ptr<yg::gl::BaseTexture> tileTarget = resourceManager()->renderTargets().Front(true);
+      shared_ptr<yg::gl::BaseTexture> tileTarget = resourceManager()->renderTargets()->Reserve();
 
       shared_ptr<yg::InfoLayer> tileInfoLayer(new yg::InfoLayer());
 
diff --git a/yg/blitter.cpp b/yg/blitter.cpp
index cbee595d77..a50a0284e0 100644
--- a/yg/blitter.cpp
+++ b/yg/blitter.cpp
@@ -76,7 +76,7 @@ namespace yg
         idxData[i * 4 + 3] = i * 4 + 3;
       }
 
-      yg::gl::Storage storage = resourceManager()->multiBlitStorages().Front(true);
+      yg::gl::Storage storage = resourceManager()->multiBlitStorages()->Reserve();
 
       AuxVertex * pointsData = (AuxVertex*)storage.m_vertices->lock();
 
@@ -116,7 +116,7 @@ namespace yg
 //      /// This call is necessary to avoid parasite blitting in updateActualTarget() on IPhone.
 //      OGLCHECK(glFinish());
 
-      resourceManager()->multiBlitStorages().PushBack(storage);
+      resourceManager()->multiBlitStorages()->Free(storage);
     }
 
     void Blitter::blit(shared_ptr<yg::gl::BaseTexture> const & srcSurface,
@@ -277,7 +277,7 @@ namespace yg
                                            yg::Color const & color,
                                            bool hasColor)
     {
-      m_blitStorage = resourceManager()->blitStorages().Front(true);
+      m_blitStorage = resourceManager()->blitStorages()->Reserve();
 
       AuxVertex * pointsData = (AuxVertex*)m_blitStorage.m_vertices->lock();
 
@@ -312,7 +312,7 @@ namespace yg
 //      /// This call is necessary to avoid parasite blitting in updateActualTarget() on IPhone.
 //      OGLCHECK(glFinish());
 
-      resourceManager()->blitStorages().PushBack(m_blitStorage);
+      resourceManager()->blitStorages()->Free(m_blitStorage);
       m_blitStorage = yg::gl::Storage();
     }
   }
diff --git a/yg/geometry_batcher.cpp b/yg/geometry_batcher.cpp
index 1539a42044..5fad904a9f 100644
--- a/yg/geometry_batcher.cpp
+++ b/yg/geometry_batcher.cpp
@@ -77,7 +77,8 @@ namespace yg
    {
      if (!m_hasStorage)
      {
-       m_storage = usage != SkinPage::EStaticUsage ? resourceManager->storages().Front(true) : resourceManager->smallStorages().Front(true);
+       m_storage = usage != SkinPage::EStaticUsage ? resourceManager->storages()->Reserve()
+                                                   : resourceManager->smallStorages()->Reserve();
 
        m_maxVertices = m_storage.m_vertices->size() / sizeof(Vertex);
        m_maxIndices = m_storage.m_indices->size() / sizeof(unsigned short);
@@ -223,9 +224,9 @@ namespace yg
              renderedData = true;
 
              if (skinPage->usage() != SkinPage::EStaticUsage)
-               resourceManager()->storages().PushBack(pipeline.m_storage);
+               resourceManager()->storages()->Free(pipeline.m_storage);
              else
-               resourceManager()->smallStorages().PushBack(pipeline.m_storage);
+               resourceManager()->smallStorages()->Free(pipeline.m_storage);
 
              pipeline.m_hasStorage = false;
              pipeline.m_storage = Storage();
diff --git a/yg/resource_manager.cpp b/yg/resource_manager.cpp
index 509d4784e4..869aa5a441 100644
--- a/yg/resource_manager.cpp
+++ b/yg/resource_manager.cpp
@@ -19,6 +19,26 @@ namespace yg
 
   DECLARE_EXCEPTION(ResourceManagerException, RootException);
 
+  TTextureFactory::TTextureFactory(size_t w, size_t h, char const * resName)
+    : BasePoolElemFactory(resName, w * h * sizeof(TDynamicTexture::pixel_t)),
+      m_w(w), m_h(h)
+  {}
+
+  shared_ptr<gl::BaseTexture> const TTextureFactory::Create()
+  {
+    return shared_ptr<gl::BaseTexture>(new TDynamicTexture(m_w, m_h));
+  }
+
+  TStorageFactory::TStorageFactory(size_t vbSize, size_t ibSize, bool useVA, char const * resName)
+    : BasePoolElemFactory(resName, vbSize + ibSize),
+      m_vbSize(vbSize), m_ibSize(ibSize), m_useVA(useVA)
+  {}
+
+  gl::Storage const TStorageFactory::Create()
+  {
+    return gl::Storage(m_vbSize, m_ibSize, m_useVA);
+  }
+
   ResourceManager::ResourceManager(size_t vbSize, size_t ibSize, size_t storagesCount,
                                    size_t smallVBSize, size_t smallIBSize, size_t smallStoragesCount,
                                    size_t blitVBSize, size_t blitIBSize, size_t blitStoragesCount,
@@ -43,36 +63,12 @@ namespace yg
     if (useVA)
       LOG(LINFO, ("buffer objects are unsupported. using client vertex array instead."));
 
-    for (size_t i = 0; i < storagesCount; ++i)
-      m_storages.PushBack(gl::Storage(vbSize, ibSize, m_useVA));
+    m_storages.reset(new TStoragePool(TStoragePoolTraits(TStorageFactory(vbSize, ibSize, useVA, "primaryStorage"), storagesCount)));
+    m_smallStorages.reset(new TStoragePool(TStoragePoolTraits(TStorageFactory(smallVBSize, smallIBSize, useVA, "smallStorage"), smallStoragesCount)));
+    m_blitStorages.reset(new TStoragePool(TStoragePoolTraits(TStorageFactory(blitVBSize, blitIBSize, useVA, "blitStorage"), blitStoragesCount)));
 
-    LOG(LINFO, ("allocating ", (vbSize + ibSize) * storagesCount, " bytes for main storage"));
-
-    for (size_t i = 0; i < smallStoragesCount; ++i)
-      m_smallStorages.PushBack(gl::Storage(smallVBSize, smallIBSize, m_useVA));
-
-    LOG(LINFO, ("allocating ", (smallVBSize + smallIBSize) * smallStoragesCount, " bytes for small storage"));
-
-    for (size_t i = 0; i < blitStoragesCount; ++i)
-      m_blitStorages.PushBack(gl::Storage(blitVBSize, blitIBSize, m_useVA));
-
-    LOG(LINFO, ("allocating ", (blitVBSize + blitIBSize) * blitStoragesCount, " bytes for blit storage"));
-
-    for (size_t i = 0; i < dynamicTexCount; ++i)
-    {
-      shared_ptr<gl::BaseTexture> t(new TDynamicTexture(dynamicTexWidth, dynamicTexHeight));
-      m_dynamicTextures.PushBack(t);
-    }
-
-    LOG(LINFO, ("allocating ", dynamicTexCount * dynamicTexWidth * dynamicTexHeight * sizeof(TDynamicTexture::pixel_t), " bytes for textures"));
-
-    for (size_t i = 0; i < fontTexCount; ++i)
-    {
-      shared_ptr<gl::BaseTexture> t(new TDynamicTexture(fontTexWidth, fontTexHeight));
-      m_fontTextures.PushBack(t);
-    }
-
-    LOG(LINFO, ("allocating ", fontTexCount * fontTexWidth * fontTexHeight * sizeof(TDynamicTexture::pixel_t), " bytes for font textures"));
+    m_dynamicTextures.reset(new TTexturePool(TTexturePoolTraits(TTextureFactory(dynamicTexWidth, dynamicTexHeight, "dynamicTexture"), dynamicTexCount)));
+    m_fontTextures.reset(new TTexturePool(TTexturePoolTraits(TTextureFactory(fontTexWidth, fontTexHeight, "fontTexture"), fontTexCount)));
   }
 
   void ResourceManager::initMultiBlitStorage(size_t multiBlitVBSize, size_t multiBlitIBSize, size_t multiBlitStoragesCount)
@@ -80,10 +76,7 @@ namespace yg
     m_multiBlitVBSize = multiBlitVBSize;
     m_multiBlitIBSize = multiBlitIBSize;
 
-    for (size_t i = 0; i < multiBlitStoragesCount; ++i)
-      m_multiBlitStorages.PushBack(gl::Storage(multiBlitVBSize, multiBlitIBSize, m_useVA));
-
-    LOG(LINFO, ("allocating ", (multiBlitVBSize + multiBlitIBSize) * multiBlitStoragesCount, " bytes for multi-blit storages"));
+    m_multiBlitStorages.reset(new TStoragePool(TStoragePoolTraits(TStorageFactory(multiBlitVBSize, multiBlitIBSize, m_useVA, "multiBlitStorage"), multiBlitStoragesCount)));
   }
 
   void ResourceManager::initRenderTargets(size_t renderTargetWidth, size_t renderTargetHeight, size_t renderTargetsCount)
@@ -91,13 +84,7 @@ namespace yg
     m_renderTargetWidth = renderTargetWidth;
     m_renderTargetHeight = renderTargetHeight;
 
-    for (size_t i = 0; i < renderTargetsCount; ++i)
-    {
-      shared_ptr<gl::BaseTexture> t(new TStaticTexture(renderTargetWidth, renderTargetHeight));
-      m_renderTargets.PushBack(t);
-    }
-
-    LOG(LINFO, ("allocating ", renderTargetsCount * renderTargetWidth * renderTargetHeight * sizeof(TStaticTexture::pixel_t), " bytes for render targets"));
+    m_renderTargets.reset(new TTexturePool(TTexturePoolTraits(TTextureFactory(renderTargetWidth, renderTargetHeight, "renderTargets"), renderTargetsCount)));
   }
 
   shared_ptr<gl::BaseTexture> const & ResourceManager::getTexture(string const & fileName)
@@ -186,53 +173,52 @@ namespace yg
   {
     threads::MutexGuard guard(m_mutex);
 
-    m_storagesCount = m_storages.Size();
-    m_smallStoragesCount = m_smallStorages.Size();
-    m_blitStoragesCount = m_blitStorages.Size();
-    m_dynamicTexturesCount = m_dynamicTextures.Size();
-    m_fontTexturesCount = m_fontTextures.Size();
-    m_multiBlitStoragesCount = m_multiBlitStorages.Size();
-    m_renderTargetsCount = m_renderTargets.Size();
+    if (m_storages.get())
+    m_storages->EnterBackground();
 
-    m_storages.Clear();
-    m_smallStorages.Clear();
-    m_blitStorages.Clear();
-    m_multiBlitStorages.Clear();
+    if (m_smallStorages.get())
+      m_smallStorages->EnterBackground();
 
-    m_dynamicTextures.Clear();
-    m_fontTextures.Clear();
-    m_renderTargets.Clear();
+    if (m_blitStorages.get())
+      m_blitStorages->EnterBackground();
 
+    if (m_multiBlitStorages.get())
+      m_multiBlitStorages->EnterBackground();
 
-/*    LOG(LINFO, ("freed ", m_storagesCount, " storages, ",
-                          m_smallStoragesCount, " small storages, ",
-                          m_blitStoragesCount, " blit storages, ",
-                          m_dynamicTexturesCount, " dynamic textures, ",
-                          m_fontTexturesCount, " font textures, ",
-                          m_renderTargetsCount, " render targets and ",
-                          m_multiBlitStoragesCount, " multi-blit storages"));*/
+    if (m_dynamicTextures.get())
+      m_dynamicTextures->EnterBackground();
+
+    if (m_fontTextures.get())
+      m_fontTextures->EnterBackground();
+
+    if (m_renderTargets.get())
+      m_renderTargets->EnterBackground();
   }
 
   void ResourceManager::enterForeground()
   {
     threads::MutexGuard guard(m_mutex);
 
-    for (size_t i = 0; i < m_storagesCount; ++i)
-      m_storages.PushBack(gl::Storage(m_vbSize, m_ibSize, m_useVA));
-    for (size_t i = 0; i < m_smallStoragesCount; ++i)
-      m_smallStorages.PushBack(gl::Storage(m_smallVBSize, m_smallIBSize, m_useVA));
-    for (size_t i = 0; i < m_blitStoragesCount; ++i)
-      m_blitStorages.PushBack(gl::Storage(m_blitVBSize, m_blitIBSize, m_useVA));
-    for (size_t i = 0; i < m_multiBlitStoragesCount; ++i)
-      m_multiBlitStorages.PushBack(gl::Storage(m_multiBlitVBSize, m_multiBlitIBSize, m_useVA));
+    if (m_storages.get())
+      m_storages->EnterForeground();
 
-    for (size_t i = 0; i < m_dynamicTexturesCount; ++i)
-      m_dynamicTextures.PushBack(shared_ptr<gl::BaseTexture>(new TDynamicTexture(m_dynamicTextureWidth, m_dynamicTextureHeight)));
-    for (size_t i = 0; i < m_fontTexturesCount; ++i)
-      m_fontTextures.PushBack(shared_ptr<gl::BaseTexture>(new TDynamicTexture(m_fontTextureWidth, m_fontTextureHeight)));
-    for (size_t i = 0; i < m_renderTargetsCount; ++i)
-      m_renderTargets.PushBack(shared_ptr<gl::BaseTexture>(new TDynamicTexture(m_renderTargetWidth, m_renderTargetHeight)));
+    if (m_smallStorages.get())
+      m_smallStorages->EnterForeground();
 
+    if (m_blitStorages.get())
+      m_blitStorages->EnterForeground();
+
+    if (m_multiBlitStorages.get())
+      m_multiBlitStorages->EnterForeground();
+
+    if (m_dynamicTextures.get())
+      m_dynamicTextures->EnterForeground();
+
+    if (m_fontTextures.get())
+      m_fontTextures->EnterForeground();
+
+    if (m_renderTargets.get())
+      m_renderTargets->EnterForeground();
   }
 
   shared_ptr<yg::gl::BaseTexture> ResourceManager::createRenderTarget(unsigned w, unsigned h)
@@ -258,38 +244,38 @@ namespace yg
     return 0;
   }
 
-  ThreadedList<gl::Storage> & ResourceManager::storages()
+  ResourceManager::TStoragePool * ResourceManager::storages()
   {
-    return m_storages;
+    return m_storages.get();
   }
 
-  ThreadedList<gl::Storage> & ResourceManager::smallStorages()
+  ResourceManager::TStoragePool * ResourceManager::smallStorages()
   {
-    return m_smallStorages;
+    return m_smallStorages.get();
   }
 
-  ThreadedList<gl::Storage> & ResourceManager::blitStorages()
+  ResourceManager::TStoragePool * ResourceManager::blitStorages()
   {
-    return m_blitStorages;
+    return m_blitStorages.get();
   }
 
-  ThreadedList<gl::Storage> & ResourceManager::multiBlitStorages()
+  ResourceManager::TStoragePool * ResourceManager::multiBlitStorages()
   {
-    return m_multiBlitStorages;
+    return m_multiBlitStorages.get();
   }
 
-  ThreadedList<shared_ptr<gl::BaseTexture> > & ResourceManager::dynamicTextures()
+  ResourceManager::TTexturePool * ResourceManager::dynamicTextures()
   {
-    return m_dynamicTextures;
+    return m_dynamicTextures.get();
   }
 
-  ThreadedList<shared_ptr<gl::BaseTexture> > & ResourceManager::fontTextures()
+  ResourceManager::TTexturePool * ResourceManager::fontTextures()
   {
-    return m_fontTextures;
+    return m_fontTextures.get();
   }
 
-  ThreadedList<shared_ptr<gl::BaseTexture> > & ResourceManager::renderTargets()
+  ResourceManager::TTexturePool * ResourceManager::renderTargets()
   {
-    return m_renderTargets;
+    return m_renderTargets.get();
   }
 }
diff --git a/yg/resource_manager.hpp b/yg/resource_manager.hpp
index ad320f4c49..05e720ce48 100644
--- a/yg/resource_manager.hpp
+++ b/yg/resource_manager.hpp
@@ -4,9 +4,10 @@
 #include "../std/map.hpp"
 #include "../std/string.hpp"
 #include "../std/list.hpp"
+#include "../std/auto_ptr.hpp"
 
 #include "../base/mutex.hpp"
-#include "../base/threaded_list.hpp"
+#include "../base/resource_pool.hpp"
 
 #include "storage.hpp"
 #include "glyph_cache.hpp"
@@ -29,8 +30,33 @@ namespace yg
     Rt4Bpp
   };
 
+  struct TTextureFactory : BasePoolElemFactory
+  {
+    size_t m_w;
+    size_t m_h;
+    TTextureFactory(size_t w, size_t h, char const * resName);
+    shared_ptr<gl::BaseTexture> const Create();
+  };
+
+  struct TStorageFactory : BasePoolElemFactory
+  {
+    size_t m_vbSize;
+    size_t m_ibSize;
+    bool m_useVA;
+    TStorageFactory(size_t vbSize, size_t ibSize, bool useVA, char const * resName);
+    gl::Storage const Create();
+  };
+
   class ResourceManager
   {
+  public:
+
+    typedef FixedSizePoolTraits<shared_ptr<gl::BaseTexture>, TTextureFactory> TTexturePoolTraits;
+    typedef ResourcePool<shared_ptr<gl::BaseTexture>, TTexturePoolTraits> TTexturePool;
+
+    typedef FixedSizePoolTraits<gl::Storage, TStorageFactory> TStoragePoolTraits;
+    typedef ResourcePool<gl::Storage, TStoragePoolTraits> TStoragePool;
+
   private:
 
     typedef map<string, shared_ptr<gl::BaseTexture> > TStaticTextures;
@@ -42,17 +68,17 @@ namespace yg
     size_t m_dynamicTextureWidth;
     size_t m_dynamicTextureHeight;
 
-    ThreadedList<shared_ptr<gl::BaseTexture> > m_dynamicTextures;
+    auto_ptr<TTexturePool> m_dynamicTextures;
 
     size_t m_fontTextureWidth;
     size_t m_fontTextureHeight;
 
-    ThreadedList<shared_ptr<gl::BaseTexture> > m_fontTextures;
+    auto_ptr<TTexturePool> m_fontTextures;
 
     size_t m_renderTargetWidth;
     size_t m_renderTargetHeight;
 
-    ThreadedList<shared_ptr<gl::BaseTexture> > m_renderTargets;
+    auto_ptr<TTexturePool> m_renderTargets;
 
     size_t m_vbSize;
     size_t m_ibSize;
@@ -66,10 +92,10 @@ namespace yg
     size_t m_multiBlitVBSize;
     size_t m_multiBlitIBSize;
 
-    ThreadedList<gl::Storage> m_storages;
-    ThreadedList<gl::Storage> m_smallStorages;
-    ThreadedList<gl::Storage> m_blitStorages;
-    ThreadedList<gl::Storage> m_multiBlitStorages;
+    auto_ptr<TStoragePool> m_storages;
+    auto_ptr<TStoragePool> m_smallStorages;
+    auto_ptr<TStoragePool> m_blitStorages;
+    auto_ptr<TStoragePool> m_multiBlitStorages;
 
     vector<GlyphCache> m_glyphCaches;
 
@@ -77,14 +103,6 @@ namespace yg
 
     bool m_useVA;
 
-    size_t m_storagesCount;
-    size_t m_smallStoragesCount;
-    size_t m_multiBlitStoragesCount;
-    size_t m_renderTargetsCount;
-    size_t m_blitStoragesCount;
-    size_t m_dynamicTexturesCount;
-    size_t m_fontTexturesCount;
-
   public:
 
     ResourceManager(size_t vbSize, size_t ibSize, size_t storagesCount,
@@ -103,14 +121,14 @@ namespace yg
 
     shared_ptr<gl::BaseTexture> const & getTexture(string const & fileName);
 
-    ThreadedList<gl::Storage> & storages();
-    ThreadedList<gl::Storage> & smallStorages();
-    ThreadedList<gl::Storage> & blitStorages();
-    ThreadedList<gl::Storage> & multiBlitStorages();
+    TStoragePool * storages();
+    TStoragePool * smallStorages();
+    TStoragePool * blitStorages();
+    TStoragePool * multiBlitStorages();
 
-    ThreadedList<shared_ptr<gl::BaseTexture> > & dynamicTextures();
-    ThreadedList<shared_ptr<gl::BaseTexture> > & fontTextures();
-    ThreadedList<shared_ptr<gl::BaseTexture> > & renderTargets();
+    TTexturePool * dynamicTextures();
+    TTexturePool * fontTextures();
+    TTexturePool * renderTargets();
 
     size_t dynamicTextureWidth() const;
     size_t dynamicTextureHeight() const;
@@ -135,7 +153,6 @@ namespace yg
     void enterForeground();
 
     shared_ptr<yg::gl::BaseTexture> createRenderTarget(unsigned w, unsigned h);
-
   };
 
   Skin * loadSkin(shared_ptr<ResourceManager> const & resourceManager,
diff --git a/yg/skin_page.cpp b/yg/skin_page.cpp
index 8dbc666f77..539a5df013 100644
--- a/yg/skin_page.cpp
+++ b/yg/skin_page.cpp
@@ -769,10 +769,10 @@ namespace yg
       switch (m_usage)
       {
       case EDynamicUsage:
-        m_resourceManager->dynamicTextures().PushBack(m_texture);
+        m_resourceManager->dynamicTextures()->Free(m_texture);
         break;
       case EFontsUsage:
-        m_resourceManager->fontTextures().PushBack(m_texture);
+        m_resourceManager->fontTextures()->Free(m_texture);
         break;
       default:
         LOG(LINFO, ("freeTexture call for with invalid usage param"));
@@ -787,10 +787,10 @@ namespace yg
     switch (m_usage)
     {
     case EDynamicUsage:
-      m_texture = m_resourceManager->dynamicTextures().Front(true);
+      m_texture = m_resourceManager->dynamicTextures()->Reserve();
       break;
     case EFontsUsage:
-      m_texture = m_resourceManager->fontTextures().Front(true);
+      m_texture = m_resourceManager->fontTextures()->Reserve();
       break;
     default:
       LOG(LINFO, ("freeTexture call for with invalid usage param"));
diff --git a/yg/yg.pro b/yg/yg.pro
index 0501e8a932..82356eb626 100644
--- a/yg/yg.pro
+++ b/yg/yg.pro
@@ -56,7 +56,7 @@ SOURCES += \
     overlay_element.cpp \
     symbol_element.cpp \
     overlay_renderer.cpp \
-    render_state_updater.cpp
+    render_state_updater.cpp \
 
 HEADERS += \
     internal/opengl.hpp \
@@ -105,7 +105,7 @@ HEADERS += \
     overlay_element.hpp \
     symbol_element.hpp \
     overlay_renderer.hpp \
-    render_state_updater.hpp
+    render_state_updater.hpp \
 
 win32 {
   HEADERS += internal/opengl_win32.hpp