What gpu-unlock unlocks on GeForce RTX 30 and 40 cards and how much AI speed you gain

gpu-unlock is a Linux kernel module that lets a GeForce RTX 30 card multiply matrices in FP16 and BF16 with FP32 accumulation at the same rate as its professional sibling. NVIDIA has documented that cap in its own whitepapers since 2020, and Zagitta’s project lifts it before the official driver loads, without patching the driver. A fork, gpu-unlock-ada, brings the same idea to the RTX 4090. This article covers what the cap is, how the module gets around it, what the two READMEs report against the official spec sheets, what a local LLM actually gains and which risks you take on. We have not run it on a card of our own: the figures come from the authors and their community, checked against NVIDIA’s documents on 25 October 2026. There is also a Spanish version of this article.

Key takeaways

• NVIDIA’s GeForce cards run FP16 with FP32 accumulation, and BF16, at half the rate of FP16 with FP16 accumulation. An RTX 3090 does 142 TFLOPS in the first mode and 71 in the second; the RTX A6000, built on the same GA102 chip, does 154.8 in both.
• gpu-unlock loads from the initramfs, runs NVIDIA firmware, writes two speed-select registers and resets the card before the official driver binds to it.
• On an RTX 3090 Ti running an 8192³ matrix multiplication at 450 W, BF16 goes from 87.50 to 157.41 TFLOPS, TF32 from 42.58 to 82.61 and FP16 from 87.46 to 118.39.
• On an unlocked RTX 4090, the FP16 instruction rate reaches 331.6 TFLOPS, the figure NVIDIA publishes for FP16 with FP16 accumulation (330.3). In real cuBLAS work the gain drops to between 12% and 34%.
• In a local LLM the prefill improves (by 14% to 36% across reports), not token generation, which depends on memory bandwidth.

What cap do GeForce cards have on FP16 and BF16

NVIDIA reserves the full tensor core rate for its professional cards when the input is FP16 or BF16 and the accumulator is FP32. Tensor cores are the units that multiply blocks of matrices in one cycle, and the accumulator is the register where the partial products are summed. Accumulating in FP32 keeps long sums from losing precision. That makes it the mode used by mixed-precision training and by BF16 inference, and according to the GA102 architecture whitepaper^[1], BF16 only exists with FP32 accumulation.

The tables in that same document show the gap between product lines that share the silicon:

Ada repeats the pattern. The Ada Lovelace whitepaper^[2] gives the RTX 4090 330.3 TFLOPS in FP16 with FP16 accumulation and 165.2 with FP32 accumulation. TF32, the 19-bit format PyTorch uses for FP32 matrix multiplications when you enable it, is halved as well. The cap is not in the silicon: it is product segmentation, and that is why it can be lifted.

How gpu-unlock works without patching the driver

gpu-unlock changes the card’s state before the NVIDIA driver sees it, instead of modifying the driver. The gpu-unlock README^[3] describes it as "neither a UEFI application nor a patched NVIDIA driver" and lays out the sequence:

1. The module starts from the initramfs, before nvidia binds to the card
2. It runs firmware on the GPU generated from the technique of the CMP mining-card unlocker (the V67/PLM chain, which lifts the privilege level masks)
3. It writes two speed selectors: SS0 with 0x88888888, which according to the author selects the full BF16 rate, and SS1 with 0x8
4. It performs a PCIe Function Level Reset (FLR) and lets the official, untouched driver bind to the card

Because the driver does not change, an NVIDIA update does not force you to redo a patch, which was the problem with earlier attempts. In the README’s words, the module "doubles the instruction issuing speed of FP/BF16 FMA into FP32 operations" on the GA102, GA103, GA104 and GA106 chips. The module’s code is GPL-2.0, and the firmware it generates stays under NVIDIA’s license.

The Wccftech story from 24 October^[4] tells a different story. It says the module hands the driver the PCIe device ID of a professional card, and that it works on the GTX 900, GTX 1000 and RTX 20 series. The README says none of that: it only accepts GeForce Ampere IDs, and the mechanism is the speed selectors. If you read the story, keep the numbers and drop the explanation.

How fast is an unlocked RTX 3090 Ti

