diff --git a/drape/glstate.cpp b/drape/glstate.cpp
index a7a7fc8dce..895a079a4b 100644
--- a/drape/glstate.cpp
+++ b/drape/glstate.cpp
@@ -93,7 +93,7 @@ void ApplyUniforms(UniformValuesStorage const & uniforms, ref_ptr<GpuProgram> pr
   uniforms.ForeachValue(bind(&ApplyUniformValue, _1, program));
 }
 
-void ApplyState(GLState state, ref_ptr<GpuProgram> program)
+void ApplyTextures(GLState state, ref_ptr<GpuProgram> program)
 {
   ref_ptr<Texture> tex = state.GetColorTexture();
   if (tex != nullptr)
@@ -112,7 +112,17 @@ void ApplyState(GLState state, ref_ptr<GpuProgram> program)
     tex->Bind();
     GLFunctions::glUniformValuei(maskTexLoc, 1);
   }
+}
+
+void ApplyBlending(GLState state, ref_ptr<GpuProgram> program)
+{
   state.GetBlending().Apply();
 }
 
+void ApplyState(GLState state, ref_ptr<GpuProgram> program)
+{
+  ApplyTextures(state, program);
+  ApplyBlending(state, program);
+}
+
 }
diff --git a/drape/glstate.hpp b/drape/glstate.hpp
index 931225ca68..231d56c48a 100644
--- a/drape/glstate.hpp
+++ b/drape/glstate.hpp
@@ -65,5 +65,7 @@ private:
 
 void ApplyUniforms(UniformValuesStorage const & uniforms, ref_ptr<GpuProgram> program);
 void ApplyState(GLState state, ref_ptr<GpuProgram> program);
+void ApplyTextures(GLState state, ref_ptr<GpuProgram> program);
+void ApplyBlending(GLState state, ref_ptr<GpuProgram> program);
 
 } // namespace dp
