# GPU Passthrough for Proxmox: Complete Setup Guide 2026

Step-by-step GPU passthrough on Proxmox VE 9 with VFIO: IOMMU setup, driver binding, VM configuration, NVIDIA drivers, and running local LLMs.

- URL: https://homelabpicks.com/gpu-ai/gpu-passthrough-proxmox/
- Published: 2026-03-15
- Updated: 2026-09-30
- Evidence: research-backed

> HomeLabPicks earns a commission on qualifying purchases made through https://homelabpicks.com/go/ links. Prices change; check the retailer before buying. Disclosure: https://homelabpicks.com/disclosure/

GPU passthrough gives a virtual machine direct control of a physical GPU. For home lab users running local LLMs, that means you can run Proxmox as the hypervisor, pass an NVIDIA GPU to a dedicated AI VM, and still run other VMs and containers on the same box. The VM drives the GPU through VFIO, with no emulated graphics device in the path.

The setup isn't hard, but it's specific. One wrong kernel parameter and the GPU won't unbind from the host. One missing VFIO module and the VM won't start. This guide walks through every step, from firmware settings to running your first Ollama prompt in a GPU-accelerated VM.

If you're still choosing a GPU, read [best GPU for local LLMs](https://homelabpicks.com/gpu-ai/best-gpu-local-llms/) first. If you're choosing hardware to run Proxmox on, see [best mini PCs for Proxmox](https://homelabpicks.com/mini-pc/best-mini-pc-proxmox/).

## Hardware Requirements

GPU passthrough depends on specific hardware features. Not every motherboard, CPU, or GPU combination works cleanly.

### CPU: IOMMU Support Is Non-Negotiable

Your CPU must support an IOMMU, which lets the hypervisor map physical devices into a virtual machine safely.

- **Intel:** VT-d. Check Intel's product page for your exact processor before you buy.
- **AMD:** AMD-Vi, supported across Ryzen and EPYC, provided the motherboard firmware exposes it.

If your platform has no IOMMU, passthrough won't work, and no software workaround exists.

### Motherboard: IOMMU Grouping Matters

Devices are passed through by IOMMU group, and every device in a group has to go to the VM together. If your GPU shares a group with your SATA controller, you'd have to pass both.

Good grouping gives each PCIe slot its own group. Server and workstation boards generally do this well, while consumer boards vary by chipset, slot and firmware. Check the groups on your own board with the command in the troubleshooting section before you buy a second GPU.

### Recommended GPUs

These cards are common choices for local LLM passthrough:

- **[NVIDIA RTX 3090 (Used)](https://homelabpicks.com/go/rtx-3090-used):** 24GB of VRAM holds 32B models at Q4_K_M with a moderate context. It is a large 350W card, so plan on a tower with a strong PSU and good airflow. See [how much VRAM you need for LLMs](https://homelabpicks.com/gpu-ai/how-much-vram-for-llms/) to size your GPU.
- **[NVIDIA RTX 5060 Ti 16GB](https://homelabpicks.com/go/rtx-5060-ti-16gb):** 16GB of GDDR7 at a 180W board rating. It suits 14B models at up to Q6_K. Like other RTX 50-series cards, it needs NVIDIA's open kernel modules inside the Linux VM.
- **[NVIDIA Tesla P40](https://homelabpicks.com/go/tesla-p40-used):** 24GB of VRAM with no video output. It is a passive, dual-slot datacenter card that needs server airflow, a CPU (EPS) 8-pin power connection, and NVIDIA's proprietary driver on the R580 branch, which is the last to support Pascal.

For a full comparison, see [best GPU for home server inference](https://homelabpicks.com/gpu-ai/best-gpu-home-server-inference/).

### Recommended Host Hardware

**Custom tower build.** An AM5 or Intel LGA 1700 or LGA 1851 board with a clean IOMMU layout, 64 GB of RAM, and a full-length x16 slot. This is the right host for full-size GPUs like the RTX 3090 or RTX 5060 Ti, because it gives you the slot space, PSU connectors and airflow they need.

**[Minisforum MS-A2](https://homelabpicks.com/go/minisforum-ms-a2).** A compact Proxmox node with dual 10GbE SFP+ and an x16 slot wired as PCIe 4.0 x8. The slot takes only low-profile, slot-powered cards, so it can't host the full-size GPUs above. It is a good fit for passing through a low-profile GPU or a high-speed NIC. See [best mini PC for Proxmox](https://homelabpicks.com/mini-pc/best-mini-pc-proxmox/) and [best mini PCs for local AI](https://homelabpicks.com/mini-pc/best-mini-pc-local-ai/) for other options.

## Step-by-Step Setup

This guide assumes **Proxmox VE 9** (based on Debian 13) and an NVIDIA GPU. Proxmox VE 8 reached end of life in August 2026, so upgrade before you start. The process is nearly identical for AMD GPUs; only the driver names change.

### 1. Enable IOMMU in Firmware

Reboot into your BIOS or UEFI settings and enable:

- **Intel:** VT-d (usually under CPU or Advanced settings)
- **AMD:** AMD-Vi or IOMMU (usually under Advanced or NBIO settings)

Also turn on **Above 4G Decoding**. Cards with large memory windows need it; NVIDIA's product brief lists a 32 GB compute BAR for the Tesla P40, for example.

### 2. Configure Kernel Parameters

Proxmox VE 9's kernel enables the IOMMU by default on both AMD and Intel CPUs (Intel since kernel 6.8), so you usually only need to add `iommu=pt`. The Proxmox documentation notes that it might increase performance. Kernels older than 6.8 also need `intel_iommu=on` on Intel systems.

First, find out which bootloader your host uses:

```bash
proxmox-boot-tool status
```

Proxmox uses systemd-boot on UEFI systems with a ZFS root (unless Secure Boot is enabled) and GRUB everywhere else.

**For GRUB:** edit `/etc/default/grub` and add the parameter to `GRUB_CMDLINE_LINUX_DEFAULT`:

```bash
GRUB_CMDLINE_LINUX_DEFAULT="quiet iommu=pt"
```

Then apply it:

```bash
update-grub
```

**For systemd-boot:** append `iommu=pt` to the single line in `/etc/kernel/cmdline`, keeping the existing `root=` options, then refresh the boot entries:

```bash
proxmox-boot-tool refresh
```

### 3. Load VFIO Modules

Add the VFIO kernel modules so they load at boot. Edit `/etc/modules` and add:

```
vfio
vfio_iommu_type1
vfio_pci
```

### 4. Keep Host Drivers Off the GPU

Prevent the Proxmox host from claiming the GPU. Create `/etc/modprobe.d/blacklist-gpu.conf`:

```
blacklist nouveau
blacklist nvidia
blacklist nvidiafb
blacklist nvidia_drm
```

For AMD GPUs, blacklist `amdgpu` (and `radeon` on older cards) instead. As an alternative to blacklisting, the Proxmox documentation describes a `softdep` line that makes `vfio-pci` load before the GPU driver.

### 5. Bind the GPU to VFIO

Find your GPU's PCI IDs:

```bash
lspci -nn | grep -i nvidia
```

You'll see output like:

```
01:00.0 VGA compatible controller [0300]: NVIDIA Corporation ... [10de:2204]
01:00.1 Audio device [0403]: NVIDIA Corporation ... [10de:1aef]
```

Note the vendor:device IDs in brackets. Create `/etc/modprobe.d/vfio.conf`:

```
options vfio-pci ids=10de:2204,10de:1aef
```

Include both the GPU and its audio device. They share an IOMMU group and must be passed through together.

Update the initramfs and reboot:

```bash
update-initramfs -u -k all
reboot
```

### 6. Verify IOMMU and VFIO

After the reboot, verify everything is working:

```bash
# Check that the IOMMU is active
dmesg | grep -e DMAR -e IOMMU -e AMD-Vi

# Check that VFIO has claimed the GPU
lspci -nnk -s 01:00 | grep "Kernel driver in use"
# Should show: Kernel driver in use: vfio-pci
```

If the kernel driver shows `nvidia` or `nouveau` instead of `vfio-pci`, the blacklisting or VFIO binding didn't take effect. Double-check your config files and run `update-initramfs -u -k all` again.

### 7. Create a VM with GPU Passthrough

In the Proxmox web UI:

1. Create a new VM with your preferred OS (a current Ubuntu Server LTS release for LLM workloads, or Windows 11 for gaming and rendering).
2. Set **Machine** to `q35` and **BIOS** to `OVMF (UEFI)`, as the Proxmox documentation recommends for GPU passthrough.
3. Add an EFI disk.
4. Under **Hardware**, click **Add > PCI Device**.
5. Select your GPU. Enable **All Functions** to include the audio device, and enable **PCI-Express**.
6. Enable **Primary GPU** only if the GPU should be the VM's display, for example in a Windows gaming VM.

In `/etc/pve/qemu-server/<vmid>.conf`, the key settings look like this:

```
cpu: host
machine: q35
```

### 8. Install GPU Drivers in the VM

**Linux VM (Ubuntu):**

```bash
sudo apt update
sudo ubuntu-drivers install --gpgpu

# Verify
nvidia-smi
```

`ubuntu-drivers install --gpgpu` installs the recommended server driver for the detected GPU. Two NVIDIA rules matter here:

- RTX 50-series (Blackwell) cards must use NVIDIA's open-source kernel modules. The proprietary modules don't support them.
- Pascal cards such as the Tesla P40 must use the proprietary modules. The open modules don't support Pascal, and the R580 branch is the last driver branch for these cards.

You don't need the CUDA toolkit to run Ollama.

**Windows VM:**

Download the current NVIDIA driver and install it normally. Current GeForce drivers support running in a VM with passthrough, so you don't need extra configuration to hide the hypervisor.

## Running Ollama in a GPU-Passthrough VM

Once your Linux VM has working NVIDIA drivers (verify with `nvidia-smi`), setting up Ollama for local LLM inference is straightforward:

```bash
# Install Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Pull a model and run it
ollama pull llama3.1:8b
ollama run llama3.1:8b "Explain GPU passthrough in one sentence"
```

Ollama detects and uses the passed-through GPU automatically. You can verify with:

```bash
ollama ps
# The PROCESSOR column should read 100% GPU
```

For llama.cpp users the same principle applies: build it with the CUDA backend and it will use the passed-through card.

This setup gives you the best of both worlds. Proxmox manages your containers and VMs (Pi-hole, Home Assistant, NAS services), while a dedicated VM gets full GPU access for AI workloads. If the LLM VM crashes, the rest of the host keeps running.

## Troubleshooting Common Issues

### IOMMU Groups Not Separating

If your GPU shares an IOMMU group with other devices, you have two options:

1. **Move the GPU to a different PCIe slot.** Different slots often map to different IOMMU groups.
2. **Use the ACS override as a last resort.** The Proxmox VE kernel includes the ACS override patch, enabled with `pcie_acs_override=downstream` on the kernel command line. It makes the kernel treat devices as isolated even when the hardware doesn't guarantee it, which weakens isolation between VMs. The Proxmox wiki calls it a last option that is not without risks.

Check your groups with:

```bash
find /sys/kernel/iommu_groups/ -type l | sort -V
```

### Code 43 in Windows VMs

Old GeForce drivers stopped with Error 43 when they detected a hypervisor. Current drivers support passthrough, so update the driver first. If Code 43 persists:

- Confirm the VM uses the `q35` machine type and `OVMF` firmware.
- Make sure **All Functions** is enabled so the GPU's audio device goes to the VM too.
- Make sure the host isn't using the GPU for its own console.

Only very old drivers need the hypervisor hidden. In that case, add the `hidden=1` flag to the VM's `cpu` option, for example `cpu: hidden=1,cputype=host`, with no spaces inside the value.

### GPU Reset Bug

Some AMD GPUs don't reset cleanly when a VM shuts down. The GPU gets stuck and can't be reassigned until you reboot the host.

- The `vendor-reset` kernel module handles several affected AMD families: Polaris 10, 11 and 12, Vega 10 and 20, and Navi 10, 12 and 14, according to its README. It does not cover NVIDIA GPUs or newer AMD generations.
- Shut GPU VMs down cleanly instead of force-stopping them. When a card still won't reinitialize, a host reboot clears it.

### Audio Passthrough

The GPU's HDMI/DP audio device passes through automatically when you select **All Functions** during PCI device assignment. If audio is choppy or missing in the VM, confirm that both PCI function 0 (GPU) and function 1 (audio) are assigned to the same VM.

For USB audio devices or separate sound cards, pass them through as additional PCI or USB devices.

## Common Mistakes to Avoid

**Leaving the audio function on the host.** Every device in the GPU's IOMMU group must be available to VFIO. If the audio function stays bound to a host driver, the VM can fail to start. Pass through all functions.

**Using i440fx instead of q35.** The q35 machine type provides a PCIe bus, which modern GPUs expect. The older i440fx type emulates plain PCI.

**Forgetting to update the initramfs.** Every change to modprobe or VFIO configuration requires `update-initramfs -u -k all` to take effect at boot.

**Skipping UEFI/OVMF.** Proxmox recommends OVMF over SeaBIOS for GPU passthrough, and the GPU needs a UEFI-capable ROM.

**Assigning too little RAM.** LLM workloads need system RAM as well as VRAM. The model loads into VRAM, but the inference engine, OS and page cache need RAM too. Allocate at least 16 GB to an LLM VM, and more if part of a model will run from system RAM.

## What's Next

With GPU passthrough running, you have a proper AI inference setup inside your Proxmox home lab. From here, you can:

- Confirm that each model fits entirely on the GPU with `ollama ps`, and size larger models with the [VRAM planning guide](https://homelabpicks.com/gpu-ai/how-much-vram-for-llms/)
- Add a second GPU for multi-GPU inference, or pass one GPU to each of two VMs
- Expose your Ollama instance as an API endpoint for other VMs and containers on your network
- Compare your setup against purpose-built AI mini PCs in [best mini PCs for local AI](https://homelabpicks.com/mini-pc/best-mini-pc-local-ai/)

## FAQ

### Can I pass through my only GPU in Proxmox?

Yes, but the host loses its local video output once the GPU is bound to VFIO. Proxmox runs fine headless; manage it through the web interface from another device. The GPU is then dedicated to the VM.

### Does GPU passthrough work with AMD CPUs?

Yes. AMD CPUs use AMD-Vi for IOMMU, and the Proxmox documentation notes that it is enabled by default. How cleanly devices separate into IOMMU groups depends on the motherboard and firmware, so check the groups before you buy a second GPU.

### Can I run Ollama with a passed-through GPU?

Yes. Once the GPU is passed through to a Linux VM and the NVIDIA driver is installed, Ollama detects it automatically. Run ollama ps after loading a model; 100% GPU in the processor column means the whole model is on the card.

### Why does my Windows VM show Code 43 for the NVIDIA GPU?

Old GeForce drivers stopped with Code 43 inside a VM. Current GeForce drivers support passthrough, so update the driver first. If the error persists, confirm the VM uses the q35 machine type and OVMF firmware, that All Functions is enabled so the GPU's audio device is passed through, and that the host is not using the GPU for its own console.

### Do I need a separate GPU for the Proxmox host?

No. Proxmox is managed through its web interface on port 8006, so most home lab users run the host headless and pass their only GPU to a VM.

## Sources

- [Proxmox VE: PCI(e) Passthrough](https://pve.proxmox.com/wiki/PCI(e)_Passthrough) (accessed 2026-09-30)
- [Proxmox VE: Host Bootloader (GRUB, systemd-boot, kernel command line)](https://pve.proxmox.com/wiki/Host_Bootloader) (accessed 2026-09-30)
- [Proxmox VE: PCI Passthrough examples (ACS override)](https://pve.proxmox.com/wiki/PCI_Passthrough) (accessed 2026-09-30)
- [Proxmox VE FAQ (support lifecycle)](https://pve.proxmox.com/wiki/FAQ) (accessed 2026-09-30)
- [NVIDIA: Transitioning to open-source GPU kernel modules](https://developer.nvidia.com/blog/nvidia-transitions-fully-towards-open-source-gpu-kernel-modules/) (accessed 2026-09-30)
- [NVIDIA: Navigating GPU architecture support for CUDA developers](https://developer.nvidia.com/blog/navigating-gpu-architecture-support-a-guide-for-nvidia-cuda-developers/) (accessed 2026-09-30)
- [Ubuntu Server: Install NVIDIA drivers](https://ubuntu.com/server/docs/how-to/graphics/install-nvidia-drivers/) (accessed 2026-09-30)
- [vendor-reset kernel module README](https://github.com/gnif/vendor-reset) (accessed 2026-09-30)
- [NVIDIA Tesla P40 product brief (BAR size and power connector)](https://images.nvidia.com/content/pdf/tesla/Tesla-P40-Product-Brief.pdf) (accessed 2026-09-30)
- [Ollama FAQ (checking GPU placement with ollama ps)](https://docs.ollama.com/faq) (accessed 2026-09-30)
- [llama.cpp README (CUDA backend)](https://github.com/ggml-org/llama.cpp) (accessed 2026-09-30)
- [Minisforum MS-A2 product specifications](https://store.minisforum.com/products/minisforum-ms-a2-workstation) (accessed 2026-09-29)
- [ServeTheHome Minisforum MS-A2 review (PCIe slot and cooling)](https://www.servethehome.com/minisforum-ms-a2-review-an-almost-perfect-amd-ryzen-intel-10gbe-homelab-system/2/) (accessed 2026-09-29)