diff --git a/README.md b/README.md
index 6bc856a..32dca32 100644
--- a/README.md
+++ b/README.md
@@ -18,3 +18,5 @@ Ability to create applications that can leverage Buffers and Textures to render
 # Plans
 Improved Validation <br />
   Currently validation is always run and it discards the messages if you dont have a debugger attached, I plan to support layers like vulkan that can validation certain parts of the API
+Device Features <br />
+  Physical Devices dont report features that they support at all so the developer can't chose them based on features
diff --git a/rendering_api/vulkan/src/debugger/vulkan_debugger.c b/rendering_api/vulkan/src/debugger/vulkan_debugger.c
index d933cf3..b324b6a 100644
--- a/rendering_api/vulkan/src/debugger/vulkan_debugger.c
+++ b/rendering_api/vulkan/src/debugger/vulkan_debugger.c
@@ -1,161 +1,158 @@
 #include "vulkan_debugger.h"
 #include <instance/vulkan_instance.h>
-#include "core/instance/gryphn_instance.h"
-#include "stdio.h"
 
-void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT* createInfo) {
+void vkPopulateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT* createInfo) {
     createInfo->sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
     createInfo->messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
     createInfo->messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
 }
 
+// gnBool vkCheckValidationLayerSupport(uint32_t count, const char** layers) {
+//     uint32_t layerCount;
+//     vkEnumerateInstanceLayerProperties(&layerCount, NULL);
+//     if (layerCount == 0) return gnFalse;
 
-gnBool checkValidationLayerSupport(uint32_t count, const char** layers) {
-    uint32_t layerCount;
-    vkEnumerateInstanceLayerProperties(&layerCount, NULL);
-    if (layerCount == 0) return gnFalse;
+//     VkLayerProperties* properties = malloc(sizeof(VkLayerProperties) * layerCount);
+//     vkEnumerateInstanceLayerProperties(&layerCount, properties);
 
-    VkLayerProperties* properties = malloc(sizeof(VkLayerProperties) * layerCount);
-    vkEnumerateInstanceLayerProperties(&layerCount, properties);
+//     for (int i = 0; i < count; i++) {
+//         gnBool layerFound = gnFalse;
 
-    for (int i = 0; i < count; i++) {
-        gnBool layerFound = gnFalse;
+//         for (int c = 0; c < layerCount; c++) {
+//             if (strcmp(layers[i], properties[c].layerName) == 0) {
+//                 layerFound = gnTrue;
+//                 break;
+//             }
+//         }
 
-        for (int c = 0; c < layerCount; c++) {
-            if (strcmp(layers[i], properties[c].layerName) == 0) {
-                layerFound = gnTrue;
-                break;
-            }
-        }
+//         if (layerFound == gnFalse)
+//             return gnFalse;
+//     }
 
-        if (layerFound == gnFalse)
-            return gnFalse;
-    }
+//     return gnTrue;
+// }
 
-    return gnTrue;
-}
+// typedef struct vk_userData_t {
+//     gnDebuggerCallback debuggerCallback;
+//     void* userData;
+// } vkUserData;
 
-typedef struct vk_userData_t {
-    gnDebuggerCallback debuggerCallback;
-    void* userData;
-} vkUserData;
+// static VKAPI_ATTR VkBool32 VKAPI_CALL vk_debuggerDebugCallback(
+//     VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
+//     VkDebugUtilsMessageTypeFlagsEXT messageType,
+//     const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
+//     void* pUserData) {
+//     struct vk_userData_t userData = *(struct vk_userData_t*)pUserData;
 