The headline figure, "nearly 80%", is BF16 on an RTX 3090 Ti. The author measured a dense 8192³ matrix multiplication at 450 W, taking the median of five samples with FP32 accumulation:

BF16 gains 80% and TF32 nearly doubles (+94%), but FP16 stops at 35%, and the README does not explain why. Across the rest of the 30 series, community reports give these BF16 gains:

There are two exceptions. On the 20 GB OEM RTX 3080 Ti (GA102-250) the unlock completes, but BF16 stays at half rate. There are no reports for the GA103 chip.

What about the RTX 4090 and the 40 series

The 40 series has its own fork, JustAResearcher’s gpu-unlock-ada^[5], which adds an AD102 payload taken from TOTORONG’s AD103_win_unlocker project. The RTX 4090 is the main target. The 4090 D, the 4070 Ti SUPER and the 16 GB 4060 Ti are experimental, each tested on one card and gated behind its own parameter.

The number matches a ceiling NVIDIA publishes for another mode. With driver 615.78.08, the 4090 goes from 165.6 to 331.6 TFLOPS in FP16 with FP32 accumulation. NVIDIA’s spec sheet gives 330.3 for FP16 with FP16 accumulation:

The unlock does not create performance: it runs FP32 accumulation at the rate the card already had for FP16 accumulation. A second owner repeated the test at 450 W and got 160.4 versus 320.4. The README itself warns that these are "register-resident issue rates, not application GEMM or inference speedups": with cuBLAS, the real gain was 12% to 34% in FP16, 16% to 20% in BF16 and none with 4096³ matrices.

How much it shows in LLMs, diffusion and inference

The unlock speeds up compute-bound operations and leaves memory-bound ones alone. In a local LLM, the prefill (processing the whole prompt at once) is a large matrix multiplication, and the README’s reports give 14% to 36% more. Wccftech reports 33–36% faster long-context prefill with vLLM and 25% less time to first token.

Token generation, the decode, reads every model weight for each token, and there memory bandwidth rules, which does not change. If your use is a chat with short prompts, you will barely notice anything. If you process long documents, run reranking or serve RAG with contexts of tens of thousands of tokens, you will.

Integer formats and FP8 do not change either. The Ada fork measured INT8 and dp4a unchanged, and an FP8 E4M3 matrix multiplication on the 4070 Ti SUPER went from 59.326 to 59.495 TFLOPS (+0.3%).

If you already serve models quantized with llama.cpp in 4- or 8-bit integers, the unlock gives you little. It shows most in BF16 diffusion image generation, in FlashAttention and in BF16 LoRA fine-tuning. According to the README, the outputs that were compared were bit-identical before and after.

How to install it and check that it works

The install builds the module on your machine with DKMS and adds it to the initramfs. You need your kernel headers and the DKMS toolchain. These are the README’s steps for Debian and Ubuntu with GRUB, checked on 25 October 2026:

git clone https://github.com/Zagitta/gpu-unlock.git
cd gpu-unlock
make install
# Add gpu_unlock.targets=all to GRUB_CMDLINE_LINUX_DEFAULT
sudoedit /etc/default/grub
sudo update-grub
sudo poweroff

make install detects the distribution family (Arch, Debian or Fedora) and builds the package. The build downloads pinned NVIDIA and CachyOS inputs over HTTPS and checks their SHA-256. The gpu_unlock.targets=all parameter enables the module on every supported card; you can swap all for a specific PCI address such as 0000:21:00.0. Power off fully instead of rebooting: the Ada fork requires a cold boot on the first attempt.

On boot, the kernel should log the unlock:

journalctl -k -b | grep gpu_unlock
lspci -nnk | grep -A3 -i nvidia

The first command looks for the gpu_unlock: unlocked line in this boot’s kernel log; the module loading is not enough. The second confirms that the nvidia driver bound to the card afterwards. To measure before and after, this PyTorch script computes the TFLOPS of an 8192³ multiplication in FP16 and BF16:

import time
import torch

