Blue Screen and Reboot Loop After Installing a GPU Driver? Driver Load, Stop Codes & Safe Mode Diagnosis Guide

2026-11-17 | GPU Repair | 41 minutes | HK GPU Fix Editorial Team

Blue Screen and Reboot Loop After Installing a GPU Driver? Driver Load, Stop Codes & Safe Mode Diagnosis Guide

Key Summary

After a graphics driver install or update, the machine blue-screens on the first restart and then loops back into the same blue screen instead of reaching the desktop. This guide separates a driver-load fault from other causes, using the stop code, the driver filename on the screen, and a Safe Mode comparison to find which layer the fault belongs to.

The Shape of the Problem: Installed, Restarted, Blue Screen, Repeat

This guide covers one specific shape, and the shape itself is the whole diagnosis. A graphics driver is installed or updated. The installer reports no error and asks for a restart, or the machine restarts on its own as part of the update. On that first restart, a blue screen appears instead of the desktop. The machine then restarts automatically, and the blue screen appears again. The loop repeats, and the desktop is never reached.

Three details define the shape, and all three have to be present. First, the trigger is the driver install or update: the machine worked before it, and the first blue screen arrived on the first restart after it. Second, the fault is a blue screen, not a black screen — there is a stop code and usually a driver filename on the screen, even if the screen vanishes too fast to read. Third, the loop repeats: one blue screen followed by a normal desktop is a different shape, and a restart loop with no blue screen at all is a different shape again.

That combination is what makes this symptom different from its neighbours. A driver that cannot be installed at all — the installer fails, rolls back, or reports an error — never gets loaded, so it cannot blue-screen the machine on boot; that is an install-failure problem, and it runs in the opposite direction from this one. A blue screen that appears once in the middle of a game, with the machine then working normally again, is a single timeout event under load, not a loop that starts at boot. And a machine that restarts over and over with no blue screen, cutting straight to black and powering up again, is following a different path — one that involves power protection or a failure before Windows can even raise an error. This guide starts from a different place: the install finished, the restart began, and the blue screen is what came back, every time.

The first conclusion most owners reach is that a blue screen after a driver install means the graphics card has died. It does not. A blue screen is Windows raising an error check: something the system was doing at that moment broke a rule the system enforces, and Windows stopped rather than continue in an unsafe state. The stop code on the screen says which part of the system raised the report. It does not, on its own, say which part is broken. The timing is the strongest evidence available at the start: a machine that was fine, then had its graphics driver changed, then blue-screened on the very next boot, is pointing at the driver load first. The rest of this guide is about testing that pointer properly instead of assuming it.

One practical problem has to be solved before anything else. By default, Windows restarts automatically after a blue screen, so the screen is visible for only a moment — too short to read the stop code or the filename. That automatic restart is itself part of the loop, and stopping it is the first diagnostic move, described in step two. Until the code is read, everything else is guessing. Photograph the screen if it appears at all, even a blurred photograph is better than a remembered fragment, because the exact code and the exact filename are the two facts every later step depends on.

What the Installer Actually Changes When It Replaces a Driver

To understand why a machine can be fine before a driver install and looping afterwards, it helps to know what an install actually does. A graphics driver is not one file. It is a set of components, and the most important of them runs in kernel mode — the privileged part of the system where a fault cannot be contained the way an ordinary application crash can be. When a driver is installed or updated, the installer replaces those core driver files with new versions. The old files are swapped out, and the new files are what Windows will load on the next boot.

That swap is why the first restart after an install is the moment of truth. Before the restart, the new driver files are sitting on the disk but the old driver is still the one running. The restart is the first time the new files are loaded. If the new files do not fit with the rest of the system — because the install package itself was damaged, because leftover files from the old driver interfere with the new ones, because the new version expects something the system does not have, or because the new version itself behaves differently on this particular machine — then the first load is where the failure appears. Nothing about the hardware has changed. What has changed is the code Windows now runs at the point where the graphics driver takes over.

The driver loads early. During startup, Windows reaches a point where it hands display work to the graphics driver, and from that point on the driver is in charge of the card. If the driver cannot complete its initialisation, or if it takes too long, or if it asks for something it should not have, Windows raises a bug check and the blue screen appears. That is the mechanism behind the whole shape: the failure is not in the installer, which finished, and not in the desktop, which is never reached. It is in the load — the short window in which the new driver is first asked to run.

