GPU Fails on Windows but Works Fine on a Linux Live USB? Cross-OS Comparison, Driver Layer & Hardware Diagnosis Guide

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

GPU Fails on Windows but Works Fine on a Linux Live USB? Cross-OS Comparison, Driver Layer & Hardware Diagnosis Guide

Key Summary

The same machine and the same card fail in Windows but run normally from a Linux live USB — a split that points at the Windows driver layer, not the card. This guide builds the comparison, explains how to tell a valid test from an empty one, and shows what each result proves.

The Shape of the Problem: Same Machine, Same Card, Two Different Answers

This guide covers one specific shape, and the shape itself is the whole diagnosis. The same machine, the same graphics card, the same cable, and the same monitor behave differently depending on which operating system is running. In Windows the card shows artefacts, goes black, or crashes under load. From a Linux live USB — a complete Linux system booted from a USB stick, without installing anything — the same card runs the same kind of load and stays normal.

That combination is what makes this symptom different from its neighbours. A card that fails everywhere is a different shape. A card that fails only in one program is a different shape. A card that fails only after an update is a different shape. This guide is about a fault that follows the operating system, not the machine, and the operating system is the variable that has to be tested.

The first conclusion most owners reach is that the card is proven healthy, because it worked in Linux. The second conclusion most owners reach is that Windows itself is broken and must be reinstalled. Both conclusions are too fast. A live environment is more forgiving than Windows in several ways — a different driver, a different load, a different way of handling faults — and a single normal result in Linux narrows the fault down without proving the card is healthy. And a Windows fault does not mean Windows must be reinstalled, because the Windows side has its own layers — the driver, the update mechanism, and the fault-handling behaviour — and each of them can be tested separately.

This guide is also not a swap-machine test and not a safe-mode test, and the differences matter. As #283 already covered, a swap-machine test changes the whole machine at once: the power supply, the slot, the firmware, the driver, and the case airflow all change together, and it tests whether the fault follows the card or stays with the original machine. This guide changes only the operating system. Everything else — the machine, the card, the cable, the monitor — stays exactly where it was. And as #141 already covered, safe mode in Windows usually still shows a picture because Windows stays on its basic display driver and the full GPU driver is never started at all. Safe mode proves nothing about the 3D engine, the memory bandwidth, or the power-state switching, because it never runs any of those paths. A Linux live USB is different: it loads a complete GPU driver and can run a real 3D load. It is a comparison with a full driver, not a comparison with a basic one.

Why a Live USB Is a Different Kind of Test

A live USB works because it changes the software stack without touching the hardware. The machine boots from the USB stick into a complete Linux system that runs entirely from the stick and the memory. The hard disk is not written to, and nothing is installed, unless the reader deliberately chooses the install option. That is the whole point of the test: the hardware is identical, the software is not, and any difference in behaviour must come from the software side — the driver, the operating system, or the way each one handles the card.

The comparison only has meaning if the two sides are actually running comparable loads. "Artefacts while gaming in Windows, normal while browsing the web in Linux" is not a comparison, because the loads are not comparable: one side is heavy and the other is light. The two sides have to run the same kind of 3D load, for a comparable length of time, before the results can be read against each other. A heavy load on one side and a light load on the other proves nothing except that a light load is easier to survive.

There is a second condition, and it is the most important one in this guide: the live environment has to be genuinely using the graphics card. Booting into Linux is not the same thing as testing the card. A live environment can boot to a normal-looking desktop while the graphics card is sitting idle and a software renderer is drawing the screen instead. In that case the test has not tested the card at all, and a normal result means nothing. The driver check in Step 3 exists for exactly this reason, and it must be done before any load is run or any conclusion is drawn.

