GPU Overclocking 2026: 12 Steps, +25 MHz, 2 Hours

Overclocking a graphics card used to mean a soldering iron, a pencil, and a private waiver with your own conscience. In 2026 it means three sliders and a benchmark you already own. The ritual survived; the danger mostly did not. Modern cards ship with a boost algorithm that spends every watt and every degree of thermal headroom you hand it, which means the factory already did roughly ninety percent of the overclocking for you and kept the receipt. What is left to claim is a thin, real, occasionally worthwhile margin: single digits of extra frame rate, or the same frame rate at lower temperature and noise, which is frequently the better trade. This is the tutorial for that margin. Twelve steps, about two hours if you respect the stress tests, and one firm rule against the two mistakes that turn an afternoon of tuning into a weekend of driver reinstalls.

Everything below is written for a Windows desktop with a discrete NVIDIA GeForce or AMD Radeon card, using MSI Afterburner as the primary tool because it is still the lingua franca of GPU tuning. Linux gets its own section. Laptops get one sentence: your thermal envelope is soldered shut, tune the power limit and stop there.

Why Overclock a GPU in 2026 (You Mostly Shouldn't)

Before you touch a slider, understand what you are actually buying. The honest answer changes how you tune.

The boost algorithm already did your overclocking

Every GeForce since Kepler and every Radeon since the RX 400 series runs a closed-loop clock manager. NVIDIA calls it GPU Boost; AMD does the same thing under a different name. It reads voltage, power draw, and temperature hundreds of times a second and pushes the core clock to the highest bin those three limits allow. The number printed on the box is a floor, not a ceiling. Out of the box, a card rated at 2,610 MHz will happily sit at 2,800 MHz when it is cool and fed, and drop to 2,550 MHz when it is hot and starved.

That is the whole game. A manual overclock does not unlock some secret reserve of speed. It raises the ceilings the boost algorithm is already pressing against: it lifts the power limit, shifts the voltage-frequency curve up by an offset, and lets memory run faster than the conservative factory setting. You are not commanding the card to a fixed higher clock. You are giving a very aggressive automatic system more rope. This is why two identical cards respond differently to the same offset, and why copying a stranger's numbers is a coin flip.

The lore: from pencil mods to warranty-approved sliders

The Machine remembers when this was dangerous on purpose. In the Athlon and Radeon 9700 era you bridged L1 connections with a graphite pencil, flashed a sister card's BIOS to unlock disabled pipelines, and soldered a variable resistor onto a VRM to fake the voltage feedback loop. A wrong move released the magic smoke and the smoke did not come back. The turbo button on the front of a 1990s PC case, by the way, did the opposite of what its name promised: pressed in, it usually slowed the CPU down for compatibility with software that ran too fast. That is the genre we are working in.

Today the vendors ship the tuning utilities themselves, which tells you how tame it has become. On the law: in the United States the Magnuson-Moss Warranty Act stops a manufacturer from voiding your entire warranty simply because you ran a tuning utility they distributed. It does not stop them from denying a specific claim if they can show the overclock cooked the specific part that failed. Most GPU warranties explicitly exclude damage from overclocking. In practice, software overclocking within the sliders almost never kills a card, because the firmware limits keep you inside survivable territory. The failure mode you will actually meet is a black screen and a recovered driver, not a funeral.

What you can actually expect

Set expectations in single digits. On a modern high-end card the realistic core headroom is a couple hundred megahertz of offset, and memory is where the surprise gains hide because factory memory settings are deliberately timid. If you are chasing frames because a specific game runs short, read our take on where those pixels go first: at 1440p versus 4K in 2026 a GPU overclock moves the needle far more at 4K, where you are GPU-bound, than at 1440p, where the CPU often caps you and the extra megahertz evaporate.

And keep it in proportion. A full generational jump dwarfs anything a slider does; our RTX 5080 versus 4080 comparison pegs the generational gain around fifteen percent, which is two to three times what a good overclock returns. If you are on a flagship already, the RTX 5090 review makes the case that the last five percent is the most expensive five percent in computing, and overclocking is the only version of it that is free. That is the correct frame: overclocking is not how you skip a GPU purchase. It is how you extract the last honest few percent from the one you own.

Prerequisites: Software Versions and Hardware

Assemble the toolkit before you touch a slider. Every item here has a job, and skipping one is how people end up unable to tell a bad overclock from a bad driver.

The software stack (and exact versions)

Install these four, in this order, and reboot after the driver:

• MSI Afterburner 4.6.6 (the current stable release, dated October 2025 on the project's version history). The preview track shows 4.6.7 Beta 3 dated 24 June 2026; the beta adds newer-card support but the stable build is the one to trust for a first pass. It remains the most recognizable GPU tuning utility in 2026 for a reason: it speaks to nearly every card, regardless of who made it.
• RivaTuner Statistics Server (RTSS), bundled with Afterburner. This is the on-screen display and frame-time monitor. Without it you are overclocking blind. Guide writers pair Afterburner with RTSS in 2026 exactly as they did in 2016; nothing has replaced it.
• UL 3DMark, specifically the Time Spy test, as your baseline-and-validation benchmark. It runs the same deterministic scene every time, so before-and-after numbers are comparable.
• Unigine Superposition, the standard soak test, for stability. It hammers the GPU harder and longer than a benchmark run.

Optionally add HWiNFO for deep sensor logging, including the memory-junction temperature that Afterburner does not always expose. Verify your driver and card details from a terminal before you begin:

C:\> nvidia-smi
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 595.76       Driver Version: 595.76       CUDA Version: 13.0      |
|-------------------------------+----------------------+----------------------+
| GPU  Name            TCC/WDDM | Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  GeForce RTX 5080   WDDM  | 00000000:01:00.0  On |                  N/A |
|  31%   42C    P8    18W / 360W|    812MiB / 16384MiB |      2%      Default |
+-------------------------------+----------------------+----------------------+

Note the power cap on the right of the fourth data row (360 W here) and the driver version in the header. Those two numbers frame everything that follows.

Drivers: the version that matters

Overclocking sits directly on top of the driver, so a flaky driver reads as a flaky overclock and you will chase a ghost for hours. On NVIDIA in 2026, one guide's field advice is to run driver 595.76 or later and specifically to avoid 595.59 and 595.71, both of which were flagged for instability. Whatever branch you are on, settle on a known-good driver first, run the machine at stock for a day to prove the driver itself is stable, and only then start tuning. If you update the driver mid-project, re-validate; a driver update can change boost behavior and quietly invalidate a profile you thought was rock solid.

Hardware you actually need

Three physical prerequisites, all cheap to ignore and expensive to skip. First, power supply headroom: an overclock raises sustained draw and, worse, the millisecond transient spikes that trip an undersized or aging PSU into a protective shutdown. If your rig reboots under load the instant you raise the power limit, the card is not the problem. Second, airflow: boost clocks are a function of temperature, so a hot case erases your overclock automatically as the algorithm bins down. Case fans earn their keep here. Third, and unglamorously, the card must not be sagging. A drooping card stresses the PCIe slot and the solder under the die, and a heatsink at a tilt makes uneven contact that shows up as a hot spot. Fix it before you add heat; our GPU support bracket guide handles that in about fifteen minutes and is the correct thing to do before, not after, you start pushing watts through the thing.

The Four Knobs: Power, Core, Memory, Voltage

Afterburner exposes a wall of sliders, but only four matter and they do not matter equally. Understand each before you drag anything.

Power limit: the one that does the most

The power-limit slider raises the board's total power ceiling, expressed as a percentage of the factory rating. This is the single highest-value move you can make, and multiple 2026 guides agree on the order of operations: raise the power limit to its maximum first, before you touch a single clock, because the extra headroom stabilizes the entire first tuning pass. Remember the boost algorithm from the intro. When you lift the power ceiling, the card is already trying to use it; on a well-cooled card, dragging the power limit to max is a small free overclock on its own, no offsets required. It costs you nothing but watts and a couple of degrees, and it does not risk data corruption the way an aggressive memory clock does. Max it and leave it.

Core and memory offsets

The core-clock and memory-clock sliders apply an offset, not an absolute frequency. On modern cards a +150 on the core slider shifts the whole voltage-frequency curve up by 150 MHz; the card still boosts and throttles dynamically, just from a higher baseline. Memory works the same way but the units feel larger because you are offsetting a much higher effective data rate. The two behave nothing alike when they fail, which is why you tune them separately: a core overclock that is too high produces a hard crash or a driver reset; a memory overclock that is too high produces visual artifacts and, past a certain point, lower performance from silent error correction. Keep them isolated so you always know which one broke.

Voltage, and why NVIDIA mostly ignores your slider

The core-voltage slider is the most overrated control on the panel. On most GeForce cards it is locked or nearly so; you can drag it, and the firmware quietly declines. Where it does apply, more voltage buys a little more clock at a steep cost in heat and power, and heat immediately bins your clock back down, so the net gain is often zero or negative. There is also a hard safety line. A 2026 safe-overclocking analysis argues for capping core voltage at 1.1 V on NVIDIA RTX 40 and 50 series and 1.2 V on AMD RX 7000 and 9000 series, per this write-up on overclocking safely. For a first overclock, leave voltage at zero offset entirely. The interesting thing you can do with voltage is go the other way and undervolt, which has its own section below and is frequently the smarter move.

Step 0: Benchmark a Baseline You Can Trust

You cannot claim an improvement you did not measure. Step 0 exists because half of all overclocking disappointment is people who never recorded where they started and are now arguing with a feeling.

Why a baseline is non-negotiable

An overclock is a difference, and a difference needs two measurements. The 2026 walkthroughs are unanimous in treating 3DMark as both the before and the after, with Time Spy named specifically as the run to record. Do a clean baseline at completely stock settings: every Afterburner slider at zero, power limit at default, no profile loaded. Close the browser, close Discord, close the launcher that is mining your CPU in the background. Run the benchmark twice and keep the second score; the first run warms the card and often reads low. Write the number down somewhere you will not lose it.

Running Time Spy at stock

Run 3DMark Time Spy and record the graphics score, not the combined score, because the combined score is diluted by your CPU. Also capture the average GPU clock, peak temperature, and peak power from the results detail page or from your monitoring overlay. Here is what a stock-versus-tuned comparison looks like once you have both halves; the numbers are illustrative of the shape of a good result, not a promise about your specific silicon:

3DMark Time Spy  --  Graphics score
  Stock         : 21,540    GPU 2,610 MHz avg    71 C    358 W
  +150 / +1000  : 22,880    GPU 2,835 MHz avg    73 C    372 W
  ------------------------------------------------------------
  Delta         : +6.2 %    +225 MHz clock       +2 C    +14 W

A six percent graphics gain for two extra degrees and fourteen extra watts is a representative, respectable outcome. If your delta comes out at one percent, the honest read is that your card was already near its limit and the juice was not worth the squeeze.

Log everything, including temperatures

Temperatures are not a footnote; they are the reason the overclock does or does not hold. Log the core temperature, the hot spot or junction temperature if your card reports it, and the memory-junction temperature, which on GDDR6X and GDDR7 runs far hotter than the core and is the quiet killer of memory overclocks. A live monitor during any run looks like this:

C:\> nvidia-smi dmon -s puct
# gpu   pwr  gtemp  mtemp    sm    mem   mclk   pclk
# Idx     W      C      C     %      %    MHz    MHz
    0   312     71     82    99     64  11500   2820
    0   316     72     83    99     65  11500   2835
    0   319     72     83    99     66  11500   2820

Watch the gap between gtemp (core) and mtemp (memory). If memory is pushing into the high 90s Celsius while the core sits in the low 70s, your memory overclock is thermally limited long before it is voltage limited, and better cooling or backing off the memory clock is the fix, not more offset.

The Overclock: 12 Steps

Here is the procedure. It is deliberately slow. Each increment is followed by a test, because the entire point is to catch the failure at the step that caused it, not three steps later when you have no idea which slider is guilty.

The rules before you start

Two rules govern the whole thing. Rule one: change one thing at a time. Core and memory are tuned in separate passes; never raise both in the same increment or you will not know which one crashed you. Rule two: retest after every single step. It is tedious and it is the difference between a stable overclock and a mystery. Modern guidance converges on small steps for exactly this reason, a +15 MHz to +25 MHz core increment and a +50 MHz to +100 MHz memory increment, retesting each time.

The 12 steps

1. Set a monitoring overlay and a hardware watchdog. Configure RTSS to show core clock, memory clock, core temp, memory temp, power, and frame rate. Rationale: you must see the card react in real time, and you must be able to spot a throttle the instant it happens.
2. Raise the power limit to maximum. Drag the Power Limit slider to its highest value and apply. Rationale: extra power headroom stabilizes the whole session and is itself a small free overclock, because the boost algorithm immediately uses it.
3. Raise the temperature limit to its ceiling and link it. Push the temp-limit slider up and lock it to the power limit. Rationale: you want the card to prioritize clocks over an artificially low thermal cap during testing; you will re-tighten fans later.
4. Apply, then re-run the baseline benchmark. Run Time Spy again with only power and temp raised. Rationale: this quantifies the free gain from headroom alone and confirms the machine is stable before you add offsets.
5. Add +15 MHz to the core clock and apply. Start the core pass conservatively. Rationale: small first steps mean the first instability arrives gently, as a recoverable driver reset, not a hard lock.
6. Run a short stability check, then increment again. Run a five-to-ten-minute Superposition loop or a Time Spy stress pass. If clean, add another +15 to +25 MHz and repeat. Rationale: retesting every increment isolates the exact clock at which artifacts or crashes begin.
7. Find the core wall, then back off one full step. When you hit a crash, a driver reset, or visible corruption, drop the core offset by one increment below the last stable value. Rationale: the edge of stability is not stable; you want margin, not the cliff itself.
8. Reset the core to its stable value and switch to memory. Leave the found core offset in place and begin the memory pass. Rationale: memory fails differently from core, so it gets its own isolated pass to keep the diagnosis clean.
9. Add +50 MHz to +100 MHz to memory and apply. Step the memory offset up. Rationale: factory memory settings are deliberately conservative, so this is often where the largest real gain hides.
10. Retest and watch the score, not just for crashes. Re-run the benchmark after each memory step and compare the score. If the score stops rising or falls while remaining crash-free, you have hit the error-correction cliff; back off until the score climbs again. Rationale: on GDDR6X and GDDR7, silent error correction trades performance for stability, so a higher memory number can mean a lower result.
11. Lock in both offsets and set a real fan curve. With the found core and memory values in place, replace the maxed temp limit with a custom fan curve that keeps the core under roughly 75 C under load. Rationale: sustained thermals, not benchmark-length ones, decide whether the overclock survives a long gaming session.
12. Save to a profile slot and enable apply-at-startup. Store the finished settings in an Afterburner profile and tick the option to apply the overclock at system startup. Rationale: an overclock that does not load automatically is one you will forget you have, and a saved profile is a one-click return to safety.

Reading the results as you go

Two patterns tell you almost everything. A hard crash, black screen, or a driver that stops responding and recovers is a core-clock or voltage problem: reduce the core offset. Speckles, flickering dots, corrupted textures, or a benchmark score that quietly drops is a memory problem: reduce the memory offset. If you keep those two signatures straight, you will never be confused about which slider to move. Everything past this section is about proving the settings hold up outside a two-minute benchmark, which is where overclocks that looked fine go to die.

Stability Testing: 30 Minutes, Then 2 Hours

A benchmark that passes is not a stable overclock. It is a stable overclock for the ninety seconds the benchmark ran. Real instability shows up on a timescale benchmarks do not reach, which is why the testing phase is longer than the tuning phase.

Synthetic first: Superposition for 30 minutes

Start synthetic because it is repeatable and it fails loudly. Run Unigine Superposition in a looping stress configuration for at least 30 minutes, which is the floor recommended across 2026 stability guides, and longer if you have the patience. Thirty minutes lets the card and its VRM and memory reach a true thermal steady state, which a benchmark run never does. Watch the overlay the whole time on the first pass. What you are looking for: any artifact, any clock that suddenly collapses and stays low (a throttle), any temperature that climbs without leveling off, and of course any crash. A clean thirty-minute Superposition run is your permission slip to move to real games. A run that dies at seven minutes is the card telling you the last increment was one too many.

Then the real test: 1 to 2 hours of actual games

Synthetic tests are necessary and insufficient. They load the GPU in an even, predictable way that real games do not; games hit the card with bursty, uneven workloads, sudden shader compiles, and scene transitions that can expose an instability a steady soak test never touches. So after Superposition passes, several 2026 guides recommend a conservative validation window of one to two hours in games you actually play, and they are right. Pick the most demanding title you own, the one with ray tracing and a busy open world, and play it the way you normally would. Alt-tab in and out; that transition alone catches a surprising number of marginal overclocks. If you make it through two hours across a couple of games with no crash to desktop, no driver reset, and no visual garbage, the overclock is real. If a game crashes at the ninety-minute mark, that is not bad luck, that is your answer, and the fix is one increment down.

Reading a crash: the TDR log

When it fails, Windows usually tells you exactly what happened. The Timeout Detection and Recovery mechanism logs an event when the display driver hangs and restarts, and that event is your smoking gun. A typical bisection session, reading from the Windows Event Viewer and your own notes, looks like this:

Event 4101, Display:
  nvlddmkm stopped responding and has successfully recovered.

OC log:
  CoreClkBoost = +180 MHz    Superposition crashed at 00:07:12
  CoreClkBoost = +165 MHz    game crash to desktop at 01:22:00
  CoreClkBoost = +150 MHz    Superposition 30:00 + 2h gaming, 0 artifacts  [KEEP]

That is the whole methodology on one screen: push until it breaks, note the time and the setting, step down, and re-prove it over a longer window until a setting survives everything you throw at it. The kept value is always a step below the highest value that did not crash, because the highest passing value is the edge and the edge moves with temperature and driver version.

The Undervolt: Often Smarter Than Overclocking

Here is the contrarian section, and the one The Machine would actually recommend to most people. For a large share of modern cards, the best tune is not more clock at more voltage. It is the same clock at less voltage.

Why lower voltage can mean higher clocks

Recall that boost clocks are gated by power and temperature. A stock card at full load often runs its voltage higher than it strictly needs to hold its clock, which wastes power as heat, which raises temperature, which makes the boost algorithm bin the clock down. Break that loop and you win twice. If you can hold, say, 2,850 MHz at a lower voltage, the card draws less power and runs cooler, and because it runs cooler it stops throttling, so it actually sustains a higher average clock over a long session than the stock card that was thermally binning itself. You end up faster in practice and quieter and cooler, from lowering a number. That is the closest thing to a free lunch in this hobby, and it is why undervolting has quietly become the enthusiast default.

The curve editor, step by step

Open Afterburner's voltage-frequency curve editor with Ctrl+F. The graph plots the clock the card will run at each voltage point. The technique: pick a target voltage on the horizontal axis, well under the cap of 1.1 V for RTX 40 and 50 series, then drag the point at that voltage up to your desired clock, and flatten everything to the right of it into a horizontal line so the card can never exceed that clock or that voltage. Apply, and the card now hits your target clock at your chosen voltage and refuses to go higher on either. Then stress test it exactly like an overclock, because an undervolt that is too aggressive is just as unstable as an overclock that is too high, and it fails the same way: a driver reset in the first ten minutes. Find the lowest voltage that holds your target clock through a full Superposition run plus real games, then back off one notch for margin.

When to undervolt instead of overclock

Choose the undervolt when your card is thermally or acoustically limited, which describes most compact builds, most cards with a coil-whine problem, and anyone whose GPU sounds like a hair dryer under load. Choose the straight overclock when you have a genuinely cold, quiet card with obvious thermal headroom and you want the absolute maximum frames and do not care about power. Choose both, in sequence, if you are thorough: undervolt to a flat efficient curve first, then nudge the whole curve up by a small offset for a tune that is faster and cooler than stock. Most people should stop at the undervolt. It solves the problem they actually have.

Common Pitfalls and How to Fix Them

Every one of these has cost someone a weekend. They are listed in rough order of how often they bite.

The two mistakes that cause most crashes

The first is overclocking before proving stock stability. If the machine is not perfectly stable at completely stock settings, every crash you hit while tuning is ambiguous and you will blame the overclock for the driver's sins. Prove stock first, for a full day of normal use. The second is raising core and memory together. When both move and the card crashes, you have two suspects and no way to convict either, so you drop both and lose gains you did not need to lose. One knob at a time, always.

The subtle ones: the memory cliff, the silicon lottery, and cold bugs

The memory error-correction cliff is the sneakiest failure because it does not crash. GDDR6X and GDDR7 correct errors silently, so past a certain clock the card stays perfectly stable while quietly retransmitting corrected data, and your performance goes down as the memory offset goes up. You will never see it if you only test for crashes; you have to watch the benchmark score. The silicon lottery is the reason a stranger's numbers betray you: two cards off the same line with the same BIOS take different offsets, so treat every published setting as a starting hypothesis, not a target. And the cold bug: an overclock validated in a cool room in the evening can fail on a hot afternoon, because the ambient temperature changed the thermal headroom the boost algorithm had to work with. Leave margin for your worst-case room, not your best-case one.

The fixes, listed

• Score drops as memory clock rises. You are past the error-correction cliff. Reduce the memory offset in 50 MHz steps until the score climbs again, and keep the setting one step below the peak.
• Stable in benchmarks, crashes in games. Your test was too short and too even. Validate with 30 minutes of Superposition and one to two hours of real gameplay before you trust any setting.
• Overclock evaporates over a long session. The card is thermal-throttling. Set a more aggressive fan curve, improve case airflow, and confirm the card is not sagging into poor heatsink contact.
• Reboots the instant you raise the power limit. Power supply cannot handle the transient spikes. Lower the power limit, and treat a persistently insufficient or aging PSU as the real fix.
• Copied someone's numbers and it will not boot cleanly. Silicon lottery. Clear the profile, start from zero, and find your card's ceiling from scratch.
• Random black screen weeks later. A too-aggressive setting that only fails under specific conditions, often a hot room. Drop the offsets one step for margin, or undervolt for a flatter, more forgiving curve.

Troubleshooting Table

When something breaks, match the symptom to the row and apply the fix. Then re-run the relevant test before you trust it again.

Symptoms, causes, and fixes

How to bisect an unstable overclock

When you cannot tell which knob is at fault, bisect. Return everything to stock, confirm stability, then raise only the core in your normal steps until it breaks and record the last stable value. Reset core to that value, then raise only the memory until it breaks and record that. Now you have two independently proven ceilings. Combine them and test together; occasionally the combination is slightly less stable than each was alone, in which case drop the more heat-sensitive of the two, usually memory, by one step. Bisection turns a vague "it crashes sometimes" into a specific number in about twenty minutes.

When it is not the overclock at all

Not every crash is your fault. A known-bad driver, as noted earlier with the versions to avoid, presents identically to an unstable overclock. So does a dying power supply, a dust-clogged cooler, or a background application fighting for the GPU. The tell is simple: set every slider to zero, reboot, and reproduce the crash at stock. If it still crashes at stock, stop tuning and go fix the driver, the PSU, or the airflow. The overclock is innocent, and no amount of slider-nudging will fix a hardware or driver problem underneath it.

Advanced Tips: Curve Editor, Linux, and LN2

Once the basic tune holds, there is a second layer of refinement, a different operating system to cover, and a lunatic fringe worth admiring from a safe distance.

Per-game profiles and memory temperature

Afterburner stores multiple profile slots, and RTSS can associate a profile with a specific executable, so a memory-bound title can load a memory-heavy tune while a lighter game loads a cool, quiet undervolt. This is overkill for most people but genuinely useful if one game in your library is the reason you started overclocking. The other advanced habit is watching memory-junction temperature, not just core temperature. On GDDR6X and GDDR7 the memory can sit twenty to thirty degrees above the core and thermally throttle independently, tanking the very memory overclock you worked to find. HWiNFO exposes that sensor when Afterburner does not. If your memory-junction temperature is climbing into the high 90s Celsius, better airflow over the backplate or a small backplate fan will buy you more than any additional offset.

Overclocking on Linux

Linux does this from the command line, and it is not hard once the driver's overclocking controls are unlocked via the Coolbits mechanism. Enable the controls, raise the power limit through nvidia-smi, and apply clock offsets through nvidia-settings:

# Unlock overclocking + fan control (Coolbits), then reboot
sudo nvidia-xconfig --cool-bits=28

# Enable persistence mode and raise the power limit to 360 W
sudo nvidia-smi -pm 1
sudo nvidia-smi -pl 360

# Apply +150 MHz core and +1000 MHz memory offset on GPU 0
nvidia-settings -a "[gpu:0]/GPUGraphicsClockOffsetAllPerformanceLevels=150"
nvidia-settings -a "[gpu:0]/GPUMemoryTransferRateOffsetAllPerformanceLevels=1000"

The Coolbits value of 28 enables both overclocking and manual fan control on current drivers. AMD on Linux is handled through CoreCtrl or LACT, or directly through the kernel's pp_od_clk_voltage interface, and the same discipline applies: small steps, long soak tests, one knob at a time. The methodology is operating-system-agnostic; only the buttons change.

The extreme end: liquid nitrogen and the 4.769 GHz record

And then there is the world where the sliders are the least of it. In February 2026, overclocker Bill Alverson, working with AMD, pushed a Radeon RX 9060 XT to 4.769 GHz of core frequency under liquid nitrogen, a run reported by HotHardware. That is not a tune you run daily; it is a physics demonstration, held for the length of a benchmark validation, with a pot of cryogenic liquid poured onto the die to hold it near two hundred degrees below zero so the silicon will accept voltages and clocks that would incinerate it at room temperature. Take from it only the principle it proves: clock speed is gated by heat, and if you remove enough heat the ceiling rises absurdly. You will not pour nitrogen into your case. But the humble version of that principle, better airflow gets you higher sustained clocks, is the single most useful idea in this entire tutorial.

Vendor Tools and the AMD Side

Afterburner is the universal tool, but the board partners keep shipping their own, and AMD folds the whole thing into its driver. Here is when any of that matters.

ASUS GPU Tweak III and PNY VelocityX

Vendor-branded utilities are alive and maintained in 2026. Geeks3D documents ASUS GPU Tweak III at version 1.9.5.8, added 2 May 2025, and PNY lists its VelocityX software at V0.1.3.5, dated 5 May 2026. They do the same three things Afterburner does, occasionally with a nicer default fan curve or a card-specific feature Afterburner has not caught up to yet. If you own that exact brand of card, the vendor tool is worth a look, mainly for the tighter fan and RGB integration. For the actual overclocking, they are interchangeable with Afterburner, and mixing two tuning utilities at once is a reliable way to create conflicts, so pick one and uninstall the other.

AMD Radeon: the driver does it in-house

Radeon owners do not need a third-party tool at all. The AMD driver includes a full tuning panel with automatic and manual modes, per-game profiles, and an undervolt-plus-overclock workflow built in. Voltage discipline still applies: the safe cap referenced earlier is 1.2 V on RX 7000 and 9000 series. The AMD panel's automatic undervolt is a genuinely good starting point and does much of the curve-editor work for you; treat its result as a baseline, then verify it with the same Superposition-plus-games regimen, because "automatic" is not the same as "validated for your specific card."

Which tool should you actually use

For a first overclock on any card, use MSI Afterburner 4.6.6 with RTSS, because it is the most documented, the most universal, and the version every 2026 guide assumes you are running. Use your vendor's tool only if it offers a specific feature you need, and never run two at once. Radeon owners can skip the third-party stack entirely and use the driver panel. The tool is not where the skill lives; the discipline of small steps and long tests is, and that transfers across every one of them.

The Complete Working Configuration

Here is a finished, validated profile to work backward from. It is written for a well-cooled RTX 5080 and is illustrative; your offsets will differ because your silicon differs. Treat it as the shape of a good result, not a set of numbers to copy.

The Afterburner profile, annotated

Afterburner stores each profile as a per-GPU configuration file in its Profiles folder. An annotated version of a validated tune reads like this:

; MSI Afterburner 4.6.6 profile  --  RTX 5080
; Validated: 30 min Superposition + 2 h gaming, 0 artifacts, 0 crashes
[Settings]
Format=2
Power=110            ; power limit slider at its maximum
Thermal=88          ; thermal target, degrees C
ThermalPrioritize=0
FanMode=1           ; custom fan curve, see [Fan]
CoreClkBoost=150000     ; +150 MHz core offset (value in kHz)
MemClkBoost=1000000     ; +1000 MHz memory offset (value in kHz)
CoreVoltageBoost=0      ; voltage untouched; hard cap 1.1 V RTX 40/50
[Fan]
FanSpeed0=30,45     ; 30% fan below 45 C
FanSpeed1=55,70     ; 55% fan at 70 C
FanSpeed2=85,83     ; 85% fan at 83 C

The offsets are stored in kilohertz, so 150000 is a +150 MHz core offset and 1000000 is a +1000 MHz memory offset. In the application, tick Apply overclocking at system startup and save this into a numbered profile slot so it survives reboots and gives you a one-click path back to safety.

The validation checklist

Before you call any configuration final, confirm every line of this checklist. It is the whole tutorial compressed into a pre-flight:

• Machine proven stable at completely stock settings for a full day.
• NVIDIA driver 595.76 or later; not 595.59 or 595.71.
• Power limit maxed; core and memory tuned in separate passes.
• Voltage left alone, and in no case above 1.1 V (NVIDIA 40/50) or 1.2 V (AMD 7000/9000).
• Time Spy baseline recorded before, and a higher score confirmed after.
• Memory offset one step below the point where the score stopped climbing.
• Superposition clean for 30 minutes; games clean for one to two hours.
• Custom fan curve holding the core near 75 C, memory junction out of the high 90s.
• Profile saved and apply-at-startup enabled.

The one-paragraph version

If you remember nothing else: max the power limit first, raise the core in 15 to 25 MHz steps and the memory in 50 to 100 MHz steps, retest after every single increment, back off one step from the first failure, prove it with 30 minutes of Superposition and two hours of games, cap voltage at 1.1 or 1.2 volts, save the profile, and set it to load at startup. Do that and you will extract every honest percent your card has to give, which in 2026 is single digits, because the boost algorithm already took the rest. That is not a disappointment. It is the correct expectation, met precisely, which is the only kind of overclocking worth doing.