Two Bits, Twice the Math: The Kernel Module That Unlocked the Full Tensor Speed NVIDIA Buried in Your RTX 3090

Published: October 25, 2026 | Reading Time: ~11 minutes | Channel: techminute

---

Somewhere on a shelf near you sits a six-year-old graphics card that has been running its AI workloads at half speed since the day it was made. Not because the silicon is worn out. Not because the drivers are badly tuned. Because two bits in its firmware say so — the same two bits that say the opposite on the professional cards built from the exact same chip.

On October 24, a GitHub project called gpu-unlock by a developer going by Zagitta hit the front page of Hacker News (280 points and climbing at time of writing, in a story submitted by user fragebogen), and the numbers it posts are the kind you usually have to read twice. On a stock RTX 3090 Ti, a dense 8192³ BF16 matrix multiplication — the bread-and-butter operation of modern AI — measured 87.50 TFLOPS before the unlock and 157.41 TFLOPS after. That is a 79.9% jump, on a card NVIDIA shipped in 2021, achieved with a Linux kernel module, a kernel command-line flag, and no soldering iron anywhere in sight.

And the best part? NVIDIA wrote the whole thing down in its own whitepapers. The cap was never a secret. It was a price tag.

---

The Context: The Half-Rate Cap Hiding in Plain Sight

Here is the deal NVIDIA has cut with the market since the Ampere generation: GeForce cards and professional cards are built from the same silicon, but they are not allowed to do the same math at the same speed.

Specifically, on GeForce Ampere and Ada cards, tensor-core instructions that accumulate their results in FP32 — the precision mode that matters for stable, serious numerics — issue at half the rate of the same instructions accumulating in FP16. This is not forum folklore. It is in NVIDIA's own whitepapers, and developers have tabulated it: the RTX 3090 issues dense FP16 HMMA instructions at a rate of 71 with FP32 accumulation versus 142 without it; the RTX 4090 shows the same 165-versus-330 split. Professional and datacenter cards — the A6000, A40, L4, L40S — carry no such penalty on the same underlying architecture.

Why does FP32 accumulation matter so much? Modern mixed-precision training and inference do their fast math in FP16 or BF16 but keep a full-precision FP32 running total, because adding thousands of half-precision numbers together in half precision quietly destroys your result. FP32-accumulate tensor math is not an exotic mode — it is how serious frameworks use tensor cores. Which means on a GeForce card, the mode everyone actually trains and prefills with is the one running at half speed.

The hardware is identical. An RTX 3090's GA102 die and an RTX A6000's GA102 die do the same FLOPs at the same clock. The limit lives in firmware speed-select registers, and unlocking them on the professional cards is, in effect, what the extra zeros on the invoice are for. As Hardware Busters put it in their October 25 write-up, this cap is "one of the few hard lines separating a $1,599 GeForce from a workstation card that costs several times as much on the same die."

For five years, that line held.

---

Under the Hood: A Boot-Time Heist, Two Bits at a Time

The gpu-unlock README describes what the module does with almost offensive understatement: it "flips the 2 bits that halve how often the core can issue" the locked instructions, as Zagitta put it in the Hacker News thread. The mechanics are more interesting than the summary.

The module is a Linux kernel module that runs before NVIDIA's driver ever binds to the card. It is packaged into the initramfs and ordered immediately ahead of the nvidia module, so there is a brief window at boot where the card exists but no driver owns it. In that window, gpu-unlock:

1. Runs the unlock transaction — combining the V67/PLM technique from the older CMP mining-card unlocker with the pre-driver timing approach pioneered by UEFI-based ports. (The lineage is legitimately spicy: the technique's documentation describes getting code execution inside the card's firmware boot environment via a stack buffer overflow and Return-Oriented Programming. That research predates this project; gpu-unlock builds on its results.)
2. Writes the speed selectors — SS0 0x88888888, which selects the full BF16 rate, and the 4-bit SS1 0x8 IMLA4 value.
3. Performs a PCIe function-level reset (FLR) and steps aside, letting the completely unmodified, stock NVIDIA driver bind the card as if nothing happened.

That last point is the engineering payoff. Earlier approaches were UEFI applications or patched drivers — both brittle, because a patched driver breaks every time NVIDIA ships a new one. The kernel-module approach survives driver updates untouched, because the driver itself is never touched. And the build system is surprisingly hygiene-obsessed: every build downloads pinned NVIDIA inputs over HTTPS, verifies them against SHA-256 hashes, and generates the unlock firmware only on the user's own machine. The repository itself ships no NVIDIA binaries. The kernel module and packaging are GPL-2.0-only.

