diff --git a/drape/batcher.cpp b/drape/batcher.cpp
index d27232dbc3..ab333bfd54 100644
--- a/drape/batcher.cpp
+++ b/drape/batcher.cpp
@@ -4,6 +4,7 @@
 #include "drape/glextensions_list.hpp"
 #include "drape/index_storage.hpp"
 #include "drape/vertex_array_buffer.hpp"
+#include "drape/shader_def.hpp"
 
 #include "base/assert.hpp"
 #include "base/stl_add.hpp"
@@ -242,22 +243,16 @@ IndicesRange Batcher::InsertTriangles(GLState const & state, ref_ptr<AttributePr
   }
 
   if (handle != nullptr)
-    bucket->AddOverlayHandle(move(handle));
+    GetBucket(state)->AddOverlayHandle(move(handle));
 
   return range;
 }
 
 Batcher * BatcherFactory::GetNew() const
 {
-  uint32_t indexBufferSize = 65000;
-  uint32_t vertexBufferSize = 65000;
-  if (dp::IndexStorage::IsSupported32bit())
-  {
-    indexBufferSize = 65000 * 2;
-    vertexBufferSize = 65000 * 2;
-  }
-
-  return new Batcher(indexBufferSize, vertexBufferSize);
+  uint32_t const kIndexBufferSize = 5000;
+  uint32_t const kVertexBufferSize = 5000;
+  return new Batcher(kIndexBufferSize, kVertexBufferSize);
 }
 
 SessionGuard::SessionGuard(Batcher & batcher, const Batcher::TFlushFn & flusher)
diff --git a/drape/batcher.hpp b/drape/batcher.hpp
index 91e16fb541..edb224fa0a 100644
--- a/drape/batcher.hpp
+++ b/drape/batcher.hpp
@@ -29,11 +29,6 @@ public:
   Batcher(uint32_t indexBufferSize, uint32_t vertexBufferSize);
   ~Batcher();
 
-  uint32_t GetIndexBufferSize() const { return m_indexBufferSize; }
-  uint32_t GetVertexBufferSize() const { return m_vertexBufferSize; }
-  void SetIndexBufferSize(uint32_t indexBufferSize) { m_indexBufferSize = indexBufferSize; }
-  void SetVertexBufferSize(uint32_t vertexBufferSize) { m_vertexBufferSize = vertexBufferSize; }
-
   void InsertTriangleList(GLState const & state, ref_ptr<AttributeProvider> params);
   IndicesRange InsertTriangleList(GLState const & state, ref_ptr<AttributeProvider> params,
                                   drape_ptr<OverlayHandle> && handle);
diff --git a/drape/index_storage.cpp b/drape/index_storage.cpp
index 2cd090f09f..ed4a789f73 100644
--- a/drape/index_storage.cpp
+++ b/drape/index_storage.cpp
@@ -56,7 +56,7 @@ void const * IndexStorage::GetRawConst() const
 
 bool IndexStorage::IsSupported32bit()
 {
-  static bool const supports32bit = GLExtensionsList::Instance().IsSupported(GLExtensionsList::UintIndices);
+  static bool const supports32bit = false;//GLExtensionsList::Instance().IsSupported(GLExtensionsList::UintIndices);
   return supports32bit;
 }
 
diff --git a/drape_frontend/area_shape.hpp b/drape_frontend/area_shape.hpp
index 977282bca5..fc497a7414 100644
--- a/drape_frontend/area_shape.hpp
+++ b/drape_frontend/area_shape.hpp
@@ -16,7 +16,9 @@ class AreaShape : public MapShape
 public:
   AreaShape(vector<m2::PointF> && triangleList, AreaViewParams const & params);
 
-  virtual void Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const;
+  void Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const override;
+
+  MapShapePriority GetPriority() const override { return MapShapePriority::AreaPriority; }
 
 private:
   vector<m2::PointF> m_vertexes;
diff --git a/drape_frontend/backend_renderer.hpp b/drape_frontend/backend_renderer.hpp
index cc8a384287..96964c69dc 100644
--- a/drape_frontend/backend_renderer.hpp
+++ b/drape_frontend/backend_renderer.hpp
@@ -39,7 +39,6 @@ public:
   };
 
   BackendRenderer(Params const & params);
-
   ~BackendRenderer() override;
 
 protected:
@@ -49,32 +48,17 @@ private:
   void RecacheGui(gui::TWidgetsInitInfo const  & initInfo, gui::TWidgetsSizeInfo & sizeInfo);
   void RecacheCountryStatus();
 
-private:
-  MapDataProvider m_model;
-  drape_ptr<BatchersPool> m_batchersPool;
-  drape_ptr<ReadManager> m_readManager;
-  drape_ptr<RouteBuilder> m_routeBuilder;
-  gui::LayerCacher m_guiCacher;
-
-  /////////////////////////////////////////
-  //           MessageAcceptor           //
-  /////////////////////////////////////////
-private:
   void AcceptMessage(ref_ptr<Message> message) override;
 