diff --git a/drape/shaders/route_arrow_fragment_shader.fsh b/drape/shaders/route_arrow_fragment_shader.fsh
new file mode 100644
index 0000000000..fc3484985c
--- /dev/null
+++ b/drape/shaders/route_arrow_fragment_shader.fsh
@@ -0,0 +1,33 @@
+varying vec2 v_length;
+
+uniform sampler2D u_colorTex;
+uniform vec4 u_textureRect;
+
+uniform mat4 u_arrowBorders;
+
+void main(void)
+{
+  float needDiscard = 1.0;
+  vec2 uv = vec2(0, 0);
+  for (int i = 0; i < 4; i++)
+  {
+	vec4 arrowBorder = u_arrowBorders[i];
+    if (v_length.x >= arrowBorder.x && v_length.x <= arrowBorder.z)
+	{
+      needDiscard = 0.0;
+      float coef = clamp((v_length.x - arrowBorder.x) / (arrowBorder.z - arrowBorder.x), 0.0, 1.0);
+      float u = mix(arrowBorder.y, arrowBorder.w, coef);
+      float v = 0.5 * v_length.y + 0.5;
+      uv = vec2(mix(u_textureRect.x, u_textureRect.z, u), mix(u_textureRect.y, u_textureRect.w, v));
+	}
+  }
+
+  if (needDiscard > 0.5)
+    discard;
+
+  vec4 color = texture2D(u_colorTex, uv);
+  if (color.a < 0.1)
+    discard;
+
+  gl_FragColor = color;
+}
diff --git a/drape/shaders/route_fragment_shader.fsh b/drape/shaders/route_fragment_shader.fsh
index 94e5b07f9c..3fd7c5e9c6 100644
--- a/drape/shaders/route_fragment_shader.fsh
+++ b/drape/shaders/route_fragment_shader.fsh
@@ -1,11 +1,11 @@
-varying float v_length;
+varying vec2 v_length;
 
 uniform vec4 u_color;
 uniform float u_clipLength;
 
 void main(void)
 {
-  if (v_length < u_clipLength)
+  if (v_length.x < u_clipLength)
     discard;
 
   gl_FragColor = u_color;
diff --git a/drape/shaders/route_vertex_shader.vsh b/drape/shaders/route_vertex_shader.vsh
index 779dfa8c22..edd261bf47 100644
--- a/drape/shaders/route_vertex_shader.vsh
+++ b/drape/shaders/route_vertex_shader.vsh
@@ -1,19 +1,19 @@
 attribute vec3 a_position;
 attribute vec2 a_normal;
-attribute vec2 a_length;
+attribute vec3 a_length;
 
 uniform mat4 modelView;
 uniform mat4 projection;
 
 uniform vec2 u_halfWidth;
 
-varying float v_length;
+varying vec2 v_length;
 
 void main(void)
 {
   float normalLen = length(a_normal);
   vec2 transformedAxisPos = (vec4(a_position.xy, 0.0, 1.0) * modelView).xy;
-  float len = a_length.x;
+  vec2 len = vec2(a_length.x, a_length.z);
   if (u_halfWidth.x != 0.0 && normalLen != 0.0)
   {
     vec2 norm = a_normal * u_halfWidth.x;
@@ -24,7 +24,7 @@ void main(void)
     transformedAxisPos = transformedAxisPos + normalize(shiftPos - transformedAxisPos) * actualHalfWidth;
 
     if (u_halfWidth.y != 0.0)
-      len = a_length.x + a_length.y * u_halfWidth.y;
+      len = vec2(a_length.x + a_length.y * u_halfWidth.y, a_length.z);
   }
 
   v_length = len;
diff --git a/drape/shaders/shader_index.txt b/drape/shaders/shader_index.txt
index e54a4c4b45..6e7901d4d7 100644
--- a/drape/shaders/shader_index.txt
+++ b/drape/shaders/shader_index.txt
@@ -8,3 +8,4 @@ MY_POSITION_PROGRAM my_position_shader.vsh texturing_fragment_shader.fsh
 BUTTON_PROGRAM button_vertex_shader.vsh button_fragment_shader.fsh
 BOOKMARK_PROGRAM user_mark.vsh texturing_fragment_shader.fsh
 ROUTE_PROGRAM route_vertex_shader.vsh route_fragment_shader.fsh
+ROUTE_ARROW_PROGRAM route_vertex_shader.vsh route_arrow_fragment_shader.fsh
diff --git a/drape/utils/vertex_decl.cpp b/drape/utils/vertex_decl.cpp
index b4c4d72ce9..67627c6860 100644
--- a/drape/utils/vertex_decl.cpp
+++ b/drape/utils/vertex_decl.cpp
@@ -289,7 +289,7 @@ dp::BindingInfo const & LineVertex::GetBindingInfo()
 RouteVertex::RouteVertex()
   : m_position(0.0, 0.0, 0.0)
   , m_normal(0.0, 0.0)
-  , m_length(0.0, 0.0)
+  , m_length(0.0, 0.0, 0.0)
 {}
 
 RouteVertex::RouteVertex(TPosition const & position, TNormal const & normal, TLength const & length)
diff --git a/drape/utils/vertex_decl.hpp b/drape/utils/vertex_decl.hpp
index 2491772c85..bd689cfd6a 100644
--- a/drape/utils/vertex_decl.hpp
+++ b/drape/utils/vertex_decl.hpp
@@ -75,7 +75,7 @@ struct LineVertex : BaseVertex
 
 struct RouteVertex : BaseVertex
 {
-  typedef glsl::vec2 TLength;
+  typedef glsl::vec3 TLength;
 
   RouteVertex();
   RouteVertex(TPosition const & position, TNormal const & normal, TLength const & length);
diff --git a/drape_frontend/backend_renderer.cpp b/drape_frontend/backend_renderer.cpp
index a16caaa07f..b40d83f61d 100644
--- a/drape_frontend/backend_renderer.cpp
+++ b/drape_frontend/backend_renderer.cpp
@@ -35,11 +35,11 @@ BackendRenderer::BackendRenderer(Params const & params)
                               MessagePriority::High);
   });
 
