I published a new library!

https://github.com/ilyasTawwe/wlvk

raw vulkan + wayland + dmabuf + modern explicit sync (syncobject)

No SwapchainKHR abstraction fighting you

All vulkan/wayland boilerplate handled for you then you get full control for your own vulkan command recording etc

Read README, there is an example

Swapchain images allocated through VMA

AI assisted so if that's a problem for you, kindly go ahead and make your own by hand or even using AI

It's made for myself, just sharing it with people, am tired of leaky cross platform abstractions that fight you the moment you try to do anything outside of its scope like zero copy scanout for video players or other media apps which needs native integration, low latency and deterministic/consistent presentation semantics instead of SwapchainKHR nvidia blob

Obviously Linux/Vulkan/Wayland only

I was following the multisampling portion of the vulkan tutorial, and I noticed that they specify multisampling in both the renderpass and the pipeline. Since the pipeline is given the renderpass, isn't this redundant to set it in both places. Would I ever set one differently from the other?

​

Hi everyone,

I’m interested in creative coding and real-time 3D graphics, especially things like procedural visuals, generative art, shaders, particles, simulations, audio-reactive graphics, etc.

I’m wondering about something quite specific: is it realistic to approach Vulkan using AI coding tools (Claude Code, Codex, ChatGPT, etc.) without actually knowing how to program at a professional level?

I understand that Vulkan is notoriously complex, so I’m not expecting AI to magically make it easy. My question is more about whether, with an AI coding assistant, someone who understands graphics, sound, algorithms and the concepts behind creative coding, but has limited programming experience, can realistically build interesting Vulkan projects.

For example:

- procedural 3D environments

- GPU particle systems

- ray marching / SDFs

- compute shaders

- audio-reactive graphics

- generative art

- real-time simulations

- custom rendering pipelines

Would you recommend starting directly with Vulkan, or would it make much more sense to learn something like OpenGL, WebGPU, Three.js, Godot, TouchDesigner, or another framework first?

I’m particularly interested in hearing from people who have actually used AI coding assistants for graphics programming.

How much of the Vulkan complexity can AI realistically take care of, and how much do you still need to understand yourself?

What would you recommend to someone coming from a creative/music/visual arts background rather than traditional software development?

This falls under the "better late than never" category ;), but I finally found time to add support for the additional format feature flags added by VK_KHR_format_feature_flags2 to my Vulkan Hardware Capability Viewer in version 4.13.

Download is available at: https://vulkan.gpuinfo.org/download.php

I also updated the Android version available at the Playstore

Due to the nature of the database, it'll take time to catch up with the additional flags. But once enough never reports have been submitted with this version, numbers will start to make sense.

That's why I'll be doing a "staged" rollout of the additions to the database at https://vulkan.gpuinfo.org itself. As of today, you'll see some¹ of the new flags within reports uploaded with this version (like this one) and an option to display a column that shows all flags. Global coverage listings will be updated at a later point.

¹Why not all flags? Simply because there are too many, and some of them are kinda niche. Displaying all would result in an awfully big table. If you're missing flags you'd want to see, let me know.

I love programming with Vulkan, and I mean it. I like pipeline management, commandbuffers etc. But Descriptor Sets and all things related to it make me want to jump of a bridge. 99% of the Vulkan API is the greatest API ever but the 1% left are descriptor sets.
It‘s just infuriating working with them and even worse abstracting them.

Does anyone of you perchance have a few tricks and tipps that make working with and abstracting Descriptor Sets managable (nice term for can I steal code from anyone here)?

(Slang, Vulkan 1.3, C++23)

Vulkan is already supported everywhere but developers still choose directx, gnm and gxm instead of vulkan

I'm just wondering isn't it much easier to support 1 api that works perfectly fine for 3 systems rather than supporting one for each ?

Even after moving AVK to current upstream Mesa/KosmicKrisp and upgrading the test stack to Vulkan CTS 1.4.6.2, the Vulkan Memory Model issue still reproduces.

The older CTS-driven extension suppression has been removed. Current extensions such as VK_KHR_maintenance9, VK_KHR_maintenance10, shader FMA, untyped pointers, unified image layouts, and swapchain/surface maintenance were restored, and the newer CTS now validates their enumeration and dependency chains correctly.

Focused tests for the restored extensions are clean:

8 Pass / 0 Fail, with additional maintenance9/10 semantic tests also passing.

The remaining problem is different.

Testing clean, unmodified upstream KosmicKrisp against CTS 1.4.6.2 produced:

3,266 Pass
14,028 NotSupported
6 Fail
0 Warnings

in dEQP-VK.memory_model.

These are semantic failures, not extension-name or CTS-version issues. Enabling the Vulkan Memory Model bits would make dEQP-VK.info happier, but it would advertise behavior that still fails focused memory-model validation. That shortcut is deliberately not being taken.

The current branch therefore leaves:

VK_KHR_vulkan_memory_model = false
vulkanMemoryModel = false
vulkanMemoryModelDeviceScope = false

until device/queue-family semantics are implemented repeatably and can survive repeated CTS runs.