-  /////////////////////////////////////////
-  //             ThreadPart              //
-  /////////////////////////////////////////
-private:
   class Routine : public threads::IRoutine
   {
-   public:
+  public:
     Routine(BackendRenderer & renderer);
 
     // threads::IRoutine overrides:
     void Do() override;
 
-   private:
+  private:
     BackendRenderer & m_renderer;
   };
 
@@ -82,6 +66,12 @@ private:
 
   void InitGLDependentResource();
   void FlushGeometry(drape_ptr<Message> && message);
+
+  MapDataProvider m_model;
+  drape_ptr<BatchersPool> m_batchersPool;
+  drape_ptr<ReadManager> m_readManager;
+  drape_ptr<RouteBuilder> m_routeBuilder;
+  gui::LayerCacher m_guiCacher;
 };
 
 } // namespace df
diff --git a/drape_frontend/engine_context.cpp b/drape_frontend/engine_context.cpp
index ec70bab7cd..d7ac6a83d6 100644
--- a/drape_frontend/engine_context.cpp
+++ b/drape_frontend/engine_context.cpp
@@ -24,7 +24,7 @@ void EngineContext::BeginReadTile()
   PostMessage(make_unique_dp<TileReadStartMessage>(m_tileKey));
 }
 
-void EngineContext::Flush(list<drape_ptr<MapShape>> && shapes)
+void EngineContext::Flush(vector<drape_ptr<MapShape>> && shapes)
 {
   PostMessage(make_unique_dp<MapShapeReadedMessage>(m_tileKey, move(shapes)));
 }
diff --git a/drape_frontend/engine_context.hpp b/drape_frontend/engine_context.hpp
index 3a32008d3e..f8a3bb209f 100644
--- a/drape_frontend/engine_context.hpp
+++ b/drape_frontend/engine_context.hpp
@@ -27,7 +27,7 @@ public:
   ref_ptr<dp::TextureManager> GetTextureManager() const;
 
   void BeginReadTile();
-  void Flush(list<drape_ptr<MapShape>> && shapes);
+  void Flush(vector<drape_ptr<MapShape>> && shapes);
   void EndReadTile();
 
 private:
diff --git a/drape_frontend/frontend_renderer.cpp b/drape_frontend/frontend_renderer.cpp
index f173e612de..e8e12e71fa 100755
--- a/drape_frontend/frontend_renderer.cpp
+++ b/drape_frontend/frontend_renderer.cpp
@@ -822,13 +822,12 @@ void FrontendRenderer::Routine::Do()
   dp::BlendingParams blendingParams;
   blendingParams.Apply();
 
-  int const kMaxInactiveFrames = 60;
+  double const kMaxInactiveSeconds = 2.0;
 
   my::Timer timer;
-  timer.Reset();
+  my::Timer activityTimer;
 
   double frameTime = 0.0;
-  int inactiveFrameCount = 0;
   bool modelViewChanged = true;
   bool viewportChanged = true;
 
@@ -843,10 +842,13 @@ void FrontendRenderer::Routine::Do()
     if (modelViewChanged || viewportChanged)
       m_renderer.PrepareScene(modelView);
 
-    bool const hasAsyncRoutines = m_renderer.m_texMng->UpdateDynamicTextures();
+    // Check for a frame is active.
+    bool isActiveFrame = modelViewChanged || viewportChanged;
+
+    isActiveFrame |= m_renderer.m_texMng->UpdateDynamicTextures();
     m_renderer.RenderScene(modelView);
 
-    bool const animActive = InterpolationHolder::Instance().Advance(frameTime);
+    isActiveFrame |= InterpolationHolder::Instance().Advance(frameTime);
 
     if (modelViewChanged)
     {
@@ -854,33 +856,26 @@ void FrontendRenderer::Routine::Do()
       m_renderer.EmitModelViewChanged(modelView);
     }
 
-    bool const waitCompletion = m_renderer.m_userEventStream.IsWaitingForActionCompletion();
+    isActiveFrame |= m_renderer.m_userEventStream.IsWaitingForActionCompletion();
 
-    // Check for a frame is inactive.
-    bool const isInactiveFrame = !modelViewChanged && !viewportChanged &&
-                                 !animActive && !hasAsyncRoutines &&
-                                 !waitCompletion && m_renderer.IsQueueEmpty();
-    if (isInactiveFrame)
-      ++inactiveFrameCount;
-    else
-      inactiveFrameCount = 0;
+    if (isActiveFrame)
+      activityTimer.Reset();
 
-    if (inactiveFrameCount > kMaxInactiveFrames)
+    if (activityTimer.ElapsedSeconds() > kMaxInactiveSeconds)
     {
       // Process a message or wait for a message.
       m_renderer.ProcessSingleMessage();
-      inactiveFrameCount = 0;
+      activityTimer.Reset();
     }
     else
     {
-      double availableTime = VSyncInterval - timer.ElapsedSeconds();
-      if (availableTime < 0.0)
-        availableTime = 0.01;
-
+      double availableTime = max(VSyncInterval - timer.ElapsedSeconds(), 0.01);
       while (availableTime > 0)
       {
-        if (m_renderer.ProcessSingleMessage(availableTime * 1000.0))
-          inactiveFrameCount = 0;
+        if (!m_renderer.ProcessSingleMessage(false /* waitForMessage */))
+          break;
+
+        activityTimer.Reset();
         availableTime = VSyncInterval - timer.ElapsedSeconds();
       }
     }