-  m_routeBuilder = make_unique_dp<RouteBuilder>([this](dp::GLState const & state,
-                                                drape_ptr<dp::RenderBucket> && bucket, dp::Color const & color)
+  m_routeBuilder = make_unique_dp<RouteBuilder>([this](dp::GLState const & state, drape_ptr<dp::RenderBucket> && bucket,
+                                                dp::Color const & color, m2::RectF const & arrowTextureRect)
   {
     m_commutator->PostMessage(ThreadsCommutator::RenderThread,
-                              make_unique_dp<FlushRouteMessage>(state, move(bucket), color),
+                              make_unique_dp<FlushRouteMessage>(state, move(bucket), color, arrowTextureRect),
                               MessagePriority::Normal);
   });
 
@@ -186,7 +186,7 @@ void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
   case Message::AddRoute:
     {
       ref_ptr<AddRouteMessage> msg = message;
-      m_routeBuilder->Build(msg->GetRoutePolyline(), msg->GetColor());
+      m_routeBuilder->Build(msg->GetRoutePolyline(), msg->GetColor(), m_texMng);
       break;
     }
   case Message::RemoveRoute:
diff --git a/drape_frontend/frontend_renderer.cpp b/drape_frontend/frontend_renderer.cpp
index 4d433e4244..e20779fcfc 100755
--- a/drape_frontend/frontend_renderer.cpp
+++ b/drape_frontend/frontend_renderer.cpp
@@ -280,7 +280,8 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
       ref_ptr<FlushRouteMessage> msg = message;
       dp::GLState const & state = msg->GetState();
       drape_ptr<dp::RenderBucket> bucket = msg->AcceptBuffer();
-      m_routeRenderer->AddRouteRenderBucket(state, move(bucket), msg->GetColor(), make_ref(m_gpuProgramManager));
+      m_routeRenderer->AddRouteRenderBucket(state, move(bucket), msg->GetColor(), msg->GetArrowTextureRect(),
+                                            make_ref(m_gpuProgramManager));
       m_myPositionController->ActivateRouting();
       break;
     }
diff --git a/drape_frontend/message_subclasses.hpp b/drape_frontend/message_subclasses.hpp
index aacf554d45..a38482a69d 100644
--- a/drape_frontend/message_subclasses.hpp
+++ b/drape_frontend/message_subclasses.hpp
@@ -530,10 +530,11 @@ class FlushRouteMessage : public Message
 {
 public:
   FlushRouteMessage(dp::GLState const & state, drape_ptr<dp::RenderBucket> && buffer,
-                    dp::Color const & color)
+                    dp::Color const & color, m2::RectF const & arrowTextureRect)
     : m_state(state)
     , m_buffer(move(buffer))
     , m_color(color)
+    , m_arrowTextureRect(arrowTextureRect)
   {}
 
   Type GetType() const override { return Message::FlushRoute; }
@@ -541,11 +542,13 @@ public:
   dp::GLState const & GetState() const { return m_state; }
   drape_ptr<dp::RenderBucket> && AcceptBuffer() { return move(m_buffer); }
   dp::Color const & GetColor() const { return m_color; }
+  m2::RectF const & GetArrowTextureRect() const { return m_arrowTextureRect; }
 
 private:
   dp::GLState m_state;
   drape_ptr<dp::RenderBucket> m_buffer;
   dp::Color m_color;
+  m2::RectF m_arrowTextureRect;
 };
 
 
diff --git a/drape_frontend/route_builder.cpp b/drape_frontend/route_builder.cpp
index 5fb4be4d19..e3e4c88e85 100644
--- a/drape_frontend/route_builder.cpp
+++ b/drape_frontend/route_builder.cpp
@@ -12,19 +12,22 @@ RouteBuilder::RouteBuilder(RouteBuilder::TFlushRouteFn const & flushRouteFn)
   , m_batcher(make_unique_dp<dp::Batcher>(ESTIMATE_BUFFER_SIZE, ESTIMATE_BUFFER_SIZE))
 {}
 
-void RouteBuilder::Build(m2::PolylineD const & routePolyline, dp::Color const & color)
+void RouteBuilder::Build(m2::PolylineD const & routePolyline, dp::Color const & color, ref_ptr<dp::TextureManager> textures)
 {
   CommonViewParams params;
   params.m_depth = 0.0f;
 
-  auto flushRoute = [this, &color](dp::GLState const & state, drape_ptr<dp::RenderBucket> && bucket)
+  RouteShape shape(routePolyline, params);
+  m2::RectF textureRect = shape.GetArrowTextureRect(textures);
+
+  auto flushRoute = [this, &color, &textureRect](dp::GLState const & state, drape_ptr<dp::RenderBucket> && bucket)
   {
     if (m_flushRouteFn != nullptr)
-      m_flushRouteFn(state, move(bucket), color);
+      m_flushRouteFn(state, move(bucket), color, textureRect);
   };
 
   m_batcher->StartSession(flushRoute);
-  RouteShape(routePolyline, params).Draw(make_ref(m_batcher));
+  shape.Draw(make_ref(m_batcher), textures);
   m_batcher->EndSession();
 }
 
