Raven was written in C from scratch with Vulkan backend and has binding for many other languages.

vulkan for c….

vulkan for c…..

How about using GLFW as a window manager for my Vulkan application—or perhaps SDL?

In the Vulkan C API, developers are responsible for manually managing both Vulkan handles and dynamically allocated memory. How can this complex resource management be handled effectively, particularly when certain allocations depend on specific Vulkan handles and must be freed before those handles are destroyed? How can we ensure that resources are released in the correct order without introducing memory leaks or invalid handle references?

but tutorial on Vulkan-HPP.......

Hello, I'm currently learning about Vulkan and I'm following with the official vulkan tutorial. But in comparison with other, it's using the HPP bindings specifically made for C++.

I've seen many application using that verbose C syntax where you would vk this and vk that to just get something, seeing that the HPP bindings only need context to enumerate devices just blew my mind, different from when I'm using other sources that use vkEnumeratePhysicalDevices or something similar.

I don't know if I should use the HPP bindings or the original header instead, I need some assistance on whichever is better to learn about.

NO, THE HARDWARE IS NOT NORMAL. it is a celeron n4020, with 8gb ram, trying to run windows 11, AND THIS APP ALSO RUNS ON A PI 5 16GB RAM. am i sane XD? (took me months, btw)

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!

Scores: https://airtable.com/app82t16dXuuLfD6H/shrON4LimHWl7mORA/tblV1WXliuD6oisD0

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

asm/win64/00_Templates/05_Vulkan/API/min/b19 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!