gpu-unlock-ada and the Millisecond Before the Driver Loads
A Linux kernel module flips a firmware permission bit on Ada GPUs before NVIDIA's driver can claim the card, and then publishes the numbers it cannot hit.
- githuba.unlock-ada is a boot-order exploit, not a driver patch: it flips a firmware permission bit in the initramfs window before nvidia.ko binds the card.
- The lock is a speed-select bit in BAR0 that caps tensor-core instruction issue, not memory bandwidth or clocks, so the unlock changes how often the tensor cores accept work.
- A separate read-only diagnostic module proves the register changed without a driver or a benchmark, which is the project's most elegant design decision.
- The project publishes its negative results, including unchanged INT4, unchanged FP8 GEMM, and one physical AD103 card, and that restraint is rarer than the unlock itself.
The Millisecond Before the Driver Loads
The machine powers on. Firmware runs. The bootloader hands off. The initramfs unpacks into memory. And in that narrow slice of the boot sequence, a small kernel module loads, reaches into the GPU's BAR0 register space, and flips one permission bit.
Then nvidia.ko binds the device, and the window slams shut.
That ordering is the entire project. JustAResearcher/gpu-unlock-ada is not a driver patch, a userspace tool, or a firmware flash. It is a kernel module that does one thing at one instant and then gets out of the way.
The lock is a firmware permission bit. Once the driver claims the card, it owns the device state and re-asserts the locked value. You have to get there first, and you have to be gone before the driver shows up.
Miss the window and you wait for the next boot. There is no second chance from a running system.
The module also does nothing unless gpu_unlock.targets= is on the kernel command line. That opt-in gate is a safety, not a feature flag. Remove the parameter and the system boots stock. A user has to choose the unlock, per card, every boot.
What Is Actually Locked
The README calls the target the "SM speed-select override." Concretely, NVIDIA's consumer Ada cards ship with an SM speed-select permission set to a value that caps certain tensor-core issue paths.
The bit governs instruction issue rate for tensor operations. It does not govern memory bandwidth. It does not govern clocks. It does not make the silicon faster.
What it changes is how often the tensor cores are allowed to accept new work. Think of it as a rate limiter on the issue port, not a throttle on the engine. The distinction matters every time a number appears later in this article.
The bit lives in BAR0, in a register cluster the diagnostic module calls the speed-select cluster. Flipping it is a small write. Finding it, and reaching it before the driver does, is the hard part.
A Compass That Only Reads
The project ships diagnostics/peek/gpu_peek.c, a separate kernel module that does nothing but read. No writes to config space. No writes to BAR space. No firmware execution. No resets. No device enablement.
A module that is provably incapable of changing anything is a strange thing to build on purpose. It gives you a before and after on the register state with no driver and no benchmark in the loop.
The module expands its output through parameters. target= selects one card. cluster=1 adds the 31-word speed-select cluster. permissions=1 adds the AD102 permission targets. Every parameter is read-only at load time, so nothing can be changed through sysfs after the fact.
The register map is self-describing. Each entry carries a human-readable name, so an unlock gets a before and after that needs no driver and no benchmark.
/* Self-describing register map: an unlock has a before/after
that needs no driver and no benchmark. */
static const struct cluster_reg cluster_regs[] = {
{ "FEAT_READOUT_1 (SS effective)", 0x..., 4 },
{ "FEAT_OVR_SM_SPEED_SELECT", 0x..., 4 },
/* ... 31 words total ... */
};
The diagnostic includes the module's own vbios_610.c directly rather than linking against a library. The two files can never disagree about an offset. That coupling is the tradeoff, and for a register map it is the right one.
That naming choice is the point. It separates "what state is the hardware in?" from "what throughput does it deliver?" The first question has a cheap, exact answer. The second does not.
How You Prove It Worked
The benchmarks live in diagnostics/bench. mma_bench.cu measures instruction issue rates across FP16, BF16, INT8, FP8, dp4a, and scalar fma.
Three details make the numbers trustworthy. Every kernel ends with a comparison that cannot be true in practice, so the optimizer cannot delete the loop.
/* The loop cannot be deleted: the store only fires if the
comparison succeeds, and it never should. */
if (carry == (Acc)0x7fffffff)
sink[threadIdx.x] = 1.0f;
The chain counts are tuned per unit: 8 independent accumulator chains for tensor operations, 32 for scalar units, because the scalar units are latency-bound. The grid is fixed at 1056 blocks so runs stay comparable.
Each mode runs multiple times and the best result is reported. The header tells you to record clocks and power alongside each invocation, because sustained tensor load moves both. That instruction is the difference between a benchmark and a marketing number.
Correctness is checked separately, in validate_gemm.cu. cuBLAS runs with deterministic seed inputs and is compared against a CPU reference quantized to the same values the GPU sees. The test sizes include 127x65x95, which is not a multiple of any tile size. The program refuses to run outside sm_86 and sm_89.
The stated purpose is "a correctness check, not a throughput benchmark." That separation is deliberate. The claim that an unlock does not corrupt results rests on this check passing.
The Numbers They Refuse to Claim
Here is where the project gets interesting.
The release notes report a 1.99x TF32 instruction-issue rate result in a register-resident probe on one RTX 4070 Ti SUPER. In the same release, unsigned INT4 does not improve. A prior release reports effectively unchanged results for a tested FP8 GEMM and an INT8 workload.
The release documentation draws the line explicitly.
These all-one, register-resident loops do not establish an application GEMM or inference speedup.
A project that reports its losses is rare in a genre defined by hype. The negative results are the reason the positive ones are worth reading.
- Reported: 1.99x TF32 instruction-issue rate in a register-resident probe on one RTX 4070 Ti SUPER.
- Reported: effectively unchanged unsigned INT4 result in the same release.
- Reported: effectively unchanged FP8 GEMM result in a prior release.
- Disclaimed: register-resident rates are not application GEMM or inference speedups.
The Fork Lineage
The project is an Ada fork. It retains the Ampere device list from Zagitta's gpu-unlock and adds AD102 support plus an experimental AD103 path. A separate project, nlzy's turing-unlock, covers RTX 20-series cards with its own module and its own command-line option.
That's a fork of GP's work.
| Project | Cards targeted | Module | Notes |
|---|---|---|---|
| JustAResearcher/gpu-unlock-ada | Ampere (retained) + AD102/4090 + experimental AD103/4070 Ti SUPER | gpu_unlock | Locally generated firmware from pinned NVIDIA inputs; opt-in via gpu_unlock.targets= |
| Zagitta/gpu-unlock | GA102, GA103, GA104, GA106 | gpu_unlock | The Ampere precursor |
| nlzy/turing-unlock | TU102, TU104, TU106 | turing_unlock | Separate module; different cmdline option; high tensor power warning |
The build fetches pinned NVIDIA inputs and generates firmware locally. NVIDIA firmware binaries are never distributed in the repository. That is a licensing decision as much as a technical one.
All three projects build on the target machine. None ships prebuilt binaries. The Ada fork extends the lineage instead of replacing it.
The Edges
The AD103 path is a canary, and the project treats it like one. The report says it ran on a single card, and it says so plainly.
This is one physical card.
The report does not stretch its evidence past the boundary it can defend.
The list of cautions is longer than the list of features.
- AD103 is one physical card and one cold-boot trial.
- targets=all does not select the experimental AD103 card.
- The AD103 path needs the exact PCI address of the card.
- Keep a stock boot entry.
- Validate a cold boot before making an unlocked entry persistent.
- The throughput test was not repeated after a second full AC cycle.
DKMS, three initramfs config files, and a kernel command-line parameter. This is an invasive early-boot operation, not a performance slider.
The honest edge is the ending. The project knows exactly how far its evidence reaches, and it stops there.





