Jellyfin on Proxmox 2026: LXC vs VM - GPU Passthrough in 5 Minutes (Intel & NVIDIA)

Jellyfin on Proxmox: LXC vs VM, GPU Passthrough & Complete Setup (2026)

Proxmox VE is the hypervisor of choice for the self-hosting community in 2026. If you run a homelab, chances are your Jellyfin server lives on Proxmox or soon will. But getting hardware transcoding working inside an LXC container or VM requires specific configuration that trips up even experienced admins.

This guide covers every step from creating the container to verifying GPU passthrough with real transcoding sessions.

LXC vs VM for Jellyfin: Which Should You Choose?

Proxmox offers two virtualization options. For Jellyfin, the choice matters.

The recommendation

• Intel iGPU (QSV): Use an LXC container - simplest setup, lowest overhead, excellent performance
• NVIDIA dGPU: Use a VM with PCI passthrough - more reliable driver support
• No GPU / Direct Play only: Use an LXC container - minimal resources needed

Method 1: Jellyfin in an LXC Container with Intel QSV

This is the most popular Proxmox + Jellyfin setup in the community. An unprivileged LXC container with /dev/dri mapped from the host gives you full Intel Quick Sync hardware transcoding at near-zero overhead.

Step 1: Create the LXC container

From the Proxmox web UI:

1. Click Create CT
2. Template: Ubuntu 22.04 or Debian 12
3. Disk: 16 GB minimum (config only - media is mounted separately)
4. CPU: 2 cores minimum (4 recommended)
5. RAM: 2048 MB minimum (4096 recommended)
6. Network: DHCP or static IP on your LAN bridge
7. Uncheck "Unprivileged container" if you want the simplest GPU passthrough (see note below)

Privileged vs Unprivileged: Unprivileged containers are more secure but require extra steps for GPU access. Privileged containers make GPU passthrough trivial. For a dedicated Jellyfin container on a home network, privileged is acceptable.

Step 2: Map the Intel GPU into the container

On the Proxmox host, edit the container configuration:

nano /etc/pve/lxc/YOUR_CT_ID.conf

Add these lines at the bottom:

lxc.cgroup2.devices.allow: c 226:0 rwm
lxc.cgroup2.devices.allow: c 226:128 rwm
lxc.mount.entry: /dev/dri dev/dri none bind,optional,create=dir
lxc.mount.entry: /dev/dri/renderD128 dev/dri/renderD128 none bind,optional,create=file

For unprivileged containers, you also need UID/GID mapping. Add:

lxc.idmap: u 0 100000 65536
lxc.idmap: g 0 100000 65536

And on the host, ensure the render group GID inside the container maps correctly:

# On the Proxmox host, check the render group
ls -la /dev/dri/renderD128
# Note the group (usually "render" with GID 109 or similar)

Step 3: Install Jellyfin inside the container

Start the container and SSH in:

pct start YOUR_CT_ID
pct enter YOUR_CT_ID

# Update and install Jellyfin
apt update && apt upgrade -y
curl -fsSL https://repo.jellyfin.org/install-debuntu.sh | bash
systemctl enable --now jellyfin

Step 4: Verify GPU access

Inside the container:

ls -la /dev/dri/
# Should show: card0  renderD128

# Install vainfo to test
apt install vainfo -y
vainfo
# Should list VA-API profiles (H264, HEVC, VP9, AV1 decode)

If vainfo shows profiles, your GPU is accessible.

Step 5: Add Jellyfin user to the render group

usermod -aG render jellyfin
usermod -aG video jellyfin
systemctl restart jellyfin

Step 6: Enable QSV in Jellyfin

1. Open Jellyfin at http://YOUR_CT_IP:8096
2. Dashboard → Playback → Transcoding
3. Hardware acceleration: Intel QuickSync (QSV)
4. Enable: H.264, HEVC, VP9, AV1 (decode)
5. Enable: Hardware Tone Mapping
6. Save

Test by playing a 4K HEVC file from a client that forces transcoding (set client quality to 720p). Check intel_gpu_top on the Proxmox host to confirm the GPU is active.

Method 2: Jellyfin in an LXC with Docker (Nested)

If you prefer running Jellyfin via Docker inside an LXC container:

Enable nesting

In the Proxmox web UI → Container → Options → Features → check Nesting

Or in the config file:

features: nesting=1

Install Docker inside the LXC

curl -fsSL https://get.docker.com | sh

Docker Compose with GPU

services:
  jellyfin:
    image: jellyfin/jellyfin:latest
    container_name: jellyfin
    network_mode: host
    volumes:
      - ./config:/config
      - ./cache:/cache
      - /mnt/media:/media:ro
    devices:
      - /dev/dri/renderD128:/dev/dri/renderD128
    restart: unless-stopped

The /dev/dri device is already mapped into the LXC from Step 2 above. Docker inside the LXC inherits access.

Method 3: Jellyfin in a VM with NVIDIA PCI Passthrough

For NVIDIA GPUs, a full VM with PCI passthrough is the most reliable approach.

Step 1: Enable IOMMU on the Proxmox host

Edit GRUB:

nano /etc/default/grub

For Intel CPUs:

GRUB_CMDLINE_LINUX_DEFAULT="quiet intel_iommu=on iommu=pt"

For AMD CPUs:

GRUB_CMDLINE_LINUX_DEFAULT="quiet amd_iommu=on iommu=pt"

update-grub
reboot

Step 2: Blacklist host GPU drivers