A related point from the library deserves to be named as its source rather than presented as a new finding. As #147 already covered, Linux has no TDR — Windows Timeout Detection and Recovery, the mechanism that resets the graphics driver when Windows decides it has stopped responding — so the same card running the same workload on a Linux render farm would not show a TDR-driven crash, and a dual-boot or live-environment comparison can show whether TDR is behind the crash. That single sentence is the seed of this guide, and it is limited to rendering crashes caused by TDR. This guide takes the same comparison and extends it into a complete method, for any graphics symptom — artefacts, black screens, flicker, or crashes — and the extension is assembled from standard practices rather than taken from any single official guide. That distinction is stated plainly below, in the sources section, because no reader should mistake an assembled method for an official recommendation.

The Five Suspicion Layers

A cross-system split can fail at five layers, and they must be kept separate. Testing the driver, the load, and the boot setup all at once and finding Linux normal proves nothing about which of those things did the work. The layers below run from the setup of the test itself to the hardware it is testing, and each one has its own deciding evidence.

LayerWhat it coversDeciding evidence
1. Live USB boot layerMaking the USB stick, Secure Boot, and the boot modeThe live environment boots and reaches a desktop without touching the hard disk
2. Driver loading layerWhich driver the live environment actually loads for the cardThe OpenGL renderer names the real card, not a software renderer
3. Load comparison layerWhether the two systems run a genuinely comparable 3D loadThe same kind of load, for a comparable time, on both systems
4. Windows driver and OS layerTDR, Windows Update overwriting the driver, and the driver versionLinux is normal and the Windows driver steps change the symptom
5. Hardware and firmware layerThe card itself or its firmware, when both systems failThe same symptom appears under a comparable load on both systems

Layer One: The Live USB Boot Layer

This layer is the setup of the test itself. A live USB is made by downloading a Linux image — Ubuntu is the usual choice for this test, because it is widely documented — and writing it to a USB stick with a USB writing tool. The machine is then booted from the stick, and the live mode is chosen at the boot menu. The install option must not be chosen: live mode runs from the stick and the memory, and it does not write to the hard disk.

Two cautions belong here, and both are about the same mistake. First, Secure Boot or the boot mode can stop the stick from booting at all, and that is a property of the machine's firmware settings, not a result about the graphics card. A stick that will not boot proves nothing about the card. Second, writing the image to the wrong disk during USB creation can erase data. The disk must be confirmed before anything is written — the USB stick, not the hard disk, and not any other drive with data on it. The live mode itself does not write to the hard disk, but the creation step can, if the wrong disk is chosen.

Layer Two: The Driver Loading Layer

This is the layer that decides whether the test is valid at all. Once the live environment has booted, the first thing to check is which driver is actually loaded for the graphics card — before any load is run and before any conclusion is drawn.

For AMD and Intel cards, the live environment usually loads the open-source Mesa driver straight away, and the card works under it. For NVIDIA cards, the live environment usually loads nouveau, the open-source NVIDIA driver, which is not the full proprietary NVIDIA driver. That difference matters, and it must not be smoothed over: a normal result under nouveau does not prove the proprietary driver would behave the same way, and a fault under nouveau does not prove the proprietary driver would fail too. The three manufacturers do not behave the same way in a live environment, and the guide does not pretend they do.

The check itself is done in a Linux terminal. The command `glxinfo` reports the OpenGL renderer, and the renderer name is what matters: if it names the graphics card, the real driver is loaded. If it shows `llvmpipe` or `SwiftShader`, the screen is being drawn by a software renderer, the graphics card is not being used at all, and the test is invalid. A second command, `lspci -k`, shows which kernel driver is bound to the card. These commands are named here so the reader knows what each step proves — the renderer name proves whether the card is actually in use — not as instructions to be run blindly. If the renderer shows a software renderer, stop: no load test run after that point can say anything about the card, and any normal result would be an empty one.

Laptops add a further check inside this layer. A laptop with both an integrated GPU and a dedicated card can run the test on the integrated GPU while the dedicated card sits idle, and a browser in particular will usually choose the integrated GPU to save power. On a Linux laptop with NVIDIA Optimus, the dedicated card is reached through `nvidia-prime` or by running a program with `prime-run`, and the renderer must be confirmed afterwards with `glxinfo`. A test run on the wrong card has no value as evidence about the card that was meant to be tested.

Layer Three: The Load Comparison Layer