One specific mechanism inside that window is the timeout reset, known as TDR. When the graphics driver is asked to do something, Windows allows it a limited time — about two seconds by default — to respond. If the driver does not respond in time, Windows tries to reset it: the graphics scheduler calls the driver back to reinitialise itself, and if that reset succeeds, the screen may flicker and play continues. If the reset fails, Windows raises a blue screen with the stop code 0x116, VIDEO_TDR_FAILURE. The same result follows if the driver times out repeatedly: more than five timeouts within one minute also ends in a blue screen, according to the Microsoft documentation for this stop code. So a driver that is slow to initialise on first load, or that stalls while initialising, can trip the same mechanism that a driver under gaming load trips — the difference is only when it happens. In a game the timeout arrives in the middle of play; here it arrives at boot, on the first load, before the desktop exists.

A second mechanism in the same window is the power-state transition. When the driver loads, the graphics card has to move from a low-power state to a working state. If that transition fails — the driver asks the card to wake and the card does not answer, or the driver and the power management disagree about what state the card is in — Windows raises the stop code 0x9F, DRIVER_POWER_STATE_FAILURE. The mechanism is the same one that appears when a machine fails to wake from sleep, but the trigger here is different: this is the first load after an install, not a wake from sleep, and the two should not be confused. The code is the same because the transition is the same; the cause is found by looking at when it happened.

One more thing to note about the screen itself — a point first recorded in this site's reboot-loop guide: on Windows 11 version 24H2 and later, the crash screen is black, not blue, and the smiley face and the QR code are gone. Whether the screen is blue or black, the stop code and the driver filename on it are the useful information; the colour itself is not a diagnostic basis.

A third possibility is a memory-access fault inside the driver. If the driver reads or writes a memory address it should not have touched, Windows raises 0xD1, DRIVER_IRQL_NOT_LESS_OR_EQUAL. A fourth is a fault in a system thread that the driver set running, raised as 0x7E, SYSTEM_THREAD_EXCEPTION_NOT_HANDLED — in that case the filename on the screen matters more than the code, because the code alone says only that a system thread failed. In every one of these, the stop code and the filename together are a report, not a verdict. They say which part of the system raised the fault and which driver file was running when it happened. They do not say that the file itself is the cause, and they do not say the card is dead. A filename is where the fault surfaced, and the cause can sit one step behind it — in the install package, in a leftover file, in the version, or in the system the driver was loaded into.

The Deciding Forks: Four Questions That Narrow the Field

The whole guide turns on four forks. Each fork is a comparison, and each comparison removes a whole set of possibilities. They should be done in order, before any driver is changed, because a driver changed before the fork is tested destroys the evidence the fork would have given.

Fork One: Did the Loop Start Exactly With the Install?

The first fork is the timeline. Write down what the driver situation was before the loop began: which driver version was running, which new version was installed, how it was installed — the vendor's own installer, Windows Update, or another source — and whether the installer reported any error. Then check the order of events. If the machine was working normally, a driver was installed or updated, and the first blue screen arrived on the very next restart, the fault follows the install. If the blue screens started days later, or after some other change — a Windows update, a new piece of hardware, a power cut — the install may be a coincidence, and the timeline points elsewhere. If the installer itself reported an error or rolled back, the install never completed, and the problem is an install failure rather than a driver-load fault: the driver was never loaded, so it cannot be what is blue-screening the boot.

Fork Two: What Does the Blue Screen Actually Say?

The second fork is the stop code and the driver filename, read from the screen itself. Because the automatic restart hides the screen, the first job is to make the screen stay still long enough to read — that is step two below. Once the code and the filename are in hand, they split the field. A 0x116 with a graphics driver filename points at a timeout and reset failure during driver load. A 0x9F points at a power-state transition failure. A 0xD1 points at a driver touching memory it should not have touched. A 0x7E points at a system thread fault, where the filename carries more weight than the code. A code that names a different driver file — storage, network, or something else entirely — points away from the graphics driver, even if the loop started after a graphics driver install. And a code that changes every time the machine loops is itself information: a fault pinned to one driver tends to report the same code, while a code that changes from one boot to the next suggests the failure is not pinned to a single point, and the record should note every code seen rather than only the first.