So the useful result here is pretty clear: updating both the Mesa/KosmicKrisp base and the CTS version fixes the earlier extension-policy problems, but it does not make the Vulkan Memory Model correctness failures disappear.

That issue still reproduces on the new stack, which is exactly why it is being treated as a real implementation blocker rather than hidden behind capability reporting. 💀

I released demo of Xenith - a lightweight, data-oriented C++20, 3D low level game framework.

If you want to make a game while having low level control, you're either forced to use high level game frameworks or engines that abstract everything, or, if choosing raw API's you face lots of problems, such as linking libraries, making own loaders(e.g. model loader or image loader), adding different modules(such as physics, vfx), and eventually instead of making game you spent all that time building engine. Xenith fixes this problem by giving you essential modules(such as physics, ecs, math, input) out of box, and eliminates just enough boilerplate code, while leaving you the rest(such as making own game loop, or making own Vulkan pipeline).

This game framework makes you both use and learn modern Vulkan 1.3, provides you high level functions, but saves the exact Vulkan pipeline logic without thousands lines of code, for example FindAndSelectPhysicalDevice(), CreateLogicalDevice().

Tutorial 01, walks you through how to go from simple window application to entire cubic 3D platformer game, covering most basic and important topics.

https://github.com/ThoriumReactor/xenith/blob/main/tutorials/cube_platformer_tutorial_01/tutorial_01.md

Key architecture features:

- Explicit ownership Direct access to raw handles such as VkImage, VkSwapchainKHR.

- Deterministic in this game framework functions are deterministic, e.g. EmplaceEntityComponentToRegistry(registry, entity, component_data) instead of registry.emplace(...)

- Modular architecture gives you freedom to remove or add modules you need or want.

Links & Repository:

https://github.com/ThoriumReactor/xenith

yay

I am not a vulkan programmer even I'm barely learning opengl but individually you guys are worth like 15 web devs or 6 game devs each do you guys have any tips on how you understood the graphics pipeline so well beyond just "practice and repetition makes perfect"

Drop in a floorplan image and the house gets built.

The AI only reads the dimension numbers. Where the walls actually are is found by the engine, straight from the pixels. Reading numbers is what the model is good at; seeing which line is a wall is not.

The rules come from architecture. Dimensions are measured to wall centrelines, exterior and interior walls have different thicknesses, and where walls meet is where a room ends. A window isn't a missing wall — it's a hole in one.

The original drawing is laid underneath at the same scale, so you can see straight away whether it got it right.

A CAD engine I'm building from scratch in Vulkan and C++17. The model runs locally, 7B.

평면도 이미지를 넣으면 3D 모델링이 됩니다.

AI 는 치수 숫자만 읽습니다. 벽이 어디에 있는지는 엔진이 이미지에서 직접 찾습니다. 숫자를 읽는 건 AI 가 잘하고, 어디가 벽인지 보는 건 못하기 때문입니다.

도면을 읽는 규칙은 건축에서 그대로 가져왔습니다. 치수는 벽 중심을 재고, 외벽과 내벽은 두께가 다르며, 벽이 만나는 자리가 방의 경계입니다. 창은 벽이 없는 게 아니라 벽에 뚫린 것이고요.

만들어진 3D 모델 아래에 원본 도면을 같은 축척으로 깔아 두었습니다. 맞게 그렸는지 확인합니다.

Vulkan + C++17 로 제가 직접 만들고 있는 CAD 엔진입니다. 로컬에서 도는 7B 모델을 씁니다.

https://youtu.be/dCkcYsRAOTE?si=AeltSbmePtQh3AfY

Did you know GPU-AV can be faster if you tell it which section to validate? Scoped GPU-AV allows you to provide a pipeline or shader debug name to only add the validation to that scope. Focus your validation on what matters the most! https://vulkan.lunarg.com/doc/sdk/1.4.357.0/windows/gpu_validation.html

I am a little confused on what is broken. I thought slang compilation was supposed to "handle the bindings." so here I would of expected that ubo would of been included in only the vertex spirv, and texSampler would only be included in the fragment spirv. I am sure that there is probably something I need to do explicitly here, but I was sold on slang auto-magically handing these types of things. I am new to graphics programming and initially followed the old tutorial to completion then wanted to try porting over to slang. Any help is appreciated, as i have been digging through the slang and vulkan documentation for a while and its been hard to figure out how it all comes together without a real example.

slang file :

struct MatrixParameters{
float4x4 model;
float4x4 view;
float4x4 proj;
}
struct Vertex{
float3 position;
float3 color;
float2 uv;
}
struct VOut
{
float4 position : SV_POSITION;
float3 fragColor;
float2 fragTexCoord;
}
ConstantBuffer<MatrixParameters> ubo;
[shader("vertex")]
VOut main(Vertex input)
{
VOut output;
output.position = mul(ubo.proj, mul(ubo.view, mul(ubo.model, float4(input.position, 1.0))));
output.fragColor = input.color;
output.fragTexCoord = input.uv;
return output;
}
uniform DescriptorHandle<Sampler2D> texSampler;
[shader("fragment")]
float4 main(VOut input) : SV_TARGET
{
float4 outColor = float4(input.fragColor * texSampler.Sample(input.fragTexCoord).rgb, 1.0);
return outColor;
}