This layer is about making the two sides comparable. Windows and Linux do not run the same programs in the same way, and the same game may not run on Linux at all without a compatibility layer such as Proton — which itself introduces a new variable, and therefore cannot be part of a clean comparison. The comparison has to use loads that run on both systems: a WebGL test page in the browser, a cross-platform memory test such as memtest_vulkan, or a 3D loop test such as Unigine Superposition.

Each of those loads proves something different. A WebGL test page proves whether the card can run a real 3D workload through the browser, and it also exposes the renderer name — a page that reports SwiftShader or llvmpipe is reporting software rendering, and the test is invalid. memtest_vulkan tests the whole card's memory, and a published guide suggests running it for at least an hour with zero errors before calling it a pass — but that duration is that guide's own suggestion, not a general standard, and it should be read as such. A 3D loop test runs a sustained load, and the same published guide suggests at least thirty minutes of looping — again, that guide's own suggestion, not a standard. The durations are not the point. The point is that the load has to be sustained long enough to reproduce an intermittent fault, and a few minutes of light load passing proves only that the fault did not appear in those few minutes.

Intermittent faults deserve a paragraph of their own, because they are the easiest to misread. A fault that appears only sometimes cannot be ruled out by a single normal run. One normal run under a comparable load narrows the fault down; it does not close the case. The load has to be maintained, and the result has to be recorded with the time it ran, rather than remembered as an impression afterwards.

Layer Four: The Windows Driver and Operating System Layer

This is the layer the test points at when Linux is normal and Windows fails. The Windows side has its own mechanisms, and each of them can be tested separately.

TDR — Timeout Detection and Recovery — is the first of them. When Windows decides the graphics driver has stopped responding, it resets the driver, and the screen can go black, flicker, or recover with an error. Linux has no TDR, so a crash that is really a TDR event will not reproduce in Linux at all. That is why a Linux-normal, Windows-fails split points at the Windows layer rather than at the card — but it points at the layer, not at a single mechanism inside it, and TDR is only one of the mechanisms in that layer.

Windows Update is the second. Windows Update can replace the installed graphics driver with its own version, silently, and a driver that was working can be overwritten by one that is not. Checking whether Windows Update has replaced the driver, and whether the symptom began after an update, is part of this layer's test.

The driver version itself is the third. A clean removal with Display Driver Uninstaller, followed by a fresh install, and then a comparison against one or two earlier driver versions, is the way to test whether the version is the trigger. Each version is tested on its own, with the same load, and the result is written down. A version that clears the symptom proves the version matters for this machine; it does not prove that version is correct for every machine.

Layer Five: The Hardware and Firmware Layer

This is the layer the test points at when both systems fail. If the same symptom appears under a comparable load in Windows and in Linux, the fault is not specific to the Windows driver or to Windows itself, and the investigation moves to the card or its firmware.

That conclusion still needs care. The two systems use different drivers, so a fault in Linux can be a Linux driver problem rather than a hardware problem, and a Linux failure does not by itself prove that Windows would fail for the same reason. The hardware conclusion is strongest when the symptom is the same on both sides under the same kind of load — the same artefacts, the same black screen, the same crash point — and weakest when the two sides fail in different ways. A useful boundary, described in a published guide, is the boot boundary: if the machine cannot even reach the BIOS screen, the fault happened before the hardware finished starting, and reinstalling a driver cannot fix it. If the machine reaches the desktop and only then fails, the fault can be a driver conflict, an unstable setting, or a hardware problem that only appears under load. That distinction belongs here because it separates a failure that happens before any driver loads from one that happens after.

Even when both systems fail, the fault still has to be separated further — the card itself, the firmware, or something else in the machine — and that separation is not part of this guide. The cross-system test ends at the boundary: both systems fail, so the Windows driver layer is no longer the suspect, and the investigation moves on to the hardware and firmware layer from there.

The Deciding Fork: Three Results, and the Third One Matters Most

The whole guide turns on one comparison, and it has three possible results. All three must be kept in view, because the third one is the result most readers miss.