-static VKAPI_ATTR VkBool32 VKAPI_CALL vk_debuggerDebugCallback(
-    VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
-    VkDebugUtilsMessageTypeFlagsEXT messageType,
-    const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData,
-    void* pUserData) {
-    struct vk_userData_t userData = *(struct vk_userData_t*)pUserData;
+//     gnMessageSeverity severity;
+//     gnMessageType type;
+//     gnMessageData data = {
+//         .message = gnCreateString(pCallbackData->pMessage)
+//     };
 
-    gnMessageSeverity severity;
-    gnMessageType type;
-    gnMessageData data = {
-        .message = gnCreateString(pCallbackData->pMessage)
-    };
+//     switch (messageSeverity) {
+//     default: break;
+//     case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT: severity = GN_MESSAGE_VERBOSE; break;
+//     case VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT: severity = GN_MESSAGE_INFO; break;
+//     case VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT: severity = GN_MESSAGE_WARNING; break;
+//     case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT: severity = GN_MESSAGE_ERROR; break;
+//     }
 
-    switch (messageSeverity) {
-    default: break;
-    case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT: severity = GN_MESSAGE_VERBOSE; break;
-    case VK_DEBUG_UTILS_MESSAGE_SEVERITY_INFO_BIT_EXT: severity = GN_MESSAGE_INFO; break;
-    case VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT: severity = GN_MESSAGE_WARNING; break;
-    case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT: severity = GN_MESSAGE_ERROR; break;
-    }
+//     switch (messageType) {
+//     default: break;
+//     case VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT: type = GN_DEBUG_MESSAGE_GENERAL; break;
+//     case VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT: type = GN_DEBUG_MESSAGE_VALIDATION; break;
+//     case VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT: type = GN_DEBUG_MESSAGE_PERFORMANCE; break;
+//     }
 
-    switch (messageType) {
-    default: break;
-    case VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT: type = GN_DEBUG_MESSAGE_GENERAL; break;
-    case VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT: type = GN_DEBUG_MESSAGE_VALIDATION; break;
-    case VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT: type = GN_DEBUG_MESSAGE_PERFORMANCE; break;
-    }
+//     gnDebuggerCallback callback = *userData.debuggerCallback;
+//     gnBool result = callback(severity, type, data, userData.userData);
+//     if (result == gnFalse) return VK_FALSE;
+//     return VK_TRUE;
+// }
 
-    gnDebuggerCallback callback = *userData.debuggerCallback;
-    gnBool result = callback(severity, type, data, userData.userData);
-    if (result == gnFalse) return VK_FALSE;
-    return VK_TRUE;
-}
+// VkResult vk_createDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pDebugMessenger) {
+//     PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT");
+//     if (vkCreateDebugUtilsMessengerEXT != NULL) {
+//         return vkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, NULL, pDebugMessenger);
+//     }else
+//         return VK_ERROR_EXTENSION_NOT_PRESENT;
+//     return VK_SUCCESS;
+// }
 
-VkResult vk_createDebugUtilsMessengerEXT(VkInstance instance, const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pDebugMessenger) {
-    PFN_vkCreateDebugUtilsMessengerEXT vkCreateDebugUtilsMessengerEXT = (PFN_vkCreateDebugUtilsMessengerEXT)vkGetInstanceProcAddr(instance, "vkCreateDebugUtilsMessengerEXT");
-    if (vkCreateDebugUtilsMessengerEXT != NULL) {
-        return vkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, NULL, pDebugMessenger);
-    }else
-        return VK_ERROR_EXTENSION_NOT_PRESENT;
-    return VK_SUCCESS;
-}
+// void vk_destroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT debugMessenger, const VkAllocationCallbacks* pAllocator) {
+//     PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = (PFN_vkDestroyDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT");
+//     if (vkDestroyDebugUtilsMessengerEXT != NULL) {
+//         vkDestroyDebugUtilsMessengerEXT(instance, debugMessenger, pAllocator);
+//     }
+// }
 
-void vk_destroyDebugUtilsMessengerEXT(VkInstance instance, VkDebugUtilsMessengerEXT debugMessenger, const VkAllocationCallbacks* pAllocator) {
-    PFN_vkDestroyDebugUtilsMessengerEXT vkDestroyDebugUtilsMessengerEXT = (PFN_vkDestroyDebugUtilsMessengerEXT) vkGetInstanceProcAddr(instance, "vkDestroyDebugUtilsMessengerEXT");
-    if (vkDestroyDebugUtilsMessengerEXT != NULL) {
-        vkDestroyDebugUtilsMessengerEXT(instance, debugMessenger, pAllocator);
-    }
-}
+// gnReturnCode gnCreateDebuggerFn(gnDebuggerHandle debugger, gnInstanceHandle instance, const struct gnDebuggerInfo_t info) {
+//     debugger->debugger = malloc(sizeof(gnPlatformDebugger));
 