diff --git a/drape_frontend/route_builder.hpp b/drape_frontend/route_builder.hpp
index 79a1f4335c..7ef4c345fe 100644
--- a/drape_frontend/route_builder.hpp
+++ b/drape_frontend/route_builder.hpp
@@ -4,6 +4,7 @@
 #include "drape/glstate.hpp"
 #include "drape/pointers.hpp"
 #include "drape/render_bucket.hpp"
+#include "drape/texture_manager.hpp"
 
 #include "geometry/polyline2d.hpp"
 
@@ -15,13 +16,12 @@ namespace df
 class RouteBuilder
 {
 public:
-  using TFlushRouteFn = function<void(dp::GLState const &,
-                                      drape_ptr<dp::RenderBucket> &&,
-                                      dp::Color const &)>;
+  using TFlushRouteFn = function<void(dp::GLState const &, drape_ptr<dp::RenderBucket> &&,
+                                      dp::Color const &, m2::RectF const &)>;
 
   RouteBuilder(TFlushRouteFn const & flushRouteFn);
 
-  void Build(m2::PolylineD const & routePolyline, dp::Color const & color);
+  void Build(m2::PolylineD const & routePolyline, dp::Color const & color, ref_ptr<dp::TextureManager> textures);
 
 private:
   TFlushRouteFn m_flushRouteFn;
diff --git a/drape_frontend/route_renderer.cpp b/drape_frontend/route_renderer.cpp
index ebdb782245..a80090fa52 100644
--- a/drape_frontend/route_renderer.cpp
+++ b/drape_frontend/route_renderer.cpp
@@ -1,6 +1,7 @@
 #include "drape_frontend/route_renderer.hpp"
 
 #include "drape/glsl_func.hpp"
+#include "drape/shader_def.hpp"
 #include "drape/utils/projection.hpp"
 
 #include "indexer/scales.hpp"
@@ -21,6 +22,12 @@ float const halfWidthInPixel[] =
   2.0f, 2.5f, 3.5f, 5.0f, 7.5f, 10.0f, 14.0f, 18.0f, 36.0f,
 };
 