Stop codeWhat it meansWhat it points toward
0x116 VIDEO_TDR_FAILUREThe driver timed out and the reset attempt failed, or the driver timed out repeatedlyDriver load or timeout layer — the driver could not initialise or respond in time
0x9F DRIVER_POWER_STATE_FAILUREThe driver failed a power-state transition, such as moving from a low-power state to a working statePower-state transition layer — the driver and the card disagreed about power state during load
0xD1 DRIVER_IRQL_NOT_LESS_OR_EQUALThe driver accessed a memory address it should not have touchedDriver load layer — a fault inside the driver code path that ran during load
0x7E SYSTEM_THREAD_EXCEPTION_NOT_HANDLEDA system thread raised an exception that was not handledRead the filename first — the code alone does not say which driver was involved

Fork Three: Does Safe Mode Hold Steady?

The third fork is the Safe Mode comparison, and it is the most decisive test in the guide. Safe Mode loads only the most basic set of drivers, and it does not load the full graphics driver that normal startup loads. If the machine is stable in Safe Mode and blue-screens in normal startup, the fault follows something that only normal startup loads — and the graphics driver is the first suspect, given the timeline. If the machine blue-screens in Safe Mode too, the fault is not confined to the normal graphics driver load, and this guide no longer applies: the investigation moves to hardware, firmware, or startup files. If Safe Mode cannot be entered at all, stop: the next step is the recovery environment and professional inspection, not further testing at home. Safe Mode being stable is not a repair. It only narrows the field to the driver layer, and the narrowing is the result — what comes after is the confirmation testing in steps five and six.

Fork Four: Does Removing the Driver Change the Result?

The fourth fork is the confirmation test. In Safe Mode, the graphics driver is removed cleanly, and the machine is restarted into normal mode. If normal mode is now stable, the driver layer is confirmed: removing the driver removed the fault. If Windows Update then installs the same driver again at once and the loop returns, the fault moves to the update-source layer — the problem is not only the driver, but the source that keeps putting the same driver back. If the machine still blue-screens with the driver removed and the basic display driver in its place, the fault is not confined to that driver, and the investigation moves to the system-file layer. This fork is what turns a suspicion into a tested conclusion, and it is the reason the removal step is a comparison test rather than a repair: removing a driver is not a finished state, and the machine still needs a working driver afterwards.

The Five Suspicion Layers

A blue-screen loop after a driver install can fail at five layers, and they must be kept separate. Changing the driver, the version, and the install source all at once and finding the machine stable proves nothing about which change did the work, and the loop will return the next time only one of those conditions is present. The layers below run from the install itself to the system underneath it, and each one has its own deciding evidence.

LayerWhat it coversDeciding evidence
1. Installer file-swap layerThe installer replacing core driver files; a damaged package; leftover old driver files interfering with the new onesThe loop began on the first restart after the install, and no other change happened at the same time
2. Driver load and timeout layerThe new driver initialising too slowly or stalling on first load; the timeout reset failingStop code 0x116 with a graphics driver filename; Safe Mode stable, normal mode looping
3. Power-state transition layerThe driver moving the card from a low-power state to a working state during loadStop code 0x9F on the first load after the install
4. Driver version and source layerThe new version itself; a damaged install package; a version pushed by Windows Update; a version from a third-party updater toolA previously working version runs normally while the new version loops; Windows Update reinstalling the same version brings the loop back
5. System file and startup layerDamaged system files, disk errors, or damaged startup settings that only show up when the new driver loadsThe loop continues with the driver removed, or Safe Mode blue-screens too

Layer One: The Installer File-Swap Layer

The first layer is the install itself. The installer replaces the core driver files, and three things can go wrong at that point. The install package may be damaged — downloaded incompletely, or corrupted on disk — so the files it writes are not the files the vendor intended. Old driver files may be left behind, and the new driver may trip over them when it loads: a leftover component from the old version answering a call the new version does not expect. Or the new files may simply not fit with the other components on this particular machine, because the system has a combination the new version was not written for. The signature of this layer is the timeline. The machine worked, the install ran, and the first restart looped. Nothing else changed at the same time. That does not prove the install package is at fault — a version problem and a package problem share the same timeline — but it puts the install at the front of the queue, and it is why the version comparison in step six exists: installing a different copy of a working version separates a damaged package from a bad version.

Layer Two: The Driver Load and Timeout Layer

