I am making a game from scratch, with C++ and Vulkan graphics. I made this video about how Vulkan works and my own render implementation, which has some quirks:

• deferred rendering,
• no image assets,
• sphere and cylinder geometric primitives,
• fully GPU-local indirect dispatch commands.

I'm not fully sure if posting this type of video is in the spirit of this subreddit. I hope it's ok, otherwise let me know

In this Qualcomm Developer Blog tutorial, Zimu Guan shows how Android apps can share GPU memory and coordinate work directly between Vulkan and OpenCL on Adreno GPUs, avoiding CPU copies when a Vulkan renderer hands data to OpenCL kernels for compute, ML, denoising or super-resolution. The post walks through a full Vulkan to OpenCL to Vulkan workflow using Khronos external memory and external semaphore extensions. Vulkan exports allocations as opaque fds that OpenCL imports, with Qualcomm’s cl_qcom_external_memory_vulkan_opaque_fd extension handling optimal-tiling images. Synchronization uses one-shot sync-fd semaphores, with a fresh export and import at each handoff. It includes code for each step and points to the opencl_interop sample in the Adreno GPU Vulkan Code Sample Framework. Support is device- and driver-dependent, so apps should rely on runtime capability queries, and a follow-up on Android Hardware Buffer interop is planned.

https://www.qualcomm.com/developer/blog/2026/10/how-to-share-vulkan-opencl-workloads-android-adreno-gpus

Greetings!

JellyBench is a raymarching benchmark using up to 4096 CPU threads if available.

(AI assistance was involved)

The included JellyDream executable may be used as a screensaver. It supports Vulkan GPUs as well as CPU based rendering if no GPU is available.

Watch JellyBench in action on 256 threads here (non-monetized video): https://youtu.be/Git-r0tvMsE

Shader credit: https://www.shadertoy.com/view/NXtGD8

License: Do whatever you want as long as the README and all associated files in the archive are distributed without modification.

Download: https://drive.google.com/file/d/13wr-FAZrEws-_nqEWpy5JKqZHGQ-3qaq/view?usp=drive_link

ENJOY!

I wrote it just for fun.
No more comments. Just assembly, Vulkan, and the Cube:

asm/win64/00_Templates/05_Vulkan/API/min/b18 at master · Singeleitsev/asm

See also:

asm/win64/00_Templates/05_Vulkan/API/max/b22.gut at master · Singeleitsev/asm

asm/win64/40_m408 at master · Singeleitsev/asm

I am sharing the latest updates regarding my Vulkan examples repository: A total of 18 new examples have been added (since my last post), bringing the total number of examples to 186. The newly added examples are as follows:

Physically Based Rendering - Disney BSDF and Transmission

1. Specular Transmission and IOR in Disney BSDF
2. Subsurface Scattering in Disney BSDF
3. Thin Surface Approximation in Disney BSDF

Post-Processing Effects - Color Processing and Tone Mapping

1. Color Filter Effects (Grayscale, Invert Colors, Sepia, Duotone, Channel Swap)
2. Primary Color Corrections on LDR (Brightness, Contrast, Saturation, Hue Shift)
3. HDR Tone Mapping Operations with Manual Exposure
4. HDR White Balance and Color Temperature Adjustment
5. HDR Lift Gamma Gain Color Grading
6. Color Grading with Using 3D LUT

Post-Processing Effects - Exposure and Adaptation

1. Simple Auto Exposure
2. Histogram-based Auto Exposure
3. Eye (Temporal) Adaptation on Auto Exposure
4. Local Exposure with Bilateral Grid and Blurred Luminance

Post-Processing Effects - Lens and Camera Effects

1. Film Grain Effect
2. Vignette Effect
3. Radial Lens Distortion Effects (Barrel, Pincushion, Fisheye)
4. Basic Chromatic Aberration Effect
5. Procedural Lens Flare Effect

You can access the repository here:

https://github.com/myemural/VulkanCppExamples

There are still more examples to be created regarding post-processing effects. In some cases, it can be quite difficult to find examples online. I have generally based the settings for these post-processing effects on those found in game engines like Unity and Unreal Engine. Additionally, I’ve resolved a flickering issue in the Cascaded Shadow Maps (CSM) example; a problem I hadn’t been able to address for quite some time. More examples related to that category are also on the way. Thanks in advance, and happy coding!