+int const arrowPartsCount = 3;
+double const arrowHeightFactor = 96.0 / 36.0;
+double const arrowAspect = 400.0 / 192.0;
+double const arrowTailSize = 32.0 / 400.0;
+double const arrowHeadSize = 144.0 / 400.0;
+
 }
 
 RouteGraphics::RouteGraphics(dp::GLState const & state,
@@ -60,16 +67,64 @@ void RouteRenderer::Render(ScreenBase const & screen, ref_ptr<dp::GpuProgramMana
 
     ref_ptr<dp::GpuProgram> prg = mng->GetProgram(graphics.m_state.GetProgramIndex());
     prg->Bind();
-    dp::ApplyState(graphics.m_state, prg);
+    dp::ApplyBlending(graphics.m_state, prg);
     dp::ApplyUniforms(commonUniforms, prg);
     dp::ApplyUniforms(uniformStorage, prg);
 
     graphics.m_buffer->Render();
+
+    // TEST
+    double arrowHalfWidth = halfWidth * arrowHeightFactor;
+    uniformStorage.SetFloatValue("u_halfWidth", arrowHalfWidth, arrowHalfWidth * screen.GetScale());
+    uniformStorage.SetFloatValue("u_textureRect", m_arrowTextureRect.minX(), m_arrowTextureRect.minY(),
+                                 m_arrowTextureRect.maxX(), m_arrowTextureRect.maxY());
+
+
+
+    m_turnPoints = { 0.0091, 0.0102 };
+    float const textureWidth = 2.0 * arrowHalfWidth * arrowAspect;
+    vector<ArrowBorders> arrowBorders;
+    CalculateArrowBorders(0.001, screen.GetScale(), textureWidth, arrowBorders);
+
+    size_t const elementsCount = 16;
+    vector<float> borders(elementsCount, 0.0);
+    size_t index = 0;
+    for (size_t i = 0; i < arrowBorders.size(); i++)
+    {
+      borders[index++] = arrowBorders[i].m_startDistance;
+      borders[index++] = arrowBorders[i].m_startTexCoord;
+      borders[index++] = arrowBorders[i].m_endDistance;
+      borders[index++] = arrowBorders[i].m_endTexCoord;
+
+      // fill rests by zeros
+      if (i == arrowBorders.size() - 1)
+      {
+         for (size_t j = index; j < elementsCount; j++)
+           borders[j] = 0.0;
+
+         index = elementsCount;
+      }
+
+      // render arrow's parts
+      if (index == elementsCount)
+      {
+        index = 0;
+        uniformStorage.SetMatrix4x4Value("u_arrowBorders", borders.data());
+
+        ref_ptr<dp::GpuProgram> prgArrow = mng->GetProgram(gpu::ROUTE_ARROW_PROGRAM);
+        prgArrow->Bind();
+        dp::ApplyState(graphics.m_state, prgArrow);
+        dp::ApplyUniforms(commonUniforms, prgArrow);
+        dp::ApplyUniforms(uniformStorage, prgArrow);
+        graphics.m_buffer->Render();
+      }
+    }
   }
 }
 
 void RouteRenderer::AddRouteRenderBucket(dp::GLState const & state, drape_ptr<dp::RenderBucket> && bucket,
-                                         dp::Color const & color, ref_ptr<dp::GpuProgramManager> mng)
+                                         dp::Color const & color,  m2::RectF const & arrowTextureRect,
+                                         ref_ptr<dp::GpuProgramManager> mng)
 {
   m_routeGraphics.push_back(RouteGraphics());
   RouteGraphics & route = m_routeGraphics.back();
@@ -78,6 +133,8 @@ void RouteRenderer::AddRouteRenderBucket(dp::GLState const & state, drape_ptr<dp
   route.m_color = color;
   route.m_buffer = bucket->MoveBuffer();
   route.m_buffer->Build(mng->GetProgram(route.m_state.GetProgramIndex()));
+
+  m_arrowTextureRect = arrowTextureRect;
 }
 
 void RouteRenderer::Clear()
@@ -87,7 +144,107 @@ void RouteRenderer::Clear()
 
 void RouteRenderer::UpdateDistanceFromBegin(double distanceFromBegin)
 {
-   m_distanceFromBegin = distanceFromBegin;
+  m_distanceFromBegin = distanceFromBegin;
+}
+
+void RouteRenderer::CalculateArrowBorders(double arrowLength, double scale,
+                                          float arrowTextureWidth, vector<ArrowBorders> & borders)
+{
+  if (m_turnPoints.empty())
+    return;
+
+  double const halfLen = 0.5 * arrowLength;
+
+  borders.reserve(m_turnPoints.size() * arrowPartsCount);
+
+  // initial filling
+  for (size_t i = 0; i < m_turnPoints.size(); i++)
+  {
+    ArrowBorders arrowBorders;
+    arrowBorders.m_groupIndex = (int)i;
+    arrowBorders.m_startDistance = m_turnPoints[i] - halfLen;
+    arrowBorders.m_endDistance = m_turnPoints[i] + halfLen;
+    borders.push_back(arrowBorders);
+  }
+
+  // mark groups
+  for (size_t i = 0; i < borders.size() - 1; i++)
+  {
+    if (borders[i].m_endDistance >= borders[i + 1].m_startDistance)
+      borders[i + 1].m_groupIndex = borders[i].m_groupIndex;
+  }
+
+  // merge groups
+  int lastGroup = 0;
+  size_t lastGroupIndex = 0;
+  for (size_t i = 1; i < borders.size(); i++)
+  {
+    if (borders[i].m_groupIndex != lastGroup)
+    {
+      borders[lastGroupIndex].m_endDistance = borders[i - 1].m_endDistance;
+      lastGroupIndex = i;
+      lastGroup = borders[i].m_groupIndex;
+    }
+    else
+    {
+      borders[i].m_groupIndex = -1;
+    }
+  }
+  borders[lastGroupIndex].m_endDistance = borders.back().m_endDistance;
+
+  // clip groups
+  auto const iter = remove_if(borders.begin(), borders.end(),
+                              [&scale, &arrowTextureWidth](ArrowBorders const & borders)
+  {
+      if (borders.m_groupIndex == -1)
+        return true;
+
+      double const distanceInPixels = (borders.m_endDistance - borders.m_startDistance) * 0.9 / scale;
+      return distanceInPixels < (arrowHeadSize + arrowTailSize) * arrowTextureWidth;
+  });
+  borders.erase(iter, borders.end());
+
+  // divide to parts of arrow
+  size_t const bordersSize = borders.size();
+
+  double const glbTextureWidth = arrowTextureWidth * scale;
+  for (size_t i = 0; i < bordersSize; i++)
+  {
+    float const startDistance = borders[i].m_startDistance;
+    float const endDistance = borders[i].m_endDistance;
+
+    borders[i].m_endDistance = startDistance + arrowTailSize * glbTextureWidth;
+    borders[i].m_startTexCoord = 0.0;
+    borders[i].m_endTexCoord = arrowTailSize;
+
+    ArrowBorders arrowHead;
+    arrowHead.m_startDistance = endDistance - arrowHeadSize * glbTextureWidth;
+    arrowHead.m_endDistance = endDistance;
+    arrowHead.m_startTexCoord = 1.0 - arrowHeadSize;
+    arrowHead.m_endTexCoord = 1.0;
+    borders.push_back(arrowHead);
+
+    ArrowBorders arrowBody;
+    arrowBody.m_startDistance = borders[i].m_endDistance;
+    arrowBody.m_endDistance = arrowHead.m_startDistance;
+    arrowBody.m_startTexCoord = borders[i].m_endTexCoord;
+    arrowBody.m_endTexCoord = arrowHead.m_startTexCoord;
+    borders.push_back(arrowBody);
+
+    /*for (int j = 1; j <= arrowPartsCount; j++)
+    {
+      ArrowBorders arrowBorders;
+      arrowBorders.m_startDistance = startDistance + arrowTextureParts[j - 1] * len;
+      arrowBorders.m_endDistance = startDistance + arrowTextureParts[j] * len;
+      arrowBorders.m_startTexCoord = arrowTextureParts[j - 1];
+      arrowBorders.m_endTexCoord = arrowTextureParts[j];
+
+      if (j == 1)
+        borders[i] = arrowBorders;
+      else
+        borders.push_back(arrowBorders);
+    }*/
+  }
 }
 
 } // namespace df
