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!

The post How to Trim a GFXR File Using GFXReconstruct “Recapture” appeared first on LunarG.

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.

The post LunarG Releases Vulkan SDK 1.4.309.0 appeared first on LunarG.

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

The post Vulkanised 2025 – LunarG Technical Presentations appeared first on LunarG.

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.

The post LunarG Releases Vulkan SDK 1.4.304.1 – vkconfig3, GFXReconstruct ray tracing, ++docs, ++Slang appeared first on LunarG.

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!

The post Portable Raytracing with GFXReconstruct appeared first on LunarG.

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:

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!

The post 2024 Ecosystem Survey – Progress Report Released! appeared first on LunarG.

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.

The post Vulkan GPU-assisted validation startup time improved by >10X appeared first on LunarG.

Released 14 Jan 2025

Today, LunarG released a new Vulkan SDK for Windows, Linux, and macOS that fully supports Vulkan API revision 1.4.

New features in SDK 1.4.304.0

Highlights of the Vulkan SDK 1.4.304.0 release across all operating environments include:

• Full support for the Vulkan 1.4 API specification
• Inclusion of the release version of the slang shader language and compiler (previous SDK releases contained the beta version of slang)
• Inclusion of a shared library for glslang
• 20+ Vulkan extensions added or promoted to core
• Updates to the Vulkan Configurator (vkconfig) to improve quality and stability
• Improved validation coverage

Additional OS-specific highlights:

• (macOS) LunarG’s API capture and replay tool, GFXReconstruct is now supported
• (Windows and Linux) Crash Diagnostic Layer support is now considered beta quality
• (Linux) volk.h and volk.c moved from /include to /include/volk to align references on all platforms, simplifying cross-platform development
• (Windows) 32-bit versions of the Vulkan layers have been removed from the Windows SDK

Important Notes

GFXReconstruct is an important developer tool that captures and replays graphics API calls. With its addition to macOS, GFXReconstruct is now available to developers on all major operating systems.

LunarG’s Crash Diagnostic Layer is a critical tool to help developers debug notoriously difficult GPU crash and hang issues. To help improve this tool as rapidly as possible, please submit any issues to the Crash Diagnostic Layer repository.

32-bit versions of the Vulkan layers were removed from the Windows SDK because there is a consensus that there is no longer a need to develop new 32-bit applications nor to support a 32-bit development environment. If you disagree with this decision, please submit an issue at vulkan.lunarg.com and explain your use case.

The highlights above do not replace the important and detailed information in the release notes!

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.

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

The post LunarG Releases Vulkan SDK 1.4.304.0 – Full support for Vulkan 1.4 appeared first on LunarG.

Spencer Fricke, Graphics Engineer, LunarG Inc., provided an update on the Vulkan SDK at SIGGRAPH Asia 2024 in Tokyo, Japan. Follow the links below to access the presentation materials.

Click here for the Japanese Language Version

Click here for the English Language Version

The post Vulkan SDK Presentation at SIGGRAPH Asia 2024 appeared first on LunarG.

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!

The post LunarG 3D graphics engineer adds GLSL & SPIR-V as inputs to Compiler Explorer! appeared first on LunarG.