DaVinci Resolve 21.0.3 on AMD Strix Halo with Ubuntu 24.04.4

A minimal, reproducible installation guide for DaVinci Resolve 21.0.3 on an AMD Ryzen AI Max / Strix Halo (gfx1151) system running Ubuntu 24.04.4 with a recent OEM kernel.

[!IMPORTANT] This is an unsupported community configuration. Blackmagic Design officially targets Rocky Linux for Resolve on Linux. The libProResRAW.so symbol-visibility patch is a local workaround for a startup crash caused by interaction between that library and AMD's HSA/OpenCL runtime. Keep the original library backup. Furthermore, this documentation was compiled by GPT 5.6 based on a lengthy troubleshooting session. Double check any instructions listed here.

Tested configuration

• Ubuntu 24.04.4
• Linux 6.17.0-1030-oem kernel
• AMD Ryzen AI Max Pro 385 / Radeon 8050S
• GPU architecture: gfx1151
• AMD ROCm 7.2.x
• DaVinci Resolve 21.0.3

1. Remove an older AMDGPU/ROCm installation

Skip this section only on a genuinely fresh Ubuntu installation that has never had AMD's amdgpu-install package or a separately installed ROCm stack.

AMD's 7.2 installer supports removing the previous stack and all installed ROCm releases with:

if command -v amdgpu-install >/dev/null 2>&1; then
  sudo amdgpu-install --uninstall --rocmrelease=all
elif command -v amdgpu-uninstall >/dev/null 2>&1; then
  sudo amdgpu-uninstall
fi

Remove the old installer package and stale AMD package-source configuration:

sudo apt purge -y 'amdgpu-install*'

sudo rm -f \
  /etc/apt/sources.list.d/amdgpu*.list \
  /etc/apt/sources.list.d/rocm*.list \
  /etc/apt/preferences.d/rocm-pin-600

Remove stale OpenCL registrations left by an older AMD or Mesa/Rusticl setup. The new AMD installation will recreate its own ICD file:

sudo rm -f \
  /etc/OpenCL/vendors/amdocl64.icd \
  /etc/OpenCL/vendors/amdocl64_*.icd \
  /etc/OpenCL/vendors/mesa.icd \
  /etc/OpenCL/vendors/rusticl.icd

Repair package state and refresh APT. Do not reboot yet; install the replacement AMD stack first.

sudo apt update
sudo apt --fix-broken install

2. Install the AMD graphics and compute stack

Resolve uses OpenCL on this AMD GPU. AMD's rocm use case includes both the ROCr OpenCL runtime and HIP, while graphics installs AMD's open-source Mesa graphics and multimedia userspace.

Install the prerequisites and AMD's Ubuntu 24.04/Noble installer package:

sudo apt update
sudo apt install -y wget python3-setuptools python3-wheel

cd ~/Downloads
wget https://repo.radeon.com/amdgpu-install/7.2/ubuntu/noble/amdgpu-install_7.2.70200-1_all.deb
sudo apt install ./amdgpu-install_7.2.70200-1_all.deb

This is the installer package used by the tested working setup. The .deb filename identifies the ROCm 7.2.0 release; after installation, dpkg may display the installer package itself with an AMD Radeon Software version such as 30.30.0.0.... That difference is expected.

Check the use cases provided by the installed version:

sudo amdgpu-install --list-usecase

Install graphics plus the full ROCm stack:

sudo amdgpu-install -y --usecase=graphics,rocm --no-dkms

The options mean:

• graphics: OpenGL/Mesa graphics and multimedia userspace
• rocm: full ROCm stack, including OpenCL and HIP
• --no-dkms: keep Ubuntu's recent in-kernel/OEM amdgpu driver instead of installing a separate DKMS kernel module

Add your account to the GPU-access groups and reboot:

sudo usermod -aG render,video "$USER"
sudo reboot

3. Verify the GPU stack

After reboot, confirm that ROCm sees gfx1151:

/opt/rocm/bin/rocminfo | grep -E 'Name:|Marketing Name:|gfx'

