Microsoft dropped a long-awaited tool for game developers on June 18, 2026: a public preview of DirectX Dump Files, a standardized crash format that turns GPU hangs into actionable, replayable debugging sessions inside PIX. The new file type, bearing the extension .dxdmp, captures the full GPU state at the moment of a timeout or device removal event on DirectX 12 systems and presents it as a structured, vendor-agnostic snapshot. Developers no longer need to piece together video memory traces from incomplete TDR logs or rely on GPU-specific crash handlers. Instead, one file and one tool chain the failure directly to the draw call, the shader instruction, or the resource that tipped the pipeline over.
PIX, Microsoft’s performance and debugging utility for Windows games, can now open a .dxdmp file just as it would a capture from a running application. Frames, draw calls, bound resources, and GPU memory become inspectable, even though the original application has already been killed by the driver. In a blog post accompanying the release, the DirectX team emphasized that the dump is designed from the ground up to survive the TDR recovery sequence, slipping the GPU’s execution state into a file before the driver resets the device. That timing has always been the hardest nut to crack.
For years, GPU crashes have been among the most painful bugs to chase in real-time graphics. When a workload runs too long, Windows’ Timeout Detection and Recovery mechanism steps in and resets the display driver, often leaving developers with little more than a generic “device removed” error code and maybe a stack trace that ends somewhere in the DirectX runtime. Figuring out which of ten thousand draw calls hung the hardware meant shipping debug builds with custom GPU crash handlers, instrumenting command lists with markers, or—more commonly—binary-searching the game’s renderer by disabling passes until the crash disappeared. That process could eat days of an engineer’s time per incident.
DirectX Dump Files attack that problem at the driver level. When a GPU command buffer times out, the graphics kernel signals the user-mode driver to dump the contents of the guilty DMA buffer, the page table entries, the bound pipeline state, and—critically—the resource data that was live at the time. All of that gets packed into a single .dxdmp container. On systems with an updated Windows Display Driver Model, the dump can even include shader hash tables so that PIX can retrieve the original HLSL source if symbols are available, making the whole flow from crash to source line seamless.
Opening a .dxdmp in PIX presents a familiar timeline. The developer can scrub to the exact command that was in flight, inspect the inputs and outputs of each shader stage, and walk the resource bindings. Because the file is a self-contained snapshot, no live GPU is required; a programmer can hand a .dxdmp to a colleague on a laptop without a discrete GPU, and that colleague can open it in PIX and start debugging immediately. The DirectX team says this was a deliberate choice: they wanted crash analysis to stop being a hardware-locked activity.
The format arrives at a moment when GPU-driven crashes have become more common across the industry. Larger shaders, long compute dispatches, and cutting-edge features like DirectStorage and GPU work graphs multiply the failure surface. Even well-tested engines can hit timeouts on edge-case hardware combinations or under thermal throttling. Standardizing the dump layer means that crashes encountered by end users in live games can also generate actionable reports—provided the game opts into the crash dump pipeline via a few registry keys and a lightweight runtime component.
Early feedback from developers who tested the preview highlights a few strengths. One, the files are relatively small: a typical .dxdmp for a frame-bound crash lands around tens of megabytes, not hundreds, because the system aggressively discards unreferenced resources. Two, PIX can overlay the dump’s timestamps on its own performance counters, letting developers correlate a hang with a sudden spike in memory pressure or a thermal throttle event. Three, the format is extensible; GPU vendors can add proprietary sections to store additional hardware-specific state without breaking the openable core.
Adoption, however, will depend on how seamlessly the pipeline integrates into existing build systems. Generating a .dxdmp requires the application to call a new API—ID3D12DeviceX::CreateCrashDump or an equivalent—though Microsoft says it is working on a system-wide opt-in that would generate dumps for any DirectX 12 title without code changes. That system-wide mode is not in the June preview but is listed on the roadmap for a later beta drop. For now, developers must explicitly instrument their error handling paths, which might limit the first wave of uptake to large studios that already maintain custom crash telemetry.
Privacy and security demands had to be balanced, and Microsoft’s solution defaults to conservative resource dumping. By default, a .dxdmp does not read back buffer contents from textures or buffers flagged as “sensitive” unless the developer explicitly marks a heap as dump-friendly. This prevents accidental capture of user data—think a video player’s decoded frame or a chat application’s text buffer—from ending up in a diagnostics file that might be transmitted automatically. The dump API also hooks into the Windows Controlled-Folder Access settings, so IT-managed machines can block dump generation entirely if a policy forbids it.
The tooling story is already richer than many expected for a first preview. PIX’s 2026 update ships with a new Crash Analysis workspace that automatically runs common diagnostics on the .dxdmp: it flags command buffer overruns, uninitialized root signatures, and resource binding mismatches before a human even opens the timeline. A one-click export to the Windows Error Reporting backend is available for teams who want to collect dumps from beta testers without building their own ingestion pipeline. Microsoft’s own Xbox Advanced Technology Group is already dogfooding the format on shipping titles that use DirectX 12 on PC and Xbox Series X|S, which hints at eventual console backporting.
The competitive landscape makes the move inevitable. NVIDIA’s Aftermath SDK and AMD’s Radeon GPU Detective already provide GPU crash dumps, but both are vendor-specific and require their own viewer tools. A DirectX 12 app compiled with Aftermath, for instance, produces an .nv-aftermath file that only plays in Nsight Graphics, locking the developer into one hardware family. Microsoft’s .dxdmp ambition is to unify that fragmented space, much as Windows Error Reporting unified kernel and user-mode crash dumps a decade ago. If GPU vendors buy in—and early statements from both NVIDIA and AMD suggest they will—the .dxdmp could become the lingua franca of GPU crash forensics, with GPU vendors adding their own viewer extensions on top of PIX’s baseline.
Performance overhead during capture is another design win. The DirectX team claims that instrumenting an application to generate a .dxdmp on TDR adds less than half a millisecond of CPU time to the post-crash sequence and no measurable GPU overhead because the driver reuses the hung command buffer data that is already present in system memory. That number, verified in the preview on an NVIDIA GeForce RTX 5070 and an AMD Radeon RX 7900 XT, is low enough that developers might ship with dump generation enabled by default in developer builds or even in public betas.
Nevertheless, the .dxdmp is not a cure-all. It captures the state of a single GPU engine at the instant of a crash, but complex hangs that span multiple engines—say a graphics queue waiting on a fence from a compute queue that itself is stuck—require multiple coordinated dumps, and the preview handles only the primary engine. Multi-engine support is another roadmap item. Likewise, the format does not yet support DirectX 11 or DirectX 12 on Windows 10; it is Windows 11-only for the preview, though Microsoft says older OS support is under investigation.
For indie developers and smaller shops, the immediate value is clear: one less custom tool to build. Many small teams never invest in GPU crash telemetry because the engineering cost is too high relative to the number of crash reports they’d receive. A free, standardized dump format paired with a free, fully capable debugger in PIX could suddenly make GPU crash retrieval a checkbox instead of a sprint item. Combined with the recent PIX support for analyzing Shader Model 6.8 experiments and the ongoing DirectSR integration, the developer story on Windows is snapping into a decidedly more developer-friendly shape.
The preview release on June 18, 2026, came with a set of sample projects and a detailed migration guide for teams currently using Aftermath or RGD. Microsoft also published the file format specification under an open protocol license, which means that third-party tools—RenderDoc, for example—could add .dxdmp import support without any legal friction. RenderDoc maintainers have already signaled interest on social media, raising the possibility that a .dxdmp captured from a TDR could later be inspected in Linux-based toolchains too.
Looking ahead, the DirectX team hinted at deeper integration with Visual Studio. A future update will let developers set a breakpoint in their C++ code right at the call that touched the resource that caused the GPU hang, using the .dxdmp’s correlation data to map a GPU instruction pointer back to the application’s source. That level of integration would close the loop from crash to fix in one IDE, a workflow that until now required shuttling data between the game’s error handler, the GPU debugger, and the development environment.
There are loose ends, of course. The format’s reliance on updated graphics drivers means that old, stale driver installations will produce incomplete dumps or none at all, so Microsoft is pushing GPU vendors to backport the required WDDM extensions to their Long-Term Support branches. Enterprise customers running server GPUs in DirectX 12 compute scenarios (think AI inference) are also asking for .dxdmp support on Windows Server, which currently sits outside the preview’s scope.
Still, the arrival of .dxdmp marks a rare moment where a platform owner steps into a pain point that only developers feel and delivers a solution with visible momentum behind it. Microsoft built the format, the SDK, the PIX reader, the error reporting pipeline, and the first set of vendor bridges all at once, which suggests that GPU crash forensics is getting strategic attention inside the Windows division. For the game developer staring down a TDR that happens only on one model of GPU at three in the morning, that attention cannot come too soon.
The public preview is available now through the Windows Insider Dev Channel, with the required SDK bits shipping alongside the June 2026 DirectX Agility SDK. Developers can find documentation on the Microsoft Game Development blog and sample code in the DirectX-Graphics-Samples repository on GitHub. As the preview matures, Microsoft plans to host a series of deep-dive sessions at Game Stack Live, where engineers will walk through real-world crash investigations solved with the new format.