diff --git a/res/shaders/unused/lines_debug.frag b/res/shaders/lines_debug.frag
similarity index 50%
rename from res/shaders/unused/lines_debug.frag
rename to res/shaders/lines_debug.frag
index ab65bdb..87aae54 100644
--- a/res/shaders/unused/lines_debug.frag
+++ b/res/shaders/lines_debug.frag
@@ -1,11 +1,11 @@
 #version 450 core
 
-in vec4 vFragPos;
+layout (location = 0) in vec3 vFragPos;
 
 layout(location = 0) out vec4 outColour;
 
 void main()
 {
-    outColour = vec4(vFragPos.xyz, 1.0);
+    outColour = vec4(1., 0., 0., 1.0);
 }
 
diff --git a/res/shaders/lines_debug.frag.spv b/res/shaders/lines_debug.frag.spv
new file mode 100644
index 0000000..c0cc3de
Binary files /dev/null and b/res/shaders/lines_debug.frag.spv differ
diff --git a/res/shaders/lines_debug.vert b/res/shaders/lines_debug.vert
new file mode 100644
index 0000000..a11cd66
--- /dev/null
+++ b/res/shaders/lines_debug.vert
@@ -0,0 +1,19 @@
+#version 450 core
+
+layout (location = 0) in vec3 position;
+
+layout (binding = 0) uniform SceneUniformBufferObject {
+    mat4 proj;
+    mat4 view;
+    mat4 unused0;
+    mat4 unused1;
+} ubo;
+
+// mat4 model;
+
+layout (location = 1) out vec3 vFragPos;
+
+void main() {
+    vFragPos = vec3(vec4(position, 1.0));
+    gl_Position = ubo.proj * ubo.view * vec4(position, 1.0);
+}
diff --git a/res/shaders/lines_debug.vert.spv b/res/shaders/lines_debug.vert.spv
new file mode 100644
index 0000000..c03b0a9
Binary files /dev/null and b/res/shaders/lines_debug.vert.spv differ
diff --git a/res/shaders/unused/lines_debug.vert b/res/shaders/unused/lines_debug.vert
deleted file mode 100644
index 2b0c1e5..0000000
--- a/res/shaders/unused/lines_debug.vert
+++ /dev/null
@@ -1,15 +0,0 @@
-#version 450 core
-
-layout(location = 0) in vec4 position;
-
-uniform mat4 model;
-uniform mat4 view;
-uniform mat4 proj;
-
-out vec4 vFragPos;
-
-void main()
-{
-    vFragPos = model * position;
-    gl_Position = proj * view * model * position;
-}
diff --git a/res/shaders/vulkan_test.frag b/res/shaders/vulkan_test.frag
deleted file mode 100644
index 32335af..0000000
--- a/res/shaders/vulkan_test.frag
+++ /dev/null
@@ -1,9 +0,0 @@
-#version 450 core
-
-layout(location = 0) in vec3 fFragColour;
-
-layout(location = 0) out vec4 outColour;
-
-void main() {
-    outColour = vec4(fFragColour, 1.0);
-}
diff --git a/res/shaders/vulkan_test.frag.spv b/res/shaders/vulkan_test.frag.spv
deleted file mode 100644
index c20ecbc..0000000
Binary files a/res/shaders/vulkan_test.frag.spv and /dev/null differ
diff --git a/res/shaders/vulkan_test.vert b/res/shaders/vulkan_test.vert
deleted file mode 100644
index 7ec0749..0000000
--- a/res/shaders/vulkan_test.vert
+++ /dev/null
@@ -1,13 +0,0 @@
-#version 450 core
-
-layout(location = 0) in vec3 vPosition;
-layout(location = 1) in vec3 vColor;
-
-layout(location = 0) out vec3 fFragColour;
-
-
-void main() {
-    gl_Position = vec4(vPosition, 1.0);
-    fFragColour = vColor;
-}
-
diff --git a/res/shaders/vulkan_test.vert.spv b/res/shaders/vulkan_test.vert.spv
deleted file mode 100644
index 648a2fa..0000000
Binary files a/res/shaders/vulkan_test.vert.spv and /dev/null differ
diff --git a/src/graphics/buffer.cpp b/src/graphics/buffer.cpp
index 40b9170..42cbb38 100644
--- a/src/graphics/buffer.cpp
+++ b/src/graphics/buffer.cpp
@@ -105,17 +105,20 @@ Buffer* vertex_buffer_create(GraphicsDevice* device, void* data, uint32_t size,
     yolo::debug("Staging buffer size: {}", bufferSize);
     buffer->NullableClientData = data;
 
-    void* mData;
-    vkMapMemory(device->VulkanDevice, buffer->StagingBuffer->DeviceData, 0, bufferSize, 0,
-        &mData);
-    memcpy(mData, data, bufferSize);
-    vkUnmapMemory(device->VulkanDevice, buffer->StagingBuffer->DeviceData);
+    if (size == 0) {
+        void* mData;
+        vkMapMemory(device->VulkanDevice, buffer->StagingBuffer->DeviceData, 0, bufferSize, 0,
+                &mData);
+        memcpy(mData, data, bufferSize);
+        vkUnmapMemory(device->VulkanDevice, buffer->StagingBuffer->DeviceData);
+    }
 
     buffer->GenericBuffer = generic_buffer_create(device, size, bufferSize,
         VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
         VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
 
-    buffer_copy(buffer, device);
+    if (size == 0)
+        buffer_copy(buffer, device);
 
     return buffer;
 }
@@ -127,6 +130,34 @@ void vertex_buffer_cleanup(Buffer* buffer)
     delete buffer;
 }
 