Confirm that OpenCL exposes one AMD GPU:

clinfo -l

Confirm access to the GPU devices:

ls -l /dev/kfd /dev/dri/renderD*
id

The user must belong to both render and video.

4. Install Resolve dependencies

sudo apt update
sudo apt install -y \
  gcc \
  python3 \
  libapr1 \
  libaprutil1 \
  libasound2t64 \
  libfuse2 \
  libglu1-mesa \
  libxcb-composite0 \
  libxcb-cursor0 \
  libxcb-damage0 \
  libxcb-xinerama0 \
  libxcb-xinput0 \
  libxkbcommon-x11-0 \
  ocl-icd-libopencl1 \
  clinfo \
  ffmpeg

Do not install a second OpenCL implementation such as Mesa Rusticl when AMD's ROCm OpenCL ICD is already active.

5. Install DaVinci Resolve 21.0.3

Extract the installer downloaded from Blackmagic Design, enter the extracted directory, and run the command.

Free edition

chmod +x DaVinci_Resolve_21.0.3_Linux.run
sudo env SKIP_PACKAGE_CHECK=1 ./DaVinci_Resolve_21.0.3_Linux.run -i

Confirm the executable exists:

ls -l /opt/resolve/bin/resolve

6. Patch the ProRes RAW library's exported filesystem symbols

Back up the original library outside Resolve's active library directory:

sudo mkdir -p /opt/resolve-disabled
sudo cp -a \
  /opt/resolve/libs/libProResRAW.so \
  /opt/resolve-disabled/libProResRAW.so.unmodified

Create the patcher:

cat > /tmp/hide-proresraw-filesystem.py <<'PY'
#!/usr/bin/env python3

import struct
import sys
from pathlib import Path

PREFIXES = (
    b"_ZNSt10filesystem",
    b"_ZNKSt10filesystem",
)

STV_MASK = 0x03
STV_HIDDEN = 0x02
SHN_UNDEF = 0

if len(sys.argv) != 2:
    raise SystemExit(f"Usage: {sys.argv[0]} ELF_FILE")

path = Path(sys.argv[1])
data = bytearray(path.read_bytes())

if data[:4] != b"\x7fELF":
    raise SystemExit("Not an ELF file")
if data[4] != 2:
    raise SystemExit("Expected a 64-bit ELF file")

if data[5] == 1:
    endian = "<"
elif data[5] == 2:
    endian = ">"
else:
    raise SystemExit("Unknown ELF byte order")

e_shoff = struct.unpack_from(endian + "Q", data, 0x28)[0]
e_shentsize = struct.unpack_from(endian + "H", data, 0x3A)[0]
e_shnum = struct.unpack_from(endian + "H", data, 0x3C)[0]
e_shstrndx = struct.unpack_from(endian + "H", data, 0x3E)[0]

if e_shentsize < 64:
    raise SystemExit(f"Unexpected section-header size: {e_shentsize}")


def section_header(index):
    offset = e_shoff + index * e_shentsize
    return struct.unpack_from(endian + "IIQQQQIIQQ", data, offset)


def cstring(blob, offset):
    end = blob.find(b"\0", offset)
    if end < 0:
        raise ValueError("Unterminated string")
    return blob[offset:end]


shstr = section_header(e_shstrndx)
section_names = bytes(data[shstr[4]:shstr[4] + shstr[5]])
sections = []

for index in range(e_shnum):
    header = section_header(index)
    sections.append({
        "name": cstring(section_names, header[0]),
        "offset": header[4],
        "size": header[5],
        "link": header[6],
        "entsize": header[9],
    })

dynsym = next((s for s in sections if s["name"] == b".dynsym"), None)
if dynsym is None:
    raise SystemExit("No .dynsym section found")
if dynsym["entsize"] != 24:
    raise SystemExit(f"Unexpected ELF64 dynamic-symbol entry size: {dynsym['entsize']}")