diff --git a/drape_frontend/route_renderer.hpp b/drape_frontend/route_renderer.hpp
index 3f830418c8..2967681d9e 100644
--- a/drape_frontend/route_renderer.hpp
+++ b/drape_frontend/route_renderer.hpp
@@ -23,6 +23,15 @@ struct RouteGraphics
   dp::Color m_color;
 };
 
+struct ArrowBorders
+{
+  double m_startDistance = 0;
+  double m_endDistance = 0;
+  float m_startTexCoord = 0;
+  float m_endTexCoord = 1;
+  int m_groupIndex = 0;
+};
+
 class RouteRenderer final
 {
 public:
@@ -32,15 +41,21 @@ public:
               dp::UniformValuesStorage const & commonUniforms);
 
   void AddRouteRenderBucket(dp::GLState const & state, drape_ptr<dp::RenderBucket> && bucket,
-                            dp::Color const & color, ref_ptr<dp::GpuProgramManager> mng);
+                            dp::Color const & color, m2::RectF const & arrowTextureRect,
+                            ref_ptr<dp::GpuProgramManager> mng);
 
   void Clear();
 
   void UpdateDistanceFromBegin(double distanceFromBegin);
 
 private:
+  void CalculateArrowBorders(double arrowLength, double scale,
+                             float arrowTextureWidth, vector<ArrowBorders> & borders);
+
   vector<RouteGraphics> m_routeGraphics;
   double m_distanceFromBegin;
+  m2::RectF m_arrowTextureRect;
+  vector<double> m_turnPoints;
 };
 
 } // namespace df
diff --git a/drape_frontend/route_shape.cpp b/drape_frontend/route_shape.cpp
index e7da939336..0c3e1a0213 100644
--- a/drape_frontend/route_shape.cpp
+++ b/drape_frontend/route_shape.cpp
@@ -2,13 +2,14 @@
 
 #include "drape_frontend/line_shape_helper.hpp"
 
-#include "drape/utils/vertex_decl.hpp"
-#include "drape/glsl_types.hpp"
-#include "drape/glsl_func.hpp"
-#include "drape/shader_def.hpp"
 #include "drape/attribute_provider.hpp"
-#include "drape/glstate.hpp"
 #include "drape/batcher.hpp"
+#include "drape/glsl_func.hpp"
+#include "drape/glsl_types.hpp"
+#include "drape/glstate.hpp"
+#include "drape/shader_def.hpp"
+#include "drape/texture_manager.hpp"
+#include "drape/utils/vertex_decl.hpp"
 
 #include "base/logging.hpp"
 
