Skip to main content
Mini PC Lab logo
Mini PC LabMini PCs for Homelabs
tutorials

Share an Intel iGPU with Jellyfin in an Unprivileged Proxmox LXC

By Max · November 17, 2026

Compact computer on a media shelf beneath a television showing a mountain scene

Illustration of a living-room media server.

If Jellyfin plays a movie smoothly on the living-room TV but sends CPU usage soaring when you lower the bitrate on a phone, check how the server handles video conversion. On a Proxmox mini PC with Intel integrated graphics, an unprivileged Linux container can share the host’s video engine. The piece you give Jellyfin is a render device, usually a path such as /dev/dri/renderD128. The Intel kernel driver stays on the host.

This walkthrough assumes Jellyfin already plays a file from a Debian or Ubuntu container, Jellyfin runs there as a system service, and your Proxmox Resources panel offers Device Passthrough. Jellyfin documents this interface for Proxmox VE 8 and newer. Start with the service working in software so you have a way back. Jellyfin’s Intel setup guide

Decide whether your file needs the GPU

In the Jellyfin dashboard, open the active session and look at the playback method. Direct Play means the client accepts the file as delivered. Remux can change the container while copying the video stream. Even a session that converts audio can leave the picture untouched. For this walkthrough you need a session that actually converts video. Save the title and timestamp of a short SDR clip that plays normally before making changes.

Intel graphics in the hostFirst useful checkLimit that changes the result
N100 with UHD GraphicsTry HEVC Main 10 input and H.264 8-bit output when both profiles appear in the driverAV1 decode support does not give this chip an AV1 encoder
N150 with UHD GraphicsCheck the host kernel before adjusting guest permissionsJellyfin lists kernel 6.9 or newer for this refresh
Skylake Core with HD 5xx graphicsBegin with H.264 8-bitHEVC 10-bit decode needs a newer generation
Processor with no enabled Intel GPUCheck the exact processor and firmware display settingsA Jellyfin setting cannot create a host render device

If your existing processor lacks the video features your clients need, compare mini PCs for Jellyfin before replacing the server. Use the profiles exposed by your installed driver as the final check. Codec, bit depth, subtitles and HDR conversion can each change which part of playback needs the CPU. The transcode calculator helps plan a workload. The individual playback session tells you which path your machine took. Intel codec capabilities in Jellyfin and known acceleration issues.

Identify the host device and guest group

Run the first block on the Proxmox node that hosts the container. If you have several nodes, note the node name alongside the container ID. A render device is local to the physical machine.

pveversion
uname -r
lspci -nnk | grep -A3 -Ei 'vga|display'
ls -l /dev/dri/renderD*
ls -l /dev/dri/by-path/

Look for the Intel graphics controller and its kernel driver. On machines with two GPUs, use the PCI address in the by-path listing to associate a render node with the Intel controller. Save the resolved render path. If there is no render device, stop here. Check whether the integrated graphics are enabled, the host driver loaded and the host kernel supports the chip. If a VM owns the GPU through VFIO, plan which workload will own it before changing the VM. Our PCI passthrough guide covers that different arrangement.

Now run the following inside the Jellyfin container. Confirm that Proxmox lists it as unprivileged in its Options panel. The group number you need is the number inside this guest. Another container on the same node can use a different number for the same group name.

getent group render
id jellyfin

In the group record, the numeric field immediately after the password field is the GID. If the service account is missing, check how Jellyfin was installed. A Docker deployment has its own service identity. If only the group is missing on this Debian-based guest, create it with groupadd --system render as guest root and look up the number again.

Give just this container access

  1. Record the container’s existing device entries and the current Jellyfin transcoding settings. Choose a time when you can restart the container without interrupting another service.
  2. In the Proxmox web interface, sign in as root and select the correct node and container. Open Resources → Add → Device Passthrough. Enter the host render path you identified.
  3. Open the advanced options. Set the group ID to the guest’s render GID and the access mode to 0660. Leave the primary display node and other GPUs out of the mapping.
  4. Inside the guest, as root, add the service user to the group with usermod -aG render jellyfin. Preserve its other groups, including any that give it read access to your library.
  5. Shut down the container cleanly and start it again from Proxmox. Return to the guest shell and check the device as the account that runs playback.