The second layer is the load itself. The new driver is asked to initialise the card, and it has a limited time to answer. If it stalls — waiting for a response from the card that never comes, or waiting on another component that is not ready — the timeout mechanism steps in and tries to reset it. If the reset fails, the result is a 0x116 blue screen. If the driver stalls repeatedly, more than five timeouts in one minute ends the same way. This layer is the same mechanism that produces a timeout blue screen in the middle of a game, but the trigger is different: there the driver stalls under load, here it stalls on its very first load, before the desktop exists. The deciding evidence is the combination of the stop code and the Safe Mode comparison. A 0x116 with a graphics driver filename, plus a machine that is stable in Safe Mode and looping in normal mode, points squarely at this layer. Note what this layer does not claim: it does not say the card is faulty. A driver that stalls on load is a driver problem until proven otherwise, and the proof is the removal test in step five.

Layer Three: The Power-State Transition Layer

The third layer is the power-state transition during load. When the driver loads, the card must move from a low-power state to a working state, and the driver manages that move. If the transition fails, Windows raises 0x9F. This is a narrower layer than the timeout layer, and it is identified by its code rather than by timing alone. The same code appears when a machine fails to wake from sleep, because waking also involves a power-state transition — but the trigger here is the first load after an install, not a wake, and the two situations should not be treated as the same fault. The evidence for this layer is the code itself, together with the timeline: a 0x9F that first appears on the restart after a driver install points at the driver managing the transition, and the confirmation is the same as for the other layers — remove the driver, test, and see whether the loop goes away.

Layer Four: The Driver Version and Source Layer

The fourth layer is the version and where it came from. Four sources behave differently, and the source matters to the investigation. A version installed from the vendor's own installer is one thing; a version pushed by Windows Update is another, because Windows Update can install a driver without being asked, and can install the same version again after it has been removed. A version that arrived through any source other than the vendor's own installer or Windows Update is a third: such sources should not be used at all — only the vendor's own installer and Windows Update itself are legitimate sources for a graphics driver, and a driver that arrived through any other channel should be treated as untrusted until it is replaced by a vendor installer. And a version that was already installed once and removed is a fourth, because the removal may not have been clean. Versions can only be judged by timeline. A version that ran normally before the install and a version that loops after it are a comparison, not a verdict: no version should be written down as generally good or generally bad, because versions change and the current official release is the only reference that stays valid. The deciding evidence for this layer is the version comparison in step six, and the update-source trap in step seven: if a previously working version runs normally and the new version loops, the version layer is indicated; if Windows Update reinstalls the same version at once and the loop returns, the source layer is indicated.

Layer Five: The System File and Startup Layer

The fifth layer is the system underneath the driver: damaged system files, disk errors, or damaged startup settings. This layer is considered last, and for a reason. Its symptoms do not follow a driver install neatly — a damaged system file would be expected to cause trouble in other situations too, not only on the first load of a new driver. It becomes the leading suspect only when the evidence points away from the driver: the machine blue-screens in Safe Mode as well, or it keeps looping after the graphics driver has been cleanly removed and only the basic display driver is running. Until that evidence exists, running system-file checks first is the wrong order — it spends time on the least likely layer and leaves the driver layer untested. When this layer is reached, the work belongs with professional inspection rather than further testing at home, because the checks involved reach into startup settings and system files that should not be rebuilt by hand.

The Seven Diagnostic Steps

The steps below are comparison tests. Each one changes one variable and records the result. Changing two things at once and finding the machine stable proves nothing about which change mattered, and the loop will return the next time only one of those conditions is present. Write down each result before moving on.

Step 1: Record the Baseline

Before anything is changed, record the baseline. Which driver version was running before the install, and which new version was installed. How it was installed — the vendor's own installer, Windows Update, or another source — and whether the installer reported any error. The full text of the stop code and the driver filename from the blue screen, photographed if possible, because the automatic restart will make the screen disappear. And which stage the blue screen appears at: the Windows logo, the spinning dots, or just before the login screen. Without this record, later comparisons have nothing to compare against, and a stop code that changes halfway through the investigation will look like a new problem when it is the same one wearing a different shape. Also note anything else that changed at the same time — a Windows update, new hardware, a power cut — because a second change at the same moment weakens the timeline evidence.

Step 2: Stop the Automatic Restart and Read the Code

