Open-source projects unlock hidden NVIDIA GPU throughput, with RTX 4090 tests showing a near 2x jump

Open-source projects unlock hidden NVIDIA GPU throughput, with RTX 4090 tests showing a near 2x jump

N
News Editor
2026-10-26 03:55:24
A set of open-source experiments on GitHub is drawing attention across the GPU and AI developer community after showing that some NVIDIA GeForce cards can deliver much higher throughput on specific Tensor Core workloads without changing hardware, flashing the BIOS, or patching the official driver. The most widely discussed result came from an RTX 4090, where FP16 or BF16 input with FP32 accumulation rose from roughly 165 TFLOPS to about 331 TFLOPS in low-level tests. Similar gains were later reported on several RTX 30-series cards and on RTX 2080 Ti systems based on the older Turing architecture. The work does not suggest that every workload doubles in speed. Public results show that the gains are concentrated in specific mixed-precision Tensor Core instruction paths that appear to have been rate-limited. Matrix multiplication benchmarks using cuBLAS improved by smaller margins, and some real AI workloads saw partial acceleration rather than a blanket 2x increase. Linux has been the main testing ground so far, though an experimental Windows 11 result has also been published. Compatibility across more cards, drivers, and firmware versions remains unproven at this stage.

Open-source developers are probing low-level compute limits inside NVIDIA GPUs, and the public test data now points to a striking result: some GeForce cards can run specific Tensor Core mixed-precision paths at much higher throughput without any hardware swap, BIOS flashing, or modification to the official NVIDIA driver. In the most visible case, an RTX 4090 moved from 165.6 TFLOPS to 331.6 TFLOPS on a targeted Tensor Core workload.

Open-source projects unlock hidden NVIDIA GPU throughput, with RTX 4090 tests showing a near 2x jump 2

The effect is not limited to one card. Community tests cited in the published research also showed sizable gains on the RTX 3090 Ti, RTX 4070 Ti SUPER, and even the RTX 2080 Ti released in 2018. Projects covering the RTX 20, 30, and 40 series are now available on GitHub, and some developers have also reported experimental work under Windows 11.

RTX 4090 results drew the most attention

The headline result came from JustAResearcher, whose open-source project gpu-unlock-ada published before-and-after measurements for the RTX 4090. The repository collected 2.7k stars within two days.

Project link: https://github.com/JustAResearcher/gpu-unlock-ada

In Tensor Core operations using FP16 input with FP32 accumulation, throughput rose from 165.6 TFLOPS to 331.6 TFLOPS. In BF16 input with FP32 accumulation, the figure moved from 165.5 TFLOPS to 330.6 TFLOPS. Both results were close to a full doubling.

To rule out a one-off result, the developer increased the test loop count from 20,000 to 40,000. The longer run produced 330.8 TFLOPS for FP16/FP32 and 330.3 TFLOPS for BF16/FP32, closely matching the earlier measurements.

No hardware was changed during the experiment. The setup did not rely on a higher power limit, manual overclocking, or a patched NVIDIA driver. According to the technical report, the tested card used an AD102 chip with 128 SMs, ran Linux kernel 7.2.4, and kept the power limit at 450W. The developer used the GPU firmware execution flow during startup to enable writes to protected registers, then changed the register settings that control compute rate.

Open-source projects unlock hidden NVIDIA GPU throughput, with RTX 4090 tests showing a near 2x jump 3

After that, the card went through a PCIe Function Level Reset, or FLR, and an unmodified NVIDIA 615.78.08 driver took over normally. Register checks after driver initialization and CUDA testing showed that the unlocked configuration remained active. The published explanation is that the RTX 4090 had a rate limit removed for certain Tensor Core modes, allowing FP16 or BF16 input with FP32 accumulation to run at higher throughput.

That change did not apply to every compute type. FP16 input with FP16 accumulation was already at 325.7 TFLOPS before the unlock and reached 331.6 TFLOPS in a longer-loop test afterward, which is not the same kind of jump. INT8 throughput stayed around 661 TOPS, and standard FP32 scalar throughput remained near 79.1 TFLOPS. The result points to a narrower effect: specific Tensor Core paths that had been rate-limited, not a blanket doubling of the card’s total compute capability.

A second RTX 4090 owner later carried out an independent retest using reviewed project code. That setup used Linux kernel 7.2.11-arch1-1 and the same NVIDIA 615.78.08 driver. With the same card, the same benchmark program, and the same 450W power cap, FP16 input with FP32 accumulation increased from 160.4 TFLOPS to 320.4 TFLOPS, while BF16 input with FP32 accumulation rose from 159.7 TFLOPS to 320.2 TFLOPS. Both were again close to 2x.

Retest link: https://github.com/JustAResearcher/gpu-unlock-ada/blob/main/docs/evidence/rtx4090-pr1-matched/README.md

