GPU Blue Screen But Not TDR? VIDEO_SCHEDULER_INTERNAL_ERROR, VIDEO_MEMORY_MANAGEMENT_INTERNAL & VIDEO_DXGKRNL_FATAL_ERROR Diagnosis Guide

Key Takeaways
A blue screen is not always a TDR failure. The stop code names the subsystem that detected an inconsistency: the video scheduler, the video memory manager, the DirectX graphics kernel, or a system thread. Read the code, check Event ID 1001, then test one variable at a time. The code narrows the search; it does not name the faulty part.
What a Stop Code Actually Tells You
When Windows meets a kernel error it cannot safely continue from, it triggers a bug check — the blue screen — and displays a stop code such as `VIDEO_SCHEDULER_INTERNAL_ERROR`, together with four parameters. The most important idea in this guide is also the most commonly misunderstood: the stop code tells you which subsystem detected a fatal inconsistency. It does not tell you which part is broken.
The department that reports a problem is not necessarily the department that caused it. If a warehouse finds its stock records do not match the shelves, that does not prove the warehouse staff stole anything — the delivery note could be wrong, the system could be wrong, or someone could have altered the figures. In the same way, when the video scheduler reports a fatal violation, the scheduler itself may be the victim of bad data from a driver, corrupted memory, or a hardware fault feeding it inconsistent information. The code is first-hand evidence about where the inconsistency was detected. It is the starting point of the diagnosis, not the verdict.
That is why the first question after any blue screen should always be "what was the code?", not "is the graphics card dead?" A code narrows the search to one subsystem and one set of tests. Guessing the faulty part from the mere fact that a blue screen appeared skips the only piece of evidence Windows actually hands you.
Where the Stop Code Appears: Three Places
The stop code appears in three places, and a careful reader should know all three:
- On the blue screen itself. The code is shown at the moment of the crash. If you are present when it happens, note the full code name and number before the machine restarts.
- In Event Viewer. Open Event Viewer, go to Windows Logs, then System, and look for Event ID 1001 (BugCheck). The event records the stop code, its parameters, the time of the crash, and the drivers loaded at the time. Even if the blue screen restarted too quickly to read, Event 1001 keeps the record.
- In the minidump. Windows saves a small crash dump in `C:\Windows\Minidump`. Advanced users can open it with the Windows debugger (WinDbg) and run `!analyze -v` to see which module was involved. WinDbg is not a required step. If you know how to read a dump, it offers extra clues; if you do not, the stop code together with Event 1001 is already enough to narrow the search and choose the right tests.
Do not rely on memory or on a photograph alone. Event 1001 is the durable record, and it is there whether or not anyone wrote the code down in time.
Not TDR: How These Codes Differ
TDR is Windows' watchdog: if the GPU does not respond for more than 2 seconds, Windows resets the driver. If that reset fails, the result is a TDR failure blue screen. The five codes in this guide never go through that watchdog at all. Each one is raised directly by a subsystem that detected its own internal state was damaged, with no two-second wait and no reset attempt in between. A blue screen is therefore not the same thing as a TDR failure, and a machine that blue-screens with one of these codes should not be diagnosed with the TDR procedure. VIDEO_TDR_FAILURE, 0x117 and 0x141 belong to the TDR family and are covered in the site's TDR and overclocking guides, not in this guide.
This distinction changes the order of work. With a TDR failure, the natural question is why the GPU stopped responding in time. With the codes in this guide, the natural question is which subsystem's internal records became inconsistent, and what could have corrupted them — a driver bug, a damaged driver installation, faulty system memory, faulty video memory, a Windows component change, or a hardware fault surfacing through that subsystem.
The Five-Code Comparison Table
| Stop code | Number | Which subsystem reports | What that subsystem does | What it detected |
|---|---|---|---|---|
| `VIDEO_SCHEDULER_INTERNAL_ERROR` | 0x119 | Video scheduler, part of the DirectX graphics kernel (DxgKrnl) | Manages GPU work submission, queuing, preemption and fence synchronisation | Its own internal state is damaged — for example, fence or context tracking no longer matches — not simply that the GPU was slow |
| `VIDEO_MEMORY_MANAGEMENT_INTERNAL` | 0x10E | Video memory manager (VidMm), part of DxgKrnl | Manages the GPU virtual address space, video memory segments and allocation tracking | The video memory allocation tables or address tracking are damaged; part of VidMm's state lives in system memory, so a system RAM fault can trigger this code |
| `VIDEO_DXGKRNL_FATAL_ERROR` | 0x113 | DirectX graphics kernel (DxgKrnl), the kernel core of WDDM | The kernel hub of the Windows Display Driver Model, the bridge between drivers and the system | DxgKrnl met a fatal error it could not recover from; a driver module name is usually shown alongside it |
| `SYSTEM_THREAD_EXCEPTION_NOT_HANDLED` | 0x7E | A kernel system thread, usually a driver's worker thread | A driver performs work inside a system thread | A system thread threw an unhandled exception, such as an access violation (0xC0000005); the screen and Event 1001 name the `.sys` file involved, for example `nvlddmkm.sys` or `amdkmdag.sys` |
| `DPC_WATCHDOG_VIOLATION` | 0x133 | Deferred procedure call (DPC) watchdog | Watches whether a driver's deferred processing holds the processor too long | A DPC ran too long, or the system spent too long at DISPATCH_LEVEL or above; a graphics driver is one possible source, but storage and network drivers can cause it too, and the code itself does not say which driver |
All five code numbers and definitions above were checked against Microsoft Learn's bug check documentation. The four parameters shown with each code are additional data for advanced diagnosis; their meanings differ from code to code, and this guide does not assign fixed meanings to them.
0x119 — VIDEO_SCHEDULER_INTERNAL_ERROR: The Scheduler's Own Records Broke
Microsoft Learn defines bug check 0x119 as the video scheduler detecting a fatal violation. The scheduler's job is to take work submitted by drivers and applications, queue it, decide what runs and what waits, and track completion with fences. When it raises 0x119, it is saying that its own tracking no longer adds up — a fence identifier it did not issue, a command submission that failed, or an internal state error.
The causes behind 0x119 fall into several layers, and the code alone cannot separate them. A driver can have a bug in its scheduling path, submitting work or reporting completion incorrectly. A driver installation can be damaged, with leftover or mixed-version files leaving the scheduler with inconsistent state. Hardware can return inconsistent completion signals, with a core or power-delivery abnormality surfacing through the scheduler. System memory corruption can scramble the scheduler's tracking tables. All four routes end at the same code, which is why 0x119 must be followed by comparison tests rather than by an immediate verdict about the graphics card.
The practical consequence is a rule: never read 0x119 as "the graphics card core is faulty". It is the scheduler reporting that its records are broken. The next step is to find out which layer broke them, starting with the driver-state comparison in step 3 below.
0x10E — VIDEO_MEMORY_MANAGEMENT_INTERNAL: The Allocation Tables Broke
Microsoft Learn defines bug check 0x10E as the video memory manager encountering a condition it cannot recover from, and notes that it is usually caused by a video driver behaving improperly. VidMm manages the GPU's virtual address space, its video memory segments and its allocation tracking. When it raises 0x10E, an allocation table or address record has become inconsistent.
0x10E has one distinguishing feature that no other code in this guide shares: part of VidMm's state lives in system memory. A faulty system RAM module can therefore corrupt VidMm's records and produce 0x10E, even though nothing is wrong with the graphics card or its video memory. This is the code's key identifying point, and it is easy to miss. A reader who tests only the graphics card and never tests system memory can spend a long time replacing the wrong part.
The other layers behind 0x10E are a driver bug in the VidMm path, faulty video memory corrupting the allocation tables, and unstable video memory overclocking that pushes allocation boundaries out of range. Because system RAM is a possible source, the diagnostic flow for 0x10E always includes a system memory test alongside the driver comparison — that is step 4, and it is not optional for this code.
0x113 — VIDEO_DXGKRNL_FATAL_ERROR: The Graphics Kernel Itself Hit a Fatal Error
Microsoft Learn defines bug check 0x113 as the Microsoft DirectX graphics kernel subsystem detecting a violation. DxgKrnl is the kernel core of WDDM, the bridge between the graphics driver and the rest of Windows. When it raises 0x113, it has met a fatal error it cannot recover from, and a driver module name usually appears with it.
0x113 has its own distinguishing feature: DxgKrnl is a Windows component, not part of the graphics driver. A Windows update can therefore change DxgKrnl itself and trigger 0x113, even when the graphics driver has not changed. This is different from a TDR failure, which usually follows the driver. When 0x113 first appears after a Windows update, the update is a genuine variable in the diagnosis and must be compared separately from any driver change — rolling back the update and rolling back the driver are two different comparisons, and they should not be done at the same time.
The other layers are the familiar ones: a driver interacting incorrectly with DxgKrnl, a damaged driver installation, and a hardware fault surfacing through the kernel. The code tells you the fault surfaced in the bridge between driver and system; the comparison tests then establish which side of the bridge is responsible.
0x7E — SYSTEM_THREAD_EXCEPTION_NOT_HANDLED: A Named File Is Not a Verdict
Microsoft Learn defines bug check 0x7E as a system thread generating an exception that the error handler did not catch, with a value of 0x0000007E. Common exception codes include 0xC0000005, an access violation. What makes 0x7E different from the other codes here is that the blue screen and Event 1001 usually name a `.sys` file — for example `nvlddmkm.sys` for NVIDIA or `amdkmdag.sys` for AMD.
That name is the most misread piece of evidence in blue screen diagnosis. The named file is the module in which the exception broke out. It is not proof that the module caused the problem. A system RAM fault, a fault in another driver that damaged shared memory, or a hardware problem at the motherboard or PCIe level can all make an exception break out inside `nvlddmkm.sys` while the NVIDIA driver itself is behaving correctly. The name tells you where the exception surfaced; it does not tell you who is responsible.
The layers behind 0x7E are a bug in the named driver's own code, the driver reading or writing damaged or unmapped memory, and hardware-level memory errors surfacing through the driver. The correct response is to record the named file and the exception code, then run the same comparison tests as for the other codes — a clean driver reinstall comparison and, if the code persists on a fresh installation with an official driver, the system memory test and the cross-machine test in steps 4 and 6.
0x133 — DPC_WATCHDOG_VIOLATION: A Comparison Code, Not a Graphics Code
Microsoft Learn defines bug check 0x133 as the DPC watchdog executing because it detected a single long-running deferred procedure call, or because the system spent a prolonged time at an interrupt request level of DISPATCH_LEVEL or above. 0x133 is included in this guide only as a comparison code. It is not a graphics-specific code.
A graphics driver can be the source of a long-running DPC, but so can a storage driver or a network driver, and the code itself does not identify which one. If Event 1001 or the minidump points at a storage or network driver, the diagnosis leaves graphics territory entirely and belongs to a different guide. Never write 0x133 down as "the graphics driver is faulty" — the code says only that some driver held the processor too long, and further reading of the dump is needed to say which one.
The Step-by-Step Diagnostic Flow
Work through the steps in order. Each step states what it proves and what it does not prove. Change one variable at a time: change one thing, test once, record the result, and only then move on. Changing several things at once makes it impossible to know which change mattered, and the next time the blue screen appears the diagnosis has to start over.
| Step | What to do | What it proves | What it does not prove |
|---|---|---|---|
| 0 | Write down the full stop code from the blue screen; then check Event ID 1001 in Event Viewer and compare the code, parameters and time | Which subsystem reported, when it happened, and what was running beforehand | Which part is faulty — even a named `.sys` file in 0x7E is not proof of guilt |
| 1 | Compare timing: did the blue screens start after a driver change, a Windows update, a BIOS update, new hardware, or an overclocking change — or with no change at all? | Whether the fault follows a recent change (driver or software layer) or appeared unprompted and is becoming more frequent (hardware suspicion rises) | Timing is a clue, not a verdict; a Windows update can change DxgKrnl and the driver at the same time, so separate the two variables |
| 2 | Route by code using the five-code comparison table above | Which subsystem to test first and which tests take priority | The code alone cannot convict a driver or a part |
| 3 | Clean driver reinstall as a comparison test (see step 3); install the same driver version again | Whether the fault follows the driver files and installation state; if the blue screen clears, the old installation was damaged or mixed-version | It does not prove the old driver had a bug — only that the old installation was damaged; and if the fault persists, it does not prove hardware failure, because another driver version or a Windows component may be responsible |
| 4 | For 0x10E, test system memory with the built-in Windows Memory Diagnostic or a tool such as MemTest86 | Whether system RAM has errors; a RAM error can corrupt VidMm state and produce 0x10E, and no driver or card change will fix that | Clean RAM does not clear VidMm — a driver bug or a video memory fault is still possible; a video memory stress test is a separate line, and passing it does not rule out an intermittent video memory fault |
| 5 | Safe Mode comparison (see step 5): run the machine in Safe Mode and see whether the blue screen still appears | Whether the fault follows the loaded driver layer; a long stable run in Safe Mode points toward the driver layer, while the same code in Safe Mode points away from it | A stable Safe Mode run does not prove the driver is at fault — Safe Mode also disables third-party software, overclocking tools and some hardware acceleration, so the cause must be narrowed further by adding things back one at a time |
| 6 | Cross-machine test: move the graphics card into a different computer with adequate power delivery and run the same workload that triggers the blue screen | Whether the fault follows the card; the same code on the second machine raises suspicion of the card itself, while a clean run points back at the original machine's driver combination, Windows components, system RAM, motherboard or power delivery | A clean run does not prove the card is fault-free — an intermittent hardware fault may not trigger on the second machine; and a failure on the second machine does not prove the card is faulty, because the second machine's driver and Windows versions are variables too and must match |
| 7 | After each step, re-check Event 1001 and note whether the code changed | Whether the last change touched the failing layer — note any code change (see step 7) |
Step 0: Copy the Code Down
A blue screen that is never read is a lost piece of evidence. The blue screen itself shows the code once; Event 1001 keeps it permanently. Check Event Viewer, open Windows Logs, then System, and find the Event ID 1001 entry with the matching time. It records the stop code, the four parameters and the drivers loaded at the time. The parameters are additional data for advanced diagnosis and are not interpreted in this guide. What matters at this step is the code name and number, the time, and what the machine was doing just before the crash — gaming, idle, waking from sleep, or installing an update. Write all of it down before moving on, because later steps depend on comparing codes across crashes.
Step 1: Compare the Timing
Ask what changed before the first blue screen. A driver change, a Windows update, a BIOS update, new hardware, or a new overclocking setting all count as changes. If the blue screens began after a change, the driver or software layer is the likelier direction. If they began with no change and are becoming more frequent, hardware suspicion rises.
Timing is a clue, not a verdict. A Windows update can bring a DxgKrnl change and a driver change together, and blaming one without separating them wastes the comparison. Record the change and the date of the first crash, then let the later steps test each variable on its own.
Step 2: Route by Code
Use the five-code comparison table to decide the first suspicion and the priority test. 0x119 points first at the driver scheduling path and driver state. 0x10E points at the driver VidMm path plus system RAM. 0x113 points at the driver–DxgKrnl interaction and the Windows component. 0x7E with a named file points at that module's driver version and state, without convicting it. 0x133 points at a long-running DPC whose driver must be identified from the dump, and it may not be a graphics driver at all. Do not jump to the graphics card as the first suspect for any of these codes — the table exists precisely so the first test matches the subsystem that reported.
Step 3: The Clean Driver Reinstall Comparison
Use DDU clean reinstall as a comparison test, installing the same driver version afterwards, and see the site's TDR guide for the full DDU procedure. Installing the same version is deliberate: changing the version at the same time as cleaning the installation introduces a second variable, and the result can no longer be attributed to either one. If the blue screen clears, the old installation was damaged or mixed-version — not necessarily that the old driver had a bug. If the blue screen persists with the same code, the driver-files layer is less suspect, and the diagnosis moves to steps 4 and 5. If it persists, a further comparison is to try a different driver version, rolling back to an earlier one, before concluding anything about hardware.
Step 4: The System Memory Test for 0x10E
When 0x10E appears, add a system memory test. Windows includes the Windows Memory Diagnostic; MemTest86 is another widely used tool. This is a general step, not a graphics-specific one. If system RAM returns errors, the mechanism is direct: VidMm keeps part of its state in system memory, that state is corrupted, and 0x10E follows. In that case changing the driver or the graphics card will not help, because neither is the source of the corruption. If system RAM tests clean, VidMm is not cleared — a driver bug in the VidMm path or a video memory fault can still produce 0x10E. A video memory stress test is a separate line of evidence, and passing it does not rule out an intermittent video memory fault that the test did not trigger.
Step 5: The Safe Mode Comparison
Safe Mode uses the basic display driver. If the machine runs for a long period in Safe Mode without a blue screen, the fault leans toward the driver layer. If the same code appears in Safe Mode, the driver layer is less suspect and the hardware or system layer rises. The limitation is that Safe Mode disables many things at once — third-party software, overclocking tools, parts of hardware acceleration — so a stable Safe Mode run does not prove the driver is at fault. It only proves the fault needs something Safe Mode does not load. The cause must then be narrowed by adding things back one at a time.
Step 6: The Cross-Machine Test
Move the graphics card into a different computer with adequate power delivery and run the same workload that triggers the blue screen. If the second machine produces the same stop code, suspicion of the card itself rises sharply. If the second machine runs clean, suspicion moves back to the original machine — its driver combination, Windows components, system RAM, motherboard, or power delivery. Two cautions apply. First, a clean run does not prove the card is fault-free, because an intermittent hardware fault may simply not trigger on the second machine. Second, a failure on the second machine does not prove the card is faulty either, because the second machine brings its own driver and Windows versions; use the same driver version on both machines so no second variable is introduced.
Step 7: Read the Code Again After Every Step
After each step, re-check Event 1001. A changed code is itself diagnostic information: a code that changes means the previous layer is cleared and the next layer is now showing, while an unchanged code means the failing layer has not been touched yet. A diagnosis that ignores the code after each step throws away the clearest signal about whether the last change mattered. Keep a short log — date, code, what changed, result — and let the pattern of codes across crashes guide the next step.
Edge Cases
The same code, after a driver update versus with no change at all. After an update, the driver or Windows component layer is the likelier direction. With no change, and especially if the crashes are becoming more frequent, the hardware or ageing layer rises. Do not apply the same conclusion to both situations.
0x113 appearing only after a Windows update. DxgKrnl is a Windows component, so the update itself is a variable. Compare the update time against the first crash, and treat rolling back the update and rolling back the driver as two separate comparisons — never do both at once.
0x10E together with video memory overclocking. Unstable overclocking can push VidMm allocation boundaries out of range. Restoring default clock speeds is the first comparison step here; the full overclocking diagnosis is covered in the site's overclocking guide.
0x7E naming `nvlddmkm.sys` on a fresh installation with an official driver. The named module is not necessarily the culprit — a system RAM fault, a motherboard or PCIe-level problem, or another driver damaging shared memory can all make the exception break out inside `nvlddmkm.sys`. Run the system memory test and the cross-machine test in steps 4 and 6 instead of reinstalling the NVIDIA driver again.
Blue screens only in one game or one program. That pattern points toward the driver–program interaction layer, such as the API call path that program uses. Compare whether other programs produce the same code: if only one game produces it, do not condemn the hardware.
Intermittent blue screens versus a blue screen on every boot. Intermittent crashes lean toward driver state or marginal hardware. A crash on every boot, including an inability to reach Safe Mode, leans toward the system or hardware layer — do not keep applying the clean driver reinstall procedure when the machine cannot reach the desktop, and use the site's boot-failure guides to work through the boot layer first.
0x133 naming a storage or network driver. 0x133 is not this guide's subject. If Event 1001 points at a storage or network driver, the direction is entirely different and is not a graphics card article.
The code is a TDR family code. Those codes are covered in the site's TDR and overclocking guides. A reader who arrives here with one of those codes should use the TDR guide instead.
Common Misconceptions
| Misconception | Correction |
|---|---|
| "A blue screen means the graphics card is broken." | A blue screen means Windows detected a kernel-level fatal error. The code says which subsystem reported; a driver bug, a Windows component, system RAM, or graphics hardware can all trigger it. |
| "A blue screen means TDR." | TDR is one mechanism, built around a two-second watchdog. The five codes in this guide all bypass TDR entirely. Read the code first; do not apply the TDR procedure by default. |
| "Event 1001 names `nvlddmkm.sys`, so the NVIDIA driver has a bug." | The named file is only where the exception broke out, not proof of guilt. A system RAM fault, another driver damaging shared memory, or a hardware fault returning abnormal data can all make the exception surface in that module. |
| "The error code tells you directly which part is broken." | The code tells you which subsystem detected the problem; the detecting department is not necessarily the department at fault. Only comparison tests — a clean driver reinstall, a memory test, a cross-machine test — can narrow it down. |
| "Reinstalling Windows will definitely fix a blue screen." | A reinstall only resets the driver and system-file layers. A hardware fault, a system RAM fault, or a firmware-level problem will survive a reinstall. Before reinstalling, the code has already said which layer is in question. |
| "The newest driver will definitely fix a blue screen." | A new driver can bring a new bug, especially in the scheduling path behind 0x119 and the DxgKrnl interaction behind 0x113. A comparison test should first reinstall the same version; do not upgrade and clean at the same time. |
| "0x119 is the same as TDR, because both involve scheduling." | They are different mechanisms: TDR is a watchdog timeout when the GPU does not respond within two seconds, while 0x119 is the scheduler detecting that its own internal state is damaged. The two can occur on the same machine, but they are not the same code and must not be confused. |
| "You must know WinDbg and minidumps to diagnose a blue screen." | The stop code and Event 1001 are enough to narrow the search and choose the right tests. WinDbg is an advanced source of extra clues, not a requirement. |
| "After a blue screen, just restart and forget about it." | Event 1001 keeps the code and parameters. There is no need to hope the next blue screen is photographed; the record is already in Event Viewer, and this guide's first step is to go and read it. |
A Note on Registry Edits and TdrDelay
Changing registry values such as TdrDelay is sometimes suggested online as a way to stop blue screens. It is not a fix. Lengthening a timeout only masks the symptom by giving a slow GPU more time before Windows intervenes; it does not repair a damaged scheduler state, a corrupt allocation table, or a faulty memory module, and it can hide a worsening hardware fault until it causes worse damage. Editing the registry is an advanced test, it carries risk, and it is not recommended for general users. Diagnose with the code and the comparison tests in this guide instead.
When the Tests Point Beyond Software
If the code persists after a clean driver reinstall comparison, a system memory test, and a Safe Mode comparison — or if the same code follows the card into a second machine — the next step is a physical inspection. An inspection can check the card's seating, its power delivery, and whether the card behaves the same way in a different machine, which no settings change can establish.
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. Bring the record from Event 1001 — the code, the parameters and the dates — because that record is what lets an inspection start from the right subsystem instead of from the beginning.
Frequently Asked Questions
My computer blue-screens, but the code is not one of the five in this guide. What should I do?
Read the code first, then find the guide that covers it. TDR family codes belong to the site's TDR and overclocking guides. A code naming a storage or network driver belongs to a different diagnosis entirely. The method in this guide — copy the code, check Event 1001, change one variable at a time — still applies, but the routing table here is written for the five codes above.
Where do I find the stop code if the blue screen disappears too quickly to read?
Open Event Viewer, go to Windows Logs, then System, and look for Event ID 1001 (BugCheck) at the time of the crash. The event records the stop code, its parameters, and the drivers loaded at the time. There is no need to wait for the next blue screen to photograph it.
Event 1001 names `nvlddmkm.sys`. Does that prove the NVIDIA driver is the cause?
No. The named file is the module in which the exception broke out, not proof that the module caused it. A system RAM fault, another driver damaging shared memory, or a hardware fault can all make an exception surface inside `nvlddmkm.sys`. Record the name and the exception code, then run the clean driver reinstall comparison, the system memory test and the cross-machine test before drawing any conclusion.
0x10E keeps appearing. Should I replace the graphics card?
Not yet. 0x10E is the video memory manager reporting damaged allocation tracking, and part of VidMm's state lives in system memory. Test system memory first: a RAM fault can produce 0x10E with a healthy graphics card. Only after the driver comparison and the system memory test both point away from software and RAM should the card itself become the prime suspect.
0x113 started right after a Windows update. Is the graphics driver to blame?
Not necessarily. DxgKrnl is a Windows component, so the update itself is a variable. Compare the update time against the first crash, and treat rolling back the update and rolling back the driver as two separate comparisons. Do the driver comparison first, with the same driver version, and keep the update comparison separate so the result can be attributed to one change.
Do I need to learn WinDbg to diagnose a blue screen?
No. The stop code and Event 1001 are enough to narrow the search and choose the right tests. WinDbg and the minidump in `C:\Windows\Minidump` offer extra clues for advanced users, but not knowing them does not prevent a diagnosis.
The blue screen only happens in one game. Does that mean the hardware is fine?
It points toward the driver–program interaction layer rather than the hardware. Compare whether other programs produce the same code: if only one game produces it, do not condemn the hardware. The game's own API call path, or a driver bug in that path, is the likelier direction.
The code changed after I reinstalled the driver — 0x119 became 0x10E. Is that bad news?
It is useful news: a code that changes means the previous layer is cleared and the next layer is now showing, while an unchanged code means the failing layer has not been touched yet. Record the new code and continue the flow from the step that matches it.