# DaVinci Resolve in distrobox

Two images built from the same `Dockerfile`, pushed to a private registry,
used via distrobox:

- `davinci-amd` — DaVinci Resolve + ROCm + Intel `intel-compute-runtime`,
  for AMD/Intel GPUs
- `davinci-nvidia` — DaVinci Resolve only; the NVIDIA driver/toolchain is
  provided by the host

Registry: `docker.slambin.fr`. Files: `Dockerfile`, `davinci-dependencies`
(package list), `davinci-run` (in-image launcher).

This setup is a direct adaptation of
[zelikos/davincibox](https://github.com/zelikos/davincibox) — same base
image, same dependency list, same install flags — with one change: Resolve
is baked into the image at build time instead of being installed into the
box afterwards, to match this repo's "build once, push" convention. See
`CLAUDE.md` for what was changed and why.

Both `amd` and `nvidia` targets have been build-tested end to end (Docker
Desktop/WSL2, real `DaVinci_Resolve_21.1_Linux.run`) — dependency install,
the silent Resolve install, and the patchelf fix all completed cleanly, and
`ldd` on the installed binary shows no missing libraries. Not yet tested:
an actual `distrobox create` + GUI launch on real Linux/GPU hardware (see
`CLAUDE.md` for the full breakdown).

> DaVinci Resolve binaries get baked into these images from your own
> Blackmagic Design download. Keep the registry **private** — never push
> these images publicly. Not affiliated with Blackmagic Design.

---

## Prerequisites

- The DaVinci Resolve (or DaVinci Resolve Studio) Linux `.run` installer
  from [Blackmagic's site](https://www.blackmagicdesign.com/products/davinciresolve),
  unzipped, placed next to the `Dockerfile` (the download is a `.zip`
  containing the `.run` — `unzip DaVinci_Resolve_*_Linux.zip` first).
- Your host user should be in the `render` and `video` groups for GPU
  device access: `sudo usermod -aG render,video "$USER"` (log out/in after).
- NVIDIA only: [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html)
  installed on the host (see "NVIDIA gotcha" below).

## Build & push

```bash
REGISTRY=docker.slambin.fr
VERSION=21.1
INSTALLER=DaVinci_Resolve_21.1_Linux.run

for target in amd nvidia; do
    podman build -f Dockerfile \
      --build-arg "RESOLVE_INSTALLER=${INSTALLER}" \
      --target "${target}" \
      -t "${REGISTRY}/davinci-${target}:${VERSION}" \
      -t "${REGISTRY}/davinci-${target}:latest" .
    podman push "${REGISTRY}/davinci-${target}:${VERSION}"
    podman push "${REGISTRY}/davinci-${target}:latest"
done
```

## Install / run

```bash
# AMD / Intel
distrobox create \
  --name davinci \
  --image docker.slambin.fr/davinci-amd:latest \
  --additional-flags "--hostname davinci-resolve"

# NVIDIA (see gotcha below re: --nvidia vs CDI)
distrobox create \
  --name davinci \
  --image docker.slambin.fr/davinci-nvidia:latest \
  --nvidia \
  --additional-flags "--hostname davinci-resolve"
```

Then:

```bash
distrobox enter davinci
davinci-run
```

### NVIDIA gotcha (unverified)

Houdini's NVIDIA variant just needs `distrobox --nvidia` (host driver files
bind-mounted, enough for GL/Vulkan viewport rendering). DaVinci Resolve
needs full CUDA/OpenCL/NVENC, and upstream davincibox's README documents
using the **NVIDIA Container Toolkit + CDI** route instead:

```bash
distrobox create \
  --name davinci \
  --image docker.slambin.fr/davinci-nvidia:latest \
  --additional-flags "--device nvidia.com/gpu=all"
```

which requires `nvidia-container-toolkit` set up on the host (already the
case on Universal Blue images; see NVIDIA's own install guide otherwise).
Whether plain `--nvidia` is actually enough has not been tested here — try
it first since it's simpler, fall back to the CDI form above if Resolve
reports something like "Unsupported GPU processing mode" on launch.

## App menu entry (icon, no terminal)

Resolve ships its own `.desktop` files and icons under
`/opt/resolve/share` and `/opt/resolve/graphics` — no need to write one by
hand:

```bash
distrobox enter davinci
mkdir -p ~/.local/share/applications
cp /opt/resolve/share/*.desktop ~/.local/share/applications
rm ~/.local/share/applications/DaVinciResolveInstaller.desktop
sed -i 's/RESOLVE_INSTALL_LOCATION/\/opt\/resolve/' \
    ~/.local/share/applications/{blackmagicraw*,DaVinci*}.desktop
sed -i "s,Exec=,Exec=distrobox enter -n davinci -- /usr/local/bin/davinci-run ," \
    ~/.local/share/applications/{blackmagicraw*,DaVinci*}.desktop
distrobox-export --app "$HOME/.local/share/applications/DaVinciResolve.desktop"
```

(Adapted from davincibox's `add-davinci-launcher` script — see CLAUDE.md.)

## Known gotchas (from upstream, not yet hit here ourselves)

- **No audio**: Resolve uses ALSA via the `pipewire-alsa` plugin baked into
  the image. If your host doesn't run PipeWire, swap it inside the box:
  `sudo dnf remove pipewire-alsa && sudo dnf install alsa-plugins-pulseaudio`.
- **Codecs**: the free version's codec support is limited — this is a
  Blackmagic licensing limitation, not something this image can fix.
- **Studio + USB dongle**: needs a udev rule on the host to let the
  container see the license dongle. See
  [davincibox's README](https://github.com/zelikos/davincibox#davinci-resolve-studio-crashes-on-checking-licences)
  if you hit "Checking Licences..." crashes.