Category: Blog

Vulkan SDK 1.4.313 Release: New Extensions, Cross-Platform Enhancements, and More

Released 06 May 2025

The Vulkan SDK 1.4.313 release has landed, bringing updates across Linux, Windows, and macOS platforms (download here). Announced on May 6, 2025, this release introduces new extensions, enhances cross-compiling capabilities, improves validation coverage, and upgrades tools like vkconfig3. Whether you’re a game developer, a graphics engineer, or working on compute applications, this update offers valuable additions to streamline your workflow. Let’s break down the key changes in this release.

Deprecation Notices

• The May 2025 SDK release is the last release of Ubuntu Packages. As Ubuntu Packages become older than two years, they will be removed from public availability.
• Visual Studio 2019 will be deprecated in the future and when this happens, SDKs will require the use of Visual Studio 2022.

New Vulkan Extensions

The Vulkan headers in SDK 1.4.313 now include the following new extensions, which are optional and may not be supported by all drivers or ICDs (Installable Client Drivers). Applications can query for these features to ensure compatibility:

• VK_QCOM_tile_memory_heap
• VK_NV_external_compute_queue_vendor
• VK_QCOM_tile_shading
• VK_EXT_fragment_density_map_offset
• VK_KHR_shader_bfloat16

These extensions expand Vulkan’s flexibility, catering to diverse use cases from mobile optimization to machine learning. Developers should query for support using Vulkan’s enumeration functions (e.g., vkEnumerateDeviceExtensionProperties) to ensure compatibility with target hardware.

Enhancements to vkconfig3

The Vulkan Configurator (vkconfig3) sees multiple improvements, making it a more robust tool for debugging and configuration:

• Dark Mode Support: For Windows and macOS, a new dark mode option improves usability in low-light environments, reducing eye strain during long development sessions.Variations in Linux distributions are making proper Linux support problematic. We are continuing to pursue a Linux solution for this oft-requested feature.
• Removal of vkVIA: The vkVIA tool has been deprecated, with its diagnostic functionality now integrated into the System Diagnostic tab of the Vulkan Configurator, streamlining the diagnostic process.
• Log File Creation: vkconfig3 can now generate log files specifically formatted for submission with Vulkan bug reports, simplifying the process of reporting issues to driver vendors or the Khronos Group.
• Additional Enhancements: The vkconfig changelog details further improvements, such as UI tweaks and performance optimizations

These updates make vkconfig3 a more user-friendly and efficient tool for managing Vulkan layers and settings, which is crucial for debugging complex graphics applications.

Cross-Compiling Enhancements (Windows Only)

The Windows release of Vulkan SDK 1.4.313 includes significant improvements for cross-compiling, catering to developers targeting both x64 and ARM64 architectures:

• Windows/x64 SDK: Now includes Windows ARM libraries and DLLs in the Lib-ARM64 and Bin-ARM64 directories, allowing developers to cross-compile for ARM64 devices from an x64 system.
• Windows/ARM SDK: Includes Windows/x64 libraries and DLLs in the Lib-X64 and Bin-X64 directories, enabling cross-compilation for x64 systems from an ARM setup.
• Developer Responsibility: The SDK provides the necessary libraries and DLLs for linking and packaging, but no additional tools (e.g., compilers) are included. Developers must configure their own cross-compilation toolchains, such as using Visual Studio with ARM64 support.

This cross-compiling support is a big win for Windows developers, enabling them to target a broader range of devices—like ARM-based laptops or mixed-architecture deployments—without needing separate build machines. However, the lack of bundled tools means you’ll need to be comfortable setting up your own environment.

Improved Validation Coverage (All Platforms)

All three SDK releases (Linux, Windows, macOS) include enhanced validation layers, a critical component for catching errors in Vulkan applications:

• Updated Validation Documentation: The validation_error_database.csv and validation_error_database.html files have been updated to reflect the latest VUID (Validation Unique ID) coverage status. This documentation helps developers understand which Vulkan API rules are enforced by the validation layers, making it easier to debug and optimize code.
• Broader Coverage: More edge cases and API misuse scenarios are caught by the validation layers. This reduces the likelihood of runtime errors in production applications.

Stronger validation is especially useful for developers new to Vulkan, as it helps identify mistakes early in the development process, saving time and effort.

Why This Release Matters