echo "blacklist nouveau" >> /etc/modprobe.d/blacklist.conf
echo "blacklist nvidia" >> /etc/modprobe.d/blacklist.conf
echo "options vfio-pci ids=XXXX:XXXX" >> /etc/modprobe.d/vfio.conf
update-initramfs -u
reboot

Replace XXXX:XXXX with your GPU PCI vendor:device ID (find with lspci -nn | grep NVIDIA).

Step 3: Create the VM and pass through the GPU

1. Create a VM with Ubuntu 22.04 Server
2. Hardware → Add → PCI Device → Select your NVIDIA GPU
3. Check All Functions and PCI-Express
4. Boot the VM and install NVIDIA drivers:

sudo apt install nvidia-driver-550 -y
sudo reboot
nvidia-smi  # Verify GPU is detected

Step 4: Install Jellyfin with Docker + NVIDIA runtime

# Install Docker
curl -fsSL https://get.docker.com | sh

# Install NVIDIA Container Toolkit
curl -fsSL https://nvidia.github.io/libnvidia-container/gpgkey | sudo gpg --dearmor -o /usr/share/keyrings/nvidia-container-toolkit-keyring.gpg
curl -s -L https://nvidia.github.io/libnvidia-container/stable/deb/nvidia-container-toolkit.list | \
  sed "s#deb https://#deb [signed-by=/usr/share/keyrings/nvidia-container-toolkit-keyring.gpg] https://#g" | \
  sudo tee /etc/apt/sources.list.d/nvidia-container-toolkit.list
sudo apt update && sudo apt install -y nvidia-container-toolkit
sudo nvidia-ctk runtime configure --runtime=docker
sudo systemctl restart docker

services:
  jellyfin:
    image: jellyfin/jellyfin:latest
    container_name: jellyfin
    runtime: nvidia
    environment:
      - NVIDIA_VISIBLE_DEVICES=all
      - NVIDIA_DRIVER_CAPABILITIES=compute,video,utility
    network_mode: host
    volumes:
      - ./config:/config
      - ./cache:/cache
      - /mnt/media:/media:ro
    restart: unless-stopped

Select NVIDIA NVENC in Jellyfin transcoding settings.

Mounting Media Storage in Proxmox

Your media files likely live on a NAS or a separate disk. Here is how to make them available inside your Jellyfin container or VM.

NFS mount (most common for NAS)

On the Proxmox host:

apt install nfs-common -y
mkdir -p /mnt/media
echo "NAS_IP:/volume1/media /mnt/media nfs defaults,_netdev 0 0" >> /etc/fstab
mount -a

For LXC, add a bind mount in the container config:

mp0: /mnt/media,mp=/mnt/media,ro=1

For VMs, mount NFS directly inside the VM or use Proxmox storage passthrough.

SMB/CIFS mount

apt install cifs-utils -y
mkdir -p /mnt/media
echo "//NAS_IP/media /mnt/media cifs credentials=/root/.smbcredentials,uid=1000,gid=1000,_netdev 0 0" >> /etc/fstab

Create /root/.smbcredentials:

username=your_user
password=your_password

chmod 600 /root/.smbcredentials
mount -a

Performance Tuning for Proxmox + Jellyfin

CPU pinning (optional, advanced)

For consistent transcoding performance, pin the Jellyfin container to specific CPU cores:

# In /etc/pve/lxc/YOUR_CT_ID.conf
lxc.cgroup2.cpuset.cpus: 2-5

This dedicates cores 2-5 to Jellyfin, preventing other containers from competing during heavy transcoding.

Memory limits

Set a reasonable memory limit to prevent Jellyfin from consuming all host RAM during large library scans:

• 2 GB: minimum for small libraries
• 4 GB: recommended for most setups
• 8 GB: large libraries with Trickplay generation

Storage performance

Place Jellyfin config on local SSD storage (not the NAS). Metadata access is random I/O and benefits enormously from SSD speed.

In the Proxmox container config:

rootfs: local-lvm:vm-YOUR_CT_ID-disk-0,size=32G

Proxmox Helper Scripts (Community)

The Proxmox community maintains helper scripts that automate Jellyfin LXC creation:

bash -c "$(wget -qLO - https://github.com/community-scripts/ProxmoxVE/raw/main/ct/jellyfin.sh)"

This script creates an optimized LXC container with Jellyfin pre-installed and GPU passthrough configured. Review the script before running it.

Troubleshooting

FAQ

Can I run Jellyfin in an unprivileged LXC with GPU? Yes, but it requires additional UID/GID mapping configuration. Privileged containers are simpler for GPU passthrough on a trusted home network.

Does Intel QSV work in an LXC container? Yes. Mapping /dev/dri/renderD128 into the container gives full QSV access. This is the recommended setup for Intel iGPU users.

Can I pass an NVIDIA GPU to an LXC? It is possible using the NVIDIA container toolkit on the host, but it is fragile and poorly documented. A VM with PCI passthrough is more reliable for NVIDIA.

How many 4K transcodes can I expect? Same as bare metal. The LXC adds negligible overhead. An Intel N100 handles 3-4 simultaneous 4K transcodes via QSV whether bare metal or in an LXC.

Can I snapshot my Jellyfin LXC? Yes. Proxmox LXC snapshots are fast and include the full container state. Use them before major Jellyfin upgrades.

Running Jellyfin on Proxmox? Monitor it from your phone. Download JellyWatch on Google Play - real-time session monitoring, GPU usage tracking, and push notifications for your Jellyfin server on Android.

On Emby? Download EmbyWatch on Google Play - the same monitoring experience for Emby servers.