diff --git a/engine/core/include/engine.hpp b/engine/core/include/engine.hpp
index de54000..8eb0716 100755
--- a/engine/core/include/engine.hpp
+++ b/engine/core/include/engine.hpp
@@ -16,7 +16,6 @@ namespace ui {
 }
 
 class Scene;
-class Renderer;
 class RenderTarget;
 class Physics;
 struct Timer;
@@ -25,6 +24,7 @@ namespace prism {
     class app;
     class imgui_backend;
     class input_system;
+    class renderer;
 
     struct AnimationTarget {
         float current_time = 0.0f;
@@ -120,7 +120,7 @@ namespace prism {
          @param index Index of the window. Default is 0.
          @return Instance of the renderer. Will not be null.
          */
-        Renderer* get_renderer();
+        renderer* get_renderer();
 
         /** Get the physics system.
          @return Instance of the physics system. Will not be null.
@@ -373,7 +373,7 @@ namespace prism {
 
         std::unique_ptr<input_system> input;
         std::unique_ptr<Physics> physics;
-        std::unique_ptr<Renderer> renderer;
+        std::unique_ptr<renderer> renderer;
 
         std::vector<Timer*> timers, timers_to_remove;
 
diff --git a/engine/core/src/engine.cpp b/engine/core/src/engine.cpp
index 966d538..0573a62 100755
--- a/engine/core/src/engine.cpp
+++ b/engine/core/src/engine.cpp
@@ -114,7 +114,7 @@ prism::input_system* engine::get_input() {
 	return input.get();
 }
 
-Renderer* engine::get_renderer() {
+prism::renderer* engine::get_renderer() {
     return renderer.get();
 }
 
@@ -414,7 +414,7 @@ void engine::add_window(void* native_handle, const int identifier, const prism::
     Expects(identifier >= 0);
     
     if(identifier == 0) {
-        renderer = std::make_unique<Renderer>(gfx);
+        renderer = std::make_unique<prism::renderer>(gfx);
     }
     
     const auto drawable_extent = platform::get_window_drawable_size(identifier);
diff --git a/engine/renderer/include/dofpass.hpp b/engine/renderer/include/dofpass.hpp
index d6a4bd1..a72efe9 100755
--- a/engine/renderer/include/dofpass.hpp
+++ b/engine/renderer/include/dofpass.hpp
@@ -7,11 +7,14 @@ class GFXPipeline;
 class GFXRenderPass;
 class GFXTexture;
 class Scene;
-class Renderer;
+
+namespace prism {
+    class renderer;
+}
 
 class DoFPass {
 public:
-    DoFPass(GFX* gfx, Renderer* renderer);
+    DoFPass(GFX* gfx, prism::renderer* renderer);
         
     void render(GFXCommandBuffer* command_buffer, Scene& scene);
     
@@ -24,7 +27,7 @@ public:
     GFXRenderPass* renderpass = nullptr;
     
 private:
-    Renderer* renderer = nullptr;
+    prism::renderer* renderer = nullptr;
     
     GFXPipeline* pipeline = nullptr;
 };
diff --git a/engine/renderer/include/renderer.hpp b/engine/renderer/include/renderer.hpp
index ef20c3d..982e5f8 100755
--- a/engine/renderer/include/renderer.hpp
+++ b/engine/renderer/include/renderer.hpp
@@ -35,127 +35,145 @@ struct Camera;
 
 constexpr int max_scene_materials = 25, max_scene_lights = 25;
 
-struct RenderScreenOptions {
+struct render_screen_options {
     bool render_world = false;
     Matrix4x4 mvp;
 };
 
 class Material;
 
-class Renderer {
-public:
-    explicit Renderer(GFX* gfx, bool enable_imgui = true);
-    ~Renderer();
+namespace prism {
+    class renderer {
+    public:
+        explicit renderer(GFX* gfx, bool enable_imgui = true);
 
-    RenderTarget* allocate_render_target(prism::Extent extent);
-    void resize_render_target(RenderTarget& target, prism::Extent extent);
-    void recreate_all_render_targets();
-    
-    void set_screen(ui::Screen* screen);
-    void init_screen(ui::Screen* screen);
-	void update_screen();
+        ~renderer();
 
-    struct ControllerContinuity {
-        int elementOffset = 0;
-    };
+        RenderTarget* allocate_render_target(prism::Extent extent);
 
-    void render(GFXCommandBuffer* command_buffer, Scene* scene, RenderTarget& target, int index);
+        void resize_render_target(RenderTarget& target, prism::Extent extent);
 
-    void render_screen(GFXCommandBuffer* commandBuffer, ui::Screen* screen, prism::Extent extent, ControllerContinuity& continuity, RenderScreenOptions options = RenderScreenOptions());
-    void render_camera(GFXCommandBuffer* command_buffer, Scene& scene, Object camera_object, Camera& camera, prism::Extent extent, RenderTarget& target, ControllerContinuity& continuity);
-    
-    void create_mesh_pipeline(Material& material) const;
-    
-    // passes
-    template<class T, typename... Args>
-    T* addPass(Args&&... args) {
-        auto t = std::make_unique<T>(args...);
-        t->initialize();
-        
-        return static_cast<T*>(passes.emplace_back(std::move(t)).get());
-    }
+        void recreate_all_render_targets();
 
-    GFXTexture* get_requested_texture(PassTextureType type) {
-        for(auto& pass : passes) {
-            auto texture = pass->get_requested_texture(type);
-            if(texture != nullptr)
-                return texture;
+        void set_screen(ui::Screen* screen);
+
+        void init_screen(ui::Screen* screen);
+
+        void update_screen();
+
+        struct controller_continuity {
+            int elementOffset = 0;
+        };
+
+        void render(GFXCommandBuffer* command_buffer, Scene* scene, RenderTarget& target, int index);
+
+        void render_screen(GFXCommandBuffer* commandBuffer, ui::Screen* screen, prism::Extent extent,
+                           controller_continuity& continuity, render_screen_options options = render_screen_options());
+
+        void render_camera(GFXCommandBuffer* command_buffer, Scene& scene, Object camera_object, Camera& camera,
+                           prism::Extent extent, RenderTarget& target, controller_continuity &continuity);
+
+        void create_mesh_pipeline(Material& material) const;
+
+        // passes
+        template<class T, typename... Args>
+        T* addPass(Args &&... args) {
+            auto t = std::make_unique<T>(args...);
+            t->initialize();
+
+            return static_cast<T*>(passes.emplace_back(std::move(t)).get());
         }
 
-        return nullptr;
-    }
-    
-    GFXRenderPass* offscreenRenderPass = nullptr;
-    
-    std::unique_ptr<ShadowPass> shadow_pass;
-    std::unique_ptr<SceneCapture> scene_capture;
+        GFXTexture* get_requested_texture(PassTextureType type) {
+            for (auto& pass : passes) {
+                auto texture = pass->get_requested_texture(type);
+                if (texture != nullptr)
+                    return texture;
+            }
 
-    GFXTexture* dummyTexture = nullptr;
-    GFXRenderPass* unormRenderPass = nullptr;
-    GFXPipeline* renderToUnormTexturePipeline = nullptr;
-    GFXRenderPass* viewportRenderPass = nullptr;
-    
-    ShaderSource register_shader(std::string_view shader_file);
-    void associate_shader_reload(std::string_view shader_file, const std::function<void()>& reload_function);
-    void reload_shader(std::string_view shader_file, std::string_view shader_source);
-    
-    struct RegisteredShader {
-        std::string filename;
-        std::string injected_shader_source;
-        std::function<void()> reload_function;
+            return nullptr;
+        }
+
+        GFXRenderPass* offscreen_render_pass = nullptr;
+
+        std::unique_ptr<ShadowPass> shadow_pass;
+        std::unique_ptr<SceneCapture> scene_capture;
+
+        GFXTexture* dummy_texture = nullptr;
+        GFXRenderPass* unorm_render_pass = nullptr;
+        GFXPipeline* render_to_unorm_texture_pipeline = nullptr;
+
+        ShaderSource register_shader(std::string_view shader_file);
+
+        void associate_shader_reload(std::string_view shader_file, const std::function<void()> &reload_function);
+
+        void reload_shader(std::string_view shader_file, std::string_view shader_source);
+
+        struct RegisteredShader {
+            std::string filename;
+            std::string injected_shader_source;
+            std::function<void()> reload_function;
+        };
+
+        std::vector<RegisteredShader> registered_shaders;
+
+        bool reloading_shader = false;
+
+        [[nodiscard]] std::vector<RenderTarget*> get_all_render_targets() const {
+            return render_targets;
+        }
+
+    private:
+        void create_dummy_texture();
+
+        void create_render_target_resources(RenderTarget& target);
+
+        void create_post_pipelines();
+
+        void create_font_texture();
+
+        void create_sky_pipeline();
+
+        void create_ui_pipelines();
+
+        void generate_brdf();
+
+        void create_histogram_resources();
+
+        GFX* gfx = nullptr;
+
+        std::vector<RenderTarget*> render_targets;
+
+        ui::Screen* current_screen = nullptr;
+
+        // sky
+        GFXPipeline* sky_pipeline = nullptr;
+
+        // post
+        GFXPipeline* post_pipeline = nullptr;
+
+        // font
+        GFXTexture* font_texture = nullptr;
+        GFXPipeline* text_pipeline, *world_text_pipeline = nullptr;
+        int instance_alignment = 0;
+
+        // brdf
+        GFXPipeline* brdf_pipeline = nullptr;
+        GFXTexture* brdf_texture = nullptr;
+        GFXFramebuffer* brdf_framebuffer = nullptr;
+        GFXRenderPass* brdf_render_pass = nullptr;
+
+        // general ui
+        GFXPipeline* general_pipeline, *world_general_pipeline = nullptr;
+
+        // histogram compute
+        GFXPipeline* histogram_pipeline = nullptr, *histogram_average_pipeline = nullptr;
+        GFXBuffer* histogram_buffer = nullptr;
+        GFXTexture* average_luminance_texture = nullptr;
+
+        std::unique_ptr<SMAAPass> smaa_pass;
+        std::unique_ptr<DoFPass> dof_pass;
+
+        std::vector<std::unique_ptr<Pass>> passes;
     };
-    
-    std::vector<RegisteredShader> registered_shaders;
-    
-    bool reloading_shader = false;
-    
-    [[nodiscard]] std::vector<RenderTarget*> get_all_render_targets() const {
-        return render_targets;
-    }
-    
-private:
-    void create_dummy_texture();
-    void create_render_target_resources(RenderTarget& target);
-    void create_post_pipelines();
-    void create_font_texture();
-    void create_sky_pipeline();
-    void create_ui_pipelines();
-    void generate_brdf();
-    void create_histogram_resources();
-
-    GFX* gfx = nullptr;
-    
-    std::vector<RenderTarget*> render_targets;
-
-    ui::Screen* current_screen = nullptr;
-    
-    // sky
-    GFXPipeline* sky_pipeline = nullptr;
-
-    // post
-    GFXPipeline* post_pipeline = nullptr;
-
-    // font
-    GFXTexture* font_texture = nullptr;
-    GFXPipeline* text_pipeline, *world_text_pipeline = nullptr;
-    int instance_alignment = 0;
-    
-    // brdf
-    GFXPipeline* brdf_pipeline = nullptr;
-    GFXTexture* brdf_texture = nullptr;
-    GFXFramebuffer* brdf_framebuffer = nullptr;
-    GFXRenderPass* brdf_render_pass = nullptr;
-
-    // general ui
-    GFXPipeline* general_pipeline, *world_general_pipeline = nullptr;
-    
-    // histogram compute
-    GFXPipeline* histogram_pipeline = nullptr, *histogram_average_pipeline = nullptr;
-    GFXBuffer* histogram_buffer = nullptr;
-    GFXTexture* average_luminance_texture = nullptr;
-
-    std::unique_ptr<SMAAPass> smaa_pass;
-    std::unique_ptr<DoFPass> dof_pass;
-    
-    std::vector<std::unique_ptr<Pass>> passes;
-};
+}
\ No newline at end of file
diff --git a/engine/renderer/include/smaapass.hpp b/engine/renderer/include/smaapass.hpp
index d4c10e0..3a8ce40 100755
--- a/engine/renderer/include/smaapass.hpp
+++ b/engine/renderer/include/smaapass.hpp
@@ -9,12 +9,15 @@ class GFXFramebuffer;
 class GFXPipeline;
 class GFXRenderPass;
 class GFXTexture;
-class Renderer;
 class RenderTarget;
 
+namespace prism {
+    class renderer;
+}
+
 class SMAAPass {
 public:
-    SMAAPass(GFX* gfx, Renderer* renderer);
+    SMAAPass(GFX* gfx, prism::renderer* renderer);
     
     void create_render_target_resources(RenderTarget& target);
     
@@ -24,8 +27,8 @@ private:
     void create_textures();
     void create_render_pass();
     void create_pipelines();
-    
-    Renderer* renderer = nullptr;
+
+    prism::renderer* renderer = nullptr;
     
     GFXTexture* area_image = nullptr;
     GFXTexture* search_image = nullptr;
diff --git a/engine/renderer/src/dofpass.cpp b/engine/renderer/src/dofpass.cpp
index a92e9d9..c018fce 100755
--- a/engine/renderer/src/dofpass.cpp
+++ b/engine/renderer/src/dofpass.cpp
@@ -8,7 +8,7 @@
 
 AssetPtr<Texture> aperture_texture;
 
-DoFPass::DoFPass(GFX* gfx, Renderer* renderer) : renderer(renderer) {
+DoFPass::DoFPass(GFX* gfx, prism::renderer* renderer) : renderer(renderer) {
     aperture_texture = assetm->get<Texture>(file::app_domain / "textures/aperture.png");
     
     GFXRenderPassCreateInfo renderPassInfo = {};
diff --git a/engine/renderer/src/renderer.cpp b/engine/renderer/src/renderer.cpp
index f1b2aab..083cb4f 100755
--- a/engine/renderer/src/renderer.cpp
+++ b/engine/renderer/src/renderer.cpp
@@ -9,7 +9,6 @@
 #include "scene.hpp"
 #include "font.hpp"
 #include "vector.hpp"
-#include "engine.hpp"
 #include "imguipass.hpp"
 #include "gfx.hpp"
 #include "log.hpp"
@@ -25,6 +24,8 @@
 #include "asset.hpp"
 #include "debug.hpp"
 
+using prism::renderer;
+
 struct ElementInstance {
     Vector4 color;
     uint32_t position = 0, size = 0;
@@ -87,7 +88,7 @@ struct SkyPushConstant {
     float aspect;
 };
 
-Renderer::Renderer(GFX* gfx, const bool enable_imgui) : gfx(gfx) {
+renderer::renderer(GFX* gfx, const bool enable_imgui) : gfx(gfx) {
     Expects(gfx != nullptr);
     
     shader_compiler.set_include_path(file::get_domain_path(file::Domain::Internal).string());
@@ -109,21 +110,21 @@ Renderer::Renderer(GFX* gfx, const bool enable_imgui) : gfx(gfx) {
     renderPassInfo.attachments.push_back(GFXPixelFormat::RGBA_32F);
     renderPassInfo.attachments.push_back(GFXPixelFormat::DEPTH_32F);
     renderPassInfo.will_use_in_shader = true;
-    
-    offscreenRenderPass = gfx->create_render_pass(renderPassInfo);
+
+    offscreen_render_pass = gfx->create_render_pass(renderPassInfo);
 
     renderPassInfo.label = "Offscreen (UNORM)";
     renderPassInfo.attachments = {GFXPixelFormat::R8G8B8A8_UNORM};
 
-    unormRenderPass = gfx->create_render_pass(renderPassInfo);
+    unorm_render_pass = gfx->create_render_pass(renderPassInfo);
 
     create_font_texture();
     create_sky_pipeline();
 }
 
-Renderer::~Renderer() = default;
+renderer::~renderer() = default;
 
-RenderTarget* Renderer::allocate_render_target(const prism::Extent extent) {
+RenderTarget* renderer::allocate_render_target(const prism::Extent extent) {
     auto target = new RenderTarget();
     
     resize_render_target(*target, extent);
@@ -133,7 +134,7 @@ RenderTarget* Renderer::allocate_render_target(const prism::Extent extent) {
     return target;
 }
 
-void Renderer::resize_render_target(RenderTarget& target, const prism::Extent extent) {
+void renderer::resize_render_target(RenderTarget& target, const prism::Extent extent) {
     target.extent = extent;
         
     create_render_target_resources(target);
@@ -167,7 +168,7 @@ void Renderer::resize_render_target(RenderTarget& target, const prism::Extent ex
     text_pipeline = gfx->create_graphics_pipeline(pipelineInfo);
     
     if(world_text_pipeline == nullptr) {
-        pipelineInfo.render_pass = offscreenRenderPass;
+        pipelineInfo.render_pass = offscreen_render_pass;
         pipelineInfo.label = "Text World";
         pipelineInfo.depth.depth_mode = GFXDepthMode::LessOrEqual;
 
@@ -180,11 +181,11 @@ void Renderer::resize_render_target(RenderTarget& target, const prism::Extent ex
         pass->create_render_target_resources(target);
 }
 
-void Renderer::recreate_all_render_targets() {
+void renderer::recreate_all_render_targets() {
     
 }
 
-void Renderer::set_screen(ui::Screen* screen) {
+void renderer::set_screen(ui::Screen* screen) {
     Expects(screen != nullptr);
     
     current_screen = screen;
@@ -194,7 +195,7 @@ void Renderer::set_screen(ui::Screen* screen) {
 	update_screen();
 }
 
-void Renderer::init_screen(ui::Screen* screen) {
+void renderer::init_screen(ui::Screen* screen) {
     Expects(screen != nullptr);
 
     std::array<GylphMetric, numGlyphs> metrics = {};
@@ -217,7 +218,7 @@ void Renderer::init_screen(ui::Screen* screen) {
     screen->instance_buffer = gfx->create_buffer(nullptr, sizeof(StringInstance) * 50, true, GFXBufferUsage::Storage);
 }
 
-void Renderer::update_screen() {
+void renderer::update_screen() {
 	if(current_screen != nullptr) {
 		for(auto& element : current_screen->elements) {
 			if(!element.background.image.empty())
@@ -226,7 +227,7 @@ void Renderer::update_screen() {
 	}
 }
 
-void Renderer::render(GFXCommandBuffer* commandbuffer, Scene* scene, RenderTarget& target, int index) {
+void renderer::render(GFXCommandBuffer* commandbuffer, Scene* scene, RenderTarget& target, int index) {
     const auto extent = target.extent;
     const auto render_extent = target.get_render_extent();
         
@@ -252,10 +253,10 @@ void Renderer::render(GFXCommandBuffer* commandbuffer, Scene* scene, RenderTarge
     
     GFXRenderPassBeginInfo beginInfo = {};
     beginInfo.framebuffer = target.offscreenFramebuffer;
-    beginInfo.render_pass = offscreenRenderPass;
+    beginInfo.render_pass = offscreen_render_pass;
     beginInfo.render_area.extent = render_extent;
 
-    ControllerContinuity continuity;
+    controller_continuity continuity;
 
     if(scene != nullptr) {
         commandbuffer->push_group("Shadow Rendering");
@@ -368,14 +369,14 @@ void Renderer::render(GFXCommandBuffer* commandbuffer, Scene* scene, RenderTarge
     if(auto texture = get_requested_texture(PassTextureType::SelectionSobel))
         commandbuffer->bind_texture(texture, 5);
     else
-        commandbuffer->bind_texture(dummyTexture, 5);
+        commandbuffer->bind_texture(dummy_texture, 5);
     
     commandbuffer->bind_texture(average_luminance_texture, 6);
     
     if(render_options.enable_depth_of_field)
         commandbuffer->bind_texture(dof_pass->far_field, 7);
     else
-        commandbuffer->bind_texture(dummyTexture, 7);
+        commandbuffer->bind_texture(dummy_texture, 7);
 
     PostPushConstants pc;
     pc.options.x = render_options.enable_aa;
@@ -409,7 +410,7 @@ void Renderer::render(GFXCommandBuffer* commandbuffer, Scene* scene, RenderTarge
     target.current_frame = (target.current_frame + 1) % RT_MAX_FRAMES_IN_FLIGHT;
 }
 
-void Renderer::render_camera(GFXCommandBuffer* command_buffer, Scene& scene, Object camera_object, Camera& camera, prism::Extent extent, RenderTarget& target, ControllerContinuity& continuity) {
+void renderer::render_camera(GFXCommandBuffer* command_buffer, Scene& scene, Object camera_object, Camera& camera, prism::Extent extent, RenderTarget& target, controller_continuity& continuity) {
     // frustum test
     const auto frustum = normalize_frustum(camera_extract_frustum(scene, camera_object));
             
@@ -514,7 +515,7 @@ void Renderer::render_camera(GFXCommandBuffer* command_buffer, Scene& scene, Obj
             command_buffer->set_push_constant(&pc, sizeof(PushConstant));
             
             for(const auto& [index, texture] : mesh.materials[material_index]->bound_textures) {
-                GFXTexture* texture_to_bind = dummyTexture;
+                GFXTexture* texture_to_bind = dummy_texture;
                 if(texture)
                     texture_to_bind = texture->handle;
                 
@@ -530,7 +531,7 @@ void Renderer::render_camera(GFXCommandBuffer* command_buffer, Scene& scene, Obj
         if(!screen.screen)
             continue;
         
-        RenderScreenOptions options = {};
+        render_screen_options options = {};
         options.render_world = true;
         options.mvp = camera.perspective * camera.view * scene.get<Transform>(obj).model;
         
@@ -560,7 +561,7 @@ void Renderer::render_camera(GFXCommandBuffer* command_buffer, Scene& scene, Obj
     gfx->copy_buffer(target.sceneBuffer, &sceneInfo, 0, sizeof(SceneInformation));
 }
 
-void Renderer::render_screen(GFXCommandBuffer *commandbuffer, ui::Screen* screen, prism::Extent extent, ControllerContinuity& continuity, RenderScreenOptions options) {
+void renderer::render_screen(GFXCommandBuffer *commandbuffer, ui::Screen* screen, prism::Extent extent, controller_continuity& continuity, render_screen_options options) {
     std::array<GlyphInstance, maxInstances> instances;
     std::vector<ElementInstance> elementInstances;
     std::array<StringInstance, 50> stringInstances = {};
@@ -658,7 +659,7 @@ void Renderer::render_screen(GFXCommandBuffer *commandbuffer, ui::Screen* screen
             commandbuffer->bind_texture(element.background.texture->handle, 2);
         }
         else {
-            commandbuffer->bind_texture(dummyTexture, 2);
+            commandbuffer->bind_texture(dummy_texture, 2);
         }
 
         commandbuffer->set_push_constant(&pc, sizeof(UIPushConstant));
@@ -690,7 +691,7 @@ void Renderer::render_screen(GFXCommandBuffer *commandbuffer, ui::Screen* screen
     continuity.elementOffset += numElements;
 }
 
-void Renderer::create_mesh_pipeline(Material& material) const {
+void renderer::create_mesh_pipeline(Material& material) const {
     GFXShaderConstant materials_constant = {};
     materials_constant.type = GFXShaderConstant::Type::Integer;
     materials_constant.value = max_scene_materials;
@@ -733,7 +734,7 @@ void Renderer::create_mesh_pipeline(Material& material) const {
         {9, GFXBindingType::Texture}
     };
     
-    pipelineInfo.render_pass = offscreenRenderPass;
+    pipelineInfo.render_pass = offscreen_render_pass;
     pipelineInfo.depth.depth_mode = GFXDepthMode::Less;
     pipelineInfo.rasterization.culling_mode = GFXCullingMode::Backface;
     pipelineInfo.blending.src_rgb = GFXBlendFactor::SrcAlpha;
@@ -763,7 +764,7 @@ void Renderer::create_mesh_pipeline(Material& material) const {
     material.capture_pipeline = material_compiler.create_static_pipeline(pipelineInfo, false, true);
 }
 
-void Renderer::create_dummy_texture() {
+void renderer::create_dummy_texture() {
     GFXTextureCreateInfo createInfo = {};
     createInfo.label = "Dummy";
     createInfo.width = 1;
@@ -771,14 +772,14 @@ void Renderer::create_dummy_texture() {
     createInfo.format = GFXPixelFormat::R8G8B8A8_UNORM;
     createInfo.usage = GFXTextureUsage::Sampled;
 
-    dummyTexture = gfx->create_texture(createInfo);
+    dummy_texture = gfx->create_texture(createInfo);
 
     uint8_t tex[4] = {0, 0, 0, 0};
 
-    gfx->copy_texture(dummyTexture, tex, sizeof(tex));
+    gfx->copy_texture(dummy_texture, tex, sizeof(tex));
 }
 
-void Renderer::create_render_target_resources(RenderTarget& target) {
+void renderer::create_render_target_resources(RenderTarget& target) {
     const auto extent = target.get_render_extent();
     
     GFXTextureCreateInfo textureInfo = {};
@@ -797,7 +798,7 @@ void Renderer::create_render_target_resources(RenderTarget& target) {
     target.offscreenDepthTexture = gfx->create_texture(textureInfo);
 
     GFXFramebufferCreateInfo framebufferInfo = {};
-	framebufferInfo.render_pass = offscreenRenderPass;
+	framebufferInfo.render_pass = offscreen_render_pass;
     framebufferInfo.attachments.push_back(target.offscreenColorTexture);
     framebufferInfo.attachments.push_back(target.offscreenDepthTexture);
 
@@ -830,7 +831,7 @@ void Renderer::create_render_target_resources(RenderTarget& target) {
     target.sceneBuffer = gfx->create_buffer(nullptr, sizeof(SceneInformation), true, GFXBufferUsage::Storage);
 }
 
-void Renderer::create_post_pipelines() {
+void renderer::create_post_pipelines() {
     GFXGraphicsPipelineCreateInfo pipelineInfo = {};
     pipelineInfo.label = "Post";
     
@@ -854,7 +855,7 @@ void Renderer::create_post_pipelines() {
     post_pipeline = gfx->create_graphics_pipeline(pipelineInfo);
 }
 
-void Renderer::create_font_texture() {
+void renderer::create_font_texture() {
     auto file = file::open(file::app_domain / "font.fp", true);
     if(file == std::nullopt) {
         prism::log::error(System::Renderer, "Failed to load font file!");
@@ -880,10 +881,10 @@ void Renderer::create_font_texture() {
     gfx->copy_texture(font_texture, bitmap.data(), font.width * font.height);
 }
 
-void Renderer::create_sky_pipeline() {
+void renderer::create_sky_pipeline() {
     GFXGraphicsPipelineCreateInfo pipelineInfo = {};
     pipelineInfo.label = "Sky";
-    pipelineInfo.render_pass = offscreenRenderPass;
+    pipelineInfo.render_pass = offscreen_render_pass;
 
     pipelineInfo.shaders.vertex_src = register_shader("sky.vert");
     pipelineInfo.shaders.fragment_src = register_shader("sky.frag");
@@ -909,7 +910,7 @@ void Renderer::create_sky_pipeline() {
     });
 }
 
-void Renderer::create_ui_pipelines() {
+void renderer::create_ui_pipelines() {
     GFXGraphicsPipelineCreateInfo pipelineInfo = {};
     pipelineInfo.label = "UI";
 
@@ -935,13 +936,13 @@ void Renderer::create_ui_pipelines() {
     general_pipeline = gfx->create_graphics_pipeline(pipelineInfo);
 
     pipelineInfo.label = "UI World";
-    pipelineInfo.render_pass = offscreenRenderPass;
+    pipelineInfo.render_pass = offscreen_render_pass;
     pipelineInfo.depth.depth_mode = GFXDepthMode::LessOrEqual;
 
     world_general_pipeline = gfx->create_graphics_pipeline(pipelineInfo);
 }
 
-void Renderer::generate_brdf() {
+void renderer::generate_brdf() {
     GFXRenderPassCreateInfo renderPassInfo = {};
     renderPassInfo.label = "BRDF Gen";
     renderPassInfo.attachments.push_back(GFXPixelFormat::R8G8_SFLOAT);
@@ -997,7 +998,7 @@ void Renderer::generate_brdf() {
     gfx->submit(command_buffer);
 }
 
-void Renderer::create_histogram_resources() {
+void renderer::create_histogram_resources() {
     GFXComputePipelineCreateInfo create_info = {};
     create_info.shaders.compute_path = "histogram.comp";
     create_info.workgroup_size_x = 16;
@@ -1027,7 +1028,7 @@ void Renderer::create_histogram_resources() {
     average_luminance_texture = gfx->create_texture(texture_info);
 }
 
-ShaderSource Renderer::register_shader(const std::string_view shader_file) {
+ShaderSource renderer::register_shader(const std::string_view shader_file) {
     if(!reloading_shader) {
         RegisteredShader shader;
         shader.filename = shader_file;
@@ -1067,7 +1068,7 @@ ShaderSource Renderer::register_shader(const std::string_view shader_file) {
     }
 }
 
-void Renderer::associate_shader_reload(const std::string_view shader_file, const std::function<void()>& reload_function) {
+void renderer::associate_shader_reload(const std::string_view shader_file, const std::function<void()>& reload_function) {
     if(reloading_shader)
         return;
     
@@ -1077,7 +1078,7 @@ void Renderer::associate_shader_reload(const std::string_view shader_file, const
     }
 }
 
-void Renderer::reload_shader(const std::string_view shader_file, const std::string_view shader_source) {
+void renderer::reload_shader(const std::string_view shader_file, const std::string_view shader_source) {
     for(auto& shader : registered_shaders) {
         if(shader.filename == shader_file) {
             shader.injected_shader_source = shader_source;
diff --git a/engine/renderer/src/scenecapture.cpp b/engine/renderer/src/scenecapture.cpp
index 6f48334..5fd2c8d 100755
--- a/engine/renderer/src/scenecapture.cpp
+++ b/engine/renderer/src/scenecapture.cpp
@@ -274,7 +274,7 @@ void SceneCapture::render(GFXCommandBuffer* command_buffer, Scene* scene) {
                                 command_buffer->set_push_constant(&pc, sizeof(PushConstant));
                                 
                                 for(auto& [index, texture] : mesh.materials[material_index]->bound_textures) {
-                                    GFXTexture* texture_to_bind = engine->get_renderer()->dummyTexture;
+                                    GFXTexture* texture_to_bind = engine->get_renderer()->dummy_texture;
                                     if(texture)
                                         texture_to_bind = texture->handle;
                                     
diff --git a/engine/renderer/src/smaapass.cpp b/engine/renderer/src/smaapass.cpp
index 79ab730..4a5c0a2 100755
--- a/engine/renderer/src/smaapass.cpp
+++ b/engine/renderer/src/smaapass.cpp
@@ -9,7 +9,7 @@
 #include <AreaTex.h>
 #include <SearchTex.h>
 
-SMAAPass::SMAAPass(GFX* gfx, Renderer* renderer) : renderer(renderer) {
+SMAAPass::SMAAPass(GFX* gfx, prism::renderer* renderer) : renderer(renderer) {
     Expects(gfx != nullptr);
     Expects(renderer != nullptr);
     
diff --git a/tools/common/include/commoneditor.hpp b/tools/common/include/commoneditor.hpp
index 9d63b4f..4eae663 100755
--- a/tools/common/include/commoneditor.hpp
+++ b/tools/common/include/commoneditor.hpp
@@ -183,7 +183,7 @@ public:
                 
                 return texture;
             } else {
-                return engine->get_renderer()->dummyTexture;
+                return engine->get_renderer()->dummy_texture;
             }
         }
     }
@@ -196,9 +196,9 @@ public:
             
             // store as dummy texture, as to stop infinite reload because of failure (e.g. out of date model)
             if(asset == nullptr) {
-                asset_thumbnails[path.string()] = engine->get_renderer()->dummyTexture;
+                asset_thumbnails[path.string()] = engine->get_renderer()->dummy_texture;
 
-                return engine->get_renderer()->dummyTexture;
+                return engine->get_renderer()->dummy_texture;
             }
                         
             if(can_load_asset<Material>(path)) {
@@ -214,7 +214,7 @@ public:
                 
                 return get_asset_thumbnail(ptr);
             } else {
-                return engine->get_renderer()->dummyTexture;
+                return engine->get_renderer()->dummy_texture;
             }
         }
     }
diff --git a/tools/common/src/commoneditor.cpp b/tools/common/src/commoneditor.cpp
index 770368b..0aba457 100755
--- a/tools/common/src/commoneditor.cpp
+++ b/tools/common/src/commoneditor.cpp
@@ -860,7 +860,7 @@ GFXTexture* CommonEditor::get_texture_preview(Texture& texture) {
     
     GFXFramebufferCreateInfo framebuffer_create_info = {};
     framebuffer_create_info.attachments = {final_texture};
-    framebuffer_create_info.render_pass = engine->get_renderer()->unormRenderPass;
+    framebuffer_create_info.render_pass = engine->get_renderer()->unorm_render_pass;
     
     auto final_framebuffer = gfx->create_framebuffer(framebuffer_create_info);
     
@@ -871,7 +871,7 @@ GFXTexture* CommonEditor::get_texture_preview(Texture& texture) {
     GFXRenderPassBeginInfo begin_info = {};
     begin_info.render_area.extent = {thumbnail_resolution, thumbnail_resolution};
     begin_info.framebuffer = final_framebuffer;
-    begin_info.render_pass = renderer->unormRenderPass;
+    begin_info.render_pass = renderer->unorm_render_pass;
     
     command_buffer->set_render_pass(begin_info);
     
@@ -881,12 +881,12 @@ GFXTexture* CommonEditor::get_texture_preview(Texture& texture) {
     
     command_buffer->set_viewport(viewport);
     
-    command_buffer->set_graphics_pipeline(renderer->renderToUnormTexturePipeline);
+    command_buffer->set_graphics_pipeline(renderer->render_to_unorm_texture_pipeline);
     
     command_buffer->bind_texture(texture.handle, 1);
-    command_buffer->bind_texture(renderer->dummyTexture, 2);
-    command_buffer->bind_texture(renderer->dummyTexture, 3);
-    command_buffer->bind_texture(renderer->dummyTexture, 4);
+    command_buffer->bind_texture(renderer->dummy_texture, 2);
+    command_buffer->bind_texture(renderer->dummy_texture, 3);
+    command_buffer->bind_texture(renderer->dummy_texture, 4);
     
     struct PostPushConstants {
         Vector4 viewport;
@@ -963,13 +963,13 @@ GFXTexture* CommonEditor::generate_common_preview(Scene& scene, const Vector3 ca
     
     GFXFramebufferCreateInfo framebuffer_create_info = {};
     framebuffer_create_info.attachments = {offscreen_color_texture, offscreen_depth_texture};
-    framebuffer_create_info.render_pass = renderer->offscreenRenderPass;
+    framebuffer_create_info.render_pass = renderer->offscreen_render_pass;
     
     auto offscreen_framebuffer = gfx->create_framebuffer(framebuffer_create_info);
     
     framebuffer_create_info = {};
     framebuffer_create_info.attachments = {final_texture};
-    framebuffer_create_info.render_pass = renderer->unormRenderPass;
+    framebuffer_create_info.render_pass = renderer->unorm_render_pass;
     
     auto final_framebuffer = gfx->create_framebuffer(framebuffer_create_info);
     
@@ -982,17 +982,17 @@ GFXTexture* CommonEditor::generate_common_preview(Scene& scene, const Vector3 ca
     
     GFXRenderPassBeginInfo begin_info = {};
     begin_info.framebuffer = offscreen_framebuffer;
-    begin_info.render_pass = renderer->offscreenRenderPass;
+    begin_info.render_pass = renderer->offscreen_render_pass;
     begin_info.render_area.extent = {thumbnail_resolution, thumbnail_resolution};
     
     command_buffer->set_render_pass(begin_info);
     
-    Renderer::ControllerContinuity continuity;
+    prism::renderer::controller_continuity continuity;
     renderer->render_camera(command_buffer, scene, camera, scene.get<Camera>(camera), begin_info.render_area.extent, *target, continuity);
     
     // render post
     begin_info.framebuffer = final_framebuffer;
-    begin_info.render_pass = renderer->unormRenderPass;
+    begin_info.render_pass = renderer->unorm_render_pass;
     
     command_buffer->set_render_pass(begin_info);
     
@@ -1002,12 +1002,12 @@ GFXTexture* CommonEditor::generate_common_preview(Scene& scene, const Vector3 ca
     
     command_buffer->set_viewport(viewport);
     
-    command_buffer->set_graphics_pipeline(renderer->renderToUnormTexturePipeline);
+    command_buffer->set_graphics_pipeline(renderer->render_to_unorm_texture_pipeline);
     
     command_buffer->bind_texture(offscreen_color_texture, 1);
-    command_buffer->bind_texture(renderer->dummyTexture, 2);
-    command_buffer->bind_texture(renderer->dummyTexture, 3);
-    command_buffer->bind_texture(renderer->dummyTexture, 4);
+    command_buffer->bind_texture(renderer->dummy_texture, 2);
+    command_buffer->bind_texture(renderer->dummy_texture, 3);
+    command_buffer->bind_texture(renderer->dummy_texture, 4);
     
     struct PostPushConstants {
         Vector4 viewport;
diff --git a/tools/common/src/debugpass.cpp b/tools/common/src/debugpass.cpp
index 8a629dc..903f704 100755
--- a/tools/common/src/debugpass.cpp
+++ b/tools/common/src/debugpass.cpp
@@ -42,7 +42,7 @@ void DebugPass::initialize() {
             {1, GFXBindingType::PushConstant}
         };
 
-        createInfo.render_pass = engine->get_renderer()->offscreenRenderPass;
+        createInfo.render_pass = engine->get_renderer()->offscreen_render_pass;
         createInfo.rasterization.polygon_type = GFXPolygonType::Line;
 
         primitive_pipeline = engine->get_gfx()->create_graphics_pipeline(createInfo);
@@ -159,7 +159,7 @@ void DebugPass::initialize() {
         
         pipelineInfo.blending.enable_blending = true;
         
-        pipelineInfo.render_pass = engine->get_renderer()->offscreenRenderPass;
+        pipelineInfo.render_pass = engine->get_renderer()->offscreen_render_pass;
         
         billboard_pipeline = engine->get_gfx()->create_graphics_pipeline(pipelineInfo);