Activation is deliberately opt-in. The module does nothing at all unless you add gpu_unlock.targets=all — or specific PCI addresses — to your kernel command line. Cards that are already bound or powered down are skipped. It handles multi-card rigs (community reports cover up to four cards in one machine), cards passed through to VMs via vfio-pci, and yes, the card driving your display — its screen goes blank for about a second mid-boot while the reset happens, then the normal driver takes over. Suspend-to-RAM resets the selectors, so the module quietly re-unlocks on resume, adding about a second. Hibernation is explicitly not covered.

The project sits at roughly 5.1k stars and 553 forks on GitHub, with 23 commits — and a derivatives race has already started. A separate project, gpu-unlock-ada by a developer called JustAResearcher, applies the same trick to Ada-generation cards, and an HN commenter points to a community effort unlocking Turing's 2080 Ti as well.

---

By the Numbers: What Actually Doubles

Zagitta's headline table — RTX 3090 Ti, dense 8192³ GEMM, FP32 accumulation, 450 W power limit, five-sample medians:

Input precision	Before	After	Gain
FP16	87.46 TFLOPS	118.39 TFLOPS	+35%
BF16	87.50 TFLOPS	157.41 TFLOPS	+79.9%
TF32	42.58 TFLOPS	82.61 TFLOPS	+94%

Note what the table is quietly telling you: BF16 gains nearly the full 2×, FP16 gets only +35%, and TF32 — which was running at quarter-ish effective rate relative to BF16 before — nearly doubles. The cap and the unlock behave exactly the way an instruction-issue-rate limit should, which is a good sign the mechanism is what the author says it is.

