diff --git a/apps/apple/VulkanSplatting/VulkanSplatting.xcodeproj/project.pbxproj b/apps/apple/VulkanSplatting/VulkanSplatting.xcodeproj/project.pbxproj
index faac06e..894ab18 100644
--- a/apps/apple/VulkanSplatting/VulkanSplatting.xcodeproj/project.pbxproj
+++ b/apps/apple/VulkanSplatting/VulkanSplatting.xcodeproj/project.pbxproj
@@ -53,7 +53,7 @@
 		B0608E432BA54D8E00CE9114 /* DummyImguiManager.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = DummyImguiManager.cpp; path = VulkanSplatting/DummyImguiManager.cpp; sourceTree = SOURCE_ROOT; };
 		B0608E472BA5522500CE9114 /* MetalWindow.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MetalWindow.cpp; sourceTree = "<group>"; };
 		B0608E482BA5522500CE9114 /* MetalWindow.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MetalWindow.h; sourceTree = "<group>"; };
-		B0608E4D2BA5557A00CE9114 /* RenderingTarget.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderingTarget.h; sourceTree = "<group>"; };
+		B0608E4D2BA5557A00CE9114 /* RenderTarget.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RenderTarget.h; sourceTree = "<group>"; };
 		B0608E4E2BA55BBB00CE9114 /* VulkanSplatting.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = VulkanSplatting.cpp; path = ../../../src/VulkanSplatting.cpp; sourceTree = "<group>"; };
 		B0A860112BA56169008B0F4F /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist; path = Info.plist; sourceTree = "<group>"; };
 		B0B7FB3C2BA7856600DA3A53 /* project.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = project.xcconfig; sourceTree = "<group>"; };
@@ -620,7 +620,7 @@
 		B0EA8A922BA302E6003B92F7 /* vulkan */ = {
 			isa = PBXGroup;
 			children = (
-				B0608E4D2BA5557A00CE9114 /* RenderingTarget.h */,
+				B0608E4D2BA5557A00CE9114 /* RenderTarget.h */,
 				B0608E492BA5522500CE9114 /* windowing */,
 				B0608E432BA54D8E00CE9114 /* DummyImguiManager.cpp */,
 				B0EA8A932BA302E6003B92F7 /* Utils.h */,
diff --git a/apps/apple/VulkanSplatting/VulkanSplatting/DummyImguiManager.cpp b/apps/apple/VulkanSplatting/VulkanSplatting/DummyImguiManager.cpp
index 6854bdc..aff5ef7 100644
--- a/apps/apple/VulkanSplatting/VulkanSplatting/DummyImguiManager.cpp
+++ b/apps/apple/VulkanSplatting/VulkanSplatting/DummyImguiManager.cpp
@@ -1,7 +1,7 @@
 #include "ImguiManager.h"
 
 ImguiManager::ImguiManager(std::shared_ptr<VulkanContext> context, std::shared_ptr<Swapchain> swapchain,
-                           std::shared_ptr<RenderingTarget> window) {
+                           std::shared_ptr<RenderTarget> window) {
 }
 
 void ImguiManager::createCommandPool() {
diff --git a/apps/vr_viewer/src/VRViewer.cpp b/apps/vr_viewer/src/VRViewer.cpp
index 8e30ae8..872f4c9 100644
--- a/apps/vr_viewer/src/VRViewer.cpp
+++ b/apps/vr_viewer/src/VRViewer.cpp
@@ -3,7 +3,7 @@
 #include <memory>
 #include <openxr/openxr_platform.h>
 
-#include "OXRContext.h"
+#include "oxr/OXRContext.h"
 #include "3dgs.h"
 #include "spdlog/spdlog.h"
 
@@ -20,7 +20,7 @@ void VRViewer::run() {
     configuration.postVulkanInit = std::bind(&VRViewer::finishSetup, this, std::placeholders::_1, std::placeholders::_2,
         std::placeholders::_3, std::placeholders::_4, std::placeholders::_5);
 
-    auto renderingTarget = VulkanSplatting::createOpenXRRenderingTarget(configuration);
+    auto renderingTarget = VulkanSplatting::createOpenXRRenderTarget(configuration);
 }
 
 void VRViewer::finishSetup(void *vkInstance, void *vkPhysicalDevice, void *vkDevice, uint32_t vkQueueFamilyIndex,
diff --git a/apps/vr_viewer/src/oxr/Layer.cpp b/apps/vr_viewer/src/oxr/Layer.cpp
index 1552654..af26dc7 100644
--- a/apps/vr_viewer/src/oxr/Layer.cpp
+++ b/apps/vr_viewer/src/oxr/Layer.cpp
@@ -132,7 +132,7 @@ namespace OXR {
 
     void Layer::createProjectionViews(std::shared_ptr<OXRContext> context, uint64_t flags) {
         for (int i = 0; i < 2; i++) {
-            views[i].pose = {.position = { 0.0f, 0.0f, 0.0f }, .orientation = { 0.0f, 0.0f, 0.0f, 1.0f }};
+            views[i].pose = {.orientation = { 0.0f, 0.0f, 0.0f, 1.0f }, .position = { 0.0f, 0.0f, 0.0f }};
             views[i].subImage.swapchain = swapchains[i];
             views[i].subImage.imageRect.offset = {0, 0};
             views[i].subImage.imageRect.extent = {static_cast<int32_t>(context->views[i].recommendedImageRectWidth),
diff --git a/apps/vr_viewer/src/oxr/Layer.h b/apps/vr_viewer/src/oxr/Layer.h
index abc1c0b..35724ef 100644
--- a/apps/vr_viewer/src/oxr/Layer.h
+++ b/apps/vr_viewer/src/oxr/Layer.h
@@ -3,10 +3,9 @@
 #include <cstdint>
 #include <memory>
 #include <vector>
-#include <openxr/openxr.h>
-#include <openxr/openxr_platform.h>
 
 #include "OXRContext.h"
+#include <openxr/openxr_platform.h>
 
 namespace OXR {
 
diff --git a/include/3dgs/3dgs.h b/include/3dgs/3dgs.h
index d64ccdf..8fdceef 100644
--- a/include/3dgs/3dgs.h
+++ b/include/3dgs/3dgs.h
@@ -7,7 +7,7 @@
 #include <memory>
 #include <vector>
 
-class RenderingTarget;
+class RenderTarget;
 class Renderer;
 
 class VulkanSplatting {
@@ -23,17 +23,17 @@ class VulkanSplatting {
         float far = 1000.0f;
         bool enableGui = false;
 
-        std::shared_ptr<RenderingTarget> renderingTarget;
+        std::shared_ptr<RenderTarget> renderingTarget;
     };
 
     explicit VulkanSplatting(RendererConfiguration configuration) : configuration(configuration) {}
 
 #ifdef VKGS_ENABLE_GLFW
-    static std::shared_ptr<RenderingTarget> createGlfwWindow(std::string name, int width, int height);
+    static std::shared_ptr<RenderTarget> createGlfwWindow(std::string name, int width, int height);
 #endif
 
 #ifdef VKGS_ENABLE_METAL
-    static std::shared_ptr<RenderingTarget> createMetalWindow(void *caMetalLayer, int width, int height);
+    static std::shared_ptr<RenderTarget> createMetalWindow(void *caMetalLayer, int width, int height);
 #endif
 
 #ifdef VKGS_ENABLE_OPENXR
@@ -44,7 +44,7 @@ class VulkanSplatting {
         std::function<void*(void*)> getPhysicalDevice;
         std::function<void(void*, void*, void*, uint32_t, uint32_t)> postVulkanInit;
     };
-    static std::shared_ptr<RenderingTarget> createOpenXRRenderingTarget(OpenXRConfiguration configuration);
+    static std::shared_ptr<RenderTarget> createOpenXRRenderTarget(OpenXRConfiguration configuration);
 #endif
 
     void start();
diff --git a/src/3dgs.cpp b/src/3dgs.cpp
index c442ee3..6c23f67 100644
--- a/src/3dgs.cpp
+++ b/src/3dgs.cpp
@@ -4,19 +4,19 @@
 
 #ifdef VKGS_ENABLE_GLFW
 #include "vulkan/targets/GLFWWindow.h"
-std::shared_ptr<RenderingTarget> VulkanSplatting::createGlfwWindow(std::string name, int width, int height) {
+std::shared_ptr<RenderTarget> VulkanSplatting::createGlfwWindow(std::string name, int width, int height) {
     return std::make_shared<GLFWWindow>(name, width, height);
 }
 #endif
 
 #ifdef VKGS_ENABLE_METAL
 #include "vulkan/windowing/MetalWindow.h"
-std::shared_ptr<RenderingTarget> VulkanSplatting::createMetalWindow(void *caMetalLayer, int width, int height) {
+std::shared_ptr<RenderTarget> VulkanSplatting::createMetalWindow(void *caMetalLayer, int width, int height) {
     return std::make_shared<MetalWindow>(caMetalLayer, width, height);
 }
 #endif
 
-std::shared_ptr<RenderingTarget> VulkanSplatting::createOpenXRRenderingTarget(OpenXRConfiguration configuration) {
+std::shared_ptr<RenderTarget> VulkanSplatting::createOpenXRRenderTarget(OpenXRConfiguration configuration) {
     auto target = std::make_shared<OpenXRStereo>(configuration);
     return target;
 }
diff --git a/src/Renderer.cpp b/src/Renderer.cpp
index 3ea19ff..100d78e 100644
--- a/src/Renderer.cpp
+++ b/src/Renderer.cpp
@@ -101,21 +101,15 @@ void Renderer::retrieveTimestamps() {
     }
 }
 
-void Renderer::recreateSwapchain() {
-    auto oldExtent = swapchain->swapchainExtent;
-    spdlog::debug("Recreating swapchain");
-    swapchain->recreate();
-    if (swapchain->swapchainExtent == oldExtent) {
-        return;
-    }
-
-    auto [width, height] = swapchain->swapchainExtent;
+void Renderer::recreatePipelines() {
+    auto [width, height] = swapchain->currentExtent();
     auto tileX = (width + 16 - 1) / 16;
     auto tileY = (height + 16 - 1) / 16;
     tileBoundaryBuffer->realloc(tileX * tileY * sizeof(uint32_t) * 2);
 
     recordPreprocessCommandBuffer();
     createRenderPipeline();
+    return;
 }
 
 void Renderer::initializeVulkan() {
@@ -328,7 +322,7 @@ void Renderer::createPreprocessSortPipeline() {
 
 void Renderer::createTileBoundaryPipeline() {
     spdlog::debug("Creating tile boundary pipeline");
-    auto [width, height] = swapchain->swapchainExtent;
+    auto [width, height] = swapchain->currentExtent();
     auto tileX = (width + 16 - 1) / 16;
     auto tileY = (height + 16 - 1) / 16;
     tileBoundaryBuffer = Buffer::storage(context, tileX * tileY * sizeof(uint32_t) * 2, false);
@@ -383,14 +377,15 @@ void Renderer::draw() {
     }
     context->device->resetFences(inflightFences[0].get());
 
-    auto res = context->device->acquireNextImageKHR(swapchain->swapchain.get(), UINT64_MAX,
-                                                    swapchain->imageAvailableSemaphores[0].get(),
-                                                    nullptr, &currentImageIndex);
-    if (res == vk::Result::eErrorOutOfDateKHR) {
-        recreateSwapchain();
+    auto [optionalImageIndex, extentChanged] = swapchain->acquireNextImage();
+    if (extentChanged) {
+        recreatePipelines();
+    }
+
+    if (!optionalImageIndex.has_value()) {
         return;
-    } else if (res != vk::Result::eSuccess && res != vk::Result::eSuboptimalKHR) {
-        throw std::runtime_error("Failed to acquire swapchain image");
+    } else {
+        currentImageIndex = optionalImageIndex.value();
     }
 
 startOfRenderLoop:
@@ -417,24 +412,10 @@ void Renderer::draw() {
             .setWaitDstStageMask(waitStage);
     context->queues[VulkanContext::Queue::COMPUTE].queue.submit(submitInfo, inflightFences[0].get());
 
-    vk::PresentInfoKHR presentInfo{};
-    presentInfo.waitSemaphoreCount = 1;
-    presentInfo.pWaitSemaphores = &renderFinishedSemaphores[0].get();
-    presentInfo.swapchainCount = 1;
-    presentInfo.pSwapchains = &swapchain->swapchain.get();
-    presentInfo.pImageIndices = &currentImageIndex;
-
-    try {
-        ret = context->queues[VulkanContext::Queue::PRESENT].queue.presentKHR(presentInfo);
-    } catch (vk::OutOfDateKHRError &e) {
-        recreateSwapchain();
-        return;
-    }
+    extentChanged = swapchain->present(std::vector<vk::Semaphore>{renderFinishedSemaphores[0].get()}, currentImageIndex);
 
-    if (ret == vk::Result::eErrorOutOfDateKHR || ret == vk::Result::eSuboptimalKHR) {
-        recreateSwapchain();
-    } else if (ret != vk::Result::eSuccess) {
-        throw std::runtime_error("Failed to present swapchain image");
+    if (extentChanged) {
+        recreatePipelines();
     }
 }
 
@@ -592,7 +573,7 @@ bool Renderer::recordRenderCommandBuffer(uint32_t currentFrame) {
     preprocessSortPipeline->bind(renderCommandBuffer, 0, iters % 2 == 0 ? 0 : 1);
     renderCommandBuffer->writeTimestamp(vk::PipelineStageFlagBits::eComputeShader, context->queryPool.get(),
                                         queryManager->registerQuery("preprocess_sort_start"));
-    uint32_t tileX = (swapchain->swapchainExtent.width + 16 - 1) / 16;
+    uint32_t tileX = (swapchain->currentExtent().width + 16 - 1) / 16;
     // assert(tileX == 50);
     renderCommandBuffer->pushConstants(preprocessSortPipeline->pipelineLayout.get(),
                                        vk::ShaderStageFlagBits::eCompute, 0,
@@ -667,7 +648,7 @@ bool Renderer::recordRenderCommandBuffer(uint32_t currentFrame) {
     renderPipeline->bind(renderCommandBuffer, 0, std::vector<uint32_t>{0, currentImageIndex});
     renderCommandBuffer->writeTimestamp(vk::PipelineStageFlagBits::eComputeShader, context->queryPool.get(),
                                         queryManager->registerQuery("render_start"));
-    auto [width, height] = swapchain->swapchainExtent;
+    auto [width, height] = swapchain->currentExtent();
     uint32_t constants[2] = {width, height};
     renderCommandBuffer->pushConstants(renderPipeline->pipelineLayout.get(),
                                        vk::ShaderStageFlagBits::eCompute, 0,
@@ -731,7 +712,7 @@ bool Renderer::recordRenderCommandBuffer(uint32_t currentFrame) {
 
 void Renderer::updateUniforms() {
     UniformBuffer data{};
-    auto [width, height] = swapchain->swapchainExtent;
+    auto [width, height] = swapchain->currentExtent();
     data.width = width;
     data.height = height;
     data.camera_position = glm::vec4(camera.position, 1.0f);
diff --git a/src/Renderer.h b/src/Renderer.h
index 0760a56..2c7ed6a 100644
--- a/src/Renderer.h
+++ b/src/Renderer.h
@@ -6,7 +6,7 @@
 #include <atomic>
 #include "3dgs.h"
 
-#include "vulkan/RenderingTarget.h"
+#include "vulkan/RenderTarget.h"
 #include "GSScene.h"
 #include "vulkan/pipelines/ComputePipeline.h"
 #include "vulkan/Swapchain.h"
@@ -66,7 +66,7 @@ class Renderer {
 
     void retrieveTimestamps();
 
-    void recreateSwapchain();
+    void recreatePipelines();
 
     void draw();
 
@@ -86,7 +86,7 @@ class Renderer {
 
 private:
     VulkanSplatting::RendererConfiguration configuration;
-    std::shared_ptr<RenderingTarget> window;
+    std::shared_ptr<RenderTarget> window;
     std::shared_ptr<VulkanContext> context;
     std::shared_ptr<ImguiManager> imguiManager;
     std::shared_ptr<GSScene> scene;
diff --git a/src/vulkan/ImguiManager.cpp b/src/vulkan/ImguiManager.cpp
index fd534ed..900f310 100644
--- a/src/vulkan/ImguiManager.cpp
+++ b/src/vulkan/ImguiManager.cpp
@@ -7,7 +7,7 @@
 #include "targets/GLFWWindow.h"
 
 ImguiManager::ImguiManager(std::shared_ptr<VulkanContext> context, std::shared_ptr<Swapchain> swapchain,
-                           std::shared_ptr<RenderingTarget> window) : context(context), swapchain(swapchain), window(window) {
+                           std::shared_ptr<RenderTarget> window) : context(context), swapchain(swapchain), window(window) {
 }
 
 void ImguiManager::createCommandPool() {
@@ -171,7 +171,7 @@ void ImguiManager::draw(vk::CommandBuffer commandBuffer, uint32_t currentImageIn
     vk::RenderingAttachmentInfoKHR attachment_info{
         swapchain->swapchainImages[currentImageIndex]->imageView.get(), vk::ImageLayout::eColorAttachmentOptimal
     };
-    vk::RenderingInfoKHR rendering_info{{}, vk::Rect2D{{0, 0}, swapchain->swapchainExtent}, 1, {}, 1, &attachment_info};
+    vk::RenderingInfoKHR rendering_info{{}, vk::Rect2D{{0, 0}, swapchain->currentExtent()}, 1, {}, 1, &attachment_info};
     commandBuffer.beginRenderingKHR(rendering_info);
     ImGui_ImplVulkan_RenderDrawData(ImGui::GetDrawData(), commandBuffer);
     commandBuffer.endRenderingKHR();
diff --git a/src/vulkan/ImguiManager.h b/src/vulkan/ImguiManager.h
index a84724b..d051a45 100644
--- a/src/vulkan/ImguiManager.h
+++ b/src/vulkan/ImguiManager.h
@@ -5,11 +5,11 @@
 
 #include "VulkanContext.h"
 #include "Swapchain.h"
-#include "RenderingTarget.h"
+#include "RenderTarget.h"
 
 class ImguiManager {
 public:
-    ImguiManager(std::shared_ptr<VulkanContext> context, std::shared_ptr<Swapchain> swapchain, std::shared_ptr<RenderingTarget> window);
+    ImguiManager(std::shared_ptr<VulkanContext> context, std::shared_ptr<Swapchain> swapchain, std::shared_ptr<RenderTarget> window);
 
     void createCommandPool();
 
@@ -25,7 +25,7 @@ class ImguiManager {
 private:
     std::shared_ptr<VulkanContext> context;
     std::shared_ptr<Swapchain> swapchain;
-    std::shared_ptr<RenderingTarget> window;
+    std::shared_ptr<RenderTarget> window;
     vk::UniqueCommandPool commandPool;
     vk::UniqueCommandBuffer commandBuffer;
     vk::UniqueFence fence;
diff --git a/src/vulkan/RenderingTarget.h b/src/vulkan/RenderTarget.h
similarity index 94%
rename from src/vulkan/RenderingTarget.h
rename to src/vulkan/RenderTarget.h
index 46b3ebf..b751134 100644
--- a/src/vulkan/RenderingTarget.h
+++ b/src/vulkan/RenderTarget.h
@@ -7,7 +7,7 @@
 
 #include "VulkanContext.h"
 
-class RenderingTarget {
+class RenderTarget {
 public:
     virtual VkSurfaceKHR createSurface(std::shared_ptr<VulkanContext> context) = 0;
 
@@ -34,7 +34,7 @@ class RenderingTarget {
         return std::nullopt;
     }
 
-    virtual ~RenderingTarget() = default;
+    virtual ~RenderTarget() = default;
 
 };
 
diff --git a/src/vulkan/Swapchain.cpp b/src/vulkan/Swapchain.cpp
index 7311f3c..2179c1f 100644
--- a/src/vulkan/Swapchain.cpp
+++ b/src/vulkan/Swapchain.cpp
@@ -4,7 +4,7 @@
 #include "spdlog/spdlog.h"
 #include <vk_enum_string_helper.h>
 
-Swapchain::Swapchain(const std::shared_ptr<VulkanContext>& context, const std::shared_ptr<RenderingTarget>& window,
+Swapchain::Swapchain(const std::shared_ptr<VulkanContext> &context, const std::shared_ptr<RenderTarget> &window,
                      bool immediate) : context(context), window(window), immediate(immediate) {
     createSwapchain();
     createSwapchainImages();
@@ -20,7 +20,7 @@ void Swapchain::createSwapchain() {
     auto [width, height] = window->getFramebufferSize();
 
     surfaceFormat = formats[0];
-    for (const auto& availableFormat: formats) {
+    for (const auto &availableFormat: formats) {
         if (availableFormat.format == vk::Format::eB8G8R8A8Unorm &&
             availableFormat.colorSpace == vk::ColorSpaceKHR::eSrgbNonlinear) {
             surfaceFormat = availableFormat;
@@ -30,7 +30,7 @@ void Swapchain::createSwapchain() {
     spdlog::debug("Surface format: {}", string_VkFormat(static_cast<VkFormat>(surfaceFormat.format)));
 
     presentMode = vk::PresentModeKHR::eFifo;
-    for (const auto& availablePresentMode: presentModes) {
+    for (const auto &availablePresentMode: presentModes) {
         if (immediate && availablePresentMode == vk::PresentModeKHR::eImmediate) {
             presentMode = availablePresentMode;
             break;
@@ -49,7 +49,8 @@ void Swapchain::createSwapchain() {
         extent.height = std::clamp(height, capabilities.minImageExtent.height, capabilities.maxImageExtent.height);
     }
 
-    spdlog::debug("Swapchain extent range: {}x{} - {}x{}", capabilities.minImageExtent.width, capabilities.minImageExtent.height,
+    spdlog::debug("Swapchain extent range: {}x{} - {}x{}", capabilities.minImageExtent.width,
+                  capabilities.minImageExtent.height,
                   capabilities.maxImageExtent.width, capabilities.maxImageExtent.height);
 
     imageCount = capabilities.minImageCount + 1;
@@ -69,7 +70,7 @@ void Swapchain::createSwapchain() {
     createInfo.imageUsage = vk::ImageUsageFlagBits::eColorAttachment | vk::ImageUsageFlagBits::eStorage;
 
     std::vector<uint32_t> uniqueQueueFamilies;
-    for (auto& queue: context->queues) {
+    for (auto &queue: context->queues) {
         if (std::find(uniqueQueueFamilies.begin(), uniqueQueueFamilies.end(), queue.first) ==
             uniqueQueueFamilies.end()) {
             uniqueQueueFamilies.push_back(queue.first);
@@ -100,7 +101,7 @@ void Swapchain::createSwapchain() {
 void Swapchain::createSwapchainImages() {
     auto images = context->device->getSwapchainImagesKHR(*swapchain);
 
-    for (auto& image: images) {
+    for (auto &image: images) {
         auto imageView = context->device->createImageViewUnique({
             {}, image, vk::ImageViewType::e2D,
             swapchainFormat, {},
@@ -121,7 +122,25 @@ void Swapchain::createSwapchainImages() {
     }
 }
 
-void Swapchain::recreate() {
+std::pair<std::optional<uint32_t>, bool> Swapchain::acquireNextImage() {
+    uint32_t currentImageIndex;
+    auto res = context->device->acquireNextImageKHR(swapchain.get(), UINT64_MAX,
+                                                    imageAvailableSemaphores[0].get(),
+                                                    nullptr, &currentImageIndex);
+    if (res == vk::Result::eErrorOutOfDateKHR) {
+        if (recreateSwapchain()) {
+            return {std::nullopt, true};
+        }
+        return {std::nullopt, false};
+    } else if (res != vk::Result::eSuccess && res != vk::Result::eSuboptimalKHR) {
+        throw std::runtime_error("Failed to acquire swapchain image");
+    }
+    return {{currentImageIndex}, false};
+}
+
+bool Swapchain::recreateSwapchain() {
+    auto oldExtent = currentExtent();
+    spdlog::debug("Recreating swapchain");
     context->device->waitIdle();
     swapchain.reset();
     swapchainImages.clear();
@@ -129,4 +148,21 @@ void Swapchain::recreate() {
     createSwapchain();
     createSwapchainImages();
     spdlog::debug("Swapchain recreated");
+    return currentExtent() != oldExtent;
+}
+
+bool Swapchain::present(const std::vector<vk::Semaphore> &waitSemaphores, uint32_t imageIndex) {
+    vk::PresentInfoKHR presentInfo{waitSemaphores, swapchain.get(), imageIndex};
+    try {
+        auto ret = context->queues[VulkanContext::Queue::PRESENT].queue.presentKHR(presentInfo);
+        if (ret == vk::Result::eSuboptimalKHR || ret == vk::Result::eErrorOutOfDateKHR) {
+            return recreateSwapchain();
+        }
+        if (ret != vk::Result::eSuccess) {
+            throw std::runtime_error("Failed to present swapchain image");
+        }
+    } catch (vk::OutOfDateKHRError &e) {
+        return recreateSwapchain();
+    }
+    return false;
 }
diff --git a/src/vulkan/Swapchain.h b/src/vulkan/Swapchain.h
index f768c38..6c7f780 100644
--- a/src/vulkan/Swapchain.h
+++ b/src/vulkan/Swapchain.h
@@ -4,31 +4,42 @@
 
 #include <memory>
 #include "VulkanContext.h"
-#include "RenderingTarget.h"
+#include "RenderTarget.h"
 
 class Swapchain {
 public:
-    Swapchain(const std::shared_ptr<VulkanContext> &context, const std::shared_ptr<RenderingTarget> &window, bool immediate);
+    Swapchain(const std::shared_ptr<VulkanContext> &context, const std::shared_ptr<RenderTarget> &window, bool immediate);
+
+    [[nodiscard]] virtual vk::Extent2D currentExtent() const {
+        return swapchainExtent;
+    }
+
+    std::pair<std::optional<uint32_t>, bool> acquireNextImage();
+
+    bool present(const std::vector<vk::Semaphore> &waitSemaphores, uint32_t uint32);
 
-    vk::UniqueSwapchainKHR swapchain;
-    vk::Extent2D swapchainExtent;
     std::vector<std::shared_ptr<Image>> swapchainImages;
     std::vector<vk::UniqueSemaphore> imageAvailableSemaphores;
-    vk::SurfaceFormatKHR surfaceFormat;
     vk::Format swapchainFormat;
-    vk::PresentModeKHR presentMode;
     uint32_t imageCount;
 
-    void recreate();
 private:
     std::shared_ptr<VulkanContext> context;
-    std::shared_ptr<RenderingTarget> window;
+    std::shared_ptr<RenderTarget> window;
+
+    vk::UniqueSwapchainKHR swapchain;
+    vk::SurfaceFormatKHR surfaceFormat;
+    vk::Extent2D swapchainExtent;
+    vk::PresentModeKHR presentMode;
 
     bool immediate = false;
 
     void createSwapchain();
 
     void createSwapchainImages();
+
+    bool recreateSwapchain();
+
 };
 
 
diff --git a/src/vulkan/targets/GLFWWindow.h b/src/vulkan/targets/GLFWWindow.h
index 647042d..4c41b68 100644
--- a/src/vulkan/targets/GLFWWindow.h
+++ b/src/vulkan/targets/GLFWWindow.h
@@ -1,9 +1,9 @@
 #ifndef GLFWWINDOW_H
 #define GLFWWINDOW_H
 
-#include "../RenderingTarget.h"
+#include "../RenderTarget.h"
 
-class GLFWWindow final : public RenderingTarget {
+class GLFWWindow final : public RenderTarget {
 public:
     GLFWWindow(std::string name, int width, int height);
 
diff --git a/src/vulkan/targets/MetalWindow.h b/src/vulkan/targets/MetalWindow.h
index 993ebc1..2ed2ae2 100644
--- a/src/vulkan/targets/MetalWindow.h
+++ b/src/vulkan/targets/MetalWindow.h
@@ -1,9 +1,9 @@
 #ifndef METALWINDOW_H
 #define METALWINDOW_H
-#include "../RenderingTarget.h"
+#include "../RenderTarget.h"
 #include "../VulkanContext.h"
 
-class MetalWindow final : public RenderingTarget {
+class MetalWindow final : public RenderTarget {
 public:
     MetalWindow(void *caMetalLayer, int width, int height);
 
diff --git a/src/vulkan/targets/OpenXRStereo.cpp b/src/vulkan/targets/OpenXRStereo.cpp
index dcd4951..7649f7b 100644
--- a/src/vulkan/targets/OpenXRStereo.cpp
+++ b/src/vulkan/targets/OpenXRStereo.cpp
@@ -1,10 +1,10 @@
+#ifdef VKGS_ENABLE_OPENXR
 #include "OpenXRStereo.h"
-
 VkSurfaceKHR OpenXRStereo::createSurface(std::shared_ptr<VulkanContext> context) {
 }
 
 std::array<bool, 3> OpenXRStereo::getMouseButton() {
-    return RenderingTarget::getMouseButton();
+    return RenderTarget::getMouseButton();
 }
 
 std::vector<std::string> OpenXRStereo::getRequiredInstanceExtensions() {
@@ -16,31 +16,31 @@ std::vector<std::string> OpenXRStereo::getRequiredDeviceExtensions() {
 }
 
 std::pair<uint32_t, uint32_t> OpenXRStereo::getFramebufferSize() const {
-    return RenderingTarget::getFramebufferSize();
+    return {};
 }
 
 std::array<double, 2> OpenXRStereo::getCursorTranslation() {
-    return RenderingTarget::getCursorTranslation();
+    return RenderTarget::getCursorTranslation();
 }
 
 std::array<bool, 7> OpenXRStereo::getKeys() {
-    return RenderingTarget::getKeys();
+    return RenderTarget::getKeys();
 }
 
 void OpenXRStereo::mouseCapture(bool capture) {
-    RenderingTarget::mouseCapture(capture);
+    RenderTarget::mouseCapture(capture);
 }
 
 bool OpenXRStereo::tick() {
-    return RenderingTarget::tick();
+    return RenderTarget::tick();
 }
 
 void OpenXRStereo::logTranslation(float x, float y) {
-    RenderingTarget::logTranslation(x, y);
+    RenderTarget::logTranslation(x, y);
 }
 
 void OpenXRStereo::logMovement(float x, float y) {
-    RenderingTarget::logMovement(x, y);
+    RenderTarget::logMovement(x, y);
 }
 
 std::optional<vk::PhysicalDevice> OpenXRStereo::requirePhysicalDevice(vk::Instance instance) {
@@ -52,3 +52,4 @@ void OpenXRStereo::postVulkanInit(vk::Instance instance, vk::PhysicalDevice phys
     uint32_t queueFamily, uint32_t queueIndex) {
     configuration.postVulkanInit(instance, physicalDevice, device, queueFamily, queueIndex);
 }
+#endif
\ No newline at end of file
diff --git a/src/vulkan/targets/OpenXRStereo.h b/src/vulkan/targets/OpenXRStereo.h
index adba290..0c0b49f 100644
--- a/src/vulkan/targets/OpenXRStereo.h
+++ b/src/vulkan/targets/OpenXRStereo.h
@@ -4,9 +4,9 @@
 #include <string>
 #include <vector>
 
-#include "../RenderingTarget.h"
+#include "../RenderTarget.h"
 
-class OpenXRStereo : public RenderingTarget {
+class OpenXRStereo : public RenderTarget {
 public:
     explicit OpenXRStereo(const VulkanSplatting::OpenXRConfiguration &configuration)
         : configuration(configuration) {