diff --git a/drape_frontend/line_shape.cpp b/drape_frontend/line_shape.cpp
index b95494e917..3671f44229 100644
--- a/drape_frontend/line_shape.cpp
+++ b/drape_frontend/line_shape.cpp
@@ -221,8 +221,7 @@ public:
 
   SolidLineBuilder(BuilderParams const & params, size_t pointsInSpline)
     : TBase(params, pointsInSpline * 2, (pointsInSpline - 2) * 8)
-  {
-  }
+  {}
 
   dp::GLState GetState() override
   {
@@ -233,7 +232,7 @@ public:
 
   dp::BindingInfo const & GetCapBindingInfo() override
   {
-    if (m_params.m_cap != dp::RoundCap)
+    if (m_params.m_cap == dp::ButtCap)
       return TBase::GetCapBindingInfo();
 
     static unique_ptr<dp::BindingInfo> s_capInfo;
@@ -252,7 +251,7 @@ public:
 
   dp::GLState GetCapState() override
   {
-    if (m_params.m_cap != dp::RoundCap)
+    if (m_params.m_cap == dp::ButtCap)
       return TBase::GetCapState();
 
     dp::GLState state(gpu::CAP_JOIN_PROGRAM, dp::GLState::GeometryLayer);
@@ -271,39 +270,22 @@ public:
     return m_capGeometry.size();
   }
 
-  void SubmitVertex(LineSegment const & segment, glsl::vec3 const & pivot,
-                    glsl::vec2 const & normal, bool isLeft, float offsetFromStart)
+  void SubmitVertex(glsl::vec3 const & pivot, glsl::vec2 const & normal, bool isLeft)
   {
-    UNUSED_VALUE(segment);
-    UNUSED_VALUE(offsetFromStart);
-
     float halfWidth = GetHalfWidth();
     m_geometry.emplace_back(V(pivot, TNormal(halfWidth * normal, halfWidth * GetSide(isLeft)), m_colorCoord));
   }
 
-  void SubmitJoin(LineSegment const & seg1, LineSegment const & seg2)
+  void SubmitJoin(glsl::vec2 const & pos)
   {
     if (m_params.m_join == dp::RoundJoin)
-      CreateRoundCap(seg1.m_points[EndPoint]);
-    else
-      SubmitJoinImpl(glsl::vec3(seg1.m_points[EndPoint], m_params.m_depth), GenerateJoin(seg1, seg2));
+      CreateRoundCap(pos);
   }
 
-  void SubmitCap(LineSegment const & segment, bool isStart)
+  void SubmitCap(glsl::vec2 const & pos)
   {
-    if (m_params.m_cap == dp::ButtCap)
-      return;
-
-    EPointType const type = isStart ? StartPoint : EndPoint;
-    if (m_params.m_cap != dp::RoundCap)
-    {
-      float const sign = isStart ? -1.0 : 1.0;
-      SubmitJoinImpl(glsl::vec3(segment.m_points[type], m_params.m_depth), GenerateCap(segment, type, sign, isStart));
-    }
-    else
-    {
-      CreateRoundCap(segment.m_points[type]);
-    }
+    if (m_params.m_cap != dp::ButtCap)
+      CreateRoundCap(pos);
   }
 
 private:
@@ -327,19 +309,6 @@ private:
                                       CapVertex::TTexCoord(m_colorCoord)));
   }
 
-  void SubmitJoinImpl(glsl::vec3 const & pivot, vector<glsl::vec2> const & normals)
-  {
-    float halfWidth = GetHalfWidth();
-    size_t const trianglesCount = normals.size() / 3;
-    for (int j = 0; j < trianglesCount; j++)
-    {
-      size_t baseIndex = 3 * j;
-      m_joinGeom.push_back(V(pivot, TNormal(normals[baseIndex + 0], halfWidth), m_colorCoord));
-      m_joinGeom.push_back(V(pivot, TNormal(normals[baseIndex + 1], halfWidth), m_colorCoord));
-      m_joinGeom.push_back(V(pivot, TNormal(normals[baseIndex + 2], halfWidth), m_colorCoord));
-    }
-  }
-
 private:
   TCapBuffer m_capGeometry;
 };
@@ -437,47 +406,6 @@ LineShape::LineShape(m2::SharedSpline const & spline, LineViewParams const & par
   ASSERT_GREATER(m_spline->GetPath().size(), 1, ());
 }
 
