Install guide

The whole install is: build the package, add one kernel command-line parameter, reboot. This guide follows the project's own README, including the parts people usually skim past — verification and rollback.

Based on gpu-unlock README v1.0.0 · Checked 2026-10-25 · Source project

Before you start

Linux only. There is no Windows version of this module. Your card must be a GA102, GA103, GA104 or GA106 model (RTX 30 series) — check yours first. The project is experimental and unofficial; you are modifying how your hardware initialises at boot. Read the rollback section before you begin so you know the way out exists and is simple.

What this guide applies to

Upstream project gpu-unlock v1.0.0, as documented in its README pinned at commit af28cbb (2026-10-24), on the distribution families the README covers (Arch, Debian/Ubuntu, Fedora/RHEL). One honest gap: the README does not document Secure Boot or module-signing behaviour — if your distribution enforces Secure Boot, resolve signing for locally built modules using your distribution's own documentation before you reboot. And a standing disclosure: this site has not performed an install — there is no first-party install log here; these steps are a faithful summary of the upstream README, which remains the authoritative source.

Before you start — the 60-second preflight

Know your card's PCI address — run lspci -D and note it (e.g. 0000:21:00.0). You need it if you target specific cards, and it is how you verify afterwards.
Know how to edit your bootloader entry once, at boot — that is your escape hatch: deleting the parameter in the bootloader's edit screen gives you one stock boot, no surgery required.
Save your current kernel command line (cat /proc/cmdline) somewhere you can reach it offline, so you can restore it exactly.
Multi-GPU? Prefer explicit PCI targets over all — name the cards you mean, leave the rest untouched.
Have console or physical access for the first reboot — the documented failure mode (below) is handled by powering off, not by remote poking.

What you need

A supported card (GA102 / GA103 / GA104 / GA106) — see the compatibility list.
A Linux distribution in the Arch, Debian/Ubuntu or Fedora/RHEL families — make install auto-detects from /etc/os-release. On other distributions, use the explicit build targets below.
The stock, unmodified NVIDIA driver. The whole point of this module is that the driver stays untouched.
sudo access. Building downloads pinned NVIDIA/CachyOS inputs over HTTPS and verifies their SHA-256 hashes; firmware is generated locally in the build directory.

Step 1 — Clone and install

git clone https://github.com/Zagitta/gpu-unlock
cd gpu-unlock
make install

make install detects your distribution and picks the right installer. The explicit variants are:

make install-arch   # makepkg -sif
make install-deb    # apt-get build-dep, dpkg-buildpackage, apt-get install
make install-rpm    # dnf builddep, rpmbuild, dnf install

make arch, make deb and make rpm build packages without installing them (Debian and RPM packages land in build/deb and build/rpm). The install puts the module and its firmware into your initramfs — with mkinitcpio, a drop-in places gpu_unlock immediately before nvidia in MODULES so a display card stays blank for as short a time as possible; initramfs-tools and dracut have equivalent drop-ins. Images are rebuilt on install.

Step 2 — Opt in on the kernel command line

The module is inert until you tell it which cards to unlock. Append gpu_unlock.targets=all to your kernel command line, keeping your existing options:

GRUB (Debian/Ubuntu/Mint): add it inside GRUB_CMDLINE_LINUX_DEFAULT in /etc/default/grub, then run sudo update-grub.
GRUB (Arch/CachyOS): same edit, then run sudo grub-mkconfig -o /boot/grub/grub.cfg.
Fedora/RHEL: run sudo grubby --update-kernel=ALL --args="gpu_unlock.targets=all".
systemd-boot: append it to the options line in your boot entry (bootctl status shows where it lives).
UKI / generated entries: add it to /etc/kernel/cmdline and regenerate your boot images (e.g. sudo mkinitcpio -P for mkinitcpio UKIs).

Instead of all, you can name specific cards by full PCI address, as lspci -D prints them:

gpu_unlock.targets=all                            # every unbound GA102/103/104/106 card
gpu_unlock.targets=0000:21:00.0                   # only this card
gpu_unlock.targets=0000:21:00.0,0000:22:00.0      # comma-separated list

Addresses are independent of GPU numbering and display role. Anything that isn't a GA102/GA103/GA104/GA106 card — including mixing all with addresses — is logged and ignored. Unlocking takes about a second total however many cards you have; each card is handled on its own, and a card that is already bound or powered down is skipped.

Step 3 — Reboot and verify

Reboot, then check the kernel log:

journalctl -k -b | grep gpu_unlock
lspci -nnk -s 0000:21:00.0   # your card's address

Then run your usual FP16/BF16 workload or GEMM benchmark and compare. A few behaviours worth knowing:

The display card works too. Its console framebuffer keeps running during the unlock and is removed just before the reset; the screen is blank from the reset until nvidia-drm takes over — the same thing the driver would do a moment later.
Loading the module by hand after boot does nothing to a card the NVIDIA driver has already bound. The timing is the entire trick.
Suspend to RAM resets the selectors (the cards power off), so the module re-unlocks its boot-time cards on resume, just ahead of the driver resuming them — expect resume to take about a second longer. This can be turned off with gpu_unlock.resume=0. Hibernation is not covered.
Multi-card, display and VM setups are reported working — user reports cover up to four cards in one machine and cards passed through to a VM with vfio-pci.

Rollback — how to undo everything

The exit is one parameter

Remove gpu_unlock.targets= from your kernel command line and reboot — no unlock happens. For a one-off stock boot, delete the parameter in your bootloader's edit screen instead. Removing the packages also removes the module and the initramfs drop-ins. By design, nothing about the card, its firmware or the NVIDIA driver is permanently modified — that is the rollback path the upstream documentation describes.

One failure mode to respect: if the firmware running on a card never stops, the module logs it and deliberately keeps the DMA buffers that firmware may still be using until the next power off. Power off before trying again — don't keep poking it.

Licence and provenance

The kernel module and local packaging are GPL-2.0-only. The generated payload derives from the pinned CMP reference; NVIDIA firmware remains under its own terms — see the project's firmware/NOTICE.md and licenses/ directories for attribution. If it works for you, the project page links ways to support its author.

Found a problem, or a card that works?

The project explicitly asks for compatibility reports — whether it worked or not. GA103 cards in particular have no reports yet. Filing yours is the fastest way this list gets more accurate.