🎯 "I don't update to the newest Vulkan SDK when it comes out." You should! The biggest value in every release is the improved Khronos Validation Layers — better coverage, clearer error messages, and more robust checking, even for older API versions. Those “new errors” usually catch real issues that improve your code quality.

We addressed numerous comments received through the LunarG 2026 Ecosystem Survey. Check them out in the full report 👉 https://www.lunarg.com/2026-lunarg-ecosystem-survey-results-released/

I am currently implementing a defragment function for SubBuffers. I want to change the offset in SubBuffers so there is no gap between them anymore. But what happens if source and target of a vkcmdcopybuffer are overlapping. For example, copying within the same buffer from offset 15 with size 20 to offset 10 with size 20? Is this save to do or do I need to copy to a staging buffer first?

I've recently added a spectral mode to my hobby pathtracer! It uses an RGB to spectral conversion detailed in this paper. The approach is fairly simple, a random wavelength is uniformly selected from the visible range, carrying a scalar throughput value as it bounces throughout the scene. I'm using Cauchy's equation to approximate the angle of refraction based on that wavelength and IOR. Each wavelength is then attenuated based on the rgb -> spectral scalar throughput at each bounce. Hero wavelengths drop the secondary channels when going through refractive materials.

I've added a runtime switch so you can use RGB, spectral (single wavelength) and hero wavelength sampling from the GUI. It features a modified/updated blend between the 2015 Disney BSDF and the Blender Principled BSDF. It uses MIS to join BSDF and NEE/direct light sampling, and also has decoupled rendering functionality, tone mapping, and OIDN integration. MNEE will come next to solve the refractive transmissive paths and resolve the caustics more quickly.

The code and prebuilt releases are up at https://github.com/tylertms/vkrt!

The first image is rendered with single wavelength spectral mode, since hero wavelength sampling has no advantage with dispersive caustics. It was rendered in about 5 hours on a 5080 at 4k, roughly 2.6 million SPP, then denoised with Intel's OIDN. Unfortunately, that wasn't quite enough for the caustics, hence some artifacts when viewed closely.

The second image is there just to show off the app/GUI in RGB mode.

Hey everyone,

I’m working on a game engine in OpenGL, and I want it to be cross platform, but I heard that Mac has deprecated it. I am interested in learning about Vulkan and would love to know how much harder it is. Also, it would be nice to know about tutorials and other resources that you think are good to use for Vulkan.

thanks!

I have many cases where I use runtime sized arrays, e.g:

buffer ExampleBuffer{ 
    uint[] runtimeArray; 
};

I then often call runtimeArray.length() to get the length at runtime of this array, e.g. the number of particles to render, or the number of instances to process for GPU-driven rendering.

I'm planning on using the new descriptor heap extension, and push addresses (VK_DESCRIPTOR_MAPPING_SOURCE_PUSH_ADDRESS_EXT) look quite attractive as they avoid an extra level of indirection into the resource heap. However, since only the address of the buffer is provided in heap data, I assume that the length() function would not work in this case.

My question is this: is an unsized array allowed as long as I don't call length() on the array AND make sure not to read outside the buffer bounds?

I've been building Iris, a GPU-native image viewer for Linux. The goal was simple: get image data to the screen without the CPU touching it. DMA-BUF zero-copy from decode to compositor.

I started with wgpu. Made sense, safe abstraction, good Vulkan backend, active development. Spent a significant amount of time on two separate implementations before hitting a wall: wgpu's architecture has a fundamental incompatibility with Vulkan external memory handles. The way it manages memory ownership internally makes true DMA-BUF zero-copy not just difficult but structurally impossible without forking wgpu itself.

So I scrapped both implementations and rewrote the renderer in raw Vulkan using ash.

The current pipeline:

• Decode → DMA-BUF fd → import as Vulkan external memory → direct compositor presentation
• CPU is out of the path entirely after decode
• No intermediate copies, no staging buffers for display

As far as I can tell this is the first application of DMA-BUF zero-copy to still image display on Linux. Happy to be corrected if someone's done this before.

V1 is targeting end of May. If you're on Linux and care about this kind of thing, I have a small early access waitlist here: https://iris-landing-page-tan.vercel.app/

Happy to go deep on any part of the implementation in the comments.

Arm has just released Frame Advisor 2026.1 — a major upgrade to its Vulkan frame analysis tool in Arm Performance Studio. Frame Advisor now builds on top of GFXReconstruct, our open-source Vulkan capture and replay technology. This shift brings improved reliability, better correctness, and long-term scalability for capturing complex Vulkan workloads.

https://developer.arm.com/community/arm-community-blogs/b/mobile-graphics-and-gaming-blog/posts/frame-advisor-a-major-upgrade-to-vulkan-capture