If Linux runs normally under a comparable load and Windows fails, the fault points at the Windows driver or operating system layer. That is the result most readers expect, and it is the result this guide is built around — but it is a pointer, not a proof, because the live environment is more forgiving than Windows, and a normal result narrows the fault down without proving the card is healthy.

If both systems fail under a comparable load, the fault points at the hardware or firmware layer. The Windows driver is no longer the suspect, and no further time should be spent circling the driver layer. But the two failures have to be the same kind of failure under the same kind of load, because the two systems use different drivers, and a Linux failure can be a Linux driver problem on its own.

If Linux cannot even load a real GPU driver — if the renderer shows llvmpipe or SwiftShader, meaning the screen is drawn by a software renderer — the test is invalid, and no conclusion can be drawn at all. This is the result that matters most, because it is the one that looks like a pass. The machine boots, the desktop looks normal, a web page opens, and everything seems fine — while the graphics card has not been used once. A reader who treats "Linux booted" as "Linux passed" has run no test at all, and any conclusion drawn from that result is built on nothing. The driver check in Step 3 exists to catch exactly this case, and it must be done before any load is run.

What the Published Sources Say, and What They Do Not Prove

The published sources for this guide describe individual tools, individual guides, and individual mechanisms, and none of them can be turned into a general rule. They are worth naming honestly, because a reader who only sees one of them can easily mistake a single guide's suggestion for a standard.

A WebGL GPU detection page from checkadevice.com states plainly that if the renderer shows SwiftShader, Google SwiftShader, or llvmpipe, the browser is using software rendering, hardware acceleration is not enabled, or the GPU driver failed to initialise, and it notes that on Linux with NVIDIA Optimus the dedicated card is reached through nvidia-prime or `prime-run`, confirmed afterwards with `glxinfo`. That is a third-party tool page, not an official document.

A cross-platform guide to testing a used graphics card from src.gdn describes a Linux testing flow: using `nvidia-smi` to check the model, the memory, the VBIOS, and the PCIe link; running memtest_vulkan across the whole card's memory, suggesting at least an hour with zero errors before calling it a pass; running Unigine Superposition in a loop or an OCCT GPU test as a sustained load, suggesting at least thirty minutes; and monitoring with nvtop on Linux. Those durations are that guide's own suggestions, not general standards, and the tools it names work in a live environment in the same way they work on an installed one.

A guide from gpusolutions.net separates boot problems from driver problems: if the machine cannot reach the BIOS screen, the fault happened before the hardware finished starting, and reinstalling a driver cannot fix it; if the machine reaches the desktop and only then fails, the fault can be a driver conflict, an unstable setting, or a hardware problem that only appears under load. That division lines up with this guide's cross-system fork, and it is a third-party guide, not a manufacturer's document.

One honest gap has to be stated plainly, and it is the most important statement in this section. No single official document or authoritative guide was found that presents "live USB GPU diagnosis" as a standard procedure. The method in this guide is assembled from standard practices — booting a live USB, confirming which driver is loaded, running cross-platform test tools, and reading the results as a comparison — and that assembly is what it is: an assembled method, not an official recommendation, and not a procedure guaranteed to be accurate. A reader who follows it is following an assembled method, and should know that.

The seed of the method, as noted above, is the single sentence from #147: Linux has no TDR, so the same card running the same workload on a Linux render farm would not show a TDR-driven crash, and a dual-boot or live-environment comparison can show whether TDR is behind the crash. That sentence is the source of the TDR part of this guide, and it is limited to rendering crashes caused by TDR. The extension to every graphics symptom is this guide's own, and it is presented as an assembled method for that reason.

The Seven Steps

Work through these steps in order, changing one thing at a time and writing down the result after each step. A test that changes two things at once proves nothing about which change mattered, and the fault will return the next time only one of those conditions is present.

Step 1: Record the Windows Baseline

Before changing anything, write down the symptom in Windows: what it looks like, which program it appears in, what kind of load triggers it, whether it happens every time or only sometimes, and whether the Windows Event Viewer shows any TDR or LiveKernelEvent records. That note is the baseline every later step is compared against, and it is also the record an in-shop inspection will need.