The Vulkan SDK 1.4.313 release strengthens Vulkan’s position as a versatile, cross-platform API for graphics and compute. The new extensions cater to emerging needs, like efficient mobile rendering (Qualcomm extensions) and machine learning (bfloat16 support), while also supporting advanced rendering techniques (fragment density map offsets). The cross-compiling enhancements for Windows are a practical addition for developers targeting diverse architectures, and the improvements to vkconfig3 and validation layers make debugging easier than ever. Together, these changes empower developers to build more efficient, robust applications across Linux, Windows, and macOS.

Getting Started

Download the latest Vulkan SDK from https://vulkan.lunarg.com. The SDK includes the updated headers, libraries, validation layers, and tools like vkconfig3, along with sample code to help you explore the new extensions. Be sure to check the vkconfig changelog for a full list of enhancements, and review the validation documentation to understand the updated coverage.

Final Thoughts

Vulkan SDK 1.4.313 is a solid update that balances new features with practical improvements. While the new extensions are optional and hardware-dependent, they signal Vulkan’s ongoing evolution to meet modern demands. The cross-compiling support and enhanced tools like vkconfig3 demonstrate a commitment to developer productivity, though Windows developers will need to invest time in setting up their cross-compilation environment. Whether you’re optimizing for mobile, experimenting with machine learning, or debugging a complex render pipeline, this release has something to offer.

A Big Thank You!

LunarG is grateful to every contributor in the Vulkan Ecosystem—your efforts power these SDKs and make them a reality!

Release Notes

• Release Notes for Linux
• Release Notes for Windows
• Release Notes for macOS

About LunarG

GPU software development teams often run into roadblocks they can’t move on their own. LunarG is the industry’s leading problem-solving partner for GPU programming. We provide the tools, expertise, and passion you need to keep moving forward and deliver innovative, quality products. Visit the LunarG website to learn more.

Vulkan is used in every industry requiring visualization

Vulkan development is everywhere—any industry using a GPU is in on the action! Gaming takes the top spot since it pushes GPUs to the limit with the toughest workloads, making it the biggest player in Vulkan dev by a long shot. Coming in second is self-learning, showing how students, hobbyists, and up-and-coming pros are using Vulkan to level up their GPU programming skills. Visualization (think scientific and medical stuff) grabs third place, engineering (across all kinds) is fourth, and media and entertainment (like digital content creation) rounds out the top five. There’s also smaller but still key usage in industries like research, automotive, aerospace, manufacturing, and government/defense projects.

Vulkan is used to deliver cross-platform applications

Vulkan apps are running on more than a dozen major OS environments, making the Vulkan API the go-to for native, cross-platform software on modern GPUs. Devs can roll out their apps across ALL the big operating systems with ease! In the survey, Windows 11/x64 took the top spot for Vulkan app deployment targets, followed by Linux/x64 in second, and Windows 10/x64 in third—over half of devs are targeting each of these. macOS came in fourth with about 25% of devs on board, while Android and Steam Deck are also in the mix, each targeted by nearly a quarter of developers. Windows/ARM64, iOS, Nintendo Switch, Steam VR, and Embedded Linux are getting some love too. The huge range of environments devs are hitting with Vulkan just proves it’s the ultimate pick for native cross-platform GPU app development!

Windows ARM and Linux ARM ranked as #1 and #2 “important development environments” in the future

Windows ARM and Linux ARM are seen as the top two future dev environments to watch! Right now, less than 20% of developers think Windows 11 on ARM64 is a big deal for development, but a whopping 90% say it’ll be important down the road—landing it the #1 spot for the future. Same feeling with Linux on ARM: only about 25% see it as key today, but over 80% believe it’ll matter a lot later, putting it at #2 for future dev priorities.

Vulkan API is important now and in the future; WebGPU importance growing

No surprise here—Vulkan is a total rockstar for this crew of devs, with nearly 100% saying it’s a key API for development now and in the future. Meanwhile, OpenGL is on the way down, dropping from 40% (important now) to 20% (important in the future), and most of that shift is heading toward WebGPU, which is gaining big time, jumping from 23% to almost 50%!

Interest in Slang is growing quickly

Though Slang has only been part of the Vulkan SDK since the October 2024 SDK release, it’s already climbed to the #2 spot as the preferred shading language among Vulkan developers. This is a great example of how swiftly LunarG integrates highly anticipated tools into the Vulkan SDK to meet developers’ needs.

The majority of Vulkan developers use vkconfig

Validation layers are a big deal for catching errors, performance hiccups, and API slip-ups while you’re building your app. Vkconfig makes it super easy for devs to debug their Vulkan apps by handling the enabling, disabling, and customizing of layers. Over half of devs are now using vkconfig to mess with layer settings—that’s almost 3x more than any other method! We totally recommend devs jump on vkconfig during development to build apps that are as portable and solid as possible.