The automatic restart is what hides the evidence, so it has to be switched off before the code can be read. First, find the BitLocker recovery key, if the machine uses BitLocker: entering the recovery environment without it can lock the machine out, and the key should be in hand before any restart is interrupted. Then get into the recovery environment. If the machine cannot reach the desktop, interrupt the startup repeatedly — power off during startup, power on again, and repeat — until the Automatic Repair screen appears. Sources differ on how many interruptions this takes, so no fixed number should be relied on: repeat the interruption until the screen appears, and do not treat the interruption itself as a normal operation — it is a way into the recovery environment, not something to do routinely. From Automatic Repair, go to Troubleshoot, then Advanced options, then Startup Settings, and choose the option to disable automatic restart after failure — option 9 in the Startup Settings list. The machine will then fault once more and stop on the blue screen instead of restarting, and the full stop code and driver filename can be read and photographed. This step is a comparison test, not a repair: switching off the automatic restart does not fix anything, it only makes the evidence visible. Record the code and the filename exactly as shown, including the full filename — nvlddmkm.sys is not the same evidence as amdkmdag.sys, and a half-remembered code is no evidence at all.

Step 3: The Safe Mode Comparison

From the recovery environment, go back to Startup Settings and choose Safe Mode — option 4. If a driver download is needed later, Safe Mode with Networking, option 5, is the one to use, because plain Safe Mode has no network access. Watch what happens. If Safe Mode is stable — the desktop appears, the machine sits there without blue-screening — the fault follows something that only normal startup loads, and the graphics driver is the first suspect given the timeline. If Safe Mode blue-screens too, leave this guide: the fault is not confined to the normal graphics driver load, and the investigation moves to hardware, firmware, or startup files. If Safe Mode cannot be entered at all, stop testing and arrange inspection — forcing further restarts on a machine that cannot reach even Safe Mode adds risk without adding information. Safe Mode being stable only narrows the field to the driver layer. It is not a repair, and the machine is not fixed because it runs in Safe Mode. What follows is the confirmation testing that separates the driver from the version and the source.

Step 4: The Driver Filename Comparison

With the code and filename recorded, compare the filename against the hardware in the machine. The filename says which driver was running when the fault was raised. The common ones are nvlddmkm.sys for NVIDIA, amdkmdag.sys or atikmpag.sys for AMD, and igdkmd64.sys for Intel — the NVIDIA filename also appears in the Microsoft documentation's own example analysis for a 0x116 fault. If the filename matches the card in the machine, the evidence is consistent with a graphics driver fault, and the investigation stays in the driver layer. If the filename does not match the hardware — a machine with only integrated graphics showing an NVIDIA driver filename, for example — that mismatch is a clue in itself, and it should be written down rather than ignored: it suggests a driver is present that should not be, or a leftover install is loading where it should not. If the blue screen names no driver file at all, the code carries the weight instead, and the investigation leans on the code table in the forks section above. Either way, the filename is where the fault surfaced, not the cause itself. A filename on the screen proves which driver was running when the system stopped; it does not prove that the driver file itself is damaged, and it certainly does not prove the card is dead.

Step 5: The Clean-Removal Comparison

This is the confirmation test, and it has to be done in the right order. Before entering Safe Mode, download the installer for a driver version that previously ran normally on this machine, and save it somewhere easy to reach, such as the desktop — Safe Mode without networking cannot download it afterwards. Then enter Safe Mode and use Display Driver Uninstaller, known as DDU, to remove the graphics driver completely, choosing the "Clean and restart" option. DDU should only be used in Safe Mode; using it in normal mode, while the faulty driver is loaded, is not the right way to run it. After the restart, the machine should come up in normal mode using the basic display driver. Watch what happens. If normal mode is now stable, the driver layer is confirmed: removing the driver removed the fault. If the loop returns at once, the fault is not confined to that driver, and the investigation moves to the system-file layer. This step is a comparison test, not a repair. Removing a driver leaves the machine without a proper graphics driver, and the machine still needs one installed afterwards. What the step proves is where the fault lives, not that anything is fixed — and that distinction matters, because a machine with its driver removed and nothing installed is not a working machine, only a tested one.

Step 6: The Version Comparison