Step 2: Make the Live USB

Download an Ubuntu image and write it to a USB stick with a USB writing tool. Confirm the target disk before writing — the USB stick, not the hard disk, and not any other drive with data on it — because choosing the wrong disk during creation can erase data. Boot the machine from the stick and choose the live mode at the boot menu. Do not choose the install option: the live mode runs from the stick and the memory, and it does not write to the hard disk.

Step 3: Start Up and Confirm Which Driver Is Loaded

Once the live environment has booted, confirm which driver is loaded for the graphics card before running any load. In a Linux terminal, `glxinfo` reports the OpenGL renderer — the name it shows is what matters — and `lspci -k` shows which kernel driver is bound to the card. If the renderer names the graphics card, the real driver is loaded and the test can proceed. If the renderer shows `llvmpipe` or `SwiftShader`, the screen is drawn by a software renderer, the graphics card is not being used, and the test is invalid: stop here, because no load test run after that point can say anything about the card. On a laptop, also confirm which card is running the test — the integrated GPU or the dedicated one — because a browser will usually choose the integrated GPU to save power, and a test run on the wrong card has no value as evidence about the other one.

Step 4: Run a Comparable 3D Load

Run a 3D load that can be compared with the Windows side: a WebGL test page, a cross-platform memory test such as memtest_vulkan, or a 3D loop test such as Unigine Superposition. The load has to be the same kind as the Windows load, and it has to run for a comparable length of time. Do not compare a heavy load on one side with a light load on the other — "artefacts while gaming in Windows, normal while browsing the web in Linux" is not a comparison. Keep the load running long enough to give an intermittent fault a chance to appear, and note the time it ran rather than remembering it as an impression.

Step 5: Record the Comparison Table

Write down the comparison: the two systems, the same kind of load, whether the symptom appeared, which driver was loaded on each side, and how long the load was maintained. Write it down with the times, rather than relying on memory afterwards. That table is the evidence the fork is read from, and it is also the record an in-shop inspection will need.

Step 6: When Linux Is Normal, Work the Windows Driver Layer

If Linux runs normally under a comparable load and Windows fails, go back to Windows and work the driver layer. Remove the driver completely with Display Driver Uninstaller, install it fresh, try one or two earlier versions, and check whether Windows Update has overwritten the driver. Test each version on its own, with the same load, and write down the result after each change. A version that clears the symptom proves the version matters for this machine; it does not prove that version is correct for every machine.

Step 7: When Both Systems Fail, Stop at the Hardware and Firmware Layer

If both systems fail under a comparable load, stop circling the driver layer. The fault points at the hardware or firmware layer, and the investigation moves there — but it still has to be separated further, and that separation is not part of this guide. Write the conclusion in three sentences: what the symptom is, which change made the symptom appear or disappear, and which possibilities are still not ruled out. That note is the record that makes any further step — including an in-shop inspection — start from evidence instead of from the beginning.

Six Common Misconceptions

Misconception 1: "Linux is normal, so the card is definitely fine"

Wrong. A live environment runs a different driver and a different load from Windows, and a normal result narrows the fault down without proving the card is healthy. A normal result in Linux points at the Windows layer; it does not clear the card.

Misconception 2: "The live USB booted, so the test is valid"

Wrong. Booting is not testing. A live environment can reach a normal-looking desktop while a software renderer is drawing the screen and the graphics card sits idle. If the renderer shows llvmpipe or SwiftShader, the test is invalid, and no conclusion can be drawn from it at all.

Misconception 3: "I don't know Linux, so I can't do this"

Wrong. A live USB needs no installation and no Linux knowledge to boot to a desktop. The part that needs care is the driver check — reading the renderer name to confirm the card is actually in use — and if that step cannot be done confidently, no conclusion should be drawn from the test. Not knowing the commands is a reason to stop at the check, not a reason to skip it.

Misconception 4: "One test is enough"