Read the whole survey!

If these highlights got you curious, there’s a ton more to check out in the full 2025 LunarG Ecosystem Survey! Grab it here. 

 

 

 

 

If you’re working with graphics debugging or Vulkan application analysis, you’ve likely encountered GFXReconstruct—a powerful open-source tool by LunarG for capturing and replaying graphics API calls. But sometimes, those capture files can balloon in size—especially if you’re recording an entire session when you only need a small slice of it to reproduce a bug or analyze a specific moment.

One of the lesser-known but incredibly useful features of GFXReconstruct is the ability to “recapture” during replay, allowing you to trim a lengthy GFXR capture file down to a shorter, more focused version. In this blog post, we’ll go through the process step-by-step. (The discussion here refers to execution on a Windows or Linux or macOS desktop system. Trimming on Android is significantly different and will be the topic of a future tutorial.)

What is GFXReconstruct “Recapture”?

GFXReconstruct’s “recapture” process involves replaying an existing GFXR file with the capture layer enabled, letting you record a new, trimmed capture file that includes only the frames or sections you care about. This method leverages the replay process to create a new file—perfect for isolating specific moments in a graphics workload without slogging through the entire original capture.

Why Trim a GFXR File?

Trimming is invaluable when:

• You’re debugging a bug that occurs in a specific frame range.
• You want to share a concise capture with a colleague or report a bug without sending gigabytes of data.
• You need to optimize replay performance by focusing on a smaller subset of frames.

Let’s dive into how to do it!

Step-by-Step Guide to Trimming a GFXR File with Recapture

Prerequisites

Before starting, ensure you have:

• GFXReconstruct installed: You’ll need the tools (gfxrecon-replay, etc.) from the latest Vulkan SDK or built from the GitHub repository.
• A source GFXR file: This is the original capture you want to trim (e.g., original_capture.gfxr).
• A working Vulkan environment: Since recapture uses replay, your system must support Vulkan and be able to run the original capture successfully.
• Python: The gfxrecon-capture-vulkan.py script requires Python 3.5 or higher

Step 1: Understand Your Source File

First, get a sense of what’s in your original GFXR file. Use the gfxrecon-info tool to inspect it:

gfxrecon-info original_capture.gfxr

This will output details like the total frame count, helping you decide which frames to trim to. For example, if your bug appears around frame 100 to 150, that’s your target range.

Step 2: Capture API calls with a Python Convenience Script

python gfxrecon-capture-vulkan.py -o trimmed_capture.gfxr –capture-frames 100-150 gfxrecon-replay original_capture.gfxr

Explanation:

• -o trimmed_capture.gfxr: Specifies the file name for the new, trimmed capture file.
• –capture-frames 100-150: Specifies the frame range to recapture (replace with your desired range).
• gfxrecon-replay original_capture.gfxr: The capture file that is to be replayed and trimmed.

(Note: On some systems you may have to specify python3 instead of python.)

When you execute this command, here’s what happens:

You’ll see output indicating the replay process, and possibly a note like [gfxrecon] INFO – Recording graphics API capture to game_capture.gfxr if logging is not explicitly disabled.

GFXR will also add the trimming info and a timestamp to a capture file, so in this case it would output “game_capture_frames_100_through_150_{timestamp}.gfxr” where “timestamp” is something like “20250305T111451”.

Step 3: Verify the Trimmed File

Once the replay finishes, check your new file with gfxrecon-info:

gfxrecon-info trimmed_capture.gfxr

Confirm the frame count matches your expected range (e.g., 51 frames for 100-150). You can also replay it to ensure it captures the intended section:

gfxrecon-replay trimmed_capture.gfxr

Tips and Tricks

• Trim During “Live Capture”: You don’t have to capture instructions into a file. You can “trim” during a live session. The same options  and benefits apply, especially in combination with specifying the conditions for capturing data. It is still called “trimming” even though there’s no source file to trim (i.e., we’re “trimming” the commands from the live app).
• Logging for Debugging: If something goes wrong, set GFXRECON_LOG_LEVEL=debug to get detailed output during recapture.
• Performance: Recapture requires a live GPU, so ensure your system matches the original capture system’s configuration (same operating system, GPU, and driver version).  Ideally recapture should occur soon after capture, on the same system.
• Hotkey Alternative: Instead of a frame range, you can use –trigger {key}(e.g., use  F12 for “{key}”) to manually start/stop capturing during replay by pressing the hotkey. This is less precise but useful for interactive trimming.  Optionally provide –trigger-frames to limit triggered frames to a count.
• Optimize the Result: If your trimmed file still feels bloated, run

  gfxrecon-optimize trimmed_capture.gfxr optimized_capture.gfxr

  to remove unused resource data.

