Extension samples

The goal of these samples is to demonstrate how to use a particular Vulkan extension at the API level with as little abstraction as possible.

Conservative Rasterization

Uses conservative rasterization to change the way fragments are generated. Enables overestimation to generate fragments for every pixel touched instead of only pixels that are fully covered.

Dynamic Rendering

Demonstrates how to use Dynamic Rendering. Read the blog post here for discussion: (https://www.khronos.org/blog/streamlining-render-passes)

Push Descriptors

Push descriptors apply the push constants concept to descriptor sets. Instead of creating per-object descriptor sets, this example passes descriptors at command buffer creation time.

Debug Utilities

Extension: VK_EXT_debug_utils

Uses the debug utilities extension to name and group Vulkan objects (command buffers, images, etc.). This information makes debugging in tools like RenderDoc significantly easier.

Memory Budget

Uses the memory budget extension to monitor the allocated memory in the GPU and demonstrates how to use it.

Mesh Shader Culling

Extension: VK_EXT_mesh_shader

Uses the mesh shader extension to demonstrate how to do basic culling utilizing both a mesh and a task shader.

Basic ray queries

Render a sponza scene using the ray query extension. Shows how to set up all data structures required for ray queries, including the bottom and top level acceleration structures for the geometry and a standard vertex/fragment shader pipeline. Shadows are cast dynamically by ray queries being cast by the fragment shader.

Basic hardware accelerated ray tracing

Render a basic scene using the official cross-vendor ray tracing extension. Shows how to setup all data structures required for ray tracing, including the bottom and top level acceleration structures for the geometry, the shader binding table and the ray tracing pipelines with shader groups for ray generation, ray hits, and ray misses. After dispatching the rays, the final result is copied to the swapchain image.

Extended hardware accelerated ray tracing

Render Sponza with Ambient Occlusion. Place a vase in center. Generate a particle fire that demonstrates the TLAS (Top Level Acceleration Structure) animation for the same underlying geometry. Procedurally generate a transparent quad and deform the geometry of the quad in the BLAS (Bottom Level Acceleration Structure) to demonstrate how to animate with deforming geometry. Shows how to rebuild the acceleration structure and when to set it to fast rebuild vs fast traversal.

Mesh shading

Extensions: VK_EXT_mesh_shader

Renders a triangle with the most simple of all possible mesh shader pipeline examples. There is no vertex shader, there is only a mesh and fragment shader. The mesh shader creates the vertices for the triangle. The mesh shading pipeline includes the task and mesh shaders before going into the fragment shader. This replaces the vertex / geometry shader standard pipeline.

HPP Mesh shading

A transcoded version of the Extensions sample Mesh shading that illustrates the usage of the C++ bindings of vulkan provided by vulkan.hpp.

OpenGL interoperability

Render a procedural image using OpenGL and incorporate that rendered content into a Vulkan scene. Demonstrates using the same backing memory for a texture in both OpenGL and Vulkan and how to synchronize the APIs using shared semaphores and barriers.

OpenCL interoperability

This sample shows how to do Vulkan and OpenCL interoperability using cross vendor extensions in both apis. The sample uses OpenCL to update an image that is then displayed in Vulkan. This is done by sharing the memory for that image across the two apis. The sample also shares semaphores for doing cross api synchronization.

OpenCL interoperability (Arm)

This sample demonstrates usage of OpenCL extensions available on Arm devices. Fill a procedural texture using OpenCL and display it using Vulkan. In this sample data sharing between APIs is achieved using Android Hardware Buffers.

Timeline semaphore

Demonstrates various use cases which are enabled with timeline semaphores. The sample implements "Game of Life" in an esoteric way, using out-of-order signal and wait, multiple waits on same semaphore in different queues, waiting and signalling semaphore on host.

Buffer device address

Demonstrates how to use the buffer device address feature, which enables extreme flexibility in how buffer memory is accessed.


Demonstrates the use of the reworked synchronization api introduced with VK_KHR_synchronization2. Based on the compute shading N-Body particle system, this sample uses the new extension to streamline the memory barriers used for the compute and graphics work submissions.

Descriptor indexing

Demonstrates how to use descriptor indexing to enable update-after-bind and non-dynamically uniform indexing of descriptors.

Fragment shading rate

Uses a special framebuffer attachment to control fragment shading rates for different framebuffer regions. This allows explicit control over the number of fragment shader invocations for each pixel covered by a fragment, which is e.g. useful for foveated rendering.

Fragment shading rate_dynamic

Render a simple scene showing the basics of shading rate dynamic. This sample shows low and high frequency textures over several cubes. It creates a sample rate map based upon this frequency every frame. Then it uses that dynamic sample rate map as a base for the next frame.

Ray tracing: reflection, shadow rays

Render a simple scene showing the basics of ray tracing, including reflection and shadow rays. The sample creates some geometries and create a bottom acceleration structure for each, then make instances of those, using different materials and placing them at different locations.


Demonstrate how to include non-conformant portable Vulkan implementations by using the portability extension to include those implementations in the device query. An example of a non-conformant portable Vulkan implementation is MoltenVk: MoltenVk. Also demonstrate use of beta extension which allows for querying which features of the full Vulkan spec are not currently supported by the non-conformant Vulkan implementation.

Graphics pipeline library

Uses the graphics pipeline library extensions to improve run-time pipeline creation. Instead of creating the whole pipeline at once, this sample makes use of that extension to pre-build shared pipeline parts such as vertex input state and fragment output state. These building blocks are then used to create pipelines at runtime, improving build times compared to traditional pipeline creation.

Conditional rendering

Demonstrate how to do conditional rendering, dynamically discarding rendering commands without having to update command buffers. This is done by sourcing conditional rendering blocks from a dedicated buffer that can be updated without having to touch command buffers.

Vertex input dynamic state

Demonstrate how to use vertex input bindings and attribute descriptions dynamically, which can reduce the number of pipeline objects that are needed to be created.

Extended dynamic state 2

Demonstrate how to use depth bias, primitive restart, rasterizer discard and patch control points dynamically, which can reduce the number of pipeline objects that are needed to be created.

Logic operations dynamic state

Demonstrate how to use logical operations dynamically, which can reduce the number of pipeline objects that are needed to be created or allow to change the pipeline state dynamically (change type of the logical operation).

Patch control points

Demonstrate how to use patch control points dynamically, which can reduce the number of pipeline objects that are needed to be created.

Fragment shader barycentric

Demonstrate how to use fragment shader barycentric feature, which allows accessing barycentric coordinates for each processed fragment.

Basic descriptor buffer

Demonstrate how to use the new extension to replace descriptor sets with resource descriptor buffers

Color write enable

Demonstrate how to create multiple color blend attachments and then toggle them dynamically.

Geometry shader to mesh shader

Extension: VK_EXT_mesh_shader

Demonstrates how a mesh shader can be used to achieve the same results as with geometry shader, it loads model from a file and visualizes its normals.

Shader object

Demonstrate how to use shader objects.

Dynamic blending

Demonstrate how to use the blending related functions available in the VK_EXT_extended_dynamic_state3 extension.

Dynamic line rasterization

Demonstrate methods for dynamically customizing the appearance of the rendered lines.

Shader Debug Printf

Demonstrates how to use Printf statements in a shader to output per-invocation values. This can help find issues with shaders in combination with graphics debugging tools.

Dynamic depth clipping and primitive clipping

Rendering using primitive clipping and depth clipping configured by dynamic pipeline state.