With the driver removed and the machine stable in normal mode, install the version that previously ran normally — the version recorded in step one as the last working version — using the installer downloaded before step five. Do not install the newest version first. The question being tested is whether the version matters, and that question can only be answered by going back to a version that is already known to have worked on this machine. Record the version installed, then restart and watch. If the previously working version runs normally and the new version looped, the fault follows the version, and the version layer is indicated. If the previously working version loops as well, the fault is not a version problem, and the investigation moves to the system-file layer. Two cautions apply here. First, if the desktop can be reached at all, rolling back to the previous driver through Device Manager is the cheapest comparison to try first, because Windows usually keeps a copy of the old driver; if the machine is stuck in a loop and cannot reach the desktop, the Safe Mode and clean-removal route in step five comes first instead. Both orders are valid, and which one applies depends on whether the desktop can be reached. Second, no version should be treated as generally good or generally bad: versions change, and the current official release is the only reference that stays valid. A version that loops on this machine, in this combination, is evidence about this machine — not a verdict on the version for everyone.

Step 7: The Update-Source Trap and Preparing for Inspection

After a clean removal, watch what Windows Update does. Windows Update can install a graphics driver on its own, and it can install the same version again at once — the same version that just looped. If the loop returns immediately after Windows Update reinstalls the driver, the fault has moved to the update-source layer: the problem is not only the driver, but the source that keeps putting the same driver back. That is a different problem from a driver that loops once, and it needs a different answer — controlling which driver Windows Update installs, rather than removing the driver again and watching it come back. If the loop does not return, the version comparison in step six stands as the result. Then assemble the conclusion in three sentences: what the symptom is, which variable made the symptom appear or disappear, and which possibilities are still not ruled out. Write it down with the full record: the stop code and filename from every blue screen seen, the driver versions before and after, the source of the install, the Safe Mode result, the clean-removal result, and the version comparison result. Also note the minidump location, C:\Windows\Minidump, where Windows saves a small memory dump for each crash — the files there are part of the evidence for inspection, and they should be mentioned, not deleted. Bring that record to inspection. A record that says "0x116 with nvlddmkm.sys, Safe Mode stable, loop gone after clean removal, previously working version stable, Windows Update reinstalled the new version and the loop returned" is worth far more than a record that says "it blue-screens."

Six Misconceptions That Mislead This Diagnosis

Misconception 1: A Blue Screen Means the Card Is Dead

A blue screen is Windows raising an error check, and the stop code says which part of the system raised the report — not which part is broken. A machine that blue-screens only after a driver install, on the first load of the new driver, is pointing at the driver load first. Hardware faults do exist, and they can blue-screen a machine, but a fault that starts exactly when a driver changes is a driver-layer suspect until the comparison tests say otherwise. Jumping to a dead card skips every test that could prove otherwise, and it leads to replacing a part that was never at fault.

Misconception 2: The Newest Driver Is Always the Most Stable

The newest driver is the latest release, not the most suitable release for this particular machine. Published answers to the same question contradict each other directly: one advises installing the newest version, another advises going back one or two versions and trying those first. Both cannot be right as a general rule, and that is the point — there is no general rule. A version can only be judged by timeline: did this machine run normally on this version, and did it loop on that version. Newest does not mean most suitable, and a version that loops on one machine may run normally on another. Compare versions, and use the current official release as the reference rather than treating any version as generally good or bad.

Misconception 3: Rolling Back the Driver Means It Is Fixed

Rolling back is a comparison test. It proves the fault follows the version — the old version runs, the new version loops — and that is valuable evidence. It does not repair anything, because the fault can return: Windows Update can install the same newer version again, and the loop comes back with it. A machine that is stable only because it is running an older driver, with the newer driver waiting to be reinstalled, is not a fixed machine. It is a machine whose fault has been located, and the update source still needs to be dealt with.

Misconception 4: Safe Mode Working Means the Problem Is Fixed

Safe Mode only loads the most basic drivers, and it deliberately skips the full graphics driver. A machine that is stable in Safe Mode has only shown that the fault follows something normal startup loads — it has not shown what the fault is, and it has not fixed anything. The clean-removal test and the version comparison still have to be done before the driver layer is confirmed. Treating Safe Mode as a fix leaves the machine in a state where it cannot run its normal driver, and the loop will return the moment normal startup loads the driver again.

Misconception 5: Clean Removal and Reinstalling Means It Is Fixed for Good

