For years there's been a quiet, unspoken suspicion among local-AI folks that consumer GeForce cards were somehow running slower than they should. Benchmarks never quite matched the spec sheet. A card advertised at 165 TFLOPS would hand you a fraction of that in real FP16 workloads. Most of us chalked it up to power limits, memory bandwidth, or "that's just how it is with consumer silicon."
Turns out it wasn't any of those. NVIDIA ships GeForce cards with their tensor cores deliberately capped to half speed for FP16, BF16, and TF32 math with FP32 accumulation — which happens to be exactly the math that nearly all AI training, unquantized inference, and image generation relies on. The identical silicon sold as an RTX A-series or professional card runs at the full rate.
In the last two weeks, the open-source community finally did something about it. Two projects — gpu-unlock (13k+ stars) and gpu-unlock-ada (4.5k+ stars) — went from zero to essential overnight, and there is still almost no plain-English explainer for what they actually do. This post is that explainer.
The TL;DR
- Your GeForce GPU is running FP16/BF16/TF32 tensor math at roughly half its true rate. This is a deliberate market-segmentation decision by NVIDIA, not a hardware limitation.
- Two new Linux kernel modules remove the cap at boot, before the stock NVIDIA driver loads. No patched driver, no VBIOS flash, nothing to redo when a new driver drops.
- The speedup is workload-dependent. LLM prefill (prompt processing) gains 25–55%, fine-tuning gains 25–50%, image generation gains 30–55%. LLM decode (token-by-token generation) — which is memory-bound, not compute-bound — sees little to no change.
- It covers RTX 20, 30, and 40 series. RTX 50 (Blackwell) is not supported and likely won't be. It's Linux-only for now.
The Cap Nobody Documented
Let me be precise about what "half speed" means, because it matters for knowing whether your workload benefits.
Modern GPUs have tensor cores — dedicated hardware for matrix multiplication that LLMs and diffusion models hammer constantly. These tensor cores run math at different precisions:
- FP16 / BF16 — 16-bit floating point, the workhorse of modern AI training and unquantized inference.
- TF32 — a TensorFloat-32 hybrid used by PyTorch's default matmul path.
- INT8 / FP8 / INT4 — quantized inference formats.
The cap NVIDIA places on GeForce cards applies specifically to FP16, BF16, and TF32 when accumulating into FP32 (the "FMA" or fused-multiply-add path). On a stock RTX 4090, that path runs at ~165 TFLOPS. The same die with the cap removed runs at ~330 TFLOPS. The tensor cores were physically capable of double the rate the entire time.
Crucially, the cap does not touch:
- INT8 / FP8 / INT4 quantized matmuls — these run at full speed already.
- Gaming and FP32 CUDA — completely unaffected.
- Memory bandwidth — which is why token generation (decode) doesn't speed up.
This is the single most important thing to internalize before you get excited: quantized models (the GGUF/AWQ/GPTQ files most homelabbers run through llama.cpp or Ollama) already sidestep much of the cap by using INT8/INT4 paths. The people who see the full 2× are running FP16/BF16 inference, training, or diffusion — not a Q4_K_M Llama.
What the Two Projects Do
gpu-unlock (Zagitta)
The original. A Linux kernel module that targets RTX 20 (Turing), RTX 30 (Ampere), and RTX 40 (Ada) cards. It builds from source (make install detects your distro and packages it for Arch, Debian/Ubuntu, or Fedora/RHEL), drops a firmware payload into your initramfs, and runs the unlock before the unmodified NVIDIA driver binds the card.
It works by writing the card's speed selectors at boot — specifically SS0 = 0x88888888, which selects the full BF16 rate, and the 4-bit SS1 selector for IMLA4. There's no VBIOS flash and no patched driver: the magic happens in the ~1 second between initramfs and driver load, and the stock driver then binds the card and runs it as normal.
Opt-in is via a kernel command-line flag:
gpu_unlock.targets=all # every supported card
gpu_unlock.targets=0000:21:00.0 # or specific cards
The project is GPL-2.0, with the caveat that it bundles NVIDIA firmware under its own terms (the maintainer is explicit about this in firmware/NOTICE.md).
gpu-unlock-ada (JustAResearcher)
A fork focused on RTX 4090 (AD102) and experimental Ada support — RTX 4070 Ti SUPER, 4080, 4080 SUPER, 4070, and the RTX 4090 laptop GPU. It integrates the published AD102 payload into gpu-unlock's Linux module and packaging. Where the original lists RTX 40 as "experimental," this fork is where the deep 4090-specific validation actually happened — matched stock-vs-unlocked benchmarks, multiple driver versions, multiple cold boots.
The two projects overlap heavily and are now somewhat symbiotic. The short version: gpu-unlock is the umbrella for 20/30/40; gpu-unlock-ada is the precision fork for 4090 and other AD102/AD103 parts. If you own a 4090, you probably want the Ada fork's validation behind you.
The Benchmarks: What Actually Speeds Up
Here's the honest table. I'm pulling from the maintainers' own numbers and the compatibility reports users have filed — not the marketing-friendly "up to 2×" headline.
Dense matrix multiply (BF16, FP32 accumulation, stock power limits):
| Card | BF16 Before | BF16 After | Gain |
|---|---|---|---|
| RTX 3060 12GB | 27 TFLOPS | 51 TFLOPS | +87% |
| RTX 3070 | 40 TFLOPS | 72 TFLOPS | +81% |
| RTX 3080 10GB | 65 TFLOPS | 113 TFLOPS | +73% |
| RTX 3090 | 75 TFLOPS | 125 TFLOPS | +65% |
| RTX 3090 Ti | 88 TFLOPS | 157 TFLOPS | +80% |
| RTX 4070 Ti | 81 TFLOPS | 150 TFLOPS | +84% |
| RTX 4080 | 104 TFLOPS | 193 TFLOPS | +87% |
| RTX 4090 | 165 TFLOPS | 329 TFLOPS | +100% (peak) |
Those are register-resident issue rates — the theoretical ceiling. The real-world gains depend entirely on how compute-bound your workload is:
| Workload | Typical Speedup |
|---|---|
| LLM prefill / prompt processing (FP16/BF16, AWQ/GPTQ) | +25–55% |
| Time to first token | 25–30% lower |
| LoRA and full fine-tuning (BF16) | +25–50% |
| Image generation (SDXL, SD 1.5, DiT in ComfyUI) | +30–55% |
| FlashAttention / SDPA kernels | +50–60% |
| Video generation (Wan 2.2, BF16) | +15–20% |
| llama.cpp / Ollama with quantized GGUF | 0–15%, mostly long-context |
| LLM decode / token generation (memory-bound) | No change |
| INT8 / FP8 / INT4 quantized models | No change |
| Gaming and FP32 CUDA | No change |
The RTX 4090 deserves its own caveat: it hits its power ceiling before it saturates the unlocked tensor cores. At a fixed 450 W cap, large GEMMs gain much less than the 2× peak suggests — you're power-limited, not compute-limited. That's why the honest 4090 numbers in real cuBLAS GEMMs are 12–34% for FP16, not 100%.
Why Did NVIDIA Do This?
Because they can. Market segmentation. The tensor cores are identical across GeForce and professional/datacenter parts; NVIDIA simply sells the full rate to the RTX A-series, RTX Pro, and datacenter buyers at a 3–10× price premium. Capping consumer cards is how they keep that price gradient defensible without designing separate silicon.
The project FAQ puts it bluntly: "They want businesses to purchase the professional cards without these limitations at significantly higher prices." It's the same play as ECC memory gating, virtualization gating, and the NVENC stream limits — software-enforced tiers on identical hardware.
This also explains why the unlock is possible at all. It's not an overclock in the traditional sense — it's removing an artificial floor that NVIDIA set in the card's speed-select registers. The thermal and power management systems stay fully intact, so the card still throttles and downclocks exactly as it always did. You're not pushing the silicon harder than it was designed to go; you're letting it do what it was always physically capable of.
The Risks (Read This Before You Clone)
I'm not going to tell you this is zero-risk, because it isn't, and anyone who says otherwise is being cavalier. Here's the honest risk profile:
1. It's brand new and moving fast. gpu-unlock went from nothing to 13k stars in two weeks. The code is being rewritten, the supported-card matrix is changing, and "experimental" on the README genuinely means experimental. The Ampere (RTX 30) support is marked "stable, 100+ user reports." Everything else is "experimental" for a reason.
2. It's a boot-time kernel module that touches your GPU's firmware state. If something goes wrong, it goes wrong at boot, before your driver loads. Worst case is a card that doesn't initialize and a blank screen — recoverable by removing the kernel flag, but not a fun afternoon if you don't have a second display output.
3. Warranty and terms-of-service. NVIDIA could reasonably argue this violates their EULA. It's not illegal, and it doesn't modify the VBIOS, but it does alter the card's operating parameters in a way NVIDIA didn't intend. If you RMA a card, unlock it back first.
4. Laptops are flaky. If your laptop powers the dGPU down when idle (most do), that power-off silently resets the unlock. You can sometimes fix it with NVreg_DynamicPowerManagement=0x00, but expect mixed results.
5. It only helps if you're compute-bound. If your bottleneck is VRAM capacity or memory bandwidth — which describes most homelab llama.cpp setups — you will see little or nothing. Don't unlock a 3060 running Q4_K_M models and expect magic.
My honest take: the risk is modest and the reward is real, but it's an enthusiast move, not a production-homelab move. Do it on a dedicated inference box or a spare card first. Don't do it on the machine that runs your Home Assistant or your router.
How to Install (The Short Version)
This is Linux-only. Windows has an unofficial port (Windows-GPU-UNLOCK), but be very careful with third-party Windows installers — the maintainer explicitly warns against them.
git clone https://github.com/Zagitta/gpu-unlock
cd gpu-unlock
make install # detects your distro and packages it
Then opt in on the kernel command line. The exact method depends on your bootloader:
- GRUB (Debian/Ubuntu/Mint/Arch): add
gpu_unlock.targets=allinsideGRUB_CMDLINE_LINUX_DEFAULTin/etc/default/grub, thensudo update-grub(orgrub-mkconfig -o /boot/grub/grub.cfgon Arch). - Fedora/RHEL:
sudo grubby --update-kernel=ALL --args="gpu_unlock.targets=all". - systemd-boot: append it to the
optionsline in your boot entry (bootctl statusshows where). - UKI: add it to
/etc/kernel/cmdlineand regenerate (sudo mkinitcpio -P).
Reboot, then verify it actually worked:
journalctl -k -b | grep gpu_unlock
If you want to turn it off, just remove gpu_unlock.targets= from the kernel command line — or delete it in the bootloader's one-off edit screen. It's fully reversible.
For the RTX 4090 / Ada fork, the flow is the same, but each experimental card ID requires its own opt-in flag (and targets=all will not select experimental Ada parts — you must name them by PCI address). Read QUICKSTART.md in the repo carefully before touching a 4090.
Should You Do It? A Decision Table
| Your setup | Verdict |
|---|---|
| RTX 4090/4080/3090 running FP16/BF16 inference (vLLM, PyTorch, Transformers) | Yes — this is the ideal case. 25–55% faster prefill. |
| Fine-tuning or LoRA training on a GeForce card | Yes — 25–50% faster epochs, real money saved on time. |
| ComfyUI / SDXL / diffusion on a 30/40-series card | Yes — 30–55% faster image generation. |
| llama.cpp / Ollama with quantized GGUF models | Maybe — expect 0–15% and only at long context. |
| Token generation / chat latency (memory-bound) | No — decode is unchanged. |
| RTX 50-series (Blackwell) | No — not supported, unlikely to be. |
| Production homelab / single machine that runs everything | Not yet — wait for the code to mature, or use a dedicated box. |
The Bigger Picture
Here's what actually fascinates me about this moment, beyond the benchmarks.
For years, the "consumer GPUs for AI" story has been constraint: not enough VRAM, not enough bandwidth, locked-down features, a driver stack designed to push you toward the cloud or the datacenter card. The community's response has always been to work within those walls — smaller quantizations, offloading, clever sharding.
gpu-unlock is the first time the community has looked at the wall and simply removed it. And the fact that it exploded to 17k+ stars across two repos in two weeks tells you exactly how much pent-up demand there was for that. It's the difference between "make do with what NVIDIA gives you" and "the silicon was always yours."
That's a meaningful shift for the whole self-hosted AI movement. It won't turn a 3060 into a 4090, and it won't make a 24GB card run a 70B model. But for the specific, common, expensive case of FP16/BF16 compute — training, diffusion, unquantized serving — it's a genuinely free 25–50% that NVIDIA was holding back.
Whether that's a license violation, a warranty risk, or a gift is between you and your hardware. But it's worth knowing it exists, and it's worth knowing exactly what it does and doesn't buy you before you reach for make install.
Running this on your own card? I'd love real-world numbers from homelab workloads — especially the cases the maintainers flag as uncertain, like quantized MoE serving and long-context llama.cpp. The source for this post is on GitHub; PRs and benchmark reports welcome.
Related Posts
- Local LLMs for Homelab: Which Model Runs Best on Your Hardware — match your model and quant to your actual VRAM before you chase speed
- Local LLMs on the Mac Mini: A Practical Guide — unified memory, no unlock required
- LocalAI vs Ollama in 2026 — pick the right inference backend for your stack