The picture changed once testing moved from low-level instruction throughput to actual matrix multiplication. In cuBLAS matrix multiplication benchmarks, FP16 throughput improved by about 12% to 34%, depending on matrix size. For a 4096×4096 matrix multiply, throughput increased from 153.2 TFLOPS to 206.0 TFLOPS, a gain of about 34.4%. BF16 results varied more. The 1024×1024 and 8192×8192 tests improved by about 19.6% and 16.0%, while the 4096×4096 BF16 test showed little change.

The published explanation is straightforward. Low-level instruction tests minimize the effect of memory access and other bottlenecks, while real matrix multiplication also depends on data movement, scheduling, and efficiency at different problem sizes. The independent retest supports the claim that specific RTX 4090 Tensor Core instruction paths can nearly double in throughput, but that does not mean AI training or inference speed will also double in practice.

Open-source projects unlock hidden NVIDIA GPU throughput, with RTX 4090 tests showing a near 2x jump 4

RTX 30-series cards also posted large gains

The RTX 30-series work came from Zagitta’s open-source project gpu-unlock, which has reported successful results across several Ampere-based cards.

Project link: https://github.com/Zagitta/gpu-unlock

The RTX 3090 Ti stood out. At a 450W power limit, BF16 matrix throughput increased from 87.5 TFLOPS to 157.4 TFLOPS, close to an 80% gain. TF32 improved by 94%.

Results were also reported for the RTX 3080, RTX 3070, and RTX 3060. On the RTX 3080 10GB, BF16 throughput rose from 65.4 TFLOPS to 113.4 TFLOPS, about 73%. The cited tests for the RTX 3070 and RTX 3060 showed gains of about 81% and 76%.

Like the RTX 4090 method, gpu-unlock uses the GPU firmware execution flow during startup to alter register settings that control Tensor Core instruction issue rate. The project says NVIDIA GPUs contain internal registers, including SS0 and SS1, that govern the execution rate of different instructions. Those registers are protected and cannot be modified directly by a normal driver.

Zagitta adapted V67 techniques from an earlier CMP unlock effort. According to the published description, the method uses a vulnerability in the GPU secure boot firmware and return-oriented programming, or ROP, to change the Privilege Level Mask, or PLM, and gain write access to the relevant registers. The program then sets SS0 to 0*88888888 and SS1 to 0*8, switching the targeted compute path to a higher instruction issue rate.

Open-source projects unlock hidden NVIDIA GPU throughput, with RTX 4090 tests showing a near 2x jump 5

Rather than patching the NVIDIA driver, Zagitta integrated the process into a Linux kernel module. At boot, the module runs before the official driver takes control of the card, applies the register changes, and then triggers a PCIe FLR so the configuration takes effect. After that, the unmodified NVIDIA driver loads normally. The project says this allows some Ampere cards to reach twice the original instruction issue rate for FP16 or BF16 input with FP32 accumulation.

As the technique spread, more users submitted independent test results. One developer using an RTX 3080 10GB ran additional tests at a 320W power limit. BF16 throughput improved by about 73%, and FP16 input with FP32 accumulation in matrix operations rose from 64.88 TFLOPS to 110.14 TFLOPS, about 70%.

In a 120-second alternating FP16 and BF16 matrix workload, the card completed 6,940 operations before the unlock and 11,860 after it, for an average throughput gain of about 71%. Power draw stayed near 318W in both runs, and peak temperature was 78°C and 79°C.

The tests also checked output correctness. In FP16, BF16, and TF32 matrix operations, the outputs before and after the unlock were identical. Again, not every workload improved. FP16 input with FP16 accumulation, which already ran at a higher rate, stayed near 112 TFLOPS. INT8 and standard FP32 workloads changed little.

Some real AI tasks also sped up. One RTX 3090 user running a 27B BF16 model with vLLM reported that prompt prefilling improved by about 33%, while time to first token fell by about 24%. Another developer using two memory-expanded RTX 3080 cards reported gains of about 33% to 36% in large-model prefilling tests.

Token-by-token generation speed, however, did not change much in either experiment. The explanation given in the published material is that prefilling depends heavily on matrix computation, while per-token generation is often constrained more by memory bandwidth.

Turing-based RTX 2080 Ti systems were tested too

The older RTX 20 series produced another notable set of results. Developer nlzy ported related gpu-unlock techniques to NVIDIA’s Turing architecture and released the turing-unlock project on GitHub.

Open-source projects unlock hidden NVIDIA GPU throughput, with RTX 4090 tests showing a near 2x jump 6

Project link: https://github.com/nlzy/turing-unlock