-void LineShape::Prepare(ref_ptr<dp::TextureManager> textures) const
-{
-  dp::TextureManager::ColorRegion colorRegion;
-  textures->GetColorRegion(m_params.m_color, colorRegion);
-  float const pxHalfWidth = m_params.m_width / 2.0f;
-
-  auto commonParamsFiller = [&](BaseBuilderParams & p)
-  {
-    p.m_cap = m_params.m_cap;
-    p.m_color = colorRegion;
-    p.m_depth = m_params.m_depth;
-    p.m_join = m_params.m_join;
-    p.m_pxHalfWidth = pxHalfWidth;
-  };
-
-  if (m_params.m_pattern.empty())
-  {
-    SolidLineBuilder::BuilderParams p;
-    commonParamsFiller(p);
-
-    auto builder = make_unique<SolidLineBuilder>(p, m_spline->GetPath().size());
-    Construct<SolidLineBuilder>(*builder);
-    m_lineShapeInfo = move(builder);
-  }
-  else
-  {
-    dp::TextureManager::StippleRegion maskRegion;
-    textures->GetStippleRegion(m_params.m_pattern, maskRegion);
-
-    DashedLineBuilder::BuilderParams p;
-    commonParamsFiller(p);
-    p.m_stipple = maskRegion;
-    p.m_baseGtoP = m_params.m_baseGtoPScale;
-    p.m_glbHalfWidth = pxHalfWidth / m_params.m_baseGtoPScale;
-
-    auto builder = make_unique<DashedLineBuilder>(p, m_spline->GetPath().size());
-    Construct<DashedLineBuilder>(*builder);
-    m_lineShapeInfo = move(builder);
-  }
-}
-
 template <typename TBuilder>
 void LineShape::Construct(TBuilder & builder) const
 {
@@ -485,9 +413,9 @@ void LineShape::Construct(TBuilder & builder) const
   ASSERT(path.size() > 1, ());
 
   // skip joins generation
-  float const joinsGenerationThreshold = 2.5f;
+  float const kJoinsGenerationThreshold = 2.5f;
   bool generateJoins = true;
-  if (builder.GetHalfWidth() <= joinsGenerationThreshold)
+  if (builder.GetHalfWidth() <= kJoinsGenerationThreshold)
     generateJoins = false;
 
   // constuct segments
@@ -540,6 +468,97 @@ void LineShape::Construct(TBuilder & builder) const
   builder.SubmitCap(segments[segments.size() - 1], false /* isStart */);
 }
 
+// Specialization optimized for solid lines.
+template <>
+void LineShape::Construct<SolidLineBuilder>(SolidLineBuilder & builder) const
+{
+  vector<m2::PointD> const & path = m_spline->GetPath();
+  ASSERT(path.size() > 1, ());
+
+  // skip joins generation
+  float const kJoinsGenerationThreshold = 2.5f;
+  bool generateJoins = true;
+  if (builder.GetHalfWidth() <= kJoinsGenerationThreshold)
+    generateJoins = false;
+
+  // build geometry
+  glsl::vec2 firstPoint = glsl::vec2(path.front().x, path.front().y);
+  glsl::vec2 lastPoint;
+  bool hasConstructedSegments = false;
+  for (size_t i = 1; i < path.size(); ++i)
+  {
+    if (path[i].EqualDxDy(path[i - 1], 1.0E-5))
+      continue;
+
+    glsl::vec2 const p1 = glsl::vec2(path[i - 1].x, path[i - 1].y);
+    glsl::vec2 const p2 = glsl::vec2(path[i].x, path[i].y);
+    glsl::vec2 tangent, leftNormal, rightNormal;
+    CalculateTangentAndNormals(p1, p2, tangent, leftNormal, rightNormal);
+
+    glsl::vec3 const startPoint = glsl::vec3(p1, m_params.m_depth);
+    glsl::vec3 const endPoint = glsl::vec3(p2, m_params.m_depth);
+
+    builder.SubmitVertex(startPoint, rightNormal, false /* isLeft */);
+    builder.SubmitVertex(startPoint, leftNormal, true /* isLeft */);
+    builder.SubmitVertex(endPoint, rightNormal, false /* isLeft */);
+    builder.SubmitVertex(endPoint, leftNormal, true /* isLeft */);
+
+    // generate joins
+    if (generateJoins && i < path.size() - 1)
+      builder.SubmitJoin(p2);
+
+    lastPoint = p2;
+    hasConstructedSegments = true;
+  }
+
+  if (hasConstructedSegments)
+  {
+    builder.SubmitCap(firstPoint);
+    builder.SubmitCap(lastPoint);
+  }
+}
+
+void LineShape::Prepare(ref_ptr<dp::TextureManager> textures) const
+{
+  dp::TextureManager::ColorRegion colorRegion;
+  textures->GetColorRegion(m_params.m_color, colorRegion);
+  float const pxHalfWidth = m_params.m_width / 2.0f;
+
+  auto commonParamsFiller = [&](BaseBuilderParams & p)
+  {
+    p.m_cap = m_params.m_cap;
+    p.m_color = colorRegion;
+    p.m_depth = m_params.m_depth;
+    p.m_join = m_params.m_join;
+    p.m_pxHalfWidth = pxHalfWidth;
+  };
+
+  if (m_params.m_pattern.empty())
+  {
+    SolidLineBuilder::BuilderParams p;
+    commonParamsFiller(p);
+
+    auto builder = make_unique<SolidLineBuilder>(p, m_spline->GetPath().size());
+    Construct<SolidLineBuilder>(*builder);
+    m_lineShapeInfo = move(builder);
+  }
+  else
+  {
+    dp::TextureManager::StippleRegion maskRegion;
+    textures->GetStippleRegion(m_params.m_pattern, maskRegion);
+
+    DashedLineBuilder::BuilderParams p;
+    commonParamsFiller(p);
+    p.m_stipple = maskRegion;
+    p.m_baseGtoP = m_params.m_baseGtoPScale;
+    p.m_glbHalfWidth = pxHalfWidth / m_params.m_baseGtoPScale;
+
+    auto builder = make_unique<DashedLineBuilder>(p, m_spline->GetPath().size());
+    Construct<DashedLineBuilder>(*builder);
+    m_lineShapeInfo = move(builder);
+  }
+}
+
 void LineShape::Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const
 {
   if (!m_lineShapeInfo)
diff --git a/drape_frontend/line_shape.hpp b/drape_frontend/line_shape.hpp
index b1f583e645..0c4dca2a32 100644
--- a/drape_frontend/line_shape.hpp
+++ b/drape_frontend/line_shape.hpp
@@ -40,6 +40,7 @@ public:
 
   void Prepare(ref_ptr<dp::TextureManager> textures) const override;
   void Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const override;
+  MapShapePriority GetPriority() const override { return MapShapePriority::LinePriority; }
 
 private:
   template <typename TBuilder>
diff --git a/drape_frontend/line_shape_helper.cpp b/drape_frontend/line_shape_helper.cpp
index cdb06f512a..5e27478239 100644
--- a/drape_frontend/line_shape_helper.cpp
+++ b/drape_frontend/line_shape_helper.cpp
@@ -76,6 +76,8 @@ void UpdateNormalBetweenSegments(LineSegment * segment1, LineSegment * segment2)
   }
 }
 
