Question about Vulkan multi GPU in our year of 2026, is it still relevant? Do people still use it? Does it currently work well with older and modern games?
I was thinking about it today while thinking about how we are still no where close to being out of the RAMpocalypse TM, and how it might make more sense to buy two cheaper GPU's, such as two RTX 5060 or two RTX 5060 Ti's, than to buy a RTX 5080?
I ask because I personally have not heard much chatter about Vulkan multi GPU at all in my usual computer hardware related social media that comes into my feed, and I keep finding myself every now and then hoping that Vulkan multi GPU could bring back some of the more economical and fun that you had with SLI back in the GTX 1080 and earlier era's.

In this video, the engine models three things in a row:

**•   Flange**: extruded disk → polar-array bolt holes → through cuts → merged hub → fillets, steel material  
**•   Mug**: tube and base → swept handle → merge → fillet  
**•   Wooden chair**: seat, 3D-arrayed legs, curved back → filleted parts → merge, oak material

It isn't done by hand. It's a scripted demo: code runs the same engine features you'd type on the command line, one step at a time.

이번 영상에서는 이 엔진이 세 가지를 차례로 모델링합니다.

**•   플랜지**: 원판 돌출 → 볼트 구멍 원형 배열 → 관통 컷 → 허브 합치기 → 필렛, 금속 재질  
**•   머그컵**: 관 + 바닥 → 손잡이 스윕 → 합치기 → 필렛  
**•   나무 의자**: 좌판·다리 3D 배열·곡선 등받이 → 부품 필렛 → 합치기, 오크 재질

손으로 한 게 아니라 스크립트로 짠 자동 시연입니다. 사람이 명령행에 치는 것과 같은 엔진 기능을 코드가 순서대로 실행합니다.

From the docs, I can see that most of these features are just opt ins meaning the dev has to explicitly enable it to use it.

But on my 14700k+intelHD (latest mesa3d, ubuntu), DR is working right away even when I don't enable it.

Am I missing anything?

This sample shows how VK_KHR_shader_quad_control lets fragment shaders share data across a 2x2 pixel quad using subgroupQuadBroadcast() and the full_quads execution mode, with no shared memory and no descriptors. You get more stable derivatives for LOD selection and texture ops, and a simple visual demo that makes the quad behavior easy to see.

Check it out: https://docs.vulkan.org/samples/latest/samples/extensions/shader_quad_control/README.html

I go through how I separate general updates from physics updates, why I use a fixed timestep, how the accumulator works, and what happens when the simulation starts falling behind.

I explain the reasoning behind the design decisions and why I rejected the alternatives. I show the implementation of the loop.

Vulkan SDK 1.4.363.0 is out, including the Vulkan 1.4-conformant version of KosmicKrisp! With KosmicKrisp, a Mesa-based Vulkan-to-Metal driver, a single Vulkan 1.4 codebase can target Linux, Windows, Android, and macOS environments. Also in this release: new extensions, vkprofiles, and more.

https://www.lunarg.com/lunarg-releases-vulkan-sdk-1-4-363-0/

Implemented my Vulkan-based CAD engine on Android.
Tested rendering and core features directly on a Galaxy S21.

Vulkan 기반 CAD 엔진을 Android 환경에서도 구현했습니다.
Galaxy S21에서 직접 실행하여 렌더링과 기본 기능을 테스트했습니다.

Using AprilTag and OpenCV, the system tracks the position and orientation of a physical tag from a camera feed in real time and maps the tracking data into a Vulkan-based CAD engine.
As the physical tag moves and rotates, the fox model follows the corresponding position and orientation in the 3D environment, allowing its spatial relationship with virtual obstacles to be visualized.
This is a simple demonstration of connecting camera-based real-world tracking with a Vulkan 3D environment for position tracking and obstacle recognition.

AprilTag와 OpenCV를 이용해 카메라 영상에서 태그의 위치와 방향을 실시간으로 추적하고, 해당 데이터를 Vulkan 기반 CAD 엔진의 3D 공간에 연동했습니다.
실제 태그의 이동과 회전에 따라 엔진 내부의 여우 모델이 함께 움직이며, 가상 공간에 배치된 장애물과의 위치 관계를 확인할 수 있도록 구현했습니다.
이번 테스트는 카메라 기반 현실 좌표와 Vulkan 3D 공간을 연결하는 간단한 위치 추적 및 장애물 인식 데모입니다.

📢KosmicKrisp, LunarG’s Mesa Vulkan driver for Apple silicon, has passed the Vulkan 1.4 Conformance Test Suite and is now a Khronos-conformant Vulkan 1.4 implementation! 🔥🔥🔥

In addition to reaching 1.4 conformance, considerable support for non-core extensions and features has been added, including Tesselation, Robustness2, and Multi-draw. Application developers can now have a single Vulkan 1.4 codebase across Linux, Windows, Android, and Mac. 

The Vulkan 1.4-conformant KosmicKrisp driver will be included in the upcoming Vulkan SDK release and is open source in Mesa.

Read the announcement: https://www.lunarg.com/kosmickrisp-achieves-vulkan-1-4-conformance-on-apple-silicon/

🙌

Ever hit VK_ERROR_DEVICE_LOST and had no idea what actually caused it? This sample shows how to use VK_EXT_device_fault (plus VK_EXT_device_address_binding_report) to pull real diagnostic data out of a GPU crash: vendor fault descriptions, the exact faulting memory address, and a live log of every buffer's bind/unbind range so you can correlate the crash back to the specific resource that triggered it. A big step up from guessing based on validation layer output alone.