-gnReturnCode gnCreateDebuggerFn(gnDebuggerHandle debugger, gnInstanceHandle instance, const struct gnDebuggerInfo_t info) {
-    debugger->debugger = malloc(sizeof(gnPlatformDebugger));
+//     if (instance->valid == gnFalse) {
+//         for (int i = 0; i < instance->instance->instanceMessageCount; i++) {
+//             info.callback(
+//                 instance->instance->instanceMessages[i].severity,
+//                 instance->instance->instanceMessages[i].type,
+//                 instance->instance->instanceMessages[i].data,
+//                 info.userData
+//             );
+//         }
+//         return GN_INVALID_INSTANCE;
+//     } else {
+//         for (int i = 0; i < instance->instance->instanceMessageCount; i++) {
+//             info.callback(
+//                 instance->instance->instanceMessages[i].severity,
+//                 instance->instance->instanceMessages[i].type,
+//                 instance->instance->instanceMessages[i].data,
+//                 info.userData
+//             );
+//         }
+//     }
 
-    if (instance->valid == gnFalse) {
-        for (int i = 0; i < instance->instance->instanceMessageCount; i++) {
-            info.callback(
-                instance->instance->instanceMessages[i].severity,
-                instance->instance->instanceMessages[i].type,
-                instance->instance->instanceMessages[i].data,
-                info.userData
-            );
-        }
-        return GN_INVALID_INSTANCE;
-    } else {
-        for (int i = 0; i < instance->instance->instanceMessageCount; i++) {
-            info.callback(
-                instance->instance->instanceMessages[i].severity,
-                instance->instance->instanceMessages[i].type,
-                instance->instance->instanceMessages[i].data,
-                info.userData
-            );
-        }
-    }
+//     if (instance->instance->instanceMessageCount > 0) free(instance->instance->instanceMessages);
+//     instance->instance->instanceMessageCount = 0;
 
-    if (instance->instance->instanceMessageCount > 0) free(instance->instance->instanceMessages);
-    instance->instance->instanceMessageCount = 0;
-
-    const char* layers[] = {
-        "VK_LAYER_KHRONOS_validation"
-    };
-    if (!checkValidationLayerSupport(1, layers))
-        return GN_FAILED_TO_CREATE_DEBUGGER;
+//     const char* layers[] = {
+//         "VK_LAYER_KHRONOS_validation"
+//     };
+//     if (!checkValidationLayerSupport(1, layers))
+//         return GN_FAILED_TO_CREATE_DEBUGGER;
 
 
-    struct vk_userData_t* userData = (struct vk_userData_t*)malloc(sizeof(struct vk_userData_t));
-    userData->debuggerCallback = info.callback;
-    userData->userData = info.userData;
+//     struct vk_userData_t* userData = (struct vk_userData_t*)malloc(sizeof(struct vk_userData_t));
+//     userData->debuggerCallback = info.callback;
+//     userData->userData = info.userData;
 
-    VkDebugUtilsMessengerCreateInfoEXT createInfo = {};
-    createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
-    createInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
-    createInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
-    createInfo.pUserData = (void*)userData;
-    createInfo.pfnUserCallback = vk_debuggerDebugCallback;
+//     VkDebugUtilsMessengerCreateInfoEXT createInfo = {};
+//     createInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT;
+//     createInfo.messageSeverity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT;
+//     createInfo.messageType = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT;
+//     createInfo.pUserData = (void*)userData;
+//     createInfo.pfnUserCallback = vk_debuggerDebugCallback;
 
-    VkResult result = vk_createDebugUtilsMessengerEXT(instance->instance->vk_instance, &createInfo, NULL, &debugger->debugger->debugMessenger);    if (result != VK_SUCCESS) {
-        gnMessageSeverity severity = GN_MESSAGE_ERROR;
-        gnMessageType type = GN_DEBUG_MESSAGE_VALIDATION;
-        gnMessageData data = {
-            .message = gnCombineStrings(
-                gnCreateString("Failed to create gnDebuggerObject with api vulkan\n"),
-                gnCombineStrings(gnCreateString("Returned with a vulkan error code of: (please do this)"), "")
-            )
-        };
-        info.callback(
-            severity,
-            type,
-            data,
-            info.userData
-        );
+//     VkResult result = vk_createDebugUtilsMessengerEXT(instance->instance->vk_instance, &createInfo, NULL, &debugger->debugger->debugMessenger);    if (result != VK_SUCCESS) {
+//         gnMessageSeverity severity = GN_MESSAGE_ERROR;
+//         gnMessageType type = GN_DEBUG_MESSAGE_VALIDATION;
+//         gnMessageData data = {
+//             .message = gnCombineStrings(
+//                 gnCreateString("Failed to create gnDebuggerObject with api vulkan\n"),
+//                 gnCombineStrings(gnCreateString("Returned with a vulkan error code of: (please do this)"), "")
+//             )
+//         };
+//         info.callback(
+//             severity,
+//             type,
+//             data,
+//             info.userData
+//         );
 
-        return GN_FAILED_TO_CREATE_DEBUGGER;
-    }
-    return GN_SUCCESS;
-}
+//         return GN_FAILED_TO_CREATE_DEBUGGER;
+//     }
+//     return GN_SUCCESS;
+// }
 