@@ -19,6 +20,15 @@ namespace
 {
   using RV = gpu::RouteVertex;
   using TGeometryBuffer = buffer_vector<gpu::RouteVertex, 128>;
+
+  float const LEFT_SIDE = 1.0;
+  float const CENTER = 0.0;
+  float const RIGHT_SIDE = -1.0;
+
+  void GetArrowTextureRegion(ref_ptr<dp::TextureManager> textures, dp::TextureManager::SymbolRegion & region)
+  {
+    textures->GetSymbolRegion("route-arrow", region);
+  }
 }
 
 RouteShape::RouteShape(m2::PolylineD const & polyline, CommonViewParams const & params)
@@ -26,22 +36,38 @@ RouteShape::RouteShape(m2::PolylineD const & polyline, CommonViewParams const &
   , m_polyline(polyline)
 {}
 
-void RouteShape::Draw(ref_ptr<dp::Batcher> batcher) const
+m2::RectF RouteShape::GetArrowTextureRect(ref_ptr<dp::TextureManager> textures) const
+{
+  dp::TextureManager::SymbolRegion region;
+  GetArrowTextureRegion(textures, region);
+  return region.GetTexRect();
+}
+
+void RouteShape::Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const
 {
   TGeometryBuffer geometry;
   TGeometryBuffer joinsGeometry;
   vector<m2::PointD> const & path = m_polyline.GetPoints();
   ASSERT(path.size() > 1, ());
 
+  dp::TextureManager::SymbolRegion region;
+  GetArrowTextureRegion(textures, region);
+
   auto const generateTriangles = [&](glsl::vec3 const & pivot, vector<glsl::vec2> const & normals,
-                                     glsl::vec2 const & length)
+                                     glsl::vec2 const & length, bool isLeft)
   {
+    const float eps = 1e-5;
     size_t const trianglesCount = normals.size() / 3;
+    float const side = isLeft ? LEFT_SIDE : RIGHT_SIDE;
     for (int j = 0; j < trianglesCount; j++)
     {
-      joinsGeometry.push_back(RV(pivot, normals[3 * j], length));
-      joinsGeometry.push_back(RV(pivot, normals[3 * j + 1], length));
-      joinsGeometry.push_back(RV(pivot, normals[3 * j + 2], length));
+      glsl::vec3 const len1 = glsl::vec3(length.x, length.y, glsl::length(normals[3 * j]) < eps ? CENTER : side);
+      glsl::vec3 const len2 = glsl::vec3(length.x, length.y, glsl::length(normals[3 * j + 1]) < eps ? CENTER : side);
+      glsl::vec3 const len3 = glsl::vec3(length.x, length.y, glsl::length(normals[3 * j + 2]) < eps ? CENTER : side);
+
+      joinsGeometry.push_back(RV(pivot, normals[3 * j], len1));
+      joinsGeometry.push_back(RV(pivot, normals[3 * j + 1], len2));
+      joinsGeometry.push_back(RV(pivot, normals[3 * j + 2], len3));
     }
   };
 
@@ -73,15 +99,15 @@ void RouteShape::Draw(ref_ptr<dp::Batcher> batcher) const
     float const projRightStart = -segments[i].m_rightWidthScalar[StartPoint].y;
     float const projRightEnd = segments[i].m_rightWidthScalar[EndPoint].y;
 
-    geometry.push_back(RV(startPivot, glsl::vec2(0, 0), glsl::vec2(length, 0)));
-    geometry.push_back(RV(startPivot, leftNormalStart, glsl::vec2(length, projLeftStart)));
-    geometry.push_back(RV(endPivot, glsl::vec2(0, 0), glsl::vec2(endLength, 0)));
-    geometry.push_back(RV(endPivot, leftNormalEnd, glsl::vec2(endLength, projLeftEnd)));
+    geometry.push_back(RV(startPivot, glsl::vec2(0, 0), glsl::vec3(length, 0, CENTER)));
+    geometry.push_back(RV(startPivot, leftNormalStart, glsl::vec3(length, projLeftStart, LEFT_SIDE)));
+    geometry.push_back(RV(endPivot, glsl::vec2(0, 0), glsl::vec3(endLength, 0, CENTER)));
+    geometry.push_back(RV(endPivot, leftNormalEnd, glsl::vec3(endLength, projLeftEnd, LEFT_SIDE)));
 
-    geometry.push_back(RV(startPivot, rightNormalStart, glsl::vec2(length, projRightStart)));
-    geometry.push_back(RV(startPivot, glsl::vec2(0, 0), glsl::vec2(length, 0)));
-    geometry.push_back(RV(endPivot, rightNormalEnd, glsl::vec2(endLength, projRightEnd)));
-    geometry.push_back(RV(endPivot, glsl::vec2(0, 0), glsl::vec2(endLength, 0)));
+    geometry.push_back(RV(startPivot, rightNormalStart, glsl::vec3(length, projRightStart, RIGHT_SIDE)));
+    geometry.push_back(RV(startPivot, glsl::vec2(0, 0), glsl::vec3(length, 0, CENTER)));
+    geometry.push_back(RV(endPivot, rightNormalEnd, glsl::vec3(endLength, projRightEnd, RIGHT_SIDE)));
+    geometry.push_back(RV(endPivot, glsl::vec2(0, 0), glsl::vec3(endLength, 0, CENTER)));
 
     // generate joins
     if (i < segments.size() - 1)
@@ -98,7 +124,8 @@ void RouteShape::Draw(ref_ptr<dp::Batcher> batcher) const
       normals.reserve(24);
       GenerateJoinNormals(dp::RoundJoin, n1, n2, 1.0f, segments[i].m_hasLeftJoin[EndPoint], widthScalar, normals);
 
-      generateTriangles(glsl::vec3(segments[i].m_points[EndPoint], m_params.m_depth), normals, glsl::vec2(endLength, 0));
+      generateTriangles(glsl::vec3(segments[i].m_points[EndPoint], m_params.m_depth), normals,
+                        glsl::vec2(endLength, 0), segments[i].m_hasLeftJoin[EndPoint]);
     }
 
     // generate caps
