void simple_init_test()
{
    import erupted;
    import bindbc.sdl : SDL_Window, SDL_Vulkan_GetInstanceExtensions, SDL_Vulkan_CreateSurface;

    enforce ( loadSDL() == sdlSupport, "Failed to Load sdlStatus");
    enforce ( SDL_Init(SDL_INIT_VIDEO) >= 0,  "SDL init failed" );

    import erupted.vulkan_lib_loader;
    loadGlobalLevelFunctions();

    uint layercount;
    SDL_Vulkan_LoadLibrary(null);
    auto window = SDL_CreateWindow("subterrainian", SDL_WINDOWPOS_UNDEFINED,
        SDL_WINDOWPOS_UNDEFINED, 400, 300, SDL_WINDOW_VULKAN | SDL_WINDOW_SHOWN);

    VkInstance instance = VK_NULL_HANDLE;
    VkApplicationInfo app_info = {};
    app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
    app_info.apiVersion = VK_API_VERSION_1_3;
    app_info.pApplicationName = "test-app";
    app_info.applicationVersion = VK_MAKE_API_VERSION(1,0,0,0);
    app_info.pEngineName = "test-engine";
    app_info.engineVersion = VK_MAKE_API_VERSION(1,0,0,0);

    VkInstanceCreateInfo instance_info = {};
    instance_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
    instance_info.pApplicationInfo = &app_info;
    instance_info.enabledLayerCount = 0;
    instance_info.ppEnabledLayerNames = null;

    uint count = 0;

    SDL_Vulkan_GetInstanceExtensions(window,&count, null);
    import core.stdc.stdlib : malloc, free;
    const(char) ** extensions = cast(const(char)**) malloc((char*).sizeof * count);
    SDL_Vulkan_GetInstanceExtensions(window,&count, extensions);
    instance_info.enabledExtensionCount = count;
    instance_info.ppEnabledExtensionNames = extensions;
    VkResult result = vkCreateInstance(&instance_info,null,&instance);
    enforce(result == VK_SUCCESS, "failed to create instance");
    loadInstanceLevelFunctions(instance);

    VkSurfaceKHR surface = VK_NULL_HANDLE;
    SDL_Vulkan_CreateSurface (window, instance, &surface);
    enforce(surface != null, "failed to create surface");
    uint n;
    vkEnumeratePhysicalDevices(instance,&n,null);
    VkPhysicalDevice * devices = cast(VkPhysicalDevice*) malloc((VkPhysicalDevice*).sizeof*n);
    vkEnumeratePhysicalDevices(instance,&n, devices);

    VkPhysicalDevice physicalDevice = devices[0];
    float[1] priorities  = [0];

    VkDeviceQueueCreateInfo queueCreateInfo = {};
    queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
    queueCreateInfo.queueFamilyIndex = 0;
    queueCreateInfo.queueCount = 1;
    queueCreateInfo.pQueuePriorities = priorities.ptr;
    queueCreateInfo.pNext = null;

    VkPhysicalDeviceFeatures deviceFeatures;

    VkDeviceCreateInfo createInfo = {};
    createInfo.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
    createInfo.pNext = null;
    createInfo.pQueueCreateInfos = &queueCreateInfo;
    createInfo.queueCreateInfoCount = 1;
    createInfo.pEnabledFeatures = &deviceFeatures;
    VkDevice device;
    vkCreateDevice(physicalDevice,&createInfo,null,&device);
    VkQueue graphicsQueue;
    vkGetDeviceQueue(device,0,0,&graphicsQueue);

    while (!SDL_QuitRequested())
    {

    }

    SDL_DestroyWindow(window);
    SDL_Quit();

    return;

}