Hey everyone! Today we are releasing our 2024 Ecosystem Survey Progress Report. This document describes how we’ve used the feedback you provided last year in our efforts to improve the Vulkan ecosystem. A big part of running these surveys is making sure you all feel like your voices are being heard and that we’re actually doing something with the info you give us. We work on this every year to close the loop, which also gets folks excited to join in on the next survey right after we drop the yearly progress report. (And the 2025 survey is now live, so help us out by taking a few minutes to fill it out!) In this blog post, we’ll hit the highlights of what we achieved over the last year, but do yourself a favor and check out the full report. There’s some cool notes in there on how your feedback shaped our work. Notably: Many of the accomplishments described below are thanks to the folks at LunarG, made possible with support from Valve and Google. The Khronos dev relations crew has been grinding away to improve the Vulkan specs, samples, and docs. (They are responsible for the awesome Antora work described below.) The Khronos Vulkan Working Group continues to explore options to reduce API verbosity and complexity. And let’s not forget the awesome open-source devs who’ve contributed so much. Big shoutout to everyone for all we’ve done together over the last year! Background The 2024 LunarG ecosystem survey was a collaborative effort between LunarG, Khronos developer relations, and Google to assess the Vulkan ecosystem’s health and developer satisfaction. The survey targeted a broad spectrum of Vulkan developers, both SDK users and non-users, through multiple channels including social media, developer communities (e.g., Reddit and Discord), professional networks, and direct email to over 13,000 recipients. Survey results from 2024 helped prioritize Vulkan implementation priorities and design decisions over the past year. Vulkan Ecosystem Progress (Feb. 2024-Jan. 2025) SDK Releases The biggest contribution to ecosystem progress came from six Vulkan SDK releases over the last twelve months. Turning the crank on each release requires effort and coordination from a big team of people. Hundreds of improvements and bug fixes go into each release. Significant effort is required to curate and align almost 30 major components, test things, package them up, and make them available to thousands of users worldwide. The Vulkan SDK is now supported on Windows, Linux, macOS, and Android. And it is downloaded 50,000 times every week! This level of usage makes it essential that every release is high quality. In addition to the continuous improvements from six releases, here are some specific results achieved since the 2024 Ecosystem Survey. Platform Support Windows 11 is now fully supported and is included in LunarG’s CI and SDK release test matrix. Added an SDK for ARM64 on Windows 11 and a script to enable Linux users to support ARM64. The macOS SDK is now dual platform (Apple Silicon/X86_64) and the installation can be automated more easily. Added iOS support to the macOS SDK. SDK tools Significantly improved GFXReconstruct (improved support for Android, major performance improvements, added interactive analysis features, merged foundations of portable capture and replay of ray tracing). Included support for Slang to address the need for next generation shading languages. Added a new crash diagnostic layer to provide a straightforward method for diagnosing and fixing GPU hangs and crashes. Improved GPU-AV and Debug Printf so they can be used simultaneously and added support for 8-, 16-, and 64-bit float. Added debug labels and resource handles to error messages. The SDK documentation now includes an alternative version of the Vulkan specification built using Antora. This Antora-generated specification significantly reduces load times when accessed via a browser. Now, clicking a URL link from a validation layer error message will quickly direct you to the relevant VUID section in the Vulkan specification, bypassing the slow loading times associated with the HTML version. This feature is introduced in SDK version 1.4.304.1. Validation Completed a significant amount of development for SPIR-V validation. Completed and released synchronization validation for the VK_KHR_timeline_semaphore extension. Modified the working group process to require validation layer support for new extensions coincident with their release. Completed all core validation rules for Vulkan 1.0, 1.1, and 1.2. Completed all ray tracing validation that can be done on the CPU. Documentation and Samples Improved Vulkan documentation by adding a dark mode, improved searching, and eliminating dead links. Made significant additions to Vulkan’s shading language documentation. Added programming samples for raytracing, interoperability, video, and for six new extensions Improved support for extension/feature queries. Conclusion Supporting an open-source initiative like the Vulkan SDK allows companies to innovate faster, reduce costs, and quickly develop enterprise-quality, cross-platform GPU software solutions. LunarG and our partners are proud of what we have accomplished on behalf of the Vulkan ecosystem in the last 12 months. Let’s make 2025 another great year for the Vulkan API and the Vulkan SDK!
Vulkan GPU-assisted validation startup time improved by >10X
When you create a pipeline in Vulkan, the graphics driver compiles the SPIR-V code from your application into assembly code that the GPU can execute. Given that applications can have tens of thousands of these pipelines, the speed of compilation is crucial. When tracing application execution with GFXReconstruct, all these pipelines are compiled at the beginning of the trace, which can significantly slow down the process. The Challenge with GPU-AV GPU-AV, our GPU validation tool, requires instrumenting the SPIR-V code with additional validation and error reporting instructions. Initially, this instrumentation caused performance issues, with each pipeline taking multiple seconds to compile, and the entire trace taking hours to start with GPU-AV enabled. Although subsequent runs were faster due to shader caching by the driver, we needed to enhance the initial startup time. Our Optimization Strategies Here are the four main strategies we employed to accelerate the process: Leveraging the “DontInline” Flag: SPIR-V includes a “DontInline” flag for functions. We found that most drivers ignored this flag. Inlining generally improves application performance. But with NVIDIA’s 553.31 Windows Driver, Setting this flag gave us a 10x speed increase, reducing compilation time for small traces from 205 seconds to just 32 seconds. The speedup occurred because GPU-AV instrumented the same function multiple times, and the driver’s inlining was counterproductive. Segmenting Instrumentation: We divided the large, monolithic instrumentation into smaller, more targeted checks. This allowed us to skip unnecessary instrumentation, particularly in scenarios where certain features like descriptor indexing weren’t used. This approach significantly improved performance for applications with limited use of advanced GPU features. Utilizing Vulkan Robustness Features: To prevent application crashes, GPU-AV would wrap every potentially invalid SPIR-V instruction in an if/else construct. This was computationally expensive. By adopting Vulkan’s robustness features, we could delegate crash prevention to the hardware, thereby simplifying and speeding up our instrumentation. Optimizing for Graphics Pipeline Libraries: Previously, we instrumented each library in the Graphics Pipeline Library individually. However, since many libraries might not be used during a trace, we shifted the instrumentation to occur at the library linking phase (typically at draw time). This not only distributed the compilation load over time but also reduced unnecessary instrumentation. Bonus: Parallel Pipeline Compilation: GFXReconstruct recently introduced a command line option for parallel compilation of pipelines, which, while still in beta, has dramatically increased compilation speeds. (Contact us for more details.) Conclusion These optimizations have significantly reduced the overhead of using GPU-AV for Vulkan pipeline validation, making it more practical for developers to use in their workflows without substantial delays. We continue to refine and enhance these processes to ensure both performance and reliability in GPU validation tasks.
LunarG 3D graphics engineer adds GLSL & SPIR-V as inputs to Compiler Explorer!
Innovation Flash! Spencer Fricke, a 3D graphics engineer at LunarG, has added GLSL & SPIR-V as input options to the popular Compiler Explorer (a.k.a. Godbolt) tool. To see what we mean, checkout these examples – GLSL – https://godbolt.org/z/s14W5Mx6M spirv-opt – https://godbolt.org/z/r1j1GnMer spirv-val – https://godbolt.org/z/ePbTaYK3r Stay tuned for more valuable innovations from LunarG 3D graphics engineers! FYI – Download the Vulkan SDK here!
2023 Vulkan Ecosystem & SDK Survey – End of Year Status Report
In February of 2023, LunarG conducted a Vulkan Ecosystem & SDK Survey. Many Vulkan developers shared their requests for improvements. LunarG took those suggestions to heart and made many enhancements to the Vulkan ecosystem this year. We’ve prepared a report for the Vulkan developer community that summarizes our work. Read on for more information.
A Guide to GFXReconstruct on Android
Mark Young of LunarG presents a “how to” guide (with examples) for using GFXReconstruct on Android. Click Here to View the Paper (HTML)
LunarG Collaboration with AMD’s GPUOpen Team Yields DX12/DXR Support for GFXReconstruct
After close collaboration with AMD’s GPUOpen team, LunarG is excited to announce the release of DX12 and DXR support for our GFXReconstruct tool. GFXReconstruct is LunarG’s open-source graphics API capture and replay tool for reconstructing graphics application behavior. LunarG initially developed GFXReconstruct to capture/replay Vulkan® applications. This free-use, open-source tool has seen broad adoption by Vulkan developers. Through a joint venture between AMD and LunarG, GFXReconstruct has been extended to support the capture/replay of applications using the DirectX ecosystem. D3D12 is the de facto standard for gaming on the Windows platform and has been used in the development and deployment of hundreds of titles since its release. Adding D3D12 support to GFXReconstruct provides developers with another valuable tool to help analyze and debug D3D12 applications. Since this latest version of GFXReconstruct continues to be made available through an open-source license, developers can use this tool freely and can choose to contribute back to the community by providing enhancements, support, or bug fixes. Find more information in the AMD GPUOpen blog, the release notes for this release, and the GFXReconstruct GitHub. More information about LunarG LunarG’s software engineering experts create innovative products and services for open-source and commercial customers using leading-edge 3D graphics and compute technologies, including Vulkan, OpenXR, SPIR-V, and OpenGL. We have strengths in performance analysis and tuning, runtime and tools development, shader optimizations, driver development, and porting engines and applications to Vulkan. Our software engineering team is based in Fort Collins, Colorado. LunarG was founded by software experts who are passionate about 3D graphics. For more information about LunarG, please check out our website.
Benefits of Using the Vulkan SDK
The Vulkan SDK components come from open-source repositories. While it is feasible to develop Vulkan applications without using the Vulkan SDK, there are many benefits to installing it, such as access to: An installation process that is easy and fast Vetted and curated content to ensure compatibility and seamless integration Ready-to-use versions of the Vulkan Configurator An optional updated Vulkan Runtime for Windows environments SDK release notes and user documentation A License Registry that details all of the licenses included by the SDK components Complete package of available shader toolchain tools The most up-to-date set of Linux Vulkan components All necessary macOS binaries pre-built with an option for system-level installation of MoltenVK as an ICD This white paper explains these benefits. Click here to read the white paper.
New Vulkan SDK License Registry White Paper
LunarG delivers the Vulkan SDK for Windows, Linux, and macOS. It’s free to use the SDK. We’ve received inquiries from users who want to know the license agreements for the SDK components. The Vulkan SDK is comprised of tools and layers from 13 different open source repositories that are built, integrated, tested, and packaged for installation on the user’s system. Every tool or layer is built from source with multiple open-source licenses. It isn’t appropriate to assign a license to the SDK itself since that would be re-attributing a license to all of the SDK components; so the SDK itself is “unlicensed.” Providing proper attribution for every component requires that we be able to report the exact licensing for each component. Customers may also need to understand low-level licensing details to assess the SDK for installation in their corporate environments. The Vulkan SDK Registry is LunarG’s method of communicating license information for all of the SDK components. Click here to read the white paper about the Vulkan SDK License Registry.
