At GDC 2026, we shared our vision for bringing console-level GPU developer tools to Windows, and in June we released the DirectX Dump Files public preview. Thank you to everyone who tried the preview and sent us feedback.
Today, DirectX Dump Files are ready for your retail games. Starting with Agility SDK 1.620 and PIX 2610.28, you can capture GPU crashes on your players’ PCs and on your own machines, then investigate them in PIX using one consistent workflow across hardware vendors.
We couldn’t have done this alone. DirectX Dump Files bring together data from Windows, Direct3D, and each hardware vendor’s driver, and we built them in close collaboration with AMD, Intel, NVIDIA, and Qualcomm. Thank you to all of our hardware partners. Because each vendor provides its own data, what you’ll see varies by hardware vendor and driver version.
Step-by-step guides are on Microsoft Learn, and the full details are in the specification, D3D12: DirectX Dump Files. For everything else in this release, see the Agility SDK 1.620 announcement and the PIX 2610.28 release post.
What’s new since the preview
| What’s new | Details |
|---|---|
| Ready for retail | Use DirectX Dump Files in your shipping game with Agility SDK 1.620. Developer Mode isn’t required. Learn more |
| Final file format | Dump files now use the .dxdmp extension (the preview used .dxdmp_preview). Learn more |
| Retail-friendly defaults | The NO_OVERHEAD dump file driver option is on by default, with no impact on players. Dump files aren’t kept on players’ PCs unless your game retains or uploads them. Learn more |
| Broader hardware support | Driver-backed dump files are rolling out across our hardware partners. See Hardware support. |
| PIX markers in retail dump files | Retail PIX Markers put your PIX markers in dump files. Learn more |
| PIX 2610.28 | Hang bucketing in the Summary view; shaders and resources that help you find the root cause of a crash; and the PIX API, now generally available. Learn more |
| Guides on Microsoft Learn | New guides cover generating and retrieving and analyzing dump files. |
From crash to analysis
How a DirectX Dump File gets from a GPU crash to PIX.
- Generate. When your GPU work stops making progress, DirectX captures a dump file before Windows resets the GPU, so the dump file reflects the GPU’s state at the time of the crash. It includes Direct3D runtime state, hardware and driver data from drivers that support DirectX Dump Files, and up to 2 MB of your own data.
- Retrieve. On your development and QA machines, keep dump files on disk. On players’ PCs, dump files aren’t kept by default, so the dump file end callback tells your game where each one is, and your crash pipeline uploads it. Today, retrieving dump files from players’ PCs is up to your pipeline; we’re working on making it easier.
- Analyze. Open the dump file in PIX on any PC. You don’t need the GPU or driver that crashed, because PIX decodes each vendor’s data with plugins from our hardware partners. PIX also analyzes the dump file for you: it identifies what kind of hang occurred and points you to the shaders and resources involved, so you can fix it faster.
Three scenarios
How much detail you get depends on where your game is running. Higher overhead options capture more data at a higher runtime cost, so you can choose the right balance for each scenario.
Development and QA
When it makes sense: A crash happens on your own machine, or your QA team hits crashes while testing across a range of PC hardware. You don’t need to reproduce it: you get a dump file when a crash happens. Detail matters more than runtime cost here.
What to do: Call the RetainDumpFile API to keep dump files on disk, ready to open in PIX or attach to a bug report. If the driver doesn’t support NO_OVERHEAD, or a NO_OVERHEAD dump file doesn’t have enough data to find the root cause, select MEDIUM_OVERHEAD or HIGH_OVERHEAD with ConfigureDumpFile in your development and QA builds, or with D3DConfig on your own machine without changing code. Learn more
Everyday retail play
When it makes sense: Your game has shipped. You don’t want to affect your players’ experience, but if the GPU crashes, you want data you can act on.
What to do: The NO_OVERHEAD dump file driver option is on by default, with no code changes and no impact on players. Drivers that don’t support it ignore it, and you still get a dump file with Direct3D runtime context and your application’s data. To make each dump file useful, add context such as your build ID or current level with AddBlobToDumpFile, and use the dump file end callback to upload the dump file through your crash pipeline. Learn more
Chasing a rare retail crash
When it makes sense: A crash keeps showing up on players’ PCs, you can’t reproduce it, and the default dump files don’t tell you enough to fix it.
What to do: On a few players’ PCs, turn on MEDIUM_OVERHEAD or HIGH_OVERHEAD with ConfigureDumpFile, for example with a command-line argument or a setting your game checks at startup. Higher overhead can lower frame rates or use more memory, so keep it to a session or two, upload the dump files through your crash pipeline, and then turn it back off. Learn more
Get started
Here’s what you need and what to do at each stage. The Learn more links go to the step-by-step guides.
| Stage | What you need | What to do |
|---|---|---|
| 1. Generate On the PC that crashes |
Windows 11, version 24H2 or 25H2, build 26100.8524 or 26200.8524 or later (KB5089573) Agility SDK 1.620 or later Any GPU driver. Supported drivers add hardware state and driver data; see Hardware support. Developer Mode isn’t required. |
DirectX generates a dump file when a crash happens, even if you skip these optional steps. They let you check support, choose how much data to capture, and add your own data. 1. Check support with CheckFeatureSupport (D3D12_FEATURE_DUMP_FILE).2. Choose an overhead option with ConfigureDumpFile.3. Register begin and end callbacks with SetDumpFileCallbacks, and add your own data with AddBlobToDumpFile.On your development machine, D3DConfig can override these settings without code changes. Learn more: D3D12: DirectX Dump Files spec · Learn guide |
| 2. Retrieve Locally or through your pipeline |
Development and QA: no extra setup Players’ PCs: a crash pipeline that can upload files |
Development and QA: call the RetainDumpFile API, or use D3DConfig, to keep dump files in %LOCALAPPDATA%\CrashDumps.Players’ PCs: in the dump file end callback, get the dump file’s path and upload it with your other crash data. Learn more: Learn guide |
| 3. Analyze On any PC |
PIX 2610.28 or later. You don’t need the GPU or driver that crashed. | 1. Set your shader object and PDB search paths in PIX. 2. Open the .dxdmp file and start with the Summary view, and inspect information populated in other views.3. Go further with the PIX API or AI agents. Learn more: Learn guide · PIX API samples |
Hardware support
| IHV | Supported GPUs | Overhead options | PIX plugin | PIX markers in dump files |
|---|---|---|---|---|
| AMD | Radeon RX 9000 Series and Radeon RX 7000 Series | MEDIUM_OVERHEAD, HIGH_OVERHEAD | Included in PIX 2610.28 | Yes |
| Intel | Coming soon | Coming soon | Coming soon | Coming soon |
| NVIDIA | NVIDIA Turing and newer, with R620 or later drivers | NO_OVERHEAD, MEDIUM_OVERHEAD, HIGH_OVERHEAD | Included in PIX 2610.28 | Yes |
| Qualcomm | Snapdragon X2 platform | Coming soon | Coming soon | Coming soon |
Dump files from any GPU include Direct3D runtime context and your application’s data. NO_OVERHEAD is suitable for regular gameplay, with no impact on players; MEDIUM_OVERHEAD and HIGH_OVERHEAD capture more data at a higher runtime cost. Each hardware vendor shares which of its drivers support DirectX Dump Files. For more information, contact your hardware vendor’s developer relations representative.
What you’ll see in PIX
PIX uses the same views for dump files from every hardware vendor, but what each view can show depends on the data that vendor’s driver and PIX plugin provide. Views marked with an asterisk (*) depend on hardware vendor support. For screenshots and details of each view, see the PIX 2610.28 release post.
| View | What it shows |
|---|---|
| Summary | Hang buckets, possible causes of the crash, and related information |
| Events * | Driver events and PIX markers, with execution status, from the plugin; otherwise DRED breadcrumbs and PIX markers |
| Page Faults * | Faulting GPU addresses and the resources that covered them from the plugin; otherwise the faulting address and allocations from DRED, if page fault reporting is on |
| Resources * | Resource details from the D3D12 runtime, plus extra properties and lifetime events from the plugin when available |
| Shader Waves * | Executing shader waves, with lanes, stage, exceptions, and the current instruction |
| Shaders * | DXIL, HLSL, and ISA support for executing shaders |
| Shader Autos * | Shader registers for a selected wave and lane |
| D3D12 API Objects | Command queues, command allocators, and other runtime objects |
| Application Blobs | The data your app added with AddBlobToDumpFile |
| File Details | Driver, adapter, device, OS, and application details |
* Depends on hardware vendor support.
Go further
- Put your PIX markers in dump files. By default, PIX markers don’t reach the GPU driver, so they aren’t in dump files. Turn on Retail PIX Markers and they show up in your dump files, so you can see where the GPU was in your frame when it crashed. See D3D12: PIX Markers.
- Automate analysis with the PIX API. The PIX API is now generally available and installs with PIX 2610.28, so you can analyze dump files at scale. See the PIX API documentation and samples.
- Analyze with AI agents. PIX 2610.28 includes the DxDmp command-line tools and an MCP server for AI-assisted analysis. Learn more
Known issues
- Data varies by hardware vendor. If the data in a dump file does not help you root cause the crash, let us know and ask your hardware vendor’s developer relations contact to add it.
- Software device removals, as opposed to TDRs, don’t generate a dump file yet. Support is planned for a future release.
What’s next
- More data from our hardware partners, added to their dump files and shown through their PIX plugins over time.
- Easier uploads of dump files from your players’ PCs.
- More hardware support as drivers and PIX plugins roll out. We’ll update this post as support lands.
- DebugBreak(), which lets a shader trigger a dump file on purpose, coming with Shader Model 6.10 in a retail Agility SDK soon.
Tell us what you think
Tell us what’s working, what isn’t, and what you’d like to see next in the #dxdmp channel on the DirectX Discord, with Help > Send Feedback in PIX, or at dxdmpsupport@microsoft.com.
0 comments
Be the first to start the discussion.