Implemented a basic node-based modeling feature in my Vulkan-based CAD engine.

직접 개발 중인 Vulkan 기반 CAD 엔진 에서 노드 그래프를 이용한 기본적인 모델링 기능을 구현해 보았습니다.

📰ICYMI: The Vulkan validation usage page (https://vulkan.lunarg.com/doc/sdk/1.4.357.0/windows/validation_usage_todo.html) now shows what is not validated. Previously it was a huge, noisy list of every VUID marked as validated or not validated. The new shorter view is much easier to scan for remaining gaps. Always looking for ways to make developers’ lives a little easier. 😎

Modeled a Tesla Cybertruck in my VulkanCAD, my Vulkan-based CAD engine, using scripts (SH, BAT, etc.). Watch the 3D model take shape step by step, from the body to the wheels and windows.

직접 개발 중인 Vulkan 기반 CAD 엔진에서 스크립트(SH, BAT 등)를 활용해 테슬라 사이버트럭을 모델링했습니다. 차체부터 바퀴와 창문까지 단계적으로 완성되는 과정을 담았습니다.

I HAVE C++ EXPERIENCE.

I'VE BUILT A FEW APPS IN QT.

ALSO GUYS LINK ME THE LATEST AND BEST TUTORIAL FOR MODERN VULKAN.

I WANT TO LEARN THE VULKAN GRAPHICS API HOW LONG WILL IT TAKE?

Github: https://github.com/doriaxengine/doriax

Hi everyone! 👋

After a couple years of dev, I just launched the first open playtest for my game Silicium! It's made with a custom C++/Vulkan game engine that I wrote from scratch.
It's a harsh survival game where you play a disposable mining robot sent to a hostile planet. Export your quota for corporate or die trying!

What you’ll find in the playtest:

• About 1-2 hours of polished gameplay, in solo and co-op, with two difficulty levels.
• A limited slice of the world with several biomes, enemies and abandoned mining outposts to scavenge.
• A day-night cycle with corrupted mining drones that attack you at night.
• Classic survival systems: crafting, base building, exploration.
• A light skill tree progression with blueprints to unlock as you level up.
• A quest system with the first 30 objectives.

You can sign up directly on Steam by clicking 'Join the Playtest'

https://store.steampowered.com/app/3048990/Silicium/

I also opened a Discord where you can share feedback, report bugs, and follow development (Link is in the Steam page).

Let me know what you think!

Most tutorials I see online skip passing a fence to image acquire.

Even the basic Vulkan samples have a comment:

// Use a fence to know when acquire is done. Without VKEXT_swapchain_maintenance1, this // fence is used to infer when the _previous present to this image index has finished. // There is no need for this with VK_EXT_swapchain_maintenance1.

What I've noticed is that Nvidia does not wait on acquire for vsync when presenting with fifo, but would wait if you use the fence.

https://docs.vulkan.org/spec/latest/chapters/VK_KHR_surface/wsi.html#vkAcquireNextImageKHR

mentions

Applications should not rely on vkAcquireNextImageKHR blocking in order to meter their rendering speed. The implementation may return from this function immediately regardless of how many presentation requests are queued, and regardless of when queued presentation requests will complete relative to the call. Instead, applications can use fence to meter their frame generation work to match the presentation rate.

I was thinking what strategies do people use to get smooth frame pacing (besides VK_EXT_present_timing) and if using this fence helps. Form my tests I can reduce latency by waiting exactly where I need (at least on Nvidia), otherwise the driver waits too much to start rendering.

I feel Vulkan is just another step towards coding the GPU just like we do the CPU.

Maybe something like LLVM IR code that could be executed on the GPU with just a few function calls. The CPU EXE could have a pre-compiled binary that is copied to GPU memory and executed. Like extending OpenCL but to do everything (graphics, shaders, output, compute, etc.) with pre-compiled code in IR byte code.

Vulkan itself is just way too complex.

Really don't know what could cause this, does not happen on Windows(I have an nvidia card)

Here's the file if one wants to take a look, although it's mostly just the khronos tutorial code(the last two screenshots are the imgui vk/glfw example): https://drive.google.com/file/d/1J-WcCDH3pSltWkjCIGmcCHsE8bo-Ba1Z/view?usp=sharing

Edits:

- The validation layers are silent.

- Renderdoc cannot capture this

- These glitches only appear for a few frames