diff --git a/thermion_dart/native/src/RenderTicker.cpp b/thermion_dart/native/src/RenderTicker.cpp
index e5014c02..42849103 100644
--- a/thermion_dart/native/src/RenderTicker.cpp
+++ b/thermion_dart/native/src/RenderTicker.cpp
@@ -18,6 +18,7 @@
 #include <filament/Camera.h>
 #include <filament/ColorGrading.h>
 #include <filament/Engine.h>
+#include <filament/Fence.h>
 #include <filament/IndexBuffer.h>
 #include <filament/IndirectLight.h>
 #include <filament/LightManager.h>
@@ -29,7 +30,8 @@
 #include <filament/TransformManager.h>
 #include <filament/VertexBuffer.h>
 
-#include <chrono> 
+#include <chrono>
+#include <map>
 
 #include "Log.hpp"
 #include "RenderTicker.hpp"
@@ -43,20 +45,37 @@ namespace thermion
 
   using std::string;
 
-  void RenderTicker::setRenderable(SwapChain *swapChain, View **views, uint8_t numViews) {
+  void RenderTicker::removeSwapChain(SwapChain *swapChain)
+  {
+    std::lock_guard lock(mMutex);
+    auto erased = std::remove_if(mRenderable.begin(),
+                                 mRenderable.end(),
+                                 [=](ViewAttachment attachment)
+                                 { return attachment.first == swapChain; });
+    mRenderable.erase(erased,
+                      mRenderable.end());
+  }
+
+  void RenderTicker::setRenderable(SwapChain *swapChain, View **views, uint8_t numViews)
+  {
     std::lock_guard lock(mMutex);
 
     auto it = std::find_if(mRenderable.begin(), mRenderable.end(),
-      [swapChain](const auto& pair) { return pair.first == swapChain; });
+                           [swapChain](const auto &pair)
+                           { return pair.first == swapChain; });
 
-    std::vector<View*> swapChainViews;
-    for(int i = 0; i < numViews; i++) {
+    std::vector<View *> swapChainViews;
+    for (int i = 0; i < numViews; i++)
+    {
       swapChainViews.push_back(views[i]);
     }
-    
-    if (it != mRenderable.end()) {
+
+    if (it != mRenderable.end())
+    {
       it->second = swapChainViews;
-    } else {
+    }
+    else
+    {
       mRenderable.emplace_back(swapChain, swapChainViews);
     }
     TRACE("Set %d views as renderable", numViews);
@@ -65,74 +84,80 @@ namespace thermion
   bool RenderTicker::render(uint64_t frameTimeInNanos)
   {
     auto startTime = std::chrono::high_resolution_clock::now();
-    
+
     std::lock_guard lock(mMutex);
 
-    for (auto animationManager : mAnimationManagers) {
+    for (auto animationManager : mAnimationManagers)
+    {
       animationManager->update(frameTimeInNanos);
     }
 
     auto durationNs = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - mLastRender).count() / 1e6f;
     TRACE("Updated animations in %.3f ms", durationNs);
-    
-    int numRendered = 0;
-    
-    #ifdef ENABLE_TRACING
-    TRACE("%d swapchains", mRenderable.size());
-    #endif
-    
-    for (const auto& [swapChain, views] : mRenderable)
-    {
-      if (!views.empty())
-      {
-        TRACE("Rendering %d views", views.size());
 
-        bool beginFrame = mRenderer->beginFrame(swapChain, frameTimeInNanos);
-        if (beginFrame)
+    int swapChainIndex = 0;
+    bool rendered = false;
+
+    for (const auto &[swapChain, views] : mRenderable)
+    {
+
+      int numRendered = 0;
+
+      bool beginFrame = mRenderer->beginFrame(swapChain, frameTimeInNanos);
+      if (beginFrame)
+      {
+        numRendered++;
+        durationNs = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - mLastRender).count() / 1e6f;
+
+        TRACE("Beginning frame (%.3f ms since last endFrame())", durationNs);
+        for (auto view : views)
         {
-          numRendered++;        
-          durationNs = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - mLastRender).count() / 1e6f;
-          TRACE("Beginning frame (%.3f ms since last endFrame())", durationNs);
-          for (auto view : views)
-          {
-            mRenderer->render(view);
-          }
-          mLastRender = std::chrono::high_resolution_clock::now();          
-          mRenderer->endFrame();
-        } else {
-          durationNs = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - mLastRender).count() / 1e6f;
-          TRACE("Skipping frame (%.3f ms since last endFrame())", durationNs);
+          mRenderer->render(view);
         }
 
-    #ifdef ENABLE_TRACING
-      } else {
-        TRACE("No views for swapchain");
+        if (mOverlayComponentManager)
+        {
+          mOverlayComponentManager->update();
+        }
+
+        mLastRender = std::chrono::high_resolution_clock::now();
+        mRenderer->endFrame();
+      }
+      else
+      {
+        durationNs = std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now() - mLastRender).count() / 1e6f;
+        TRACE("Skipping frame (%.3f ms since last endFrame())", durationNs);
+      }
+      TRACE("%d views rendered for swapchain %d", numRendered, swapChainIndex);
+      swapChainIndex++;
+      if (numRendered > 0)
+      {
+        rendered = true;
       }
-      TRACE("%d swapchains rendered", numRendered);
-    #else
     }
-      #endif
-    }
-    #ifdef __EMSCRIPTEN__
+#ifdef __EMSCRIPTEN__
     mEngine->execute();
-    #endif
+#endif
     auto endTime = std::chrono::high_resolution_clock::now();
     durationNs = std::chrono::duration_cast<std::chrono::nanoseconds>(endTime - startTime).count();
     float durationMs = durationNs / 1e6f;
 
     TRACE("Total render() time: %.3f ms", durationMs);
-    return numRendered > 0;
+    return rendered;
   }
 
-  void RenderTicker::addAnimationManager(AnimationManager* animationManager) {
+  void RenderTicker::addAnimationManager(AnimationManager *animationManager)
+  {
     std::lock_guard<std::mutex> lock(mMutex);
     mAnimationManagers.push_back(animationManager);
   }
 
-  void RenderTicker::removeAnimationManager(AnimationManager* animationManager) {
+  void RenderTicker::removeAnimationManager(AnimationManager *animationManager)
+  {
     std::lock_guard<std::mutex> lock(mMutex);
     auto it = std::find(mAnimationManagers.begin(), mAnimationManagers.end(), animationManager);
-    if (it != mAnimationManagers.end()) {
+    if (it != mAnimationManagers.end())
+    {
       mAnimationManagers.erase(it);
     }
   }