-void gnDestroyDebuggerFn(gnDebuggerHandle debugger) {
-    vk_destroyDebugUtilsMessengerEXT(debugger->instance->instance->vk_instance, debugger->debugger->debugMessenger, NULL);
-}
+// void gnDestroyDebuggerFn(gnDebuggerHandle debugger) {
+//     vk_destroyDebugUtilsMessengerEXT(debugger->instance->instance->vk_instance, debugger->debugger->debugMessenger, NULL);
+// }
diff --git a/rendering_api/vulkan/src/debugger/vulkan_debugger.h b/rendering_api/vulkan/src/debugger/vulkan_debugger.h
index 8bed69f..4045a56 100644
--- a/rendering_api/vulkan/src/debugger/vulkan_debugger.h
+++ b/rendering_api/vulkan/src/debugger/vulkan_debugger.h
@@ -6,10 +6,4 @@ typedef struct gnPlatformDebugger_t {
     VkDebugUtilsMessengerEXT debugMessenger;
 } gnPlatformDebugger;
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-void populateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT* createInfo);
-#ifdef __cplusplus
-}
-#endif
+void vkPopulateDebugMessengerCreateInfo(VkDebugUtilsMessengerCreateInfoEXT* createInfo);
diff --git a/rendering_api/vulkan/src/instance/vulkan_instance.c b/rendering_api/vulkan/src/instance/vulkan_instance.c
index 26c2b3f..d79a06c 100644
--- a/rendering_api/vulkan/src/instance/vulkan_instance.c
+++ b/rendering_api/vulkan/src/instance/vulkan_instance.c
@@ -2,6 +2,11 @@
 #include <debugger/vulkan_debugger.h>
 #include <stdio.h>
 