n, iters = 8192, 50
for dtype in (torch.float16, torch.bfloat16):
    a = torch.randn(n, n, device="cuda", dtype=dtype)
    b = torch.randn(n, n, device="cuda", dtype=dtype)
    for _ in range(5):
        a @ b
    torch.cuda.synchronize()
    t0 = time.perf_counter()
    for _ in range(iters):
        a @ b
    torch.cuda.synchronize()
    dt = time.perf_counter() - t0
    tflops = 2 * n**3 * iters / dt / 1e12
    print(dtype, round(tflops, 1), "TFLOPS")

The first five multiplications warm up the GPU and do not count. Each multiplication of two n×n matrices is 2n³ operations, and the script divides the total by the measured time. Run it with a normal boot and with the unlock, at the same power limit.

Risks and limits before you install it

gpu-unlock touches the card’s firmware on every boot, and NVIDIA neither supports it nor has said anything about it. The READMEs list these risks:

• Linux only: the Windows port for the RTX 4070 Ti is a single MSI board profile, with no binaries or installer
• Late loading: if nvidia has already bound the card, loading the module afterwards does nothing
• Blank screen: the card’s video output stays blank from the FLR until nvidia-drm takes over
• Suspend: suspend to RAM resets the selectors; the module runs the unlock again on resume (one extra second) and hibernation is not covered
• Hung firmware: if the firmware never stops, the module keeps its DMA buffers and you must power off fully before retrying
• More than one GPU: the Ada fork has not validated multi-card use
• Measurements: nearly every figure is a single run on a single card, sometimes with the desktop open

One risk appears in neither README: the warranty and the terms of the driver license. The module does not modify the driver or flash the BIOS, and powering off returns the card to its factory state. Even so, running NVIDIA firmware in a way NVIDIA does not intend is your call.

Is it worth buying an RTX 3090 for this

Not at this week’s prices. According to another Wccftech story from 24 October^[6], used RTX 3090 cards have gone from about 1,000 dollars to over 2,000 on eBay. There are 3090 Ti listings at 2,650 dollars. At that premium you pay for a gain that, in cuBLAS and in LLMs, is 12% to 36%, not the headline 80%.

If you already own an RTX 30 card or a 4090 and train, fine-tune or generate images in BF16 on Linux, the unlock is a free upgrade worth a test. If your use is a local chat with quantized models, memory is still the limit. In that case you are better off reading which alternatives to NVIDIA exist or how an engine like vLLM compares with llama.cpp.

Frequently asked questions

Does gpu-unlock work on Windows?

No. The module is for the Linux kernel and loads before the driver from the initramfs. An experimental UEFI port was tested on Windows with an MSI RTX 4070 Ti, but it ships no binaries or installer.

Does it improve gaming performance?

There is no evidence that it does. The unlock only affects tensor cores with FP32 accumulation, and games use those tensor cores for DLSS and little else. Nobody has published gaming measurements with the module active.

Do I need to reinstall it when I update the NVIDIA driver?

No, because the module does not modify the driver. You do need to regenerate the initramfs when you update the kernel, which DKMS and the mkinitcpio, initramfs-tools and dracut hooks do on their own.

Conclusion

gpu-unlock does not conjure performance out of nothing. It gives GeForce cards back the FP16 and BF16 tensor rate with FP32 accumulation that NVIDIA already publishes for its professional cards. Instruction rates double, but real applications gain between 12% and 36%, and token generation does not change.

If you have an RTX 30 card or a 4090 on Linux and work in BF16, measure with the script above before and after. Keep a boot entry without the parameter so you can go back.

Sources: [1] NVIDIA, Ampere GA102 architecture whitepaper^[1], [2] NVIDIA, Ada Lovelace architecture whitepaper^[2], [3] Zagitta, gpu-unlock repository^[3], [4] JustAResearcher, gpu-unlock-ada repository^[5], [5] Wccftech, RTX 3090 Ti gets nearly 80% FP16/BF16 boost^[4], [6] Wccftech, RTX 30 and 40 get faster in AI as prices surge^[6].

Sources

1. GA102 architecture whitepaper
2. Ada Lovelace whitepaper
3. gpu-unlock README
4. Wccftech story from 24 October
5. JustAResearcher’s gpu-unlock-ada
6. another Wccftech story from 24 October