Wrong. An intermittent fault can pass a single normal run by chance. The load has to be maintained for a comparable length of time, and a few minutes of light load passing proves only that the fault did not appear in those few minutes. A single normal run narrows the fault down; it does not close the case.

Misconception 5: "If Linux fails, Windows must fail too"

Wrong. The two systems use different drivers, so a fault in Linux can be a Linux driver problem on its own, and it does not directly prove anything about Windows. The hardware conclusion is strongest when both sides fail in the same way under the same kind of load, and weakest when they fail differently.

Misconception 6: "A live USB will write to my hard disk"

Wrong. Live mode itself does not write to the hard disk; writing only happens if the install option is deliberately chosen. But the creation step can erase data if the wrong disk is chosen when writing the image to the USB stick, so the target disk must be confirmed before anything is written.

Boundaries: Problems That Look Similar but Are Not This One

Several problems look like a cross-system split but belong to other guides, and naming them here saves the reader from following the wrong diagnosis.

A swap-machine test — moving the card into a different machine to see whether the fault follows the card — belongs with #283, which changes the whole machine at once: the power supply, the slot, the firmware, the driver, and the case airflow. This guide changes only the operating system, and the two tests answer different questions. A safe-mode test belongs with #141: safe mode runs on Windows' basic display driver alone and never starts the full GPU driver, so it proves nothing about the 3D engine, the memory bandwidth, or the power-state switching. A rendering crash that is specifically a TDR crash belongs with the single sentence in #147, which is the seed of this guide, not its whole method. A repair-bench memory diagnosis that uses Linux MODS and MATS belongs with #127 and #128 — those are bench tools, not a user comparison. And eGPU behaviour under Linux, including its tools and authorisation mechanism, belongs with #140, which states its own focus is Windows and macOS. And a fault that appears in only one program, in only one system, belongs with the guides for that program rather than with a cross-system comparison. This guide only covers the shape where the same machine and the same card behave differently under two operating systems, with a comparable load on both sides.

When to Stop and Bring the Machine In

Stop when all seven steps have been worked through, one variable at a time, and the layers still cannot be separated. Stop sooner if the machine shuts itself down, if the fault appears together with a burning smell or visible damage, or if any step involves opening the machine or changing firmware — those belong to professional inspection. Stop also if the live environment cannot load a real GPU driver and the renderer shows a software renderer: the test is invalid, and no conclusion should be drawn from it.

Bring the machine in with the notes from the seven steps: the Windows baseline, including any TDR or LiveKernelEvent records; which live USB image was used; which driver the live environment loaded and what the renderer showed; which comparable loads were run on each side and how long each ran; the comparison table with the times; and, if Linux was normal, which driver versions were compared in Windows and whether a clean removal was done. That record is what makes an in-shop inspection efficient, because it shows exactly which layers were tested and which evidence each one produced.

In-store inspection takes place at Room 1209, Dali Plaza, Shek Mun. You can call 2186 8010, or reach the shop on WhatsApp at 6558 6806. Inspection is charged at the site's published three-tier fees of HK$400–2,800 (Tier 1 HK$400–780, Tier 2 HK$480–1,380, Tier 3 HK$680–2,800), with the actual price subject to a post-inspection quote. There is no home-visit service and no Mong Kok shop; inspection is carried out in the shop.

A diagnosis that ends at the stop line is not a failed diagnosis. A note that says "Artefacts in Windows under a 3D load, live USB booted, renderer names the card, same kind of load ran normally for half an hour, Windows driver cleanly removed and reinstalled, one earlier version tried, symptom unchanged" is a precise description of where the fault lives, and it is exactly what an in-shop inspection needs to start from the right place instead of from the beginning.

FAQ

My card fails in Windows but works from a Linux live USB — does that prove the card is fine?

No. It points at the Windows driver or operating system layer, but it does not prove the card is healthy. A live environment runs a different driver and a different load from Windows, and it is more forgiving in several ways. A normal result in Linux narrows the fault down; it does not clear the card. Work the Windows driver layer next — a clean removal, a fresh install, and a comparison against one or two earlier versions — before drawing any conclusion about the card itself.

