A PC that boots into Windows and runs a benchmark for ninety seconds without crashing is not the same thing as a stable PC. The real test happens when every core and every shader are pegged at once for twenty minutes straight, drawing full power, dumping full heat into the case, and giving a badly-seated cooler, a marginal power supply, or an undersized case fan nowhere to hide. That is what a stress test actually checks, and it is the step most builders skip right before the machine locks up two weeks later during a long render or a ranked match. Call it a PC stress test or just stress test your computer before you trust it with real work; either way, the goal is the same: find the weak link now, on your own schedule, instead of mid-render.
This tutorial walks through a complete PC stress test in 12 steps: a GPU stress test, a CPU stress test, and the combined run that ties them together, using free tools that already sit at the top of the download charts for PC builders: FurMark, Prime95, Cinebench, Unigine Superposition, OCCT, and HWiNFO64. Geeks3D has kept FurMark on an aggressive release cadence since then: FurMark 2.10.1.0 landed on 24 October 2025 according to FileHorse, and Journal du Geek lists build 2.10.2 as the current release as of October 2025; OpenBenchmarking.org had already logged 106 public FurMark 2 stress-test results by February 2025, a sign of how widely the tool gets used for exactly this kind of comparison. That cadence goes back further than it looks: the 2.6.0.0 release alone added support for three RTX 50-series GPUs back in February 2025, per Geeks3D. The multiplatform FurMark 2 line it belongs to now runs natively on both Windows and Linux with Vulkan 1.1 and OpenGL 3.2 support built in, so the GPU-stress steps below apply no matter which OS you are testing from. Budget about 60 minutes for the full sequence: roughly 10 minutes of preparation up front (Steps 1 through 3), then for the GPU portion specifically, a minimum of 20 minutes of execution, extended to 30 minutes if you are testing a high-end card such as an RTX 4080+ or RX 7900 XTX. As of August 2026, this is still the validated sequence for catching a bad cooler mount, a marginal PSU, or a defective card before it fails somewhere less convenient. By the end you will have logged real sensor data, caught any thermal or power problem on the spot, know which computer heat monitor to keep running afterward and how to fix a graphics driver crash if one shows up mid-test, and built a small Python tool that turns raw temperature logs into a pass-or-fail report you can rerun after every driver update.
Timing matters here more than it used to. Nvidia’s RTX 5090 carries a 575W board power rating, and even a mid-range RTX 5070 Ti pulls 300W under load. On the CPU side, AMD’s X3D chips and Intel’s current Core Ultra parts both run close to their thermal ceiling out of the box just to hit their rated boost clocks. None of that headroom is a problem by itself, but it means a marginal cooler mount or a PSU cable that is not fully seated shows up as a crash under stress far sooner than it would during everyday browsing and word processing.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
Why a New PC Build Needs a Real Stress Test
Every component in a new build is tested in isolation at the factory, not tested together in your specific case with your specific airflow. A CPU cooler that looks correctly mounted can still sit a few degrees off from full contact, a RAM kit running at its rated speed can still be unstable once it warms up, and a power supply rated for 750W can still sag under a sudden combined load spike even if it never trips on paper. A stress test exists to surface exactly those problems in a controlled twenty-minute window, in your own home, instead of during a client render at 11pm.
The economics are simple. A stress test costs an hour of your time. A crash during unsaved work costs the work itself, plus the time spent troubleshooting a problem that stress testing would have caught in the first sitting. Builders who skip this step are not saving meaningful time. They are just moving the risk to a moment they do not get to pick.
One build guide from EVETech frames a fresh build’s checklist about as plainly as it gets: “Stability: Prime95, MemTest86, FurMark.” That three-tool shorthand has held up for years because it still covers the three parts most likely to fail under sustained load, the CPU, the RAM, and the GPU. This guide expands that shorthand into a full, repeatable routine, including two tools most quick-start guides skip entirely: OCCT for combined system stress, and HWiNFO64 for the sensor logging that turns “seems fine” into a number you can actually check against a limit.
If you just finished assembling the machine and have not yet touched driver tuning, it is worth running this stress test routine before you do anything else, including before you attempt a GPU undervolt or enable XMP or EXPO on your RAM. You want a known-stable baseline first. Every tuning change after that gets measured against this baseline, not against a guess.
GPU Stress Test vs CPU Stress Test: What Each One Checks
A GPU stress test and a CPU stress test are not interchangeable, and running only one tells you nothing about the other component. Some readers land here wanting to stress test the CPU specifically, others want a GPU stress test for a new card, and others just want to stress test the computer as a whole after a fresh build; the distinction below determines which tool to reach for first. A GPU test like this, run through a tool such as FurMark (Geeks3D’s build 2.10.2, current as of October 2025 per Journal du Geek) or Unigine Superposition, hammers the graphics card’s shader cores and memory controller with a synthetic 3D workload designed to pull more sustained power than most games ever will. It is checking three things at once: whether the cooler can hold temperatures inside a safe range, whether the power delivery on the card and the PSU can sustain peak draw without voltage sag, and whether the GPU itself is free of manufacturing defects that show up as visual artifacts under load. Not all GPU stress tests target the same failure mode, either: some push raw thermal and power load, others push memory-controller stability or real-world rendering, which is why Steps 6 and 7 below use more than one.
Running the CPU equivalent, through Prime95 or a Cinebench loop, does the same job for the processor. Prime95’s torture test modes push every core at once with math operations chosen specifically because they generate more heat than almost any real application, which is exactly why it is the standard tool for finding a CPU’s absolute worst-case thermal ceiling. Cinebench instead measures a real rendering workload, so it tells you less about worst-case heat and more about sustained, real-world performance, including whether the chip is throttling under a workload you would actually run.
Here is the distinction that trips up a lot of new builders: a machine can pass each test independently and still crash the first time you run both at once, because the two components draw power from the same PSU rails and dump heat into the same case air. That is why step 8 in this guide covers a combined system stress test using OCCT, which loads the CPU, GPU, and RAM simultaneously. Skipping that step and calling the job done after two clean individual runs is one of the most common gaps in a home stress test routine.
Prerequisites: Tools, Versions, and a Safety Checklist
You do not need anything exotic to run a full PC stress test at home. Every tool below is free, and the entire routine works on any desktop built in the last several years. What you do need is about an hour of uninterrupted time, a case with its side panel on (testing open-air changes your thermal results), and a plan for what happens if a test fails, which mainly means: stop, and do not push forward into a second test while the first one is still throwing errors.
Tools You Will Use
Install these before you start so you are not hunting for downloads mid-session. FurMark’s release history alone shows how fast this space moves: Geeks3D shipped 2.10.0.0 on 17 October 2025, 2.9.0.0 on 15 July 2025 (having added GeForce RTX 5050 and Radeon AI PRO R9700 support just days earlier, on 9 July 2025), 2.8.0.0 in April 2025 with RTX 5060 Ti, RTX PRO 6000 Blackwell, and RTX 5090 Laptop support, and 2.7.0.0 on 12 March 2025 adding Radeon RX 9070 XT/9070 and GeForce RTX 5070 support; Geeks3D also maintains a lightweight legacy build, FurMark 1.39.1.0, current as of 29 April 2025 for older GeForce, Radeon, and Arc GPUs. FurMark is no longer the only game in town, either: SoftwareOK pushed its own StressTheGPU tool to version 1.44 in March 2026 with minor improvements and a language-file update, and GamesPress/EzBench reported an Early Access GPU stress test called NukeMark, built in Unreal Engine 5.7, launching in July 2026. For every other tool below, where a specific version could not be confirmed at publication time, this guide lists “latest version” rather than guessing at a number.
| Tool | Version | What It Tests |
|---|---|---|
| HWiNFO64 | 8.48 or newer | Live sensor monitoring and CSV logging for CPU and GPU |
| FurMark (Geeks3D) | Latest version | GPU thermal and power stress test |
| Prime95 (GIMPS) | Latest version | CPU worst-case thermal and stability stress test |
| Cinebench (Maxon) | Latest release | CPU real-world render benchmark |
| Unigine Superposition | Latest version | GPU stability and real-world load benchmark |
| OCCT | Latest version | Combined CPU, GPU, and RAM stress test |
| PassMark MemTest86 | Latest free edition | Bootable RAM stability test |
| Python | 3.10 or newer | Running the log-analysis script in Step 10 |
One contributor to a heavily-upvoted r/buildapc thread on stress testing summed up a similar stack in a single line: “Use Prime95 to stress-test CPU overclocking, Heaven for GPU overclocking, run Cinebench in a loop to monitor temperatures, and rely on Aida64 to verify OS stability.” This guide follows that same general shape, substituting Superposition and OCCT for Heaven and Aida64 since both are actively maintained in 2026 and cover slightly more ground.
Safe Temperature and Power Targets
Before you run a single test, know what number would actually worry you. These are general, widely-published ranges rather than an exact spec for any one chip, since your specific model’s throttle point varies. Treat the right-hand column as the point where the component’s own firmware starts pulling back clocks to protect itself, not as a damage threshold.
| Component | Comfortable Under Load | Starting to Worry | Typical Throttle Point |
|---|---|---|---|
| Nvidia RTX 50-series GPU | Under 75°C | 75-83°C | ~83-90°C, varies by model |
| AMD RX 9000-series GPU | Under 75°C | 75-85°C | ~90-95°C junction temp |
| Intel Core (current gen) | Under 85°C | 85-95°C | ~100-105°C (Tjmax) |
| AMD Ryzen X3D | Under 80°C | 80-89°C | ~89-95°C, cache-limited |
| DDR5 RAM (standard kits) | Under 45°C | 45-55°C | Varies by kit, often 85°C+ spec ceiling |
| GPU Hotspot (any brand) | At or below 93°C | 93-95°C | >95°C for 90+ seconds = fail |
Power draw is worth watching alongside temperature. If you are unsure what your GPU is actually rated for, check it against a card like the ones compared in our RTX 5090 vs RTX 5070 Ti breakdown before you assume a reading is abnormal. A card pulling close to its rated board power under FurMark is expected behavior, not a failure.
How to Stress Test a GPU and CPU: Step-by-Step
A guide published on Drizz.dev opens its own version of this routine with a line worth borrowing: “If you’ve just built a PC or installed new components, here’s the full testing sequence.” The order below is deliberate. Each step builds on the one before it, starting with the least invasive check and ending with the automation that makes the whole routine repeatable.
Step 1: Update Drivers, BIOS, and Chipset Software First
Stress testing on an outdated driver wastes your time twice, once when the test fails for a reason that has nothing to do with your hardware, and again when you have to redo everything after the update anyway. Update your GPU driver, your motherboard’s chipset driver, and check for a BIOS update before you install a single stress-test tool. Confirm what you are currently running from PowerShell:
Get-CimInstance Win32_VideoController | Select-Object Name, DriverVersion, DriverDateIf that date is more than a couple of months old, update before continuing. A BIOS update matters just as much on a brand-new motherboard, since launch-day BIOS revisions are frequently the ones with the least mature memory training and power delivery tuning.
Step 2: Record a Clean Idle Baseline
Before any load goes on the system, close every background application and let the machine sit idle for five minutes. Then take a snapshot of idle temperature, power draw, and clock speed. On Nvidia hardware, the fastest way to do this is a single command-line query, using the nvidia-smi utility documented directly on Nvidia’s developer site, rather than opening a full monitoring overlay:
nvidia-smi --query-gpu=name,temperature.gpu,power.draw,clocks.gr,clocks.mem --format=csvWrite these idle numbers down somewhere you will actually look at again. Every load number you collect for the rest of this guide only means something in comparison to this baseline, and it is also your fastest way to notice if a later driver update quietly changes idle behavior.
Step 3: Install and Configure HWiNFO64 for Live Sensor Logging
HWiNFO64 is the sensor backbone for this entire routine. Install it, launch the Sensors-only mode, and open its logging configuration. Set a logging interval of 2 to 5 seconds, enable CSV export, and select at minimum: CPU package temperature, CPU package power, GPU temperature, GPU hotspot temperature if your card reports one, and GPU power draw. Start the log now and leave it running in the background for every test that follows. Trying to remember peak numbers from memory instead of logging them is how builders miss a five-second temperature spike that happened while they looked away from the screen.
Step 4: Run a CPU Stress Test With Prime95
Launch Prime95 and choose the Small FFTs torture test mode, which maximizes heat output rather than memory bandwidth, making it the closest thing to a worst-case thermal test your CPU will ever see. Let it run for 15 to 20 minutes while you watch HWiNFO64’s live readout. Package temperature should climb quickly in the first minute or two, then level off. A temperature that keeps climbing without leveling off, or a temperature that touches your chip’s throttle point from the table above within the first five minutes, is a sign to stop and check your cooler mount before continuing.
Prime95 is intentionally harsher than any real application, including demanding renders and games, so treat a clean pass here as your ceiling test rather than your only test. A CPU that runs hot under Prime95 but stays well under its throttle point is behaving normally, not failing.
Step 5: Run a CPU Benchmark Loop With Cinebench
Where Prime95 checks worst-case heat, Cinebench checks real-world sustained performance. Maxon’s current Cinebench 2026 release added support for Apple’s M5 chips and Nvidia’s RTX 5000-series GPUs, so the benchmark you are running is scored against the same generation of silicon most 2026 builds actually ship with. Run the multi-core benchmark once, note the score, then immediately run it again without letting the CPU cool down. If your second score drops more than roughly 5 to 10% from the first, the chip is thermal throttling under sustained load, which points back to cooling rather than to the chip itself. Repeat the back-to-back run a third time if the first two scores disagree by more than that, since a single anomalous run is not enough to diagnose a real throttling pattern.
Step 6: Run a GPU Stress Test With FurMark
FurMark’s “fur” rendering workload is famous in PC building circles for pulling more sustained power than almost any game, which is precisely why it remains the standard first GPU stress test more than a decade after its original release; run whatever build Geeks3D currently ships, since recent point releases have kept pace with new silicon, including the RTX 5090, 5080, and 5070 Ti support added in the 2.6.0.0 release on 21 February 2025. For thermal validation specifically, run FurMark at 1920×1080 with 0% anti-aliasing, or match your own monitor’s native resolution if you run something higher, enable the built-in stress test mode, and let it run for a minimum of 20 minutes, extending to 30 minutes on a high-end card such as an RTX 4080+ or RX 7900 XTX; other 2026 guidance on this step converges on the same 20-to-30-minute window. While it runs, start a continuous log of GPU sensor data alongside your HWiNFO64 log, which is useful later if you build the Python report in Step 10:
nvidia-smi --query-gpu=timestamp,temperature.gpu,power.draw,clocks.gr --format=csv -l 5 -f gpu-log.csvWatch for two failure signs specifically: visual artifacts (flickering triangles, discolored patches, or texture corruption) and an unexpected driver crash or “display driver stopped responding” message. Either one points to a GPU that is unstable under sustained load, not just hot.
Step 7: Run a GPU Benchmark With Unigine Superposition
Unigine Superposition complements FurMark rather than replacing it. Where FurMark is a synthetic thermal torture test, Superposition renders a detailed, game-like 3D scene, which makes it a better proxy for how your card behaves during actual gameplay. Run the 1080p Extreme preset for a shorter check, or for general stability validation, use the 4K Optimized preset at your native resolution with 8x MSAA at Extreme quality, the combination that surfaces instability the lighter presets tend to miss. Superposition also includes a built-in stability testing mode that runs the scene in a loop for a set duration, which is worth using here as a second, independent confirmation of whatever FurMark already showed you. If you want a pure comparative score to track over time, 3DMark is worth adding to the rotation as well, and it is worth watching more closely lately: UL Solutions folded new stress tests into 3DMark’s Advanced and Professional editions during 2026, then in June 2026 announced its next-generation 3DMark GPU Benchmark outright, with Seasonic signing on as a sponsor the following month. Tellusim added another option to that rotation in July 2026 with GravityMark, pitched as a combined GPU stress, stability, and efficiency test rather than a pure benchmark, giving builders yet another cross-check beyond FurMark and Superposition.
Step 8: Run a Combined System Test With OCCT
This is the step that catches problems individual component tests cannot. OCCT’s Combined test mode loads the CPU, GPU, and RAM simultaneously, which is the closest a synthetic benchmark gets to the real demand profile of a modern game running physics, ray tracing, and background processes all at once. One builder’s community-shared routine, posted in a PC-building Facebook group, describes almost exactly this approach: “Run Prime95 for the CPU, FurMark for the GPU, and OCCT combined stability test, all simultaneously, for 30 to 60 minutes while monitoring temps with Hardware Info.” OCCT’s reputation for this holds up in independent scoring, too: WorldMetrics rated it 9.2 out of 10 as of August 2026, among the highest marks of any tool in this guide. Run OCCT’s Combined test for at least 20 minutes, longer if your first individual GPU and CPU tests ran clean with room to spare.
OCCT also has a GPU-only test worth running on its own, separate from Combined mode, specifically to validate VRAM reliability: set an 8 GB buffer size and run it in OpenCL mode for 30 minutes. OCBASE rolled new memory test presets into OCCT v17 Stable during 2026, so dialing in that buffer size and mode is largely a matter of picking the right preset rather than configuring the VRAM test by hand. This exercises the card’s memory controller in a way the shorter Combined pass does not, which matters most on cards with large memory pools where a single unstable memory cell can sit outside the address range Combined mode happens to touch.
If your system passes the individual GPU and CPU tests but fails here, the PSU is the first thing to check. A power supply that handles either component alone but sags under their combined peak draw is a textbook symptom of insufficient wattage headroom or a marginal-quality unit, not a symptom of a bad CPU or GPU.
Step 9: Stress Test RAM With MemTest86
RAM instability rarely shows up as a crash during a GPU or CPU stress test. It shows up as silent data corruption, a random blue screen days later, or a game save that will not load. MemTest86 tests outside of Windows entirely, from a bootable USB drive, which is what lets it access memory addresses a running OS cannot safely touch. Create the bootable USB using MemTest86’s own image-writing tool, boot from it, and let a full pass run. A complete pass across all test patterns commonly takes several hours, so this is the one step in the routine worth starting before bed or before you leave for the day rather than the one you rush through in the first 60-minute sitting.
Any error at all, even a single one, means stop and investigate before trusting the system with anything important. If you recently enabled XMP or EXPO, a single error is often resolved by dropping one speed bin or loosening timings slightly, then re-testing from scratch.
Step 10: Automate Monitoring With a Python Logging Script
By this point you have two CSV logs sitting on disk, one from HWiNFO64 and one from nvidia-smi, both full of numbers you would otherwise have to scroll through by hand to find a single spike. The next section builds a small Python project that reads both logs, checks every row against the safe limits from the table in the prerequisites section, and prints a clear pass-or-fail verdict. This turns a manual “does this number look okay to me” judgment call into a script you can rerun after every future driver update, BIOS flash, or hardware change, with the exact same criteria applied every time.
Step 11: Read Your Results and Catch Red Flags Early
With every test complete and your logs analyzed, grade the run against a hard pass/fail line instead of a vague “seems fine.” A clean pass requires no crashes, no BSODs, no WHEA errors, and no visual artifacts across every test in this guide; any one of those is an automatic fail no matter what the temperature numbers say. From there, check four specific things. First, did any component’s core temperature cross the throttle point from the safety table, even briefly? Second, and separately, did the GPU’s hotspot reading stay at or below 93°C? Treat anything that holds above 95°C for more than 90 seconds as an outright failure, since a hotspot that high points to a localized cooling or contact problem the core temperature alone will not show you. Third, did clock speeds stay steady under sustained load, or throttle more than 5% below your chip’s base frequency, a sign of unstable power delivery or an overly aggressive fan curve triggering thermal cycling? Fourth, did the combined OCCT test in Step 8 pass at the same stability level as the individual GPU and CPU tests did on their own? A system that clears all four cleanly is genuinely stable, not just lucky on one particular run.
Step 12: Cool Down, Document, and Set a Retest Schedule
Let the system idle for ten minutes after your last test before you shut anything down or start tuning further. Save your logs, your Cinebench scores, and your idle baseline from Step 2 somewhere you will find them again, ideally in the same folder as the Python script from Step 10. Set a reminder to rerun this full routine after any major GPU driver update, any BIOS update, any RAM or storage change, and at minimum once every six months even if nothing changes, since thermal paste and fan bearings both degrade slowly over time in ways a single stress test months apart is well suited to catch.
The Best Computer Heat Monitor Tools for Day-to-Day Checks
A computer heat monitor is any tool that tracks CPU and GPU temperatures continuously in the background rather than during a one-time dedicated stress test, and it matters just as much between those sessions. HWiNFO64’s Sensors-only mode, already installed back in Step 3, can stay minimized with an on-screen display active so you catch a slow thermal creep, like a fan bearing wearing out or dust building up in a filter, months before it would ever show up as a hard failure. It remains the most complete free computer heat monitor for logging CPU and GPU sensors side by side as of August 2026, which is why this guide leans on it rather than a lighter single-purpose tool.
| Computer Heat Monitor | What It Shows | Best For | Runs In Background |
|---|---|---|---|
| HWiNFO64 | CPU, GPU, VRM, and storage sensors, plus CSV logging | Builders who want every sensor and a saved log | Yes, Sensors-only mode |
| Core Temp | Per-core CPU temperature | A minimal always-on CPU-only readout | Yes, system tray |
| AIDA64 | Full system sensors plus a desktop OSD gadget | Detailed system reports alongside monitoring | Yes, paid license |
| GPU-Z | GPU temperature, clocks, and power draw | A quick GPU-only snapshot | Minimized sensor panel |
| MSI Afterburner | GPU temperature, clocks, fan curve control | Gamers who also want fan curve and overclock control | Yes, on-screen display |
| AMD Software: Adrenalin Edition | Radeon GPU temperature, clocks, power | AMD GPU owners who want a vendor-native overlay | Yes, in-game overlay |
| Nvidia App | GeForce GPU temperature, clocks, power | Nvidia GPU owners who want a vendor-native overlay | Yes, in-game overlay |
| Windows Task Manager | Basic GPU temperature (Performance tab) | A quick check with nothing extra to install | No, manual open |
For a lighter touch while gaming rather than testing, your GPU vendor’s overlay or a tray tool like Core Temp is usually enough, with none of HWiNFO64’s CSV logging overhead. Whichever computer heat monitor you pick from the table above, check its readings against the safe-target table in the prerequisites section, and set a personal alert threshold a few degrees below the “starting to worry” column rather than waiting until a component reaches its throttle point to take notice.
Build a Python Tool to Auto-Grade Your Stress Test Logs
This is the complete working project referenced in Step 10. It is a single script, stress_report.py, that reads the nvidia-smi CSV log from your GPU stress test and the CPU temperature column you configured in HWiNFO64, then prints a pass-or-fail summary for both. Save the two functions below into one file. Nothing beyond Python’s built-in csv module is required, so there is no dependency installation step to get wrong.
Start with the configuration and the two log loaders. Note that psutil, the usual go-to Python library for hardware sensors, does not expose CPU temperatures on Windows, which is exactly why this script reads HWiNFO64’s CSV export instead of querying a sensor library directly:
import csv
LIMITS = {"gpu_temp_c": 83, "gpu_power_w": 300, "cpu_temp_c": 95}
def load_gpu_log(path):
rows = []
with open(path, newline="") as f:
for raw in csv.DictReader(f):
row = {k.strip(): v.strip() for k, v in raw.items()}
rows.append({
"temp_c": float(row["temperature.gpu"]),
"power_w": float(row["power.draw [W]"].replace(" W", "")),
})
return rows
def load_cpu_log(path, temp_column):
rows = []
with open(path, newline="", encoding="utf-8") as f:
for raw in csv.DictReader(f):
rows.append({"temp_c": float(raw[temp_column].replace(",", "."))})
return rowsAdjust the three values in LIMITS to match your own hardware using the safe-target table from the prerequisites section above, and change temp_column to whatever you named the CPU package sensor when you set up HWiNFO64 logging in Step 3. Next, add the grading logic and the entry point that ties both logs together:
def summarize(label, rows, temp_limit, power_limit=None):
peak_temp = max(r["temp_c"] for r in rows)
breaches = sum(1 for r in rows if r["temp_c"] > temp_limit)
if power_limit:
breaches += sum(1 for r in rows if r.get("power_w", 0) > power_limit)
status = "FAIL" if breaches else "PASS"
print(f"{label}: peak {peak_temp:.1f}C, {breaches} breach(es) -> {status}")
return status == "PASS"
if __name__ == "__main__":
gpu_rows = load_gpu_log("gpu-log.csv")
cpu_rows = load_cpu_log("hwinfo-log.csv", "CPU Package")
gpu_ok = summarize("GPU", gpu_rows, LIMITS["gpu_temp_c"], LIMITS["gpu_power_w"])
cpu_ok = summarize("CPU", cpu_rows, LIMITS["cpu_temp_c"])
print("OVERALL:", "PASS" if gpu_ok and cpu_ok else "FAIL")Run it from the same folder as your two CSV logs with python stress_report.py. A clean run on a healthy system looks like this:
GPU: peak 81.0C, 0 breach(es) -> PASS
CPU: peak 91.4C, 0 breach(es) -> PASS
OVERALL: PASSIf a breach shows up, the script tells you immediately which component and how many samples crossed the line, instead of leaving you to scroll through thousands of CSV rows by hand. Extending it is straightforward from here. A natural next addition is a rolling average check that flags sustained high temperatures even when no single sample crosses your hard limit, which catches slow thermal creep that a simple peak-value check misses entirely.
Stress Testing an AMD-Based System: What Changes
The routine above works identically on AMD hardware, with a couple of practical adjustments. Ryzen’s X3D chips, built around a stacked 3D V-Cache die, run hotter at a given power level than their non-X3D counterparts because that extra cache layer adds thermal resistance between the compute die and the heatspreader. AMD’s own guidance and independent reviewers both treat X3D chips reaching the high-80s to low-90s Celsius under Prime95 as expected, not alarming, which is why the safety table earlier in this guide lists a separate, lower comfortable range for X3D parts specifically.
On the GPU side, Radeon cards report through AMD Software: Adrenalin Edition rather than the Nvidia-focused nvidia-smi command used in the code examples above. The equivalent live metrics overlay is built directly into Adrenalin under its Performance tab, and HWiNFO64 reads AMD GPU sensors the same way it reads Nvidia ones, so Steps 3 and 10 need no changes beyond swapping which brand-specific tool you glance at during the test itself. If you are deciding between a Radeon and a GeForce card in the same price bracket, the thermal and power differences are covered in our RX 9070 vs RTX 5070 comparison.
Stress Testing a Gaming Laptop: What Is Different
Laptops change three things about this routine, and all three make the results harder to interpret than on a desktop. First, thermal design power on a laptop chip is a dynamic, software-managed budget rather than a fixed ceiling, so the same CPU can behave completely differently across two laptop models depending on how aggressively the manufacturer tuned its power limits. Second, shared heat pipes mean GPU load and CPU load are never fully independent the way they can be on a desktop with separate coolers, since heat from one component measurably affects the other’s ceiling. Third, running on battery instead of the charger can silently cap performance well below what the laptop is actually capable of, which looks exactly like a stability problem but is not one.
Always plug in and set the power plan to its highest-performance mode before stress testing a laptop, and expect combined CPU-and-GPU load in Step 8 to run meaningfully hotter and throttle sooner than either component did in isolation. That is normal laptop behavior, not a defect, and it is precisely why Step 8’s combined test matters even more on a laptop than on a desktop.
6 Common Pitfalls When You Stress Test a GPU or CPU
- Testing components separately and stopping there. A clean individual GPU test and a clean individual CPU test do not guarantee a clean combined result. Always finish with Step 8’s OCCT combined test before declaring the build stable.
- Trusting one sensor tool without a second opinion. HWiNFO64 is reliable, but a reading that looks unusual is worth confirming against a second tool, such as your GPU vendor’s own overlay, before you assume a component is failing.
- Treating FurMark’s most extreme legacy burn-in mode as a real-world failure. FurMark can pull power well beyond what any game realistically demands. A card that struggles specifically with FurMark’s most punishing legacy settings but runs every game flawlessly is not necessarily an unstable card.
- Ignoring ambient room temperature when comparing results. A load temperature recorded in a 65°F room and one recorded in a 78°F room are not comparable numbers. Note the room temperature alongside your results if you plan to compare them later.
- Skipping the cooldown period between back-to-back tests. Starting a second test while the system is still elevated from the first one produces a worse result than the same test run from a cool baseline, which can make a perfectly healthy system look unstable.
- Chasing a higher benchmark score instead of a stable, repeatable one. A slightly lower Cinebench score that repeats consistently across three runs is more trustworthy than a higher score you only saw once.
Troubleshooting: 8 Stress Test Problems and How to Fix Them
Most PC stress test failures trace back to one of the same handful of root causes. Check this table before assuming the worst about a component.
| Symptom | Likely Cause | Fix |
|---|---|---|
| FurMark crashes or closes within the first minute | Outdated or corrupted GPU driver | Reinstall the latest driver, ideally after a clean uninstall of the old one, then retry |
| GPU temperature exceeds its throttle point within 2 minutes | Poor thermal paste contact or blocked airflow | Reseat the cooler, check paste coverage, clear dust from intake filters |
| Prime95 throws a rounding error warning | Unstable RAM overclock or XMP/EXPO profile | Lower the RAM frequency or loosen timings one notch, then retest from scratch |
| System reboots with no error message during the combined test | PSU cannot sustain simultaneous peak draw | Check PSU wattage headroom against combined rated draw, retest components individually |
| Cinebench score sits well below typical published results | Thermal throttling or an aggressive power limit | Check HWiNFO64 for throttle flags, review your motherboard’s power plan settings |
| GPU fans do not ramp up despite rising temperature | Custom fan curve stuck on a silent profile | Check your GPU vendor software’s fan curve settings and reset to automatic |
| OCCT reports an error within the first minute of the combined test | Unstable memory timings or an aggressive GPU voltage curve | Revert to default clocks and voltages, then reintroduce tuning incrementally |
| HWiNFO64 shows the CPU hitting its throttle point almost immediately | Cooler not seated correctly, or the wrong mounting bracket for your socket | Reseat the cooler and confirm you used the correct bracket for your CPU socket |
| MemTest86 reports errors tied to one specific module | A faulty DIMM or an unstable XMP/EXPO profile | Test each stick individually, drop to JEDEC default speed, RMA the module if errors persist alone |
| Results vary significantly between otherwise identical test runs | Ambient temperature swings or background apps consuming resources | Close background apps, test at a consistent room temperature, compare delta-over-ambient rather than raw numbers |
Fixing a Graphics Driver Crash During or After a Stress Test
A graphics driver crash is the single most common way a GPU stress test ends early, and it is worth treating as its own troubleshooting category rather than folding it into general instability. The same crash shows up outside a dedicated test too, most often during a demanding game, a render, or an aggressive overclock, for the same underlying reason: the driver is being pushed past sustained peak load it rarely handles during normal use. The telltale sign is a black screen, a brief flicker, or a “Display driver stopped responding and has recovered” message, which is Windows’ Timeout Detection and Recovery (TDR) feature stepping in after the driver stops responding to the OS within its timeout window. That message means the driver crashed and recovered, not that the GPU itself failed, and it shows up most often during Step 6’s FurMark run or Step 8’s combined OCCT test, since both push sustained peak load the driver rarely sees during normal use.
- Reinstall the GPU driver cleanly. Uninstall it completely with Display Driver Uninstaller (DDU) in Safe Mode, then install a fresh copy of the current driver instead of installing on top of the old one. This is the most common cause of a graphics driver crash and the easiest to rule out.
- Revert any GPU overclock or undervolt. Reset clocks and voltage to stock, confirm a clean pass, then reintroduce any tuning from our GPU undervolt guide one change at a time.
- Check PSU headroom. A crash tied to a sudden load spike rather than a steady high load points to insufficient power delivery; recheck the combined-load PSU test from Step 8.
If a graphics driver crash repeats after all three fixes above, treat it as a hardware signal rather than a software one. Re-run the OCCT combined test from Step 8 and recheck PSU headroom before assuming the GPU itself is defective, since a card and a power supply that each pass alone can still produce a driver crash under their combined peak draw.
GPU and CPU Stress Test Tools Compared
Each tool in this guide has a specific job. Here is how they stack up side by side, including the platforms they support and roughly how long a useful pass takes.
| Tool | Primarily Tests | Platform | Cost | Typical Run Time |
|---|---|---|---|---|
| FurMark | GPU thermal and power stress | Windows | Free | 20-30 minutes |
| Unigine Superposition | GPU stability and real-world load | Windows, Linux | Free (paid tiers for extended features) | 10-20 minutes |
| 3DMark | GPU comparative benchmark score | Windows | Free demo, paid full version | 10-15 minutes |
| Prime95 | CPU worst-case thermal and stability | Windows, Linux, macOS | Free | 20-30 minutes |
| Cinebench | CPU real-world render performance | Windows, macOS | Free | 10 minutes per run |
| OCCT | Combined CPU, GPU, and RAM stress | Windows, Linux | Free (paid Pro tier) | 20-60 minutes |
| MemTest86 | RAM stability | Bootable, OS-independent | Free | 2-8 hours for a full pass |
| HWiNFO64 | Sensor monitoring and CSV logging | Windows | Free | Runs continuously alongside other tools |
Other 2026 guides sequence these same tools differently, and the gap mostly comes down to how much time a builder is willing to spend. Drizz.dev’s 2026 stress-testing guide runs a single MemTest86 pass at roughly 45 minutes, Prime95 Small FFTs for 20 minutes, and FurMark for 15 to 30 minutes, among other steps. A separate 2026 protocol from Temp-Core takes a different shortcut that adds up to about 2 to 3 hours for a full system test: Cinebench R24 for 10 minutes, FurMark for 15 minutes, Prime95 Small FFTs for 20 minutes, and two full MemTest86 passes instead of one. Both point to the same shift this guide already follows: separate, individually-timed component tests rather than one long combined run, which is exactly why Steps 4 through 9 above break the routine into discrete passes instead of a single marathon session.
Advanced Tips for Results You Can Actually Trust
Once the basic 12-step routine is second nature, a few refinements separate a casual check from a result you can actually stand behind. Test with the case panel on, not off. Open-air testing looks convenient but changes the airflow path enough to shift results by several degrees compared with how the system runs day to day. Record ambient room temperature every time and compare delta-over-ambient rather than raw numbers if you plan to track results over months, since a 78°C load temperature in August and the same 78°C in a cooler room in January do not represent the same thermal margin.
Validate synthetic results against a real workload before fully trusting them. A render in Blender, a video export in Handbrake, or an hour in the specific game you play most often will not match a synthetic tool’s power draw, but it tells you whether your actual use case is stable, which is the number that actually matters. Silicon quality also varies chip to chip even within the same model, so do not assume your specific CPU or GPU will match a review outlet’s published numbers exactly. Your own logged baseline is the only number your future comparisons should be measured against.
For power users who run this routine often, orchestrating the whole sequence with one script removes the manual clicking between tools. A basic PowerShell wrapper can start GPU logging, launch a timed stress test, and clean up afterward:
# Starts GPU logging, waits briefly, then launches a stress test for a fixed duration.
# Check your specific FurMark version's own command-line documentation for exact flag names.
Start-Process nvidia-smi -ArgumentList "--query-gpu=timestamp,temperature.gpu,power.draw,clocks.gr --format=csv -l 5 -f gpu-log.csv" -WindowStyle Hidden
Start-Sleep -Seconds 2
Start-Process "C:\Program Files\Geeks3D\FurMark\FurMark.exe" -Wait
Get-Process nvidia-smi -ErrorAction SilentlyContinue | Stop-ProcessPair that with the stress_report.py script from earlier and the entire GPU stress test, from launch to a graded pass-or-fail result, runs with a single script execution and no manual monitoring required.
A Complete Walkthrough: Before and After on a 2026 Build
To show how the full routine fits together, here is what it looks like end to end on a mid-range 2026 build pairing an RTX 5070 Ti with a current-generation Ryzen X3D chip. Treat the specific numbers as one illustrative example rather than a guarantee for your own hardware, since case airflow, ambient temperature, and silicon variance all shift the real result.
After a five-minute idle period, Step 2’s baseline snapshot shows the GPU sitting around 38°C and the CPU package around 42°C, both unremarkable for an idle system with decent case airflow. Step 4’s Prime95 Small FFTs run climbs CPU package temperature to the high-80s within ninety seconds, then holds steady there for the full 20-minute run with no rounding errors, a clean pass. Step 6’s FurMark run settles the GPU at a load temperature in the high-70s, comfortably under its throttle point, with power draw holding just under 290W against the card’s 300W rating.
The real test comes in Step 8. Running OCCT’s combined test for 20 minutes pushes CPU package temperature into the low-90s and GPU temperature up a further few degrees compared with the isolated tests, both still inside the safe range from the prerequisites table, confirming the two components share thermal headroom without pushing each other past their limits. The Python script from earlier grades the resulting logs automatically:
GPU: peak 82.3C, 0 breach(es) -> PASS
CPU: peak 92.1C, 0 breach(es) -> PASS
OVERALL: PASSTotal time for this specific walkthrough, from driver check in Step 1 through a fully logged, scripted pass-or-fail result, ran close to 60 minutes, not counting the multi-hour MemTest86 pass left running overnight. That lines up with the estimate at the top of this guide, and most of that hour goes into letting tests run rather than configuring software.
Is Stress Testing Safe? Risk, Warranty, and Failure Points
Stress testing carries very little real risk to modern hardware. Every GPU and CPU sold in the last several years ships with automatic thermal and power protection that throttles clocks, and in extreme cases shuts the system down, long before temperatures reach a level that causes physical damage. The realistic worst case from an aggressive stress test is a crash, a driver reset, or a forced reboot, all of which resolve the moment you stop the test, not a damaged component.
Stress testing itself does not void a warranty. You are running the hardware within its own firmware-enforced limits, not bypassing them, which is a fundamentally different category of action than physically modifying a card or disabling its protections. Where risk does increase is when stress testing is combined with an aggressive overclock or a voltage change that overrides those built-in safeguards, so if you plan to push clocks beyond stock, run this stability routine again afterward using the same baseline comparison approach from Step 2.
The one rule worth repeating: never disable a component’s built-in thermal or power protection to “win” a stress test. Those safeguards exist specifically to keep testing safe, and defeating them turns a low-risk diagnostic routine into a genuinely risky one.
Frequently Asked Questions
How long should a GPU stress test run?
A 15- to 20-minute initial FurMark or Superposition pass is usually enough to catch most thermal and stability problems, since temperatures typically plateau within the first few minutes. For this guide’s fuller validated window, budget a minimum of 20 minutes, extended to 30 minutes if you are testing a high-end card such as an RTX 4080+ or RX 7900 XTX, or if you changed cooling, thermal paste, or case fans and want higher confidence in the result.
Is FurMark safe to use, or will it damage my GPU?
Modern GPUs handle FurMark safely thanks to automatic power and thermal limiting built into the hardware itself. Older-generation cards from over a decade ago occasionally lacked robust enough protection circuitry to be fully comfortable with it, but every GPU sold in recent years is designed to throttle rather than fail under FurMark’s load.
What temperature is too hot during a stress test?
Use the throttle points in this guide’s safety table as your ceiling, roughly 83-90°C for most current GPUs and 95-105°C for most current CPUs depending on model. For GPU hotspot specifically, a separate and usually higher reading than core temperature, keep the peak at or below 93°C and treat anything above 95°C for more than 90 seconds as a failure. Reaching your ceiling within the first minute or two of a test, rather than after a sustained period of load, is the bigger warning sign than the raw number itself.
What is the best computer heat monitor to run between stress tests?
HWiNFO64 is the most complete free computer heat monitor for logging CPU and GPU sensors together, and its Sensors-only mode can run minimized in the background day to day rather than only during a dedicated stress test session. Your GPU vendor’s own overlay, such as AMD Software: Adrenalin Edition or the Nvidia app, works well for a lighter always-on-top readout while gaming.
Do I need to stress test the CPU and GPU separately, or together?
Both. Individual tests isolate which component has a problem if something fails, while the combined test in Step 8 catches PSU and case-airflow issues that only appear when every component draws peak power at once. Skipping either type of test leaves a real gap in what you have actually verified.
Why did my PC pass Prime95 but crash in a game?
This usually points to the combined-load gap covered in Step 8, since a game taxes CPU, GPU, and RAM simultaneously in a way that Prime95 alone never does. It can also indicate a game-specific driver bug rather than a hardware stability problem, so try the OCCT combined test before assuming your hardware is at fault.
Why does my graphics driver crash during a stress test?
Most graphics driver crashes during a stress test trace back to an outdated or corrupted driver, an unstable overclock or undervolt, or a PSU that cannot sustain a sudden load spike. A “display driver stopped responding” message means Windows’ TDR feature recovered the driver after it stopped responding, not that the GPU itself failed, so reinstall the driver with a clean uninstall first and revert any overclock or undervolt before you retest.
How often should I re-run a stress test after the initial build?
After any GPU driver update, BIOS update, or RAM and storage change, plus at least once every six months as routine maintenance. Dust buildup and thermal paste degradation both happen gradually, so a periodic retest catches slow decline that you would not otherwise notice day to day.
Can I stress test a laptop the same way as a desktop?
Mostly, with the adjustments covered earlier in this guide: stay plugged into AC power, set the highest-performance power plan, and expect the combined CPU-and-GPU test to run hotter and throttle sooner than on a desktop, since laptop coolers share heat pipes between components in a way most desktop coolers do not.
What counts as a failed stress test?
Any crash, BSOD, WHEA error, or visual artifact is an automatic fail, regardless of what your temperatures look like. On the numbers side, a GPU hotspot reading above 95°C for more than 90 seconds and clock speeds throttling more than 5% below your chip’s base frequency both count as failures too, even if the system never actually crashes. See Step 11 for the full breakdown of what to check across your logs.
What is the best way to stress test a PC after a new build?
Follow the order this guide uses: CPU first with Prime95 and Cinebench, then GPU with FurMark and Superposition, then a combined CPU-GPU-RAM test with OCCT, and finally an overnight RAM pass with MemTest86. Testing components in that sequence, individually before combined, is what isolates which specific part is responsible if something fails.
Related Coverage
- How to Undervolt a GPU: 12 Steps, 45 Min [2026]
- How to Enable XMP/EXPO RAM: 12 Steps, 40 Min [2026]
- How to Overclock RAM: 10 Steps, 90 Min [2026]
- How to Enable Resizable BAR: 12 Steps, 25 Min [2026]
- 12VHPWR GPU Cable Setup: 10 Steps, 30 Min [2026]
- RTX 5090 vs RTX 5070 Ti for AI: 2x VRAM, 2.7x Price [2026]
- AMD 9800X3D vs 9950X3D vs Intel 285K: 25-35% Faster [2026]
- How to Install an NVMe SSD: 13 Steps, 50 Min [2026]
