Most GPU temperature checks stop at one number, and that number is the least useful one. A modern graphics card reports at least three: the core reading, the hotspot (also called junction), and the memory junction. Third-party guides such as PcPartsUK’s overheating guide put the main GPU reading at roughly 60-85°C under gaming load, but they also stress that a healthy figure depends on the cooler, the power limit, the room temperature, and the fan curve.
This tutorial shows you how to check GPU temperature in 13 steps and about 35 minutes, on Windows and Linux, for NVIDIA GeForce RTX 50 cards and AMD Radeon RX 9000 cards. You will read all three sensors with free tools, run a repeatable load test, and finish with a small Python logger that writes a CSV file and warns you when a sensor stays hot. If you are still choosing between the two vendors, our RTX 5070 vs RX 9070 XT comparison covers speed and price, and the same logging habit works on the processor side, as the CPU temperature guide shows.
Two facts shape this guide as of October 25, 2026. First, the RTX 50 series is still NVIDIA’s current GeForce generation, and AMD still sells the Radeon RX 9000 Series as its RDNA 4 family. Second, the two vendors expose different sensors. Several current guides report that NVIDIA’s standard monitoring interface generally does not show a hotspot reading on RTX 50 cards even though the physical sensor exists, while Radeon RX 9000 cards report a junction value. That means you will often collect two numbers on a GeForce and three on a Radeon, and the tutorial handles both cases.
Both vendors also shipped fresh drivers on October 20, 2026. NVIDIA released a Game Ready driver for Phantom Blade Zero and Call of Duty: Modern Warfare 4, and AMD published Adrenalin Edition 26.10.1 with FSR Upscaling 4.1 support for Radeon RX 6000 cards. Update first, then measure, so your baseline reflects the software you will actually run.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What You Need Before You Start: Prerequisites and Versions
Reading a sensor is safe. Nothing in this guide changes voltage, clocks, or fan speed, so you cannot damage the card by following it. The only real requirement is patience for one 20-minute load test. Here is the checklist, with the versions that matter.
- Graphics card: a GeForce RTX 50 series or Radeon RX 9000 Series card. Older cards work too, but their sensor lists differ.
- Operating system: Windows 11 on a current build, or a current Ubuntu LTS with the in-kernel amdgpu driver for Radeon cards.
- NVIDIA driver: the current Game Ready driver or newer. It installs
nvidia-smialongside the display driver. - AMD driver: AMD Software: Adrenalin Edition 26.10.1 (October 20, 2026) or newer on Windows. On Linux the kernel driver provides the sensors, so no extra package is required.
- Monitoring tools: the latest HWiNFO, the latest GPU-Z, and the latest MSI Afterburner with RivaTuner Statistics Server. All three are free for personal use.
- Python: version 3.8 or newer for the logger in Steps 11 to 13.
- A repeatable load: one game with a built-in benchmark, or a synthetic 3D test, that keeps the GPU busy for 20 minutes.
- A notes file: a plain text document where you record every reading, because comparisons only work when you write the numbers down.
The timing works out because the load test overlaps with setup. Steps 1 to 3 take about 5 minutes, Steps 4 to 6 take about 8, and Steps 7 and 8 take about 4. Steps 9 and 10 start the 20-minute load while you install the logger in Step 11, so the total lands near 35 minutes rather than the 50 you would get by running everything in sequence.
One more preparation note. According to NVIDIA’s own announcement with Microsoft on October 7, 2026, RTX Spark is a new Windows platform for laptops and compact desktops, with the desktops scheduled for November. It uses unified memory and is not a GeForce RTX 50 desktop card, so the memory sensor and the thermal limits in this guide may not map onto it. If you own an RTX Spark machine, treat the core and hotspot ideas as general guidance and check the maker’s documentation for limits.
Core, Hotspot and Memory Junction: What Each Sensor Measures
The core temperature, which some tools label GPU temperature or edge temperature, is the general reading for the processor die. The hotspot, also called junction, is the hottest point measured anywhere on that die, so it always reads higher than the core. The memory junction covers the video memory chips, and it moves on its own schedule because the memory sits under a different part of the cooler. Each number tells you something different, which is why a one-number check can miss a real problem.
The gap between core and hotspot is the cheapest health test you own. Current guidance says a hotspot about 10-20°C above the core is typical in gaming, and that some Radeon cards show a wider spread. A sustained gap of roughly 30°C or more is worth investigating, because it can point to poor cooler contact or uneven thermal paste. That 30°C line is troubleshooting advice from third-party guides, not a failure threshold published by NVIDIA or AMD, so treat it as a prompt to look closer rather than a verdict.
Memory deserves its own attention. The nvidiareview.com explainer on GPU memory junction temperature treats readings near 105°C as warning territory. Reported typical figures for GDDR6X and GDDR7 under heavy load run lower, in the range of roughly 80-100°C, but those ranges come from third-party guidance and not from a manufacturer specification. If a tool shows N/A for memory, the card or the software did not expose the sensor. That tells you nothing about whether the memory is cool.
Which sensors you can read depends on the vendor and the tool. For a Radeon RX 9000 card, monitor both the edge reading and the junction reading. For a GeForce RTX 50 card, plan on core plus memory, and treat hotspot as a bonus if your monitoring tool supports it. Reports differ on this point. Third-party coverage says HWiNFO64 pre-release 8.51 (August 3, 2026), HWMonitor 1.65, and GPU-Z 2.71.0 restored or enabled RTX 50 hotspot readings through direct access methods, but those claims come from a single report each, so verify on your own card before you rely on them.
The card family matters too. Workstation siblings built on the same silicon, such as the parts compared in our RTX PRO 6000 Blackwell vs RTX 5090 vs W7900 breakdown, ship with different coolers and different fan behavior, so the same chip can run at a different temperature in a different chassis. Always compare a card to its own baseline, not to a forum screenshot from another build.
Normal GPU Temperature Ranges for RTX 50 and Radeon RX 9000
Every search for normal GPU temperature ends in the same trap: people want one number. No such number exists. NVIDIA’s own pages, as returned in our October 2026 research, do not establish a universal normal range, hotspot limit, or memory-junction limit for all RTX 50 cards. What exists is third-party guidance and model-specific core limits reported by hardware sites. The table below collects the figures that survived cross-checking, and it leaves blank anything we could not verify.
| Card | Typical gaming core reading | Reported core limit | Hotspot readout | Hotspot or junction ceiling cited |
|---|---|---|---|---|
| GeForce RTX 5090 | 60-85°C | No universal figure verified | Often not exposed by the standard interface | Not published |
| GeForce RTX 5080 | 60-85°C | 88°C | Often not exposed | Not published |
| GeForce RTX 5070 Ti | 60-85°C | 88°C | Often not exposed | Not published |
| GeForce RTX 5070 | 60-85°C | 85°C | Often not exposed | Not published |
| Radeon RX 9070 XT | 60-85°C | Check the board spec | Reported | About 110°C (verify per board) |
| Radeon RX 9070 GRE | 60-85°C | Check the board spec | Reported | About 110°C (verify per board) |
| Radeon RX 9060 XT | 60-85°C | Check the board spec | Reported | About 110°C (verify per board) |
The core limits in that table come from the GPU temperature range page on botleneckcalculator.com, which reports 85°C for the RTX 5070 and 88°C for the RTX 5080 and RTX 5070 Ti. Across all RTX 50 models, reported maximum core figures range from 85°C to 90°C, so the often-repeated 90°C line is not valid for every model. Do not assume that a number written for an RTX 40 card carries over to an RTX 50 card. Those older limits were different, and board partners can tune their own.
For Radeon, the picture is looser. A junction ceiling near 110°C is commonly cited for RX 9000 cards, and GPUSPOINT’s temperature limits explainer repeats it, but that figure comes from secondary sources and not an AMD specification page. Check the exact AMD or board-partner specification for your model before you declare a fault. Readings that approach 110°C deserve attention even when they stay under the stated limit, because a card that lives at its ceiling has no margin left on a hot afternoon.
Mid-range buyers should read these rows with the same caution. The cards in our Arc B580 vs RTX 5060 vs RX 9060 XT comparison use smaller coolers and lower power limits, so their absolute numbers differ even when their relative health is fine. In short, the table gives you a sanity range, and your own baseline from Step 13 gives you the real benchmark.
Steps 1 to 3: Set a Baseline and Use the Tools Already on Your PC
Step 1: Record the baseline conditions. Before you open any monitoring tool, write down five facts in your notes file: the room temperature, whether the case side panel is on, the fan setting (automatic or manual), the driver version, and the date. A card that reads 78°C in a cool room with the panel off can read 86°C on a warm evening with the panel on, and without notes you will blame the wrong thing. Close background apps that load the GPU, such as video editors, browser tabs with hardware acceleration, and wallpaper engines, so idle really means idle.
Step 2: Open Windows Task Manager. Press Ctrl+Shift+Esc, switch to the Performance tab, and select your GPU in the left column. On many systems with a dedicated card, the panel shows a temperature figure under the utilization graphs. This reading is the core value only, with no hotspot and no memory data, so use it as a quick idle check and not as your measurement. If the temperature line is missing, move on, because the next steps cover the same ground with better tools. Note the idle core temperature and the idle fan state in your file.
Step 3: Check the vendor overlay. NVIDIA ships its in-game tools through the NVIDIA App, and AMD ships performance metrics inside Adrenalin Edition. Open each one and look for a performance or statistics overlay. Menu layouts change between releases, and older instructions may not match the current Adrenalin interface, so rely on the menu names in your installed version rather than a screenshot from last year. The vendor overlay is convenient for a glance during play. For logging and for the hotspot, you still want the dedicated tools in the next section.
Finish this group by writing three lines in your notes: idle core temperature, idle fan state (stopped or spinning), and whether each overlay showed memory or hotspot. Many modern cards stop their fans below a temperature threshold, so a silent fan at idle is normal behavior and not a fault. If the idle core reading sits above 50°C with the fans stopped, you probably have background load, so check the utilization graph before you suspect cooling.
Steps 4 to 6: HWiNFO, GPU-Z and an MSI Afterburner Overlay
Step 4: Read every sensor in HWiNFO. Download the latest HWiNFO, run it, and choose the Sensors-only option at startup. Scroll to the block named after your graphics card. You should see the GPU temperature, and on cards that expose it, a hotspot line and a memory junction line, along with power draw, fan speed, clocks, and utilization. Each row has Current, Minimum, Maximum, and Average columns. HWiNFO also has a logging button in the lower toolbar that writes a CSV, which Step 10 uses. Reports from August 2026 say HWiNFO64 builds also gained per-chip VRAM temperature monitoring on some Navi cards, as TweakTown’s coverage describes, so a Radeon owner may see several memory rows instead of one.
Step 5: Cross-check with GPU-Z. Open GPU-Z and switch to the Sensors tab. Compare its temperature rows with HWiNFO. The two tools should agree within a degree or two. If one tool shows a hotspot and the other does not, that tells you about tool support and not about your card, so trust the tool that shows more rows and note which one it was. GPU-Z also lists the exact driver version and BIOS, which makes your notes file more useful when you compare a later session against this one.
Step 6: Build an on-screen overlay. Install MSI Afterburner with RivaTuner Statistics Server, open the monitoring settings, and tick the boxes for GPU temperature, GPU memory temperature, GPU usage, power, and core clock. Enable the on-screen display for each. The walkthrough in our MSI Afterburner guide covers the full interface if you want it, but for this job you only need the monitoring tab. Launch a game, and the numbers should appear in a corner. Keep the overlay on for every test in this guide so you see what the card does at the moment a game stutters.
| Tool | Platform | Core | Hotspot | Memory | CSV logging |
|---|---|---|---|---|---|
| Task Manager | Windows | Yes, on many systems | No | No | No |
| NVIDIA App or Adrenalin overlay | Windows | Yes | Varies by vendor and version | Varies | No |
| HWiNFO | Windows | Yes | Where the card exposes it | Yes, where exposed | Yes |
| GPU-Z | Windows | Yes | Version dependent on RTX 50 | Yes, where exposed | Yes, to a text file |
| MSI Afterburner with RTSS | Windows | Yes | Card dependent | Card dependent | Yes |
| nvidia-smi | Windows and Linux | Yes | Not in the standard query | Query field, may report N/A | Yes, built in |
| amdgpu sysfs and lm-sensors | Linux | Yes (edge) | Yes (junction) | Yes (mem) | Via script |
Use the table to pick your toolkit. A Windows Radeon owner can do everything with HWiNFO and the Adrenalin metrics. A Windows GeForce owner should add nvidia-smi for the memory field and for the driver-reported limits you will meet in Step 7. A Linux user can skip the graphical tools completely and go straight to the command line.
Steps 7 and 8: Command-Line Readouts with nvidia-smi and Linux Sysfs
Step 7: Query the NVIDIA driver directly. Open a terminal (PowerShell on Windows) and run nvidia-smi. The default screen prints the temperature next to the fan percentage, power draw, and memory use. For a cleaner and scriptable view, ask for specific fields. The first command below prints one line of CSV with core temperature, memory temperature, fan speed, power draw, and utilization. The second command prints the temperature thresholds the driver itself reports for your card, which is the most reliable per-card limit you can get because it comes from the driver and not from a forum post.
nvidia-smi --query-gpu=name,temperature.gpu,temperature.memory,fan.speed,power.draw,utilization.gpu --format=csv
nvidia-smi -q -d TEMPERATURE
nvidia-smi -q -d PERFORMANCEThe temperature query lists the current core temperature, the slowdown temperature, the shutdown temperature, and the maximum operating temperature, plus a memory block that may read N/A on some cards. The performance query lists the clock event reasons, including hardware and software thermal slowdown flags. If a thermal slowdown flag reads Active during your load test, the card is lowering its own clocks to protect itself, and you have found your answer without any further analysis. Run nvidia-smi --help-query-gpu if a field name fails, because the available field names vary between driver branches.
For a continuous view, add a loop flag. This command samples every two seconds and writes a CSV you can open later. On Windows PowerShell, the same command works unchanged, and you stop it with Ctrl+C.
nvidia-smi --query-gpu=timestamp,temperature.gpu,temperature.memory,fan.speed,power.draw,utilization.gpu,clocks.sm --format=csv -l 2 -f gpu-nvsmi.csvStep 8: Read the amdgpu sensors on Linux. The in-kernel amdgpu driver publishes temperatures through hwmon, and the labels map directly onto the three sensors we care about: edge is the core, junction is the hotspot, and mem is the memory. If you have lm-sensors installed, sensors prints them all. If not, read the files directly. Note that an integrated Radeon GPU in your processor also uses the amdgpu driver, so on a system with both you may see two hwmon entries. The command below prints every amdgpu device it finds along with each labeled temperature.
sensors amdgpu-pci-*
for hw in /sys/class/drm/card*/device/hwmon/hwmon*; do
[ "$(cat $hw/name)" = "amdgpu" ] || continue
echo "== $hw"
for f in $hw/temp*_input; do
label=$(cat ${f%_input}_label)
echo "$label: $(( $(cat $f) / 1000 )) C"
done
doneA typical result from a discrete card under load looks like the sample below. These are illustrative values from a mock device used to test the script, so yours will differ. The pattern is what matters: junction runs above edge, and memory sits between them.
== /sys/class/drm/card1/device/hwmon/hwmon3
edge: 64 C
junction: 88 C
mem: 82 CSteps 9 and 10: Create a Repeatable Load and Log the Run
Step 9: Pick one load and keep it fixed. Idle numbers prove very little. Temperature problems appear after the card has soaked in heat for several minutes, so you need a load that runs for 20 minutes at the same settings every time. A game with a built-in benchmark loop is ideal. Pin the resolution, the graphics preset, and the frame cap, and write them in your notes. Turn upscaling on or off consistently, because it changes how hard the card works. If you play on a Radeon with FSR, our FSR Redstone setup guide explains the toggles, and the FSR 4.1 expansion that AMD announced on October 20, 2026 for Radeon RX 6000 cards means older Radeon owners can now use a newer upscaler, which shifts their load and their temperatures.
Overclocked or factory-boosted cards run hotter at the same settings, so reset any manual tuning before the test. Our guide to overclocking an RTX 5080, RTX 5090, or RX 9070 XT explains what those tweaks do. For a clean baseline, run stock. If you want a bare-minimum alternative to a game, any sustained 3D stress test works, as long as you use the same one every session. Avoid short synthetic spikes of one or two minutes. They finish before the cooler reaches steady state and produce flattering numbers.
Step 10: Start logging before the load begins. Open HWiNFO sensors, click the logging icon in the toolbar, choose a file name, and let it write a CSV. On NVIDIA you can use the nvidia-smi -l 2 -f command from Step 7 instead. Start the logger first, wait about 30 seconds so the file shows the idle starting point, then launch the game or benchmark. Run it for at least 20 minutes. Current guides give the same advice: game for 20 minutes and read the Maximum column. The Maximum column is the first thing to check, and the Average column tells you what the card does most of the time.
While the test runs, watch for three behaviors. First, check whether the frame rate drops after 10 to 20 minutes and not at the start, because that pattern is a classic sign of heat-driven clock reduction. Second, listen for fans that sit at full speed and sound loud, which suggests the cooler is working at its limit. Third, look at the clock line next to the temperature line in the overlay. A clock that sags as temperature climbs is the card protecting itself. Stop the test early if any temperature approaches the ceilings in the ranges table, and do not push through a warning.
Steps 11 to 13: Build the gputemp.py Logger Project
The graphical tools are fine for one-off checks, but they leave you with scattered files and no alerts. The project in this section is a single Python script, about 170 lines, that works with both vendors. On NVIDIA it calls nvidia-smi, and on Linux Radeon cards it reads the amdgpu sysfs files you met in Step 8. It appends one row per sample to a CSV, prints a live status line, and raises an alert when a sensor stays above your limit for several samples in a row. A second subcommand summarizes any CSV, including a HWiNFO export, with minimum, average, 95th percentile, and maximum per sensor.
Step 11: Save the script. Create a folder, save the code below as gputemp.py, and confirm Python works with python --version. We tested it against a mock nvidia-smi and a mock amdgpu sysfs tree, and the logic ran correctly for both readers, but you are the first person to run it on real hardware, so read the output of your first run with that in mind.
#!/usr/bin/env python3
"""gputemp.py: log GPU core, hotspot and memory temperatures, then summarize the log."""
import argparse
import csv
import glob
import os
import statistics
import subprocess
import time
from datetime import datetime
FIELDS = ["ts", "core", "hotspot", "memory", "fan_pct", "fan_rpm", "power_w", "util_pct", "clock_mhz"]
NV_QUERY = "temperature.gpu,temperature.memory,fan.speed,power.draw,utilization.gpu,clocks.sm"
def to_float(text):
try:
return float(text.strip())
except ValueError:
return None
def read_nvidia(index):
cmd = ["nvidia-smi", "-i", str(index), f"--query-gpu={NV_QUERY}", "--format=csv,noheader,nounits"]
line = subprocess.run(cmd, capture_output=True, text=True, timeout=10, check=True).stdout.strip()
core, mem, fan, power, util, clock = [to_float(x) for x in line.split(",")]
return {"core": core, "hotspot": None, "memory": mem, "fan_pct": fan, "fan_rpm": None,
"power_w": power, "util_pct": util, "clock_mhz": clock}
def read_sysfs(path):
try:
with open(path) as fh:
return fh.read().strip()
except OSError:
return None
def find_amd_hwmon(index):
cards = sorted(glob.glob("/sys/class/drm/card[0-9]*/device/hwmon/hwmon*"))
amd = [p for p in cards if read_sysfs(os.path.join(p, "name")) == "amdgpu"]
if index >= len(amd):
raise SystemExit(f"No amdgpu hwmon device at index {index}. Found {len(amd)}.")
return amd[index]
def read_amd(index):
hw = find_amd_hwmon(index)
temps = {}
for label_file in glob.glob(os.path.join(hw, "temp*_label")):
raw = read_sysfs(label_file.replace("_label", "_input"))
if raw:
temps[read_sysfs(label_file)] = int(raw) / 1000
power = read_sysfs(os.path.join(hw, "power1_average")) or read_sysfs(os.path.join(hw, "power1_input"))
fan = read_sysfs(os.path.join(hw, "fan1_input"))
busy = read_sysfs(os.path.join(os.path.dirname(os.path.dirname(hw)), "gpu_busy_percent"))
return {"core": temps.get("edge"), "hotspot": temps.get("junction"), "memory": temps.get("mem"),
"fan_pct": None, "fan_rpm": float(fan) if fan else None,
"power_w": int(power) / 1_000_000 if power else None,
"util_pct": float(busy) if busy else None, "clock_mhz": None}
def fmt(value, unit=""):
return "n/a" if value is None else f"{value:.0f}{unit}"
def status_line(row):
return (f"{row['ts']} core {fmt(row['core'], 'C')} hotspot {fmt(row['hotspot'], 'C')} "
f"mem {fmt(row['memory'], 'C')} util {fmt(row['util_pct'], '%')} power {fmt(row['power_w'], 'W')}")
def watch(args):
reader = read_nvidia if args.vendor == "nvidia" else read_amd
limits = {"core": args.core_warn, "hotspot": args.hot_warn, "memory": args.mem_warn}
streak = {key: 0 for key in limits}
is_new = not os.path.exists(args.out)
end = time.time() + args.minutes * 60 if args.minutes else None
with open(args.out, "a", newline="") as fh:
writer = csv.DictWriter(fh, fieldnames=FIELDS)
if is_new:
writer.writeheader()
while end is None or time.time() < end:
row = {"ts": datetime.now().isoformat(timespec="seconds")}
row.update(reader(args.index))
writer.writerow(row)
fh.flush()
for key, limit in limits.items():
value = row[key]
streak[key] = streak[key] + 1 if value is not None and value >= limit else 0
if streak[key] == args.sustain:
print(f"ALERT {row['ts']} {key} {value:.0f}C held at or above {limit:.0f}C "
f"for {args.sustain} samples", flush=True)
print(status_line(row), flush=True)
time.sleep(args.interval)
def p95(values):
if len(values) < 2:
return values[0]
return statistics.quantiles(values, n=20, method="inclusive")[18]
def column(rows, name):
out = []
for row in rows:
try:
out.append(float(row[name]))
except (KeyError, ValueError, TypeError):
pass
return out
def summary(args):
with open(args.csv_file, newline="", encoding=args.encoding, errors="replace") as fh:
rows = list(csv.DictReader(fh))
cols = {"core": args.core_col, "hotspot": args.hot_col, "memory": args.mem_col}
print(f"{len(rows)} samples from {args.csv_file}")
print(f"{'sensor':<10}{'min':>6}{'avg':>7}{'p95':>7}{'max':>6}")
for key, name in cols.items():
vals = column(rows, name)
if not vals:
print(f"{key:<10}{'no data':>26}")
continue
print(f"{key:<10}{min(vals):>6.0f}{statistics.mean(vals):>7.1f}{p95(vals):>7.1f}{max(vals):>6.0f}")
gaps = []
for row in rows:
try:
gaps.append(float(row[cols["hotspot"]]) - float(row[cols["core"]]))
except (KeyError, ValueError, TypeError):
pass
if gaps:
verdict = "INVESTIGATE cooler contact" if max(gaps) >= args.gap_warn else "ok"
print(f"hotspot minus core: avg {statistics.mean(gaps):.1f}C, max {max(gaps):.0f}C -> {verdict}")
def main():
parser = argparse.ArgumentParser(description="Log and summarize GPU temperatures")
sub = parser.add_subparsers(dest="cmd", required=True)
w = sub.add_parser("watch", help="sample sensors and append to a CSV")
w.add_argument("--vendor", choices=["nvidia", "amd"], required=True)
w.add_argument("--index", type=int, default=0)
w.add_argument("--interval", type=float, default=2.0)
w.add_argument("--minutes", type=float, default=0, help="0 means run until Ctrl+C")
w.add_argument("--out", default="gpu-temps.csv")
w.add_argument("--core-warn", type=float, default=85)
w.add_argument("--hot-warn", type=float, default=100)
w.add_argument("--mem-warn", type=float, default=100)
w.add_argument("--sustain", type=int, default=5, help="consecutive samples before an alert")
w.set_defaults(func=watch)
s = sub.add_parser("summary", help="min, avg, p95 and max per sensor")
s.add_argument("csv_file")
s.add_argument("--core-col", default="core")
s.add_argument("--hot-col", default="hotspot")
s.add_argument("--mem-col", default="memory")
s.add_argument("--gap-warn", type=float, default=30)
s.add_argument("--encoding", default="utf-8")
s.set_defaults(func=summary)
args = parser.parse_args()
try:
args.func(args)
except KeyboardInterrupt:
print("\nstopped")
if __name__ == "__main__":
main()Step 12: Run the logger during your load test. Start it just before you launch the game. On a GeForce, run it with --vendor nvidia. On a Linux Radeon, use --vendor amd. The alert defaults are my starting margins and not manufacturer limits: 85°C for core (the top of the usual third-party gaming range), 100°C for hotspot (under the commonly cited 110°C Radeon ceiling), and 100°C for memory (under the 105°C warning level). Adjust them to your card using the limits from Step 7. The --sustain flag requires five consecutive samples above the limit before it alerts, which filters out one-off spikes.
# NVIDIA, 25 minutes, one sample every 2 seconds
python gputemp.py watch --vendor nvidia --minutes 25 --out geforce-run1.csv
# Radeon on Linux, tighter core alert, first amdgpu device
python gputemp.py watch --vendor amd --index 0 --core-warn 80 --out radeon-run1.csv
# Windows Radeon: log with HWiNFO, then summarize its export
python gputemp.py summary hwinfo-export.csv --encoding latin-1 --core-col "GPU Temperature [°C]" --hot-col "GPU Hot Spot Temperature [°C]" --mem-col "GPU Memory Junction Temperature [°C]"The third command exists because Windows Radeon owners have no command-line sensor tool, so the script reads HWiNFO’s own CSV instead. HWiNFO writes column names that include units and can vary by card, so open your export, copy the exact header text, and pass it with the column flags. A sample live run looks like this, using synthetic readings to show the format. The alert fires once when the streak reaches five samples and stays quiet until the sensor drops below the limit and climbs back.
2026-10-25T09:22:24 core 63C hotspot n/a mem 74C util 98% power 310W
2026-10-25T09:22:26 core 78C hotspot n/a mem 74C util 98% power 310W
ALERT 2026-10-25T09:22:28 core 86C held at or above 85C for 5 samples
2026-10-25T09:22:28 core 86C hotspot n/a mem 74C util 98% power 310WStep 13: Summarize and write down the verdict. When the run ends, call the summary subcommand on the CSV. The output gives you the minimum, average, 95th percentile, and maximum for each sensor, and it computes the hotspot-minus-core gap for every sample. If the largest gap reaches your gap limit (30°C by default), the script prints a prompt to investigate cooler contact. The sample below comes from 600 synthetic Radeon-style readings, so use it only to see the layout. Paste your own result into the notes file next to the room temperature and driver version from Step 1, and you have a baseline you can compare against after a driver update, a fan change, or a dust cleaning.
$ python gputemp.py summary radeon-run1.csv
600 samples from radeon-run1.csv
sensor min avg p95 max
core 57 75.4 77.3 78
hotspot 73 93.7 98.9 100
memory 68 87.9 91.1 92
hotspot minus core: avg 18.3C, max 23C -> okTo keep the logger running in the background, use your operating system’s scheduler. On Windows, Task Scheduler can start it at logon. On Linux, a user-level systemd service is enough. Both examples below log with a 10-second interval and no end time, so the file grows slowly and you can review days of data. Rotate or delete the CSV now and then.
# Windows (PowerShell, adjust the path)
schtasks /Create /SC ONLOGON /TN "GpuTempLog" /TR "python C:/tools/gputemp.py watch --vendor nvidia --interval 10 --out C:/tools/gpu-daily.csv"
# Linux (~/.config/systemd/user/gputemp.service)
[Unit]
Description=GPU temperature logger
[Service]
ExecStart=/usr/bin/python3 %h/tools/gputemp.py watch --vendor amd --interval 10 --out %h/tools/gpu-daily.csv
Restart=on-failure
[Install]
WantedBy=default.targetReading the Results: What Your Numbers Say About Cooling Health
Once you hold a baseline, interpretation gets easier because you compare your card to itself. Start with the maximum column, then check the 95th percentile, which shows what the card sustains rather than what it touches for a second. A maximum that is far above the p95 usually means a brief spike during a scene load. A p95 close to the maximum means the card sits near its peak for long stretches, and that is the figure to worry about. The table below turns common patterns into next steps.
| What you see | Likely meaning | What to do next |
|---|---|---|
| Core 60-85°C, gap 10-20°C, clocks steady | Normal for a gaming load | Save the run as your baseline |
| Core near the model limit, clocks dropping | Thermal throttling | Clean dust, raise the fan curve, improve case airflow |
| Gap of about 30°C or more between hotspot and core | Possible poor cooler contact or uneven paste | Reseat the cooler or consider a repaste after warranty checks |
| Memory near 105°C while core is fine | Memory cooling or thermal pad issue | Check airflow over the backplate, then pads |
| Sensor shows N/A | Tool or card does not expose it | Try HWiNFO or GPU-Z, do not assume cool |
| Idle above 50°C with fans stopped | Background GPU load or a stuck fan mode | Close apps, check utilization, reset the fan profile |
| Temperatures climb over several weeks | Dust, dried paste, or a warmer room | Compare room temperature in your notes, then clean |
Sustained compute work deserves a separate note. If you run local AI models, the load is flatter and hotter than a game, so repeat the test with your real workload.
Be careful with single dramatic stories. A developer-forum thread updated on October 24, 2026 described workload-dependent RTX 5090 failures, with reported hotspot peaks around 105-110°C, and said that limiting GPU clocks prevented six later bus-loss events on one Gigabyte Aorus RTX 5090 setup. That is one user’s test on one configuration. It is not an NVIDIA fix, and it should not push you to cap your own card. It does show why logging matters: if a card falls off the bus, a CSV with timestamps tells you what the temperature and power were in the minutes before it happened.
What to Do When Your GPU Runs Hot
Work through fixes from cheapest to most invasive, and re-run the same 20-minute test after each change. Changing three things at once leaves you guessing which one helped. Record the result in your notes after every pass. Most hot-running cards respond to the first two fixes, so do not jump to a repaste on day one.
- Clean the dust. Power down, unplug, and blow out the heatsink fins and fans with short bursts of air while holding the fans still. Dust is the most common cause of a slow temperature creep over months.
- Check case airflow. Confirm the intake fans pull cool air toward the card and an exhaust fan clears the heat. A cable bundle sitting in front of an intake costs more degrees than most people expect.
- Raise the fan curve. The stock curve favors silence. A modest increase in fan speed at a given temperature trades noise for a lower reading and often keeps boost clocks up.
- Cap the frame rate. A frame limiter stops the card from rendering frames your monitor never shows, which lowers power draw and temperature with no visible downside.
- Trim the power limit or undervolt. Lower voltage at the same clocks cuts heat directly. Re-baseline with this guide’s logger afterward to prove the gain.
- Inspect the thermal interface. If the core-to-hotspot gap stays at about 30°C or more after cleaning, the cooler contact or the paste may be the problem. Check your warranty terms before you open the card.
Stop and seek help if you see artifacts, crashes, or driver timeouts that line up with high readings in your log. Those symptoms mean the card is no longer coping, and continuing to stress it will not teach you anything new. A CSV that shows the temperature climbing just before each crash is exactly what a support team or a repair shop wants to see.
Common Pitfalls When You Check GPU Temperature
These mistakes cause most of the bad advice you find in forum threads. Each one has a simple remedy, and avoiding them makes your readings comparable from one session to the next.
- Judging by idle temperature. An idle reading says almost nothing about gaming behavior. Always test under a sustained load of at least 20 minutes.
- Watching only the core. A healthy core with a hot memory junction or a wide hotspot gap still signals a problem. Log all available sensors.
- Ignoring the room. A 5°C change in ambient temperature moves every reading. Write the room temperature in your notes.
- Using a ceiling from another generation. RTX 40 and earlier limits are not universal RTX 50 limits, and a Radeon junction ceiling is not a memory ceiling. Match the number to the card and the sensor.
- Trusting one tool blindly. Tools disagree about hotspot support on RTX 50 cards. Cross-check with a second tool before you panic or relax.
- Reading the peak instead of the plateau. A single high sample can be a loading spike. Use the 95th percentile and the sustained streak, which the script reports.
- Comparing different settings. A run at 4K with upscaling off is not comparable to a run at 1440p with it on. Lock your settings and keep them in the notes.
- Treating N/A as cool. An unavailable sensor is an unknown, not a safe value.
- Changing several things at once. Swap one variable per run or the test teaches you nothing.
One more habit helps. After a driver update, repeat your baseline run. Driver releases like the October 20 packages from NVIDIA and AMD change fan behavior, boost logic, or game-specific load on rare occasions, and the only way to know is to measure again. A five-minute rerun is cheap insurance against a regression you would otherwise blame on summer.
Troubleshooting: 10 Problems and Their Fixes
nvidia-smiis not recognized. On Windows, open a new terminal after the driver install, since the path only loads in new sessions. On Linux, install the NVIDIA utilities package that matches your driver branch, then reboot.- The memory temperature field shows N/A. The card or the driver did not expose that sensor through this query. Use HWiNFO or GPU-Z for the memory reading, and keep the script column, which will simply store an empty value.
- No hotspot row on an RTX 50 card. This is expected in the standard NVIDIA interface. Try the latest HWiNFO and GPU-Z, which reportedly read it through other access paths. If your tool still lacks it, rely on core and memory readings.
- Task Manager shows no GPU temperature. The graph depends on the driver model and Windows build. It is not a fault. Use HWiNFO instead.
- The Afterburner overlay does not appear in a game. Make sure RivaTuner Statistics Server is running, set the game to borderless windowed mode, and check whether the game’s anti-cheat blocks overlays.
- The script says no amdgpu hwmon device was found. Run the loop from Step 8 to see what exists. The card index counts only amdgpu devices, so an integrated GPU may take index 0 and your discrete card index 1. Pass
--index 1. - Permission errors reading sysfs. Temperature files are normally world-readable. If your distribution restricts them, run the script from a session with sufficient rights rather than loosening system permissions.
- Garbled degree symbols in the summary. HWiNFO exports in a Windows code page. Pass
--encoding latin-1and copy the column names exactly as they appear in the file. - Readings freeze after sleep or resume. Restart the monitoring tool, and if the problem persists, restart the display driver with Win+Ctrl+Shift+B on Windows.
- On a laptop, polling keeps the GPU awake. Hybrid graphics systems can sleep the discrete GPU to save power, and a query every two seconds may wake it. Use a longer interval such as 30 seconds when you only want a background record.
If none of these match, rerun the failing command in a plain terminal and read the first error line. Most failures come from a missing driver component, a wrong device index, or a tool that lacks support for your newest card. Updating the tool usually fixes the last one within a few weeks of a card’s launch.
Advanced Tips for Long-Term GPU Temperature Monitoring
Once the basics work, a few upgrades turn the logger into a proper health record. Run the daily logger from Step 13 for a month, then plot the p95 core temperature per day. A gentle upward slope with a flat room temperature is the earliest sign of dust or aging paste. On NVIDIA hardware, nvidia-smi dmon -s pu -d 2 prints power and utilization columns beside temperature, which helps you see whether a hot reading came from high power or poor airflow.
Add a second alert path. The script prints to the terminal, but you can pipe its output to any notifier that reads standard input, such as a desktop notification command or a chat webhook. Keep the alert logic in the script and the delivery outside it, so you can change one without touching the other. Also consider logging the CPU alongside the GPU, because a hot processor can heat the whole case and raise the card’s reading.
Tune thresholds per game. Heavy path-traced titles load the card differently from esports titles, so keep one CSV per game and compare like with like. If you plan a long-term purchase, remember that a card has to last, and the timeline in our report on the RTX 60 delay and the AMD freeze suggests you may keep today’s card longer than you expected, which makes good thermal habits worth the effort. For more hands-on guides in this area, browse the hardware section.
FAQ: GPU Temperature Questions Answered
What is a normal GPU temperature while gaming?
Third-party guidance commonly places the main GPU reading at about 60-85°C under gaming load. The exact figure depends on the card, the cooler, the power limit, the room, and the fan curve, so compare against your own baseline.
How do I check GPU temperature on Windows 11?
Open Task Manager and look at the GPU entry on the Performance tab for a quick core reading. For hotspot and memory data, install HWiNFO or GPU-Z, or use nvidia-smi on a GeForce card.
Why does my RTX 50 card not show a hotspot temperature?
Several current guides report that NVIDIA’s standard public monitoring interface generally does not expose hotspot on RTX 50 cards, although the sensor exists. Some third-party tools reportedly read it through other methods, but support varies by tool version.
What is a safe GPU hotspot temperature on a Radeon RX 9000 card?
A junction ceiling near 110°C is commonly cited, but it comes from secondary sources. Check the specification for your exact AMD or board-partner model, and treat sustained readings close to that figure as a reason to improve cooling.
How hot can GPU memory get?
Heavy-load memory readings are reportedly around 80-100°C, and sustained readings near 105°C are treated as a warning level in third-party guidance. These figures are not universal manufacturer limits.
How big a gap between hotspot and core is a problem?
A gap of 10-20°C is typical in gaming. A sustained gap of roughly 30°C or more is worth investigating, since it can indicate poor cooler contact or uneven thermal paste. That threshold is troubleshooting guidance, not an official limit.
Can I run the logger on AMD cards under Windows?
Not directly, because Windows has no command-line sensor tool for Radeon cards. Log with HWiNFO instead, then feed its CSV to the summary command with the matching column names and the latin-1 encoding.
Does this guide apply to NVIDIA RTX Spark systems?
Only in general terms. RTX Spark is a separate Windows platform with unified memory and is not a GeForce RTX 50 desktop card, so check the maker’s documentation for its sensors and limits.