@@ -110,7 +137,8 @@ void RouteShape::Draw(ref_ptr<dp::Batcher> batcher) const
                          segments[i].m_rightNormals[StartPoint], -segments[i].m_tangent,
                          1.0f, true /* isStart */, normals);
 
-      generateTriangles(glsl::vec3(segments[i].m_points[StartPoint], m_params.m_depth), normals, glsl::vec2(length, 0));
+      generateTriangles(glsl::vec3(segments[i].m_points[StartPoint], m_params.m_depth), normals,
+                        glsl::vec2(length, 0), true);
     }
 
     if (i == segments.size() - 1)
@@ -121,13 +149,15 @@ void RouteShape::Draw(ref_ptr<dp::Batcher> batcher) const
                          segments[i].m_rightNormals[EndPoint], segments[i].m_tangent,
                          1.0f, false /* isStart */, normals);
 
-      generateTriangles(glsl::vec3(segments[i].m_points[EndPoint], m_params.m_depth), normals, glsl::vec2(endLength, 0));
+      generateTriangles(glsl::vec3(segments[i].m_points[EndPoint], m_params.m_depth), normals,
+                        glsl::vec2(endLength, 0), true);
     }
 
     length = endLength;
   }
 
   dp::GLState state(gpu::ROUTE_PROGRAM, dp::GLState::GeometryLayer);
+  state.SetColorTexture(region.GetTexture());
 
   dp::AttributeProvider provider(1, geometry.size());
   provider.InitStream(0, gpu::RouteVertex::GetBindingInfo(), make_ref(geometry.data()));
diff --git a/drape_frontend/route_shape.hpp b/drape_frontend/route_shape.hpp
index ec0632d615..1c8a9f0a36 100644
--- a/drape_frontend/route_shape.hpp
+++ b/drape_frontend/route_shape.hpp
@@ -14,9 +14,12 @@ public:
   RouteShape(m2::PolylineD const & polyline,
              CommonViewParams const & params);
 
-  void Draw(ref_ptr<dp::Batcher> batcher) const;
+  m2::RectF GetArrowTextureRect(ref_ptr<dp::TextureManager> textures) const;
+
+  void Draw(ref_ptr<dp::Batcher> batcher, ref_ptr<dp::TextureManager> textures) const;
 
 private:
+
   CommonViewParams m_params;
   m2::PolylineD m_polyline;
 };
diff --git a/drape_head/testing_engine.cpp b/drape_head/testing_engine.cpp
index d0b06d054f..9eef22fac4 100644
--- a/drape_head/testing_engine.cpp
+++ b/drape_head/testing_engine.cpp
@@ -525,7 +525,7 @@ void TestingEngine::DrawImpl()
 
     CommonViewParams rvp;
     rvp.m_depth = 95.0f;
-    RouteShape(pln, rvp).Draw(make_ref(m_batcher));
+    RouteShape(pln, rvp).Draw(make_ref(m_batcher), make_ref(m_textures));
   }
 
   {