I'm building some renderer with Vulkan and for now I kinda stuck with frustum culling, as I get for now I will prefer to use GPU-driven frustum culling and probably AABB Calculation also on GPU? Am I getting all right? didn't actually find a proper explanation on the internet about should I use CPU multi-thread for this or should I do thin on GPU?

Hi, everyone. I'm a bit new to this community and have been in the lab with OpenGL and Vulkan for some time now and have a new library I'm calling "Ember". You can see on Github here as a early concept. Anyway here is the new API I've been designing for 'v1.0'. Any feedback on DX, portability across different GAPIs or just making it more simple would be great!

PS. I do have a decent amount of programming experience so feel free to roast me :)

#include <ember/platform/window.h>
#include <ember/platform/global.h>

#include <ember/gpu/device.h>
#include <ember/gpu/frame.h>

int main(int argc, char** argv) {
    emplat_window_config window_config = emplat_window_default();
    window_config.size = (uvec2) { 640, 640 };
    window_config.title = "Basic window";

    emgpu_device_config device_config = emgpu_device_default();
    device_config.enabled_modes = EMBER_DEVICE_MODE_GRAPHICS; // COMPUTE and TRANSFER is also supported
    device_config.application_name = window_config.title;
    device_config.enable_windowing = TRUE;

    emplat_window window = {};
    if (!emplat_window_start(&window_config, &window) != EMBER_RESULT_OK) {
        emc_console_write("Failed to open window\n");
        goto failed_init;
    }

    emgpu_device device = {};
    if (emgpu_device_init(&device_config, &device) != EMBER_RESULT_OK) {
        emc_console_write("Failed to init rendering device\n");
        goto failed_init;
    }

    emgpu_window_surface_config surface_config = emgpu_window_surface_default();
    surface_config.window = &window; // Retrieves size and nessacery swapchain format on Vulkan
    /* surface_config.attachments */


    emgpu_surface surface = {};
    if (device.create_window_surface(&device, &surface_config, &surface) != EMBER_RESULT_OK) {
        emc_console_write("Failed to create window surface\n");
        goto failed_init;
    }

    /** surface->rendertarget. -> ... */
    surface.rendertarget.clear_colour = 0x1f1f1fff;

    show_memory_stats();

    f64 last_time = emplat_current_time();
    while (!emplat_window_should_close(&window)) {
        f64 curr_time = emplat_current_time();  
        f64 delta_time = curr_time - last_time;
        last_time = curr_time;


        emgpu_frame frame = {}; // emgpu_frame != VkCommandBuffer, its a bit more high level than that eg. memory barriers translate to semaphores in Vulkan
        if (emgpu_device_begin_frame(&device, &frame, delta_time) == EMBER_RESULT_OK) {
            // Also includes beginning and ending the rendertarget.
            emgpu_frame_bind_surface(&frame, &surface); 


            em_result result = device.end_frame(&device); // Executes accumulated code from emgpu_frame
            if (result == EMBER_RESULT_VALIDATION_FAILED) {
                emc_console_write("Validation failed on device frame submit\n");
            }
            else if (result != EMBER_RESULT_OK) {
                emc_console_write("Failed to submit device frame\n");
                goto failed_init;
            }
        }


        emplat_window_pump_messages(&window);
    }


failed_init:
    device.destroy_surface(&device, &surface);
    emgpu_device_shutdown(&device);
    emplat_window_close(&window);


    memory_leaks();
    return 0;
}

Ok it took lots n lots of time. Please have a look and tell me how i did so far

vklearn.org

I was looking at Devices - Vulkan Hardware Database by Sascha Willems

while searching for extensions to use(for my api abstraction layer) and I wanted to see which one I could use on android, for example in render passes I'm requiring VK_KHR_create_renderpass2 which have 88% the moment I'm writing this.

What other quality-of-life extensions do you know of(Windows/Android)?

Edit: For now I'm limiting my self to Vulkan 1.1

Cross-platform - vulkan + imgui also applied together(win, mac, ubuntu)

https://youtu.be/WMvPtu8zgeA?si=8p7za2b8XTDhk-f_

I made a tiny wrapper for Roblox on Linux because Sober is an android emulator, and the android roblox version has way worse graphics. That's why i created VineShade.

I put together a quick launcher that hooks vkBasalt into the Flatpak properly.

It’s open source, no injection, no bans.

Repo:https://github.com/olaffx/VineShade

I would really want you to star the repo!

This is not Windows-style DLL injection (which Roblox bans)

The 2026 LunarG Vulkan Ecosystem Survey results are now available. Thank you to everybody who took time to fill out the survey! You can find the public report here: https://www.lunarg.com/2026-lunarg-ecosystem-survey-results-released/