ls -ln /dev/dri/renderD*
id jellyfin
runuser -u jellyfin -- /usr/lib/jellyfin-ffmpeg/vainfo --display drm --device /dev/dri/renderD128

Replace the example path wherever your node differs. The numeric group on the device should agree with a group in the service user’s membership. Successful output lists driver profiles and entry points. A decode entry can appear without an encode entry for the same codec. A permission error at this stage points back to the mapping and group. Running the command as root can conceal precisely the fault you are looking for.

If the executable is missing, check the Jellyfin-supported FFmpeg package for your distribution inside the guest. The host supplies the kernel device while the guest needs the user-space media components. Installing another kernel inside the container cannot change the one reported by the host. Jellyfin hardware acceleration

Verify playback end to end

In Jellyfin’s administration dashboard open Playback → Transcoding, choose Intel Quick Sync on supported hardware, and select the mapped device where the interface exposes a device setting. Enable decoding only for profiles your GPU supports. Enable hardware encoding and save. Leave HDR tone mapping and subtitle burn-in out of the first run. That gives you one conversion to diagnose.

Play the SDR clip. In the client, choose a quality with a video bitrate below the source. Open playback information and confirm that the video is being transcoded. In the server dashboard, open the corresponding FFmpeg transcode log. For Quick Sync output, look for a hardware encoder such as h264_qsv on the output stream. A reference to a hardware decoder alone does not establish which encoder wrote the output.

During that same session, run intel_gpu_top as root on the host if the Intel GPU tools package is installed. Watch the Video engine while the client starts or seeks. Transcoders can fill a buffer and pause, so an idle reading after a minute of smooth playback says little. Correlate the file, session log and engine activity. Another container can use the same engine. Once the baseline works, repeat with your actual HEVC, HDR or subtitled title and inspect the new log.

What you observeNext check
Host sees the device, guest sees nothingCheck the container ID, configured path and whether the shutdown and start applied the change
Root can query profiles, Jellyfin gets permission deniedCompare numeric GIDs in the guest and restart the service after membership changes
Profiles work, GPU stays idleCheck Direct Play, remux and audio-only conversion before changing drivers
SDR works, a particular title buffersCompare codec profile, bit depth, subtitle burn-in and tone mapping one at a time
Playback breaks immediately after the changeReturn Jellyfin to software acceleration, replay the original clip and read the failed session log

Nested Docker, Plex and moving to another host

With Jellyfin inside Docker inside an LXC there are two device boundaries. Get the render node working inside the LXC first. Then expose that same device to the Docker service and include the owning numeric group in the Docker container’s supplemental groups. Repeat the access check as the account inside the innermost container. Our Jellyfin Docker setup covers the application layer.

A Plex service can share a render node on the same principle, but has its own acceleration controls and subscription requirements. Use Plex’s own playback details and hardware indicator to check a Plex stream. The Jellyfin log and dashboard steps above apply only to Jellyfin. Plex hardware-accelerated streaming

Before moving or restoring the LXC on another Proxmox node, check that node’s GPU, driver and render path. To roll back, disable acceleration in Jellyfin, stop the container cleanly, remove only the render-device entry you added and start the container again. Verify software playback of the original clip. Skip device sharing altogether if your clients already direct-play your library or if you need a VM to have exclusive ownership of that GPU.

Frequently asked questions

Does Jellyfin need a privileged Proxmox container?

A current Proxmox installation with render-device passthrough can grant an unprivileged container access to Intel graphics. Use the guest render group and check access as the Jellyfin service user.

Which render device should I select on a dual-GPU host?

Match the Intel controller’s PCI address to its render link under /dev/dri/by-path on the host. Use the resolved device path in Proxmox, then verify the model and profiles from inside the guest.

Why does the GPU stay idle during Direct Play?

The client can already decode the original video. Choose a lower bitrate that forces video conversion and check the session log while the client starts playing.

Can I enable every codec after vainfo succeeds?

Enable the profiles your device and driver expose. Decode and encode are separate capabilities. A server can decode AV1 in hardware and still need a different codec for the output.

Will the container keep transcoding after a migration?

Only if the destination host supplies a compatible GPU, driver and device mapping. Check them before the move and repeat the playback test afterward.