+void vertex_buffer_update(Buffer* buffer, void* data, uint32_t size)
+{
+    VkDeviceSize bufferSize = size * sizeof(scene::Vert);
+
+    if (buffer->StagingBuffer->Size < bufferSize) {
+        generic_buffer_cleanup(buffer->StagingBuffer);
+        generic_buffer_cleanup(buffer->GenericBuffer);
+
+        buffer->StagingBuffer = generic_buffer_create(buffer->GenericBuffer->Device,
+            size, bufferSize, VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
+            VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
+
+        buffer->GenericBuffer = generic_buffer_create(buffer->GenericBuffer->Device,
+            size, bufferSize,
+            VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
+            VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
+    }
+
+    void* mData;
+    vkMapMemory(buffer->GenericBuffer->Device->VulkanDevice,
+        buffer->StagingBuffer->DeviceData, 0, bufferSize, 0, &mData);
+    memcpy(mData, data, bufferSize);
+    vkUnmapMemory(buffer->GenericBuffer->Device->VulkanDevice,
+        buffer->StagingBuffer->DeviceData);
+
+    buffer_copy(buffer, buffer->GenericBuffer->Device);
+}
+
 void vertex_buffer_bind(Buffer* buffer, VkCommandBuffer commandBuffer)
 {
     VkBuffer vertexBuffers[] = { buffer->GenericBuffer->Handle };
diff --git a/src/graphics/buffer.hpp b/src/graphics/buffer.hpp
index 2792be6..b1e09d0 100644
--- a/src/graphics/buffer.hpp
+++ b/src/graphics/buffer.hpp
@@ -38,16 +38,21 @@ void generic_buffer_cleanup(GenBuffer* buffer);
 
 void buffer_copy(Buffer* buffer, GraphicsDevice* device);
 
-Buffer* vertex_buffer_create(GraphicsDevice* device, void* data, uint32_t size, bool bind = false);
+Buffer* vertex_buffer_create(
+    GraphicsDevice* device, void* data, uint32_t size, bool bind = false);
 void vertex_buffer_cleanup(Buffer* buffer);
+void vertex_buffer_update(Buffer* buffer, void* data, uint32_t size);
 void vertex_buffer_bind(Buffer* buffer, VkCommandBuffer commandBuffer);
 
-Buffer* index_buffer_create(GraphicsDevice* device, void* data, uint32_t size, bool bind = false);
+Buffer* index_buffer_create(
+    GraphicsDevice* device, void* data, uint32_t size, bool bind = false);
 void index_buffer_cleanup(Buffer* buffer);
+void index_buffer_update(Buffer* buffer, void* data, uint32_t size);
 void index_buffer_bind(Buffer* buffer, VkCommandBuffer commandBuffer);
 
 // We *do* want universally mapped memory to act as a "uniform buffer"
-template<typename T> GenBuffer* uniform_buffer_create(GraphicsDevice* device, bool bind = false)
+template <typename T>
+GenBuffer* uniform_buffer_create(GraphicsDevice* device, bool bind = false)
 {
     GenBuffer* buffer
         = generic_buffer_create(device, 0, sizeof(T), VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
@@ -61,7 +66,7 @@ template<typename T> GenBuffer* uniform_buffer_create(GraphicsDevice* device, bo
 
 inline void uniform_buffer_cleanup(GenBuffer* buffer) { generic_buffer_cleanup(buffer); }
 
-template<typename T> void uniform_buffer_update(GenBuffer* buffer, T* data)
+template <typename T> void uniform_buffer_update(GenBuffer* buffer, T* data)
 {
     memcpy(buffer->MappedData, (void*)data, sizeof(T));
 }
diff --git a/src/graphics/pipeline.cpp b/src/graphics/pipeline.cpp
index 3171b27..c93c470 100644
--- a/src/graphics/pipeline.cpp
+++ b/src/graphics/pipeline.cpp
@@ -44,6 +44,9 @@ Pipeline* pipeline_create(GraphicsDevice* device, SwapChain* swap, Shader* shade
     inputAssembly.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
     inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
     inputAssembly.primitiveRestartEnable = VK_FALSE;
+    if (type == PIPELINE_TYPE_GRAPHICS_LINE) {
+        inputAssembly.topology = VK_PRIMITIVE_TOPOLOGY_LINE_LIST;
+    }
 
     VkPipelineViewportStateCreateInfo viewportState {};
     viewportState.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
@@ -53,7 +56,6 @@ Pipeline* pipeline_create(GraphicsDevice* device, SwapChain* swap, Shader* shade
     VkPipelineRasterizationStateCreateInfo rasterizer {};
     rasterizer.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
     rasterizer.depthClampEnable = VK_FALSE; // NOTE: This is for shadow mapping
-    rasterizer.polygonMode = VK_POLYGON_MODE_LINE;
     rasterizer.rasterizerDiscardEnable = VK_FALSE;
     rasterizer.polygonMode = VK_POLYGON_MODE_FILL;
     rasterizer.lineWidth = 1.3f;
diff --git a/src/graphics/shader.cpp b/src/graphics/shader.cpp
index dbce32d..bb9b8b7 100644
--- a/src/graphics/shader.cpp
+++ b/src/graphics/shader.cpp
@@ -21,11 +21,13 @@ std::string textFromFile(const std::filesystem::path& path)
         (std::istreambuf_iterator<char>(input)), std::istreambuf_iterator<char>());
 }
 
-Shader* shader_create(GraphicsDevice* device, SwapChain* swapchain)
+Shader* shader_create(
+    GraphicsDevice* device, SwapChain* swapchain, ShaderProgramType type)
 {
     Shader* shader = new Shader;
     shader->Device = device;
     shader->GraphicsSwapchain = swapchain;
+    shader->Type = type;
 
     return shader;
 }
@@ -173,8 +175,21 @@ void shader_build(Shader* shader)
         yolo::error("failed to allocate descriptor sets!");
     }
 
+    PipelineType pipelineType = PIPELINE_TYPE_GRAPHICS;
+    switch (shader->Type) {
+    case SHADER_PROGRAM_TYPE_GRAPHICS:
+        pipelineType = PIPELINE_TYPE_GRAPHICS;
+        break;
+    case SHADER_PROGRAM_TYPE_GRAPHICS_LINE:
+        pipelineType = PIPELINE_TYPE_GRAPHICS_LINE;
+        break;
+    default:
+        yolo::error("Shader type not supported");
+        break;
+    }
+
     shader->GraphicsPipeline = pipeline_create(shader->Device, shader->GraphicsSwapchain,
-        shader, layouts.size(), layouts.data(), PIPELINE_TYPE_GRAPHICS);
+        shader, layouts.size(), layouts.data(), pipelineType);
     shader->GlobalUniformBuffer
         = uniform_buffer_create<scene::GlobalUniformObject>(shader->Device, true);
 }
diff --git a/src/graphics/shader.hpp b/src/graphics/shader.hpp
index 6e25a02..b3661ec 100644
--- a/src/graphics/shader.hpp
+++ b/src/graphics/shader.hpp
@@ -19,6 +19,13 @@ struct SwapChain;
 struct Pipeline;
 struct GenBuffer;
 
+typedef enum ShaderProgramType {
+    SHADER_PROGRAM_TYPE_GRAPHICS,
+    SHADER_PROGRAM_TYPE_GRAPHICS_LINE,
+    SHADER_PROGRAM_TYPE_COMPUTE,
+    SHADER_PROGRAM_TYPE_RAYTRACING
+} ShaderProgramType;
+
 typedef struct ShaderPushConst {
     union {
         glm::mat4 mat[2]; // 64 bytes each
@@ -30,6 +37,8 @@ typedef struct ShaderPushConst {
 typedef struct Shader {
     GraphicsDevice* Device;
 
+    ShaderProgramType Type;
+
     SwapChain* GraphicsSwapchain;
     Pipeline* GraphicsPipeline;
 
@@ -45,7 +54,8 @@ typedef struct Shader {
     VkPipelineVertexInputStateCreateInfo VertexInputInfo;
 } Shader;
 
-Shader* shader_create(GraphicsDevice* device, SwapChain* swapchain);
+Shader* shader_create(
+    GraphicsDevice* device, SwapChain* swapchain, ShaderProgramType type);
 void shader_cleanup(Shader* shader);
 
 void shader_load(Shader* shader, std::filesystem::path path);
diff --git a/src/graphics/vkrenderer.cpp b/src/graphics/vkrenderer.cpp
index 511fbf2..8ade0b6 100644
--- a/src/graphics/vkrenderer.cpp
+++ b/src/graphics/vkrenderer.cpp
@@ -198,7 +198,7 @@ bool renderer_begin_frame(VulkanRenderer* renderer)
 }
 
 void renderer_begin_pass(
-    VulkanRenderer* renderer, RenderTarget* target, VkRect2D renderArea)
+    VulkanRenderer* renderer, RenderTarget* target, VkRect2D renderArea, bool clear)
 {
     VkImageMemoryBarrier imageMemoryBarrier {};
     imageMemoryBarrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
@@ -224,6 +224,9 @@ void renderer_begin_pass(
     attachmentInfo.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
     attachmentInfo.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
     attachmentInfo.clearValue = clearColor;
+    if (!clear) {
+        attachmentInfo.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
+    }
 
     VkRenderingAttachmentInfo depthAttachmentInfo;
     if (target->TargetDepth != nullptr) {
@@ -237,6 +240,9 @@ void renderer_begin_pass(
         depthAttachmentInfo.resolveImageView = VK_NULL_HANDLE;
         depthAttachmentInfo.resolveImageLayout = VK_IMAGE_LAYOUT_GENERAL;
         depthAttachmentInfo.pNext = VK_NULL_HANDLE;
+        if (!clear) {
+            depthAttachmentInfo.loadOp = VK_ATTACHMENT_LOAD_OP_LOAD;
+        }
     }
 
     VkRenderingInfo renderingInfo {};
diff --git a/src/graphics/vkrenderer.hpp b/src/graphics/vkrenderer.hpp
index a21c549..4189a64 100644
--- a/src/graphics/vkrenderer.hpp
+++ b/src/graphics/vkrenderer.hpp
@@ -67,8 +67,8 @@ void renderer_submit_now(VulkanRenderer* renderer,
 
 bool renderer_begin_frame(VulkanRenderer* renderer);
 
-void renderer_begin_pass(
-    VulkanRenderer* renderer, RenderTarget* target, VkRect2D renderArea);
+void renderer_begin_pass(VulkanRenderer* renderer, RenderTarget* target,
+    VkRect2D renderArea, bool clear = true);
 // this is for rendering to the swapchain / present image
 void renderer_begin_pass(VulkanRenderer* renderer, VkRect2D renderArea);
 
diff --git a/src/inferno.cpp b/src/inferno.cpp
index 9bf9ee1..919466f 100644
--- a/src/inferno.cpp
+++ b/src/inferno.cpp
@@ -14,6 +14,7 @@
 #include "graphics/shader.hpp"
 #include "graphics/swapchain.hpp"
 #include "graphics/vkrenderer.hpp"
+#include "preview_renderer/debug.hpp"
 #include "window.hpp"
 
 // #include "preview_renderer/debug.hpp"
@@ -292,7 +293,7 @@ int inferno_run(InfernoApp* app)
                 ImGui::Checkbox("Show Preview", &showPreview);
                 graphics::preview_draw_ui(app->PreviewRenderer);
                 if (ImGui::TreeNode("Debug Overlay")) {
-                    // graphics::debug_draw_ui();
+                    graphics::debug_draw_ui();
                     ImGui::TreePop();
                 }
                 ImGui::TreePop();
@@ -323,6 +324,8 @@ int inferno_run(InfernoApp* app)
             lastViewport = currentViewport;
 
             graphics::preview_draw(app->PreviewRenderer, app->Scene);
+            // graphics::debug_draw_line({0, 0, 0}, {1, 1, 0}, {1, 1, 0});
+            // graphics::debug_draw_to_target(app->Scene);
 
             ImTextureID texture
                 = (ImTextureID)graphics::preview_get_target(app->PreviewRenderer)
diff --git a/src/preview_renderer/debug.cpp b/src/preview_renderer/debug.cpp
index a44c5d8..f894f2b 100644
--- a/src/preview_renderer/debug.cpp
+++ b/src/preview_renderer/debug.cpp
@@ -1,9 +1,14 @@
 #include "debug.hpp"
 
-#include "preview_renderer/renderer.hpp"
-#include "graphics/shader.hpp"
 #include "graphics/buffer.hpp"
+#include "graphics/rendertarget.hpp"
+#include "graphics/shader.hpp"
+#include "graphics/vkrenderer.hpp"
+
+#include "preview_renderer/renderer.hpp"
+
 #include "scene/camera.hpp"
+#include "scene/mesh.hpp"
 #include "scene/scene.hpp"
 
 #include <graphics.hpp>
@@ -26,34 +31,31 @@ struct DebugTextBillboard {
 struct _DebugInternal {
     std::mutex DebugMutex;
 
-    Buffer* LineBuffer;
+    Buffer* LineBuffer = nullptr;
     Shader* LineShader;
 };
 
 static DebugDrawer* DebugDrawerInstance = nullptr;
 
-void debug_init()
+void debug_init(PreviewRenderer* renderer)
 {
     DebugDrawerInstance = new DebugDrawer;
 
+    DebugDrawerInstance->Renderer = renderer;
     DebugDrawerInstance->LineElements = std::vector<DebugLine>();
-    DebugDrawerInstance->BillboardElements = std::vector<DebugTextBillboard>();
+    // DebugDrawerInstance->BillboardElements = std::vector<DebugTextBillboard>();
 
     DebugDrawerInstance->_Internal = new _DebugInternal;
-    // DebugDrawerInstance->_Internal->LineShader = shader_create();
+    // DebugDrawerInstance->_Internal->LineShader = shader_create(renderer->Renderer->Device,
+    //     renderer->Renderer->Swap, SHADER_PROGRAM_TYPE_GRAPHICS_LINE);
+    // graphics::shader_load(
+    //     DebugDrawerInstance->_Internal->LineShader, "res/shaders/lines_debug");
+    // graphics::shader_build(DebugDrawerInstance->_Internal->LineShader);
 
     yolo::debug("DebugDrawer initialized");
 }
 
-void debug_cleanup()
-{
-    delete DebugDrawerInstance;
-}
-
-void debug_attach_renderer(PreviewRenderer* renderer)
-{
-    DebugDrawerInstance->Renderer = renderer;
-}
+void debug_cleanup() { delete DebugDrawerInstance; }
 
 void debug_draw_line(glm::vec3 start, glm::vec3 end, glm::vec3 color)
 {
@@ -61,55 +63,62 @@ void debug_draw_line(glm::vec3 start, glm::vec3 end, glm::vec3 color)
     DebugDrawerInstance->LineElements.push_back({ start, end, color });
 }
 
-void debug_draw_text_billboard(glm::vec3 position, glm::vec3 color, std::string text)
-{
-    std::lock_guard<std::mutex> lock(DebugDrawerInstance->_Internal->DebugMutex);
-    DebugDrawerInstance->BillboardElements.push_back({ position, color, text });
-}
+// void debug_draw_text_billboard(glm::vec3 position, glm::vec3 color, std::string text)
+// {
+//     std::lock_guard<std::mutex> lock(DebugDrawerInstance->_Internal->DebugMutex);
+//     DebugDrawerInstance->BillboardElements.push_back({ position, color, text });
+// }
 
-void debug_draw_ui()
-{
-    ImGui::Checkbox("Show Overlay", &DebugDrawerInstance->DoShow);
-}
+void debug_draw_ui() { ImGui::Checkbox("Show Overlay", &DebugDrawerInstance->DoShow); }
 
 void debug_draw_to_target(scene::Scene* scene)
 {
     if (!DebugDrawerInstance->DoShow)
         return;
 
-    auto renderer = DebugDrawerInstance->Renderer;
+    uint32_t bufferSize
+        = DebugDrawerInstance->LineElements.size() * sizeof(DebugLine) * 2;
+    scene::DebugLineVert* bufferData = new scene::DebugLineVert[bufferSize];
 
-    GLuint vertex_position_arr_size = DebugDrawerInstance->LineElements.size() * 2 * 3;
-    GLfloat vertex_position_arr[vertex_position_arr_size];
     for (int i = 0; i < DebugDrawerInstance->LineElements.size(); i++) {
-        auto line = DebugDrawerInstance->LineElements[i];
-        vertex_position_arr[i * 6 + 0] = line.Start.x;
-        vertex_position_arr[i * 6 + 1] = line.Start.y;
-        vertex_position_arr[i * 6 + 2] = line.Start.z;
-        vertex_position_arr[i * 6 + 3] = line.End.x;
-        vertex_position_arr[i * 6 + 4] = line.End.y;
-        vertex_position_arr[i * 6 + 5] = line.End.z;
+        bufferData[i * 2] = { DebugDrawerInstance->LineElements[i].Start,
+            DebugDrawerInstance->LineElements[i].Color };
+        bufferData[i * 2 + 1] = { DebugDrawerInstance->LineElements[i].End,
+            DebugDrawerInstance->LineElements[i].Color };
     }
 
+    if (bufferSize > 0 && DebugDrawerInstance->_Internal->LineBuffer == nullptr) {
+        DebugDrawerInstance->_Internal->LineBuffer = vertex_buffer_create(
+            DebugDrawerInstance->Renderer->Renderer->Device, bufferData, bufferSize);
+    }
 
-    // glDrawArrays(GL_LINES, 0, vertex_position_arr_size);
+    auto backend = DebugDrawerInstance->Renderer->Renderer;
+    VkCommandBuffer commandBuffer = *backend->CommandBufferInFlight;
+
+    graphics::renderer_begin_pass(backend,
+        DebugDrawerInstance->Renderer->PreviewRenderTarget,
+        DebugDrawerInstance->Renderer->Viewport, false);
+
+    graphics::shader_use(DebugDrawerInstance->_Internal->LineShader, commandBuffer,
+        DebugDrawerInstance->Renderer->Viewport);
+
+    scene::GlobalUniformObject GlobalUniformObject {
+        .Projection = graphics::camera_get_projection(scene->Camera),
+        .View = graphics::camera_get_view(scene->Camera),
+    };
+
+    graphics::shader_update_state(DebugDrawerInstance->_Internal->LineShader,
+        commandBuffer, GlobalUniformObject, backend->CurrentFrameIndex);
+
+    graphics::vertex_buffer_bind(
+        DebugDrawerInstance->_Internal->LineBuffer, commandBuffer);
+
+    vkCmdDraw(commandBuffer, DebugDrawerInstance->LineElements.size() * 2, 1, 0, 0);
+
+    graphics::renderer_end_pass(backend);
 
     DebugDrawerInstance->LineElements.clear();
-
-    // glEnable(GL_TEXTURE_2D);
-    // glEnable(GL_BLEND);
-    // glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-    //
-    // for (auto& billboard : DebugDrawerInstance->BillboardElements) {
-    //     glColor3f(billboard.Color.x, billboard.Color.y, billboard.Color.z);
-    //     glRasterPos3f(billboard.Position.x, billboard.Position.y, billboard.Position.z);
-    //
-    //     for (auto& c : billboard.Text) {
-    //         glutBitmapCharacter(GL_BITMAP, c);
-    //     }
-    // }
-
-    DebugDrawerInstance->BillboardElements.clear();
+    delete[] bufferData;
 }
 
 }
diff --git a/src/preview_renderer/debug.hpp b/src/preview_renderer/debug.hpp
index c53636b..e950da2 100644
--- a/src/preview_renderer/debug.hpp
+++ b/src/preview_renderer/debug.hpp
@@ -21,21 +21,20 @@ struct DebugTextBillboard;
 struct _DebugInternal;
 
 struct DebugDrawer {
+    PreviewRenderer* Renderer = nullptr;
     _DebugInternal* _Internal = nullptr;
 
     bool DoShow = true;
-    PreviewRenderer* Renderer = nullptr;
+
     std::vector<DebugLine> LineElements;
-    std::vector<DebugTextBillboard> BillboardElements;
+    // std::vector<DebugTextBillboard> BillboardElements;
 };
 
-void debug_init();
+void debug_init(PreviewRenderer* renderer);
 void debug_cleanup();
 
-void debug_attach_renderer(PreviewRenderer* renderer);
-
 void debug_draw_line(glm::vec3 start, glm::vec3 end, glm::vec3 color);
-void debug_draw_text_billboard(glm::vec3 position, glm::vec3 color, std::string text);
+// void debug_draw_text_billboard(glm::vec3 position, glm::vec3 color, std::string text);
 
 void debug_draw_ui();
 
diff --git a/src/preview_renderer/renderer.cpp b/src/preview_renderer/renderer.cpp
index 05cf283..5380a82 100644
--- a/src/preview_renderer/renderer.cpp
+++ b/src/preview_renderer/renderer.cpp
@@ -30,7 +30,8 @@ PreviewRenderer* preview_create(VulkanRenderer* vkrenderer)
     PreviewRenderer* renderer = new PreviewRenderer;
     renderer->Renderer = vkrenderer;
 
-    renderer->DrawShader = graphics::shader_create(vkrenderer->Device, vkrenderer->Swap);
+    renderer->DrawShader = graphics::shader_create(
+        vkrenderer->Device, vkrenderer->Swap, SHADER_PROGRAM_TYPE_GRAPHICS);
 
     graphics::shader_load(renderer->DrawShader, "res/shaders/basic");
     graphics::shader_build(renderer->DrawShader);
@@ -39,8 +40,7 @@ PreviewRenderer* preview_create(VulkanRenderer* vkrenderer)
         renderer->Renderer->Device, { 1920, 1080 }, VK_FORMAT_R8G8B8A8_UNORM, true);
 
     // bind preview renderer to debugdraw
-    debug_init();
-    debug_attach_renderer(renderer);
+    // debug_init(renderer);
 
     return renderer;
 }
diff --git a/src/scene/mesh.hpp b/src/scene/mesh.hpp
index 0e2dc18..f759f81 100644
--- a/src/scene/mesh.hpp
+++ b/src/scene/mesh.hpp
@@ -21,8 +21,15 @@ struct Vert {
     glm::vec3 Normal;
 };
 
+struct DebugLineVert {
+    glm::vec3 Position;
+    glm::vec3 Color;
+};
+
 using Index = uint32_t;
 
+// NOTE: Out of coincidence, this is the same for both vert and debug line vert
+// TODO: Make this a template // somehow
 VkVertexInputBindingDescription get_vert_binding_description();
 std::array<VkVertexInputAttributeDescription, 2> get_vert_attribute_descriptions();