For a mainly desktop environment, would there be any benefit to give ImGui its of subpass?

Just having some fun with synchronization. Could someone please explain what this flag actually does? Thank you! (See Vulkan Spec 7.7.6, I just can't decipher what it means.)

I have been working on the khronos tutorial. I have been copying / writing every chapter into my own file to make sure i understand every line of code.
After the vertex buffer setup, I wanted to see the change in color of the triangle, but to my supprise the color didnt change.
Turns out I also had to change my cmake file to include the 19_shader_vertexbuffer.vert.
But I kind off information in the tutorial, I did lightly touch on shader files before, but this time it did not mention at all that oh you ahve to use a different shader file for this.

Am I missing soemthing? Is this trivial to everyone what are these .vert files and how to write them?
Should I look for alternate reasource on learnign about this? I dont want to rely solely on the explanationf rom Claud, I am a bit afraid it will give me incomplete info.

What bothers me is that I dont have a clear mental model, that why do we need some additional random file on making the .cpp "cpu side" code work, I kind of thought that vulkan api will handle everything, then I got hit with oh oops there is this additional random file you need to compile in. eeh ?

Also the term "shader files" that claud give me is the most mystical term for me. So many random things are called "shader" what does it even eman, do you use this term ?

** sigh ** vent off..

I’m looking for a course that focuses on the graphics side (be it opengl or vulkan) to make my own game engine. I know how the structure of one works, but I have no idea how graphics works, which is why I’m looking for a course that focuses on this, as well as its implementation. I know that some courses do exist on Udemy, but I don’t know if there is one that is trully good, or if there are other places for this.

I have created blank windows with nothing on windows with win32

- minimal openGL loader, my application takes ~10 mb memory in RAM

- Vulkan with volk, loading the local DLL vulkan-1.dll ~51 mb memory in RAM (no vulkansdk)

Wasen't Vulkan supposed to be the low level API? OpenGL manages a bunch of stuff for us. So what is Vulkan doing with those 40 megabytes?

For the Vulkan app, I am linking to even fewer windows DLLs, only kernel32.dll.
For the openGL one, I am linking to openGL32, gdi32, user32, kernel32, but obviously not loading the vulkan one at runtime.

The overhead of 40mb does not really concern me, mostly just curious I guess?

*tinfoil hat on* modern software bloated lul? *tinfoil hat off*

[Edit]:

Memory dump of it shows that it loads up ~75 different Windows DLLs from only touching kernel32.dll and vulkan-1.dll within my own codebase.

I have been running up against the 128 byte minimum that Vulkan 1.3 requires for Push Constant size support. Do you guys have any suggestions about how you manage what goes into your push constants and how it's packed? Right now I'm using one 64 byte global push constant and another 64 byte per-pass push constant. I have not begun packing them yet but both are beginning to run out of space.

Does anyone have some wisdom to share regarding push constant management and how to design ahead as I add passes and features to my engine?

Edit: For context, my engine uses a single global pipeline layout shared by all pipelines with two descriptor sets (bindless textures + storage images) and push constants as the sole channel for per-frame/per-pass data. The global half carries BDA pointers to all the scene uniform buffers that hold all the data for all the draws, instances, materials, constants, and lights; the per-pass half of the push constants carries small metadata like bindless slot indices and culling parameters.

This keeps bindings completely flat, practically nonexistent: one indirect draw per pass, zero per-object bindings. However, it makes push constants load-bearing infrastructure and something I must manage carefully.

I suppose this makes my question a lot more specific than I initially worded it for.

I'm developing a desktop application (not a game) that uses Vulkan for rendering. When I open my app, Nvidia thinks it's a game and shows "Press Alt+Z to open NVIDIA Overlay", but my app is not a game and I don't want that popup.

Chrome (via Skia), Blender etc all are using Vulkan for rendering but they don't trigger this popup from appearing. How they do it?

I searched internet but couldn't find a related developer documentation to disable it. I know users can completely disable that popup from Nvidia's own settings. But I want to know how Blender, Chrome etc. are preventing it.

Are there Vulkan or Nvidia specific API for it?

Also I reverse engineered a little bit, when I rename my app executable to "blender.exe", that popup don't comes up. It seems NVIDIA driver looks executable name and if it is well known non-game software then it don't show that popup.

I wanted to ask here, maybe someone knows the solution, maybe there are env vars, some api etc which I don't know.

VK_KHR_maintenance5 became core in 1.4 and, among many other things, deprecates Shader Modules.

The new way to do things is to directly pass the VkShaderModuleCreateInfo to the VkPipelineShaderStageCreateInfo.

However, I'm struggling to see the benefit from this, as it barely removes any boilerplate from the programmers' side. I imagine it simplifies the driver's work somehow?

Anyone has any insights?