+typedef struct vkUserData {
+    gnDebuggerCallback debuggerCallback;
+    void* userData;
+} vkUserData;
+
 static VKAPI_ATTR VkBool32 VKAPI_CALL vk_debuggerDebugCallback(
     VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity,
     VkDebugUtilsMessageTypeFlagsEXT messageType,
@@ -29,27 +34,11 @@ static VKAPI_ATTR VkBool32 VKAPI_CALL vk_debuggerDebugCallback(
     case VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT: type = GN_DEBUG_MESSAGE_PERFORMANCE; break;
     }
 
-    gnInstanceHandle instance = (gnInstanceHandle)pUserData;
-
-    if (instance->debugger) {
-        instance->debugger->info.callback(
-          severity, type, data, instance->debugger->info.userData
-        );
-    } else {
-        instance->instance->instanceMessageCount++;
-        if (instance->instance->instanceMessageCount == 1)
-            instance->instance->instanceMessages = malloc(sizeof(struct gnInstanceMessage) * instance->instance->instanceMessageCount);
-        else
-            instance->instance->instanceMessages = realloc(instance->instance->instanceMessages, sizeof(struct gnInstanceMessage) * instance->instance->instanceMessageCount);
-
-        instance->instance->instanceMessages[instance->instance->instanceMessageCount - 1] = (struct gnInstanceMessage){
-            .data = data,
-            .severity = severity,
-            .type = type
-        };
-    }
-
-    return VK_FALSE;
+    vkUserData* userData = (vkUserData*)pUserData;
+    gnDebuggerCallback callback = userData->debuggerCallback;
+    gnBool result = callback(severity, type, data, userData->userData);
+    if (result == gnFalse) return VK_FALSE;
+    return VK_TRUE;
 }
 
 gnReturnCode gnCreateInstanceFn(gnInstanceHandle instance, gnInstanceInfo instanceInfo) {
@@ -108,15 +97,26 @@ gnReturnCode gnCreateInstanceFn(gnInstanceHandle instance, gnInstanceInfo instan
 
     createInfo.flags = createFlags;
 
-    const char* validation_layers[1] = { "VK_LAYER_KHRONOS_validation" };
-    createInfo.enabledLayerCount = 1;
-    createInfo.ppEnabledLayerNames = validation_layers;
+    if (instanceInfo.debugger != NULL) {
+        for (int i = 0; i < instanceInfo.debugger->info.layerCount; i++) {
+            if (instanceInfo.debugger->info.layers[i] == GN_DEBUGGER_LAYER_PLATFORM) {
+                const char* validation_layers[1] = { "VK_LAYER_KHRONOS_validation" };
+                createInfo.enabledLayerCount = 1;
+                createInfo.ppEnabledLayerNames = (const char*[]){ "VK_LAYER_KHRONOS_validation" };
+            }
+        }
+
+        vkUserData* userData = malloc(sizeof(vkUserData));
+        userData->debuggerCallback = instanceInfo.debugger->info.callback;
+        userData->userData = instanceInfo.debugger->info.userData;
+
+        VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo = {};
+        vkPopulateDebugMessengerCreateInfo(&debugCreateInfo);
+        debugCreateInfo.pfnUserCallback = vk_debuggerDebugCallback;
+        debugCreateInfo.pUserData = userData;
+        createInfo.pNext = &debugCreateInfo;
+    }
 
-    VkDebugUtilsMessengerCreateInfoEXT debugCreateInfo = {};
-    populateDebugMessengerCreateInfo(&debugCreateInfo);
-    debugCreateInfo.pfnUserCallback = vk_debuggerDebugCallback;
-    debugCreateInfo.pUserData = instance;
-    createInfo.pNext = &debugCreateInfo;
 
     createInfo.enabledExtensionCount = extensionCount;
     createInfo.ppEnabledExtensionNames = extensions;
diff --git a/src/core/buffers/gryphn_buffer.c b/src/core/buffers/gryphn_buffer.c
index 31b454d..00b51c0 100644
--- a/src/core/buffers/gryphn_buffer.c
+++ b/src/core/buffers/gryphn_buffer.c
@@ -12,12 +12,7 @@ void gnBufferData(gnBufferHandle buffer, size_t dataSize, void* data) {
     buffer->device->deviceFunctions->_gnBufferData(buffer, dataSize, data);
 }
 void* gnMapBuffer(gnBufferHandle buffer) {
-    if (buffer->info.usage == GN_STATIC_DRAW) {
-        gnDebuggerSetErrorMessage(buffer->device->instance->debugger, (gnMessageData){
-           .message = gnCreateString("Cannot map static draw buffers")
-        });
-        return NULL;
-    }
+    if (buffer->info.usage == GN_STATIC_DRAW) return NULL;
     return buffer->device->deviceFunctions->_gnMapBuffer(buffer);
 }
 void gnDestroyBuffer(gnBufferHandle buffer) {
diff --git a/src/core/debugger/gryphn_debugger.c b/src/core/debugger/gryphn_debugger.c
index 233bb1d..6c38bae 100644
--- a/src/core/debugger/gryphn_debugger.c
+++ b/src/core/debugger/gryphn_debugger.c
@@ -1,11 +1,9 @@
 #include "gryphn_debugger.h"
 #include <core/gryphn_platform_functions.h>
 
-gnReturnCode gnCreateDebugger(gnDebuggerHandle* debugger, const struct gnDebuggerInfo_t info) {
+gnReturnCode gnCreateDebugger(gnDebuggerHandle* debugger, const gnDebuggerInfo info) {
     *debugger = malloc(sizeof(struct gnDebugger_t));
     (*debugger)->info = info;
     return GN_SUCCESS;
 }
-void gnDestroyDebugger(gnDebuggerHandle debugger) {
-    // free(debugger);
-}
+void gnDestroyDebugger(gnDebuggerHandle debugger) {}
diff --git a/src/core/debugger/gryphn_debugger.h b/src/core/debugger/gryphn_debugger.h
index 7d5329b..cb16461 100644
--- a/src/core/debugger/gryphn_debugger.h
+++ b/src/core/debugger/gryphn_debugger.h
@@ -1,4 +1,5 @@
 #pragma once
+#include "stdint.h"
 #include "utils/gryphn_string.h"
 #include "utils/gryphn_error_code.h"
 #include "core/gryphn_handles.h"
@@ -7,29 +8,18 @@ struct gnPlatformDebugger_t;
 
 typedef enum gnMessageSeverity_e {
     GN_MESSAGE_VERBOSE = 0x00000001,
-    GN_MESSAGE_INFO = 0x00000010,
-    GN_MESSAGE_WARNING = 0x00000100,
-    GN_MESSAGE_ERROR = 0x00001000,
+    GN_MESSAGE_INFO = 0x00000002,
+    GN_MESSAGE_WARNING = 0x00000004,
+    GN_MESSAGE_ERROR = 0x00000008,
 } gnMessageSeverity;
 
 typedef enum gnMessageType_e {
     GN_DEBUG_MESSAGE_GENERAL = 0x00000001,
     GN_DEBUG_MESSAGE_VALIDATION = 0x00000002,
     GN_DEBUG_MESSAGE_PERFORMANCE = 0x00000004,
-    // GN_DEBUG_MESSAGE_ADDRESS_BINDING = 0x00000008, vulkan had this but imma leave it out
 } gnMessageType;
 
 typedef struct gnMessageData {
-    // const char*                                  pMessageIdName;
-    // int32_t                                      messageIdNumber;
-    // uint32_t                                     queueLabelCount;
-    // const VkDebugUtilsLabelEXT*                  pQueueLabels;
-    // uint32_t                                     cmdBufLabelCount;
-    // const VkDebugUtilsLabelEXT*                  pCmdBufLabels;
-    // uint32_t                                     objectCount;
-    // const VkDebugUtilsObjectNameInfoEXT*         pObjects;
-    //
-    // If i ever figure out what this shit does il add it
     gnString message;
 } gnMessageData;
 
@@ -39,20 +29,26 @@ typedef gnBool (*gnDebuggerCallback)(
     gnMessageData     messageData,
     void*             userData);
 
-typedef struct gnDebuggerInfo_t {
+typedef enum gnDebuggerLayer {
+    GN_DEBUGGER_LAYER_PLATFORM // enable platform (vulkan validation) layers
+} gnDebuggerLayer;
+
+typedef struct gnDebuggerInfo {
     gnDebuggerCallback callback;
     void* userData;
+
+    uint32_t layerCount;
+    gnDebuggerLayer* layers;
 } gnDebuggerInfo;
 
 #ifdef GN_REVEAL_IMPL
+
 struct gnDebugger_t {
-    struct gnPlatformDebugger_t* debugger;
-    struct gnDebuggerInfo_t info;
-    gnInstanceHandle instance;
+    gnDebuggerInfo info;
 };
 #endif
 
-gnReturnCode gnCreateDebugger(gnDebuggerHandle* debugger, const struct gnDebuggerInfo_t info);
+gnReturnCode gnCreateDebugger(gnDebuggerHandle* debugger, const gnDebuggerInfo info);
 void gnDestroyDebugger(gnDebuggerHandle debugger);
 
 #ifdef GN_REVEAL_IMPL
diff --git a/src/core/gryphn_platform_functions.h b/src/core/gryphn_platform_functions.h
index 0c149f8..cb0dbbf 100644
--- a/src/core/gryphn_platform_functions.h
+++ b/src/core/gryphn_platform_functions.h
@@ -2,7 +2,7 @@
 // theoretically you could have multible gryphn instances running in one application,
 // why I dont know
 #include "instance/gryphn_instance.h"
-#include "debugger/gryphn_debugger.h"
+// #include "debugger/gryphn_debugger.h"
 #include "output_device/gryphn_physical_output_device.h"
 #include "output_device/gryphn_output_device.h"
 #include "window_surface/gryphn_surface.h"
@@ -24,13 +24,9 @@ typedef struct gnFunctions_t {
     gnReturnCode (*_gnCreateInstance)(gnInstanceHandle instance, gnInstanceInfo info);
     void (*_gnDestroyInstance)(gnInstanceHandle instance);
 
-    gnReturnCode (*_gnCreateDebugger)(gnDebuggerHandle debugger, gnInstanceHandle instance, const gnDebuggerInfo info);
-    void (*_gnDestroyDebugger)(gnDebuggerHandle debugger);
-
     gnPhysicalDevice* (*_gnGetPhysicalDevices)(gnInstanceHandle instance, uint32_t* count);
     gnBool (*_gnQueueCanPresentToSurface)(const gnPhysicalDevice device, uint32_t queueIndex, const gnWindowSurfaceHandle windowSurface);
 
-
     gnReturnCode (*_gnCreateOutputDevoce)(gnOutputDeviceHandle device, gnInstanceHandle instance, struct gnOutputDeviceInfo_t deviceInfo);
     void (*_gnDestroyOutputDevice)(gnOutputDeviceHandle device);
 
diff --git a/src/core/instance/gryphn_instance.c b/src/core/instance/gryphn_instance.c
index 4e64af5..bb7bed3 100644
--- a/src/core/instance/gryphn_instance.c
+++ b/src/core/instance/gryphn_instance.c
@@ -1,7 +1,6 @@
 #include "gryphn_instance.h"
 #include "init/gryphn_init.h"
 #include <core/gryphn_platform_functions.h>
-#include "core/debugger/gryphn_debugger.h"
 #include "core/instance/gryphn_instance.h"
 #include "stdio.h"
 
@@ -18,30 +17,11 @@ gnReturnCode gnCreateInstance(gnInstanceHandle* instanceHandlePtr, struct gnInst
     instance->functions = malloc(sizeof(struct gnFunctions_t));
     instance->loadCommandFunctions = gnFalse;
     instance->loadDeviceFunctions = gnFalse;
+    instance->debugger = info.debugger;
     gnLoadFunctions(instance->dynamicLib, instance->functions);
     return instance->functions->_gnCreateInstance(instance, info);
 }
-void gnInstanceAttachDebugger(gnInstanceHandle instance, struct gnDebugger_t *debugger) {
-    if (instance->debugger != NULL) {
-        gnDebuggerSetErrorMessage(debugger, (gnMessageData){
-            .message = gnCreateString("Debugger already attached to instance")
-        });
-    }
-    instance->debugger = debugger;
-    debugger->instance = instance;
-    gnReturnCode debuggerInfo = instance->functions->_gnCreateDebugger(debugger, instance, debugger->info);
-    if (debuggerInfo != GN_SUCCESS) {
-        gnDebuggerSetErrorMessage(debugger, (gnMessageData){
-            .message = gnCreateString("Failed to attach debugger to instance")
-        });
-    }
-}
 
 void gnDestroyInstance(gnInstanceHandle instance) {
-    if (instance->debugger) instance->functions->_gnDestroyDebugger(instance->debugger);
     instance->functions->_gnDestroyInstance(instance);
 }
-
-void gnInstanceReleaseDebugger(gnInstanceHandle instance) {
-    instance->debugger = NULL;
-}
diff --git a/src/core/instance/gryphn_instance.h b/src/core/instance/gryphn_instance.h
index 3efddc8..74bc38f 100644
--- a/src/core/instance/gryphn_instance.h
+++ b/src/core/instance/gryphn_instance.h
@@ -15,6 +15,7 @@ typedef struct gnInstanceInfo_t {
     gnVersion engineVersion;
 
     gnRenderingAPI renderingAPI;
+    gnDebuggerHandle debugger;
 } gnInstanceInfo;
 
 #ifdef GN_REVEAL_IMPL
@@ -35,6 +36,4 @@ struct gnInstance_t {
 #endif
 
 gnReturnCode gnCreateInstance(gnInstanceHandle* instance, struct gnInstanceInfo_t info);
-void gnInstanceAttachDebugger(gnInstanceHandle istance, gnDebuggerHandle debugger);
-void gnInstanceReleaseDebugger(gnInstanceHandle instance);
 void gnDestroyInstance(gnInstanceHandle instance);
diff --git a/src/core/instance/init/gryphn_init.c b/src/core/instance/init/gryphn_init.c
index 7ea9dcc..ab1f974 100644
--- a/src/core/instance/init/gryphn_init.c
+++ b/src/core/instance/init/gryphn_init.c
@@ -40,8 +40,8 @@ struct gnDynamicLibrary_t* gnLoadRenderingDLL(gnRenderingAPI renderingAPI) {
 void gnLoadFunctions(struct gnDynamicLibrary_t* lib, struct gnFunctions_t* functions) {
     gnLoadDLLFunction(lib, functions->_gnCreateInstance, "gnCreateInstanceFn");
     gnLoadDLLFunction(lib, functions->_gnDestroyInstance, "gnDestroyInstanceFn");
-    gnLoadDLLFunction(lib, functions->_gnCreateDebugger, "gnCreateDebuggerFn");
-    gnLoadDLLFunction(lib, functions->_gnDestroyDebugger, "gnDestroyDebuggerFn");
+    // gnLoadDLLFunction(lib, functions->_gnCreateDebugger, "gnCreateDebuggerFn");
+    // gnLoadDLLFunction(lib, functions->_gnDestroyDebugger, "gnDestroyDebuggerFn");
     gnLoadDLLFunction(lib, functions->_gnGetPhysicalDevices, "gnGetPhysicalDevicesFn");
     gnLoadDLLFunction(lib, functions->_gnQueueCanPresentToSurface, "gnQueueCanPresentToSurfaceFn");
     gnLoadDLLFunction(lib, functions->_gnCreateOutputDevoce, "gnCreateOutputDeviceFn");
diff --git a/src/core/output_device/gryphn_physical_output_device.c b/src/core/output_device/gryphn_physical_output_device.c
index 10a287a..d895f8d 100644
--- a/src/core/output_device/gryphn_physical_output_device.c
+++ b/src/core/output_device/gryphn_physical_output_device.c
@@ -1,6 +1,5 @@
 #include "gryphn_physical_output_device.h"
 #include "core/gryphn_platform_functions.h"
-#include "stdio.h"
 
 gnPhysicalDevice* gnGetPhyscialDevices(gnInstanceHandle instance, uint32_t* count) {
     gnPhysicalDevice* devices = instance->functions->_gnGetPhysicalDevices(instance, count);
@@ -11,14 +10,14 @@ gnPhysicalDevice* gnGetPhyscialDevices(gnInstanceHandle instance, uint32_t* coun
 }
 
 gnBool gnQueueCanPresentToSurface(const struct gnPhysicalDevice_t device, uint32_t queueIndex, gnWindowSurfaceHandle windowSurface) {
-    if (queueIndex >= device.queueProperties.queueCount) {
-        gnDebuggerSetErrorMessage(device.instance->debugger,
-            (gnMessageData){
-                .message = gnCreateString("gnQueueCanPresentToSurface queue index passed in is large then queueProperties.queueCount")
-            }
-        );
-        return gnFalse;
-    }
+    // if (queueIndex >= device.queueProperties.queueCount) {
+    //     gnDebuggerSetErrorMessage(device.instance->debugger,
+    //         (gnMessageData){
+    //             .message = gnCreateString("gnQueueCanPresentToSurface queue index passed in is large then queueProperties.queueCount")
+    //         }
+    //     );
+    //     return gnFalse;
+    // }
     return device.instance->functions->_gnQueueCanPresentToSurface(device, queueIndex, windowSurface);
 }
 
@@ -46,11 +45,11 @@ int gnGetGraphicsQueueIndex(const struct gnPhysicalDevice_t device) {
             break;
         }
     }
-    gnDebuggerSetErrorMessage(device.instance->debugger,
-        (gnMessageData){
-            .message = gnCreateString("gnGetGraphicsQueueIndex failed no queue that support graphics on this device")
-        }
-    );
+    // gnDebuggerSetErrorMessage(device.instance->debugger,
+    //     (gnMessageData){
+    //         .message = gnCreateString("gnGetGraphicsQueueIndex failed no queue that support graphics on this device")
+    //     }
+    // );
     return -1;
 }
 int gnGetPresentQueueIndex(const struct gnPhysicalDevice_t device, gnWindowSurfaceHandle windowSurface) {
@@ -60,10 +59,10 @@ int gnGetPresentQueueIndex(const struct gnPhysicalDevice_t device, gnWindowSurfa
             break;
         }
     }
-    gnDebuggerSetErrorMessage(device.instance->debugger,
-        (gnMessageData){
-            .message = gnCreateString("gnGetPresentQueueIndex failed no queue that support presenting to this window surface")
-        }
-    );
+    // gnDebuggerSetErrorMessage(device.instance->debugger,
+    //     (gnMessageData){
+    //         .message = gnCreateString("gnGetPresentQueueIndex failed no queue that support presenting to this window surface")
+    //     }
+    // );
     return -1;
 }
diff --git a/src/utils b/src/utils
index 5b05fb2..c5049bd 160000
--- a/src/utils
+++ b/src/utils
@@ -1 +1 @@
-Subproject commit 5b05fb287d4766420f8517c3352742922959ffdf
+Subproject commit c5049bda3d13e63d401748bacc25fe72f4456755