+}
+
 void CalculateTangentAndNormals(glsl::vec2 const & pt0, glsl::vec2 const & pt1,
                                 glsl::vec2 & tangent, glsl::vec2 & leftNormal,
                                 glsl::vec2 & rightNormal)
@@ -85,8 +87,6 @@ void CalculateTangentAndNormals(glsl::vec2 const & pt0, glsl::vec2 const & pt1,
   rightNormal = -leftNormal;
 }
 
-}
-
 void ConstructLineSegments(vector<m2::PointD> const & path, vector<LineSegment> & segments)
 {
   ASSERT_LESS(1, path.size(), ());
diff --git a/drape_frontend/line_shape_helper.hpp b/drape_frontend/line_shape_helper.hpp
index 6b30061195..5014367cc4 100644
--- a/drape_frontend/line_shape_helper.hpp
+++ b/drape_frontend/line_shape_helper.hpp
@@ -46,6 +46,10 @@ struct LineSegment
   }
 };
 
+void CalculateTangentAndNormals(glsl::vec2 const & pt0, glsl::vec2 const & pt1,
+                                glsl::vec2 & tangent, glsl::vec2 & leftNormal,
+                                glsl::vec2 & rightNormal);
+
 void ConstructLineSegments(vector<m2::PointD> const & path, vector<LineSegment> & segments);
 
 void UpdateNormals(LineSegment * segment, LineSegment * prevSegment, LineSegment * nextSegment);
