DaVinci Resolve on Ubuntu 25 (AMD + Wayland)

May 20, 2026 · View on GitHub

A working setup for DaVinci Resolve Studio 20.3.x on Ubuntu 25.10 / KDE Plasma 6 (Wayland) with an AMD Radeon RX 7700 XT (Navi 32, gfx1101).

This is a personal lab notebook, but the steps generalise to:

Recent Ubuntu (24.10, 25.04, 25.10) where Resolve's bundled libs can't see the host's glib symbols.
Any AMD RDNA3 card (RX 7600 / 7700 XT / 7800 XT / 7900 XT(X)) and probably RDNA2 with the right HSA_OVERRIDE_GFX_VERSION.
KDE Plasma 6 Wayland sessions (also valid for GNOME Wayland).

The four problems Resolve hits

#	Symptom	Root cause	Fix
1	`/opt/resolve/bin/resolve: symbol lookup error: ... g_task_set_static_name`	Resolve was built against glib older than what ships on Ubuntu 25.x	Run inside an Ubuntu 22.04 distrobox container
2	Resolve crashes in `QGuiApplicationPrivate::createPlatformIntegration`	Bundled Qt5 has no Wayland plugin; Wayland session is in use	Force `QT_QPA_PLATFORM=xcb` to route via XWayland
3	"Unable to load plugin: dimension.plugin — libgomp.so.1 not found"	Container missing OpenMP runtime	`apt install libgomp1` in the container
4	"Unsupported GPU processing mode" / no OpenCL device	Container has no ROCm OpenCL ICD, and rootless podman doesn't map the host `render` group through so `/dev/kfd` is inaccessible	Install ROCm OpenCL inside the container + udev rule to relax `/dev/kfd` perms

End state

Resolve Studio 20.3.2.0009 launches via davinci-resolve from the user's $PATH, runs full-speed with OpenCL on the AMD GPU.
Survives reboots. No host-level Resolve install.
Host stays clean — only one udev rule and a launcher script are added at the host level; everything else lives inside the distrobox.

Prerequisites

On the host:

Recent Ubuntu (tested on 25.10).
AMD GPU with the open amdgpu kernel driver loaded.
podman + distrobox installed (sudo apt install podman distrobox).
~15 GB free in $HOME for the extracted Resolve tree, plus ~3 GB inside the container for ROCm.

You do not need to install ROCm on the host. The container brings its own.

Setup

1. Create the distrobox

distrobox create --name resolve --image ubuntu:22.04

2. Get the Resolve installer and extract it

Download DaVinci_Resolve_Studio_<version>_Linux.zip from Blackmagic Design. Inside is a .run file that is actually an AppImage. Skip the installer GUI (it does distro checks that fail on Ubuntu 25.x); just extract the AppImage contents directly:

unzip DaVinci_Resolve_Studio_*_Linux.zip
chmod +x DaVinci_Resolve_Studio_*_Linux.run
./DaVinci_Resolve_Studio_*_Linux.run --appimage-extract
mv squashfs-root ~/resolve-app

You now have the full Resolve tree at ~/resolve-app/ — bin/resolve, libs/, plugins/, etc. Shared between host and container thanks to distrobox's default $HOME mount.

3. Install the runtime dependencies inside the container

distrobox enter resolve -- sudo apt update
distrobox enter resolve -- sudo apt install -y \
    libxcb-icccm4 libxcb-shape0 libxcb-xinerama0 libxcb-xinput0 \
    libc++1 libc++abi1 \
    libgomp1

The xcb / libc++ packages let Resolve's bundled libQt5XcbQpa.so load. The default Ubuntu 22.04 base image is missing them. libgomp1 is needed by Resolve's dimension.plugin.

4. Install ROCm OpenCL inside the container

distrobox enter resolve -- bash -c '
  sudo apt install -y wget gnupg
  wget -qO - https://repo.radeon.com/rocm/rocm.gpg.key \
    | sudo gpg --dearmor -o /etc/apt/keyrings/rocm.gpg
  echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/rocm.gpg] https://repo.radeon.com/rocm/apt/6.4 jammy main" \
    | sudo tee /etc/apt/sources.list.d/rocm.list
  printf "Package: *\nPin: release o=repo.radeon.com\nPin-Priority: 600\n" \
    | sudo tee /etc/apt/preferences.d/rocm-pin-600
  sudo apt update
  sudo apt install -y rocm-opencl-runtime
