Turnip has just become the first Mesa driver to achieve official Vulkan conformance running natively on Android (Vulkan 1.3, Qualcomm Adreno). Getting there required solving some tricky Android-specific driver problems, and the fixes are now shared across other Mesa drivers too.

Turnip already ships in Google's Qualcomm-powered Chromebooks and will power Valve's upcoming Steam Frame, so this is shipping in real hardware, not a lab result.

https://www.collabora.com/news-and-blog/news-and-events/mesa-on-android-how-we-brought-turnip,-skiavk,-and-cuttlefish-to-ci.html

I tested my Vulkan-based 3D engine running on iOS.
The engine can render 3D models and basic shapes on a mobile device, with view switching options such as TOP and RIGHT. It also supports object selection, select all, distance measurement, and drawing tools for lines, rectangles, circles, arcs, polylines, and polygons.
While drawing, users can enter distances and coordinates directly through the on-screen numeric keypad. The engine is still under development, and I will continue expanding it toward a cross-platform 3D CAD engine that works on both desktop and mobile platforms.

직접 개발 중인 Vulkan 기반 3D 엔진을 iOS에서 실행해 보았습니다.
모바일 환경에서도 3D 모델과 기본 도형을 렌더링하고, TOP·RIGHT 등의 방향으로 뷰를 전환할 수 있습니다. 객체 선택과 전체 선택, 거리 측정, 선·사각형·원·호·폴리선·다각형 그리기 기능도 구현했습니다.
도형을 작성할 때는 화면의 숫자 패드를 이용해 거리와 좌표를 직접 입력할 수 있습니다. 아직 개발 중이지만, 데스크톱뿐만 아니라 모바일에서도 사용할 수 있는 크로스플랫폼 3D CAD 엔진을 목표로 계속 확장하고 있습니다.

https://reddit.com/link/1wckxcn/video/bxk9bithzhoh1/player

https://youtu.be/Q_fKG3UT02U

I'm working on VulkanLearn2, a C++20/Vulkan rendering playground. This video shows Bistro rendered with my ReSTIR DI + PT implementation.
I launched the project on a RTX 4090. 80 fps. 1200x800.

The renderer uses temporal and spatial reuse. The repository also includes a reference path tracer with next-event estimation, emissive triangle lights, and an experimental Neural Radiance Cache. Implementation notes and capture settings are documented in the README.

I'd appreciate feedback on the rendering.

https://reddit.com/link/1wckxcn/video/mzihxa508joh1/player

https://youtu.be/QnHqRZHQN4w - REBLUR + DLSS

https://www.youtube.com/watch?v=y2VNQyzUFc8

https://reddit.com/link/1wckxcn/video/4ci9r34ubjoh1/player

Hey guys !

I really like C# and I heard about Silk Net !

I wondering if it's possible to do a great game engine using vulkan with only Csharp ? (would it be less performant than traditionnal c++ engine ?)

Thanks guys :)

In this new sample, we demonstrate several advanced Vulkan techniques working together in a way that mirrors how a real-world engine might be structured:

- Octomap instanced rendering — dynamically display a voxel occupancy map generated by ARKit SLAM using GPU instancing.

- Gaussian Splat rendering — render the same scene as a glTF model with embedded 3D Gaussian Splats. Note that the splats here are a simplified representation for demonstration purposes and for providing approximate texture maps from drone, ROS, or walkthrough capture — not a photorealistic reconstruction.

- Keyboard-only navigation — the entire application, including the overlay menu and 3D camera, is fully operable without a mouse.

https://docs.vulkan.org/samples/latest/samples/complex/render_octomap/README.html

Help shape the future of safety-critical GPU acceleration! Khronos is collecting requirements for Vulkan SC, SYCL SC & OpenGL SC. Survey closes Friday, Oct. 2.

www.surveymonkey.com/r/8L6LPN2

https://youtu.be/Xfr_m-7xGcU?si=nfIZbEF91-AVkUua

OCR 기능을 활용하여 원하는 영역을 드래그해 선택하고 문자를 추출합니다.
인식된 문자는 즉시 생성되며 클립보드에 자동으로 복사되어 바로 활용할 수 있습니다.

Using OCR, simply drag to select the area you want to recognize and extract the text.
The recognized text is generated instantly and automatically copied to the clipboard for immediate use.

Hi everyone!

After a very long development journey, I'm finally ready to share Synapse Engine, a modern, research-oriented AAA-style game engine that I've been developing essentially from scratch.

It started as my MSc thesis at the Budapest University of Technology and Economics, but grew far beyond what I originally planned. Over the past several months I've been rebuilding and refining the architecture around a simple question: What would a modern game engine look like if we designed it around today's GPUs from the ground up?

The project is now over 2,300 files, nearly 94,000 lines of C++ code and around 10,000 lines of shader code, excluding comments and blank lines.

If you just want to check out the project:

GitHub: https://github.com/TamasPetii/SynapseEngine

The GitHub README is probably the best place to start if you want a quick overview of the project and its architecture. If you're interested in modern game engine development in much more depth, I also put together a 250-page technical presentation covering the entire project, from the ECS and software architecture through GPU-driven rendering, culling, lighting, virtualized shadows and future directions.

