diff --git a/drape/constants.hpp b/drape/constants.hpp
index 77623f2e8b..faf678b3c5 100644
--- a/drape/constants.hpp
+++ b/drape/constants.hpp
@@ -6,7 +6,7 @@ namespace dp
 {
 namespace depth
 {
-float constexpr kMyPositionMarkDepth = maxDepth - 1.0f;
+float constexpr kMyPositionMarkDepth = kMaxDepth - 1.0f;
 }  // namespace depth
 
 namespace displacement
diff --git a/drape/metal/metal_base_context.hpp b/drape/metal/metal_base_context.hpp
index f5bd6c5642..fd9055c543 100644
--- a/drape/metal/metal_base_context.hpp
+++ b/drape/metal/metal_base_context.hpp
@@ -4,10 +4,14 @@
 #include "drape/graphics_context.hpp"
 #include "drape/gpu_program.hpp"
 #include "drape/metal/metal_states.hpp"
+#include "drape/metal/metal_texture.hpp"
 #include "drape/pointers.hpp"
 #include "drape/texture_types.hpp"
 
+#include "geometry/point2d.hpp"
+
 #include <cstdint>
+#include <functional>
 
 namespace dp
 {
@@ -16,11 +20,16 @@ namespace metal
 class MetalBaseContext : public dp::GraphicsContext
 {
 public:
-  MetalBaseContext(id<MTLDevice> device, id<MTLTexture> depthStencilTexture);
+  using DrawableRequest = std::function<id<CAMetalDrawable>()>;
+  
+  MetalBaseContext(id<MTLDevice> device, m2::PointU const & screenSize,
+                   DrawableRequest && drawableRequest);
   
   void Present() override;
   void MakeCurrent() override {}
   void DoneCurrent() override {}
+  bool Validate() override { return true; }
+  void Resize(int w, int h) override;
   void SetFramebuffer(ref_ptr<dp::BaseFramebuffer> framebuffer) override;
   void ApplyFramebuffer(std::string const & framebufferLabel) override;
   void Init(ApiVersion apiVersion) override;
@@ -47,12 +56,14 @@ public:
                                       TextureWrapping wrapTMode);
   
 protected:
-  void SetFrameDrawable(id<CAMetalDrawable> drawable);
-  bool HasFrameDrawable() const;
+  void RecreateDepthTexture(m2::PointU const & screenSize);
+  void RequestFrameDrawable();
+  void ResetFrameDrawable();
   void FinishCurrentEncoding();
 
   id<MTLDevice> m_device;
-  id<MTLTexture> m_depthStencilTexture;
+  DrawableRequest m_drawableRequest;
+  drape_ptr<MetalTexture> m_depthTexture;
   MTLRenderPassDescriptor * m_renderPassDescriptor;
   id<MTLCommandQueue> m_commandQueue;
   ref_ptr<dp::BaseFramebuffer> m_currentFramebuffer;
diff --git a/drape/metal/metal_base_context.mm b/drape/metal/metal_base_context.mm
index 4895084c44..c36261569b 100644
--- a/drape/metal/metal_base_context.mm
+++ b/drape/metal/metal_base_context.mm
@@ -7,6 +7,7 @@
 #include "base/assert.hpp"
 
 #include <algorithm>
+#include <functional>
 #include <string>
 #include <vector>
 #include <utility>
@@ -15,9 +16,10 @@ namespace dp
 {
 namespace metal
 {
-MetalBaseContext::MetalBaseContext(id<MTLDevice> device, id<MTLTexture> depthStencilTexture)
+MetalBaseContext::MetalBaseContext(id<MTLDevice> device, m2::PointU const & screenSize,
+                                   DrawableRequest && drawableRequest)
   : m_device(device)
-  , m_depthStencilTexture(depthStencilTexture)
+  , m_drawableRequest(std::move(drawableRequest))
 {
   m_renderPassDescriptor = [MTLRenderPassDescriptor renderPassDescriptor];
   m_renderPassDescriptor.colorAttachments[0].loadAction = MTLLoadActionClear;
@@ -28,8 +30,27 @@ MetalBaseContext::MetalBaseContext(id<MTLDevice> device, id<MTLTexture> depthSte
   m_renderPassDescriptor.stencilAttachment.loadAction = MTLLoadActionClear;
   m_renderPassDescriptor.stencilAttachment.storeAction = MTLStoreActionStore;
   m_renderPassDescriptor.stencilAttachment.clearStencil = 0;
+  
+  RecreateDepthTexture(screenSize);
 }
-
+  
+void MetalBaseContext::RecreateDepthTexture(m2::PointU const & screenSize)
+{
+  if (screenSize.x == 0 || screenSize.y == 0)
+  {
+    m_depthTexture.reset();
+    return;
+  }
+  
+  m_depthTexture = make_unique_dp<MetalTexture>(nullptr /* allocator */);
+  HWTexture::Params params;
+  params.m_width = screenSize.x;
+  params.m_height = screenSize.y;
+  params.m_format = TextureFormat::Depth;
+  params.m_isRenderTarget = true;
+  m_depthTexture->Create(make_ref(this), params, nullptr /* data */);
+}
+  
 void MetalBaseContext::Init(dp::ApiVersion apiVersion)
 {
   CHECK(apiVersion == dp::ApiVersion::Metal, ());
@@ -83,6 +104,14 @@ std::string MetalBaseContext::GetRendererVersion() const
   }
   return "Unknown";
 }
+  
+void MetalBaseContext::Resize(int w, int h)
+{
+  if (m_depthTexture && m_depthTexture->GetWidth() == w && m_depthTexture->GetHeight() == h)
+    return;
+  
+  RecreateDepthTexture(m2::PointU(w, h));
+}
 
 void MetalBaseContext::SetFramebuffer(ref_ptr<dp::BaseFramebuffer> framebuffer)
 {
@@ -102,8 +131,9 @@ void MetalBaseContext::ApplyFramebuffer(std::string const & framebufferLabel)
   if (!m_currentFramebuffer)
   {
     // Use default(system) framebuffer and depth-stencil.
-    m_renderPassDescriptor.colorAttachments[0].texture = m_frameDrawable.texture;
-    m_renderPassDescriptor.depthAttachment.texture = m_depthStencilTexture;
+    RequestFrameDrawable();
+    m_renderPassDescriptor.colorAttachments[0].texture = m_frameDrawable != nil ? m_frameDrawable.texture : nil;
+    m_renderPassDescriptor.depthAttachment.texture = m_depthTexture ? m_depthTexture->GetTexture() : nil;
     m_renderPassDescriptor.stencilAttachment.texture = nil;
   }
   else
@@ -176,7 +206,7 @@ void MetalBaseContext::SetViewport(uint32_t x, uint32_t y, uint32_t w, uint32_t
   id<MTLRenderCommandEncoder> encoder = GetCommandEncoder();
   [encoder setViewport:(MTLViewport){ static_cast<double>(x), static_cast<double>(y),
                                       static_cast<double>(w), static_cast<double>(h),
-                                      -1.0, 1.0 }];
+                                      0.0, 1.0 }];
   [encoder setScissorRect:(MTLScissorRect){ x, y, w, h }];
 }
 
@@ -248,27 +278,35 @@ id<MTLSamplerState> MetalBaseContext::GetSamplerState(TextureFilter filter, Text
 void MetalBaseContext::Present()
 {
   FinishCurrentEncoding();
+  
+  RequestFrameDrawable();
   if (m_frameDrawable)
-  {
     [m_frameCommandBuffer presentDrawable:m_frameDrawable];
-    [m_frameCommandBuffer commit];
-  }
+  
+  [m_frameCommandBuffer commit];
   m_frameDrawable = nil;
   [m_frameCommandBuffer waitUntilCompleted];
   m_frameCommandBuffer = nil;
 }
   
-void MetalBaseContext::SetFrameDrawable(id<CAMetalDrawable> drawable)
+void MetalBaseContext::RequestFrameDrawable()
 {
-  CHECK(drawable != nil, ());
-  m_frameDrawable = drawable;
+  if (m_frameDrawable != nil)
+    return;
+  
+  CHECK(m_drawableRequest != nullptr, ());
+  m_frameDrawable = m_drawableRequest();
 }
   
-bool MetalBaseContext::HasFrameDrawable() const
+void MetalBaseContext::ResetFrameDrawable()
 {
-  return m_frameDrawable != nil;
-}
+  if (m_frameDrawable == nil)
+    return;
   
+  m_frameDrawable = nil;
+  RequestFrameDrawable();
+}
+
 void MetalBaseContext::FinishCurrentEncoding()
 {
   [m_currentCommandEncoder popDebugGroup];
@@ -276,4 +314,12 @@ void MetalBaseContext::FinishCurrentEncoding()
   m_currentCommandEncoder = nil;
 }
 }  // namespace metal
+
+void RenderFrameMediator(std::function<void()> && renderFrameFunction)
+{
+  @autoreleasepool
+  {
+    renderFrameFunction();
+  }
+}
 }  // namespace dp
diff --git a/drape/metal/metal_gpu_buffer_impl.mm b/drape/metal/metal_gpu_buffer_impl.mm
index fe16beb7f7..9197ef11c7 100644
--- a/drape/metal/metal_gpu_buffer_impl.mm
+++ b/drape/metal/metal_gpu_buffer_impl.mm
@@ -55,9 +55,17 @@ void MetalGPUBuffer::Resize(ref_ptr<MetalBaseContext> context, void const * data
   
   id<MTLDevice> device = context->GetMetalDevice();
   uint32_t const sizeInBytes = GetCapacity() * GetElementSize();
-  m_metalBuffer = [device newBufferWithBytes:data
-                                      length:sizeInBytes
-                                     options:MTLResourceCPUCacheModeWriteCombined];
+  if (data != nil)
+  {
+    m_metalBuffer = [device newBufferWithBytes:data
+                                        length:sizeInBytes
+                                       options:MTLResourceCPUCacheModeWriteCombined];
+  }
+  else
+  {
+    m_metalBuffer = [device newBufferWithLength:sizeInBytes
+                                       options:MTLResourceCPUCacheModeWriteCombined];
+  }
   
   // If we have already set up data, we have to call SetDataSize.
   if (data != nullptr)
diff --git a/drape/metal/metal_states.mm b/drape/metal/metal_states.mm
index f55a32f412..34145c89f7 100644
--- a/drape/metal/metal_states.mm
+++ b/drape/metal/metal_states.mm
@@ -278,7 +278,15 @@ bool MetalStates::PipelineKey::operator<(PipelineKey const & rhs) const
 MTLRenderPipelineDescriptor * MetalStates::PipelineKey::BuildDescriptor() const
 {
   MTLRenderPipelineDescriptor * desc = [[MTLRenderPipelineDescriptor alloc] init];
-  desc.rasterSampleCount = 1;
+  if (@available(iOS 11.0, *))
+  {
+    desc.rasterSampleCount = 1;
+    desc.vertexBuffers[0].mutability = MTLMutabilityImmutable;  // The first VB is always immutable.
+  }
+  else
+  {
+    desc.sampleCount = 1;
+  }
   ref_ptr<MetalGpuProgram> metalProgram = m_program;
   desc.vertexFunction = metalProgram->GetVertexShader();
   desc.fragmentFunction = metalProgram->GetFragmentShader();
diff --git a/drape/utils/projection.cpp b/drape/utils/projection.cpp
index 012a450414..497e61176f 100644
--- a/drape/utils/projection.cpp
+++ b/drape/utils/projection.cpp
@@ -2,20 +2,33 @@
 
 namespace dp
 {
-void MakeProjection(std::array<float, 16> & result, float left, float right, float bottom, float top)
+std::array<float, 16> MakeProjection(dp::ApiVersion apiVersion, float left, float right,
+                                     float bottom, float top)
 {
-  result.fill(0.0f);
+  std::array<float, 16> result = {};
 
-  float width = right - left;
-  float height = top - bottom;
-  float depth = maxDepth - minDepth;
+  // Projection matrix is calculated for [-1;1] depth-space, in some APIs (e.g. Metal)
+  // depth-space is [0;1], so we have to remap projection matrix.
+  float depthScale = 1.0f;
+  float depthOffset = 0.0f;
+  if (apiVersion == dp::ApiVersion::Metal)
+  {
+    depthScale = 0.5f;
+    depthOffset = 0.5f;
+  }
+
+  float const width = right - left;
+  float const height = top - bottom;
+  float const depth = kMaxDepth - kMinDepth;
 
   result[0] = 2.0f / width;
   result[3] = -(right + left) / width;
   result[5] = 2.0f / height;
   result[7] = -(top + bottom) / height;
-  result[10] = -2.0f / depth;
-  result[11] = -(maxDepth + minDepth) / depth;
+  result[10] = -2.0f * depthScale / depth;
+  result[11] = depthOffset - (kMaxDepth + kMinDepth) / depth;
   result[15] = 1.0;
+
+  return result;
 }
 }  // namespace dp
diff --git a/drape/utils/projection.hpp b/drape/utils/projection.hpp
index 2744bd23ff..d2c8946443 100644
--- a/drape/utils/projection.hpp
+++ b/drape/utils/projection.hpp
@@ -1,11 +1,14 @@
 #pragma once
 
+#include "drape/drape_global.hpp"
+
 #include <array>
 
 namespace dp
 {
-float constexpr minDepth = -20000.0f;
-float constexpr maxDepth = 20000.0f;
+float constexpr kMinDepth = -20000.0f;
+float constexpr kMaxDepth = 20000.0f;
 
-void MakeProjection(std::array<float, 16> & result, float left, float right, float bottom, float top);
+std::array<float, 16> MakeProjection(dp::ApiVersion apiVersion, float left, float right,
+                                     float bottom, float top);
 }  // namespace dp
diff --git a/drape_frontend/apply_feature_functors.cpp b/drape_frontend/apply_feature_functors.cpp
index ce3644f57c..662366154f 100644
--- a/drape_frontend/apply_feature_functors.cpp
+++ b/drape_frontend/apply_feature_functors.cpp
@@ -491,7 +491,7 @@ ApplyPointFeature::ApplyPointFeature(TileKey const & tileKey, TInsertShapeFn con
   , m_createdByEditor(false)
   , m_obsoleteInEditor(false)
   , m_depthLayer(depthLayer)
-  , m_symbolDepth(dp::minDepth)
+  , m_symbolDepth(dp::kMinDepth)
   , m_symbolRule(nullptr)
   , m_displacementMode(displacementMode)
 {}
diff --git a/drape_frontend/backend_renderer.cpp b/drape_frontend/backend_renderer.cpp
index 3ccff2c3a1..5ce46dafff 100644
--- a/drape_frontend/backend_renderer.cpp
+++ b/drape_frontend/backend_renderer.cpp
@@ -118,10 +118,6 @@ void BackendRenderer::RecacheChoosePositionMark()
 
 void BackendRenderer::AcceptMessage(ref_ptr<Message> message)
 {
-  // TODO: Temporary code.
-  if (m_apiVersion == dp::ApiVersion::Metal)
-    return;
-
   switch (message->GetType())
   {
   case Message::Type::UpdateReadManager:
diff --git a/drape_frontend/drape_api_renderer.cpp b/drape_frontend/drape_api_renderer.cpp
index eada7b3040..576b2000ac 100644
--- a/drape_frontend/drape_api_renderer.cpp
+++ b/drape_frontend/drape_api_renderer.cpp
@@ -58,7 +58,8 @@ void DrapeApiRenderer::Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu:
       program->Bind();
       dp::ApplyState(context, program, bucket.first);
 
-      if (bucket.first.GetProgram<gpu::Program>() == gpu::Program::TextOutlinedGui)
+      auto const p = bucket.first.GetProgram<gpu::Program>();
+      if (p == gpu::Program::TextOutlinedGui || p == gpu::Program::TextStaticOutlinedGui)
       {
         gpu::GuiProgramParams params;
         frameValues.SetTo(params);
diff --git a/drape_frontend/frontend_renderer.cpp b/drape_frontend/frontend_renderer.cpp
index 3b48b27f20..8e6c31c4f7 100755
--- a/drape_frontend/frontend_renderer.cpp
+++ b/drape_frontend/frontend_renderer.cpp
@@ -46,6 +46,16 @@
 
 using namespace std::placeholders;
 
+#if defined(OMIM_OS_IPHONE)
+namespace dp
+{
+extern void RenderFrameMediator(std::function<void()> && renderFrameFunction);
+}  // namespace dp
+#define RENDER_FRAME(renderFunction) dp::RenderFrameMediator([this]{ renderFunction; });
+#else
+#define RENDER_FRAME(renderFunction) renderFunction;
+#endif
+
 namespace df
 {
 namespace
@@ -103,8 +113,8 @@ struct RemoveTilePredicate
     return false;
   }
 };
-} // namespace
-
+}  // namespace
+  
 FrontendRenderer::FrontendRenderer(Params && params)
   : BaseRenderer(ThreadsCommutator::RenderThread, params)
   , m_trafficRenderer(new TrafficRenderer())
@@ -214,6 +224,7 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
   {
   case Message::Type::FlushTile:
     {
+      if (m_apiVersion == dp::ApiVersion::Metal) return; // TODO(@darina, @rokuz): TEMPORARY
       ref_ptr<FlushRenderBucketMessage> msg = message;
       dp::RenderState const & state = msg->GetState();
       TileKey const & key = msg->GetKey();
@@ -228,6 +239,7 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
 
   case Message::Type::FlushOverlays:
     {
+      if (m_apiVersion == dp::ApiVersion::Metal) return; // TODO(@darina, @rokuz): TEMPORARY
       ref_ptr<FlushOverlaysMessage> msg = message;
       TOverlaysRenderData renderData = msg->AcceptRenderData();
       for (auto & overlayRenderData : renderData)
@@ -253,6 +265,7 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
 
   case Message::Type::FinishTileRead:
     {
+      if (m_apiVersion == dp::ApiVersion::Metal) return; // TODO(@darina, @rokuz): TEMPORARY
       ref_ptr<FinishTileReadMessage> msg = message;
       bool changed = false;
       for (auto const & tileKey : msg->GetTiles())
@@ -289,6 +302,7 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
 
   case Message::Type::FlushUserMarks:
     {
+      if (m_apiVersion == dp::ApiVersion::Metal) return; // TODO(@darina, @rokuz): TEMPORARY
       ref_ptr<FlushUserMarksMessage> msg = message;
       TUserMarksRenderData marksRenderData = msg->AcceptRenderData();
       for (auto & renderData : marksRenderData)
@@ -345,6 +359,7 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
 
   case Message::Type::MapShapes:
     {
+      if (m_apiVersion == dp::ApiVersion::Metal) return; // TODO(@darina, @rokuz): TEMPORARY
       ref_ptr<MapShapesMessage> msg = message;
       CHECK(m_context != nullptr, ());
       m_myPositionController->SetRenderShape(m_context, m_texMng, msg->AcceptShape());
@@ -426,6 +441,7 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
 
   case Message::Type::FlushSubroute:
     {
+      if (m_apiVersion == dp::ApiVersion::Metal) return; // TODO(@darina, @rokuz): TEMPORARY
       ref_ptr<FlushSubrouteMessage> msg = message;
       auto subrouteData = msg->AcceptRenderData();
 
@@ -456,6 +472,7 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
 
   case Message::Type::FlushTransitScheme:
     {
+      if (m_apiVersion == dp::ApiVersion::Metal) return; // TODO(@darina, @rokuz): TEMPORARY
       ref_ptr<FlushTransitSchemeMessage > msg = message;
       auto renderData = msg->AcceptRenderData();
       CHECK(m_context != nullptr, ());
@@ -466,6 +483,7 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
 
   case Message::Type::FlushSubrouteArrows:
     {
+      if (m_apiVersion == dp::ApiVersion::Metal) return; // TODO(@darina, @rokuz): TEMPORARY
       ref_ptr<FlushSubrouteArrowsMessage> msg = message;
       drape_ptr<SubrouteArrowsData> routeArrowsData = msg->AcceptRenderData();
       if (CheckRouteRecaching(make_ref(routeArrowsData)))
@@ -479,6 +497,7 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
 
   case Message::Type::FlushSubrouteMarkers:
     {
+      if (m_apiVersion == dp::ApiVersion::Metal) return; // TODO(@darina, @rokuz): TEMPORARY
       ref_ptr<FlushSubrouteMarkersMessage> msg = message;
       drape_ptr<SubrouteMarkersData> markersData = msg->AcceptRenderData();
       if (markersData->m_recacheId < 0)
@@ -495,6 +514,7 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
 
   case Message::Type::RemoveSubroute:
     {
+      if (m_apiVersion == dp::ApiVersion::Metal) return; // TODO(@darina, @rokuz): TEMPORARY
       ref_ptr<RemoveSubrouteMessage> msg = message;
       if (msg->NeedDeactivateFollowing())
       {
@@ -544,6 +564,7 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
 
   case Message::Type::AddRoutePreviewSegment:
     {
+      if (m_apiVersion == dp::ApiVersion::Metal) return; // TODO(@darina, @rokuz): TEMPORARY
       ref_ptr<AddRoutePreviewSegmentMessage> const msg = message;
       RouteRenderer::PreviewInfo info;
       info.m_startPoint = msg->GetStartPoint();
@@ -554,6 +575,7 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
 
   case Message::Type::RemoveRoutePreviewSegment:
     {
+      if (m_apiVersion == dp::ApiVersion::Metal) return; // TODO(@darina, @rokuz): TEMPORARY
       ref_ptr<RemoveRoutePreviewSegmentMessage> const msg = message;
       if (msg->NeedRemoveAll())
         m_routeRenderer->RemoveAllPreviewSegments();
@@ -564,6 +586,7 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
 
   case Message::Type::SetSubrouteVisibility:
     {
+      if (m_apiVersion == dp::ApiVersion::Metal) return; // TODO(@darina, @rokuz): TEMPORARY
       ref_ptr<SetSubrouteVisibilityMessage> const msg = message;
       m_routeRenderer->SetSubrouteVisibility(msg->GetSubrouteId(), msg->IsVisible());
       break;
@@ -661,6 +684,7 @@ void FrontendRenderer::AcceptMessage(ref_ptr<Message> message)
 
   case Message::Type::FlushCirclesPack:
     {
+      if (m_apiVersion == dp::ApiVersion::Metal) return; // TODO(@darina, @rokuz): TEMPORARY
       ref_ptr<FlushCirclesPackMessage> msg = message;
       CHECK(m_context != nullptr, ());
       switch (msg->GetDestination())
@@ -1496,6 +1520,112 @@ void FrontendRenderer::RenderEmptyFrame()
 
   m_context->Present();
 }
+  
+void FrontendRenderer::RenderFrame()
+{
+  CHECK(m_context != nullptr, ());
+  if (!m_context->Validate())
+  {
+    m_frameData.m_forceFullRedrawNextFrame = true;
+    m_frameData.m_inactiveFramesCounter = 0;
+    return;
+  }
+
+  auto & scaleFpsHelper = gui::DrapeGui::Instance().GetScaleFpsHelper();
+  m_frameData.m_timer.Reset();
+
+  ScreenBase modelView = ProcessEvents(m_frameData.m_modelViewChanged, m_frameData.m_viewportChanged);
+  if (m_frameData.m_viewportChanged)
+    OnResize(modelView);
+
+  // Check for a frame is active.
+  bool isActiveFrame = m_frameData.m_modelViewChanged || m_frameData.m_viewportChanged;
+
+  if (isActiveFrame)
+    PrepareScene(modelView);
+
+  isActiveFrame |= m_texMng->UpdateDynamicTextures(m_context);
+  isActiveFrame |= m_userEventStream.IsWaitingForActionCompletion();
+  isActiveFrame |= InterpolationHolder::Instance().IsActive();
+
+  bool isActiveFrameForScene = isActiveFrame || m_frameData.m_forceFullRedrawNextFrame;
+  if (AnimationSystem::Instance().HasAnimations())
+  {
+    isActiveFrameForScene |= AnimationSystem::Instance().HasMapAnimations();
+    isActiveFrame = true;
+  }
+
+  m_routeRenderer->UpdatePreview(modelView);
+
+#ifdef SHOW_FRAMES_STATS
+  m_frameData.m_framesOverall += static_cast<uint64_t>(isActiveFrame);
+  m_frameData.m_framesFast += static_cast<uint64_t>(!isActiveFrameForScene);
+#endif
+
+  RenderScene(modelView, isActiveFrameForScene);
+
+  auto const hasForceUpdate = m_forceUpdateScene || m_forceUpdateUserMarks;
+  isActiveFrame |= hasForceUpdate;
+
+  if (m_frameData.m_modelViewChanged || hasForceUpdate)
+    UpdateScene(modelView);
+
+  InterpolationHolder::Instance().Advance(m_frameData.m_frameTime);
+  AnimationSystem::Instance().Advance(m_frameData.m_frameTime);
+
+  // On the first inactive frame we invalidate overlay tree.
+  if (!isActiveFrame)
+  {
+    if (m_frameData.m_inactiveFramesCounter == 0)
+      m_overlayTree->InvalidateOnNextFrame();
+    m_frameData.m_inactiveFramesCounter++;
+  }
+  else
+  {
+    m_frameData.m_inactiveFramesCounter = 0;
+  }
+
+  bool const canSuspend = m_frameData.m_inactiveFramesCounter > FrameData::kMaxInactiveFrames;
+  m_frameData.m_forceFullRedrawNextFrame = m_overlayTree->IsNeedUpdate();
+  if (canSuspend)
+  {
+    // Process a message or wait for a message.
+    // IsRenderingEnabled() can return false in case of rendering disabling and we must prevent
+    // possibility of infinity waiting in ProcessSingleMessage.
+    ProcessSingleMessage(IsRenderingEnabled());
+    m_frameData.m_forceFullRedrawNextFrame = true;
+    m_frameData.m_timer.Reset();
+    m_frameData.m_inactiveFramesCounter = 0;
+  }
+  else
+  {
+    auto availableTime = kVSyncInterval - m_frameData.m_timer.ElapsedSeconds();
+    do
+    {
+      if (!ProcessSingleMessage(false /* waitForMessage */))
+        break;
+      m_frameData.m_forceFullRedrawNextFrame = true;
+      m_frameData.m_inactiveFramesCounter = 0;
+      availableTime = kVSyncInterval - m_frameData.m_timer.ElapsedSeconds();
+    }
+    while (availableTime > 0.0);
+  }
+
+  m_context->Present();
+
+  // Limit fps in following mode.
+  double constexpr kFrameTime = 1.0 / 30.0;
+  auto const ft = m_frameData.m_timer.ElapsedSeconds();
+  if (!canSuspend && ft < kFrameTime && m_myPositionController->IsRouteFollowingActive())
+  {
+    auto const ms = static_cast<uint32_t>((kFrameTime - ft) * 1000);
+    std::this_thread::sleep_for(std::chrono::milliseconds(ms));
+  }
+
+  m_frameData.m_frameTime = m_frameData.m_timer.ElapsedSeconds();
+  scaleFpsHelper.SetFrameTime(m_frameData.m_frameTime,
+    m_frameData.m_inactiveFramesCounter + 1 < FrameData::kMaxInactiveFrames);
+}
 
 void FrontendRenderer::BuildOverlayTree(ScreenBase const & modelView)
 {
@@ -1541,8 +1671,7 @@ void FrontendRenderer::RenderSingleGroup(ref_ptr<dp::GraphicsContext> context,
 
 void FrontendRenderer::RefreshProjection(ScreenBase const & screen)
 {
-  std::array<float, 16> m;
-  dp::MakeProjection(m, 0.0f, screen.GetWidth(), screen.GetHeight(), 0.0f);
+  auto m = dp::MakeProjection(m_apiVersion, 0.0f, screen.GetWidth(), screen.GetHeight(), 0.0f);
   m_frameValues.m_projection = glsl::make_mat4(m.data());
 }
 
@@ -1977,14 +2106,6 @@ void FrontendRenderer::Routine::Do()
 
   m_renderer.OnContextCreate();
 
-  base::Timer timer;
-  double frameTime = 0.0;
-  bool modelViewChanged = true;
-  bool viewportChanged = true;
-  uint32_t inactiveFramesCounter = 0;
-  bool forceFullRedrawNextFrame = false;
-  uint32_t constexpr kMaxInactiveFrames = 2;
-
   auto & scaleFpsHelper = gui::DrapeGui::Instance().GetScaleFpsHelper();
 #ifdef DEBUG
   scaleFpsHelper.SetVisible(true);
@@ -1993,120 +2114,17 @@ void FrontendRenderer::Routine::Do()
   m_renderer.ScheduleOverlayCollecting();
 
 #ifdef SHOW_FRAMES_STATS
-  uint64_t framesOverall = 0;
-  uint64_t framesFast = 0;
-
   m_renderer.m_notifier->Notify(ThreadsCommutator::RenderThread, std::chrono::seconds(5),
-                                true /* repeating */, [&framesOverall, &framesFast](uint64_t)
+                                true /* repeating */, [this](uint64_t)
   {
-    LOG(LINFO, ("framesOverall =", framesOverall, "framesFast =", framesFast));
+    LOG(LINFO, ("framesOverall =", m_renderer.m_frameData.m_framesOverall,
+                "framesFast =", m_renderer.m_frameData.m_framesFast));
   });
 #endif
 
   while (!IsCancelled())
   {
-    CHECK(m_renderer.m_context != nullptr, ());
-    if (m_renderer.m_context->Validate())
-    {
-      timer.Reset();
-
-      ScreenBase modelView = m_renderer.ProcessEvents(modelViewChanged, viewportChanged);
-      if (viewportChanged)
-        m_renderer.OnResize(modelView);
-
-      // Check for a frame is active.
-      bool isActiveFrame = modelViewChanged || viewportChanged;
-
-      if (isActiveFrame)
-        m_renderer.PrepareScene(modelView);
-
-      isActiveFrame |= m_renderer.m_texMng->UpdateDynamicTextures(m_renderer.m_context);
-      isActiveFrame |= m_renderer.m_userEventStream.IsWaitingForActionCompletion();
-      isActiveFrame |= InterpolationHolder::Instance().IsActive();
-
-      bool isActiveFrameForScene = isActiveFrame || forceFullRedrawNextFrame;
-      if (AnimationSystem::Instance().HasAnimations())
-      {
-        isActiveFrameForScene |= AnimationSystem::Instance().HasMapAnimations();
-        isActiveFrame = true;
-      }
-
-      m_renderer.m_routeRenderer->UpdatePreview(modelView);
-
-#ifdef SHOW_FRAMES_STATS
-      framesOverall += static_cast<uint64_t>(isActiveFrame);
-      framesFast += static_cast<uint64_t>(!isActiveFrameForScene);
-#endif
-
-      m_renderer.RenderScene(modelView, isActiveFrameForScene);
-
-      auto const hasForceUpdate = m_renderer.m_forceUpdateScene || m_renderer.m_forceUpdateUserMarks;
-      isActiveFrame |= hasForceUpdate;
-
-      if (modelViewChanged || hasForceUpdate)
-        m_renderer.UpdateScene(modelView);
-
-      InterpolationHolder::Instance().Advance(frameTime);
-      AnimationSystem::Instance().Advance(frameTime);
-
-      // On the first inactive frame we invalidate overlay tree.
-      if (!isActiveFrame)
-      {
-        if (inactiveFramesCounter == 0)
-          m_renderer.m_overlayTree->InvalidateOnNextFrame();
-        inactiveFramesCounter++;
-      }
-      else
-      {
-        inactiveFramesCounter = 0;
-      }
-
-      bool const canSuspend = inactiveFramesCounter > kMaxInactiveFrames;
-      forceFullRedrawNextFrame = m_renderer.m_overlayTree->IsNeedUpdate();
-      if (canSuspend)
-      {
-        // Process a message or wait for a message.
-        // IsRenderingEnabled() can return false in case of rendering disabling and we must prevent
-        // possibility of infinity waiting in ProcessSingleMessage.
-        m_renderer.ProcessSingleMessage(m_renderer.IsRenderingEnabled());
-        forceFullRedrawNextFrame = true;
-        timer.Reset();
-        inactiveFramesCounter = 0;
-      }
-      else
-      {
-        auto availableTime = kVSyncInterval - timer.ElapsedSeconds();
-        do
-        {
-          if (!m_renderer.ProcessSingleMessage(false /* waitForMessage */))
-            break;
-          forceFullRedrawNextFrame = true;
-          inactiveFramesCounter = 0;
-          availableTime = kVSyncInterval - timer.ElapsedSeconds();
-        }
-        while (availableTime > 0.0);
-      }
-
-      m_renderer.m_context->Present();
-
-      // Limit fps in following mode.
-      double constexpr kFrameTime = 1.0 / 30.0;
-      auto const ft = timer.ElapsedSeconds();
-      if (!canSuspend && ft < kFrameTime &&
-          m_renderer.m_myPositionController->IsRouteFollowingActive())
-      {
-        auto const ms = static_cast<uint32_t>((kFrameTime - ft) * 1000);
-        std::this_thread::sleep_for(std::chrono::milliseconds(ms));
-      }
-
-      frameTime = timer.ElapsedSeconds();
-      scaleFpsHelper.SetFrameTime(frameTime, inactiveFramesCounter + 1 < kMaxInactiveFrames);
-    }
-    else
-    {
-      forceFullRedrawNextFrame = true;
-      inactiveFramesCounter = 0;
-    }
+    RENDER_FRAME(m_renderer.RenderFrame());
     m_renderer.CheckRenderingEnabled();
   }
 
@@ -2121,7 +2139,7 @@ void FrontendRenderer::ReleaseResources()
 
   m_guiRenderer.reset();
   m_myPositionController.reset();
-  m_selectionShape.release();
+  m_selectionShape.reset();
   m_routeRenderer.reset();
   m_buildingsFramebuffer.reset();
   m_screenQuadRenderer.reset();
diff --git a/drape_frontend/frontend_renderer.hpp b/drape_frontend/frontend_renderer.hpp
index a4b63d34bb..568979769a 100755
--- a/drape_frontend/frontend_renderer.hpp
+++ b/drape_frontend/frontend_renderer.hpp
@@ -171,6 +171,7 @@ private:
   void RenderSearchMarksLayer(ScreenBase const & modelView);
   void RenderTransitBackground();
   void RenderEmptyFrame();
+  void RenderFrame();
 
   bool HasTransitRouteData() const;
   bool HasRouteData() const;
@@ -349,6 +350,22 @@ private:
 
   drape_ptr<DrapeNotifier> m_notifier;
 
+  struct FrameData
+  {
+    base::Timer m_timer;
+    double m_frameTime = 0.0;
+    bool m_modelViewChanged = true;
+    bool m_viewportChanged = true;
+    uint32_t m_inactiveFramesCounter = 0;
+    bool m_forceFullRedrawNextFrame = false;
+#ifdef SHOW_FRAMES_STATS
+    uint64_t m_framesOverall = 0;
+    uint64_t m_framesFast = 0;
+#endif
+    static uint32_t constexpr kMaxInactiveFrames = 2;
+  };
+  FrameData m_frameData;
+
 #ifdef DEBUG
   bool m_isTeardowned;
 #endif
diff --git a/drape_frontend/gui/gui_text.cpp b/drape_frontend/gui/gui_text.cpp
index e698c96992..f2f2f1bb66 100644
--- a/drape_frontend/gui/gui_text.cpp
+++ b/drape_frontend/gui/gui_text.cpp
@@ -106,7 +106,7 @@ dp::BindingInfo const & StaticLabel::Vertex::GetBindingInfo()
 }
 
 StaticLabel::LabelResult::LabelResult()
-  : m_state(df::CreateRenderState(gpu::Program::TextOutlinedGui, df::DepthLayer::GuiLayer))
+  : m_state(df::CreateRenderState(gpu::Program::TextStaticOutlinedGui, df::DepthLayer::GuiLayer))
 {
   m_state.SetDepthTestEnabled(false);
 }
@@ -483,7 +483,7 @@ void MutableLabelHandle::GetAttributeMutation(ref_ptr<dp::AttributeBufferMutator
   uint32_t byteCount =
       static_cast<uint32_t>(result.m_buffer.size()) * sizeof(MutableLabel::DynamicVertex);
 
-  MutableLabel::DynamicVertex * dataPointer =
+  auto dataPointer =
       reinterpret_cast<MutableLabel::DynamicVertex *>(mutator->AllocateMutationBuffer(byteCount));
   copy(result.m_buffer.begin(), result.m_buffer.end(), dataPointer);
 
diff --git a/drape_frontend/gui/shape.cpp b/drape_frontend/gui/shape.cpp
index 2bf3183a20..3cacc28d96 100644
--- a/drape_frontend/gui/shape.cpp
+++ b/drape_frontend/gui/shape.cpp
@@ -90,10 +90,9 @@ void ShapeRenderer::Build(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::Pro
 void ShapeRenderer::Render(ref_ptr<dp::GraphicsContext> context, ref_ptr<gpu::ProgramManager> mng,
                            ScreenBase const & screen)
 {
-  std::array<float, 16> m = {};
   m2::RectD const & pxRect = screen.PixelRectIn3d();
-  dp::MakeProjection(m, 0.0f, static_cast<float>(pxRect.SizeX()),
-                     static_cast<float>(pxRect.SizeY()), 0.0f);
+  auto m = dp::MakeProjection(context->GetApiVersion(), 0.0f, static_cast<float>(pxRect.SizeX()),
+                              static_cast<float>(pxRect.SizeY()), 0.0f);
   glsl::mat4 const projection = glsl::make_mat4(m.data());
 
   ForEachShapeInfo([&projection, &screen, context, mng](ShapeControl::ShapeInfo & info) mutable
diff --git a/drape_frontend/postprocess_renderer.cpp b/drape_frontend/postprocess_renderer.cpp
index 9e5bbc6fb0..35f2df7ec2 100644
--- a/drape_frontend/postprocess_renderer.cpp
+++ b/drape_frontend/postprocess_renderer.cpp
@@ -185,7 +185,9 @@ void PostprocessRenderer::SetStaticTextures(drape_ptr<PostprocessStaticTextures>
 bool PostprocessRenderer::IsEnabled() const
 {
   // Do not use post processing in routing following mode by energy-saving reasons.
-  if (m_isRouteFollowingActive)
+  // For Metal rendering to the texture is more efficient,
+  // since nextDrawable will be requested later.
+  if (m_apiVersion != dp::ApiVersion::Metal && m_isRouteFollowingActive)
     return false;
 
   return IsSupported(m_mainFramebuffer);
@@ -195,7 +197,7 @@ void PostprocessRenderer::SetEffectEnabled(ref_ptr<dp::GraphicsContext> context,
                                            Effect effect, bool enabled)
 {
   // Do not support AA for OpenGLES 2.0.
-  if (context->GetApiVersion() == dp::ApiVersion::OpenGLES2 && effect == Effect::Antialiasing)
+  if (m_apiVersion == dp::ApiVersion::OpenGLES2 && effect == Effect::Antialiasing)
     return;
 
   auto const oldValue = m_effects;
@@ -379,15 +381,15 @@ void PostprocessRenderer::UpdateFramebuffers(ref_ptr<dp::GraphicsContext> contex
   ASSERT_NOT_EQUAL(width, 0, ());
   ASSERT_NOT_EQUAL(height, 0, ());
 
-  auto const apiVersion = context->GetApiVersion();
+  CHECK_EQUAL(m_apiVersion, context->GetApiVersion(), ());
   InitFramebuffer(context, m_mainFramebuffer, width, height, true /* depthEnabled */,
-                  apiVersion != dp::ApiVersion::OpenGLES2 /* stencilEnabled */);
+                  m_apiVersion != dp::ApiVersion::OpenGLES2 /* stencilEnabled */);
   m_isMainFramebufferRendered = false;
 
   m_isSmaaFramebufferRendered = false;
   if (!m_isRouteFollowingActive && IsEffectEnabled(Effect::Antialiasing))
   {
-    CHECK_NOT_EQUAL(apiVersion, dp::ApiVersion::OpenGLES2, ());
+    CHECK_NOT_EQUAL(m_apiVersion, dp::ApiVersion::OpenGLES2, ());
 
     InitFramebuffer(context, m_edgesFramebuffer, dp::TextureFormat::RedGreen,
                     m_mainFramebuffer->GetDepthStencilRef(),
diff --git a/iphone/Maps/Classes/EAGLView.h b/iphone/Maps/Classes/EAGLView.h
index 40f278c663..098987019c 100644
--- a/iphone/Maps/Classes/EAGLView.h
+++ b/iphone/Maps/Classes/EAGLView.h
@@ -32,7 +32,5 @@ namespace dp
 - (void)createDrapeEngine;
 - (void)deallocateNative;
 - (void)setPresentAvailable:(BOOL)available;
-- (CGPoint)viewPoint2GlobalPoint:(CGPoint)pt;
-- (CGPoint)globalPoint2ViewPoint:(CGPoint)pt;
 
 @end
diff --git a/iphone/Maps/Classes/EAGLView.mm b/iphone/Maps/Classes/EAGLView.mm
index e183908b82..6907acbf70 100644
--- a/iphone/Maps/Classes/EAGLView.mm
+++ b/iphone/Maps/Classes/EAGLView.mm
@@ -89,12 +89,13 @@ double getExactDPI(double contentScaleFactor)
 
 - (void)createDrapeEngine
 {
+  m2::PointU const s = [self pixelSize];
   if (m_apiVersion == dp::ApiVersion::Metal)
   {
     CHECK(self.metalView != nil, ());
     CHECK_EQUAL(self.bounds.size.width, self.metalView.bounds.size.width, ());
     CHECK_EQUAL(self.bounds.size.height, self.metalView.bounds.size.height, ());
-    m_factory = make_unique_dp<MetalContextFactory>(self.metalView);
+    m_factory = make_unique_dp<MetalContextFactory>(self.metalView, s);
   }
   else
   {
@@ -102,8 +103,6 @@ double getExactDPI(double contentScaleFactor)
     m_factory = make_unique_dp<dp::ThreadSafeFactory>(
                   new iosOGLContextFactory(eaglLayer, m_apiVersion, m_presentAvailable));
   }
-  
-  m2::PointU const s = [self pixelSize];
   [self createDrapeEngineWithWidth:s.x height:s.y];
 }
 
@@ -166,20 +165,6 @@ double getExactDPI(double contentScaleFactor)
   m_factory.reset();
 }
 
-- (CGPoint)viewPoint2GlobalPoint:(CGPoint)pt
-{
-  CGFloat const scaleFactor = self.contentScaleFactor;
-  m2::PointD const ptG = GetFramework().PtoG(m2::PointD(pt.x * scaleFactor, pt.y * scaleFactor));
-  return CGPointMake(ptG.x, ptG.y);
-}
-
-- (CGPoint)globalPoint2ViewPoint:(CGPoint)pt
-{
-  CGFloat const scaleFactor = self.contentScaleFactor;
-  m2::PointD const ptP = GetFramework().GtoP(m2::PointD(pt.x, pt.y));
-  return CGPointMake(ptP.x / scaleFactor, ptP.y / scaleFactor);
-}
-
 - (void)setPresentAvailable:(BOOL)available
 {
   m_presentAvailable = available;
diff --git a/iphone/Maps/Classes/MetalContextFactory.h b/iphone/Maps/Classes/MetalContextFactory.h
index 981a8c32bc..246f587ff3 100644
--- a/iphone/Maps/Classes/MetalContextFactory.h
+++ b/iphone/Maps/Classes/MetalContextFactory.h
@@ -8,7 +8,7 @@
 class MetalContextFactory: public dp::GraphicsContextFactory
 {
 public:
-  explicit MetalContextFactory(MetalView * metalView);
+  MetalContextFactory(MetalView * metalView, m2::PointU const & screenSize);
   dp::GraphicsContext * GetDrawContext() override;
   dp::GraphicsContext * GetResourcesUploadContext() override;
   bool IsDrawContextCreated() const override { return true; }
diff --git a/iphone/Maps/Classes/MetalContextFactory.mm b/iphone/Maps/Classes/MetalContextFactory.mm
index 160de400d8..35333cea3c 100644
--- a/iphone/Maps/Classes/MetalContextFactory.mm
+++ b/iphone/Maps/Classes/MetalContextFactory.mm
@@ -7,19 +7,16 @@ namespace
 class DrawMetalContext : public dp::metal::MetalBaseContext
 {
 public:
-  DrawMetalContext(CAMetalLayer * metalLayer, id<MTLTexture> depthStencilTexture)
-    : dp::metal::MetalBaseContext(metalLayer.device, depthStencilTexture)
+  DrawMetalContext(CAMetalLayer * metalLayer, m2::PointU const & screenSize)
+    : dp::metal::MetalBaseContext(metalLayer.device, screenSize, [this]{ return [m_metalLayer nextDrawable]; })
     , m_metalLayer(metalLayer)
   {}
   
-  bool Validate() override
+  void Resize(int w, int h) override
   {
-    if (HasFrameDrawable())
-      return true;
-    
-    id<CAMetalDrawable> drawable = [m_metalLayer nextDrawable];
-    SetFrameDrawable(drawable);
-    return drawable != nil;
+    m_metalLayer.drawableSize = CGSize{static_cast<float>(w), static_cast<float>(h)};
+    ResetFrameDrawable();
+    dp::metal::MetalBaseContext::Resize(w, h);
   }
   
 private:
@@ -30,17 +27,17 @@ class UploadMetalContext : public dp::metal::MetalBaseContext
 {
 public:
   explicit UploadMetalContext(id<MTLDevice> device)
-    : dp::metal::MetalBaseContext(device, nil)
+    : dp::metal::MetalBaseContext(device, {}, nullptr)
   {}
   
   void Present() override {}
   void MakeCurrent() override {}
+  void Resize(int w, int h) override {}
   void SetFramebuffer(ref_ptr<dp::BaseFramebuffer> framebuffer) override {}
   void Init(dp::ApiVersion apiVersion) override
   {
     CHECK_EQUAL(apiVersion, dp::ApiVersion::Metal, ());
   }
-  bool Validate() override { return true; }
   
   void SetClearColor(dp::Color const & color) override {}
   void Clear(uint32_t clearBits) override {}
@@ -54,10 +51,10 @@ public:
 };
 }  // namespace
 
-MetalContextFactory::MetalContextFactory(MetalView * metalView)
+MetalContextFactory::MetalContextFactory(MetalView * metalView, m2::PointU const & screenSize)
 {
   CAMetalLayer * metalLayer = (CAMetalLayer *)metalView.layer;
-  m_drawContext = make_unique_dp<DrawMetalContext>(metalLayer, metalView.depthStencilTexture);
+  m_drawContext = make_unique_dp<DrawMetalContext>(metalLayer, screenSize);
   m_uploadContext = make_unique_dp<UploadMetalContext>(m_drawContext->GetMetalDevice());
 }
 
diff --git a/iphone/Maps/Classes/MetalView.mm b/iphone/Maps/Classes/MetalView.mm
index 750014e366..b71634cee8 100644
--- a/iphone/Maps/Classes/MetalView.mm
+++ b/iphone/Maps/Classes/MetalView.mm
@@ -29,6 +29,7 @@
   self.paused = TRUE;
   self.enableSetNeedsDisplay = FALSE;
   self.clearColor = MTLClearColorMake(0.0, 0.0, 0.0, 0.0);
+  self.contentScaleFactor = [[UIScreen mainScreen] nativeScale];
 }
 
 @end
diff --git a/shaders/GL/shader_index.txt b/shaders/GL/shader_index.txt
index 2514ad6075..a984dca95c 100644
--- a/shaders/GL/shader_index.txt
+++ b/shaders/GL/shader_index.txt
@@ -6,6 +6,7 @@ BookmarkAnim user_mark.vsh.glsl user_mark.fsh.glsl
 TextOutlined text_outlined.vsh.glsl text.fsh.glsl
 Text text.vsh.glsl text.fsh.glsl
 TextFixed text.vsh.glsl text_fixed.fsh.glsl
+TextStaticOutlinedGui text_outlined_gui.vsh.glsl text.fsh.glsl
 TextOutlinedGui text_outlined_gui.vsh.glsl text.fsh.glsl
 Area area.vsh.glsl solid_color.fsh.glsl
 AreaOutline area.vsh.glsl solid_color.fsh.glsl
diff --git a/shaders/GL/text_outlined_gui.vsh.glsl b/shaders/GL/text_outlined_gui.vsh.glsl
index 79d154ae48..b1732f8085 100755
--- a/shaders/GL/text_outlined_gui.vsh.glsl
+++ b/shaders/GL/text_outlined_gui.vsh.glsl
@@ -1,4 +1,4 @@
-attribute vec4 a_position;
+attribute vec3 a_position;
 attribute vec2 a_normal;
 attribute vec2 a_colorTexCoord;
 attribute vec2 a_outlineColorTexCoord;
@@ -24,7 +24,7 @@ void main()
   float isOutline = step(0.5, u_isOutlinePass);
   float depthShift = kBaseDepthShift * isOutline;
   
-  vec4 pos = (vec4(a_position.xyz, 1.0) + vec4(0.0, 0.0, depthShift, 0.0)) * u_modelView;
+  vec4 pos = (vec4(a_position, 1.0) + vec4(0.0, 0.0, depthShift, 0.0)) * u_modelView;
   vec4 shiftedPos = vec4(a_normal, 0.0, 0.0) + pos;
   gl_Position = shiftedPos * u_projection;
   vec2 colorTexCoord = mix(a_colorTexCoord, a_outlineColorTexCoord, isOutline);
diff --git a/shaders/Metal/debug_rect.metal b/shaders/Metal/debug_rect.metal
index d6e3a1eb99..206be760be 100644
--- a/shaders/Metal/debug_rect.metal
+++ b/shaders/Metal/debug_rect.metal
@@ -18,7 +18,7 @@ typedef struct
 } Uniforms_T;
 
 vertex Fragment_T vsDebugRect(device const Vertex_T * vertices [[buffer(0)]],
-                              uint vid [[vertex_id]])
+                              ushort vid [[vertex_id]])
 {
   Fragment_T out;
   out.position = float4(vertices[vid].a_position, 0.0, 1.0);
diff --git a/shaders/Metal/gui.metal b/shaders/Metal/gui.metal
new file mode 100644
index 0000000000..4214718c0f
--- /dev/null
+++ b/shaders/Metal/gui.metal
@@ -0,0 +1,171 @@
+#include <metal_stdlib>
+#include <simd/simd.h>
+using namespace metal;
+
+typedef struct
+{
+  float4x4 u_modelView;
+  float4x4 u_projection;
+  packed_float2 u_contrastGamma;
+  packed_float2 u_position;
+  float u_isOutlinePass;
+  float u_opacity;
+  float u_length;
+} Uniforms_T;
+
+// Ruler
+
+typedef struct
+{
+  packed_float2 a_position;
+  packed_float2 a_normal;
+  packed_float2 a_texCoords;
+} RulerVertex_T;
+
+typedef struct
+{
+  float4 position [[position]];
+  float2 texCoords;
+} RulerFragment_T;
+
+vertex RulerFragment_T vsRuler(device const RulerVertex_T * vertices [[buffer(0)]],
+                               constant Uniforms_T & uniforms [[buffer(1)]],
+                               ushort vid [[vertex_id]])
+{
+  RulerVertex_T const in = vertices[vid];
+  RulerFragment_T out;
+  float2 p = uniforms.u_position + in.a_position + uniforms.u_length * in.a_normal;
+  out.position = float4(p, 0.0, 1.0) * uniforms.u_projection;
+  out.texCoords = in.a_texCoords;
+  return out;
+}
+
+fragment float4 fsRuler(const RulerFragment_T in [[stage_in]],
+                        constant Uniforms_T & uniforms [[buffer(0)]],
+                        texture2d<float> u_colorTex [[texture(0)]],
+                        sampler u_colorTexSampler [[sampler(0)]])
+{
+  float4 color = u_colorTex.sample(u_colorTexSampler, in.texCoords);
+  color.a *= uniforms.u_opacity;
+  return color;
+}
+
+// TextStaticOutlinedGui / TextOutlinedGui
+
+typedef struct
+{
+  packed_float3 a_position;
+  packed_float2 a_normal;
+  packed_float2 a_colorTexCoord;
+  packed_float2 a_outlineColorTexCoord;
+  packed_float2 a_maskTexCoord;
+} TextStaticOutlinedGuiVertex_T;
+
+typedef struct
+{
+  packed_float3 a_position;
+  packed_float2 a_colorTexCoord;
+  packed_float2 a_outlineColorTexCoord;
+} TextOutlinedGuiVertex0_T;
+
+typedef struct
+{
+  packed_float2 a_normal;
+  packed_float2 a_maskTexCoord;
+} TextOutlinedGuiVertex1_T;
+
+typedef struct
+{
+  float4 position [[position]];
+  float2 colorTexCoords;
+  float2 maskTexCoord;
+} TextOutlinedGuiFragment_T;
+
+TextOutlinedGuiFragment_T ComputeTextOutlinedGuiVertex(constant Uniforms_T & uniforms, float3 a_position, float2 a_normal,
+                                                       float2 a_colorTexCoord, float2 a_outlineColorTexCoord,
+                                                       float2 a_maskTexCoord)
+{
+  constexpr float kBaseDepthShift = -10.0;
+  
+  TextOutlinedGuiFragment_T out;
+  
+  float isOutline = step(0.5, uniforms.u_isOutlinePass);
+  float depthShift = kBaseDepthShift * isOutline;
+  
+  float4 pos = (float4(a_position, 1.0) + float4(0.0, 0.0, depthShift, 0.0)) * uniforms.u_modelView;
+  float4 shiftedPos = float4(a_normal, 0.0, 0.0) + pos;
+  out.position = shiftedPos * uniforms.u_projection;
+  out.colorTexCoords = mix(a_colorTexCoord, a_outlineColorTexCoord, isOutline);
+  out.maskTexCoord = a_maskTexCoord;
+  return out;
+}
+
+vertex TextOutlinedGuiFragment_T vsTextStaticOutlinedGui(device const TextStaticOutlinedGuiVertex_T * vertices [[buffer(0)]],
+                                                         constant Uniforms_T & uniforms [[buffer(1)]],
+                                                         ushort vid [[vertex_id]])
+{
+  TextStaticOutlinedGuiVertex_T const in = vertices[vid];
+  return ComputeTextOutlinedGuiVertex(uniforms, in.a_position, in.a_normal, in.a_colorTexCoord, in.a_outlineColorTexCoord,
+                                      in.a_maskTexCoord);
+}
+
+vertex TextOutlinedGuiFragment_T vsTextOutlinedGui(device const TextOutlinedGuiVertex0_T * vertices0 [[buffer(0)]],
+                                                   device const TextOutlinedGuiVertex1_T * vertices1 [[buffer(1)]],
+                                                   constant Uniforms_T & uniforms [[buffer(2)]],
+                                                   ushort vid [[vertex_id]])
+{
+  TextOutlinedGuiVertex0_T const in0 = vertices0[vid];
+  TextOutlinedGuiVertex1_T const in1 = vertices1[vid];
+  return ComputeTextOutlinedGuiVertex(uniforms, in0.a_position, in1.a_normal, in0.a_colorTexCoord,
+                                      in0.a_outlineColorTexCoord, in1.a_maskTexCoord);
+}
+
+fragment float4 fsTextOutlinedGui(const TextOutlinedGuiFragment_T in [[stage_in]],
+                                  constant Uniforms_T & uniforms [[buffer(0)]],
+                                  texture2d<float> u_colorTex [[texture(0)]],
+                                  sampler u_colorTexSampler [[sampler(0)]],
+                                  texture2d<float> u_maskTex [[texture(1)]],
+                                  sampler u_maskTexSampler [[sampler(1)]])
+{
+  float4 glyphColor = u_colorTex.sample(u_colorTexSampler, in.colorTexCoords);
+  float dist = u_maskTex.sample(u_maskTexSampler, in.maskTexCoord).a;
+  float2 contrastGamma = uniforms.u_contrastGamma;
+  float alpha = smoothstep(contrastGamma.x - contrastGamma.y, contrastGamma.x + contrastGamma.y, dist);
+  glyphColor.a *= (alpha * uniforms.u_opacity);
+  return glyphColor;
+}
+
+// TexturingGui
+
+typedef struct
+{
+  packed_float2 a_position;
+  packed_float2 a_texCoords;
+} TexturingGuiVertex_T;
+
+typedef struct
+{
+  float4 position [[position]];
+  float2 texCoords;
+} TexturingGuiFragment_T;
+
+vertex TexturingGuiFragment_T vsTexturingGui(device const TexturingGuiVertex_T * vertices [[buffer(0)]],
+                                             constant Uniforms_T & uniforms [[buffer(1)]],
+                                             ushort vid [[vertex_id]])
+{
+  TexturingGuiVertex_T const in = vertices[vid];
+  TexturingGuiFragment_T out;
+  out.position = float4(in.a_position, 0.0, 1.0) * uniforms.u_modelView * uniforms.u_projection;
+  out.texCoords = in.a_texCoords;
+  return out;
+}
+
+fragment float4 fsTexturingGui(const TexturingGuiFragment_T in [[stage_in]],
+                               constant Uniforms_T & uniforms [[buffer(0)]],
+                               texture2d<float> u_colorTex [[texture(0)]],
+                               sampler u_colorTexSampler [[sampler(0)]])
+{
+  float4 color = u_colorTex.sample(u_colorTexSampler, in.texCoords);
+  color.a *= uniforms.u_opacity;
+  return color;
+}
diff --git a/shaders/Metal/screen_quad.metal b/shaders/Metal/screen_quad.metal
index 55c4475fa9..05ae891cc0 100644
--- a/shaders/Metal/screen_quad.metal
+++ b/shaders/Metal/screen_quad.metal
@@ -20,7 +20,7 @@ typedef struct
 } Uniforms_T;
 
 vertex Fragment_T vsScreenQuad(device const Vertex_T * vertices [[buffer(0)]],
-                               uint vid [[vertex_id]])
+                               ushort vid [[vertex_id]])
 {
   Vertex_T const in = vertices[vid];
   Fragment_T out;
diff --git a/shaders/metal_program_pool.mm b/shaders/metal_program_pool.mm
index 2c038094fb..0deba17732 100644
--- a/shaders/metal_program_pool.mm
+++ b/shaders/metal_program_pool.mm
@@ -32,7 +32,8 @@ std::array<ProgramInfo, static_cast<size_t>(Program::ProgramsCount)> const kMeta
   ProgramInfo("", ""),  // TextOutlined
   ProgramInfo("", ""),  // Text
   ProgramInfo("", ""),  // TextFixed
-  ProgramInfo("", ""),  // TextOutlinedGui
+  ProgramInfo("vsTextStaticOutlinedGui", "fsTextOutlinedGui"),  // TextStaticOutlinedGui
+  ProgramInfo("vsTextOutlinedGui", "fsTextOutlinedGui"),  // TextOutlinedGui
   ProgramInfo("", ""),  // Area
   ProgramInfo("", ""),  // AreaOutline
   ProgramInfo("", ""),  // Area3d
@@ -43,8 +44,8 @@ std::array<ProgramInfo, static_cast<size_t>(Program::ProgramsCount)> const kMeta
   ProgramInfo("", ""),  // DashedLine
   ProgramInfo("", ""),  // PathSymbol
   ProgramInfo("", ""),  // HatchingArea
-  ProgramInfo("", ""),  // TexturingGui
-  ProgramInfo("", ""),  // Ruler
+  ProgramInfo("vsTexturingGui", "fsTexturingGui"),  // TexturingGui
+  ProgramInfo("vsRuler", "fsRuler"),  // Ruler
   ProgramInfo("", ""),  // Accuracy
   ProgramInfo("", ""),  // MyPosition
   ProgramInfo("", ""),  // Transit
diff --git a/shaders/program_params.hpp b/shaders/program_params.hpp
index 7264708170..10abadd2c7 100644
--- a/shaders/program_params.hpp
+++ b/shaders/program_params.hpp
@@ -9,6 +9,8 @@
 
 #include "base/assert.hpp"
 
+#include "std/target_os.hpp"
+
 #include <map>
 #include <vector>
 
@@ -43,6 +45,11 @@ private:
     } \
   }
 
+#if defined(OMIM_OS_IPHONE)
+#define ALIGNMENT __attribute__ ((aligned(16)))
+#else
+#define ALIGNMENT
+#endif
 
 struct MapProgramParams
 {
@@ -82,7 +89,7 @@ struct MapProgramParams
     Program::TextOutlinedBillboard,
     Program::Texturing,
     Program::TexturingBillboard)
-};
+} ALIGNMENT;
 
 struct RouteProgramParams
 {
@@ -103,7 +110,7 @@ struct RouteProgramParams
     Program::RouteDash,
     Program::RouteArrow,
     Program::RouteMarker)
-};
+} ALIGNMENT;
 
 struct TrafficProgramParams
 {
@@ -121,7 +128,7 @@ struct TrafficProgramParams
     Program::Traffic,
     Program::TrafficLine,
     Program::TrafficCircle)
-};
+} ALIGNMENT;
 
 struct TransitProgramParams
 {
@@ -136,7 +143,7 @@ struct TransitProgramParams
     Program::Transit,
     Program::TransitCircle,
     Program::TransitMarker)
-};
+} ALIGNMENT;
 
 struct GuiProgramParams
 {
@@ -149,10 +156,11 @@ struct GuiProgramParams
   float m_length = 0.0f;
 
   BIND_PROGRAMS(GuiProgramParams,
+    Program::TextStaticOutlinedGui,
     Program::TextOutlinedGui,
     Program::TexturingGui,
     Program::Ruler)
-};
+} ALIGNMENT;
 
 struct ShapesProgramParams
 {
@@ -168,7 +176,7 @@ struct ShapesProgramParams
   BIND_PROGRAMS(ShapesProgramParams,
     Program::Accuracy,
     Program::MyPosition)
-};
+} ALIGNMENT;
 
 struct Arrow3dProgramParams
 {
@@ -179,21 +187,21 @@ struct Arrow3dProgramParams
     Program::Arrow3d,
     Program::Arrow3dShadow,
     Program::Arrow3dOutline)
-};
+} ALIGNMENT;
 
 struct DebugRectProgramParams
 {
   glsl::vec4 m_color;
 
   BIND_PROGRAMS(DebugRectProgramParams, Program::DebugRect)
-};
+} ALIGNMENT;
 
 struct ScreenQuadProgramParams
 {
   float m_opacity = 1.0f;
 
   BIND_PROGRAMS(ScreenQuadProgramParams, Program::ScreenQuad)
-};
+} ALIGNMENT;
 
 struct SMAAProgramParams
 {
@@ -203,7 +211,9 @@ struct SMAAProgramParams
     Program::SmaaEdges,
     Program::SmaaBlendingWeight,
     Program::SmaaFinal)
-};
+} ALIGNMENT;
+
+#undef ALIGNMENT
 
 class ProgramParamsSetter
 {
diff --git a/shaders/programs.hpp b/shaders/programs.hpp
index 0510369343..ca4fc30fec 100644
--- a/shaders/programs.hpp
+++ b/shaders/programs.hpp
@@ -17,6 +17,7 @@ enum class Program
   TextOutlined,
   Text,
   TextFixed,
+  TextStaticOutlinedGui,
   TextOutlinedGui,
   Area,
   AreaOutline,
@@ -74,6 +75,7 @@ inline std::string DebugPrint(Program p)
   case Program::TextOutlined: return "TextOutlined";
   case Program::Text: return "Text";
   case Program::TextFixed: return "TextFixed";
+  case Program::TextStaticOutlinedGui: return "TextStaticOutlinedGui";
   case Program::TextOutlinedGui: return "TextOutlinedGui";
   case Program::Area: return "Area";
   case Program::AreaOutline: return "AreaOutline";
diff --git a/xcode/shaders/shaders.xcodeproj/project.pbxproj b/xcode/shaders/shaders.xcodeproj/project.pbxproj
index 4cf17bed44..cfa831da84 100644
--- a/xcode/shaders/shaders.xcodeproj/project.pbxproj
+++ b/xcode/shaders/shaders.xcodeproj/project.pbxproj
@@ -9,6 +9,7 @@
 /* Begin PBXBuildFile section */
 		4560F58A213D57D600CC736C /* debug_rect.metal in Sources */ = {isa = PBXBuildFile; fileRef = 45789EDC21342BDE009955CC /* debug_rect.metal */; };
 		4560F58B213D57D600CC736C /* screen_quad.metal in Sources */ = {isa = PBXBuildFile; fileRef = 4560F582213D44CE00CC736C /* screen_quad.metal */; };
+		4560F5AB2142AC1300CC736C /* gui.metal in Sources */ = {isa = PBXBuildFile; fileRef = 4560F5AA2142AC1300CC736C /* gui.metal */; };
 		4561ADF520E378CB0096BC12 /* program_manager.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4561ADF320E378CB0096BC12 /* program_manager.cpp */; };
 		4561ADF920E37A6F0096BC12 /* shaders_compiler in Resources */ = {isa = PBXBuildFile; fileRef = 4561ADF820E37A6F0096BC12 /* shaders_compiler */; };
 		4566608A20E256240085E8C1 /* program_params.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 4566608020E256230085E8C1 /* program_params.cpp */; };
@@ -59,6 +60,7 @@
 
 /* Begin PBXFileReference section */
 		4560F582213D44CE00CC736C /* screen_quad.metal */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.metal; path = screen_quad.metal; sourceTree = "<group>"; };
+		4560F5AA2142AC1300CC736C /* gui.metal */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.metal; path = gui.metal; sourceTree = "<group>"; };
 		4561ADF320E378CB0096BC12 /* program_manager.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = program_manager.cpp; sourceTree = "<group>"; };
 		4561ADF420E378CB0096BC12 /* program_manager.hpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = program_manager.hpp; sourceTree = "<group>"; };
 		4561ADF820E37A6F0096BC12 /* shaders_compiler */ = {isa = PBXFileReference; lastKnownFileType = folder; name = shaders_compiler; path = ../../tools/shaders_compiler; sourceTree = "<group>"; };
@@ -370,6 +372,7 @@
 			children = (
 				45789EDC21342BDE009955CC /* debug_rect.metal */,
 				4560F582213D44CE00CC736C /* screen_quad.metal */,
+				4560F5AA2142AC1300CC736C /* gui.metal */,
 			);
 			path = Metal;
 			sourceTree = "<group>";
@@ -527,6 +530,7 @@
 			isa = PBXSourcesBuildPhase;
 			buildActionMask = 2147483647;
 			files = (
+				4560F5AB2142AC1300CC736C /* gui.metal in Sources */,
 				4560F58A213D57D600CC736C /* debug_rect.metal in Sources */,
 				4560F58B213D57D600CC736C /* screen_quad.metal in Sources */,
 			);