NVIDIA Sells the Same Silicon Twice. A Kernel Module Opens the Lock Before the Driver Loads.

NVIDIA ships GeForce cards with their tensor cores capped at half rate for FP16, BF16 and TF32 math with FP32 accumulation. That is the arithmetic nearly all AI training and unquantized inference runs on. The identical silicon sold as an RTX A-series or professional card runs at full rate.
A project called gpu-unlock removes that cap at boot, before the stock NVIDIA driver binds the card. It reached 17,990 stars in three weeks, which says something about how many people suspected the cap was there.
What the README actually claims
The repository is a Linux kernel module, C, GPL-2.0 for the module and the packaging, created October 18. At boot it writes two speed selectors: SS0 gets `0x88888888`, which selects the full BF16 rate, and SS1 gets the 4-bit value `0x8` for IMLA4. Then it performs an FLR reset, and the unmodified NVIDIA driver loads and binds the card as usual.
The method is narrow by design: no UEFI application, no patched driver, no VBIOS flash. The module sits in the initramfs ahead of `nvidia`, does its work in about a second, and leaves nothing to redo when NVIDIA ships a new driver. The driver is only downloaded during the build, to extract the firmware the unlock depends on, which is why one version gets pinned.
The reported numbers, filed by users in the issue tracker rather than measured by the author alone:
| 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 4080 | 104 TFLOPS | 193 TFLOPS | +87% | | RTX 4090 | 165 TFLOPS | 329 TFLOPS | +100% |
The RTX 4090 line is the interesting one, and the README says so itself: the card runs out of power before it runs out of tensor cores, so large GEMMs at stock power limits gain much less than that peak rate suggests. A hundred percent on paper turns into something closer to a third in practice.

Real workloads are where the honesty continues. LLM prefill and prompt processing in FP16/BF16 or AWQ/GPTQ gains 25 to 55 percent, time to first token drops 25 to 30 percent, LoRA and full fine-tuning in BF16 gain 25 to 50 percent, image generation in FP16/BF16 across SDXL, SD 1.5, Krea and DiT models in ComfyUI gains 30 to 55 percent, video generation in BF16 gains 15 to 20 percent on Wan 2.2, and FlashAttention kernels gain 50 to 60 percent.
Then the column nobody puts in a launch post: quantized GGUF through llama.cpp or Ollama gains 0 to 15 percent, mostly at long context. LLM decode gains nothing, because it is memory bound. INT8, FP8 and INT4 models gain nothing. Gaming and FP32 CUDA gain nothing.
Bit-identical is the claim that matters
Buried in the middle of the README is one sentence: outputs are bit-identical before and after, only the speed changes.
That single line moves the project out of the overclocking category. Overclocking changes results when it is unstable, and stability is a coin flip you repeat every session. This changes a rate limit, and the arithmetic that comes out is the same arithmetic. If the sentence holds, a training run does not need to be re-validated, a benchmark does not need a footnote, and a fine-tune does not drift because the hardware multiplied differently.
It also explains the licensing posture. The kernel module and packaging are GPL-2.0-only, and the README points at `firmware/NOTICE.md` for the generated buffer, which derives from a pinned CMP reference. NVIDIA firmware stays under NVIDIA's own terms. The project is not pretending it owns what it is redistributing.
Install, and the part where you should slow down
The install is three lines for anyone who has compiled a kernel module:
git clone https://github.com/Zagitta/gpu-unlock
cd gpu-unlock
make install
Then `gpu_unlock.targets=all` goes on the kernel command line. `make install` reads `/etc/os-release` and picks an installer for Arch, Debian/Ubuntu or Fedora/RHEL. There are explicit targets for each if detection guesses wrong. GRUB users edit `GRUB_CMDLINE_LINUX_DEFAULT` and run `update-grub`; Fedora users run `grubby --update-kernel=ALL --args="gpu_unlock.targets=all"`; systemd-boot users append to the `options` line.
The opt-in matters. Without the kernel parameter the module does nothing. You can pass a comma-separated list of PCI addresses instead of `all`, using the names `lspci -D` prints, so a machine with a display card and a compute card can unlock only the second one. Unsupported cards are logged and ignored, and an `all` mixed with explicit addresses is rejected rather than half-applied.
Laptops are the honest casualty. The unlock only survives if the discrete GPU never fully powers off, and many laptops power it down when idle, silently resetting the selector. The README suggests `NVreg_DynamicPowerManagement=0x00` in `/etc/modprobe.d/`, then admits to expect mixed results.
Support is graded, not uniform. Ampere (RTX 30) is stable with more than a hundred user reports. Ada (RTX 40) and Turing (RTX 20) are experimental. Blackwell (RTX 50) is not supported and the author says it is unlikely to happen. Windows is not maintained, and the README recommends being very careful with the installers floating around for it.
Why this exists, in the author's own framing
The FAQ answers "why did NVIDIA handicap my GPU" with one sentence: market segmentation, they want businesses to purchase the professional cards without these limitations at significantly higher prices.
That is the argument, and the omissions are deliberate. It does not claim the crippled cards are unusable, or that the professional markup is fraud, or that unlocking produces different images. It claims two products are the same product with a rate limit, and the limit is enforced in firmware rather than in the die.
Whether that holds up legally is a different question from whether it holds up technically. The module is GPL-2.0, and GPL covers the module, not the act of running it against firmware you bought. The interesting exposure is warranty and, for anyone running this in a paid cluster, whatever the operator's terms say about unsupported configurations.
The supply chain problem nobody asked for
Halfway down the FAQ there is a question about a website, a coin and an installer. The answer is a flat no: this is the one and only original source, and crypto, websites and installers are not associated with the project in any way. The README also carries three wallet addresses for donations, which is a strange place to find a warning about crypto and a strange place to find crypto.
The shape of this project is now familiar. A utility that unlocks hardware capability, a large audience that wants it, no distribution channel, and a README that has to defend itself against impersonators. For anyone with a fleet of 3090s and a training budget, the risk sits elsewhere: the person who needs the module most is the least likely to read the FAQ before running a `curl | bash` from a lookalike domain.
What to take from it
The gain is real but narrow. If your workload is BF16 matrix math, you get most of the advertised speedup, with image generation and fine-tuning at the top of the range. If your workload is quantized inference, you get almost nothing, and the README says so before you install anything.
The honest framing is that this is a hardware segmentation unlock with a measured, workload-dependent payoff, published with its own failure cases attached. For a project with 18,000 stars and a strong incentive to overstate, the README spends an unusual amount of space telling you when not to bother.
Related articles
Chinese text in video always turns to mush. Dreamina handed the typesetting to code
Dreamina launched Motion Studio on November 10. It no longer generates frames; the model writes code that lays out text, shapes and pacing. Chinese titles stop blurring, but whether the content is right is still on you.
A community spreadsheet of taps that turns off the ads inside Chinese Android builds
A no-root tool that switches off the ads Chinese phone makers ship inside the system UI. Its method is a hand-written tap script per phone model, maintained by volunteers every time a ROM moves. It works, and the maintenance is the point.
GPT Image 2.6 held the token price and raised the bill
GPT Image 2.6 kept every token rate from 2.5 and still costs more per image, because more of the work now happens in output tokens. Eleven days into the ramp, the pricing structure says more than the leaderboard does.
Someone rebuilt IDM from the outside and wrote down what they did not touch
A Rust reimplementation of Internet Download Manager claims 5x the speed and 86 languages. The more interesting document is the paragraph explaining how it was built without copying anything.