A clean removal with DDU only removes the driver. It is a removal tool, not a repair. If the problem was a damaged install package, reinstalling the same package will loop again. If the problem was the version itself, reinstalling the same version will loop again. If Windows Update reinstalls the same version, the loop will return. The removal test proves the fault lives in the driver layer; it does not prove the layer is now clean. What comes after — the version comparison, and the update-source check — is what decides whether the fault stays away.

Misconception 6: The Filename on the Blue Screen Is the Culprit

The filename is where the fault surfaced, not the cause itself. A blue screen naming nvlddmkm.sys says the NVIDIA driver was running when the system stopped; it does not say the NVIDIA driver file is damaged, and it does not say the card is broken. The cause can sit one step behind the filename — in the install package, in a leftover file, in the version, or in the system the driver was loaded into. The filename and the code are a report, not a verdict. They narrow the field to the driver that was running, and the comparison tests are what decide whether that driver is the cause.

What the Sources Disagree About

The published sources do not agree with each other, and both sides are given below.

First, the order of the comparison steps. One guide puts rolling back first, because it is the fastest option — Windows usually keeps a copy of the old driver. Other guides put Safe Mode and clean removal first. This guide follows the position that both orders are valid and the choice depends on the situation: if the desktop can be reached, roll back first, because it costs the least; if the machine is stuck in a loop and cannot reach the desktop, Safe Mode and clean removal come first. Either order on its own, presented as the universal standard, would be wrong for the other situation.

Second, newest version against older version. Published answers to the same question give opposite advice: one says install the newest version, another says install an older version or two first and try those. This guide follows the position that versions are timeline comparisons only, and no version should be treated as generally good or generally bad.

Third, how many interrupted startups it takes to reach Automatic Repair. The sources differ on the number, so no fixed number should be relied on: repeat the interruption until the Automatic Repair screen appears. The disagreement itself is the reason the number cannot be written down as a rule.

Fourth, there is a disagreement about how to describe the comparison steps. Third-party tutorials often describe rolling back, clean removal with DDU, and reinstalling an older version as repairs. This site's position is that all of them are comparison tests. They produce evidence about which layer the fault belongs to, and they are not repairs. This guide follows that position throughout: no comparison step is presented as a fix.

Two further points should be stated plainly. Some third-party tutorials describe changing the driver timeout in the registry, and others describe running Driver Verifier. The timeout change reaches into the system's low level, and Driver Verifier itself can blue-screen a system by design — neither is a step to take on one's own, and this guide gives instructions for neither. And one secondary source repeats a claim that a large share of stop errors come from third-party drivers, attributed second-hand to an analysis by Microsoft. That figure is not used anywhere in this guide: a second-hand statistic is not evidence, and it is not repeated here as a number.

When to Stop Testing

Blue-screen loop testing carries risk, and the testing should stop before the risk outweighs the evidence. Do not keep forcing the power off in the middle of a loop: interrupting startup is a way into the recovery environment, not a routine operation, and repeated forced power cuts add stress without adding information after the first few results. Stop immediately if there is any smell of burning, any scorch mark on a power cable, any unusual noise, or any visible damage — those are signs to stop and arrange inspection, not to keep testing. Do not disable any protection to run a test. A test that has already given a clear result does not need to be run again, and a test that blue-screens the machine is a result in itself — record it and move to the next comparison instead of running the same crash again.

Do not change the driver timeout in the registry, do not run Driver Verifier, and do not rebuild the startup records from the recovery-environment command line. The first two reach into the system's low level and can hide the evidence or cause new blue screens; the last is work for inspection, not for testing at home. If Safe Mode cannot be entered, if the recovery environment cannot be reached, or if the machine blue-screens in Safe Mode as well, stop testing and bring the record so far to inspection. The record is already useful at that point — it says where the fault is not — and further testing on a machine that cannot reach Safe Mode risks more than it can reveal.

What to Bring for Inspection

If the comparisons point toward a hardware layer or a system-file layer, or if they point nowhere conclusive, the next step is a professional inspection. Bring the full record: the stop code and driver filename from every blue screen seen, the driver versions before and after the install, how the driver was installed, the Safe Mode result, the clean-removal result, the version comparison result, and whether Windows Update reinstalled the driver. Mention the minidump files at C:\Windows\Minidump, and do not delete them. The three-sentence conclusion from step seven is the summary of that record.

Inspection and repair pricing follows the site's published three-tier scale of HK$400 to HK$2,800, with the actual quote given after inspection. No price in this guide should be read as a quote for a particular fault, and no fee is stated here for any specific repair.

