[add]: unified interface

11 files changed, 952 insertions, 186 deletions

diff --git a/assets/shaders/Geodesic.slang b/assets/shaders/Geodesic.slang
index 9120ac0..7acbd78 100644
--- a/assets/shaders/Geodesic.slang
+++ b/assets/shaders/Geodesic.slang
@@ -28,8 +28,9 @@ struct Disk
     float disk_r1;      // inner edge (clamped to the ISCO, 3 r_s, below)
     float disk_r2;      // outer edge
     float disk_num;     // turbulence strength (0 = smooth physical disk)
-    float thickness;    // unused by the thin-disk model; kept for UBO layout
-    float disk_density; // overall disk brightness / exposure
+    float thickness;    // slab half-height (anti-aliases the edge-on disk)
+    float disk_density; // disk brightness / exposure
+    float temperature;  // Kelvin at the flux peak (disk colour)
 };
 ConstantBuffer<Disk> disk;
 
@@ -73,8 +74,6 @@ static const float MAX_STEP_SIZE = 2e10;
 // Display mapping for the (relative) Novikov-Thorne flux -> visible colour.
 // The RADIAL PROFILE is physical; the absolute temperature scale is a display
 // choice (a real Sgr A* disk is far cooler / redder than this).
-static const float T_PEAK        = 4800.0;   // Kelvin at the flux peak (display scale)
-static const float DISK_EXPOSURE = 0.9;      // overall brightness of the disk
 
 struct Hit
 {
@@ -162,7 +161,7 @@ float3 DiskEmission(float3 P, float3 rayDir)
     float xr   = rc / rin;
     float flux = max((1.0 - sqrt(1.0 / xr)) / (xr * xr * xr), 0.0);
     float Tn   = pow(flux / FLUX_PEAK, 0.25);            // normalised temperature, peak ~ 1
-    float Temit = T_PEAK * Tn;
+    float Temit = disk.temperature * Tn;
 
     // Keplerian orbit (prograde about +Y). Locally-measured orbital speed for a
     // Schwarzschild circular geodesic: v = sqrt( M / (r - 2M) ) = 0.5 c at ISCO.
@@ -197,8 +196,7 @@ float3 DiskEmission(float3 P, float3 rayDir)
         bright *= max(turb, 0.0);
     }
 
-    float exposure = DISK_EXPOSURE * max(disk.disk_density, 0.0) * 10.0;
-    return colour * bright * exposure;
+    return colour * bright * max(disk.disk_density, 0.0);
 }
 
 struct Ray
diff --git a/src/core/application.cpp b/src/core/application.cpp
index f9e52a4..ae8a5d9 100644
--- a/src/core/application.cpp
+++ b/src/core/application.cpp
@@ -13,6 +13,7 @@
 #include <ImGuizmo.h>
 
 #include "platform/vulkan/vulkan_renderer.h"
+#include "platform/opengl/opengl_renderer.h"
 
 #ifdef __APPLE__
 #include "platform/metal/metal_context.h"
