An unofficial tool that removes certain compute performance limits on NVIDIA GeForce GPUs has expanded beyond the RTX 30 series to support the RTX 20 and 40 series as well. As of October 26, 2026, implementations and test results for the Turing and Ada Lovelace generations are available on GitHub, and they confirm roughly double the throughput for certain Tensor Core operations. However, this figure comes from measuring the execution speed of specific instructions. Real AI applications do not necessarily speed up by the same factor.
In fact, in tests on an RTX 4090, instruction throughput roughly doubled, but the improvement in matrix multiplication varied widely depending on the data format and matrix size. In some quantized LLM inference tests, performance barely changed. Reports of rising used prices for older GPUs have followed, but a boost in specific compute performance is a separate question from whether a used GPU is worth a high price.
Compute-limit unlock expands to RTX 20 and 40 series, with support varying by GPU
The starting point for this development is the open-source project gpu-unlock, originally released for the RTX 30 series. The tool intervenes during Linux boot, before NVIDIA's standard driver initializes the GPU, and removes a speed limit applied to certain compute instructions. The target is the instruction issue rate of Tensor Core operations that take 16-bit FP16 or BF16 data as input and accumulate results at 32-bit FP32 precision.
The key point is that the input precision (FP16/BF16) differs from the accumulation precision (FP32). What the tool changes is the instruction issue speed on this specific compute path. It does not raise the GPU's overall computing power across the board. It does not increase VRAM capacity or memory bandwidth, nor does it speed up every data format.
gpu-unlock does not require rewriting the GPU's VBIOS or the NVIDIA driver itself. However, it works by embedding a module in the Linux initial RAM disk (initramfs) and intervening in GPU initialization, so it carries risks different from ordinary software settings. Most of the published reports also come from individual users' own testing, and even when a model is listed as supported, there is no guarantee that it will work on every unit of the same product.
turing-unlock ports this approach to the Turing architecture of the RTX 20 series. Its developer confirmed operation on a Dell-made RTX 2080 Ti 22GB (device ID: 10de:1e07) with a TU102 GPU. With NVIDIA driver 575.51.03 and a 250W power limit, the performance of a 2048×2048 matrix multiplication using FP16 input and FP32 accumulation rose from 55.7 TFLOPS to 91.4 TFLOPS, an improvement of about 64%. The number of repetitions and the aggregation method are not specified.
Furthermore, the test used a special RTX 2080 Ti with 22GB of VRAM, so the same result is not guaranteed on a standard 11GB model. The developer states that other GPU and driver combinations have not been tested, and warns that running the Tensor Cores under heavy load could damage the hardware.
For the Ada Lovelace architecture of the RTX 40 series, gpu-unlock-ada has been released. In addition to successful results on the RTX 4090, results were reported for an RTX 4070 Ti SUPER with a 240W power limit. On that GPU, instruction throughput with FP16 input and FP32 accumulation rose from 95.0 TFLOPS to 189.9 TFLOPS, and with BF16 input and FP32 accumulation from 95.0 TFLOPS to 189.7 TFLOPS. Both are nearly double, but they were measured as instruction issue performance using data held in the GPU's registers, and are not figures for real application speed.
Supported targets also include the RTX 4080, the RTX 4070 family, and some laptop GPUs, though many of these remain experimental. Each model may require its own enabling option, and in some cases the GPU's PCI address must be specified explicitly.
Differences between models were also found among laptop RTX 4090s. A Clevo configuration was unlocked successfully but showed no change in performance, while a Lenovo configuration reportedly achieved roughly double the instruction throughput after two cold boots. An implementation for the RTX 4070 Ti on Windows has also been reported, but so far it is limited to successful manual launches on specific configurations. The range of supported GPU generations has certainly widened, but whether it works in practice depends on the individual GPU, VBIOS, driver, and boot environment.
On the RTX 4090, instruction throughput doubles, but matrix multiplication gains top out around 34%
A comparison test using the same RTX 4090 unit examined the performance gains from unlocking in detail. The public test report for gpu-unlock-ada describes measurements taken on October 24, 2026 (UTC). Using Linux 7.2.11-arch1-1, NVIDIA driver 615.78.08, and CUDA 13.4.92, the same RTX 4090 with a 450W power limit was compared before and after unlocking. The GNOME desktop was running during the measurements, and the GPU's clock settings and power management policy were left unchanged.
The test measured two things separately: instruction throughput, meaning how fast specific compute instructions can be executed, and matrix multiplication (GEMM) performance using NVIDIA's cuBLAS library. The results are as follows.
| Measurement | Stock (TFLOPS) | Unlocked (TFLOPS) | Ratio | Aggregation |
|---|---|---|---|---|
| FP16 input / FP32 accumulate instruction | 160.4 | 320.4 | 1.998x | Best of 5 runs |
| BF16 input / FP32 accumulate instruction | 159.7 | 320.2 | 2.005x | Best of 5 runs |
| 4096×4096 FP16 matrix multiplication | 153.234 | 205.956 | 1.344x | Median of 5 runs |
| 4096×4096 BF16 matrix multiplication | 153.418 | 152.720 | 0.995x | Median of 5 runs |
Source: gpu-unlock-ada RTX 4090 test report. Ratios are the unlocked value divided by the stock value, shown to three decimal places. Instruction throughput is the best of five measurements; matrix multiplication is the median of five runs, each timed over 20 operations after 10 warm-up iterations.
The results show that instruction throughput for both FP16-input/FP32-accumulate and BF16-input/FP32-accumulate roughly doubled. However, in 4096×4096 matrix multiplication via cuBLAS, FP16 improved by about 34% while BF16 barely changed. In other words, even if the GPU can issue a particular instruction faster, the actual library does not necessarily make full use of that capability.
This difference matters when considering AI workload performance. Matrix multiplication speed is determined not only by instruction issue rate but also by data format, matrix size, and the implementation of the kernel used. Indeed, the same test showed an improvement of about 19% for 1024-square matrices, and about 12% for FP16 and 16% for BF16 at 8192-square, so the effect also varied with matrix size.
This measurement is also a single before-and-after comparison on one GPU, and does not guarantee long-term stability or benefits across a broad range of AI applications. The test did pass numerical accuracy checks, but only for the compute paths that were verified. A doubling of instruction throughput cannot simply be read as AI processing as a whole becoming twice as fast.
Some quantized LLM tests show almost no change
For workloads closer to real AI applications, the differences become even clearer. gpu-unlock-ada also includes another test report comparing inference performance of a quantized Mixture of Experts (MoE) model on an RTX 4090 with VRAM expanded to 48GB.
The test used a modified RTX 4090 sold in the Chinese market. In an environment with Ubuntu 26.04.1, NVIDIA driver 610.57.04, and a 450W power limit, it compared performance before and after unlocking. Instruction throughput rose from 164.9 TFLOPS to 328.9 TFLOPS for FP16 input with FP32 accumulation, and from 164.8 TFLOPS to 328.7 TFLOPS for BF16 input with FP32 accumulation, in both cases roughly doubling.
However, the results of running the quantized MoE model were very different. When processing 8K and 32K tokens of input, the difference stayed within 1–2% of stock performance, and no practical speedup was confirmed. Measurements during output token generation also varied widely, and no clear improvement from unlocking was observed.
The compute structure of the model being run is a factor here. In this quantized MoE model, much of the processing does not use the FP16/BF16-input, FP32-accumulate path targeted by the unlock. Overhead from splitting expert processing between the CPU and GPU also affects performance, so speeding up only specific Tensor Core instructions likely left overall inference speed almost unchanged.
That said, this measurement was not a strictly controlled comparison either. The stock result was measured once on an inference engine that had been running for a long time, while the unlocked result was measured three times on a freshly launched engine, so cache states also differed. A difference of only 1–2% therefore cannot be credited to the unlock. In addition, the 48GB of VRAM used in the test came from physical hardware modification; the unlock tool did not increase capacity.
Other user reports have confirmed some improvement. In a post by Reddit user u/Striking_Luck_886, an RTX 3090 with a 230W power limit running Qwen3.8 27B reportedly saw input processing improve by 22–30% and output token generation by 1–5%. The number of repetitions and statistical error are not given, so the result cannot be generalized, but it illustrates how the effect can differ greatly by processing stage even for the same model.
The developer of gpu-unlock for the RTX 30 series has also compiled multiple user reports and explains that LLM input processing (prefill) improved by 14–36%, while output token generation (decode) and INT8 operations were largely unchanged.
This difference follows from the characteristics of LLM processing. Input processing executes matrix operations on many tokens at once, so Tensor Core compute performance tends to determine speed. In contrast, when generating output tokens one at a time, the bottleneck tends to be the speed of reading model weights and other data from VRAM, that is, memory bandwidth. Because this tool does not increase the GPU's memory bandwidth, faster compute instructions may have almost no effect on output token generation speed.
Therefore, when evaluating the effect for LLM use, input processing speed and output token generation speed must be distinguished. Results also vary with the model's quantization method, the inference engine, and the number of tokens processed. These results also concern a specific compute path for AI workloads and do not support claims such as doubled game frame rates.
Are used prices for older GPUs surging? Listing prices and sold prices are different things
The removal of compute limits has also drawn attention to the used market for older GeForce cards. A Wccftech article dated October 24, 2026 reported that RTX 3090 Ti cards were listed on eBay at nearly $3,000, and that 10GB and 12GB RTX 3080 models had listings of $900–$1,100. The article also includes an example of an RTX 3090 Ti listed at $2,650.
Such prices hint that older GPUs may be getting a second look for AI use. But listing prices must be distinguished from prices at which deals were actually completed. A seller's high asking price does not mean a buyer exists who will pay it.
In fact, the eBay search page for RTX 3090 Ti that Wccftech referenced mixes new and used items and is sorted by combined price and shipping from highest to lowest. It is not filtered to sold items only, so the high listings at the top cannot be taken as representative of the used market as a whole. To gauge actual market prices, one needs to look at the distribution and median of sold prices for completed sales.
No time-series data has been presented either on how actual sold prices changed before and after the unlock tool's release. While a link between rising demand for older GPUs and high asking prices cannot be ruled out, there is no basis for concluding that the tool's release caused a rise in the used market overall. Nor is it appropriate to apply U.S. eBay listings directly to used GPU prices in Japan.
Extending the life of a GeForce you own is different from paying a premium for a used one
This compute-limit unlock gives users who already own a supported GeForce a reason to reconsider the value of continuing to use it. In workloads that make heavy use of Tensor Core operations with FP16/BF16 input and FP32 accumulation in particular, it may deliver a certain performance improvement without additional hardware investment. However, the actual effect depends on the individual GPU, the runtime environment, and the compute characteristics of the application.
The situation is different for those about to buy a used GPU. Buying an expensive RTX 3090 Ti or RTX 4090 does not guarantee a sufficient speedup for the LLM or inference engine you want to run. Even on models with successful unlock examples, results cannot be reproduced on every unit, and one must also consider the effort of modifying the Linux boot environment and the recovery work if something goes wrong. Long-term stability and effects on the hardware have also not been sufficiently verified at this point.
Nor can the test results for the RTX 4090 modified to 48GB be applied as is to a standard 24GB model or to another modified card. Actual processing performance depends greatly not only on the GPU's compute power but also on VRAM capacity, memory bandwidth, and the quantization method of the model used.
What these tests make clear is that the performance limit on specific GeForce Tensor Core instructions can sometimes be lifted, and that the effect varies greatly with the actual workload. Extending support to the RTX 20 and 40 series widens the options for putting older GPUs to work on AI tasks. But to judge their economic value, what matters is not the theoretical instruction throughput but how much processing time is actually saved on the model you use. As information accumulates on reproducibility across supported units, long-term stability, and sold prices in the used market, it should become easier to decide more concretely whether to keep using an older GeForce or upgrade to a newer GPU.