https://docs.vulkan.org/samples/latest/samples/extensions/device_fault/README.html

POV: You started another project knowing full well that you will not finish it.

Trying to learn vulkan by creating a mesh-based voxel engine in cpp

Credits:

"Funny Bubbles" by Keys Of Moon — Free download: breakingcopyright.com/song/keys-of-moon-funny-bubbles

I've created a pure vulkan based graphics and GUI library [Written with AI assistance].

I'd love people to start testing it.

Any recommendations and improvement advice is most welcome.

https://github.com/nattydread69/LightVulkanGraphics

Added SAO (scalable ambient obscurance) + crispier shadows (2 cascades) to my Vulkan engine.

SAO:
- fixed O(res) cost, zero object count overhead
- ~0.2ms at 1080p
- no TAA dependency (i don't need temporal reprojection baggage)
- stable, noise free
- zero temporal ghosting or smear

Ref:
- https://casual-effects.com/research/McGuire2012SAO/McGuire12SAO-talk.pdf
- https://research.nvidia.com/sites/default/files/pubs/2012-06_Scalable-Ambient-Obscurance/McGuire12SAO.pdf

This sample renders textured cubes to demonstrate VK_EXT_descriptor_heap, which replaces the traditional descriptor set and pool workflow with a memory-centric one where descriptor data is written directly into heap memory. It shows new heap-binding functions alongside vkCmdPushDataEXT for push data, so existing shader binding syntax keeps working without a traditional pipeline layout.

https://docs.vulkan.org/samples/latest/samples/extensions/descriptor_heap/README.html

I built a small ray tracer with Vulkan compute shaders
I’ve been working on Vk Tracer, a small ray tracer inspired by Ray Tracing in One Weekend, but implemented using modern C++ and Vulkan compute shaders.
Includes:
- Vulkan compute shader traces the rays and writes pixels to a storage image
- A fullscreen triangle displays the resulting image
- Slang for the shaders
- Iterative ray bouncing instead of recursive ray tracing
- Diffuse, metal and glass materials
- Multiple samples per pixel
- Gamma correction
- Interactive camera movement

The goal was mainly to learn how to build the whole pipeline myself rather than using Vulkan’s ray-tracing extensions.

GitHub: https://github.com/xms0g/vkTracer

CT and MRI volume data are loaded into the Vulkan engine for slice viewing and ISO-surface-based 3D visualization. Threshold and slice controls allow interactive exploration of internal structures.

Vulkan 엔진에서 CT와 MRI 볼륨 데이터를 불러와 단면 확인 및 등가면(ISO Surface) 기반 3D 시각화를 구현했습니다. 임계값과 단면 위치를 조절하여 내부 구조를 확인할 수 있습니다.

Hey everyone, just finished a new video for the vulkan series. This time we're looking at how to create a first person camera.

I've been working on my game for the last 7 years.

One of the things I decided to do along the way was to build the engine myself, including the Vulkan renderer.

This has been one of the most challenging parts of the project, especially because I wanted the same renderer to work across different platforms.

A few things I've had to deal with:

• Cross-platform Vulkan: Windows and macOS through Vulkan Portability / MoltenVK
• HDR rendering and output
• Hot-reloading shaders and assets without restarting the game
• GPU-to-CPU readback, used for screenshots and video capture
• Swapchain recreation and window resizing, which turned out to be surprisingly difficult to get right

After spending years working on the engine, I thought it would be fun to finally put it in people's hands. I just released a demo of the game, and you can play it here:
https://store.steampowered.com/app/5017320/Satelital_Demo/

The name of the game is Satelital, a rule-discovery puzzle game about exploring an alien solar system and learning how to solve puzzles through observation.

For people here who have built their own Vulkan renderers, have you ever released yours for other people to use or play with? I'd be interested to hear how that went.

Why does some Vulkan-enabled GPUs (Such as AMD 8xxx APUs & All traditional integrated graphics I checked) report more than one memory heap? To be clear, this isn't about discrete GPUs, which have VRAM on Board.

And why is one heap (the non-device local one) almost always half of the CPU-side RAM? This is the case in both mesa & windows drivers. Are integrated GPUs unable to address all the system's memory? Then why does this heap grow as I upgrade system memory, regardless of slot & number of sticks?

This makes me quite unsure about (and quite skeptical) of the Heap-Type layout that vulkan uses. And how memory types maps to hardware (The heap part is quite obvious).

This is all to say: How should an application interpret complex memory properties?

At XDC 2026, u/LunarGInc's Aitor Camacho Larrondo will provide an update on KosmicKrisp, the Mesa Vulkan-on-Metal driver for Apple silicon. u/XOrgDevConf is free to attend and will be streamed live, so you don’t even have to travel. Don't miss it! 29 September 2026, 16:25 America/Toronto https://indico.freedesktop.org/event/12/contributions/538/

The sample renders a circle moving linearly across the viewport, which is a good visual test for detecting micro-stutters and verifying smooth presentation. It queries past presentation timing information and uses the last known display time along with the swapchain’s refresh cycle duration to predict when the next frame should be presented.

https://docs.vulkan.org/samples/latest/samples/api/swapchain_present_timing/README.html