# DaVinci Resolve - Intel Arc Omarchy

Install [DaVinci Resolve](https://www.blackmagicdesign.com/products/davinciresolve) on [Omarchy](https://omarchy.com) (Arch Linux + Hyprland) with **Intel Arc** GPU support — Alchemist (Arc Axxx, A770), Battlemage (B580/B570), and Panther Lake Xe3-LPG iGPUs (Arc B360/B370/B380/B390 in Core Ultra 300).

Adapted from the NVIDIA variant. Handles ABI-safe library replacement, RPATH patching, the OpenCL/Level Zero stack, GPU pinning by PCI BDF, the DeckLink → ALSA audio default, and the `snd-aloop` render-blocker fix.

> **Support caveat**
> Blackmagic does **not** officially support Intel GPUs on Linux. With `intel-compute-runtime` installed the Arc shows up as an OpenCL device and editing/playback/transcode generally work, but Neural Engine, Fairlight FX, noise reduction, and some effects may fall back to CPU or fail. Treat this as community/experimental — not a supported configuration.

## Requirements

- **OS**: [Omarchy](https://omarchy.com) (Arch Linux + Hyprland)
- **GPU**: Intel Arc on the `xe` driver
  - Alchemist Xe-HPG dGPU (Arc Axxx, e.g. A770)
  - Battlemage Xe2 dGPU (Arc B580/B570, late 2024)
  - Panther Lake Xe3-LPG iGPU (Core Ultra 300, Jan 2026)
  - Older UHD/Iris on `i915` is detected but not preferred for pinning when an `xe` device is present
- **Kernel**: 6.12+ (Xe driver). 6.19+ recommended for stable Battlemage support
- **Audio stack**: PipeWire + Wireplumber (Omarchy default)
- **Disk space**: ~10 GiB free in `~/Downloads` for extraction (temporary)
- **DaVinci Resolve ZIP**: downloaded from Blackmagic's website

## Quick Start

1. **Download DaVinci Resolve** from [blackmagicdesign.com](https://www.blackmagicdesign.com/products/davinciresolve)
   - Choose "DaVinci Resolve" (free) or "DaVinci Resolve Studio" (paid)
   - Select **Linux** and download the ZIP
   - Save it to `~/Downloads/`

2. **Run the installer**:
```bash
git clone https://git.no-signal.uk/nosignal/DaVinci-Resolve-Intel-Arc-Omarchy.git
cd DaVinci-Resolve-Intel-Arc-Omarchy
chmod +x install-davinci-resolve-intel-arc.sh
./install-davinci-resolve-intel-arc.sh
```

3. **Launch Resolve** from your app menu, or run `resolve-intel-arc`.

## What It Does

### 1. Preflight checks

- Verifies kernel ≥ 6.12 (warns and continues otherwise)
- Greps `lspci` for Intel Arc GPUs
- Picks the newest `DaVinci_Resolve*_Linux.zip` in `~/Downloads/` by mtime
- Refuses to start if `~/Downloads/` has under 10 GiB free

### 2. Installs dependencies

**Build/extraction tools:**

| Package | Purpose |
|---------|---------|
| `unzip` | Extract the Resolve ZIP |
| `patchelf` | RPATH patching of all ELF binaries |
| `libarchive` | Archive handling |
| `desktop-file-utils` | App menu integration |
| `file` | Identify ELF binaries for patchelf |
| `gtk-update-icon-cache` | Refresh hicolor icon cache |

**Runtime dependencies (Intel-specific stack on top of the common set):**

| Package | Purpose |
|---------|---------|
| `libxcrypt-compat` | Legacy `libcrypt.so.1` (Arch moved to v2) |
| `ffmpeg4.4` | Older FFmpeg version Resolve links against |
| `glu` | OpenGL Utility Library |
| `fuse2` | AppImage compatibility layer |
| `mesa` | OpenGL stack (Iris driver) |
| `vulkan-intel` | ANV — Vulkan ICD for Intel |
| `intel-media-driver` | iHD VA-API driver (HW H.264/HEVC/AV1 decode/encode) |
| `intel-compute-runtime` | NEO — OpenCL & Level Zero ICD. **What Resolve actually uses for compute.** |
| `level-zero-loader` | Loader for Intel oneAPI Level Zero |
| `ocl-icd` | Generic OpenCL ICD loader (`libOpenCL.so.1`) |
| `clinfo` | Sanity tool — used post-install to confirm OpenCL visibility |

The script aborts if any of `intel-compute-runtime`, `level-zero-loader`, `ocl-icd`, or `clinfo` failed to install — without them Resolve sees no OpenCL device and crashes with **Unsupported GPU Processing Mode** on first launch.

> Note: `gtk2` is **not** installed. Verified via `ldd` that Resolve 21 doesn't link `libgtk-x11-2.0`; the modern UI is fully Qt. The leftover `gtk2` dep in older install scripts came from the era when Resolve had GTK file dialogs.

### 3. Extracts Resolve

```
ZIP → .run file → squashfs-root (actual application files)
```

Temporary files clean up automatically via an `EXIT` trap.

### 4. ABI-safe library replacement

The same library policy as the NVIDIA variant — these libraries are GPU-agnostic:

| Library | Action | Why |
|---------|--------|-----|
| `libglib-2.0.so` | **Replace** with system | Stable C ABI, safe to swap |
| `libgio-2.0.so` | **Replace** with system | Stable C ABI, safe to swap |
| `libgmodule-2.0.so` | **Replace** with system | Stable C ABI, safe to swap |
| `libc++.so` | **Keep** bundled | C++ ABI mismatch causes crashes |
| `libc++abi.so` | **Keep** bundled | C++ ABI mismatch causes crashes |

### 5. Patches RPATH

Every ELF binary in `/opt/resolve` gets RPATH patched to point at `/opt/resolve/libs/` and the relevant subdirectories (Fusion, BlackmagicRAW, Onboarding, Qt plugins, etc.). Without this, binaries would look for libraries at the original AppImage paths that no longer exist.

### 6. Legacy `libcrypt.so.1` shim

Arch dropped `libcrypt.so.1`. The script ensures `libxcrypt-compat` is present so Resolve's older link continues to resolve.

### 7. Desktop integration

- Installs `.desktop` entries for Resolve, Capture Logs, Control Panels Setup, BlackmagicRAW Player & SpeedTest
- Installs hicolor icons (128/256 px)
- Installs udev rules for Blackmagic capture cards, the Resolve Editor Keyboard, and DaVinci control panels
- Re-points all launchers at the XWayland wrapper (`/usr/local/bin/resolve-intel-arc`)
- Drops a user-level `.desktop` override at `~/.local/share/applications/davinci-resolve-wrapper.desktop` so future system updates don't undo the wrapper

### 8. XWayland wrapper (Intel Arc)

A wrapper script at `/usr/local/bin/resolve-intel-arc`:

- Forces XWayland under Hyprland/Wayland (`QT_QPA_PLATFORM=xcb`)
- Pins `LIBVA_DRIVER_NAME=iHD` for Intel media driver VA-API decode
- Sets `OCL_ICD_VENDORS=/etc/OpenCL/vendors` so the Intel ICD is found
- Clears stale `qtsingleapp-DaVinci*lockfile` files left behind after a crash
- **Pins the GPU by PCI BDF**, not by Level Zero index

#### GPU pinning (BDF-based)

NEO/Level Zero enumerates *every* Intel GPU it supports across both `xe` and `i915` backends, sorted by PCI BDF — but the numeric index is not a reliable function of BDF order. On hybrid Battlemage + iGPU systems, NEO often enumerates the discrete card at index 0 even though its BDF sorts later. The wrapper avoids the indexing trap entirely:

1. Walks `/sys/class/drm/card[0-9]*` and collects every device with vendor `0x8086`
2. **Priority 1**: discrete `xe` device (BDF *not* on bus `00:` — i.e. not an SoC iGPU). This picks Battlemage B580/B570 dGPUs.
3. **Priority 2**: any `xe` device (covers Panther Lake Xe3-LPG iGPU)
4. **Priority 3**: first Intel device (last-resort fallback)
5. Exports the chosen device's BDF as `ZE_AFFINITY_MASK` in `DDDD:BB:DD.F` form (e.g. `0000:03:00.0`) — NEO matches this directly against the device

#### Battlemage OpenCL workaround

Discrete Battlemage Xe2 silicon needs an OpenCL init workaround. The wrapper applies it **only** if `lspci` shows Battlemage **and** the picked BDF is *not* on bus `00:` (so iGPUs are excluded — Intel reuses the "Arc B-series" brand for the Xe3-LPG iGPUs in Panther Lake, and they don't want this debug key):

```bash
export NEOReadDebugKeys=1
export OverrideGpuAddressSpace=48
```

### 9. Audio backend default (DeckLink → ALSA)

Resolve ships with `Local.Audio.Type = DeckLink` in its system-wide config template at `/opt/resolve/share/default-config.dat`. Correct for users with a Blackmagic DeckLink card; aborts on first launch otherwise. The script patches:

- The system template (so future first-launches are correct)
- Any existing user config at `~/.local/share/DaVinciResolve/configs/config.dat`, with a timestamped `.bak.<epoch>` backup

### 10. `snd-aloop` (the actual render-blocker fix)

Resolve's audio engine opens raw ALSA hardware via `snd_pcm_open("hw:%d", ...)` — it never goes through ALSA's plugin layer (`default`/`pulse`/`pipewire`) and it enumerates *every* card under `/dev/snd/controlC[0-32]` looking for a usable PCM. When every real ALSA card is owned/contested by PipeWire's session manager, Resolve loops forever. Symptoms:

- Wireplumber meters "flicker" as Resolve repeatedly opens `controlC*`
- Render sits at "in progress" with growing ETA, no output file
- `ResolveDebug.txt` shows nothing useful
- `strace` shows tens of thousands of `SNDRV_CTL_IOCTL_PCM_INFO` `ENXIO` ioctls per failed render attempt

**The fix**: load the kernel's `snd-aloop` module. PipeWire ignores it (no ACP profile, not auto-acquired), so Resolve can fully own it and the render proceeds. The script:

- `modprobe snd-aloop` for the current session
- Writes `/etc/modules-load.d/snd-aloop.conf` so it autoloads at boot
- Writes a PipeWire loopback bridge at `~/.config/pipewire/pipewire.conf.d/50-resolve-aloop-bridge.conf` so monitor audio routes from the loopback's capture side to the current default sink (without it, Resolve plays back silently — headphone/HDMI sink switching keeps working through the bridge)
- Restarts user PipeWire/Wireplumber so the conf loads immediately

Set `RESOLVE_NO_ALOOP=1` to skip this entirely (useful if you have a dedicated audio interface Resolve already uses cleanly).

### 11. Post-install OpenCL sanity check

Runs `clinfo -l` and reports whether the Intel GPU is visible to the OpenCL stack. If it isn't, Resolve will fall back to CPU.

### 12. Stale-config recovery

Resolve defaults to `GPU Processing Mode = CUDA` on Linux. If a previous launch couldn't find an OpenCL device (e.g. compute runtime was missing the first time), Resolve writes out a config snapshot and segfaults on every subsequent launch — *even after* the OpenCL stack is fixed. The script detects the `Unsupported GPU Processing Mode` marker in `~/.local/share/DaVinciResolve/logs/ResolveDebug.txt` and clears `configs/` and `logs/` to force first-launch onboarding again. **Project databases under `Resolve Disk Database/` and `Resolve Project Library/` are not touched.**

Force a manual reset with `RESOLVE_RESET_CONFIG=1`.

## Files Installed

### Application

| Path | Purpose |
|------|---------|
| `/opt/resolve/` | Main application directory |
| `/opt/resolve/bin/resolve` | Resolve binary |
| `/opt/resolve/libs/` | Bundled libraries (vendor `libc++` kept) |

### Scripts

| Path | Purpose |
|------|---------|
| `/usr/local/bin/resolve-intel-arc` | XWayland wrapper (main launcher) |
| `/usr/bin/davinci-resolve` | Convenience symlink to wrapper |

### Desktop entries

| Path | Purpose |
|------|---------|
| `/usr/share/applications/DaVinciResolve.desktop` | System app menu entry |
| `~/.local/share/applications/davinci-resolve-wrapper.desktop` | User entry (takes priority, survives reinstalls) |

### Icons

| Path | Purpose |
|------|---------|
| `/usr/share/icons/hicolor/128x128/apps/davinci-resolve.png` | App icon |
| `/usr/share/icons/hicolor/256x256/apps/blackmagicraw-player.png` | BMRAW Player icon |

### Hardware support

| Path | Purpose |
|------|---------|
| `/usr/lib/udev/rules.d/99-BlackmagicDevices.rules` | Capture cards |
| `/usr/lib/udev/rules.d/99-ResolveKeyboardHID.rules` | Resolve Editor Keyboard |
| `/usr/lib/udev/rules.d/99-DavinciPanel.rules` | DaVinci control panels |

### Audio

| Path | Purpose |
|------|---------|
| `/etc/modules-load.d/snd-aloop.conf` | Autoload `snd-aloop` at boot |
| `~/.config/pipewire/pipewire.conf.d/50-resolve-aloop-bridge.conf` | Loopback monitor bridge |

## Environment Variables

All optional — set when running the script or the launcher:

| Variable | Effect |
|----------|--------|
| `RESOLVE_FULL_UPGRADE=1` | Run `pacman -Syu` instead of just `-Sy` before installing deps |
| `RESOLVE_NO_ALOOP=1` | Skip the `snd-aloop` setup entirely (use if you have a dedicated audio interface) |
| `RESOLVE_RESET_CONFIG=1` | Force-clear Resolve's `configs/` and `logs/` even if no prior crash is detected |
| `RESOLVE_GPU_BDF=0000:XX:YY.Z` | Manual GPU pinning override (sets `ZE_AFFINITY_MASK`) |
| `RESOLVE_NO_PIN=1` | Disable `ZE_AFFINITY_MASK` pinning — let NEO pick whatever it wants |

Examples:

```bash
# First install on a system that hasn't been pacman-upgraded recently
RESOLVE_FULL_UPGRADE=1 ./install-davinci-resolve-intel-arc.sh

# Skip the audio fix
RESOLVE_NO_ALOOP=1 ./install-davinci-resolve-intel-arc.sh

# Pin to a specific Arc B580 at 04:00.0
RESOLVE_GPU_BDF=0000:04:00.0 resolve-intel-arc
```

## Troubleshooting

### Resolve crashes on launch with "Unsupported GPU Processing Mode"

Either the OpenCL stack isn't visible, or you have a stale config from a previous failed launch.

```bash
# Confirm OpenCL sees the Arc
clinfo -l

# If clinfo lists nothing, check the compute stack
pacman -Q intel-compute-runtime level-zero-loader ocl-icd

# If clinfo is fine but Resolve still crashes, force a config reset
RESOLVE_RESET_CONFIG=1 ./install-davinci-resolve-intel-arc.sh
```

### Render starts but never finishes (no output file, growing ETA)

This is the `snd-aloop` render-blocker. Either you ran with `RESOLVE_NO_ALOOP=1`, or `snd-aloop` failed to load.

```bash
# Confirm the module is loaded
lsmod | grep snd_aloop

# If not, load it manually
sudo modprobe snd-aloop

# And persist it
echo snd-aloop | sudo tee /etc/modules-load.d/snd-aloop.conf
```

### Wrong GPU selected on a hybrid system

Override `ZE_AFFINITY_MASK` directly:

```bash
# Find your Intel GPUs
for d in /sys/class/drm/card[0-9]*; do
  vendor=$(cat "$d/device/vendor" 2>/dev/null)
  [[ "$vendor" == "0x8086" ]] || continue
  echo "$(basename "$(readlink -f "$d/device")") -> $(basename "$d")"
done

# Pin to the right BDF
RESOLVE_GPU_BDF=0000:03:00.0 resolve-intel-arc
```

### Battlemage-specific OpenCL init failures

The wrapper applies `NEOReadDebugKeys=1` + `OverrideGpuAddressSpace=48` automatically when it detects a discrete Battlemage card. If you've manually overridden `RESOLVE_GPU_BDF` to a non-Battlemage BDF, those debug keys aren't set — set them yourself if you actually want them.

### Stale Qt lockfiles after a crash

The wrapper clears `/tmp/qtsingleapp-DaVinci*lockfile` on every launch — but if the wrapper isn't being used (e.g. you ran `/opt/resolve/bin/resolve` directly), clear them manually:

```bash
rm -f /tmp/qtsingleapp-DaVinci*lockfile
```

### Logs

```
~/.local/share/DaVinciResolve/logs/ResolveDebug.txt
```

## Uninstalling

```bash
# Resolve itself
sudo rm -rf /opt/resolve
sudo rm -f /usr/local/bin/resolve-intel-arc /usr/bin/davinci-resolve

# Desktop entries / icons
sudo rm -f /usr/share/applications/DaVinciResolve.desktop \
           /usr/share/applications/DaVinciResolveCaptureLogs.desktop \
           /usr/share/applications/DaVinciControlPanelsSetup.desktop \
           /usr/share/applications/blackmagicraw-player.desktop \
           /usr/share/applications/blackmagicraw-speedtest.desktop \
           /usr/share/icons/hicolor/128x128/apps/davinci-resolve*.png \
           /usr/share/icons/hicolor/256x256/apps/blackmagicraw-*.png
rm -f ~/.local/share/applications/davinci-resolve-wrapper.desktop

# Audio fix (optional — leaving it in place is harmless)
sudo rm -f /etc/modules-load.d/snd-aloop.conf
rm -f ~/.config/pipewire/pipewire.conf.d/50-resolve-aloop-bridge.conf

sudo update-desktop-database 2>/dev/null
sudo gtk-update-icon-cache -f /usr/share/icons/hicolor 2>/dev/null
```

User configs and project databases under `~/.local/share/DaVinciResolve/` are left in place — delete them by hand if you want a fully clean uninstall.

## Related

- [DaVinci-Resolve-Omarchy](https://git.no-signal.uk/nosignal/DaVinci-Resolve-Omarchy) — NVIDIA variant
- [DaVinci-Resolve-AMD-Omarchy](https://git.no-signal.uk/nosignal/DaVinci-Resolve-AMD-Omarchy) — AMD (RDNA 1–4) variant
- [DaVinci-Resolve-Linux-Mint](https://git.no-signal.uk/nosignal/DaVinci-Resolve-Linux-Mint), [DaVinci-Resolve-PopOS](https://git.no-signal.uk/nosignal/DaVinci-Resolve-PopOS), [DaVinci-Resolve-openSUSE-Tumbleweed](https://git.no-signal.uk/nosignal/DaVinci-Resolve-openSUSE-Tumbleweed) — non-Arch installers

## License

MIT — see [LICENSE](LICENSE).