Microsoft shipped a public preview of DirectX Dump Files on June 18, 2026, a move that could reshape how game developers diagnose GPU crashes on Windows. The feature, accessible today through Microsoft's PIX for Windows tool, delivers a standardized binary format for preserving the full DirectX state at the moment a graphics device is removed. AMD has already stepped forward as the first GPU vendor to publicly adopt the format, signaling an industry push toward a unified crash analysis pipeline.

Graphics programming has long suffered from a black-box problem when a device is lost. "Device removed" errors—those dreaded DXGI_ERROR_DEVICE_REMOVED and DXGI_ERROR_DEVICE_HUNG codes—often leave developers with little more than a vague error code and a heap of frustration. The new DirectX Dump File aims to change that by capturing a snapshot that mimics the familiar Windows minidump, but for the GPU.

What DirectX Dump Files actually are

A DirectX Dump File is a portable, self-contained binary artifact that records the state of the Direct3D device, command lists, pipeline state objects, heaps, and other GPU resources at the instant of a crash. It draws inspiration from the crash dumps that have been a mainstay of CPU debugging for decades, but tailors the format to the specific needs of graphics developers. The result is a file that can be loaded back into PIX for offline analysis, letting developers replay the fatal frame, inspect resource contents, and trace the exact draw call or compute dispatch that triggered the device removal.

Under the hood, the dump captures everything the driver and the Direct3D runtime can report: outstanding command list pointers, descriptor heaps, root signature bindings, and even the raw memory of selected resources. Crucially, it does not require special capture hardware or invasive debug layers to be enabled ahead of time. The runtime itself generates the dump when a device removal is detected, providing a true crash-time record rather than a pre-recorded trace.

How developers can put the preview to work

Accessing the preview requires the latest version of PIX for Windows, available from the Microsoft Store or the Windows Developer Center. Once installed, developers need to enable the feature through the DirectX Dump File preview flag in PIX's settings. After that, any Direct3D 12 application that hits a device removal will automatically write a .dxdmp file to a configurable output location.

The workflow is straightforward:

  • Reproduce the crash in a test environment.
  • Locate the newly generated .dxdmp file.
  • Open it in PIX, which presents a timeline of the frame leading up to the crash.
  • Inspect the state of each command list, including resource barriers, pipeline bindings, and constant buffer contents.
  • Use PIX's shader debugger to step through the instructions that were in flight when the device was lost.

Because the dump file is self-contained, it can be shared across team members without requiring the original executable, assets, or even the same GPU driver version—a massive boon for bug reports that often get lost in translation between testers and engineers.

AMD leads the pack with first vendor support

Microsoft's announcement makes it clear that the DirectX Dump File format is intended to be vendor-neutral, but AMD has become the first hardware partner to publicly confirm support. In a series of driver previews aligned with the PIX release, AMD's Radeon software now includes the necessary driver-side hooks to populate dump files with additional hardware-specific telemetry. This includes wavefront occupancy, cache hit rates, and memory controller statistics—data points that go well beyond the generic Direct3D state.

NVIDIA and Intel have not yet announced their own implementations, but Microsoft indicated that the architecture was designed in collaboration with all major IHVs. The company expects other vendors to follow suit once they have validated the reliability of the dump capture on their hardware.

Why this matters for the Windows gaming ecosystem

The economic impact of GPU crashes on game development is rarely discussed outside of engineering meetings, but it is vast. A complex title can ship with hundreds of crash signatures, many of which are nondeterministic and take weeks to reproduce. The DirectX Dump File promises to compress that cycle from days to hours. QA teams can attach a .dxdmp file to every bug report, giving developers an immediate, precise snapshot of the failure. Indie studios, who often lack the resources to build bespoke crash capture systems, gain access to a free, built-in tool that plugs directly into their existing PIX workflows.

For Microsoft, solving this problem strengthens Windows' position as the premier game development platform. While consoles like Xbox already benefit from deep hardware integration that eases crash analysis, the PC's open ecosystem has always made equivalent fidelity hard to achieve. DirectX Dump Files narrow that gap, bringing console-like debugging to any Direct3D 12 title on Windows 10 and Windows 11.

A closer look at the dump format