The live USB booted to a normal desktop — is the test valid?

Not yet. Booting is not testing. Check which driver is loaded before running any load: in a Linux terminal, `glxinfo` reports the OpenGL renderer, and `lspci -k` shows which kernel driver is bound to the card. If the renderer shows `llvmpipe` or `SwiftShader`, the screen is drawn by a software renderer, the card is not being used at all, and the test is invalid. Stop there — no load test run after that point can say anything about the card.

Why can't I just compare gaming in Windows with browsing the web in Linux?

Because the loads are not comparable. A heavy load on one side and a light load on the other proves nothing except that a light load is easier to survive. The two sides have to run the same kind of 3D load, for a comparable length of time — a WebGL test page, a cross-platform memory test such as memtest_vulkan, or a 3D loop test such as Unigine Superposition — before the results can be read against each other.

Both systems fail — does that mean the card is definitely broken?

Not definitely, but the investigation moves to the hardware and firmware layer, and no further time should be spent circling the Windows driver layer. The conclusion is strongest when both sides fail in the same way under the same kind of load. The two systems use different drivers, so a Linux failure can be a Linux driver problem on its own, and the hardware layer still has to be separated further — the card itself, the firmware, or something else in the machine.

What is TDR, and why does it matter for this comparison?

TDR is Windows Timeout Detection and Recovery: when Windows decides the graphics driver has stopped responding, it resets the driver, and the screen can go black, flicker, or recover with an error. Linux has no TDR, so a crash that is really a TDR event will not reproduce in Linux at all. As #147 already covered, a dual-boot or live-environment comparison can show whether TDR is behind a rendering crash — but that sentence is limited to TDR-driven crashes, and this guide extends the same comparison into a complete method for any graphics symptom.

I don't know Linux — can I still run this test?

A live USB needs no installation and no Linux knowledge to boot to a desktop. The part that needs care is the driver check — reading the renderer name to confirm the card is actually in use — and if that step cannot be done confidently, no conclusion should be drawn from the test. Not knowing the commands is a reason to stop at the check, not a reason to skip it and treat a booted desktop as a pass.

Will a live USB write to my hard disk or erase my files?

Live mode itself does not write to the hard disk; writing only happens if the install option is deliberately chosen at the boot menu. But the creation step can erase data if the wrong disk is chosen when writing the image to the USB stick, so the target disk must be confirmed before anything is written — the USB stick, not the hard disk, and not any other drive with data on it.

My laptop has two graphics cards — which one is the test actually using?

That has to be checked, because a browser will usually choose the integrated GPU to save power, and a test run on the integrated GPU says nothing about the dedicated card. On a Linux laptop with NVIDIA Optimus, the dedicated card is reached through `nvidia-prime` or by running a program with `prime-run`, and the renderer must be confirmed afterwards with `glxinfo`. If the renderer names the wrong card, the test has measured the wrong thing.

How long should the load run before I trust the result?

There is no general standard, and no duration in this guide should be read as one. A published guide suggests at least an hour of memtest_vulkan with zero errors and at least thirty minutes of a 3D loop test, but those durations are that guide's own suggestions, not standards. The principle is that the load has to be sustained long enough to give an intermittent fault a chance to appear, and a few minutes of light load passing proves only that the fault did not appear in those few minutes.

If all seven steps still cannot separate the layers, what should I bring for inspection?

The notes from the seven steps: the Windows baseline, including any TDR or LiveKernelEvent records; which live USB image was used; which driver the live environment loaded and what the renderer showed; which comparable loads were run on each side and how long each ran; the comparison table with the times; and, if Linux was normal, which driver versions were compared in Windows and whether a clean removal was done. The shop is at Room 1209, Dali Plaza, Shek Mun, telephone 2186 8010, WhatsApp 6558 6806. Inspection is charged at the site's published three-tier fees of HK$400–2,800, quoted after inspection. There is no home-visit service and no Mong Kok shop.

Related articles

Related services

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