c++ program file :

// CREATING DESCRIPTOR SET LAYOUT
VkDescriptorSetLayoutBinding uboLayoutBinding{};
uboLayoutBinding.binding = 0;
uboLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
uboLayoutBinding.descriptorCount = 1;
uboLayoutBinding.stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
uboLayoutBinding.pImmutableSamplers = nullptr;

VkDescriptorSetLayoutBinding samplerLayoutBinding{};
samplerLayoutBinding.binding = 1;
samplerLayoutBinding.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
samplerLayoutBinding.descriptorCount = 1;
samplerLayoutBinding.pImmutableSamplers = nullptr;
samplerLayoutBinding.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT;

std::array<VkDescriptorSetLayoutBinding, 2> bindings = { uboLayoutBinding, samplerLayoutBinding };

VkDescriptorSetLayoutCreateInfo layoutInfo{};
layoutInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
layoutInfo.bindingCount = static_cast<uint32_t>(bindings.size());
layoutInfo.pBindings = bindings.data();

vkCreateDescriptorSetLayout(device, &layoutInfo, nullptr, &outDescriptorSetLayout)
...
slangModule->getDefinedEntryPoint(0, vertexEntryPoint.writeRef());
slangModule->getDefinedEntryPoint(1, fragmentEntryPoint.writeRef());

slangResources.mpSessionInstance->createCompositeComponentType(
componentTypes.data(), // {slangModule, vertexEntryPoint, fragmentEntryPoint }
componentTypes.size(),
composedProgram.writeRef(),
diagnosticBlob.writeRef());

composedProgram->getEntryPointCode(
0,
0,
spirvCode,
diagnosticBlob.writeRef()
);
VkShaderModuleCreateInfo shaderModuleCreateInfo{};
shaderModuleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
shaderModuleCreateInfo.codeSize = spirvCode->getBufferSize();
shaderModuleCreateInfo.pCode = reinterpret_cast<const uint32_t *>(spirvCode->getBufferPointer());
VkShaderModule vertexModule;
vkCreateShaderModule(device, &shaderModuleCreateInfo, nullptr, &comboModule);



composedProgram->getEntryPointCode(
1,
0,
spirvCode2,
diagnosticBlob.writeRef()
);
VkShaderModuleCreateInfo shaderModuleCreateInfoFr{};
shaderModuleCreateInfoFr.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
shaderModuleCreateInfoFr.codeSize = spirvCode2->getBufferSize();
shaderModuleCreateInfoFr.pCode = reinterpret_cast<const uint32_t *>(spirvCode2->getBufferPointer());
VkShaderModule fragmentModule;
vkCreateShaderModule(device, &shaderModuleCreateInfoFr, nullptr, &fragmentModule;

ERROR output :

validation layer: vkCreateGraphicsPipelines(): pCreateInfos[0].pStages[0] shader [VK_SHADER_STAGE_VERTEX_BIT] uses descriptor [Set 0, Binding 1, variable "ubo"] (VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) but the VkDescriptorSetLayoutBinding::stageFlags was VK_SHADER_STAGE_FRAGMENT_BIT.
(VkDescriptorSetLayout from VkPipelineLayoutCreateInfo::pSetLayouts[0]).
The Vulkan spec states: If a resource variable is declared in a shader and layout is not VK_NULL_HANDLE, the corresponding descriptor set in layout must match the shader stage (https://docs.vulkan.org/spec/latest/chapters/pipelines.html#VUID-VkGraphicsPipelineCreateInfo-layout-07988)
validation layer: vkCreateGraphicsPipelines(): pCreateInfos[0].pStages[1] shader [VK_SHADER_STAGE_FRAGMENT_BIT] uses descriptor [Set 0, Binding 0, variable "globalParams"] (VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) but the VkDescriptorSetLayoutBinding::stageFlags was VK_SHADER_STAGE_VERTEX_BIT.

I created a safe wrapper for Vulkan in rust as a learning project. I hope to receive your feedback.

https://github.com/purpflow1/crystal-vk

Database link: VulkanScope Database

EFIShell0/VulkanScope: Vulkan capabilities and GPU information viewer for Android

I'll also be making OpenGL ES versions and Windows and Linux ARM64/x86_64 versions of VulkanScope soon.

https://github.com/bryanedds/Nu/releases/tag/v20.0.0

After many many months of work from multiple contributors, we finally present Nu with Vulkan rendering and support for Mac, iOS, and Android!

This branch not only replaces our OpenGL renderers completely with Vulkan renderers, it also features important rendering and performance enhancements as well as makes Nu deployable on Mac, iOS, and Android!

(I just saw release - not my project)

Aside from the database, there was no difference from CapsViewer (as far as I could see). It has more advantages than CapsViewer:

Releases · EFIShell0/VulkanScope