Why Not a Dedicated Trim Tool?

You might wonder why we’re jumping through these hoops instead of using a simple offline trim utility. While GFXReconstruct supports capturing specific frames during initial recording, trimming an existing file currently relies on this recapture method. A dedicated tool has been proposed (see GitHub issue #1109), but for now, recapture gets the job done—albeit with a bit more setup.

Wrap-Up

Trimming a GFXR file with GFXReconstruct’s recapture feature is a straightforward way to focus on the frames that matter. Whether you’re debugging a glitch, analyzing performance, or sharing a concise repro, this technique saves time and disk space. Give it a try next time you’re drowning in a sea of frames—your future self will thank you!

Got questions or run into issues? You can find the user’s guide for GFXReconstruct here. If that’s not sufficient, drop a comment below or hit up the GFXReconstruct community on GitHub. Happy debugging!

Now Available – Vulkan 1.4.309.0 SDKs

Released 13 March 2025

LunarG is excited to announce the release of Vulkan SDK 1.4.309.0 for Linux, Windows, and MacOS! Supporting Vulkan API revision 1.4.309, this SDK update brings a host of enhancements designed to streamline your graphics development workflow. Whether you’re debugging shaders, optimizing performance, or exploring new extensions, this SDK has something for you.

Key enhancements in this version include:  

• Vulkan Validation Layer error messages get a major upgrade—now clearer, more actionable, and easier to digest due to a standardized format.  
• The Vulkan Configurator levels up with slick new features, aimed at improving developer productivity.  
• Ten new extensions join the lineup, expanding your creative toolkit.  
• Validation coverage sees a boost, helping you catch more issues with less hassle.

Go to the Vulkan SDK Download site to get the new SDKs

Revamped Validation Layer Messages: Clarity Meets Flexibility

Debugging just got a lot friendlier. We’ve overhauled the Validation Layer error messages to make them more human-readable and actionable:

• New Format: Errors now follow a clean, three-line structure—VUID and metadata on the first line, the core message on the second, and spec text with a URL on the third. Say goodbye to cluttered object lists!
• Warnings On by Default: Core Validation now enables warnings (like Undefined Values) out of the box, helping you catch issues early without disrupting existing setups (e.g., VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT users are unaffected).
• JSON Output Option: Prefer structured data? Enable JSON output for VkDebugUtilsMessengerCallbackDataEXT::pMessage and parse it with ease. 
• Sync Validation Upgrade: Synchronization validation errors are now easier to understand, with an optional key-value properties section for simpler filtering—configurable via vkconfig or the khronos_validation.syncval_message_extra_properties setting.

These changes mean less time deciphering errors and more time building. Check out all the details here.

Vulkan Configurator: Enhanced Usability and Reliability

The Vulkan Configurator (vkconfig) has been improved with features that boost usability and stability:

• Loader Commands: Import, export, delete, and apply stored loader configs with new vkconfig loader commands.
• Stay Updated: Get notified when a newer SDK drops, so you’re always on the cutting edge.
• Quality Boost: Numerous fixes enhance reliability

Whether you’re tweaking settings or managing configs, vkconfig is now a smoother ride.

New Extensions to Explore

The Vulkan headers now include ten fresh extensions, unlocking new creative possibilities (note: driver support varies, so query availability):

• VK_NV_present_metering
• VK_NV_cooperative_vector
• VK_NV_cluster_acceleration_structure
• VK_NV_partitioned_acceleration_structure
• VK_NV_ray_tracing_linear_swept_spheres
• VK_EXT_external_memory_metal
• VK_KHR_video_maintenance2
• VK_ARM_pipeline_opacity_micromap
• VK_KHR_depth_clamp_zero_one
• VK_KHR_maintenance8

From ray tracing enhancements to video and memory improvements, these extensions give you more tools to push graphics boundaries.

Platform Updates and Deprecation Notice

• Ubuntu Packages Winding Down: Starting summer 2025, we’ll phase out Ubuntu-specific packages due to limited demand. This SDK and one more will be the final releases. The Linux tarball remains a versatile alternative for all Linux devs—check the Getting Started Guide (link-to-guide) for supported distros.
• DXC Holdback: Ubuntu 24.04 packages for SDK 1.4.304.0 won’t update DirectXShaderCompiler due to a stack corruption issue. Need the latest DXC features? Switch to the Linux tarball executable.

A Big Thank You!

LunarG is grateful to every contributor in the Vulkan Ecosystem—your efforts power these SDKs and make them a reality!

Release Notes

• Release Notes for Linux
• Release Notes for Windows
• Release Notes for macOS

About LunarG

Looking to elevate your GPU software project with expert optimization, customized development tools, or Vulkan mastery? LunarG combines industry-leading technical knowledge with a proven track record of supporting developers and hardware vendors. Our services include consulting, customization, or staff augmentation. Visit the LunarG website to learn more.

At Vulkanised 2025 in Cambridge | UK, LunarG presented the following technical presentations:

Watch the Videos –

• Vulkan SDK – Enhancements Over the Last Year – by Karen Ghavam, CEO & Engineering Director
• Debugging your GPU Workflow – by Spencer Fricke, Graphics Software Engineer
• Vulkan Crash Diagnostic Layer – by Jeremy Gebben, Senior Graphics Software Engineer
• Vk-Bootstrap: Vulkan Project Startup Made Easy – by Charles Giessen, Graphics Software Engineer
• So You Want to Write a Vulkan Renderer in 2025 – by Charles Giessen, Graphics Software Engineer

Download the Presentations –

• Vulkan SDK – Enhancements Over the Last Year – by Karen Ghavam, CEO & Engineering Director
• Debugging your GPU Workflow – by Spencer Fricke, Graphics Software Engineer
• Vulkan Crash Diagnostic Layer – by Jeremy Gebben, Senior Graphics Software Engineer
• Vk-Bootstrap: Vulkan Project Startup Made Easy – by Charles Giessen, Graphics Software Engineer
• So You Want to Write a Vulkan Renderer in 2025 – by Charles Giessen, Graphics Software Engineer

Now Available – Vulkan 1.4.304.1 SDKs

Released 7 Feb 2025

Today, we dropped a new Vulkan SDK for Windows, Linux, and macOS that adds significant new features across all three versions:

• A new version (v3) of the Vulkan Configurator that provides a ton of useful new features
• Improvements to GFXReconstruct that allow ray tracing capture/playback in a portable manner
• Documentation improvements that provide massive speedups in load times
• An updated version of Slang containing a variety of bug fixes and improvements

Go to the Vulkan SDK Download site to get the new SDKs

Vulkan Configurator v3

Some of the big improvements to the Vulkan Configurator include:

• Numerous improvements to loading and selecting layers
• Improvements to layer ordering
• Enhancements to executable lists
• Additional logging support for Vulkan Loader
• UI and system diagnostics improvements
• Improvements to $(VULKAN_SDK) variable coverage

Note that previous versions of Vulkan Configurator will no longer be supported.

GFXReconstruct Support for Portable Ray Tracing

Device-independent capture and replay of ray tracing commands (capturing on one device and replaying on a different device) has proven challenging due to the differences in support for ray tracing functionality. GFXReconstruct now contains support for capture-time tracking of device buffer device addresses, shader group handles, and acceleration structures in order to correctly replay them later on a different device.

Antora version of Vulkan Specification

The Vulkan Working Group has developed a version of the Vulkan specification using Antora. With this release, the Antora-based version of the Vulkan specification has been integrated into the SDK version-specific specification of the LunarXchange SDK documentation. This greatly improves load times for documentation within a browser. The single file HTML version of the Vulkan Specification has been removed from the SDK due to serious usability issues. In a future SDK release, the “chunked” and PDF versions of the specification will also be removed.

Slang

An updated version of the Slang shading language compiler is included in this release. This version adds DescriptorHandle for bindless handle support.

Thank you!

LunarG would like to thank all the contributors to the Vulkan Ecosystem that help make the SDKs possible!

Release Notes

• Release Notes for Linux
• Release Notes for Windows
• Release Notes for macOS

About LunarG

LunarG makes it easy for you to tap into the power of GPU processing without straying from your mission to deliver compelling software to your customers. We offer training, consulting, and developer tools for the GPU ecosystem. Vulkan-specific expertise includes performance analysis and tuning, runtime and tools development, shader optimizations, driver development, and porting engines and applications to Vulkan.

Visit the LunarG  website to learn more.

 

Capturing and replaying ray-tracing commands in a device-independent manner has been challenging. However, Vulkan developers can now benefit from a solution we’ve implemented in GFXReconstruct. This advancement allows for the capture of ray tracing commands on one device and their accurate replay on another.

 

Check out Fabian’s white paper for details on how we achieved this!

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!

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!