GPU Unlock

GPU Unlock Installation Guide

Install on Linux, enable the boot option, and verify the result before relying on it.

Sources checked . Independent community reference. Sources & verification.

Before you start

This guide is for the main Linux project. Windows uses a separate experimental implementation, described in our Windows guide. Check the exact model and PCI device ID in Supported GPUs. Ampere is listed as stable upstream; Ada and Turing remain experimental. Blackwell is not supported. A listing is not verification of your particular machine.

You need a working Linux system, Git, Make, network access and the build requirements for your distribution. Matching kernel headers and a usable module build environment matter. Installation may ask for administrator credentials to install packages or dependencies. If Secure Boot prevents an unsigned module from loading, follow your distribution’s signing policy rather than assuming installation has failed.

Back up important files and preserve an unmodified boot entry or known-good kernel. Identify the actual bootloader and initramfs generator before changing settings. Driver and boot changes can cause display loss, instability, failure to start or data loss. Read the recovery section before enabling anything, and stop if you cannot restore the original configuration.

Step 1 — Install

Clone the original repository and run its automatic installer from the repository directory. These are the normal first-install commands:

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

The default target reads /etc/os-release, using ID and then ID_LIKE, and chooses an installer for Arch, Debian/Ubuntu, or Fedora/RHEL/CentOS families. You do not normally need to select an explicit distribution target. The RPM path requires DNF.

The build downloads the NVIDIA/CachyOS inputs and generates firmware locally. The NVIDIA input version identifies a firmware source; it is not, by itself, an instruction to replace your installed driver with that version. Read the installation output and resolve package or build errors before continuing. A successful package installation prepares the boot integration; it does not establish that a GPU has already unlocked.

The early-boot integration belongs to your initramfs generator. The main packages provide mkinitcpio, initramfs-tools and dracut integration rather than relying on a late manual module load. For initramfs-tools and dracut, upstream describes building the module for installed kernels that have headers and rebuilding their images on installation and removal. A kernel without the needed headers is not made ready by a successful build for another kernel. Check which image you will actually boot.

Step 2 — Enable at boot

Append the following option to your existing kernel command line. Preserve every option already required by your system:

Kernel parameter
gpu_unlock.targets=all

The parameter opts in every supported, unbound card. Choose the instructions for your boot configuration below. Distribution names alone do not determine whether you use GRUB, systemd-boot or a generated UKI.

GRUB on Debian / Ubuntu / Mint

Edit /etc/default/grub. Append the parameter inside the existing GRUB_CMDLINE_LINUX_DEFAULT value without deleting its contents. Then regenerate GRUB:

Bash
sudo update-grub
GRUB on Arch / CachyOS

Make the same parameter edit in /etc/default/grub, keeping the existing value. Regenerate the configuration using the upstream path:

Bash
sudo grub-mkconfig -o /boot/grub/grub.cfg
Fedora / RHEL with grubby

For entries managed by grubby, upstream uses:

Bash
sudo grubby --update-kernel=ALL --args="gpu_unlock.targets=all"

This updates all managed kernel entries. Keep a recovery path and do not combine it with another distribution’s GRUB command.

systemd-boot with editable entries

Locate the entry first:

Bash
bootctl status

Append the parameter to the entry’s existing options line. If entries are generated, edit their source configuration instead so regeneration does not discard your change.

UKI / generated entries

Where applicable, append the parameter in /etc/kernel/cmdline and regenerate images or entries with your configured tool. For mkinitcpio UKIs only, upstream gives:

Bash
sudo mkinitcpio -P

This command is not a universal replacement for a dracut or other UKI workflow.

Step 3 — Reboot and verify

Save your work. Confirm installation and image generation completed, then reboot into the intended entry. Keep the original recovery entry available. After boot, inspect the current kernel journal:

Bash
journalctl -k -b | grep gpu_unlock

Read the per-card result and any reason for skipping it. An already-bound, powered-down or unsupported card is not a successful unlock. An installed package, a loaded module, or the presence of the NVIDIA driver alone is insufficient evidence.

Find the full PCI address for your actual card:

Bash
lspci -D

Upstream also uses lspci -nnk -s 0000:[ID]:00.0 to inspect a selected device. That address is a template. Replace the entire example with the actual BDF from your machine; do not paste the placeholder or assume the device function is always 00.0. Driver binding information is useful context, but is not a throughput measurement.

Record the selected card, current kernel and relevant log result together. On a multi-card system, a successful result for one device does not establish the state of the others. Keep errors associated with their actual PCI addresses rather than combining them into one overall success label.

Finally, compare an appropriate workload under controlled conditions. Keep the input, precision, power policy and software environment comparable. Our benchmark guide explains why a tensor instruction result is different from application performance.

Advanced options

Explicit installer targets

Use one compatible target only when automatic detection is unsuitable. These are alternatives, not three additional steps.

Arch family

Bash
make install-arch

Debian / Ubuntu family

Bash
make install-deb

Fedora / RHEL family

Bash
make install-rpm
Select individual cards

Use full PCI addresses reported by lspci -D. The following examples illustrate syntax only; replace them with your own addresses:

Example parameter
gpu_unlock.targets=0000:21:00.0
Example parameter
gpu_unlock.targets=0000:21:00.0,0000:22:00.0

Do not mix all with explicit addresses. Apply the same boot-configuration update procedure used for the original opt-in.

Initramfs and resume limits

The packages arrange early loading before NVIDIA. mkinitcpio configurations selected with -c or a preset’s custom config can ignore drop-ins; the relevant MODULES list must place gpu_unlock immediately before nvidia.

The main project describes a suspend-to-RAM resume path that depends on NVIDIA notifier behavior. Hibernation is not covered. gpu_unlock.resume=0 disables that resume behavior. Laptop runtime power-off can reset the unlock independently of a normal suspend cycle; do not assume one successful boot covers every power state.

Disable / roll back

For a one-off recovery boot, remove gpu_unlock.targets=… in the bootloader’s edit screen. For a persistent change, remove it from the source configuration you edited, preserve unrelated options, and regenerate the corresponding GRUB configuration, UKI or generated entries. Then reboot with the opt-in absent.

Package removal is separate from removing the boot option. Upstream states that removing its packages removes the module and initramfs drop-ins. Use your package manager and the package names actually installed by your build; there is no universal uninstall command here. Verify the removal and image rebuild completed.

If the log says firmware did not stop and DMA buffers are retained, power off before another attempt. Do not treat repeated module loading or a warm reboot as an equivalent recovery procedure.

If something does not work

Use Troubleshooting to distinguish installation errors, missing boot options, early-loading problems and power-state limitations. Record the failing stage before changing another setting.

For Windows, use the separate Windows compatibility and recovery overview. Linux commands and support states do not transfer to its UEFI workflow.

Sources & verification

This guide follows the main project’s current README, checked October 29, 2026. It does not substitute instructions from the independent Ada branch. View source README on GitHub.