GeForce GTX 1050 Ti vGPU Unlock on Linux: mdev Setup, Kernel Downgrade and Risks

This is not a general unlock of "professional features." It is a narrow trick: getting Nvidia's vGPU virtualization stack to accept hardware it was never meant to run on. That's useful for homelabbers. It's less useful for anyone who just wants a free Quadro.

What was actually unlocked​

The tool is the community project vgpu_unlock. Its README says Nvidia vGPU normally supports only a few datacenter Teslas and professional Quadro GPUs by design, not consumer cards, through a software limitation. The project aims to remove that limitation on Linux. It targets most Maxwell, Pascal, Volta (untested), and Turing based GPUs.

The mechanism is less exotic than "hacking the GPU" sounds. According to the project's documentation, the driver looks at the PCI device ID to decide whether a GPU supports vGPU. The tool intercepts those checks and makes a GeForce card look like a vGPU-capable one. It also hooks the kernel module so the driver's deeper capability checks pass.

Nvidia's own vGPU documentation describes the legitimate version of this feature. It lets multiple virtual machines share a single physical GPU, with each vGPU getting a fixed slice of the card's framebuffer. The unlock aims to give a GeForce card that same capability.

The reported GTX 1050 Ti recipe​

The author's setup was Arch Linux on a GTX 1050 Ti. These are their reported details, not a verified recipe for every machine:

• Driver: Nvidia GRID vGPU driver 535.104.06, downloaded from Nvidia's site with an evaluation account.
• Kernel: Downgraded to 6.1. The author says a newer kernel (6.18, which they call the current LTS) wouldn't work with this driver and card.
• Patching: Community scripts patched the vGPU driver, followed by a standard DKMS install. The installer must run from a text console (TTY), not a live graphical session.
• Refinements: The Rust companion tool vgpu_unlock-rs removed some artificial limits. The author says it removes throttling from the unofficial driver.
• Finish: Blacklist the Nouveau module and reboot. Running nvidia-smi then showed the vGPUs, which could be assigned to multiple VMs.

Nvidia's release table identifies 535.104.06 as the Linux vGPU Manager for vGPU software 16.1 (released August 2023). The matching Windows manager is 537.13 and the Linux guest driver is 535.104.05. These are different components. The same table lists branch 16 as end-of-life since July 2026, so this is an old, unsupported branch.

The upstream README gives a more general procedure than the author's write-up. It involves installing the GRID driver as a DKMS module, editing the nvidia-vgpud and nvidia-vgpu-mgr systemd services, adding hooks and a linker script to the driver build, then rebuilding with DKMS. The Rust companion adds profile overrides. Its example sets display count and resolution, enables CUDA, and disables the frame-rate limiter. Migration and snapshotting need a recompiled kernel module.

What it does not do​

It is not SR-IOV by default. The MakeUseOf piece says the unlock exposes both mdev and SR-IOV. The upstream documentation describes the older mediated-device (mdev) path instead. After the device-ID checks pass, the vGPU service creates an mdev device and the system builds the mdev bus directory, and vGPUs are created through it. Nothing in the evidence shows SR-IOV working on a GTX 1050 Ti. Treat the mdev model as the correct mental picture.

It does not multiply your hardware. Each vGPU's framebuffer is carved from the physical card's memory, and the vGPU keeps it until it is destroyed. On a 4 GB card, that leaves little to share. Nvidia's marketing page lists the 1050 Ti with 4 GB of GDDR5 on the Pascal architecture. The author says this severely limits what the setup can do.

It does not make a GeForce card an officially supported product. Nvidia's licensing FAQ says vGPU downloads come through its licensing portal. It says evaluation licenses exist but that a supported NVIDIA GPU is required to use the license. A trial account gets you the software. It doesn't make your GeForce card supported.

The Ampere line is blurrier than the article suggests​

The article says the unlock is unavailable on Ampere and newer. It attributes this to Nvidia moving driver initialization onto a die on the GPU. I couldn't verify that explanation, so treat it as the author's claim.

The wider picture is more nuanced than "impossible":

• The original README says Ampere support is currently a work in progress.
• A community wiki's support table lists most Pascal and most Turing cards as compatible, and says of Ampere "none (don't expect any)".
• XDA Developers reported that an enthusiast had cracked Ampere and Ada, though that project hadn't been released at the time of writing.

For a reader buying hardware today, the practical reading is the same either way. Pascal and Turing are the realistic targets, and Ampere or newer is not something to plan around.

Who should bother​

Compatibility depends on the GPU generation, the driver version, the kernel, and the host OS. The README warns that not all cards are guaranteed to work smoothly with vGPU. It also says bleeding-edge Linux distributions may not behave well, which fits the author's kernel downgrade.

Reasons to try it:

• You have a spare Pascal or Turing card, ideally with plenty of VRAM. The author suggests the 11 GB RTX 2080 Ti as an interesting option.
• You run a homelab and want GPU-accelerated VMs without buying a licensed professional card.
• You're comfortable with DKMS, kernel pinning, and recovering from a broken graphics driver.

Reasons to skip it:

• You only want to game on one machine.
• You need a stable, supported production setup.
• You'd rather not run a patched kernel module and an end-of-life driver branch.

The author floats hosting games or a Minecraft server on the vGPUs. That is a suggestion, not a benchmarked result. No performance numbers were given.

Bottom line​

The vgpu_unlock approach turns a spare older GeForce card into a shared GPU for virtual machines, at the cost of an unsupported, version-sensitive setup. The author's GTX 1050 Ti experiment shows it can work. It also shows how much has to line up: a specific driver, a pinned kernel, and several community patches. It is a neat project for tinkerers with old Pascal or Turing hardware. It is not a shortcut to a professional workstation card.