@@ -60,12 +61,12 @@ namespace Donut
     {
         while (m_running)
         {
-            if (m_vulkan_renderer)
+            if (m_renderer)
             {
                 glfwPollEvents(); // before the ImGui frame so input is current
                 if (!m_minimized)
-                    m_vulkan_renderer->draw_frame(glm::vec4(0.05f, 0.06f, 0.10f, 1.0f),
-                                                [this] { build_vulkan_ui(); });
+                    m_renderer->draw_frame(glm::vec4(0.05f, 0.06f, 0.10f, 1.0f),
+                                                [this] { build_ui(); });
             }
             else
             {
@@ -79,86 +80,138 @@ namespace Donut
         }
     }
 
-    auto Application::build_vulkan_ui() -> void
+    // One-time ImGui theme: rounded, roomy, dark with a warm accretion-disk accent.
+    static auto apply_donut_style() -> void
     {
-        ImGui::Begin("Donut - Vulkan backend");
-        ImGui::Text("Geodesic black hole through Vulkan (MoltenVK).");
-        ImGui::Text("%.1f FPS", ImGui::GetIO().Framerate);
-        ImGui::Separator();
+        ImGuiStyle& s = ImGui::GetStyle();
+        s.WindowRounding = 7.0f; s.ChildRounding = 5.0f; s.FrameRounding = 4.0f;
+        s.GrabRounding = 4.0f; s.PopupRounding = 4.0f; s.ScrollbarRounding = 5.0f; s.TabRounding = 4.0f;
+        s.WindowPadding = ImVec2(12, 12); s.FramePadding = ImVec2(9, 5);
+        s.ItemSpacing = ImVec2(9, 8); s.ItemInnerSpacing = ImVec2(7, 5);
+        s.WindowBorderSize = 0.0f; s.FrameBorderSize = 0.0f; s.WindowTitleAlign = ImVec2(0.02f, 0.5f);
 
-        if (m_vulkan_renderer)
-        {
-            bool scene = m_vulkan_renderer->is_scene_mode();
-            ImGui::Text("View");
-            if (ImGui::RadioButton("Black hole", !scene)) m_vulkan_renderer->set_scene_mode(false);
-            ImGui::SameLine();
-            if (ImGui::RadioButton("Scene", scene))       m_vulkan_renderer->set_scene_mode(true);
-            ImGui::Separator();
+        const ImVec4 amber   = ImVec4(0.98f, 0.62f, 0.20f, 1.00f);
+        const ImVec4 amberHi = ImVec4(1.00f, 0.73f, 0.36f, 1.00f);
+        ImVec4* c = s.Colors;
+        c[ImGuiCol_WindowBg]        = ImVec4(0.07f, 0.08f, 0.10f, 0.97f);
+        c[ImGuiCol_ChildBg]         = ImVec4(0.10f, 0.11f, 0.13f, 0.55f);
+        c[ImGuiCol_PopupBg]         = ImVec4(0.09f, 0.10f, 0.12f, 0.98f);
+        c[ImGuiCol_TitleBg]         = ImVec4(0.09f, 0.10f, 0.12f, 1.00f);
+        c[ImGuiCol_TitleBgActive]   = ImVec4(0.13f, 0.14f, 0.17f, 1.00f);
+        c[ImGuiCol_Text]            = ImVec4(0.90f, 0.91f, 0.93f, 1.00f);
+        c[ImGuiCol_TextDisabled]    = ImVec4(0.48f, 0.50f, 0.54f, 1.00f);
+        c[ImGuiCol_FrameBg]         = ImVec4(0.16f, 0.17f, 0.20f, 1.00f);
+        c[ImGuiCol_FrameBgHovered]  = ImVec4(0.22f, 0.24f, 0.28f, 1.00f);
+        c[ImGuiCol_FrameBgActive]   = ImVec4(0.26f, 0.28f, 0.33f, 1.00f);
+        c[ImGuiCol_Header]          = ImVec4(0.17f, 0.19f, 0.23f, 1.00f);
+        c[ImGuiCol_HeaderHovered]   = ImVec4(0.24f, 0.27f, 0.32f, 1.00f);
+        c[ImGuiCol_HeaderActive]    = ImVec4(0.28f, 0.31f, 0.37f, 1.00f);
+        c[ImGuiCol_Button]          = ImVec4(0.20f, 0.22f, 0.26f, 1.00f);
+        c[ImGuiCol_ButtonHovered]   = ImVec4(0.27f, 0.30f, 0.35f, 1.00f);
+        c[ImGuiCol_ButtonActive]    = amber;
+        c[ImGuiCol_SliderGrab]      = amber;
+        c[ImGuiCol_SliderGrabActive]= amberHi;
+        c[ImGuiCol_CheckMark]       = amberHi;
+        c[ImGuiCol_Separator]       = ImVec4(0.20f, 0.22f, 0.26f, 1.00f);
+        c[ImGuiCol_ScrollbarGrab]   = ImVec4(0.24f, 0.26f, 0.30f, 1.00f);
+    }
 
-            if (scene)
-            {
-                ImGui::TextDisabled("Drag to orbit, scroll to zoom. HDRI skybox behind.");
-                ImGui::Separator();
+    auto Application::build_ui() -> void
+    {
+        static bool styled = false;
+        if (!styled) { apply_donut_style(); styled = true; }
+        if (!m_renderer) return;
+        RendererBackend& r = *m_renderer;
 
-                auto& objs = m_vulkan_renderer->scene_objects();
-                static int sel = 0;
-                if (sel >= (int)objs.size()) sel = (int)objs.size() - 1;
+        // Full-viewport dock space with a pass-through centre, so the panel can be
+        // docked to any edge while the render shows through the middle.
+        ImGui::DockSpaceOverViewport(0, ImGui::GetMainViewport(), ImGuiDockNodeFlags_PassthruCentralNode);
 
-                ImGui::Text("Spheres (%d)", (int)objs.size());
-                if (ImGui::Button("Add") && objs.size() < 64)
-                {
-                    SceneObject o;
-                    o.position = glm::vec3(((int)objs.size() % 5) * 5.0f - 10.0f, 2.0f, ((int)objs.size() / 5) * 5.0f);
-                    o.radius   = 1.5f;
-                    o.color    = glm::vec3(0.35f + 0.12f * (objs.size() % 5), 0.55f, 0.9f - 0.12f * (objs.size() % 4));
-                    objs.push_back(o);
-                    sel = (int)objs.size() - 1;
-                }
-                ImGui::SameLine();
-                if (ImGui::Button("Delete") && !objs.empty())
-                {
-                    objs.erase(objs.begin() + sel);
-                    if (sel >= (int)objs.size()) sel = (int)objs.size() - 1;
-                }
+        ImGui::SetNextWindowSize(ImVec2(340, 580), ImGuiCond_FirstUseEver);
+        ImGui::Begin("Donut  \xc2\xb7  Black Hole");
 
-                ImGui::BeginChild("obj_list", ImVec2(0, 90), true);
-                for (int i = 0; i < (int)objs.size(); ++i)
-                {
-                    std::string label = "Sphere " + std::to_string(i);
-                    if (ImGui::Selectable(label.c_str(), sel == i)) sel = i;
-                }
-                ImGui::EndChild();
+        // --- header: device + performance -----------------------------------
+        ImGuiIO& io = ImGui::GetIO();
+        ImGui::TextDisabled("%s", r.device_name().empty() ? "GPU" : r.device_name().c_str());
+        ImGui::Text("%.0f FPS", io.Framerate);
+        ImGui::SameLine(); ImGui::TextDisabled("%.1f ms/frame", io.Framerate > 0 ? 1000.0f / io.Framerate : 0.0f);
+        ImGui::Spacing();
 
-                m_vulkan_renderer->set_selected_object(sel);
-                if (sel >= 0 && sel < (int)objs.size())
-                {
-                    SceneObject& o = objs[sel];
-                    ImGui::DragFloat3("Position", &o.position.x, 0.1f);
-                    ImGui::DragFloat("Radius", &o.radius, 0.05f, 0.1f, 20.0f);
-                    ImGui::ColorEdit3("Color", &o.color.x);
-                }
+        if (ImGui::CollapsingHeader("Renderer", ImGuiTreeNodeFlags_DefaultOpen))
+        {
+            auto& s = SettingsManager::get_settings();
+            const char* apis[] = { "OpenGL", "Vulkan" };
+            int cur = (s.graphics.render_api == "Vulkan") ? 1 : 0;
+            if (ImGui::Combo("Graphics API", &cur, apis, 2))
+            {
+                s.graphics.render_api = apis[cur];
+                SettingsManager::save_settings();
             }
+            const char* running = (RendererAPI::get_api() == RendererAPI::API::Vulkan) ? "Vulkan" : "OpenGL";
+            if (s.graphics.render_api != running)
+                ImGui::TextColored(ImVec4(0.98f, 0.62f, 0.20f, 1.0f), "Restart to apply (%s running)", running);
             else
+                ImGui::TextDisabled("Active backend: %s", running);
+        }
+
+        ImGui::Spacing();
+        bool scene = r.is_scene_mode();
+        ImGui::TextDisabled("VIEW");
+        if (ImGui::RadioButton("Black hole", !scene)) r.set_scene_mode(false);
+        ImGui::SameLine();
+        if (ImGui::RadioButton("Scene", scene))       r.set_scene_mode(true);
+        ImGui::Separator();
+
+        if (scene)
+        {
+            build_scene_ui();
+        }
+        else
+        {
+            BlackHoleParams& bh = r.black_hole_params();
+
+            if (ImGui::CollapsingHeader("Camera", ImGuiTreeNodeFlags_DefaultOpen))
             {
-                bool free_fly = m_vulkan_renderer->is_free_fly();
-                ImGui::Text("Camera");
-                if (ImGui::RadioButton("Orbital", !free_fly))  m_vulkan_renderer->set_free_fly(false);
+                bool ff = r.is_free_fly();
+                if (ImGui::RadioButton("Orbital", !ff)) r.set_free_fly(false);
                 ImGui::SameLine();
-                if (ImGui::RadioButton("Free-fly", free_fly))  m_vulkan_renderer->set_free_fly(true);
-                ImGui::TextDisabled(free_fly ? "WASD move | Q/E down-up | Shift boost | drag to look"
-                                             : "Drag to orbit | scroll to zoom");
-                ImGui::Separator();
+                if (ImGui::RadioButton("Free-fly", ff)) r.set_free_fly(true);
+                ImGui::SameLine();
+                if (ImGui::Button("Reset view")) r.reset_camera();
+                ImGui::SliderFloat("FOV", &bh.fov_degrees, 20.0f, 90.0f, "%.0f\xc2\xb0");
+                ImGui::TextDisabled(ff ? "WASD move | Q/E down-up | Shift boost | drag look"
+                                       : "Drag to orbit | scroll to zoom");
+            }
+
+            if (ImGui::CollapsingHeader("Accretion disk", ImGuiTreeNodeFlags_DefaultOpen))
+            {
+                ImGui::SliderFloat("Temperature", &bh.temperature, 2000.0f, 15000.0f, "%.0f K");
+                ImGui::SliderFloat("Brightness",  &bh.brightness, 0.0f, 3.0f, "%.2f");
+                ImGui::SliderFloat("Inner radius", &bh.disk_inner_rs, 3.0f, 12.0f, "%.1f r_s");
+                if (bh.disk_outer_rs < bh.disk_inner_rs + 0.5f) bh.disk_outer_rs = bh.disk_inner_rs + 0.5f;
+                ImGui::SliderFloat("Outer radius", &bh.disk_outer_rs, bh.disk_inner_rs + 0.5f, 25.0f, "%.1f r_s");
+                ImGui::SliderFloat("Turbulence",  &bh.turbulence, 0.0f, 2.0f, "%.2f");
+                ImGui::TextDisabled("Inner edge is the ISCO (3 r_s). Novikov-Thorne profile.");
+            }
 
+            if (ImGui::CollapsingHeader("Quality"))
+            {
+                ImGui::SliderInt("Integration steps", &bh.quality_steps, 2000, 15000);
+                ImGui::TextDisabled("Deeper lensing at higher cost. Settled frame is 4x supersampled.");
+            }
+
+            if (ImGui::CollapsingHeader("Environment", ImGuiTreeNodeFlags_DefaultOpen))
+            {
                 auto& hdri = HDRIManager::get();
-                std::string current = m_vulkan_renderer->current_hdri();
+                std::string current = r.current_hdri();
                 std::string preview = hdri.get_hdri_name(current);
-                if (ImGui::BeginCombo("HDRI", preview.c_str()))
+                if (ImGui::BeginCombo("Starfield", preview.c_str()))
                 {
                     for (const auto& path : hdri.get_available_hdri())
                     {
                         bool selected = (path == current);
                         if (ImGui::Selectable(hdri.get_hdri_name(path).c_str(), selected))
-                            m_vulkan_renderer->set_hdri(path);
+                            r.set_hdri(path);
                         if (selected) ImGui::SetItemDefaultFocus();
                     }
                     ImGui::EndCombo();
@@ -170,6 +223,52 @@ namespace Donut
         ImGui::End();
     }
 
+    auto Application::build_scene_ui() -> void
+    {
+        RendererBackend& r = *m_renderer;
+        if (!ImGui::CollapsingHeader("Objects", ImGuiTreeNodeFlags_DefaultOpen))
+            return;
+
+        ImGui::TextDisabled("Drag to orbit, scroll to zoom. HDRI skybox behind.");
+        auto& objs = r.scene_objects();
+        static int sel = 0;
+        if (sel >= (int)objs.size()) sel = (int)objs.size() - 1;
+
+        ImGui::Text("Spheres (%d)", (int)objs.size());
+        if (ImGui::Button("Add") && objs.size() < 64)
+        {
+            SceneObject o;
+            o.position = glm::vec3(((int)objs.size() % 5) * 5.0f - 10.0f, 2.0f, ((int)objs.size() / 5) * 5.0f);
+            o.radius   = 1.5f;
+            o.color    = glm::vec3(0.35f + 0.12f * (objs.size() % 5), 0.55f, 0.9f - 0.12f * (objs.size() % 4));
+            objs.push_back(o);
+            sel = (int)objs.size() - 1;
+        }
+        ImGui::SameLine();
+        if (ImGui::Button("Delete") && !objs.empty())
+        {
+            objs.erase(objs.begin() + sel);
+            if (sel >= (int)objs.size()) sel = (int)objs.size() - 1;
+        }
+
+        ImGui::BeginChild("obj_list", ImVec2(0, 90), true);
+        for (int i = 0; i < (int)objs.size(); ++i)
+        {
+            std::string label = "Sphere " + std::to_string(i);
+            if (ImGui::Selectable(label.c_str(), sel == i)) sel = i;
+        }
+        ImGui::EndChild();
+
+        r.set_selected_object(sel);
+        if (sel >= 0 && sel < (int)objs.size())
+        {
+            SceneObject& o = objs[sel];
+            ImGui::DragFloat3("Position", &o.position.x, 0.1f);
+            ImGui::DragFloat("Radius", &o.radius, 0.05f, 0.1f, 20.0f);
+            ImGui::ColorEdit3("Color", &o.color.x);
+        }
+    }
+
     auto Application::close() -> void
     {
         m_running = false;
@@ -192,9 +291,9 @@ namespace Donut
             else
                 m_minimized = false;
 
-            if (m_vulkan_renderer)
+            if (m_renderer)
             {
-                m_vulkan_renderer->on_resize(e.get_width(), e.get_height());
+                m_renderer->resize(e.get_width(), e.get_height());
             }
             else
             {
@@ -237,44 +336,29 @@ namespace Donut
 
     auto Application::on_init() -> void
     {
-        // (Logger, settings and API selection happen in the constructor.)
+        // (Logger, settings and API selection happen in the constructor.) Both
+        // backends run the SAME application through the RendererBackend interface,
+        // so the app behaves identically regardless of the active graphics API.
+        int w = 0, h = 0;
+        glfwGetFramebufferSize((GLFWwindow*)m_window->get_native_window(), &w, &h);
 
         if (RendererAPI::get_api() == RendererAPI::API::Vulkan)
-        {
-            int w = 0, h = 0;
-            glfwGetFramebufferSize((GLFWwindow*)m_window->get_native_window(), &w, &h);
-            m_vulkan_renderer = create_scope<VulkanRenderer>();
-            if (!m_vulkan_renderer->init(m_window->get_native_window(), w, h))
-                DONUT_ERROR("Vulkan renderer initialization failed");
-            else
-                m_vulkan_renderer->init_im_gui();
-            // Scene rendering hooks in here in the B-3 phase; the Vulkan path now
-            // clears, presents, and draws the ImGui UI.
-            return;
-        }
-
-        Renderer::init();
-        m_window->init_im_gui();
-
-        Renderer::on_window_resize(1280, 720);
-        RenderCommand::set_face_culling(false);
-
-        m_engine = create_scope<Engine>();
-        m_engine->set_window_dimensions(1280, 720);
+            m_renderer = create_scope<VulkanRenderer>();
+        else
+            m_renderer = create_scope<OpenGLRenderer>();
 
-        m_state_manager = create_scope<StateManager>();
-        m_state_manager->register_state("Config",       create_scope<ConfigState>());
-        m_state_manager->register_state("Simulation",   create_scope<SimulationState>());
-        m_state_manager->register_state("WorldBuilder", create_scope<WorldBuilderState>());
-        m_state_manager->switch_to_state("Config");
+        if (!m_renderer->init(m_window->get_native_window(), w, h))
+            DONUT_ERROR("Renderer initialization failed");
+        else
+            m_renderer->init_ui();
     }
 
     auto Application::on_shutdown() -> void
     {
-        if (m_vulkan_renderer)
+        if (m_renderer)
         {
-            m_vulkan_renderer->shutdown();
-            m_vulkan_renderer.reset();
+            m_renderer->shutdown();
+            m_renderer.reset();
         }
         else
         {
diff --git a/src/core/application.h b/src/core/application.h
index 06c4e94..4c377f0 100644
--- a/src/core/application.h
+++ b/src/core/application.h
@@ -7,11 +7,10 @@
 #include "log.h"
 
 #include "engine/engine.h"
+#include "rendering/renderer_backend.h"
 
 namespace Donut
 {
-    class VulkanRenderer; // live-window Vulkan backend (platform/vulkan)
-
     class Application
     {
     public:
@@ -34,13 +33,14 @@ namespace Donut
         auto on_render() -> void;
         auto on_event(Event& event) -> void;
         auto setup_docking_layout() -> void;
-        auto build_vulkan_ui() -> void; // ImGui UI built each frame on the Vulkan path
+        auto build_ui() -> void;       // shared ImGui panel, drives the active RendererBackend
+        auto build_scene_ui() -> void; // scene-view (object list) section of the UI
 
     private:
         Scope<StateManager> m_state_manager;
         Scope<Window> m_window;
         Scope<Engine> m_engine;
-        Scope<VulkanRenderer> m_vulkan_renderer; // non-null only when the Vulkan API is selected
+        Scope<RendererBackend> m_renderer; // active backend (non-null once a backend runs the app)
 
         bool m_running;
         bool m_minimized;
diff --git a/src/engine/engine.cpp b/src/engine/engine.cpp
index 059fdda..bf5a2b6 100644
--- a/src/engine/engine.cpp
+++ b/src/engine/engine.cpp
@@ -51,7 +51,7 @@ namespace Donut
         }
 
         m_camera_ubo = UniformBuffer::create(128, 1);
-        m_disk_ubo   = UniformBuffer::create(sizeof(float) * 5, 2);
+        m_disk_ubo   = UniformBuffer::create(sizeof(float) * 6, 2);  // r1,r2,turbulence,thickness,brightness,temperature
 
         uint32_t obj_ubo_size = sizeof(int) + 3 * sizeof(float)
             + 16 * (sizeof(glm::vec4) + sizeof(glm::vec4))
@@ -231,16 +231,25 @@ namespace Donut
             int   _pad4;
         } data;
 
-        glm::vec3 fwd   = glm::normalize(cam.get_orbital_target() - cam.get_orbital_position());
-        glm::vec3 up    = glm::vec3(0, 1, 0);
-        glm::vec3 right = glm::normalize(glm::cross(fwd, up));
-        up = glm::cross(right, fwd);
+        glm::vec3 pos, fwd;
+        if (cam.get_camera_mode() == CameraMode::FPS)
+        {
+            pos = cam.get_position();
+            fwd = cam.get_forward_direction();
+        }
+        else
+        {
+            pos = cam.get_orbital_position();
+            fwd = glm::normalize(cam.get_orbital_target() - pos);
+        }
+        glm::vec3 right = glm::normalize(glm::cross(fwd, glm::vec3(0, 1, 0)));
+        glm::vec3 up    = glm::cross(right, fwd);
 
-        data.pos        = cam.get_orbital_position();
+        data.pos        = pos;
         data.right      = right;
         data.up         = up;
         data.forward    = fwd;
-        data.tan_half_fov = static_cast<float>(tan(glm::radians(60.0f * 0.5f)));
+        data.tan_half_fov = static_cast<float>(tan(glm::radians(m_bh.fov_degrees * 0.5f)));
         data.aspect     = static_cast<float>(get_compute_width()) / static_cast<float>(m_compute_height);
         data.moving     = cam.is_dragging() || cam.is_panning();
 
@@ -275,12 +284,17 @@ namespace Donut
 
     auto Engine::upload_disk_ubo() -> void
     {
-        float r1 = static_cast<float>(m_sag_a.m_rs * 2.2);
-        float r2 = static_cast<float>(m_sag_a.m_rs * 5.2);
-        float num = 2.0f;
-        float thickness = static_cast<float>(m_sag_a.m_rs * m_disk_thickness);
-        float disk_data[5] = { r1, r2, num, thickness, m_disk_density };
-
+        // Layout matches the shared Geodesic Disk struct (same as Vulkan). Radii
+        // are in Schwarzschild radii x the shader's SagA_rs constant (1.269e10).
+        const float rs = 1.269e10f;
+        float disk_data[6] = {
+            std::max(m_bh.disk_inner_rs, 3.0f) * rs,
+            std::max(m_bh.disk_outer_rs, m_bh.disk_inner_rs + 0.5f) * rs,
+            std::max(m_bh.turbulence, 0.0f),
+            rs * 0.1f,                              // slab half-thickness (fixed)
+            std::max(m_bh.brightness, 0.0f),
+            std::max(m_bh.temperature, 1000.0f),
+        };
         m_disk_ubo->set_data(disk_data, sizeof(disk_data));
         m_disk_ubo->bind(2);
     }
@@ -295,20 +309,17 @@ namespace Donut
             float time;
         } data;
 
-        data.max_steps_moving    = m_max_steps_moving;
-        data.max_steps_static    = m_max_steps_static;
+        data.max_steps_moving    = m_bh.quality_steps;
+        data.max_steps_static    = m_bh.quality_steps;   // resolution/tiling is the lever, not step count
         data.early_exit_distance = m_early_exit_distance;
         data.time              = static_cast<float>(glfwGetTime()) * m_rotation_speed;
 
 #ifdef __APPLE__
         // macOS has no compute shaders, so the geodesic pass runs as a tiled
-        // fragment shader under the OS GPU watchdog. The stock step counts
-        // (up to 30000) make a single tile exceed the watchdog and hang the
-        // GPU, so cap them here. Windows/Linux keep the full step count.
-        // While the camera moves, render cheaply so interaction stays smooth;
-        // when it settles, spend more steps for a cleaner image. Both stay well
-        // under the per-tile GPU-watchdog budget (see draw_geodesic_pass).
-        data.max_steps_moving = std::min(data.max_steps_moving, 4000);
+        // fragment shader under the OS GPU watchdog. Cap the step count so a
+        // single 64px tile stays under the safe per-submission budget (~25M
+        // pixel-steps); Windows/Linux keep the full count.
+        data.max_steps_moving = std::min(data.max_steps_moving, 6000);
         data.max_steps_static = std::min(data.max_steps_static, 6000);
 #endif
 
diff --git a/src/engine/engine.h b/src/engine/engine.h
index c7d02b5..fef8b57 100644
--- a/src/engine/engine.h
+++ b/src/engine/engine.h
@@ -12,6 +12,7 @@
 #include "object.h"
 
 #include "rendering/renderer.h"
+#include "rendering/renderer_backend.h"
 #include "rendering/shader.h"
 #include "rendering/vertex_array.h"
 #include "rendering/texture.h"
@@ -131,6 +132,10 @@ namespace Donut
 
         auto set_hdri_environment(Ref<CubemapTexture> hdri) -> void { m_hdri_environment = hdri; }
         auto get_hdri_environment() const -> Ref<CubemapTexture> { return m_hdri_environment; }
+
+        // Shared live black-hole/disk parameters (drives the geodesic UBOs so the
+        // GL path renders identically to Vulkan). The OpenGL backend mutates this.
+        auto black_hole_params() -> BlackHoleParams& { return m_bh; }
     private:
         auto create_compute_program(const char* path) -> Ref<Shader>;
         std::pair<Ref<VertexArray>, Ref<Texture2D>> QuadVAO();
@@ -175,6 +180,8 @@ namespace Donut
         int   m_max_steps_static    = 30000;
         float m_early_exit_distance = 5.0e11f;
 
+        BlackHoleParams m_bh;   // shared UI-tunable disk/camera params (GL geodesic driver)
+
         float m_disk_thickness = 0.1f;
         float m_disk_density   = 0.1f;
         float m_rotation_speed = 1.0f;
diff --git a/src/platform/opengl/opengl_renderer.cpp b/src/platform/opengl/opengl_renderer.cpp
new file mode 100644
index 0000000..ae12f10
--- /dev/null
+++ b/src/platform/opengl/opengl_renderer.cpp
@@ -0,0 +1,377 @@
+#include "opengl_renderer.h"
+
+#include "engine/engine.h"
+#include "core/log.h"
+#include "core/camera.h"
+#include "core/hdri_manager.h"
+#include "rendering/renderer.h"   // Renderer::init / RenderCommand
+
+#include <glad/glad.h>
+#include <GLFW/glfw3.h>
+#include <imgui.h>
+#include <imgui_impl_glfw.h>
+#include <imgui_impl_opengl3.h>
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <cmath>
+#include <vector>
+
+#include "core/hdri_manager.h"
+#include "rendering/texture.h"    // CubemapTexture::bind
+
+namespace Donut
+{
+    // Scroll is accumulated through a chained GLFW callback (keeps ImGui's scroll
+    // handling intact), consumed once per frame for orbital zoom.
+    static double       g_scroll_accum = 0.0;
+    static GLFWscrollfun g_prev_scroll  = nullptr;
+    static void gl_scroll_cb(GLFWwindow* w, double x, double y)
+    {
+        if (g_prev_scroll) g_prev_scroll(w, x, y);
+        g_scroll_accum += y;
+    }
+
+    OpenGLRenderer::OpenGLRenderer() = default;
+    OpenGLRenderer::~OpenGLRenderer() = default;
+
+    auto OpenGLRenderer::init(void* glfwWindow, int width, int height) -> bool
+    {
+        m_window = glfwWindow;
+        auto* win = static_cast<GLFWwindow*>(glfwWindow);
+        glfwMakeContextCurrent(win);
+
+        Renderer::init();                       // GLAD load + default GL state
+        RenderCommand::set_face_culling(false);
+
+        const GLubyte* name = glGetString(GL_RENDERER);
+        m_device_name = name ? reinterpret_cast<const char*>(name) : "OpenGL";
+
+        m_engine = create_scope<Engine>();
+        m_engine->set_window_dimensions(width, height);
+#ifdef __APPLE__
+        m_engine->set_compute_height(256);      // capped for the macOS watchdog (tiled fragment pass)
+#else
+        m_engine->set_compute_height(540);
+#endif
+        m_engine->update_compute_dimensions();
+
+        // Match the Vulkan framing exactly (camera sits outside the disk).
+        Camera& cam = m_engine->get_camera();
+        cam.set_camera_mode(CameraMode::Orbital);
+        cam.set_orbital_target(glm::vec3(0.0f));
+        cam.set_orbital_radius(4e11);
+        cam.set_orbital_limits(2.2e11, 1.5e12);
+        cam.set_orbital_speed(0.01f);
+        cam.set_zoom_speed(3e10);
+        cam.set_azimuth(0.0f);
+        cam.set_elevation(1.25f);
+
+        m_hdri_path = "assets/hdri/HDR_blue_nebulae-1.hdr";
+        HDRIManager::get().set_current_hdri(m_hdri_path);
+
+        create_scene_resources();
+
+        DONUT_INFO("OpenGL renderer ready: {} ({}x{})", m_device_name, width, height);
+        return true;
+    }
+
+    auto OpenGLRenderer::init_ui() -> bool
+    {
+        IMGUI_CHECKVERSION();
+        ImGui::CreateContext();
+        ImGui::GetIO().ConfigFlags |= ImGuiConfigFlags_DockingEnable;
+        ImGui::StyleColorsDark();
+        ImGui_ImplGlfw_InitForOpenGL(static_cast<GLFWwindow*>(m_window), true);
+        ImGui_ImplOpenGL3_Init("#version 410");
+        g_prev_scroll = glfwSetScrollCallback(static_cast<GLFWwindow*>(m_window), gl_scroll_cb);
+        m_ui_ready = true;
+        DONUT_INFO("OpenGL: ImGui backend initialized");
+        return true;
+    }
+
+    auto OpenGLRenderer::shutdown() -> void
+    {
+        if (m_ui_ready)
+        {
+            ImGui_ImplOpenGL3_Shutdown();
+            ImGui_ImplGlfw_Shutdown();
+            ImGui::DestroyContext();
+            m_ui_ready = false;
+        }
+        m_engine.reset();
+    }
+
+    auto OpenGLRenderer::resize(int width, int height) -> void
+    {
+        if (m_engine) m_engine->set_window_dimensions(width, height);
+    }
+
+    auto OpenGLRenderer::process_input() -> void
+    {
+        auto*   win     = static_cast<GLFWwindow*>(m_window);
+        Camera& cam     = m_scene_mode ? m_scene_camera : m_engine->get_camera();
+        bool    over_ui = m_ui_ready && ImGui::GetIO().WantCaptureMouse;
+
+        double now = glfwGetTime();
+        float  dt  = m_last_frame_time > 0.0 ? static_cast<float>(now - m_last_frame_time) : 0.0f;
+        m_last_frame_time = now;
+
+        double mx = 0, my = 0; glfwGetCursorPos(win, &mx, &my);
+        bool left_down = glfwGetMouseButton(win, GLFW_MOUSE_BUTTON_LEFT) == GLFW_PRESS;
+
+        if (!m_scene_mode && cam.get_camera_mode() == CameraMode::FPS)
+        {
+            if (left_down && !m_left_was_down) { m_last_x = mx; m_last_y = my; }
+            if (left_down && !over_ui)
+                cam.on_mouse_move(static_cast<float>(mx - m_last_x), static_cast<float>(m_last_y - my));
+            m_last_x = mx; m_last_y = my; m_left_was_down = left_down;
+
+            bool over_kb = m_ui_ready && ImGui::GetIO().WantCaptureKeyboard;
+            if (!over_kb && dt > 0.0f)
+            {
+                float mdt = dt * (glfwGetKey(win, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS ? 4.0f : 1.0f);
+                if (glfwGetKey(win, GLFW_KEY_W) == GLFW_PRESS) cam.move_forward(mdt);
+                if (glfwGetKey(win, GLFW_KEY_S) == GLFW_PRESS) cam.move_backward(mdt);
+                if (glfwGetKey(win, GLFW_KEY_A) == GLFW_PRESS) cam.move_left(mdt);
+                if (glfwGetKey(win, GLFW_KEY_D) == GLFW_PRESS) cam.move_right(mdt);
+                if (glfwGetKey(win, GLFW_KEY_E) == GLFW_PRESS) cam.move_up(mdt);
+                if (glfwGetKey(win, GLFW_KEY_Q) == GLFW_PRESS) cam.move_down(mdt);
+            }
+            g_scroll_accum = 0.0;   // scroll unused in free-fly
+        }
+        else
+        {
+            if (left_down && !m_left_was_down && !over_ui)
+                cam.process_orbital_mouse_button(GLFW_MOUSE_BUTTON_LEFT, GLFW_PRESS, 0);
+            else if (!left_down && m_left_was_down)
+                cam.process_orbital_mouse_button(GLFW_MOUSE_BUTTON_LEFT, GLFW_RELEASE, 0);
+            m_left_was_down = left_down;
+
+            cam.process_orbital_mouse_move(mx, my);
+            double scroll = g_scroll_accum; g_scroll_accum = 0.0;
+            if (scroll != 0.0 && !over_ui) cam.process_orbital_scroll(0.0, scroll);
+        }
+    }
+
+    // 36-vertex unit cube for the skybox (positions only; the shader forces depth=1).
+    static const float SKYBOX_CUBE[] = {
+        -1, 1,-1, -1,-1,-1,  1,-1,-1,  1,-1,-1,  1, 1,-1, -1, 1,-1,
+        -1,-1, 1, -1,-1,-1, -1, 1,-1, -1, 1,-1, -1, 1, 1, -1,-1, 1,
+         1,-1,-1,  1,-1, 1,  1, 1, 1,  1, 1, 1,  1, 1,-1,  1,-1,-1,
+        -1,-1, 1, -1, 1, 1,  1, 1, 1,  1, 1, 1,  1,-1, 1, -1,-1, 1,
+        -1, 1,-1,  1, 1,-1,  1, 1, 1,  1, 1, 1, -1, 1, 1, -1, 1,-1,
+        -1,-1,-1, -1,-1, 1,  1,-1,-1,  1,-1,-1, -1,-1, 1,  1,-1, 1,
+    };
+
+    auto OpenGLRenderer::create_scene_resources() -> void
+    {
+        const float PI = 3.14159265358979f;
+
+        m_grid_shader   = Ref<Shader>(Shader::create("assets/shaders/Grid.glsl"));
+        m_sphere_shader = Ref<Shader>(Shader::create("assets/shaders/Sphere.glsl"));
+        m_skybox_shader = Ref<Shader>(Shader::create("assets/shaders/Skybox.glsl"));
+
+        m_scene_camera.set_camera_mode(CameraMode::Orbital);
+        m_scene_camera.set_orbital_target(glm::vec3(0.0f));
+        m_scene_camera.set_orbital_radius(15.0);
+        m_scene_camera.set_orbital_limits(2.0, 200.0);
+        m_scene_camera.set_orbital_speed(0.01f);
+        m_scene_camera.set_zoom_speed(2.0);
+        m_scene_camera.set_azimuth(0.0f);
+        m_scene_camera.set_elevation(PI / 3.0f);
+
+        // Grid: +/-50 lines on the XZ plane (Grid shader scales by u_GridSize/50).
+        std::vector<glm::vec3> lines;
+        for (int i = -50; i <= 50; ++i)
+        {
+            lines.push_back({ (float)i, 0.0f, -50.0f }); lines.push_back({ (float)i, 0.0f, 50.0f });
+            lines.push_back({ -50.0f, 0.0f, (float)i }); lines.push_back({ 50.0f, 0.0f, (float)i });
+        }
+        m_grid_vertex_count = (int)lines.size();
+        glGenVertexArrays(1, &m_grid_vao); glGenBuffers(1, &m_grid_vbo);
+        glBindVertexArray(m_grid_vao); glBindBuffer(GL_ARRAY_BUFFER, m_grid_vbo);
+        glBufferData(GL_ARRAY_BUFFER, lines.size() * sizeof(glm::vec3), lines.data(), GL_STATIC_DRAW);
+        glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(glm::vec3), (void*)0);
+
+        // Sphere: indexed UV sphere (position + normal), unit radius.
+        const int RINGS = 24, SECT = 48;
+        std::vector<float> sv; std::vector<unsigned int> si;
+        for (int r = 0; r <= RINGS; ++r)
+        {
+            float th = PI * r / RINGS;
+            for (int s = 0; s <= SECT; ++s)
+            {
+                float ph = 2.0f * PI * s / SECT;
+                glm::vec3 p(sinf(th) * cosf(ph), cosf(th), sinf(th) * sinf(ph));
+                sv.insert(sv.end(), { p.x, p.y, p.z, p.x, p.y, p.z });   // pos, normal (unit sphere)
+            }
+        }
+        for (int r = 0; r < RINGS; ++r)
+            for (int s = 0; s < SECT; ++s)
+            {
+                int a = r * (SECT + 1) + s, b = a + SECT + 1;
+                si.insert(si.end(), { (unsigned)a, (unsigned)b, (unsigned)(a + 1),
+                                      (unsigned)(a + 1), (unsigned)b, (unsigned)(b + 1) });
+            }
+        m_sphere_index_count = (int)si.size();
+        glGenVertexArrays(1, &m_sphere_vao); glGenBuffers(1, &m_sphere_vbo); glGenBuffers(1, &m_sphere_ebo);
+        glBindVertexArray(m_sphere_vao);
+        glBindBuffer(GL_ARRAY_BUFFER, m_sphere_vbo);
+        glBufferData(GL_ARRAY_BUFFER, sv.size() * sizeof(float), sv.data(), GL_STATIC_DRAW);
+        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_sphere_ebo);
+        glBufferData(GL_ELEMENT_ARRAY_BUFFER, si.size() * sizeof(unsigned), si.data(), GL_STATIC_DRAW);
+        glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
+        glEnableVertexAttribArray(1); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float)));
+
+        // Skybox cube.
+        glGenVertexArrays(1, &m_skybox_vao); glGenBuffers(1, &m_skybox_vbo);
+        glBindVertexArray(m_skybox_vao); glBindBuffer(GL_ARRAY_BUFFER, m_skybox_vbo);
+        glBufferData(GL_ARRAY_BUFFER, sizeof(SKYBOX_CUBE), SKYBOX_CUBE, GL_STATIC_DRAW);
+        glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
+
+        glBindVertexArray(0);
+        m_scene_ready = true;
+    }
+
+    auto OpenGLRenderer::render_scene(int w, int h) -> void
+    {
+        if (!m_grid_shader || !m_sphere_shader || !m_skybox_shader) return;
+        glViewport(0, 0, w, h);
+        glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+        float aspect = h > 0 ? (float)w / (float)h : 1.0f;
+        m_scene_camera.set_projection(45.0f, aspect, 0.1f, 1000.0f);
+        glm::mat4 proj = m_scene_camera.get_projection_matrix();
+        glm::mat4 view = m_scene_camera.get_view_matrix();
+        glm::mat4 vp   = proj * view;
+        glm::vec3 cam  = m_scene_camera.get_orbital_position();
+
+        // Skybox behind everything (depth test on, write off; shader forces depth=1).
+        glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glDepthMask(GL_FALSE);
+        m_skybox_shader->bind();
+        m_skybox_shader->set_mat4("u_Projection", proj);
+        m_skybox_shader->set_mat4("u_View", glm::mat4(glm::mat3(view)));   // strip translation
+        auto hdri = HDRIManager::get().get_current_hdri();
+        if (hdri) { hdri->bind(0); m_skybox_shader->set_int("u_Skybox", 0); }
+        glBindVertexArray(m_skybox_vao); glDrawArrays(GL_TRIANGLES, 0, 36);
+
+        // Lit spheres.
+        glDepthFunc(GL_LESS); glDepthMask(GL_TRUE);
+        m_sphere_shader->bind(); glBindVertexArray(m_sphere_vao);
+        for (int i = 0; i < (int)m_scene_objects.size(); ++i)
+        {
+            const SceneObject& o = m_scene_objects[i];
+            m_sphere_shader->set_mat4("u_ViewProjection", vp);
+            m_sphere_shader->set_mat4("u_Transform",
+                glm::translate(glm::mat4(1.0f), o.position) * glm::scale(glm::mat4(1.0f), glm::vec3(o.radius)));
+            m_sphere_shader->set_float3("u_Color", o.color);
+            m_sphere_shader->set_float("u_Specular", 0.6f);
+            m_sphere_shader->set_float("u_Emission", 0.0f);
+            m_sphere_shader->set_float3("u_LightPos", glm::vec3(10.0f, 20.0f, 10.0f));
+            m_sphere_shader->set_float3("u_CameraPos", cam);
+            m_sphere_shader->set_int("u_IsSelected", i == m_selected_object ? 1 : 0);
+            m_sphere_shader->set_float3("u_OutlineColor", glm::vec3(1.0f, 1.0f, 0.0f));
+            m_sphere_shader->set_float("u_OutlineWidth", 0.15f);
+            glDrawElements(GL_TRIANGLES, m_sphere_index_count, GL_UNSIGNED_INT, 0);
+        }
+
+        // Transparent grid on top (test, no depth write).
+        glDepthMask(GL_FALSE); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+        m_grid_shader->bind();
+        m_grid_shader->set_mat4("u_ViewProjection", vp);
+        m_grid_shader->set_mat4("u_Transform", glm::mat4(1.0f));
+        m_grid_shader->set_float("u_GridSize", 50.0f);
+        m_grid_shader->set_float3("u_GridColor", glm::vec3(0.55f, 0.55f, 0.6f));
+        m_grid_shader->set_float("u_GridAlpha", 0.75f);
+        m_grid_shader->set_float3("u_CameraPos", cam);
+        glBindVertexArray(m_grid_vao); glDrawArrays(GL_LINES, 0, m_grid_vertex_count);
+        glDisable(GL_BLEND); glDepthMask(GL_TRUE); glBindVertexArray(0);
+    }
+
+    auto OpenGLRenderer::draw_frame(const glm::vec4& clear_color,
+                                    const std::function<void()>& build_ui) -> void
+    {
+        auto* win = static_cast<GLFWwindow*>(m_window);
+        process_input();
+
+        int w = 0, h = 0; glfwGetFramebufferSize(win, &w, &h);
+
+        if (m_scene_mode)
+        {
+            render_scene(w, h);
+        }
+        else
+        {
+            m_engine->set_window_dimensions(w, h);
+            // Geodesic pass -> low-res texture (watchdog-tiled on macOS), then
+            // upscale to the window. Disk/camera come from the shared BlackHoleParams.
+            m_engine->dispatch_compute(m_engine->get_camera());
+            RenderCommand::set_viewport(0, 0, w, h);
+            RenderCommand::set_clear_color(clear_color);
+            RenderCommand::clear();
+            m_engine->draw_full_screen_quad();
+        }
+
+        if (m_ui_ready)
+        {
+            ImGui_ImplOpenGL3_NewFrame();
+            ImGui_ImplGlfw_NewFrame();
+            ImGui::NewFrame();
+            if (build_ui) build_ui();
+            ImGui::Render();
+            ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
+        }
+        glfwSwapBuffers(win);
+    }
+
+    auto OpenGLRenderer::set_scene_mode(bool enabled) -> void { m_scene_mode = enabled; }
+    auto OpenGLRenderer::is_scene_mode() const -> bool { return m_scene_mode; }
+
+    auto OpenGLRenderer::set_free_fly(bool enabled) -> void
+    {
+        Camera& cam = m_engine->get_camera();
+        if (enabled && cam.get_camera_mode() != CameraMode::FPS)
+        {
+            glm::vec3 pos = cam.get_orbital_position();
+            glm::vec3 fwd = glm::normalize(cam.get_orbital_target() - pos);
+            float pitch = glm::degrees(asinf(glm::clamp(fwd.y, -1.0f, 1.0f)));
+            float yaw   = glm::degrees(atan2f(fwd.z, fwd.x));
+            cam.set_position(pos);
+            cam.set_rotation(glm::vec3(pitch, yaw, 0.0f));
+            cam.set_movement_speed(2.0e10f);
+            cam.set_mouse_sensitivity(0.15f);
+            cam.set_camera_mode(CameraMode::FPS);
+        }
+        else if (!enabled)
+        {
+            cam.set_camera_mode(CameraMode::Orbital);
+        }
+    }
+
+    auto OpenGLRenderer::is_free_fly() const -> bool
+    {
+        return m_engine->get_camera().get_camera_mode() == CameraMode::FPS;
+    }
+
+    auto OpenGLRenderer::reset_camera() -> void
+    {
+        Camera& cam = m_engine->get_camera();
+        cam.set_camera_mode(CameraMode::Orbital);
+        cam.set_orbital_radius(4e11);
+        cam.set_azimuth(0.0f);
+        cam.set_elevation(1.25f);
+    }
+
+    auto OpenGLRenderer::set_hdri(const std::string& path) -> void
+    {
+        HDRIManager::get().set_current_hdri(path);  // the Engine re-reads it each frame
+        m_hdri_path = path;
+    }
+
+    auto OpenGLRenderer::current_hdri() const -> const std::string& { return m_hdri_path; }
+    auto OpenGLRenderer::scene_objects() -> std::vector<SceneObject>& { return m_scene_objects; }
+    auto OpenGLRenderer::set_selected_object(int index) -> void { m_selected_object = index; }
+    auto OpenGLRenderer::black_hole_params() -> BlackHoleParams& { return m_engine->black_hole_params(); }
+    auto OpenGLRenderer::device_name() const -> const std::string& { return m_device_name; }
+}
diff --git a/src/platform/opengl/opengl_renderer.h b/src/platform/opengl/opengl_renderer.h
new file mode 100644
index 0000000..4258f40
--- /dev/null
+++ b/src/platform/opengl/opengl_renderer.h
@@ -0,0 +1,72 @@
+#pragma once
+
+#include "rendering/renderer_backend.h"
+#include "core/memory.h"
+#include "core/camera.h"
+#include "rendering/shader.h"
+
+// OpenGL implementation of the shared RendererBackend interface. It renders the
+// SAME cross-compiled Geodesic shader the Vulkan backend does (driven by the
+// same BlackHoleParams + camera), so the application behaves identically on
+// either backend. Wraps the Engine, which owns the GL geodesic/present passes
+// and the macOS watchdog-safe tiled rendering.
+namespace Donut
+{
+    class Engine;
+
+    class OpenGLRenderer : public RendererBackend
+    {
+    public:
+        OpenGLRenderer();
+        ~OpenGLRenderer() override;
+
+        auto init(void* glfwWindow, int width, int height) -> bool override;
+        auto init_ui() -> bool override;
+        auto shutdown() -> void override;
+        auto resize(int width, int height) -> void override;
+        auto draw_frame(const glm::vec4& clear_color,
+                        const std::function<void()>& build_ui) -> void override;
+
+        auto set_scene_mode(bool enabled) -> void override;
+        auto is_scene_mode() const -> bool override;
+        auto set_free_fly(bool enabled) -> void override;
+        auto is_free_fly() const -> bool override;
+        auto reset_camera() -> void override;
+
+        auto set_hdri(const std::string& path) -> void override;
+        auto current_hdri() const -> const std::string& override;
+        auto scene_objects() -> std::vector<SceneObject>& override;
+        auto set_selected_object(int index) -> void override;
+        auto black_hole_params() -> BlackHoleParams& override;
+
+        auto device_name() const -> const std::string& override;
+
+    private:
+        auto process_input() -> void;
+        auto create_scene_resources() -> void;   // grid + sphere + skybox meshes/shaders
+        auto render_scene(int width, int height) -> void;
+
+        void*                    m_window = nullptr;
+        Scope<Engine>            m_engine;
+
+        // World-builder scene view (normal-scale): mirrors the Vulkan scene view
+        // with the same shared Grid/Sphere/Skybox shaders.
+        Camera        m_scene_camera{ 45.0f, 16.0f / 9.0f, 0.1f, 1000.0f };
+        Ref<Shader>   m_grid_shader, m_sphere_shader, m_skybox_shader;
+        unsigned int  m_grid_vao = 0, m_grid_vbo = 0;
+        unsigned int  m_sphere_vao = 0, m_sphere_vbo = 0, m_sphere_ebo = 0;
+        unsigned int  m_skybox_vao = 0, m_skybox_vbo = 0;
+        int           m_grid_vertex_count = 0, m_sphere_index_count = 0;
+        bool          m_scene_ready = false;
+        std::vector<SceneObject> m_scene_objects{ SceneObject{} };
+        int                      m_selected_object = 0;
+        std::string              m_hdri_path;
+        std::string              m_device_name;
+        bool                     m_scene_mode = false;
+        bool                     m_ui_ready   = false;
+
+        double m_last_x = 0.0, m_last_y = 0.0;
+        bool   m_left_was_down = false;
+        double m_last_frame_time = 0.0;
+    };
+}
diff --git a/src/platform/vulkan/vulkan_renderer.cpp b/src/platform/vulkan/vulkan_renderer.cpp
index 8ecf088..8b0d0c0 100644
--- a/src/platform/vulkan/vulkan_renderer.cpp
+++ b/src/platform/vulkan/vulkan_renderer.cpp
@@ -105,6 +105,9 @@ namespace Donut
         VkDeviceMemory cam_mem = VK_NULL_HANDLE, disk_mem = VK_NULL_HANDLE, obj_mem = VK_NULL_HANDLE, sim_mem = VK_NULL_HANDLE;
         void* cam_mapped = nullptr;
         void* sim_mapped = nullptr;
+        void* disk_mapped = nullptr;            // disk UBO, refilled from bh_params each frame
+        BlackHoleParams bh_params;              // live UI-tunable disk/camera parameters
+        std::string gpu_name;                   // physical device name for the UI
         Camera camera{ 60.0f, (float)GEO_HI_W / (float)GEO_HI_H, 0.1f, 100.0f };
         bool left_was_down = false;
         double last_frame_time = 0.0;               // for free-fly dt
@@ -323,7 +326,8 @@ namespace Donut
         VkPhysicalDeviceProperties props{};
         vkGetPhysicalDeviceProperties(physical, &props);
         vkGetPhysicalDeviceMemoryProperties(physical, &mem_props);
-        DONUT_INFO("Vulkan device: {}", props.deviceName);
+        gpu_name = props.deviceName;
+        DONUT_INFO("Vulkan device: {}", gpu_name);
         return true;
     }
 
@@ -670,12 +674,8 @@ namespace Donut
         camera.set_elevation(1.25f);
 
         void* p = nullptr;
-        vkMapMemory(device, cam_mem, 0, 128, 0, &cam_mapped);  // camera UBO is refilled every frame
-
-        // disk_r1=inner (ISCO 3 r_s), disk_r2=outer, disk_num=turbulence strength,
-        // thickness (unused by the thin-disk model), disk_density=exposure.
-        float disk_data[8] = { SagA_rs * 3.0f, SagA_rs * 12.0f, 0.4f, SagA_rs * 0.1f, 0.1f, 0, 0, 0 };
-        vkMapMemory(device, disk_mem, 0, 32, 0, &p); memcpy(p, disk_data, sizeof(disk_data)); vkUnmapMemory(device, disk_mem);
+        vkMapMemory(device, cam_mem, 0, 128, 0, &cam_mapped);   // camera UBO refilled every frame
+        vkMapMemory(device, disk_mem, 0, 32, 0, &disk_mapped);  // disk UBO refilled from bh_params every frame
 
         std::vector<uint8_t> obj_data(800, 0);
         int num_objects = 1; memcpy(obj_data.data(), &num_objects, 4);
@@ -1479,7 +1479,7 @@ namespace Donut
         }
         glm::vec3 right = glm::normalize(glm::cross(fwd, glm::vec3(0, 1, 0)));
         cam_data.pos = pos; cam_data.right = right; cam_data.up = glm::cross(right, fwd); cam_data.fwd = fwd;
-        cam_data.tan_half_fov = (float)tan(glm::radians(60.0f * 0.5f));
+        cam_data.tan_half_fov = (float)tan(glm::radians(bh_params.fov_degrees * 0.5f));
         cam_data.aspect = (float)GEO_HI_W / (float)GEO_HI_H;  // 16:9, same for both targets
         cam_data.moving = user_moving ? 1u : 0u;
         if (cam_mapped) memcpy(cam_mapped, &cam_data, sizeof(cam_data));
@@ -1495,11 +1495,26 @@ namespace Donut
         // Sourced from settings.toml (max_steps_static), capped GPU-safe.
         constexpr int kStepCeil = 15000;
         struct SimUBO { int steps_moving; int steps_static; float early_exit; float time; } sim;
-        sim.steps_static = std::clamp(SettingsManager::get_max_steps_static(), 1000, kStepCeil);
+        sim.steps_static = std::clamp(bh_params.quality_steps, 1000, kStepCeil);
         sim.steps_moving = sim.steps_static;  // same budget both frames; resolution is the lever
         sim.early_exit   = SettingsManager::get_early_exit_distance();
         sim.time = (float)(glfwGetTime() - start_time);
         if (sim_mapped) memcpy(sim_mapped, &sim, sizeof(sim));
+
+        // Disk UBO, refilled live from the UI-tunable parameters. Layout matches
+        // the shader Disk struct: r1, r2, turbulence, slab thickness, brightness,
+        // temperature. Radii are in Schwarzschild radii (x SagA_rs).
+        const float SagA_rs = 1.269e10f;
+        float disk_data[8] = {
+            std::max(bh_params.disk_inner_rs, 3.0f) * SagA_rs,
+            std::max(bh_params.disk_outer_rs, bh_params.disk_inner_rs + 0.5f) * SagA_rs,
+            std::max(bh_params.turbulence, 0.0f),
+            SagA_rs * 0.1f,                       // slab half-thickness (fixed)
+            std::max(bh_params.brightness, 0.0f),
+            std::max(bh_params.temperature, 1000.0f),
+            0.0f, 0.0f,
+        };
+        if (disk_mapped) memcpy(disk_mapped, disk_data, sizeof(disk_data));
     }
 
     static double g_ScrollAccum = 0.0;
@@ -1617,6 +1632,7 @@ namespace Donut
         if (cube_mem) vkFreeMemory(device, cube_mem, nullptr);
         if (cam_mapped) { vkUnmapMemory(device, cam_mem); cam_mapped = nullptr; }
         if (sim_mapped) { vkUnmapMemory(device, sim_mem); sim_mapped = nullptr; }
+        if (disk_mapped) { vkUnmapMemory(device, disk_mem); disk_mapped = nullptr; }
         VkBuffer ubos[4] = { cam_buf, disk_buf, obj_buf, sim_buf };
         VkDeviceMemory umem[4] = { cam_mem, disk_mem, obj_mem, sim_mem };
         for (int i = 0; i < 4; ++i) { if (ubos[i]) vkDestroyBuffer(device, ubos[i], nullptr); if (umem[i]) vkFreeMemory(device, umem[i], nullptr); }
@@ -1791,7 +1807,7 @@ namespace Donut
         return true;
     }
 
-    auto VulkanRenderer::init_im_gui() -> bool
+    auto VulkanRenderer::init_ui() -> bool
     {
         Impl& v = *m_impl;
         if (v.device == VK_NULL_HANDLE) return false;
@@ -1835,7 +1851,7 @@ namespace Donut
         return true;
     }
 
-    auto VulkanRenderer::on_resize(int width, int height) -> void
+    auto VulkanRenderer::resize(int width, int height) -> void
     {
         m_impl->framebuffer_resized = true;
         m_impl->width = width; m_impl->height = height;
@@ -1905,6 +1921,26 @@ namespace Donut
         if (m_impl) m_impl->selected_object = index;
     }
 
+    auto VulkanRenderer::black_hole_params() -> BlackHoleParams&
+    {
+        return m_impl->bh_params;
+    }
+
+    auto VulkanRenderer::reset_camera() -> void
+    {
+        if (!m_impl) return;
+        Camera& cam = m_impl->camera;
+        cam.set_camera_mode(CameraMode::Orbital);  // also flips is_free_fly() back
+        cam.set_orbital_radius(4e11);
+        cam.set_azimuth(0.0f);
+        cam.set_elevation(1.25f);
+    }
+
+    auto VulkanRenderer::device_name() const -> const std::string&
+    {
+        return m_impl->gpu_name;
+    }
+
     auto VulkanRenderer::draw_frame(const glm::vec4& clear_color, const std::function<void()>& build_ui) -> void
     {
         Impl& v = *m_impl;
diff --git a/src/platform/vulkan/vulkan_renderer.h b/src/platform/vulkan/vulkan_renderer.h
index a760cb4..d583f07 100644
--- a/src/platform/vulkan/vulkan_renderer.h
+++ b/src/platform/vulkan/vulkan_renderer.h
@@ -1,14 +1,12 @@
 #pragma once
 
-#include <glm/glm.hpp>
-#include <functional>
-#include <string>
-#include <vector>
+#include "rendering/renderer_backend.h"
 
 // Live-window Vulkan backend: owns the instance, surface, device, swapchain,
 // render pass, framebuffers and per-frame synchronization, and drives the
-// acquire -> record -> submit -> present loop. Pure-C++ header (no vulkan.h /
-// glfw leak); the GLFW window is passed as an opaque handle.
+// acquire -> record -> submit -> present loop. Implements the shared
+// RendererBackend interface (SceneObject / BlackHoleParams live there). Pure-C++
+// header (no vulkan.h / glfw leak); the GLFW window is passed as an opaque handle.
 namespace Donut
 {
     // Must be called BEFORE glfwInit() when the Vulkan API is selected: points
@@ -16,55 +14,34 @@ namespace Donut
     // macOS/Homebrew) and configures the MoltenVK ICD / layer paths.
     auto vulkan_prepare_glfw() -> void;
 
-    // A placeable/editable sphere in the world-builder scene view.
-    struct SceneObject
-    {
-        glm::vec3 position = { 0.0f, 2.0f, 0.0f };
-        float     radius   = 2.0f;
-        glm::vec3 color    = { 0.85f, 0.35f, 0.2f };
-    };
-
-    class VulkanRenderer
+    class VulkanRenderer : public RendererBackend
     {
     public:
         VulkanRenderer();
-        ~VulkanRenderer();
+        ~VulkanRenderer() override;
 
         // glfwWindow must be a GLFW window created with GLFW_NO_API.
-        auto init(void* glfwWindow, int width, int height) -> bool;
-        auto shutdown() -> void;
-
-        // Creates the ImGui context + Vulkan/GLFW backends. Call after init().
-        auto init_im_gui() -> bool;
-
-        // Renders + presents one frame: clears to clearColor, then (if init_im_gui
-        // ran) opens an ImGui frame, invokes buildUI to populate it, and draws it.
-        auto draw_frame(const glm::vec4& clearColor, const std::function<void()>& buildUI = {}) -> void;
-
-        auto on_resize(int width, int height) -> void;
-
-        // Rebuilds the starfield environment cubemap from another equirect .hdr
-        // at runtime (device-idle teardown + rebuild + descriptor rewrite).
-        // No-op if path is already the active HDRI.
-        auto set_hdri(const std::string& path) -> void;
+        auto init(void* glfwWindow, int width, int height) -> bool override;
+        auto init_ui() -> bool override;
+        auto shutdown() -> void override;
+        auto resize(int width, int height) -> void override;
 
-        // Filesystem path of the HDRI currently backing the cubemap.
-        auto current_hdri() const -> const std::string&;
+        auto draw_frame(const glm::vec4& clear_color,
+                        const std::function<void()>& build_ui) -> void override;
 
-        // Free-fly (WASD + mouse-look) camera vs the default orbital camera.
-        // Enabling seeds the fly pose from the current orbital framing (no jump).
-        auto set_free_fly(bool enabled) -> void;
-        auto is_free_fly() const -> bool;
+        auto set_scene_mode(bool enabled) -> void override;
+        auto is_scene_mode() const -> bool override;
+        auto set_free_fly(bool enabled) -> void override;   // seeds the fly pose from the orbital framing
+        auto is_free_fly() const -> bool override;
+        auto reset_camera() -> void override;
 
-        // Switch between the black-hole geodesic view and the world-builder scene
-        // view (grid/sphere/skybox drawn with real Vulkan geometry pipelines).
-        auto set_scene_mode(bool enabled) -> void;
-        auto is_scene_mode() const -> bool;
+        auto set_hdri(const std::string& path) -> void override;  // rebuilds the cubemap (device-idle)
+        auto current_hdri() const -> const std::string& override;
+        auto scene_objects() -> std::vector<SceneObject>& override;
+        auto set_selected_object(int index) -> void override;
+        auto black_hole_params() -> BlackHoleParams& override;
 
-        // Runtime scene objects (spheres) drawn in scene view; the UI mutates this
-        // list directly. set_selected_object marks one for a rim highlight (-1 = none).
-        auto scene_objects() -> std::vector<SceneObject>&;
-        auto set_selected_object(int index) -> void;
+        auto device_name() const -> const std::string& override;
 
     private:
         struct Impl;
diff --git a/src/rendering/renderer_backend.h b/src/rendering/renderer_backend.h
new file mode 100644
index 0000000..6a4f1af
--- /dev/null
+++ b/src/rendering/renderer_backend.h
@@ -0,0 +1,73 @@
+#pragma once
+
+#include <glm/glm.hpp>
+#include <functional>
+#include <string>
+#include <vector>
+
+namespace Donut
+{
+    // A placeable/editable sphere in the world-builder scene view. Backend-
+    // agnostic: the app owns the list, every backend renders it the same way.
+    struct SceneObject
+    {
+        glm::vec3 position = { 0.0f, 2.0f, 0.0f };
+        float     radius   = 2.0f;
+        glm::vec3 color    = { 0.85f, 0.35f, 0.2f };
+    };
+
+    // Live-tunable black-hole / accretion-disk parameters. Radii are in
+    // Schwarzschild radii; the inner edge is clamped to the ISCO (3 r_s).
+    struct BlackHoleParams
+    {
+        float disk_inner_rs = 3.0f;      // inner edge (x r_s)
+        float disk_outer_rs = 12.0f;     // outer edge (x r_s)
+        float temperature   = 4800.0f;   // Kelvin at the flux peak (disk colour)
+        float brightness    = 0.9f;      // disk exposure
+        float turbulence    = 0.4f;      // 0 = smooth physical disk
+        int   quality_steps = 15000;     // geodesic integration steps
+        float fov_degrees   = 60.0f;     // camera field of view
+    };
+
+    // The swappable high-level renderer. Each graphics backend (OpenGL, Vulkan,
+    // and later Metal / D3D12) implements this one interface; the Application,
+    // states and UI drive it identically, so the app behaves the same no matter
+    // which backend is active. Backends own their own device/swapchain/pipelines
+    // and translate these high-level calls into their native API.
+    class RendererBackend
+    {
+    public:
+        virtual ~RendererBackend() = default;
+
+        // glfwWindow is an opaque GLFW handle (created NO_API for Vulkan/Metal,
+        // with a GL context for OpenGL). Returns false on failure.
+        virtual auto init(void* glfwWindow, int width, int height) -> bool = 0;
+
+        // Creates the ImGui context + this backend's ImGui platform/render impl.
+        virtual auto init_ui() -> bool = 0;
+        virtual auto shutdown() -> void = 0;
+        virtual auto resize(int width, int height) -> void = 0;
+
+        // Renders one frame: draws the current view (black hole or scene) from
+        // the shared state, then invokes build_ui to draw the ImGui panel on top.
+        virtual auto draw_frame(const glm::vec4& clear_color,
+                                const std::function<void()>& build_ui) -> void = 0;
+
+        // --- shared view / camera state ------------------------------------
+        virtual auto set_scene_mode(bool enabled) -> void = 0;  // black hole vs scene view
+        virtual auto is_scene_mode() const -> bool = 0;
+        virtual auto set_free_fly(bool enabled) -> void = 0;    // free-fly vs orbital camera
+        virtual auto is_free_fly() const -> bool = 0;
+        virtual auto reset_camera() -> void = 0;
+
+        // --- shared content ------------------------------------------------
+        virtual auto set_hdri(const std::string& path) -> void = 0;
+        virtual auto current_hdri() const -> const std::string& = 0;
+        virtual auto scene_objects() -> std::vector<SceneObject>& = 0;
+        virtual auto set_selected_object(int index) -> void = 0;
+        virtual auto black_hole_params() -> BlackHoleParams& = 0;
+
+        // --- introspection for the UI --------------------------------------
+        virtual auto device_name() const -> const std::string& = 0;
+    };
+}
diff --git a/src/rendering/rhi/rhi.h b/src/rendering/rhi/rhi.h
new file mode 100644
index 0000000..f64252c
--- /dev/null
+++ b/src/rendering/rhi/rhi.h
@@ -0,0 +1,131 @@
+#pragma once
+
+// Donut RHI (Render Hardware Interface): a small, portable GPU abstraction that
+// OpenGL, Vulkan (and later Metal / D3D12) implement behind ONE interface, so the
+// app's rendering — the black hole, the scene — is written ONCE on top and runs
+// on any backend. The shape is modelled on the explicit APIs (baked pipelines,
+// recorded command lists, explicit render targets); OpenGL emulates that, which
+// is easy, whereas the reverse (making Vulkan speak GL's immediate mode) is not.
+
+#include "core/memory.h"
+#include <glm/glm.hpp>
+#include <cstdint>
+#include <string>
+#include <vector>
+#include <functional>
+
+namespace Donut::rhi
+{
+    enum class Format
+    {
+        RGBA8,      // 8-bit unorm colour (swapchain / LDR targets)
+        RGBA16F,    // half-float colour (HDR / cubemap)
+        D32,        // 32-bit depth
+    };
+
+    enum class BufferType { Vertex, Index, Uniform };
+    enum class Topology   { Triangles, Lines };
+    enum class CullMode   { None, Back, Front };
+    enum class BlendMode  { Opaque, AlphaBlend };
+    enum class CompareOp  { Always, Less, LessEqual };
+    enum class Filter     { Nearest, Linear };
+
+    // One vertex attribute; offsets/stride are in bytes. `components` is 1..4 floats.
+    struct VertexAttribute { uint32_t location; uint32_t components; uint32_t offset; };
+    struct VertexLayout    { uint32_t stride = 0; std::vector<VertexAttribute> attributes; };
+
+    // A shader resource slot the pipeline exposes. `binding` is the set-0 binding
+    // index shared by the GLSL/SPIR-V (the app binds resources to these before a draw).
+    enum class ResourceKind { UniformBuffer, Texture };
+    struct ResourceSlot { ResourceKind kind; uint32_t binding; };
+
+    // --- opaque GPU resources (backends subclass) --------------------------
+    class Buffer  { public: virtual ~Buffer() = default; virtual auto update(const void* data, size_t size) -> void = 0; };
+    class Texture { public: virtual ~Texture() = default; };
+    class Pipeline{ public: virtual ~Pipeline() = default; };
+
+    // An off-screen target (colour, optional depth). The swapchain is the implicit
+    // default target, addressed by passing nullptr to begin_render_pass.
+    class RenderTarget
+    {
+    public:
+        virtual ~RenderTarget() = default;
+        virtual auto width()  const -> int = 0;
+        virtual auto height() const -> int = 0;
+        virtual auto color_texture() -> Texture* = 0;   // to sample this target's colour
+    };
+
+    struct PipelineDesc
+    {
+        std::string  shader;                 // base name; backend loads .spv or .glsl
+        VertexLayout vertex_layout;
+        std::vector<ResourceSlot> resources; // UBO/texture slots the shader reads
+        Topology  topology    = Topology::Triangles;
+        CullMode  cull        = CullMode::None;
+        BlendMode blend       = BlendMode::Opaque;
+        bool      depth_test  = false;
+        bool      depth_write = false;
+        CompareOp depth_op    = CompareOp::Less;
+        Format    color_format = Format::RGBA8;   // format of the target it renders into
+        bool      has_depth    = false;           // target has a depth attachment
+    };
+
+    // Records draws for one frame. Obtained from Device::begin_frame (targets the
+    // swapchain) or created transiently for off-screen passes via the Device.
+    class CommandList
+    {
+    public:
+        virtual ~CommandList() = default;
+
+        // target == nullptr renders to the swapchain; otherwise to the RenderTarget.
+        virtual auto begin_render_pass(RenderTarget* target, const glm::vec4& clear) -> void = 0;
+        virtual auto end_render_pass() -> void = 0;
+
+        virtual auto bind_pipeline(Pipeline* pipeline) -> void = 0;
+        virtual auto set_viewport(int x, int y, int w, int h, bool flip_y = false) -> void = 0;
+
+        virtual auto bind_uniform(uint32_t binding, Buffer* ubo) -> void = 0;
+        virtual auto bind_texture(uint32_t binding, Texture* texture) -> void = 0;
+
+        virtual auto bind_vertex_buffer(Buffer* vb) -> void = 0;
+        virtual auto bind_index_buffer(Buffer* ib) -> void = 0;   // 32-bit indices
+
+        virtual auto draw(uint32_t vertex_count) -> void = 0;
+        virtual auto draw_indexed(uint32_t index_count) -> void = 0;
+    };
+
+    // The backend root: owns the device/swapchain and creates every resource.
+    class Device
+    {
+    public:
+        virtual ~Device() = default;
+
+        // glfwWindow: opaque GLFW handle (GL context for OpenGL, NO_API otherwise).
+        virtual auto init(void* glfwWindow, int width, int height) -> bool = 0;
+        virtual auto shutdown() -> void = 0;
+        virtual auto resize(int width, int height) -> void = 0;
+        virtual auto wait_idle() -> void = 0;
+
+        virtual auto create_buffer(BufferType type, size_t size, const void* data = nullptr) -> Ref<Buffer> = 0;
+        virtual auto create_texture(int width, int height, Format format, Filter filter, const void* data = nullptr) -> Ref<Texture> = 0;
+        virtual auto create_cubemap_from_hdri(const std::string& equirect_path) -> Ref<Texture> = 0;
+        virtual auto create_render_target(int width, int height, Format color, bool with_depth,
+                                          Filter sample_filter = Filter::Linear, int mip_levels = 1) -> Ref<RenderTarget> = 0;
+        virtual auto create_pipeline(const PipelineDesc& desc) -> Ref<Pipeline> = 0;
+
+        // Frame loop: begin_frame returns the swapchain command list (or nullptr if
+        // the frame is skipped, e.g. minimised); record into it, then end_frame
+        // submits + presents. record_offscreen runs a self-contained pass whose
+        // command list targets a RenderTarget (used before the swapchain frame).
+        virtual auto begin_frame(const glm::vec4& clear) -> CommandList* = 0;
+        virtual auto end_frame() -> void = 0;
+        virtual auto record_offscreen(const std::function<void(CommandList&)>& record) -> void = 0;
+
+        // ImGui lives above the RHI but its platform/render backend is per-device.
+        virtual auto init_imgui() -> void = 0;
+        virtual auto imgui_new_frame() -> void = 0;
+        virtual auto imgui_render(CommandList& swapchain_cmds) -> void = 0;
+
+        virtual auto device_name() const -> const std::string& = 0;
+    };
+}