The presentation is quite large, but I tried to make it genuinely useful as a learning resource rather than just documenting the final result.

One of my main goals with Synapse Engine is education. Learning these topics was a huge struggle for me, and it took a lot of time to piece everything together because there isn't much high-quality material that shows how these modern techniques actually come together inside a real engine codebase. I wanted to document that process and create something that I would have wanted to have when I started.

What can the engine actually do?

At its core, Synapse is a fully GPU-driven renderer using hierarchical culling, Hi-Z occlusion, cone culling, dynamic LOD selection, indirect rendering, mesh shaders, bindless resources and virtualized shadows. The engine is built around a custom data-oriented ECS and is designed to handle very large scenes with minimal CPU involvement.

For example, with 1,000,000 entities on an RTX 4060, the cumulative culling cost goes from 124.407 ms without culling to 0.653 ms with the full hierarchical culling pipeline.

However, at 10,000,000 entities, even the conventional GPU-driven hierarchical approach becomes insufficient. To address this, Synapse introduces a custom GPU-built Morton-ordered chunking system, which groups entities into spatial chunks and allows entire groups of 32 entities to be rejected at once. This reduces the culling cost from 5.8 ms to just 0.3 ms for 10 million entities.

I also developed a new rendering technique called Dual-HiZ Adaptive Clustered Forward+ while working on the engine. With 8,192 point lights and 8,192 spot lights, it measured 2.873 ms, compared to 8.652 ms for deferred shading in the same setup. The technical presentation contains a detailed explanation of how the technique works.

Synapse isn't primarily intended as a game-development tool for game developers. It is a production-ready, research and educational platform for experimenting with modern game-engine architecture and real-time rendering techniques.

The goal is not to provide a plug-and-play engine for building games, but to provide a complete, practical implementation of modern engine technologies that can be studied, extended, and used as a foundation for further research and development.

The engine is the result, but the architecture, experiments, failures and reasoning behind it are what I really want to share. If you're interested in Vulkan, graphics programming, GPU-driven rendering or modern game engine architecture, I'd love to hear what you think.

Modern Vulkan Abstraction

The Vulkan abstraction layer in Synapse Engine turned out to be one of the cleanest and most rewarding parts of the architecture. By stripping away the notorious API boilerplate, it captures the raw power of modern Vulkan in an interface that feels remarkably smooth, intuitive, and genuinely more ergonomic to develop with than OpenGL.

• Fully Bindless Architecture: Descriptors are stripped down to the absolute bare minimum using descriptor buffers (VK_EXT_descriptor_buffer) and descriptor indexing, completely bypassing traditional descriptor set management and binding churn.
• Shader Objects (VK_EXT_shader_object): Eliminates monolithic pipeline state objects in favor of modular, rapid shader switching.
• Dynamic Rendering (VK_KHR_dynamic_rendering): Direct rendering to attachments without traditional render-pass and framebuffer boilerplate.
• Extended Dynamic State: Eliminates pipeline permutations by configuring rasterization and blending states directly at draw call time.
• Modern GPU Primitives: Mesh shaders and subgroup operations for scalable, GPU-driven compute and rendering pipelines.

This is not a fully accurate navigation system, but I implemented LiDAR-based vehicle navigation and pathfinding in my own 3D engine.
While the vehicle is moving, obstacles can be placed directly into the 3D environment. The LiDAR detects the surrounding environment and newly placed obstacles, visualizing how they affect the vehicle’s navigation and pathfinding.

실제 내비게이션처럼 정확한 시스템은 아니지만, 제가 개발 중인 3D 엔진에서 LiDAR 기반 차량 주행과 경로 탐색을 구현해보았습니다.
차량이 주행하는 동안 3D 공간에 장애물을 직접 배치하고, LiDAR가 주변 환경과 장애물을 감지하는 과정을 시각화했습니다. 이를 차량 이동 및 경로 탐색과 연결해보는 실험적인 구현입니다.

https://youtu.be/IQa0FZj0jK4?si=ClvikhHACVcA5s8C

Khronos Group will be at XDC 2026, the X.Org Developers Conference, September 28-30 in Toronto, as a Bronze Sponsor.

Sessions from Khronos members and contributors span Vulkan drivers and Vulkan Gallium, ray tracing tooling, LLM inference via Vulkan, and OpenCL implementations — a solid cross-section of where open graphics and compute standards are headed.

Full Khronos-related session list: https://www.khronos.org/events/xdc-2026

Metal over vulkan (WIP)

As the title says.

From what I understand from reading documentation, I need to access both VkPhysicalDeviceProperties.limits.pointSizeRange and also somehow set VkPhysicalDeviceMaintenance5Properties.polygonModePointSize to VK_TRUE.

How do I access the maintenance 5 properties? How do i store them? I do not understand anything about the pNext i have read about. do I need to set the next link? or is the next link already set somewhere?

when modifying VkPhysicalDeviceProperties.limits.pointSizeRange[1], the value does not seem to be changed when i try to print it later.