Community compatibility reports on the repo (each tester's own benchmarks, so not perfectly comparable) fill out the picture:

Card	Reported BF16 GEMM gain
RTX 3090 Ti (GA102)	+68–80%
RTX 3090 (GA102)	+25–67%
RTX 3080 10 GB (GA102)	+70–73%
RTX 3070 (GA104)	+73–81%
RTX 3060 12 GB (GA106)	~+80%
RTX 3080 Ti 20 GB OEM (GA102-250)	Unlock completes, BF16 stays half-rate

That last row is the honest outlier — at least one OEM-variant GA102 accepts the transaction but keeps the cap, a useful reminder that this is firmware archaeology, not a guarantee. Notebookcheck's October 24 report cites a separate community run where an RTX 3090 went from 77.5 to 129.6 TFLOPS in BF16 (TF32: 40.2 → 69.8) — different card, same story.

And the Ada-side sibling delivers on the promise completely: Hardware Busters reports gpu-unlock-ada taking an RTX 4090 from 165.6 to 331.6 TFLOPS in FP16 with FP32 accumulation, and 165.5 to 330.6 in BF16 — an almost textbook 2.00×. An experimental RTX 4070 Ti Super target doubled from 95.0 to 189.9 TFLOPS at a 240 W cap. INT8 and FP8 rates did not move at all, which is exactly what you'd expect if only the FP32-accumulate path was ever throttled.

Perhaps most reassuring: community testers who compared numerical outputs before and after found them bit-identical. This is not overclocking. The card is not computing anything differently — it is just being allowed to issue the instructions it was always physically capable of issuing.

What it means for real workloads

This is where the story gets useful instead of just fun:

• LLM prefill — the compute-bound prompt-processing phase — gains 14–36% across community reports, and Zagitta reports vLLM prefill improving up to 30% depending on kernels and prompt size.
• Token generation (decode) stays about the same, because decode is memory-bandwidth-bound, not math-bound. If you bought your 3090 to run models, your tokens-per-second barely move — but your prompts clear faster.
• Diffusion and image generation see the big wins: Notebookcheck cites ComfyUI testing on a 3090 Ti at roughly 47–59% higher throughput across BF16-heavy workloads; Hardware Busters mentions a BF16 image-generation job dropping from 72 to 45 seconds.
• Fine-tuning and training-style GEMM work — the exact jobs people buy 24 GB GeForce cards to do on the cheap — are the core beneficiary.

---

What This Changes

The homelab economics just shifted. There is an enormous installed base of RTX 30-series cards — particularly 24 GB 3090s — living in basement AI rigs, homelab servers, and budget research clusters, precisely because the VRAM crisis has made anything with 24 GB feel like a family heirloom. A free kernel module that adds up to ~70 TFLOPS of BF16 to each of those cards, with bit-identical outputs and no hardware modification, is the closest thing to a free lunch this hobby has offered in years. One Hacker News commenter described rigging 3090s in an external enclosure with a PCIe backplane to give them "fresh air" and P2P networking — the used-GPU tinkerer economy this project feeds is very real and very large.

The segmentation story takes a hit. NVIDIA's product line has always drawn some of its lines in firmware — this cap, P2P restrictions on GeForce, mining-card limps, VRAM clocks. Every time someone demonstrates that a "consumer" card was professionally capable all along, the premium on the professional SKU gets a little harder to defend. It also lands awkwardly right now: this is the same season NVIDIA shipped the $2,599 Surface Laptop Ultra's RTX Spark and $6,999 workstation laptops, products whose value proposition is exactly the local tensor throughput that a 2020 card just partially reclaimed for free.

NVIDIA's response is the open question. Hardware Busters' prediction is blunt: a firmware-level bypass of one of the last hard GeForce/professional dividing lines "is the kind of thing that tends to get closed in a later driver or firmware revision." Maybe. Closing it means touching the speed-select plumbing on every shipping GPU, and the company has historically tolerated known CMP unlocks for a long time before acting. But anyone building a workflow on this should keep a stock boot entry handy, because the off switch is NVIDIA's to flip.

---

⚠️ Limitations & Caveats

1. Power and heat are the real tax. The headline numbers were measured at 450 W — well above what stock 3090-class coolers were designed to sustain. HN user jacquesm, who tested across seven 3090s of different vintages, reports all of them need a power-limit increase to exceed ~25% gains; at a stock 225 W-style cap you get a smaller boost because the card simply shifts down its frequency curve to stay within its power budget. Water cooling helps (Zagitta runs two watercooled 3090s, a month, no issues — but that's the author's own rig).
2. The gains are workload-specific. LLM decode, INT8 work, gaming, and anything memory-bound see little to nothing. The Ada README is admirably candid that its figures are register-resident issue rates, not application-level speedups, and that independent reproduction is still pending.
3. It is Linux-only for now — with an experimental Windows port that has booted an unlocked 3090 on exactly one specific system. Your gaming rig running Windows gets no free lunch today.
4. No gaming gains demonstrated. DLSS leans on tensor cores, which made everyone hopeful, but no independently verified FPS improvement exists.
5. Not every card unlocks. The GA102-250-based 3080 Ti 20 GB OEM accepts the transaction and keeps its cap. Treat per-card results as reports, not promises.
6. It is still firmware surgery. The technique descends from research that exploited a buffer overflow in the GPU's boot firmware to run arbitrary code on the card. Reports so far show no casualties — and outputs verified bit-identical — but "experimental, at your own risk, keep a stock boot entry" is the honest framing, and it's the README's own.

---

🎯 The Bottom Line

Two bits of firmware, flipped at the right moment before the driver loads, just turned a six-year-old GeForce into something much closer to the professional card it was born as — nearly doubling its BF16 throughput for the price of a kernel argument and a warmer living room. It is a reminder that a lot of what we buy in this industry isn't silicon; it's a settings file with a marketing department. Whether NVIDIA lets this particular settings file keep working is next quarter's story. For now, the basement rigs are winning.

---

📚 Sources

1. Zagitta/gpu-unlock (GitHub) — Primary source: README with benchmark tables, compatibility reports, installation and boot-flow documentation. https://github.com/Zagitta/gpu-unlock
2. Hardware Busters — "RTX 4090 Tensor Unlock Doubles FP16 Throughput on Linux, and Ampere Cards Gain Up to 80%" (Oct 25, 2026) — Ada-side results, context on the cap and NVIDIA's likely response. https://hwbusters.com/news/rtx-4090-tensor-unlock-doubles-fp16-throughput-on-linux-and-ampere-cards-gain-up-to-80/
3. Notebookcheck (Anil Ganti) — "Nvidia RTX 3090 performance nearly doubles with free GPU unlock, but there's a catch" (Oct 24, 2026) — community figures, ComfyUI results, Windows-port status. https://www.notebookcheck.net/Nvidia-RTX-3090-performance-nearly-doubles-with-free-GPU-unlock-but-there-s-a-catch.1432805.0.html
4. NVIDIA Ampere GA102 Whitepaper — official architecture documentation (GeForce vs professional variants). https://www.nvidia.com/content/PDF/nvidia-ampere-ga-102-gpu-architecture-whitepaper-v2.1.pdf
5. kadirnar/kernel-agent Issue #257 (GitHub) — tabulated tensor-core instruction rates citing NVIDIA whitepapers (RTX 3090 71 vs 142; RTX 4090 165 vs 330). https://github.com/kadirnar/kernel-agent/issues/257
6. Hacker News thread — story 50219700 (280 points, 73 comments), author test reports by jacquesm, Tiberium, Zagitta, and others (community-sourced). https://news.ycombinator.com/item?id=50219700
7. JustAResearcher/gpu-unlock-ada (GitHub) — Ada-generation derivative project (referenced via Hardware Busters). https://github.com/JustAResearcher/gpu-unlock-ada

All claims verified against Gold-tier (GitHub repository, official whitepapers) and Silver-tier (Notebookcheck, Hardware Busters) sources; each URL was scraped and confirmed accessible with matching content on October 25, 2026. Community-reported figures (HN thread, repo compatibility reports) are labeled as such and attributed to their authors.