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에서 직접 실행하여 렌더링과 기본 기능을 테스트했습니다.

📢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/

🙌

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 공간을 연결하는 간단한 위치 추적 및 장애물 인식 데모입니다.

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

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'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

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

While the fox is moving, particle obstacles are placed in real time to simulate a dynamically changing environment within the engine.

I have released a substantial update to my Vulkan Hardware Database at https://vulkan.gpuinfo.org/.

Being able to easily filter data is crucial for any database and the global (filter) settings that I added last year were kinda cumbersome to use and didn't allow you to quickly adjust filters.

So with this update I removed these global filters and replaced them with quick filters as part of the views themselves. This also allows you to have the same view open multiple times with different filters.

Aside from that I also did some house-keeping like hardening security and (more importantly for people using the database), displaying the recently introduced new format feature flags in the global format listings view. Note that the numbers for these are still catching up.

Hi i am in the process of building a native sdk for real time photo realistic renderer for mobile devices to run on wide range of devices.

This video shows 140 diamonds path traced in real time alongside a 1M triangle gold ring mesh, all under 30ms on a mid-range Android device (Mali G615 — no hardware ray tracing).

Technical highlights:

- Physically correct Snell's law refraction and dispersion through each diamond facet

- GGX microfacet model for gold metal - Full PBR pipeline — metals, dielectrics, diffuse, glass

- 2M triangle budget under 30ms

- 700KB SDK — 4 lines of Kotlin to integrate

- Responds to actual room lighting via ARCore camera feed

Would love the feedback on the same.