Same Game Crashes on DX12 but Runs Fine on DX11? API Path, Shader Compilation & Feature Level Diagnosis

Key Takeaways
A game can crash on DirectX 12 and run on DirectX 11 because the two paths place different demands on the engine and the driver. DirectX 12 gives the engine more control and less protection, so shader compilation, pipeline setup, feature levels and driver maturity can all turn into a crash. This guide explains why and works through the diagnosis.
The Symptom This Guide Is About
This guide covers one specific failure: the same game, on the same machine, with the same driver version, crashes when it runs in DirectX 12 mode — closing to the desktop, showing an error dialog, or going black and needing to be closed — and runs steadily when switched to DirectX 11 mode. That comparison is itself the most important piece of diagnostic evidence in the whole guide: the problem follows the API path, not the hardware.
Three features define this symptom, and they should be established before anything is changed:
- It must be the same game. Different games crashing cannot be compared. The comparison only means something when it is the same game, the same scene, and the same set of graphics settings, with only the API changed.
- A crash is not slowness. Low frame rate, stutter, and hitching under DirectX 12 are a performance question — which API runs faster — not this problem. This guide is about the program ending or showing an error, not about it running slowly.
- It is not a failure to start. A game that shows an error such as "Failed to initialize Direct3D" the moment it is launched, before a single frame is drawn, has failed to create the graphics device at all. This guide is about a device that is created successfully and then fails partway through a session. The device is obtained, and only afterwards does it fail. That boundary is the dividing line between this guide and the initialization guide.
Several neighbouring symptoms are easy to confuse with this one, and each belongs elsewhere:
- A single game that crashes while other games run normally, without any API distinction, is a single-game crash problem involving shader caches, game files, or individual settings.
- An error dialog naming DXGI_ERROR_DEVICE_REMOVED or DEVICE_HUNG is the subject of the dedicated device-removal guide. This guide only explains what those codes mean when they appear; it does not reproduce that guide's decision tree.
- A driver that stops responding and recovers, with the picture going black and then returning, is a driver timeout recovery event.
- A blue screen with a stop code is a system-level failure, not a game ending while the desktop stays up.
Why DirectX 12 Can Crash While DirectX 11 Does Not
This section is the heart of the guide. "DirectX 12 is newer, so it is less stable" is a surface sentence, not an explanation. The real reason is that the two APIs are two different contracts between the game engine and the driver, and the DirectX 12 contract leaves far more room for a fault to become a crash.
Two Contracts: the Driver Does the Work, or the Engine Does the Work
DirectX 11 is a driver-led model. The driver validates state, manages resource transitions, and handles most of the bookkeeping. When the engine makes a mistake, the driver often absorbs it, corrects it, or produces a polite error message. DirectX 12 and Vulkan are low-level models: the engine must submit commands in parallel itself, manage the lifetime of its own resources, and handle synchronization itself. The principle has already been stated in the guide on choosing between APIs: mistakes show up as stutter, incorrect rendering, or crashes rather than as a polite error message. That principle is the mechanism of this whole guide. On the DirectX 11 path, the driver stands between the engine and the crash. On the DirectX 12 path, nobody stands there, so a flaw in the engine's DirectX 12 implementation, or in the driver's DirectX 12 path itself, turns directly into a crash.
Pipeline State Objects and Shader Compilation
DirectX 12 requires the game to build pipeline state objects, or PSOs — combinations that bind a shader, a render state, and a resource layout together. The first time a game enters a new scene under a given API, or encounters a new combination of materials and effects, it must compile shaders and build the matching pipeline on the spot. That process is far more involved under DirectX 12 than under DirectX 11, for three reasons:
- The shader format is different: DirectX 12 uses DXIL, while DirectX 11 uses DXBC, so the same shader code can compile to different results on the two paths.
- The engine must pre-build a PSO for every pipeline combination, and if that cache is damaged or incomplete, the game can crash when it loads a new scene, rather than merely stuttering.
- Public engine cases show the pattern in concrete terms. In Unreal Engine 5 games, PSO setup, Nanite, and anti-aliasing can compete for resources during loading under DirectX 12 and bring the game down, while the same game runs without trouble under DirectX 11, with error logs mentioning shader permutation precaching. That case is a mechanism example only — it does not mean Unreal Engine games always behave this way. It is evidence that individual engines have this class of problem on the DirectX 12 path, nothing more.
The division of labour with the neighbouring guides matters here. The shader compilation guide is about stutter on first run, and the API choice guide is about stutter in the first few minutes while the cache is being built. Both are about slowness. This guide is about compilation and pipeline setup failing and causing a crash. The symptom is different, and the stutter material must not be carried across and presented as crash evidence.
A Feature Level Is Not the Same Thing as a DirectX Version Number
This is the most common misunderstanding in this area, and it needs its own section.
- The DirectX version number — for example, DirectX 12 built into Windows 11 — describes how new the runtime installed on the system is.
- The feature level — for example, 11_0, 12_0, 12_1, or 12_2 — describes which graphics features this particular card, with this particular driver, can actually provide. The same model with a different driver version can report a different level, so the level must never be guessed from the model name. It must be read from the list dxdiag shows on the Display page. The dxdiag list is the evidence. The rest of the initialization investigation is a separate subject and is not repeated here.
Some newer games, particularly Unreal Engine 5 titles, ask for more than basic DirectX 12. They may require feature level 12_0 or 12_1, Shader Model 6.x, mesh shaders, or hardware ray tracing support. An older card may technically support part of DirectX 12 but be unable to provide the level or feature the game asks for, so the game crashes in DirectX 12 mode and runs normally in DirectX 11 mode — because DirectX 11 mode never asks for those features at all. The DirectX 12 Ultimate features behind this — feature levels 12_1 and 12_2, mesh shaders, sampler feedback, and variable rate shading — have never been covered anywhere else on this site, and they are new material for this guide. Even so, there is no table of which models support which level here — the dxdiag list on the machine in question is the only authority.
The Driver's DirectX 12 Path Has Its Own Maturity
Inside a single driver version, the DirectX 11 path and the DirectX 12 path are two different bodies of code. The DirectX 11 path has been refined for well over a decade, with a large space for driver optimization and a high level of maturity. The DirectX 12 path is newer, and its behaviour depends on how well the engine and the driver have been tuned against each other. The consequences follow directly:
- A flaw in one driver version's DirectX 12 path will only show up in DirectX 12 games, while DirectX 11 games on the same machine run perfectly.
- A crash that begins only after a game update or a driver update is timeline evidence specific to the DirectX 12 path. The question of whether to blame the driver or the game side first after an update has been covered before for single-game crashes; this guide applies the same timeline logic, focused on the API path.
One rule applies without exception: driver versions may only be recorded as timeline evidence. Readers must not be told to roll back to an older driver version. Recording which version the crash began with is a diagnostic comparison, not a repair instruction.
Multithreaded Submission and Synchronization Errors
DirectX 12 allows the engine to submit commands in parallel, which is part of why it can be faster, and also part of why it is fragile. Resource lifetimes, synchronization barriers, and descriptor heap management are all the engine's responsibility. When the engine gets one of those wrong, there is no polite error. The result is an invalid memory access, a device removal, or a trigger of the Windows timeout detection that resets the driver after about two seconds. That two-second figure is the documented timeout detection behaviour, and it should be stated plainly without teaching readers to read driver code.
The point of this section can be put in one sentence: DirectX 12 hands more responsibility to the game engine, so it is entirely reasonable for one game's DirectX 12 implementation to have a flaw while its DirectX 11 implementation works. The crash does not mean the hardware is broken. It means the less protected path has exposed a flaw that the more protected path was absorbing.
The Diagnostic Flow, in Order
Work through these steps in order, and change only one variable at a time. Each step narrows the range of possible causes, and the order matters: the later steps only mean something because the earlier steps established the pattern first.
| Step | What to do | How to read the result |
|---|---|---|
| 0 | Write down the complete error message, the API in use, the scene, how often it happens, and what changed before it first appeared | A message naming D3D11 or D3D12, a feature level, or a reason code such as HUNG, RESET, or DRIVER_INTERNAL_ERROR is first-hand evidence; even a message with no detail is a signal worth recording |
| 1 | API isolation: same scene, same graphics settings, only the API changed from DirectX 12 to DirectX 11, repeated several times | DirectX 11 stable and DirectX 12 crashing means the problem follows the API path, so continue; DirectX 11 crashing too means it is not an API-path problem, so leave this guide |
| 2 | Run dxdiag and read the feature level list | A required level missing from the list points at the feature level layer, and the next question is the driver version or the hardware capability, not the game settings; a level present in the list excludes this layer |
| 3 | Clear the game's shader cache and the driver's shader cache, then let the DirectX 12 path rebuild it, running a complete pass under each API before comparing | Stable after clearing points at the cache layer; still crashing means it is not the cache |
| 4 | Timeline comparison: which update came first — driver, game, or Windows — before the crash began? | A crash that began after a driver update means recording the version that crashes and comparing it with the version before; a crash that began after a game update means checking the game's official known issues; a crash present from the start means trying the latest stable driver |
| 5 | Display mode comparison: exclusive full screen against borderless windowed mode | Crashing only in exclusive full screen points at the full-screen optimization and desktop composition branch; crashing in both modes means it is not the display mode |
| 6 | Monitor dedicated video memory usage as a trend over time, not as a single number | Crashing only as usage approaches the top points at the memory allocation layer; crashing at low usage means it is not memory |
| 7 | If still crashing, record the error message, the API comparison result, the dxdiag level list, the driver and game versions, and which steps were tried, and take that record to an inspection | Do not keep changing settings at random; if visual artifacts or whole-system symptoms appear as well, the direction changes |
Step 1: The API Switch as a Controlled Test
Change only the API, from DirectX 12 to DirectX 11, keeping the scene and the graphics settings identical, and repeat the run several times under each. Changing only one variable at a time is what makes the comparison valid. If DirectX 11 is stable and DirectX 12 crashes, the problem follows the API path, and the rest of this guide applies. If DirectX 11 crashes as well, the fault is not specific to the API path, and the investigation belongs with single-game crashes, device removal, or driver timeout recovery instead. Note that switching to DirectX 11 is a diagnostic isolation and a temporary workaround, not a repair. The underlying cause — a driver DirectX 12 path flaw, a game DirectX 12 implementation problem, a damaged cache, or an insufficient feature level — is still unresolved, only bypassed.
Step 2: The Feature Level List in dxdiag
Run dxdiag, open the Display page, and read the list of feature levels the installed device provides. Compare that list with the level the game requires, if the game's system requirements or the error message state one. If the required level is absent, the device as currently configured cannot provide it, and the next question is whether a different driver version changes the list or whether the hardware itself does not provide that level. Never guess the level from the model name. If the required level is present, the feature level layer is excluded, and the investigation moves on.
Step 3: Clearing the Shader Cache
Clear the game's shader cache and the driver's shader cache, then let the DirectX 12 path rebuild them, running a complete pass under each API before comparing the two. If DirectX 12 is stable after the rebuild, the cache layer is confirmed. If it still crashes, the cache is excluded. One warning matters: after clearing a cache, the first entry into a scene will stutter while the cache is rebuilt. That stutter is normal rebuilding, and it must not be mistaken for the crash being unfixed. Compare only after the cache has been built — a complete pass under each API first.
Step 4: The Timeline Comparison
Write down the driver version, the game version, and the Windows version, and work out which one changed just before the crash first appeared. A crash that began after a driver update means recording the crashing version and comparing it against the version in place before the update — recording, not rolling back. A crash that began after a game update means checking the game's official known issues. A crash that has been present since the game was first installed means trying the latest stable driver version is reasonable. The criterion is timing, not newness: the newest driver is not automatically the best driver for a particular game.
Step 5: Display Mode as a Variable
Compare exclusive full-screen mode with borderless windowed mode. Crashing only in exclusive full screen points at the full-screen optimization and desktop composition branch. There are public reports linking that branch to crashes, but the evidence is weak, so treat it as a comparison, not as an established cause. Crashing in both modes excludes the display mode.
Step 6: Video Memory Pressure as a Trend
Monitor dedicated video memory usage while the game runs, watching the trend over time rather than a single number. If the crash happens only as usage approaches the top under DirectX 12, the memory allocation layer is implicated — an allocation failure can bring a game down, and genuinely running out of memory is different from merely using a lot of it. If the game crashes while usage is low, memory is excluded.
Step 7: Stop Changing Settings and Record the Evidence
If every step has been tried and DirectX 12 still crashes, further random changes will not help. Write down the error message, the API comparison result, the dxdiag level list, the driver and game versions, and which steps were tried and what each one showed. That record is what an inspection needs to start from the narrowed-down layer instead of from the beginning. If visual artifacts or whole-system symptoms appear alongside the crash, the direction changes toward hardware and driver recovery investigation instead.
How This Relates to Device Removal Errors, Driver Timeouts, and Blue Screens
Three related failures are often confused with this one, and each needs a clear dividing line.
- DXGI_ERROR_DEVICE_REMOVED and DEVICE_HUNG. These are the error dialogs a game shows, and underneath them can sit the same event: the graphics processor hanging and Windows resetting the driver. The dedicated device-removal guide has already explained the six reason codes: HUNG tends to point at the game sending invalid commands, DRIVER_INTERNAL_ERROR tends to point at the driver itself, and a message with no reason code most often follows a driver upgrade, a dual-GPU switch, or a driver timeout reset. The reason-code table is included here only so that readers write the reason code down. The full decision tree is not repeated here.
- Driver timeout recovery. Windows timeout detection watches the graphics processor and resets the driver after about two seconds without a response, and the user sees the picture return with a message that the driver stopped responding and has recovered. A DirectX 12 crash is sometimes a timeout reset that the game cannot survive: the device is rebuilt, and the game fails during that rebuild. One survives the reset and the other does not — that is the dividing line. The timeout mechanism itself belongs to the driver recovery guides, and it is mentioned here only at the point where the investigation branches.
- Blue screens. A blue screen, such as VIDEO_TDR_FAILURE, is a system-level failure: the whole machine stops. An error dialog is a game ending while the system and the desktop stay up. The severity and the direction of investigation are different, and blue screen stop codes should not be taught inside this guide.
Common Misconceptions
| Misconception | Correction |
|---|---|
| "DirectX 12 is always faster than DirectX 11." | Wrong. The newer architecture offers the possibility of reducing the processor's workload, but whether it is actually faster depends on how well the engine is written, how well the driver is tuned, and whether the scene suits it. A mature DirectX 11 path is sometimes the more stable one. |
| "Switching back to DirectX 11 means it is fixed." | Wrong. Switching APIs is only diagnostic isolation. It proves the problem follows the API path; the underlying cause is still unresolved, only bypassed. It should be described as a comparison test and a temporary workaround, never as a repair step. |
| "The newest driver is always the best driver for this game." | Wrong. Use timing as the criterion: if the crash began after a driver update, record the versions and compare; if the crash has been present all along, trying the latest stable version is reasonable. Newest and best are not the same thing. |
| "A new DirectX 12 version number means the features are all there." | Wrong. The version number is not the feature level. The feature level must be read from the dxdiag list on the machine in question. |
| "Clearing the shader cache will definitely fix it." | Wrong. The cache is only one layer. After clearing, the first entry into a scene will stutter while the cache rebuilds, and that stutter is normal, not evidence that the crash is unfixed. |
| "A DirectX 12 crash means the graphics card is broken." | Wrong. Hardware faults in the core, the memory, the power delivery, or the cooling do not usually single out one API path so politely. If the same workload is completely stable in DirectX 11 mode, the hardware should move down the suspect list, not to the top of it. |
Boundaries: What This Is Not
Several neighbouring problems look similar at first glance. Each one is a different mechanism.
- Ray tracing and upscaling switched on. Ray tracing and upscaling features appear only on the DirectX 12 path or the Vulkan path, so they belong to the same API family. If the crash only appears after one of those features is switched on, that is a feature-switch layer, not the API layer itself, and it is noted here as a branch only. The mechanism of those features is not expanded here.
- Vulkan crashing too. If the game also offers Vulkan and Vulkan crashes while DirectX 11 does not, the evidence points at a shared property of the low-level API family — an engine implementation problem on the low-level paths — rather than at something unique to DirectX 12. Don't conclude it's a DirectX 12-only problem.
- Older games. The DirectX 12 modes of older games, where they exist, and older API compatibility problems belong to the older-games guide. This guide is only about modern games with both DirectX 11 and DirectX 12 paths.
- Several games crashing on DirectX 12. If more than one game fails, the scope is no longer a single game, and the investigation moves to cross-game and driver diagnosis instead of staying here.
- A game that never starts. A game that fails before the first frame is drawn has failed to create its device, and that is the initialization guide's subject. This guide is about a device that is created and then fails.
- A single game crashing with no API distinction. A crash that follows the game rather than the API belongs to the single-game crash guide, where the scope itself — one game only — is already a diagnostic signal. The diagnostic method of restoring defaults and adding settings back one at a time is shared with that guide.
What to Do With the Result
If the diagnostic flow identifies the layer — a feature level the device cannot provide, a damaged shader cache rebuilt by clearing it, a timeline that points at a particular driver or game version, a display mode that only fails in exclusive full screen, or a memory allocation pattern that only appears under DirectX 12 — the result should be recorded with the same care as the original error: which step changed the outcome, which driver and game versions are now installed, and which feature levels dxdiag now reports. That record makes the result repeatable, and it is what an inspection needs if the problem returns.
If every step has been worked through and DirectX 12 still crashes, and especially if visual artifacts appear or other 3D programs fail as well, the problem has gone beyond what settings can isolate. The next step is a professional inspection, carried out with the card in the machine. Bring the written record — the complete error message, the API comparison result, the dxdiag feature level list, the driver and game versions, and which steps changed the outcome — because that record lets an inspection start from the layer the tests have already narrowed down, instead of from the beginning. A problem that clearly follows the API path while DirectX 11 mode is stable is a driver-path or game-implementation matter, not a hardware matter, and an inspection cannot change a driver DirectX 12 path or a game's DirectX 12 implementation; it can only confirm that the hardware itself is sound.
HK GPU Fix offers a diagnostic inspection at its Shek Mun shop: Room 1209, Dali Plaza, Shek Mun. The published inspection fee range is HK$400–2,800 in total, and the actual price is subject to a post-inspection quotation. Phone 2186 8010, WhatsApp 6558 6806. There is no on-site service; inspection is carried out at the shop.
Frequently Asked Questions
The game crashes on DirectX 12 but runs fine on DirectX 11. Does that mean my graphics card is dying?
No. Hardware faults do not usually single out one API path so politely. If the same workload is completely stable in DirectX 11 mode, the hardware should move down the suspect list. The problem follows the API path, which points at the engine's DirectX 12 implementation, the driver's DirectX 12 path, the shader cache, or the feature level.
What is a feature level, and why does it matter more than the DirectX version number?
A feature level, such as 11_0 or 12_0, describes which set of graphics features a particular device can provide. The DirectX version number describes the core runtime installed on the system. A game asks for a feature level when it creates its device, and if the device cannot provide that level, the game cannot use the DirectX 12 path properly. The feature levels a device provides are listed on the Display page of dxdiag, and that list must be read from the machine itself, never guessed from the model name.
The game crashes only when it loads a new area. Could that be the shader cache?
Yes, it is a real possibility. DirectX 12 builds pipeline state objects when it first encounters a new scene or a new combination of materials and effects, and a damaged or incomplete cache can turn that first encounter into a crash rather than a stutter. Clear the game's shader cache and the driver's shader cache, then let the DirectX 12 path rebuild them, running a complete pass under each API before comparing. The first entry into a scene after clearing will stutter while the cache rebuilds; that is normal.
I switched back to DirectX 11 and the game works. Is that the fix?
No. Switching APIs is diagnostic isolation and a temporary workaround. It proves the problem follows the API path, but the underlying cause — a driver DirectX 12 path flaw, a game DirectX 12 implementation problem, a damaged cache, or an insufficient feature level — is still there, only bypassed.
The crash started right after a driver update. Should I go back to the old driver?
Record the versions and compare them, but do not treat going back as a repair step. Write down the driver version that crashes and the version that was in place before the update, and keep that timeline as evidence. If the crash has been present since the game was first installed, trying the latest stable driver version is reasonable.
The error dialog says DXGI_ERROR_DEVICE_REMOVED. What does that mean?
It means the graphics device was lost during play, and the game could not continue. The reason code in the message matters: HUNG tends to point at the game sending invalid commands, DRIVER_INTERNAL_ERROR tends to point at the driver itself, and a message with no reason code most often follows a driver upgrade, a dual-GPU switch, or a driver timeout reset. Write the full message down, including the reason code, before changing anything.
The screen goes black for a moment and then comes back, and the game keeps running. Is that the same thing?
No. That is a driver timeout recovery: Windows detected that the graphics processor had not responded for about two seconds, reset the driver, and the picture returned. A DirectX 12 crash is sometimes a timeout reset that the game cannot survive, so the game ends instead of recovering. One survives the reset and the other does not.
My game also offers Vulkan, and Vulkan crashes too. What does that tell me?
It points at a shared property of the low-level API family rather than at something unique to DirectX 12. Both DirectX 12 and Vulkan hand the engine more responsibility and less protection than DirectX 11, so an engine implementation problem on the low-level paths would show up on both. Don't conclude it's a DirectX 12-only problem.
The crash only happens with ray tracing switched on. Is that still an API problem?
It is a branch of the same family. Ray tracing appears only on the DirectX 12 or Vulkan path, so if the crash only appears after that feature is switched on, the fault sits in the feature-switch layer rather than in the API layer itself. That distinction matters, because the settings to compare are different.
Every step has been tried and DirectX 12 still crashes. What now?
Stop changing settings and take the written record to an inspection: the complete error message, the API comparison result, the dxdiag feature level list, the driver and game versions, and which steps changed the outcome. If visual artifacts appear, or other 3D programs fail as well, say so, because that changes the direction of the investigation toward the hardware itself.