diff --git a/drape_frontend/map_shape.hpp b/drape_frontend/map_shape.hpp
index 59463aec47..b776828893 100644
--- a/drape_frontend/map_shape.hpp
+++ b/drape_frontend/map_shape.hpp
@@ -14,18 +14,29 @@ namespace dp
 namespace df
 {
 
+// Priority of shapes' processing (descending order).
+enum MapShapePriority
+{
+  AreaPriority = 0,
+  TextAndPoiPriority,
+  LinePriority,
+
+  PrioritiesCount
+};
+
 class MapShape
 {
 public:
   virtual ~MapShape(){}
   virtual void Prepare(ref_ptr<dp::TextureManager> textures) const {}
   virtual void Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const = 0;
+  virtual MapShapePriority GetPriority() const { return MapShapePriority::AreaPriority; }
 };
 
 class MapShapeReadedMessage : public Message
 {
 public:
-  using TMapShapes = list<drape_ptr<MapShape>>;
+  using TMapShapes = vector<drape_ptr<MapShape>>;
 
   MapShapeReadedMessage(TileKey const & key, TMapShapes && shapes)
     : m_key(key), m_shapes(move(shapes))
diff --git a/drape_frontend/message_acceptor.cpp b/drape_frontend/message_acceptor.cpp
index 757002bf6c..e09e47e148 100644
--- a/drape_frontend/message_acceptor.cpp
+++ b/drape_frontend/message_acceptor.cpp
@@ -10,10 +10,10 @@ MessageAcceptor::MessageAcceptor()
 {
 }
 
-bool MessageAcceptor::ProcessSingleMessage(unsigned maxTimeWait)
+bool MessageAcceptor::ProcessSingleMessage(bool waitForMessage)
 {
-  m_infinityWaiting = (maxTimeWait == -1);
-  drape_ptr<Message> message = m_messageQueue.PopMessage(maxTimeWait);
+  m_infinityWaiting = waitForMessage;
+  drape_ptr<Message> message = m_messageQueue.PopMessage(waitForMessage);
   m_infinityWaiting = false;
 
   if (message == nullptr)
diff --git a/drape_frontend/message_acceptor.hpp b/drape_frontend/message_acceptor.hpp
index ffb9cc827b..c3bdfe2f66 100644
--- a/drape_frontend/message_acceptor.hpp
+++ b/drape_frontend/message_acceptor.hpp
@@ -21,7 +21,7 @@ protected:
   virtual bool CanReceiveMessage() = 0;
 
   /// Must be called by subclass on message target thread
-  bool ProcessSingleMessage(unsigned maxTimeWait = -1);
+  bool ProcessSingleMessage(bool waitForMessage = true);
 
   void CancelMessageWaiting();
 
@@ -35,7 +35,6 @@ private:
 
   void PostMessage(drape_ptr<Message> && message, MessagePriority priority);
 
-private:
   MessageQueue m_messageQueue;
   atomic<bool> m_infinityWaiting;
 };
diff --git a/drape_frontend/message_queue.cpp b/drape_frontend/message_queue.cpp
index aa10ce442c..edbbe7d3a5 100644
--- a/drape_frontend/message_queue.cpp
+++ b/drape_frontend/message_queue.cpp
@@ -19,20 +19,16 @@ MessageQueue::~MessageQueue()
   ClearQuery();
 }
 
-drape_ptr<Message> MessageQueue::PopMessage(unsigned maxTimeWait)
+drape_ptr<Message> MessageQueue::PopMessage(bool waitForMessage)
 {
   unique_lock<mutex> lock(m_mutex);
-  if (m_messages.empty())
+  if (waitForMessage && m_messages.empty())
   {
     m_isWaiting = true;
-    if (maxTimeWait == -1)
-      m_condition.wait(lock, [this]() { return !m_isWaiting; });
-    else
-      m_condition.wait_for(lock, milliseconds(maxTimeWait), [this]() { return !m_isWaiting; });
+    m_condition.wait(lock, [this]() { return !m_isWaiting; });
     m_isWaiting = false;
   }
 
-  // m_messages can be empty if application preparing to close and CancelWait been called.
   if (m_messages.empty())
     return nullptr;
 
diff --git a/drape_frontend/message_queue.hpp b/drape_frontend/message_queue.hpp
index 88b299963c..c1b1f8cbe1 100644
--- a/drape_frontend/message_queue.hpp
+++ b/drape_frontend/message_queue.hpp
@@ -20,7 +20,7 @@ public:
   ~MessageQueue();
 
   /// if queue is empty then return NULL
-  drape_ptr<Message> PopMessage(unsigned maxTimeWait);
+  drape_ptr<Message> PopMessage(bool waitForMessage);
   void PushMessage(drape_ptr<Message> && message, MessagePriority priority);
   void CancelWait();
   void ClearQuery();
diff --git a/drape_frontend/path_symbol_shape.hpp b/drape_frontend/path_symbol_shape.hpp
index 53ee1bd17e..2366de3544 100644
--- a/drape_frontend/path_symbol_shape.hpp
+++ b/drape_frontend/path_symbol_shape.hpp
@@ -12,7 +12,8 @@ class PathSymbolShape : public MapShape
 {
 public:
   PathSymbolShape(m2::SharedSpline const & spline, PathSymbolViewParams const & params);
-  virtual void Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const;
+  void Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const override;
+  MapShapePriority GetPriority() const override { return MapShapePriority::LinePriority; }
 
 private:
   PathSymbolViewParams m_params;
diff --git a/drape_frontend/path_text_shape.hpp b/drape_frontend/path_text_shape.hpp
index e7803d3080..06e2befd10 100644
--- a/drape_frontend/path_text_shape.hpp
+++ b/drape_frontend/path_text_shape.hpp
@@ -13,7 +13,8 @@ class PathTextShape : public MapShape
 public:
   PathTextShape(m2::SharedSpline const & spline,
                 PathTextViewParams const & params);
-  virtual void Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const;
+  void Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const override;
+  MapShapePriority GetPriority() const override { return MapShapePriority::LinePriority; }
 
 private:
   m2::SharedSpline m_spline;
diff --git a/drape_frontend/poi_symbol_shape.hpp b/drape_frontend/poi_symbol_shape.hpp
index ba9189439f..2d498d33f0 100644
--- a/drape_frontend/poi_symbol_shape.hpp
+++ b/drape_frontend/poi_symbol_shape.hpp
@@ -11,7 +11,8 @@ class PoiSymbolShape : public MapShape
 public:
   PoiSymbolShape(m2::PointF const & mercatorPt, PoiSymbolViewParams const & params);
 
-  virtual void Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const;
+  void Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const override;
+  MapShapePriority GetPriority() const override { return MapShapePriority::TextAndPoiPriority; }
 
 private:
   m2::PointF const m_pt;
diff --git a/drape_frontend/render_group.cpp b/drape_frontend/render_group.cpp
index 2aa124eec1..f0f8662695 100755
--- a/drape_frontend/render_group.cpp
+++ b/drape_frontend/render_group.cpp
@@ -117,6 +117,13 @@ void RenderGroup::Disappear()
     m_disappearAnimation = make_unique<OpacityAnimation>(0.2 /* duration */, 0.05 /* delay */,
                                                          1.0 /* startOpacity */, 0.0 /* endOpacity */);
   }
+  else
+  {
+    // Create separate disappearing animation for area objects to eliminate flickering.
+    if (m_state.GetProgramIndex() == gpu::AREA_PROGRAM)
+      m_disappearAnimation = make_unique<OpacityAnimation>(0.01 /* duration */, 0.25 /* delay */,
+                                                           1.0 /* startOpacity */, 1.0 /* endOpacity */);
+  }
 }
 
 bool RenderGroupComparator::operator()(drape_ptr<RenderGroup> const & l, drape_ptr<RenderGroup> const & r)
diff --git a/drape_frontend/route_shape.cpp b/drape_frontend/route_shape.cpp
index 8648414230..83b8ae2cc5 100644
--- a/drape_frontend/route_shape.cpp
+++ b/drape_frontend/route_shape.cpp
@@ -365,7 +365,8 @@ void RouteShape::BatchGeometry(dp::GLState const & state, TGeometryBuffer & geom
   size_t const verticesCount = geometry.size() + joinsGeometry.size();
   if (verticesCount != 0)
   {
-    dp::Batcher batcher(verticesCount, verticesCount);
+    uint32_t const kBatchSize = 5000;
+    dp::Batcher batcher(kBatchSize, kBatchSize);
     dp::SessionGuard guard(batcher, [&property](dp::GLState const & state, drape_ptr<dp::RenderBucket> && b)
     {
       property.m_buckets.push_back(move(b));
diff --git a/drape_frontend/rule_drawer.cpp b/drape_frontend/rule_drawer.cpp
index 828212a774..6d5b5ea4d6 100644
--- a/drape_frontend/rule_drawer.cpp
+++ b/drape_frontend/rule_drawer.cpp
@@ -22,8 +22,15 @@
 namespace df
 {
 
-int const SIMPLIFY_BOTTOM = 10;
-int const SIMPLIFY_TOP = 12;
+int const kLineSimplifyLevelStart = 10;
+int const kLineSimplifyLevelEnd = 12;
+
+size_t kMinFlushSizes[df::PrioritiesCount] =
+{
+  1, // AreaPriority
+  5, // TextAndPoiPriority
+  10, // LinePriority
+};
 
 RuleDrawer::RuleDrawer(TDrawerCallback const & fn, ref_ptr<EngineContext> context)
   : m_callback(fn)
@@ -35,6 +42,25 @@ RuleDrawer::RuleDrawer(TDrawerCallback const & fn, ref_ptr<EngineContext> contex
   m_geometryConvertor.OnSize(0, 0, tileSize, tileSize);
   m_geometryConvertor.SetFromRect(m2::AnyRectD(m_globalRect));
   m_currentScaleGtoP = 1.0f / m_geometryConvertor.GetScale();
+
+  for (size_t i = 0; i < m_mapShapes.size(); i++)
+    m_mapShapes[i].reserve(kMinFlushSizes[i] + 1);
+}
+
+RuleDrawer::~RuleDrawer()
+{
+  for (size_t i = 0; i < m_mapShapes.size(); i++)
+  {
+    if (!m_mapShapes[i].empty())
+    {
+      for (auto const & shape : m_mapShapes[i])
+        shape->Prepare(m_context->GetTextureManager());
+
+      vector<drape_ptr<MapShape>> mapShapes;
+      mapShapes.swap(m_mapShapes[i]);
+      m_context->Flush(move(mapShapes));
+    }
+  }
 }
 
 void RuleDrawer::operator()(FeatureType const & f)
@@ -62,7 +88,9 @@ void RuleDrawer::operator()(FeatureType const & f)
 
   auto insertShape = [this](drape_ptr<MapShape> && shape)
   {
-    m_mapShapes.push_back(move(shape));
+    int const index = static_cast<int>(shape->GetPriority());
+    ASSERT_LESS(index, m_mapShapes.size(), ());
+    m_mapShapes[index].push_back(move(shape));
   };
 
   if (s.AreaStyleExists())
@@ -79,7 +107,8 @@ void RuleDrawer::operator()(FeatureType const & f)
   else if (s.LineStyleExists())
   {
     ApplyLineFeature apply(insertShape, f.GetID(), s.GetCaptionDescription(), m_currentScaleGtoP,
-                           zoomLevel >= SIMPLIFY_BOTTOM && zoomLevel <= SIMPLIFY_TOP, f.GetPointsCount());
+                           zoomLevel >= kLineSimplifyLevelStart && zoomLevel <= kLineSimplifyLevelEnd,
+                           f.GetPointsCount());
     f.ForEachPointRef(apply, zoomLevel);
 
     if (apply.HasGeometry())
@@ -129,10 +158,18 @@ void RuleDrawer::operator()(FeatureType const & f)
   insertShape(make_unique_dp<TextShape>(r.Center(), tp));
 #endif
 
-  for (auto & shape : m_mapShapes)
-    shape->Prepare(m_context->GetTextureManager());
+  for (size_t i = 0; i < m_mapShapes.size(); i++)
+  {
+    if (m_mapShapes[i].size() >= kMinFlushSizes[i])
+    {
+      for (auto const & shape : m_mapShapes[i])
+        shape->Prepare(m_context->GetTextureManager());
 
-  m_context->Flush(move(m_mapShapes));
+      vector<drape_ptr<MapShape>> mapShapes;
+      mapShapes.swap(m_mapShapes[i]);
+      m_context->Flush(move(mapShapes));
+    }
+  }
 }
 
 } // namespace df
diff --git a/drape_frontend/rule_drawer.hpp b/drape_frontend/rule_drawer.hpp
index c963c329d6..8102cec656 100644
--- a/drape_frontend/rule_drawer.hpp
+++ b/drape_frontend/rule_drawer.hpp
@@ -1,12 +1,14 @@
 #pragma once
 
 #include "drape_frontend/tile_key.hpp"
+#include "drape_frontend/map_shape.hpp"
 
 #include "drape/pointers.hpp"
 
 #include "geometry/rect2d.hpp"
 #include "geometry/screenbase.hpp"
 
+#include "std/array.hpp"
 #include "std/function.hpp"
 #include "std/set.hpp"
 #include "std/string.hpp"
@@ -18,13 +20,13 @@ namespace df
 
 class EngineContext;
 class Stylist;
-class MapShape;
 
 class RuleDrawer
 {
 public:
   using TDrawerCallback = function<void (FeatureType const &, Stylist &)>;
   RuleDrawer(TDrawerCallback const & fn, ref_ptr<EngineContext> context);
+  ~RuleDrawer();
 
   void operator() (FeatureType const & f);
 
@@ -36,7 +38,7 @@ private:
   double m_currentScaleGtoP;
   set<string> m_coastlines;
 
-  list<drape_ptr<MapShape>> m_mapShapes;
+  array<vector<drape_ptr<MapShape>>, df::PrioritiesCount> m_mapShapes;
 };
 
 } // namespace dfo
diff --git a/drape_frontend/stylist.cpp b/drape_frontend/stylist.cpp
index fc3442b798..c89c3ff7c1 100644
--- a/drape_frontend/stylist.cpp
+++ b/drape_frontend/stylist.cpp
@@ -333,11 +333,7 @@ CaptionDescription & Stylist::GetCaptionDescriptionImpl()
   return m_captionDescriptor;
 }
 
-// ==================================== //
-
-bool InitStylist(FeatureType const & f,
-                 int const zoomLevel,
-                 Stylist & s)
+bool InitStylist(FeatureType const & f, int const zoomLevel, Stylist & s)
 {
   drule::KeysT keys;
   pair<int, bool> geomType = feature::GetDrawRule(f, zoomLevel, keys);
diff --git a/drape_frontend/text_shape.hpp b/drape_frontend/text_shape.hpp
index 3302e45503..e688096a7e 100644
--- a/drape_frontend/text_shape.hpp
+++ b/drape_frontend/text_shape.hpp
@@ -16,13 +16,14 @@ class TextShape : public MapShape
 public:
   TextShape(m2::PointF const & basePoint, TextViewParams const & params);
 
-  void Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const;
+  void Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const override;
+  MapShapePriority GetPriority() const override { return MapShapePriority::TextAndPoiPriority; }
+
 private:
   void DrawSubString(StraightTextLayout const & layout, dp::FontDecl const & font,
                      glsl::vec2 const & baseOffset, ref_ptr<dp::Batcher> batcher,
                      ref_ptr<dp::TextureManager> textures) const;
 
-private:
   m2::PointF m_basePoint;
   TextViewParams m_params;
 };
diff --git a/drape_head/testing_engine.cpp b/drape_head/testing_engine.cpp
index 3871fa3d00..da8b5e4233 100644
--- a/drape_head/testing_engine.cpp
+++ b/drape_head/testing_engine.cpp
@@ -343,7 +343,7 @@ TestingEngine::TestingEngine(Viewport const & viewport, double vs)
   m_textures = make_unique_dp<dp::TextureManager>();
   m_textures->Init(params);
 
-  m_batcher = make_unique_dp<dp::Batcher>(65000, 65000);
+  m_batcher = make_unique_dp<dp::Batcher>(5000, 5000);
   m_programManager = make_unique_dp<dp::GpuProgramManager>();
 
   ModelViewInit();