dynstr = sections[dynsym["link"]]
dynstr_data = bytes(data[dynstr["offset"]:dynstr["offset"] + dynstr["size"]])
patched = []

for index in range(dynsym["size"] // dynsym["entsize"]):
    entry_offset = dynsym["offset"] + index * dynsym["entsize"]
    st_name = struct.unpack_from(endian + "I", data, entry_offset)[0]
    st_other = data[entry_offset + 5]
    st_shndx = struct.unpack_from(endian + "H", data, entry_offset + 6)[0]

    if st_name >= len(dynstr_data):
        continue

    name = cstring(dynstr_data, st_name)
    if not name.startswith(PREFIXES) or st_shndx == SHN_UNDEF:
        continue

    if (st_other & STV_MASK) == STV_HIDDEN:
        continue

    data[entry_offset + 5] = (st_other & ~STV_MASK) | STV_HIDDEN
    patched.append(name)

if not patched:
    raise SystemExit("No defined, non-hidden std::filesystem dynamic symbols found")

path.write_bytes(data)
print(f"Patched file: {path}")
print(f"Symbols changed to HIDDEN: {len(patched)}")
PY

Create a fresh working copy and patch it:

python3 -m py_compile /tmp/hide-proresraw-filesystem.py

cp \
  /opt/resolve-disabled/libProResRAW.so.unmodified \
  /tmp/libProResRAW.so.hidden-fs

python3 /tmp/hide-proresraw-filesystem.py \
  /tmp/libProResRAW.so.hidden-fs

Validate that the filesystem symbols are hidden and the required ProRes RAW API remains exported:

readelf --dyn-syms --wide /tmp/libProResRAW.so.hidden-fs \
  | grep -E '_ZNK?St10filesystem' \
  | grep -v ' HIDDEN ' \
  || echo "All matching filesystem definitions are HIDDEN"

nm -D --defined-only /tmp/libProResRAW.so.hidden-fs \
  | grep ' PRRawDestroyOpenCLProcessor$'

Install the patched library:

sudo install -o root -g root -m 0644 \
  /tmp/libProResRAW.so.hidden-fs \
  /opt/resolve/libs/libProResRAW.so

7. Start Resolve

unset LD_PRELOAD
unset LD_LIBRARY_PATH
/opt/resolve/bin/resolve

In DaVinci Resolve > Preferences > System > Memory and GPU, select:

• GPU processing mode: OpenCL
• GPU selection: Auto, or Manual with AMD Radeon Graphics selected

Save and restart Resolve.

8. Convert unsupported H.264/H.265/AAC media when needed

Resolve Free on Linux commonly cannot use H.264/H.265 media, and AAC can also be unsupported. Affected files may show black thumbnails and refuse to enter a timeline. Convert them to DNxHR with PCM audio.

Enter the directory containing the source videos:

cd "/path/to/source/videos"

Batch-convert supported input containers into a dedicated absolute output directory:

input_dir="$PWD"
output_dir="$input_dir/ResolveMedia"
mkdir -p "$output_dir"

find "$input_dir" -maxdepth 1 -type f \
  \( -iname '*.mp4' -o -iname '*.mkv' -o -iname '*.mov' \) \
  -print0 |
while IFS= read -r -d '' file; do
  name=$(basename "${file%.*}")
  output="$output_dir/${name}-resolve.mov"

  ffmpeg \
    -nostdin \
    -hide_banner \
    -i "$file" \
    -map 0:v:0 \
    -map '0:a?' \
    -map_metadata 0 \
    -c:v dnxhd \
    -profile:v dnxhr_sq \
    -pix_fmt yuv422p \
    -c:a pcm_s16le \
    "$output"
done

Import the converted files from ResolveMedia/.

Rollback

Restore the unmodified library with:

sudo cp -a \
  /opt/resolve-disabled/libProResRAW.so.unmodified \
  /opt/resolve/libs/libProResRAW.so

References

• AMD: Install Radeon software for Linux with ROCm
• AMD: ROCm installation and GPU permissions
• Blackmagic Design: DaVinci Resolve download