Extension: VK_EXT_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.

Extension: VK_KHR_dynamic_rendering

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

Extension: VK_KHR_push_descriptor

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.

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.

Extension: VK_EXT_memory_budget

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

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.

Extensions: VK_KHR_ray_query, VK_KHR_acceleration_structure

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.

Extensions: VK_KHR_ray_tracing_pipeline, VK_KHR_acceleration_structure

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.

Extensions: VK_KHR_ray_tracing_pipeline, VK_KHR_acceleration_structure

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.

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.

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

Extensions: VK_KHR_external_memory, VK_KHR_external_semaphore

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.

Extensions: VK_KHR_external_memory, VK_KHR_external_semaphore

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.

Extensions: VK_ANDROID_external_memory_android_hardware_buffer

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.

Extensions: VK_KHR_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.

Extensions: VK_KHR_buffer_device_address

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

Extension VK_KHR_synchronization2

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.

Extensions: VK_EXT_descriptor_indexing

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

Extension: VK_KHR_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.

Extension: VK_KHR_fragment_shading_rate

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.

Extensions: VK_KHR_ray_tracing_pipeline, VK_KHR_acceleration_structure, VK_EXT_descriptor_indexing, VK_EXT_scalar_block_layout

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.

Extensions: VK_KHR_portability_subset

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.

Extension: VK_EXT_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.

Extension: VK_EXT_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.

Extension: VK_EXT_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.

Extension: VK_EXT_extended_dynamic_state2

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.

Extension: VK_EXT_extended_dynamic_state2

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).

Extension: VK_EXT_extended_dynamic_state2

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

Extension: VK_KHR_fragment_shader_barycentric

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

Extension: VK_EXT_descriptor_buffer

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

Extension: VK_EXT_color_write_enable

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

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.

Extension: VK_EXT_shader_object

Demonstrate how to use shader objects.

Extension: VK_EXT_extended_dynamic_state3

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

Extensions: VK_EXT_line_rasterization, VK_EXT_extended_dynamic_state3

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

Extension: VK_KHR_shader_non_semantic_info

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.

Extension: VK_EXT_extended_dynamic_state3

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