DaVinci Resolve 20 - NVidia Bluefin DX

Bluefin
1

Tried to get the Latest DaVinci Resolve (free & studio) running on Bluefin DX (nvidia version) and ran into a bunch of issues.

Not sure if I did something to ‘bork’ my bluefin install (I don’t think so, as I run bluefin on both my laptop & desktop machines and they both run into the same problems.)

Seems that some of Resolve is using a very specific or limited set of TensorRT libraries, that seem to be only in the Rocky Linux 8.6 repos (and probably the other Centos ‘variants’)

Anyway, I sat down with Gemini 2.5 pro and had it help me work my way through a few installations (fedora 41, ubuntu 22.04, using the ujust installer, but it always ended with the CUDA libraries disappearing (fixable with a script) and the AI features (studio version only) crashing Davinci.

In the end it required I use the Rocky Linux 8.6 container and have it install it’s own TensorRT libraries in the container instead of relying on the HOST version.

Use at your own risk, I haven’t fully tested the results, but it seems to have everything working so far.

I tried to keep Gemini informed of my progress at every step of the way so it could write a guide at the end.

So here is that guide. Hope it helps someone.

Efficient Guide: Installing DaVinci Resolve Studio 20b3 on Rocky Linux 8.6 Distrobox (NVIDIA, CUDA, AI, and Audio Setup)

Based on a successful setup as of May 18, 2025

Introduction:
This guide provides an efficient, step-by-step approach to installing DaVinci Resolve Studio 20b3 within a Rocky Linux 8.6 Distrobox container. It’s designed for users with an NVIDIA GPU on a host system (like Fedora/Bluefin Linux running PipeWire for audio) who want to enable CUDA acceleration, AI features, and proper audio output.

Prerequisites:

  • A host Linux system with Distrobox installed.
  • NVIDIA GPU with proprietary drivers correctly installed and working on the host.
    • (This guide was developed with host driver 570.144 supporting CUDA 12.8. Adjust CUDA library versions if your host driver differs significantly).
  • DaVinci Resolve Studio Linux installer (.run file) downloaded from the Blackmagic Design website.

Part 1: Distrobox Container Setup

  1. Create the Distrobox Container:
    Open a terminal on your host system.

    distrobox-create -i rockylinux:8.6 -n ResolveRocky --nvidia --home /var/home/YOUR_USERNAME/Documents/Distroboxes/ResolveRocky

    (Replace YOUR_USERNAME with your actual username and adjust the --home path if desired for storing Resolve’s library and cache.)

  2. Enter the Container:

    distrobox-enter ResolveRocky

  3. Initial System Update & Essential Tools:
    Once inside the ResolveRocky container:

    sudo dnf update -y
sudo dnf install -y vim dnf-plugins-core # Or your preferred text editor

Part 2: Enabling Necessary Repositories

Proactively enable all repositories needed for dependencies.

  1. Enable PowerTools (CRB) Repository:

    sudo dnf config-manager --set-enabled powertools

    (On some RHEL derivatives, this might be crb. powertools is standard for Rocky Linux.)

  2. Install and Enable EPEL Repository:

    sudo dnf install -y epel-release

  3. Add NVIDIA CUDA Repository for RHEL8/Rocky8:

    sudo dnf config-manager --add-repo [https://developer.download.nvidia.com/compute/cuda/repos/rhel8/x86_64/cuda-rhel8.repo](https://developer.download.nvidia.com/compute/cuda/repos/rhel8/x86_64/cuda-rhel8.repo)

  4. Refresh DNF Cache:

    sudo dnf clean all
sudo dnf makecache

Part 3: Installing Core System, Resolve, Audio & NVIDIA Dependencies

Install dependencies identified through previous troubleshooting in a more consolidated manner.

  1. Essential Resolve Installer Dependency:

    sudo dnf install -y fuse-libs

  2. Common DaVinci Resolve System Dependencies:
    This list is based on common requirements and issues encountered:

    sudo dnf install -y \
    alsa-lib apr apr-util fontconfig freetype libglvnd \
    libglvnd-egl libglvnd-glx libglvnd-opengl librsvg2 \
    libXcursor libXfixes libXi libXinerama libxkbcommon-x11 \
    libXrandr libXrender libXtst libXxf86vm mesa-libGLU mtdev \
    pulseaudio-libs xcb-util xcb-util-cursor xcb-util-image \
    xcb-util-keysyms xcb-util-renderutil xcb-util-wm

    (Note: xcb-util-cursor will be pulled from the EPEL repository you enabled.)

  3. Audio Setup & Troubleshooting Packages:

    • pulseaudio-utils: For pactl (diagnostics) and paplay (testing).
    • alsa-utils: For alsamixer, aplay, and speaker-test.
    • alsa-plugins-pulseaudio: Crucial for routing ALSA audio from applications (like Resolve, if it uses ALSA) to the host’s PipeWire via PulseAudio emulation.
    sudo dnf install -y pulseaudio-utils alsa-utils alsa-plugins-pulseaudio

  4. OpenCL ICD Loader:
    For OpenCL functionality within Resolve.

    sudo dnf install -y ocl-icd

  5. Container-Native CUDA Toolkit Runtime Libraries:
    Install CUDA runtime libraries compatible with your host driver’s CUDA capability (e.g., 12.8) and Rocky 8.6’s GLIBC. Do NOT install full NVIDIA driver packages here, as they will conflict with the host driver passthrough.

    # For CUDA 12.8 (adjust version numbers if your host CUDA capability differs significantly)
sudo dnf install -y cuda-cudart-12-8 cuda-libraries-12-8 cuda-nvrtc-12-8

    (These packages provide libcudart.so, libcublas.so, libnvrtc.so, etc., without the conflicting driver files.)

  6. Container-Native cuDNN Libraries (for AI Features):
    Install cuDNN compatible with your installed CUDA toolkit version (e.g., CUDA 12.x).

    # For CUDA 12.x, this installs cuDNN 9. Adjust if different versions are shown/needed.
sudo dnf install -y libcudnn9-cuda-12.x86_64 libcudnn9-devel-cuda-12.x86_64

    (The -devel package helps ensure proper symlinks like libcudnn.so are created.)

  7. Update Linker Cache:
    After installing all these new libraries:

    sudo ldconfig

  8. Persistent NVIDIA Library Symlink Fix (.bashrc):
    To ensure core NVIDIA driver libraries (libcuda.so, libnvcuvid.so) passed from the host are correctly linked every time you start the container:

    • Edit ~/.bashrc in the container: vim ~/.bashrc
    • Add the following script to the end of the file:
      # --- Distrobox NVIDIA Library Fix (for .bashrc) ---
NEEDS_LDCONFIG_CHECK=0

fix_nvidia_symlink() {
    local link_name="$1"    # e.g., /usr/lib64/libcuda.so
    local target_name="$2"  # e.g., /usr/lib64/libcuda.so.1

    # Check if target actually exists (it should be provided by host driver passthrough)
    if [ ! -e "${target_name}" ]; then
        # echo "NVIDIA FIX: Target ${target_name} for symlink ${link_name} not found. Skipping." # Uncomment for debug
        return 1 # Skip if target doesn't exist
    fi

    # If symlink exists but is broken, or is an empty file, or doesn't exist at all
    if { [ -L "${link_name}" ] && [ ! -e "${link_name}" ]; } || \
       { [ -f "${link_name}" ] && [ ! -s "${link_name}" ]; } || \
       [ ! -e "${link_name}" ]; then
        if [ -L "${link_name}" ] && [ ! -e "${link_name}" ]; then
            echo "NVIDIA FIX: Fixing broken ${link_name} symlink..."
        elif [ -f "${link_name}" ] && [ ! -s "${link_name}" ]; then
            echo "NVIDIA FIX: Fixing empty ${link_name}..."
        elif [ ! -e "${link_name}" ]; then
            echo "NVIDIA FIX: Creating missing ${link_name} symlink..."
        fi
        sudo rm -f "${link_name}" # Remove if it's a broken link or empty file
        sudo ln -sf "${target_name}" "${link_name}" && NEEDS_LDCONFIG_CHECK=1
    # else
        # echo "NVIDIA FIX: ${link_name} seems OK." # Uncomment for debug
    fi
}

fix_nvidia_symlink "/usr/lib64/libcuda.so" "/usr/lib64/libcuda.so.1"
fix_nvidia_symlink "/usr/lib64/libnvcuvid.so" "/usr/lib64/libnvcuvid.so.1"
# Add other libraries if needed e.g.:
# fix_nvidia_symlink "/usr/lib64/libnvidia-encode.so" "/usr/lib64/libnvidia-encode.so.1"

if [ "$NEEDS_LDCONFIG_CHECK" -eq 1 ]; then
    echo "NVIDIA FIX: Running sudo ldconfig due to library fixes..."
    sudo ldconfig
fi
unset NEEDS_LDCONFIG_CHECK
# --- End Distrobox NVIDIA Library Fix ---
    • Save the file. To apply it to the current session: source ~/.bashrc (or exit and re-enter the container).

Part 4: Installing DaVinci Resolve Studio

  1. Navigate to your DaVinci Resolve Studio Installer:
    Ensure the downloaded .run file (e.g., DaVinci_Resolve_Studio_20.0b3_Linux.run) is accessible from within the container (e.g., in your container’s home directory or a mounted directory). Make it executable:

    chmod +x ./DaVinci_Resolve_Studio_*.run

  2. Run the Installer:

    sudo ./DaVinci_Resolve_Studio_20.0b3_Linux.run -i

    (The -i flag attempts a more automated install after initial confirmation. Omit it to see all prompts.) Resolve will be installed to /opt/resolve/.

Part 5: Post-Installation Configuration and Checks

  1. Desktop Integration Issues (Optional Fix):
    The Resolve installer might show errors about xdg-icon-resource, xdg-mime, or gtk-update-icon-cache not being found. These affect icons and file associations but not core functionality. To fix:

    sudo dnf install -y xdg-utils gtk3

  2. Launch DaVinci Resolve Studio:
    Ensure your .bashrc script has run (e.g., by re-entering the container).

    /opt/resolve/bin/resolve

  3. Activation: Enter your DaVinci Resolve Studio license key or connect your USB dongle when prompted.

  4. Resolve Preferences - GPU:

    • Go to DaVinci Resolve → Preferences → System → Memory and GPU.
    • Ensure “GPU processing mode” is set to CUDA.
    • Your NVIDIA GPU should be listed and checked.
    • Set “AI Processing Mode” to CUDA if available.

  5. Resolve Preferences - Audio I/O:

    • Go to DaVinci Resolve → Preferences → System → Video and Audio I/O.
    • “I/O Engine” should be System Audio.
    • “Output device” should be Default.
    • “Automatic speaker configuration” can be checked.

  6. Audio Output Verification:

    • Play a clip with audio in Resolve. You should hear it on your host’s default audio output.
    • If no audio:
      • Verify the default audio output device on your Fedora host (GNOME/KDE Sound Settings or pavucontrol on host). Ensure it’s set to the device you’re listening on (e.g., “Line Out - Built-in Audio” or your desired HDMI output). The pactl info command inside the container shows what PipeWire is reporting as the default to the container.
      • Inside the container, test with speaker-test -t wav -c 2 -D default. If this works, Resolve should too. If speaker-test also fails (after installing alsa-plugins-pulseaudio), use pavucontrol on the host (install with sudo dnf install pavucontrol on host) to check the “Playback” tab for streams from the container and ensure they are not muted and are routed to the correct host output device.

  7. AI Features Test:
    Thoroughly test AI-powered tools (Magic Mask, Voice Isolation, Speed Warp, AI transcription, Depth Map, etc.) to confirm stability.

Part 6: Understanding Common Installation Challenges & Linux Support Notes

This section explains some of the hurdles encountered and offers perspective on DaVinci Resolve’s Linux support.

1. CUDA Detection Issues (Losing CUDA on Restart):

  • Symptom: Resolve defaults to OpenCL or shows no GPU after a container restart, even if CUDA was working previously.
  • Likely Cause: The primary issue is how Distrobox (and similar containerization tools) handles the passthrough of NVIDIA driver components from the host. Core libraries like libcuda.so and libnvcuvid.so inside the container can be stubs, empty files, or incorrect symlinks that are reset or improperly established on container startup. While the host driver files are present, Resolve can’t connect to them correctly through these “interface” libraries in the container’s standard paths.
  • Solution Implemented: The .bashrc script runs on container entry, verifies these critical symlinks, and re-links them to the correct .so.1 versions (which are part of the host driver passthrough). This ensures Resolve can consistently find the necessary NVIDIA driver APIs.

2. AI Feature Instability/Crashes (cuDNN/TensorRT Dependencies):

  • Symptom: DaVinci Resolve Studio crashes, or AI-powered features (Magic Mask, Voice Isolation, etc.) fail to initialize or run.
  • Likely Cause: These advanced features depend heavily on specific versions of NVIDIA’s deep learning libraries, primarily cuDNN and sometimes TensorRT. For these to work, they must be:
    • Compatible with the CUDA version supported by your host NVIDIA driver (CUDA 12.8 in this case).
    • Compatible with the specific version of DaVinci Resolve Studio.
    • Compiled against a GLIBC version (and other system libraries) compatible with the container’s OS (Rocky Linux 8.6 uses GLIBC 2.28). If Resolve tries to use versions of these libraries bundled with it (if any) that were compiled for a different Linux distribution (e.g., one with a newer GLIBC), or if the system-installed versions are missing or incompatible, it will lead to issues.
  • Solution Implemented: We installed libcudnn9 (and its devel package for proper symlinking) from the NVIDIA CUDA repository specifically built for RHEL8/Rocky8. This provides versions of the AI libraries compatible with both the host’s CUDA capabilities and the container’s OS environment. TensorRT was noted as a potential next step if cuDNN alone wasn’t sufficient for all AI features.

3. Audio Output Issues (Container to Host):

  • Symptom: Resolve’s audio meters show activity, but no sound is heard on the host system.
  • Likely Cause:
    • Incorrect Host Default Output: The host’s sound system (PipeWire on Fedora 42) might be routing audio to an unintended output device (e.g., an HDMI monitor with no speakers or volume down), while the user expects sound from headphones or main analog speakers.
    • ALSA to PulseAudio/PipeWire Bridging: Resolve, even when set to “System Audio,” might attempt to use the ALSA backend. If ALSA applications within the container aren’t properly configured to route their audio to the host’s PulseAudio-compatible server (which PipeWire emulates), the audio signal won’t reach the host.
  • Solution Implemented:
    • First, verifying and setting the correct default audio output device on the host system.
    • Second, installing the alsa-plugins-pulseaudio package inside the container. This package provides a crucial plugin that allows ALSA applications to transparently send their audio to the PulseAudio server, ensuring proper routing to PipeWire on the host.

4. General Dependency Challenges & Packaging Quirks:

  • Symptom: The Resolve installer complains about missing libraries, or the application fails to start due to missing shared object (.so) files.
  • Likely Cause: DaVinci Resolve is a complex professional application with numerous dependencies. Linux distributions often package libraries with slightly different names or place them in different standard locations. The Resolve installer’s dependency checks might be tailored for specific distributions (like CentOS 7, its official recommendation for a long time) and may not perfectly align with others (like Rocky Linux 8.6, especially within a containerized environment). This often requires manually identifying and installing the correct packages, sometimes from various repositories (base, appstream, powertools/CRB, EPEL).
  • Solution Implemented: We systematically identified missing packages using installer errors and DNF’s provides and search capabilities. We then enabled the necessary repositories (PowerTools, EPEL) to install these dependencies.

Commentary on DaVinci Resolve Studio’s Linux Support:

  • Your Perspective (as understood): It seems DaVinci Resolve’s Linux support is becoming increasingly specific, demanding very particular library versions and configurations. This can make it challenging to run on distributions not officially certified by Blackmagic Design or within containerized setups, giving an impression of decreasing flexibility.

  • My Take:

    • Professional Application Demands: DaVinci Resolve is a high-performance, professional-grade application. To achieve the stability and performance required, it often needs to interface closely with specific versions of system drivers (especially NVIDIA) and specialized libraries (CUDA, cuDNN, TensorRT). This tight coupling is common for software that pushes hardware to its limits.
    • Official Support vs. Community Efforts: Blackmagic Design officially supports a limited range of Linux distributions (historically CentOS, with Rocky Linux and AlmaLinux now being common community-supported alternatives due to their RHEL-base). This allows for focused testing and certification. When users venture outside these, like running on Fedora or within containers, they are essentially navigating unsupported configurations where more manual intervention is expected.
    • The Evolving Tech Stack: As Resolve incorporates newer technologies (e.g., more advanced AI, new CUDA features), its dependency on the latest compatible versions of these specialized libraries naturally increases. The challenge isn’t necessarily that Resolve is becoming “less flexible” intentionally, but rather that the underlying technology stack it leverages (NVIDIA’s drivers, CUDA, AI libraries) has its own complex compatibility matrix. The diversity of the Linux ecosystem (different GLIBC versions, library paths, kernel versions across distributions) makes universal out-of-the-box support for such a demanding application very difficult.
    • Containerization - A Double-Edged Sword: While containers add a layer of abstraction that can cause initial setup hurdles (like the NVIDIA library symlink issues or driver passthrough nuances), they also offer the potential to create a highly controlled and reproducible environment tailored to Resolve’s specific needs once configured correctly. This can be a boon for consistency once the setup is mastered.
    • The Path Forward: For users on non-officially-supported distributions or those using advanced setups like Distrobox, a degree of technical understanding and willingness to troubleshoot dependencies will likely remain necessary. The Linux community is resourceful in finding solutions, as demonstrated by our process. Blackmagic’s support for newer Enterprise Linux derivatives is a positive sign, but the inherent complexity of matching a professional application to a diverse and rapidly evolving OS landscape means “plug-and-play” on every Linux variant is a high bar. The detailed requirements are a reflection of ensuring performance and stability where possible.

Final Reminders:

  • This guide reflects a specific successful setup. Your host system, driver versions, or minor updates to Resolve/Distrobox might require slight adjustments.
  • The .bashrc script is essential for maintaining NVIDIA library links in this Distrobox setup.
  • Always ensure your host system’s default audio output is correctly configured.
  • Consider backing up your Resolve project libraries and databases from the container’s dedicated home directory.

This streamlined guide should help achieve a working installation more directly. Good luck!

7 Likes
2

just a note for people who don’t need the nvidia gpu and AI integration, installing Davinci Resolve can be as straightforward as:

Download the linux installer from Black Magic Design website

They require filling out a form for user info and intended usage before providing download link.

Save the zip, then in terminal:

ujust install-resolve

…and follow the prompts.

1 Like
3

Awesome contribution!

But @Matt_Wilkie is right. The ujust install-resolve command will automate creating a distrobox for you.

If you are curious about what that command does …

less -p install-resolve /usr/share/ublue-os/just/30-distrobox.just

But thanks for the post!

kudos

4

That was the 1st thing I tried.

Remember, I am trying out the Davinci Resolve Studio 20b3 on Bluefin (Fedora 42) so things are not the same as they were with Studio 19 and Fedora 41.

I think this is because Blackmagic is in the middle of a code rewrite and it seems they are creating new AI libraries for their newer AI features (for Linux I think this is especially ‘critical’ as they are creating them for Rocky Linux 8.6, so I don’t know how much effort there will be in moving them to other distros (the Rock Linux 8.6 versions use a version ‘9’ of some specific nvidia libraries … I don’t remember which ones off the top of my heard, I’ll go look later and make a note of it here, but I read something somewhere in my research that implied the lastest version 8.x of these same libraries might be able to support the new AI features, but that was just something I read ‘in passing’ and may not have been true …so anyway, the ‘trick’ is to get the new libraries that work in Rocky Linux 8.6 to be accessible on other Linux distros.)

You probably will even be able to use Studio as long as you don’t try to use some of the newer AI feature (in which case if you do, Studio will probably crash.)

It may even be that the Free version of Resolve 20 beta will work with no issues, since I don’t think it has access to the new AI features anyway.)

I would really recommend anyone using Studio until the final release, as who knows what other changes are going to be made that will break the Linux install.

Anyway, I see there’s a 20b4 just release … time to snapshot my system and give that a go, see what problems are fixed or newly created.

1 Like
5

Thank you for the amazing guide. I’m running 19.1 on a Dell G16 7630 with iGPU and 4070 dGPU. Using your guide, I was finally able to get DRS to boot and use CUDA instead of OpenCL. The problem I’m running into now is loading any video anywhere in DRS results in an error: “Your GPU memory is full. Try reducing the timeline resolution or the number of connectors.”

The dGPU is manually selected in settings. And nvidia-smi shows only 541MB of 8GB GPU RAM in use. Where might I start looking to diagnose and fix this problem? I appreciate any guidance you can provide.