Technical documentation published alongside the preview reveals a design that prioritizes extensibility and compatibility. The .dxdmp container is essentially a ZIP archive containing a set of binary blobs and metadata. A manifest file describes the Direct3D objects captured, their sizes, and any driver-specific annotations. The core dump data adheres to the D3D12 serialization conventions already used by PIX for GPU captures, meaning that existing tooling can read the files without major rework.

Some highlights from the specification:

  • Resource snapshots: Optionally, the dump can include the actual contents of textures and buffers up to a configurable size limit, preserving the visual state at crash time.
  • Marker and event data: If the application uses PIX event markers or WinPixEventRuntime, those annotations are carried into the dump, providing human-readable labels for each draw call.
  • Driver extensions: Vendors can embed custom blobs with hardware performance counters, shader ISA dumps, or memory controller logs. AMD's initial extensions, for instance, include a graph of GPU memory pressure leading up to the crash.
  • Repro instructions: The manifest stores the driver version, OS build, and GPU SKU, allowing PIX to seamlessly request a compatible driver when replaying the dump on a different machine.

Microsoft has stressed that the format is still under active development, and the preview may see breaking changes before general availability. Developers are encouraged to experiment and provide feedback through the PIX repository on GitHub.

How it fits into the broader GPU debugging landscape

DirectX Dump Files are not the first attempt at GPU crash diagnostics. DRED (Device Removed Extended Data), introduced with Windows 10 version 1809, already provides automatic breadcrumb trails and pipeline state snapshots. NVIDIA's Nsight Graphics and AMD's Radeon GPU Profiler offer deep capture and replay functionality. However, those solutions either require explicit initialization, produce proprietary formats, or both.

The key differentiator is that DirectX Dump Files are generated automatically by the runtime, require zero code changes (provided the application is built with Direct3D 12), and produce an openly documented file format. This shifts the burden of crash capture from the developer to the platform, aligning with Microsoft's broader "built-in diagnostics" philosophy seen elsewhere in Windows Error Reporting and Windows Performance Recorder.

Real-world impact: from crash to fix in minutes

Imagine a scenario that has played out in countless game studios: a tester reports a visual corruption followed by a crash to desktop on a specific AMD Radeon GPU. The bug report includes a blurry cellphone screenshot and a one-line description. The developer spends two days attempting to reproduce the fault on a different GPU, finally realizing the crash only occurs when ray tracing is enabled while the GPU is running at high temperatures.

With DirectX Dump Files, the tester simply grabs the .dxdmp file from the output directory and attaches it to the bug. The developer opens the file in PIX, immediately sees that the crash occurred during a ray tracing dispatch, inspects the shader state, and notices a null descriptor that slipped through validation. A fix is committed within the hour.

This accelerated feedback loop is precisely what Microsoft is targeting. As game rendering becomes more complex—embracing mesh shaders, DirectStorage, and hybrid ray tracing—the number of edges cases where drivers can stumble grows exponentially. Structured crash data turns that complexity from a liability into a manageable engineering challenge.

Community reaction and expectations

In developer forums and social media, the preview has been met with cautious optimism. Many seasoned graphics engineers point out that the usefulness of a dump file is only as good as the tooling that reads it, and that PIX, while powerful, has historically been Xbox-first. Others worry about the performance overhead of automatic dump generation, though Microsoft claims the cost is negligible until a crash actually occurs.

AMD's early adoption has also drawn mixed reactions. Some developers welcome the extra hardware counter data, but independent coders note that the feature could widen the gap between first-class and second-class GPU support if other vendors lag. For the moment, however, the baseline Direct3D 12 dump is fully functional on any vendor's driver, even without vendor extensions.

What comes next

Microsoft's roadmap signals that DirectX Dump Files will eventually be integrated into the Windows Error Reporting pipeline, allowing automatic collection and cloud upload of crash dumps from end users who opt in. That would provide developers with telemetry on crashes that occur in the wild, not just in the test lab—a capability that has long been a holy grail for PC game support.

On the PIX side, future updates will add comparison views that highlight differences between a working frame and a crashing frame from the same session, as well as AI-powered analysis that suggests likely causes based on the captured state. The team is also exploring a web-based viewer that would let developers share dumps without requiring a full PIX installation.

For now, the public preview marks a concrete step toward a world where GPU crashes are no longer opaque mysteries. Developers can download PIX from the Microsoft Store, enable the preview, and start generating their own DirectX Dump Files today.