The tested card was a Dell RTX 2080 Ti with a non-standard 22GB memory configuration. A retail RTX 2080 Ti normally has 11GB, so this hardware differs from a standard consumer card. At a 250W power setting, the developer used cuBLAS to run FP16 input with FP32 accumulation matrix multiplication. When M, N, and K were all 2048, throughput increased from 55.7 TFLOPS before the unlock to 91.4 TFLOPS after it, a gain of about 64.1%.

Other matrix sizes also improved:

  • 1024: from 50.3 TFLOPS to 68.3 TFLOPS, about 35.8%.
  • 4096: from 53.7 TFLOPS to 81.7 TFLOPS, about 52.1%.
  • 8192: from 52.8 TFLOPS to 77.9 TFLOPS, about 47.5%.

For comparison, NVIDIA’s Turing architecture white paper lists 56.9 TFLOPS as the peak FP16 Tensor Core throughput for the RTX 2080 Ti. Using that figure, the 2048-size test reached 97.9% of the rated peak before the unlock and 160.6% after it. The published interpretation is that the original rate configuration was limiting this compute path, and that changing the configuration let the existing Tensor Cores execute more work in that mode.

A similar result appeared in another developer’s work. GitHub user haohervchb published a separate Turing-unlock research project and tested an ASUS RTX 2080 Ti. That card used a TU102 chip with 68 SMs and the standard 11GB memory capacity. Unlike nlzy’s Linux kernel module approach, this project used a UEFI execution path before the operating system loaded, changing the GPU configuration before booting into the OS.

Project link: https://github.com/haohervchb/Turing-unlock

Open-source projects unlock hidden NVIDIA GPU throughput, with RTX 4090 tests showing a near 2x jump 7

In low-level MMA, or matrix multiply-accumulate, instruction testing with FP16 input and FP32 accumulation, throughput rose from 46.94 TFLOPS to 93.66 TFLOPS, nearly doubling. Measured as floating-point operations per SM per clock, performance increased from about 511.7 FLOP/SM/clock to 1022.4 FLOP/SM/clock.

When the benchmark switched to actual cuBLAS matrix multiplication, the gain narrowed. In an 8192×8192 GEMM test, throughput increased from 48.15 TFLOPS to 85.17 TFLOPS, about 76.9%. That is below the near-2x result seen in the low-level instruction test, but still a substantial increase for a card first released in 2018.

Both Turing studies remain limited in scope. The current evidence only shows that some TU102 cards can raise throughput on specific Tensor Core operations by changing rate configuration. Whether other RTX 20-series models can use the same method, and how well it works across different drivers and firmware versions, still needs more verification. The same applies to AI training, inference, and gaming performance, which cannot be inferred directly from these benchmark numbers.

Experimental Windows 11 work has also surfaced

Most of the published work so far has focused on Linux, but an experimental Windows result has also been posted. Developer TOTORONG published AD103_win_unlocker on Hugging Face and described a method for changing GPU compute configuration under Windows 11.

Project link: https://huggingface.co/TOTORONG/AD103_win_unlocker/blob/main/docs/INSTALL.en.md

The test system used a memory-expanded 32GB RTX 4080 based on the AD103 GPU. Unlike the Linux kernel module approach, this method uses a UEFI program to apply the configuration changes before Windows starts, then hands control back to the operating system.

Open-source projects unlock hidden NVIDIA GPU throughput, with RTX 4090 tests showing a near 2x jump 8

The published benchmark results showed that, at matrix size 4096, FP16/FP32 throughput increased from 91.54 TFLOPS to 182.80 TFLOPS, while BF16/FP32 rose from 91.91 TFLOPS to 184.49 TFLOPS. Both were close to a full doubling. That suggests the underlying configuration change is not limited to Linux.

Even so, the Windows 11 result came from a specific modified card. It does not establish broad compatibility for a standard RTX 4080 or for the RTX 40 series as a whole.

What the public evidence shows so far

Across the published projects, the common thread is clear. Developers are changing protected register settings during GPU startup so that some Tensor Core instruction paths can issue at a higher rate than before. Public results now span Ada, Ampere, and Turing architectures, and in the Linux-based methods the stock NVIDIA driver can still run afterward.

The limits are just as clear. The current evidence supports higher low-level throughput on specific mixed-precision paths for some GeForce cards. It does not establish universal compatibility across models, drivers, or firmware versions, and it does not show that AI training, inference, or gaming performance will scale in the same way.

Reference link: https://x.com/Pirat_Nation/status/2114297495815704697

This article was sourced from the WeChat public account "机器之心" (ID: almosthuman2014), by the author listed as "关注开源的".

This article was originally published by Bit.Fan. For more cryptocurrency news and market insights, visit www.bit.fan.
12300

Disclaimer:

The market information, project data, and third-party content displayed on this platform are for industry information sharing only and do not constitute any form of investment advice or return commitment.

Cryptocurrency trading carries high risks. Users should fully assess their risk tolerance and make independent decisions. All profits, losses, and legal responsibilities are borne by the users themselves.