The workshop is at Room 1209, Dali Plaza, Shek Mun. The telephone number is 2186 8010, and the WhatsApp number is 6558 6806. There is no Mong Kok shop, and there is no on-site service — inspection is carried out at the workshop.

Frequently Asked Questions

I installed a driver and now the machine blue-screens on every boot. Is my graphics card dead?

Not necessarily. A blue screen is Windows raising an error check, and the timing — working before the install, looping on the first restart after it — points at the driver load first. A card fault is possible, but it is not the conclusion the evidence supports at the start. Run the Safe Mode comparison and the clean-removal test first: if the machine is stable in Safe Mode and stable again after the driver is removed, the fault follows the driver, not the card.

The blue screen disappears too fast to read. How do I read the stop code?

Switch off the automatic restart from the recovery environment. Find the BitLocker recovery key first if the machine uses BitLocker. Then interrupt the startup repeatedly until the Automatic Repair screen appears, go to Troubleshoot, then Advanced options, then Startup Settings, and choose the option to disable automatic restart after failure. The machine will fault once more and stop on the blue screen, and the full stop code and driver filename can be read and photographed.

What does the filename on the blue screen actually tell me?

It tells which driver was running when the system stopped. The common graphics filenames are nvlddmkm.sys for NVIDIA, amdkmdag.sys or atikmpag.sys for AMD, and igdkmd64.sys for Intel. A filename that matches the card in the machine is consistent with a graphics driver fault. A filename that does not match the hardware is a clue in itself and should be written down. Either way, the filename is where the fault surfaced, not the cause itself — the cause can sit one step behind it, in the install package, a leftover file, or the version.

Safe Mode works fine. Does that mean the problem is fixed?

No. Safe Mode only loads the most basic drivers and deliberately skips the full graphics driver, so a machine that is stable in Safe Mode has only shown that the fault follows something normal startup loads. The clean-removal test and the version comparison still have to be done. The machine is not fixed because it runs in Safe Mode, and the loop will return the moment normal startup loads the driver again.

Should I roll back the driver or use DDU first?

It depends on whether the desktop can be reached. If the desktop can be reached, roll back first, because Windows usually keeps a copy of the old driver and it costs the least. If the machine is stuck in a loop and cannot reach the desktop, Safe Mode and clean removal come first. Both orders are comparison tests, not repairs, and both are valid in the situation they fit.

Should I install the newest driver or an older one?

Use the timeline, not the release date. Install a version that previously ran normally on this machine and see whether the loop goes away — that is the comparison that answers the question. The newest version is not automatically the most suitable for this machine, and no version should be treated as generally good or generally bad. Versions change, and the current official release is the only reference that stays valid.

I used DDU and reinstalled, and it blue-screened again. What does that mean?

It depends on what was reinstalled. If the same version was reinstalled from the same package, the loop returning says nothing new — the same version, or the same damaged package, would be expected to fail again. If a previously working version was installed and it still loops, the fault is not a version problem, and the investigation moves to the system-file layer. Write down exactly which version was installed after the removal, because without that detail the result cannot be read.

Windows Update keeps installing the same driver and the loop comes back. Why?

Because Windows Update can install a graphics driver on its own, and it can install the same version again after it has been removed. The fault has moved to the update-source layer: the problem is not only the driver, but the source that keeps putting the same driver back. Removing the driver again without dealing with the source will only repeat the loop. Controlling which driver Windows Update installs is the next step, and it is separate from the driver comparison itself.

The stop code changes each time the machine loops. Does that mean there are several faults?

Not necessarily, but it does mean the fault is not pinned to a single point. A fault tied to one driver tends to report the same code each time, while a code that changes from one boot to the next suggests the failure is not settled in one place. Write down every code seen rather than only the first — the change itself is diagnostic information, and the record of how the code changed is part of what inspection needs.

What should I record before bringing the machine in for inspection?

Record the stop code and driver filename from every blue screen, the driver versions before and after the install, how the driver was installed, the Safe Mode result, the clean-removal result, the version comparison result, and whether Windows Update reinstalled the driver. Mention the minidump files at C:\Windows\Minidump. Then put it together as three sentences: what the symptom is, which variable made the symptom appear or disappear, and which possibilities are still not ruled out.

Sources

Related articles

Related services

If you need Chip-level GPU repair, see these service pages: