diff --git a/drape/CMakeLists.txt b/drape/CMakeLists.txt
index 4355682b36..9552fdd0be 100644
--- a/drape/CMakeLists.txt
+++ b/drape/CMakeLists.txt
@@ -39,6 +39,7 @@ set(
   ${DRAPE_ROOT}/debug_rect_renderer.hpp
   ${DRAPE_ROOT}/drape_diagnostics.hpp
   ${DRAPE_ROOT}/drape_global.hpp
+  ${DRAPE_ROOT}/drape_routine.hpp
   ${DRAPE_ROOT}/dynamic_texture.hpp
   ${DRAPE_ROOT}/font_texture.cpp
   ${DRAPE_ROOT}/font_texture.hpp
diff --git a/drape/drape_routine.hpp b/drape/drape_routine.hpp
new file mode 100644
index 0000000000..8aa84035cc
--- /dev/null
+++ b/drape/drape_routine.hpp
@@ -0,0 +1,118 @@
+#pragma once
+
+#include "base/macros.hpp"
+#include "base/worker_thread.hpp"
+
+#import <atomic>
+#include <condition_variable>
+#include <memory>
+#include <mutex>
+#include <utility>
+
+namespace dp
+{
+// This class MUST NOT run OpenGL-related tasks (which invoke OpenGL or contain any
+// OpenGL data), use FR/BR threads for that.
+class DrapeRoutine
+{
+  friend class Promise;
+
+public:
+  class Result
+  {
+  public:
+    void Wait()
+    {
+      if (m_isFinished)
+        return;
+
+      DrapeRoutine::Instance().Wait(m_id);
+    }
+
+  private:
+    explicit Result(uint64_t id) : m_id(id), m_isFinished(false) {}
+
+    uint64_t Finish()
+    {
+      m_isFinished = true;
+      return m_id;
+    }
+
+    uint64_t const m_id;
+    std::atomic<bool> m_isFinished;
+    friend class DrapeRoutine;
+  };
+
+  using ResultPtr = std::shared_ptr<Result>;
+
+  static void Init()
+  {
+    Instance();
+  }
+
+  static void Shutdown()
+  {
+    Instance().FinishAll();
+  }
+
+  template <typename Task>
+  static ResultPtr Run(Task && t)
+  {
+    ResultPtr result(new Result(Instance().GetId()));
+    bool const success = Instance().m_workerThread.Push([result, t]() mutable
+    {
+      t();
+      Instance().Notify(result->Finish());
+    });
+
+    if (!success)
+      return nullptr;
+
+    return result;
+  }
+
+private:
+  static DrapeRoutine & Instance()
+  {
+    static DrapeRoutine instance;
+    return instance;
+  }
+
+  uint64_t GetId()
+  {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    return m_counter++;
+  }
+
+  void Notify(uint64_t id)
+  {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    m_finishedId = id;
+    m_condition.notify_all();
+  }
+
+  void Wait(uint64_t id)
+  {
+    std::unique_lock<std::mutex> lock(m_mutex);
+    if (m_finished)
+      return;
+    m_condition.wait(lock, [this, id](){ return m_finished || m_finishedId == id; });
+  }
+
+  void FinishAll()
+  {
+    m_workerThread.ShutdownAndJoin();
+
+    std::lock_guard<std::mutex> lock(m_mutex);
+    m_finished = true;
+    m_condition.notify_all();
+  }
+
+  uint64_t m_finishedId = 0;
+  uint64_t m_counter = 0;
+  bool m_finished = false;
+  std::condition_variable m_condition;
+  std::mutex m_mutex;
+  base::WorkerThread m_workerThread;
+};
+}  // namespace dp
diff --git a/drape/font_texture.cpp b/drape/font_texture.cpp
index 5e5b8604c1..32a3faaf08 100644
--- a/drape/font_texture.cpp
+++ b/drape/font_texture.cpp
@@ -1,4 +1,5 @@
 #include "drape/font_texture.hpp"
+
 #include "drape/pointers.hpp"
 
 #include "platform/platform.hpp"
@@ -8,19 +9,15 @@
 #include "base/string_utils.hpp"
 #include "base/stl_add.hpp"
 
-#include "std/chrono.hpp"
-#include "std/string.hpp"
-#include "std/vector.hpp"
-#include "std/map.hpp"
-#include "std/bind.hpp"
+#include <functional>
+
+using namespace std::placeholders;
 
 namespace dp
 {
-
 GlyphPacker::GlyphPacker(const m2::PointU & size)
   : m_size(size)
-{
-}
+{}
 
 bool GlyphPacker::PackGlyph(uint32_t width, uint32_t height, m2::RectU & rect)
 {
@@ -72,92 +69,113 @@ bool GlyphPacker::CanBePacked(uint32_t glyphsCount, uint32_t width, uint32_t hei
 
 m2::RectF GlyphPacker::MapTextureCoords(const m2::RectU & pixelRect) const
 {
-  float fWidth = static_cast<float>(m_size.x);
-  float fHeight = static_cast<float>(m_size.y);
+  auto const width = static_cast<float>(m_size.x);
+  auto const height = static_cast<float>(m_size.y);
 
-  // Half-pixel offset to eliminate arfefacts on fetching from texture.
+  // Half-pixel offset to eliminate artefacts on fetching from texture.
   float offset = 0.0f;
   if (pixelRect.SizeX() != 0 && pixelRect.SizeY() != 0)
     offset = 0.5f;
 
-  return m2::RectF((pixelRect.minX() + offset) / fWidth,
-                   (pixelRect.minY() + offset) / fHeight,
-                   (pixelRect.maxX() - offset) / fWidth,
-                   (pixelRect.maxY() - offset) / fHeight);
+  return {(pixelRect.minX() + offset) / width,
+          (pixelRect.minY() + offset) / height,
+          (pixelRect.maxX() - offset) / width,
+          (pixelRect.maxY() - offset) / height};
 }
 
 bool GlyphPacker::IsFull() const { return m_isFull; }
 
-GlyphGenerator::GlyphGenerator(ref_ptr<GlyphManager> mng, TCompletionHandler const & completionHandler)
-  : m_mng(mng)
+GlyphGenerator::GlyphGenerator(uint32_t sdfScale,
+                               CompletionHandler const & completionHandler)
+  : m_sdfScale(sdfScale)
   , m_completionHandler(completionHandler)
-  , m_isRunning(true)
-  , m_isSuspended(false)
-  , m_thread(&GlyphGenerator::Routine, this)
 {
   ASSERT(m_completionHandler != nullptr, ());
 }
 
 GlyphGenerator::~GlyphGenerator()
 {
-  m_isRunning = false;
-  m_condition.notify_one();
-  m_thread.join();
-  m_completionHandler = nullptr;
+  DrapeRoutine::ResultPtr result;
+  {
+    std::lock_guard<std::mutex> lock(m_mutex);
+    result = m_routineResult;
+    m_completionHandler = nullptr;
+  }
 
-  for (GlyphGenerationData & data : m_queue)
+  // Here we have to wait for the last task completion,
+  // because it captures 'this' pointer.
+  if (result)
+    result->Wait();
+
+  std::lock_guard<std::mutex> lock(m_mutex);
+  for (auto & data : m_queue)
     data.m_glyph.m_image.Destroy();
   m_queue.clear();
-}
-
-void GlyphGenerator::WaitForGlyph(list<GlyphGenerationData> & queue)
-{
-  unique_lock<mutex> lock(m_queueLock);
-  m_isSuspended = true;
-  m_condition.wait(lock, [this] { return !m_queue.empty() || !m_isRunning; });
-  m_isSuspended = false;
-  queue.swap(m_queue);
+  m_glyphsCounter = 0;
 }
 
 bool GlyphGenerator::IsSuspended() const
 {
-  lock_guard<mutex> lock(m_queueLock);
-  return m_isSuspended;
+  std::lock_guard<std::mutex> lock(m_mutex);
+  return m_glyphsCounter == 0;
 }
 
-void GlyphGenerator::Routine(GlyphGenerator * generator)
+void GlyphGenerator::GenerateGlyph(m2::RectU const & rect, GlyphManager::Glyph & glyph)
 {
-  ASSERT(generator != nullptr, ());
-  while (generator->m_isRunning)
+  std::lock_guard<std::mutex> lock(m_mutex);
+  if (!m_completionHandler)
   {
-    list<GlyphGenerationData> queue;
-    generator->WaitForGlyph(queue);
-
-    // generate glyphs
-    for (GlyphGenerationData & data : queue)
-    {
-      GlyphManager::Glyph glyph = generator->m_mng->GenerateGlyph(data.m_glyph);
-      data.m_glyph.m_image.Destroy();
-      generator->m_completionHandler(data.m_rect, glyph);
-    }
+    glyph.m_image.Destroy();
+    return;
   }
-}
 
-void GlyphGenerator::GenerateGlyph(m2::RectU const & rect, GlyphManager::Glyph const & glyph)
-{
-  lock_guard<mutex> lock(m_queueLock);
+  std::list<GlyphGenerationData> queue;
   m_queue.emplace_back(rect, glyph);
-  m_condition.notify_one();
+  std::swap(m_queue, queue);
+  m_glyphsCounter += queue.size();
+
+  // Generate glyphs on the separate thread.
+  m_routineResult = DrapeRoutine::Run([this, queue]() mutable
+  {
+    std::vector<GlyphGenerator::GlyphGenerationData> glyphs;
+    glyphs.reserve(queue.size());
+    for (auto & data : queue)
+    {
+      auto const g = GlyphManager::GenerateGlyph(data.m_glyph, m_sdfScale);
+      data.m_glyph.m_image.Destroy();
+      glyphs.emplace_back(GlyphGenerator::GlyphGenerationData{data.m_rect, g});
+    }
+      
+    std::lock_guard<std::mutex> lock(m_mutex);
+    if (m_completionHandler)
+    {
+      m_completionHandler(std::move(glyphs));
+      ASSERT_GREATER_OR_EQUAL(m_glyphsCounter, queue.size(), ());
+      m_glyphsCounter -= queue.size();
+    }
+    else
+    {
+      for (auto & g : glyphs)
+        g.m_glyph.m_image.Destroy();
+    }
+  });
+
+  if (!m_routineResult)
+  {
+    for (auto & data : queue)
+      data.m_glyph.m_image.Destroy();
+  }
 }
 
 GlyphIndex::GlyphIndex(m2::PointU size, ref_ptr<GlyphManager> mng)
   : m_packer(size)
   , m_mng(mng)
-  , m_generator(new GlyphGenerator(mng, bind(&GlyphIndex::OnGlyphGenerationCompletion, this, _1, _2)))
+  , m_generator(my::make_unique<GlyphGenerator>(mng->GetSdfScale(),
+                std::bind(&GlyphIndex::OnGlyphGenerationCompletion, this, _1)))
 {
   // Cache invalid glyph.
-  GlyphKey const key = GlyphKey(m_mng->GetInvalidGlyph(GlyphManager::kDynamicGlyphSize).m_code,
-                                GlyphManager::kDynamicGlyphSize);
+  auto const key = GlyphKey(m_mng->GetInvalidGlyph(GlyphManager::kDynamicGlyphSize).m_code,
+                            GlyphManager::kDynamicGlyphSize);
   bool newResource = false;
   MapResource(key, newResource);
 }
@@ -165,14 +183,11 @@ GlyphIndex::GlyphIndex(m2::PointU size, ref_ptr<GlyphManager> mng)
 GlyphIndex::~GlyphIndex()
 {
   m_generator.reset();
-  {
-    threads::MutexGuard g(m_lock);
-    for_each(m_pendingNodes.begin(), m_pendingNodes.end(), [](TPendingNode & node)
-    {
-      node.second.m_image.Destroy();
-    });
-    m_pendingNodes.clear();
-  }
+
+  std::lock_guard<std::mutex> lock(m_mutex);
+  for (auto & node : m_pendingNodes)
+    node.second.m_image.Destroy();
+  m_pendingNodes.clear();
 }
 
 ref_ptr<Texture::ResourceInfo> GlyphIndex::MapResource(GlyphKey const & key, bool & newResource)
@@ -217,7 +232,7 @@ bool GlyphIndex::CanBeGlyphPacked(uint32_t glyphsCount) const
     return false;
 
   float const kGlyphScalar = 1.5f;
-  uint32_t const baseSize = static_cast<uint32_t>(m_mng->GetBaseGlyphHeight() * kGlyphScalar);
+  auto const baseSize = static_cast<uint32_t>(m_mng->GetBaseGlyphHeight() * kGlyphScalar);
   return m_packer.CanBePacked(glyphsCount, baseSize, baseSize);
 }
 
@@ -228,21 +243,22 @@ bool GlyphIndex::HasAsyncRoutines() const
 
 size_t GlyphIndex::GetPendingNodesCount()
 {
-  threads::MutexGuard g(m_lock);
+  std::lock_guard<std::mutex> lock(m_mutex);
   return m_pendingNodes.size();
 }
 
-void GlyphIndex::OnGlyphGenerationCompletion(m2::RectU const & rect, GlyphManager::Glyph const & glyph)
+void GlyphIndex::OnGlyphGenerationCompletion(std::vector<GlyphGenerator::GlyphGenerationData> && glyphs)
 {
-  threads::MutexGuard g(m_lock);
-  m_pendingNodes.emplace_back(rect, glyph);
+  std::lock_guard<std::mutex> lock(m_mutex);
+  for (auto & g : glyphs)
+    m_pendingNodes.emplace_back(g.m_rect, g.m_glyph);
 }
 
 void GlyphIndex::UploadResources(ref_ptr<Texture> texture)
 {
-  TPendingNodes pendingNodes;
+  PendingNodes pendingNodes;
   {
-    threads::MutexGuard g(m_lock);
+    std::lock_guard<std::mutex> lock(m_mutex);
     if (m_pendingNodes.empty())
       return;
     m_pendingNodes.swap(pendingNodes);
@@ -291,5 +307,4 @@ uint32_t GlyphIndex::GetAbsentGlyphsCount(strings::UniString const & text, int f
   }
   return count;
 }
-
-} // namespace dp
+}  // namespace dp
diff --git a/drape/font_texture.hpp b/drape/font_texture.hpp
index 30f32a9084..796bfc98ae 100644
--- a/drape/font_texture.hpp
+++ b/drape/font_texture.hpp
@@ -1,24 +1,23 @@
 #pragma once
 
+#include "drape/drape_routine.hpp"
+#include "drape/dynamic_texture.hpp"
+#include "drape/glyph_manager.hpp"
 #include "drape/pointers.hpp"
 #include "drape/texture.hpp"
-#include "drape/glyph_manager.hpp"
-#include "drape/dynamic_texture.hpp"
 
-#include "std/atomic.hpp"
-#include "std/condition_variable.hpp"
-#include "std/list.hpp"
-#include "std/map.hpp"
-#include "std/vector.hpp"
-#include "std/string.hpp"
-#include "std/thread.hpp"
+#include <list>
+#include <map>
+#include <memory>
+#include <mutex>
+#include <vector>
 
 namespace dp
 {
 class GlyphPacker
 {
 public:
-  GlyphPacker(m2::PointU const & size);
+  explicit GlyphPacker(m2::PointU const & size);
 
   bool PackGlyph(uint32_t width, uint32_t height, m2::RectU & rect);
   bool CanBePacked(uint32_t glyphsCount, uint32_t width, uint32_t height) const;
@@ -59,14 +58,15 @@ private:
 
 class GlyphInfo : public Texture::ResourceInfo
 {
-  typedef Texture::ResourceInfo TBase;
+  using Base = Texture::ResourceInfo;
+
 public:
   GlyphInfo(m2::RectF const & texRect, GlyphManager::GlyphMetrics const & metrics)
-    : TBase(texRect)
+    : Base(texRect)
     , m_metrics(metrics)
   {}
 
-  virtual Texture::ResourceType GetType() const { return Texture::Glyph; }
+  Texture::ResourceType GetType() const override { return Texture::Glyph; }
   GlyphManager::GlyphMetrics const & GetMetrics() const { return m_metrics; }
 
 private:
@@ -76,8 +76,6 @@ private:
 class GlyphGenerator
 {
 public:
-  using TCompletionHandler = function<void(m2::RectU const &, GlyphManager::Glyph const &)>;
-
   struct GlyphGenerationData
   {
     m2::RectU m_rect;
@@ -88,27 +86,22 @@ public:
     {}
   };
 
-  GlyphGenerator(ref_ptr<GlyphManager> mng, TCompletionHandler const & completionHandler);
+  using CompletionHandler = std::function<void(std::vector<GlyphGenerator::GlyphGenerationData> &&)>;
+
+  GlyphGenerator(uint32_t sdfScale, CompletionHandler const & completionHandler);
   ~GlyphGenerator();
 
-  void GenerateGlyph(m2::RectU const & rect, GlyphManager::Glyph const & glyph);
-
+  void GenerateGlyph(m2::RectU const & rect, GlyphManager::Glyph & glyph);
   bool IsSuspended() const;
 
 private:
-  static void Routine(GlyphGenerator * generator);
-  void WaitForGlyph(list<GlyphGenerationData> & queue);
+  uint32_t m_sdfScale;
+  CompletionHandler m_completionHandler;
+  DrapeRoutine::ResultPtr m_routineResult;
 
-  ref_ptr<GlyphManager> m_mng;
-  TCompletionHandler m_completionHandler;
-
-  list<GlyphGenerationData> m_queue;
-  mutable mutex m_queueLock;
-
-  atomic<bool> m_isRunning;
-  condition_variable m_condition;
-  bool m_isSuspended;
-  thread m_thread;
+  std::list<GlyphGenerationData> m_queue;
+  size_t m_glyphsCounter = 0;
+  mutable std::mutex m_mutex;
 };
 
 class GlyphIndex
@@ -131,29 +124,31 @@ public:
   size_t GetPendingNodesCount();
 
 private:
-  void OnGlyphGenerationCompletion(m2::RectU const & rect, GlyphManager::Glyph const & glyph);
+  void OnGlyphGenerationCompletion(std::vector<GlyphGenerator::GlyphGenerationData> && glyphs);
 
   GlyphPacker m_packer;
   ref_ptr<GlyphManager> m_mng;
-  unique_ptr<GlyphGenerator> m_generator;
+  std::unique_ptr<GlyphGenerator> m_generator;
 
-  typedef map<GlyphKey, GlyphInfo> TResourceMapping;
-  typedef pair<m2::RectU, GlyphManager::Glyph> TPendingNode;
-  typedef vector<TPendingNode> TPendingNodes;
+  using ResourceMapping = std::map<GlyphKey, GlyphInfo>;
+  using PendingNode = std::pair<m2::RectU, GlyphManager::Glyph>;
+  using PendingNodes = std::vector<PendingNode>;
 
-  TResourceMapping m_index;
-  TPendingNodes m_pendingNodes;
-  threads::Mutex m_lock;
+  ResourceMapping m_index;
+  PendingNodes m_pendingNodes;
+  std::mutex m_mutex;
 };
 
 class FontTexture : public DynamicTexture<GlyphIndex, GlyphKey, Texture::Glyph>
 {
   using TBase = DynamicTexture<GlyphIndex, GlyphKey, Texture::Glyph>;
 public:
-  FontTexture(m2::PointU const & size, ref_ptr<GlyphManager> glyphMng, ref_ptr<HWTextureAllocator> allocator)
+  FontTexture(m2::PointU const & size, ref_ptr<GlyphManager> glyphMng,
+              ref_ptr<HWTextureAllocator> allocator)
     : m_index(size, glyphMng)
   {
-    TBase::TextureParams params{size, TextureFormat::ALPHA, gl_const::GLLinear, true /* m_usePixelBuffer */};
+    TBase::TextureParams params{size, TextureFormat::ALPHA,
+                                gl_const::GLLinear, true /* m_usePixelBuffer */};
     TBase::Init(allocator, make_ref(&m_index), params);
   }
 
diff --git a/drape/glyph_manager.cpp b/drape/glyph_manager.cpp
index de016f6905..b8bceabc27 100644
--- a/drape/glyph_manager.cpp
+++ b/drape/glyph_manager.cpp
@@ -256,48 +256,6 @@ public:
     return result;
   }
 
-  GlyphManager::Glyph GenerateGlyph(GlyphManager::Glyph const & glyph) const
-  {
-    if (glyph.m_image.m_data != nullptr)
-    {
-      GlyphManager::Glyph resultGlyph;
-      resultGlyph.m_metrics = glyph.m_metrics;
-      resultGlyph.m_fontIndex = glyph.m_fontIndex;
-      resultGlyph.m_code = glyph.m_code;
-      resultGlyph.m_fixedSize = glyph.m_fixedSize;
-
-      if (glyph.m_fixedSize < 0)
-      {
-        sdf_image::SdfImage img(glyph.m_image.m_bitmapRows, glyph.m_image.m_bitmapPitch,
-                                glyph.m_image.m_data->data(), m_sdfScale * kSdfBorder);
-
-        img.GenerateSDF(1.0f / (float)m_sdfScale);
-
-        ASSERT(img.GetWidth() == glyph.m_image.m_width, ());
-        ASSERT(img.GetHeight() == glyph.m_image.m_height, ());
-
-        size_t bufferSize = my::NextPowOf2(glyph.m_image.m_width * glyph.m_image.m_height);
-        resultGlyph.m_image.m_data = SharedBufferManager::instance().reserveSharedBuffer(bufferSize);
-
-        img.GetData(*resultGlyph.m_image.m_data);
-      }
-      else
-      {
-        size_t bufferSize = my::NextPowOf2(glyph.m_image.m_width * glyph.m_image.m_height);
-        resultGlyph.m_image.m_data = SharedBufferManager::instance().reserveSharedBuffer(bufferSize);
-        resultGlyph.m_image.m_data->assign(glyph.m_image.m_data->begin(), glyph.m_image.m_data->end());
-      }
-
-      resultGlyph.m_image.m_width = glyph.m_image.m_width;
-      resultGlyph.m_image.m_height = glyph.m_image.m_height;
-      resultGlyph.m_image.m_bitmapRows = 0;
-      resultGlyph.m_image.m_bitmapPitch = 0;
-
-      return resultGlyph;
-    }
-    return glyph;
-  }
-
   void GetCharcodes(vector<FT_ULong> & charcodes)
   {
     FT_UInt gindex;
@@ -340,7 +298,7 @@ private:
 
   std::set<pair<strings::UniChar, int>> m_readyGlyphs;
 };
-}
+}  // namespace
 
 // Information about single unicode block.
 struct UnicodeBlock
@@ -391,7 +349,7 @@ struct UnicodeBlock
 using TUniBlocks = std::vector<UnicodeBlock>;
 using TUniBlockIter = TUniBlocks::const_iterator;
 
-const int GlyphManager::kDynamicGlyphSize = -1;
+int const GlyphManager::kDynamicGlyphSize = -1;
 
 struct GlyphManager::Impl
 {
@@ -401,12 +359,14 @@ struct GlyphManager::Impl
   std::vector<std::unique_ptr<Font>> m_fonts;
 
   uint32_t m_baseGlyphHeight;
+  uint32_t m_sdfScale;
 };
 
 GlyphManager::GlyphManager(GlyphManager::Params const & params)
   : m_impl(new Impl())
 {
   m_impl->m_baseGlyphHeight = params.m_baseGlyphHeight;
+  m_impl->m_sdfScale = params.m_sdfScale;
 
   using TFontAndBlockName = pair<std::string, std::string>;
   using TFontLst = buffer_vector<TFontAndBlockName, 64>;
@@ -542,6 +502,11 @@ uint32_t GlyphManager::GetBaseGlyphHeight() const
   return m_impl->m_baseGlyphHeight;
 }
 
+uint32_t GlyphManager::GetSdfScale() const
+{
+  return m_impl->m_sdfScale;
+}
+
 int GlyphManager::GetFontIndex(strings::UniChar unicodePoint)
 {
   TUniBlockIter iter = m_impl->m_blocks.end();
@@ -611,12 +576,47 @@ GlyphManager::Glyph GlyphManager::GetGlyph(strings::UniChar unicodePoint, int fi
   return glyph;
 }
 
-GlyphManager::Glyph GlyphManager::GenerateGlyph(Glyph const & glyph) const
+// static
+GlyphManager::Glyph GlyphManager::GenerateGlyph(Glyph const & glyph, uint32_t sdfScale)
 {
-  ASSERT_NOT_EQUAL(glyph.m_fontIndex, -1, ());
-  ASSERT_LESS(glyph.m_fontIndex, static_cast<int>(m_impl->m_fonts.size()), ());
-  auto const & f = m_impl->m_fonts[glyph.m_fontIndex];
-  return f->GenerateGlyph(glyph);
+  if (glyph.m_image.m_data != nullptr)
+  {
+    GlyphManager::Glyph resultGlyph;
+    resultGlyph.m_metrics = glyph.m_metrics;
+    resultGlyph.m_fontIndex = glyph.m_fontIndex;
+    resultGlyph.m_code = glyph.m_code;
+    resultGlyph.m_fixedSize = glyph.m_fixedSize;
+
+    if (glyph.m_fixedSize < 0)
+    {
+      sdf_image::SdfImage img(glyph.m_image.m_bitmapRows, glyph.m_image.m_bitmapPitch,
+                              glyph.m_image.m_data->data(), sdfScale * kSdfBorder);
+
+      img.GenerateSDF(1.0f / static_cast<float>(sdfScale));
+
+      ASSERT(img.GetWidth() == glyph.m_image.m_width, ());
+      ASSERT(img.GetHeight() == glyph.m_image.m_height, ());
+
+      size_t bufferSize = my::NextPowOf2(glyph.m_image.m_width * glyph.m_image.m_height);
+      resultGlyph.m_image.m_data = SharedBufferManager::instance().reserveSharedBuffer(bufferSize);
+
+      img.GetData(*resultGlyph.m_image.m_data);
+    }
+    else
+    {
+      size_t bufferSize = my::NextPowOf2(glyph.m_image.m_width * glyph.m_image.m_height);
+      resultGlyph.m_image.m_data = SharedBufferManager::instance().reserveSharedBuffer(bufferSize);
+      resultGlyph.m_image.m_data->assign(glyph.m_image.m_data->begin(), glyph.m_image.m_data->end());
+    }
+
+    resultGlyph.m_image.m_width = glyph.m_image.m_width;
+    resultGlyph.m_image.m_height = glyph.m_image.m_height;
+    resultGlyph.m_image.m_bitmapRows = 0;
+    resultGlyph.m_image.m_bitmapPitch = 0;
+
+    return resultGlyph;
+  }
+  return glyph;
 }
 
 void GlyphManager::ForEachUnicodeBlock(GlyphManager::TUniBlockCallback const & fn) const
diff --git a/drape/glyph_manager.hpp b/drape/glyph_manager.hpp
index a120064fa3..4ebb1acb98 100644
--- a/drape/glyph_manager.hpp
+++ b/drape/glyph_manager.hpp
@@ -73,11 +73,10 @@ public:
     int m_fixedSize;
   };
 
-  GlyphManager(Params const & params);
+  explicit GlyphManager(Params const & params);
   ~GlyphManager();
 
   Glyph GetGlyph(strings::UniChar unicodePoints, int fixedHeight);
-  Glyph GenerateGlyph(Glyph const & glyph) const;
 
   void MarkGlyphReady(Glyph const & glyph);
   bool AreGlyphsReady(strings::UniString const & str, int fixedSize) const;
@@ -88,6 +87,9 @@ public:
   Glyph GetInvalidGlyph(int fixedSize) const;
 
   uint32_t GetBaseGlyphHeight() const;
+  uint32_t GetSdfScale() const;
+
+  static Glyph GenerateGlyph(Glyph const & glyph, uint32_t sdfScale);
 
 private:
   int GetFontIndex(strings::UniChar unicodePoint);
diff --git a/drape_frontend/drape_engine.cpp b/drape_frontend/drape_engine.cpp
index ea47367692..0388493d8e 100644
--- a/drape_frontend/drape_engine.cpp
+++ b/drape_frontend/drape_engine.cpp
@@ -5,6 +5,7 @@
 #include "drape_frontend/my_position_controller.hpp"
 #include "drape_frontend/visual_params.hpp"
 
+#include "drape/drape_routine.hpp"
 #include "drape/support_manager.hpp"
 
 #include "platform/settings.hpp"
@@ -17,6 +18,8 @@ DrapeEngine::DrapeEngine(Params && params)
   : m_myPositionModeChanged(std::move(params.m_myPositionModeChanged))
   , m_viewport(std::move(params.m_viewport))
 {
+  dp::DrapeRoutine::Init();
+
   VisualParams::Init(params.m_vs, df::CalculateTileSize(m_viewport.GetWidth(), m_viewport.GetHeight()));
 
   df::VisualParams::Instance().SetFontScale(params.m_fontsScaleFactor);
@@ -112,6 +115,8 @@ DrapeEngine::DrapeEngine(Params && params)
 
 DrapeEngine::~DrapeEngine()
 {
+  dp::DrapeRoutine::Shutdown();
+
   // Call Teardown explicitly! We must wait for threads completion.
   m_frontend->Teardown();
   m_backend->Teardown();
diff --git a/drape_frontend/frontend_renderer.cpp b/drape_frontend/frontend_renderer.cpp
index 47fa2a84fc..0d9258b786 100755
--- a/drape_frontend/frontend_renderer.cpp
+++ b/drape_frontend/frontend_renderer.cpp
@@ -34,8 +34,9 @@
 #include "base/stl_add.hpp"
 
 #include <algorithm>
-#include <cmath>
 #include <chrono>
+#include <cmath>
+#include <thread>
 #include <utility>
 
 using namespace std::placeholders;
@@ -1955,7 +1956,7 @@ void FrontendRenderer::Routine::Do()
         m_renderer.m_myPositionController->IsRouteFollowingActive() && frameTime < kFrameTime)
     {
       uint32_t const ms = static_cast<uint32_t>((kFrameTime - frameTime) * 1000);
-      this_thread::sleep_for(std::chrono::milliseconds(ms));
+      std::this_thread::sleep_for(std::chrono::milliseconds(ms));
     }
 
     if (m_renderer.m_overlaysTracker->IsValid() &&