gpu unlock RTX 50 series: newer silicon, a different booter

The gpu-unlock RTX 50 series answer is the project’s own, and it is a no: Blackwell is not in the whitelist, and the FAQ calls support unlikely. What follows is why a boot-time exploit stops at a new die, and what to do if the card is already in your machine.

Three sources, one gpu unlock answer

The supported-GPU table in the README has four rows. Ampere is listed as stable with a hundred-plus user reports behind it, Ada and Turing are experimental, and the Blackwell row has no cards in it at all, only the words Not supported. [official README]

The FAQ is shorter and blunter. Asked about Blackwell, it answers: "Not supported and unlikely to happen." [official README]

The whitelist agrees. cards[] in recipes.c holds 87 PCI device IDs, split 51 Ampere, 17 Ada and 19 Turing. Not one of them is a 50-series board. [official README]

  • Where the answer comes from, in the project's own words.
  • Supported GPUs table

    What it says
    Blackwell row, no cards listed, status Not supported.
  • FAQ

    What it says
    Not supported and unlikely to happen.
  • cards[] in recipes.c

    What it says
    87 device IDs, none from the 50 series.

Worth separating two things here. "Unlikely to happen" is the maintainer's estimate, written in a FAQ, and it is the only forward-looking sentence in the project. Nothing in the repository turns it into a date, a milestone, or a branch. If a page tells you a version number is coming, that page is inventing it. Plan around the answer that exists. For anyone who owns one of these cards, the gpu-unlock RTX 50 series record is that short: not in the list, and not expected to be.

What blocks gpu unlock on Blackwell

Most guesses about why the 50 series is excluded start in the wrong layer. The module does not patch the NVIDIA driver, and there is no modified driver to wait for: the README describes the tool as neither a UEFI application nor a patched driver, and the unmodified driver binds to the card after the unlock. [official README]

What the module actually reaches is the card's boot firmware. The whole technique is one 4-byte write performed from inside the firmware's secure context, used to lift the write protection on the speed registers so the host can set them afterwards.

The write is not generic. recipes.c carries a chain per die: six writes in fixed-size frames for the Ampere parts, and for Ada the same body with the addresses remapped through the firmware map — 0x686 becomes 0x1e02, 0x1110 becomes 0x257e, 0x84c8 becomes 0x7a02, 0x81ee becomes 0x771e. [official README]

  1. origin

    A booter image that can be read

    The Ampere work started from a debug-signed Booter that shipped alongside the production one. Reading it is what makes the rest possible.
  2. payload

    A payload that performs one write

    The v67 payload exists to write four bytes to an address you choose. Everything else in the chain is scaffolding around those four bytes.
  3. recipe

    A per-die address map

    The same write means a different address on each die. Ada worked because the payload body transferred and only the map moved.

    [official README]

  4. where 50 stops

    A booter the vendor has not closed

    A new generation brings a new boot stage. Without a readable one and its address map, there is nothing to port the recipe onto.

That is the honest answer to "why not": not that the author declined, and not that a driver flag is missing. The technique is bound to a specific firmware generation, and the work of extending it is the work of reversing a boot stage first. The project publishes no Blackwell recipe and the FAQ does not describe one in progress, so the gap a gpu-unlock RTX 50 series port would have to close is the boot stage itself.

The power ceiling gpu unlock would still face

Say the port existed tomorrow. The card would still be the limit, and the 4090 is the clearest evidence available.

+100%

Matrix-multiply peak on a 4090

164.9 → 329.6 TFLOPS, the number the headline quotes.

[issue #218]

0–5%

PyTorch matmul, same card

4096 and 8192 sizes, measured end to end.

[issue #218]

The gap between those two numbers is power. The same report scores the card at +1.5% under a 180 W limit and +14% at 340 W on a video workload, which is the unlock being starved rather than failing. [issue #218] High-end boards can still run into a power ceiling, and the arithmetic does not get kinder: the selector sets a rate, the power budget decides whether the rate can be held.

What people try with gpu unlock on RTX 50

Community attempts at Blackwell exist as claims, not as logs. I have not found a reproducible 50-series report in the project's issues — no device ID, no log line, no patch that a reader could apply. Treat any gpu unlock claim for the 50 series as unverified until it survives the same three questions this site uses everywhere.

  • Three questions that separate a report from a claim.
  • Does it name a PCI device ID?

    Why it settles the argument
    The whitelist is keyed by ID. A model name cannot be checked against cards[].
  • Is there an open pull request with the recipe?

    Why it settles the argument
    The whitelist grows through patches. A merged or pending patch is visible; a screenshot is not.
  • Does the boot log show the unlock chain?

    Why it settles the argument
    A working run prints gpu_unlock: unlocked and the handoff line. Without it there was no unlock.

If gpu unlock is not an option for your card

Keep it for what it does well, and do not buy a second one expecting this to arrive. That is a judgement about the evidence above, not a prediction about the vendor, and nothing in the gpu-unlock RTX 50 series record points the other way.

If tensor throughput per dollar is the actual goal, the supported generations are the shortlist. Ampere is the only one the project calls stable, with the hundred-plus reports behind it; Ada is experimental, works on many boards, and runs into the power ceiling shown above. [official README]

What separates them for a buyer is not peak TFLOPS but whether your workload is the kind that gains at all — prefill, fine-tuning and image generation do, token decoding and quantised inference do not.

One more note for anyone who arrived here after a purchase. A 50-series card is not a broken choice; it is a card this project does not touch. The two facts are unrelated, and a page that blurs them is selling something.

Your next gpu unlock step

Check your card against the compatibility table: if its device ID is listed, the generation question does not apply to you. If it is a 50-series board, the table will say so plainly, and the useful next question is what the machine is for rather than how to unlock it.

If you already run a supported card and want the install order, that is the gpu-unlock install page. If a log line is what sent you here, troubleshooting reads the codes one by one.

Checked VERSION 2.0.0commit 1fc6d62