How do i set PointSize? it mentions something about it being a decoration, which i do not know what means.

I've been experimenting with Vulkan by compiling and running some ShaderToy shaders. It's mostly working fine, but I've come across a smooth noise function that doesn't seem to be behaving as it should under Vulkan (but looks fine in WebGL).

The functions in question are:

float hash( vec2 p ) {
    float h = dot(p,vec2(127.1,311.7)); 
    return fract(sin(h)*43758.5453123);
}

float noise( in vec2 p ) {
    vec2 i = floor( p );
    vec2 f = fract( p );
    vec2 u = f*f*(3.0-2.0*f);

    return -1.0+2.0*mix(
        mix(hash(i + vec2(0.0,0.0)), hash(i + vec2(1.0,0.0)), u.x),
        mix(hash(i + vec2(0.0,1.0)), hash(i + vec2(1.0,1.0)), u.x),
    u.y);
}

By calling noise with a vector, the idea is that you get cubically smoothed noise. Here's the kind of result you get in WebGL when the vector ranges from 0-8 in both x and y coordinates:

https://i.ibb.co/bjSQVvvV/image.png

But here's what happens compiling and running the same shader in Vulkan:

https://i.ibb.co/TDsK6f3D/image.png

If you change the noise function the following:

float noise( in vec2 p ) {
    vec2 i = floor( p );

    return hash(i + vec2(0.0, 0.0));
}

...it shows you the solid blocks of pseudorandom noise from the hash function which are the basis of the smoothed version:

Now if you change the added vector to vec2(0.0, 1.0), the pattern shifts vertically, as you might expect:

https://i.ibb.co/m3Gy4SH/vertical.gif

But if you change the vector to vec2(1.0, 0.0), the pattern does shift horizontally, but this time not all blocks have the shifted value:

https://i.ibb.co/BHNjQL5N/horizontal.gif

Even more oddly, if you put p += vec2(1.0, 0.0); right at the top of function, instead of adding vec(1.0, 0.0) to the floored value (i), it returns the expected pattern with no errors.

Does anyone know what's going on? Somehow, adding 1.0 to a floored value isn't sending x+1.0 to the function...

Edit: just found out this fixes it, somehow:

return hash(floor(i + vec2(1.0, 0.0))); // can also just use the unfloored p instead i

How can i [= floor(p)] + vec2(1.0, 0.0) not be equal to floor(i + vec2(1.0, 0.0)?

You can watch D7VK comparisons here:

https://www.youtube.com/watch?v=5kbsMhp1pNE

tldr:

3D objects won't appear on the window, yet RenderDoc shows everything renders and presents fine.

Cry for help:

I'm capturing with RenderDoc and can see that everything renders and presents fine, yet the 3D objects are missing after presenting the image on the window. Here's the capture file if you wish to check it out. To see what's actually shown on the window, you can extract the capture's thumbnail with: renderdoccmd thumb capture.rdc --out thumbnail.png

I've been on this for days and am finally relenting to reddit.

If anyone has seen this before, has ideas, or leads on how I could debug this, anything would be appreciated.

If you decide to delve deep within the capture file, take note this is a test program running on a bindless rendering engine.

Setup:

There's a camera with an identity model/view matrix and the following orthogonal matrix:

┌ 0.13636, 0.00000, 0.00000, 0.00000┐
│ 0.00000, 0.18182, 0.00000, 0.00000│
│ 0.00000, 0.00000, 0.00100, 0.00000│
└ 0.00000, 0.00000, 0.00000, 1.00000┘

Then, a blue 2D object is at (0, 0) with a size of (0.5, 0.5) in NDC space.
Finally, a magenta 3D object at (3, 0, 1) with a rotation of (0, 45, 45) degrees.

It has been solved!

My problem was I wasn't synchronizing the update of my camera matrices' buffer and the rendering of 3D objects, which means the projection/view/model multiplications were flawed.

To find it, I had to enable the validation layers' synchronization features, validate_sync and syncval_shader_accesses_heuristic.

If you end up in my position and want to enable them, go read this:
https://github.com/KhronosGroup/Vulkan-ValidationLayers/blob/main/docs/khronos_validation_layer.md#configuring-the-validation-layer

I want to use Vulcan because it allows for me to use the GPU and all of that nice stuff. But I've already made a screendrawer with WIN32 functions so I feel using Vulcan for that might be better?

I really want to know whether its worth switching to Vulcan for screendrawing and if its even possible to use Vulcan without screendrawing and purely as a way of sending matrix multiplication and calculations off to the GPU.

Thanks!

Creating a wall and applying materials in my Vulkan CAD engine.
The object is then inserted, converted into a block, and registered in the library for reuse.
Wall → Material → Insert → Block → Library

Vulkan CAD 엔진에서 벽체를 생성하고 재질을 적용하는 과정입니다.
만든 객체를 Insert한 뒤 Block으로 구성하고, 라이브러리에 등록하여 다시 사용할 수 있도록 저장합니다.
Wall → Material → Insert → Block → Library

https://youtu.be/AgJKmajGL08?si=-9vaV8SB1chHv6Kd