'

This pulls only the runtime — no kernel modules, no compilers, ~1.5 GB. The kernel-side amdgpu driver is on the host and is exposed via /dev/kfd and /dev/dri/renderD128, which distrobox mounts into the container.

5. Fix the device permissions (the rootless-podman gotcha)

On the host, /dev/kfd and /dev/dri/renderD* belong to root:render with mode 0660. Inside a rootless distrobox container, the host render group (typically GID 992) isn't mapped into the user namespace, so the container user appears as nobody to those devices and can't open them. AMD's libamdocl64 then reports the ICD but 0 devices:

Number of platforms:    1
  Platform Name:        AMD Accelerated Parallel Processing
  Platform Vendor:      Advanced Micro Devices, Inc.
Number of devices:      0

The blunt fix is to grant world access via a udev rule. Copy udev/70-amdgpu-rocm-containers.rules to /etc/udev/rules.d/ and reload:

sudo install -m 0644 udev/70-amdgpu-rocm-containers.rules \
    /etc/udev/rules.d/70-amdgpu-rocm-containers.rules
sudo udevadm control --reload-rules
sudo udevadm trigger

After this, clinfo inside the container should list your GPU:

Number of devices:      1
  Name:                 gfx1101

Security note: this lets any local user run GPU compute. On a single-user workstation that's a non-issue; on a multi-user box, prefer the container-recreation approach below (option B).

Option B (tighter, but rebuilds the container)

Recreate the distrobox with --group-add keep-groups and --security-opt label=disable so it inherits host group membership properly:

distrobox rm resolve
distrobox create --name resolve --image ubuntu:22.04 \
    --additional-flags "--group-add keep-groups --security-opt label=disable"
# Then redo steps 3 and 4. No udev rule needed.

6. Install the launcher

Copy bin/davinci-resolve somewhere on your $PATH:

install -m 0755 bin/davinci-resolve ~/bin/davinci-resolve

It runs:

distrobox enter resolve -- bash -c "cd ~/resolve-app && QT_QPA_PLATFORM=xcb ./bin/resolve"

That's it. Launch with davinci-resolve from anywhere.

If you don't want a stray "DaVinci Resolve" entry pointing at a broken /opt/resolve binary, drop this at ~/.local/share/applications/com.blackmagicdesign.resolve.desktop:

[Desktop Entry]
Type=Application
Name=DaVinci Resolve
GenericName=Video Editor
Exec=/home/YOUR_USER/bin/davinci-resolve
TryExec=/home/YOUR_USER/bin/davinci-resolve
Icon=/home/YOUR_USER/resolve-app/graphics/DV_Resolve.png
Terminal=false
Categories=AudioVideo;AudioVideoEditing;
StartupNotify=true
StartupWMClass=resolve

Replace YOUR_USER. Then update-desktop-database ~/.local/share/applications/.

Verifying GPU acceleration is actually live

Inside Resolve, go to DaVinci Resolve → Preferences → System → Memory and GPU. You should see your card listed under GPU configuration, with OpenCL as the processing mode and the card selected. If it falls back to "Auto" with a warning, you're still on CPU — re-check step 5.

Upgrading Resolve

For a new Resolve point release:

# Extract the new AppImage
./DaVinci_Resolve_Studio_<new>_Linux.run --appimage-extract
mv ~/resolve-app ~/resolve-app.bak-<oldver>   # safety net
mv squashfs-root ~/resolve-app
davinci-resolve  # launch, enter licence key if asked
# When confident:
rm -rf ~/resolve-app.bak-<oldver>

No container or ROCm changes are needed for point releases.

Known limitations

No NVIDIA / no CUDA-only features. Resolve on Linux supports OpenCL on AMD; some features (notably some Neural Engine effects) need CUDA and are unavailable.
H.264/H.265 decoding only works with Resolve Studio (paid) on Linux. The free version refuses most consumer-camera codecs — transcode to DNxHR or ProRes first if you're on free.
No Studio HW accel via AMD VAAPI. Decode/encode goes through Resolve's own paths; the system VAAPI stack is not used.

File listing

bin/davinci-resolve                         # launcher script
udev/70-amdgpu-rocm-containers.rules        # device permissions for rootless containers

Licence

MIT. Reuse, fork, adapt freely.