Running Ableton Live 12 on Linux, done rightFaire tourner Ableton Live 12 sur Linux, proprement

This guide turns a real debugging session into a method. Every blocker is shown as symptom → cause → fix, with a note to adapt it to your distro. The point isn't to paste commands blindly — it's to understand the chain, because once you grasp why, you can repair it when things move.

Ce guide transforme un dépannage réel en méthode. Chaque blocage est présenté sous la forme symptôme → cause → solution, avec une note pour l'adapter à ta distribution. L'idée n'est pas de copier des commandes à l'aveugle, mais de comprendre la chaîne — parce que si tu comprends pourquoi, tu sauras réparer quand ça bougera.

The one mental key from start to finish: Ableton is a Windows program. On Linux it runs inside Wine, a compatibility layer that translates Windows calls into Linux ones. Almost every problem lives at the border between that simulated Windows world and your real Linux desktop — the compositor, the audio, the display scaling.

La clé mentale à garder du début à la fin : Ableton est un logiciel Windows. Sous Linux, il tourne dans Wine, une couche de compatibilité qui traduit les appels Windows en appels Linux. Presque tous les problèmes viennent de la frontière entre ce monde Windows simulé et ton vrai bureau Linux (le compositeur, l'audio, l'échelle des écrans).

PrerequisitesPrérequis

The minimum vocabularyLe vocabulaire minimum

Six words show up everywhere. Keep them in mind and the rest reads clearly.

Six mots reviennent partout. Les avoir en tête rend tout le reste limpide.

Part 1Partie 1

Make it run: six display & input blockersLe faire tourner : six blocages d'affichage et d'entrée

Installing Ableton in a bottle is easy. Making it usable — accurate cursor, menus, keyboard, plugin windows — takes understanding six frictions. Almost all are solved by a good environment choice, not by patches.

Installer Ableton dans une bouteille est facile. Le rendre utilisable — souris juste, menus, clavier, fenêtres de plugins — demande de comprendre six frictions. Elles se règlent presque toutes par un bon choix d'environnement, pas par des rustines.

Part 2Partie 2

Windows VST plugins in AbletonLes plugins VST Windows dans Ableton

A big clarification first: yabridge is for your native Linux hosts (Bitwig, Reaper Linux…). It builds .so bridges. But Ableton runs under Wine: it's a Windows program, so it loads the real Windows plugins (.vst3) directly, without yabridge. You just have to show them to it.

Grande clarification d'abord : yabridge, c'est pour tes hôtes Linux natifs (Bitwig, Reaper Linux…). Il crée des ponts .so. Mais Ableton tourne sous Wine : c'est un logiciel Windows, il charge donc directement les vrais plugins Windows (.vst3), sans yabridge. Il suffit de les lui montrer.

Two ways to organize your pluginsDeux façons d'organiser tes plugins

Before wiring anything, pick your organization. Both are valid:

Avant de câbler quoi que ce soit, choisis ton organisation. Les deux sont valables :

The rest of this part only concerns organization B: you then have to show Ableton the plugins that live in other bottles. With organization A, jump straight to the audio part.

Le reste de cette partie ne concerne que l'organisation B : il faut alors montrer à Ableton les plugins qui vivent dans d'autres bouteilles. Avec l'organisation A, tu peux sauter directement à la partie audio.

Pitfall #1: absolutely no symbolic linksLe piège n°1 : surtout pas de liens symboliques

We want to aggregate the plugin folders (one prefix per vendor, in organization B) into the VST3 folder Ableton scans. The reflex would be a symlink… and that's the mistake.

On veut agréger les dossiers de plugins (un préfixe par éditeur, en organisation B) dans le dossier VST3 que scanne Ableton. Le réflexe serait un lien symbolique… et c'est l'erreur.

The fix: recreate the tree with hard links (cp -al). You get real folders and shared files (same inodes) — so almost zero disk space, and Ableton sees them as real.

La solution : recréer l'arborescence avec des liens durs (cp -al). On obtient de vrais dossiers et des fichiers partagés (mêmes inodes) — donc quasiment zéro espace disque consommé, et Ableton les voit comme réels.

# -a preserve everything, -l hard-link the files (no copy)
$ cp -al "$HOME"/WinePrefix/FabFilter/drive_c/.../VST3/FabFilter \
        "$HOME"/WinePrefix/Ableton/drive_c/.../VST3/FabFilter

Pitfall #2: missing shared componentsLe piège n°2 : les composants partagés manquants

Some plugins (Melda, Kilohearts…) fail to load with error 1114. Their init code looks for a shared kernel DLL that lives outside the .vst3 — in ProgramData\<Vendor>, AppData, or even windows\system32.

Certains plugins (Melda, Kilohearts…) échouent au chargement avec erreur 1114. Leur code d'initialisation cherche une DLL noyau partagée qui vit hors du .vst3 — dans ProgramData\<Éditeur>, AppData, ou même windows\system32.

• Diagnose: WINEDEBUG=+loaddll,+module wine regsvr32 /s plugin.vst3 reveals whether it's a missing DLL, a failing DllMain, or a PACE reference (see below).
• Repair: also hard-link, per vendor, the Program Files\<Vendor>, ProgramData\<Vendor>, AppData\…\<Vendor> folders and the vendor DLLs from system32.

• Le diagnostic : WINEDEBUG=+loaddll,+module wine regsvr32 /s plugin.vst3 révèle si c'est une DLL absente, un DllMain qui échoue, ou une référence à PACE (voir plus bas).
• La réparation : lier aussi, par éditeur, les dossiers Program Files\<Éditeur>, ProgramData\<Éditeur>, AppData\…\<Éditeur>, et les DLL vendeur de system32.

iLok / PACE: yes, it worksiLok / PACE : oui, ça marche

To use them, install the PACE Software Manager (the iLok/PACE runtime) into the bottle — but not the latest version, which no longer installs under Wine. Use an earlier release. Once PACE is present, the plugins authorize and load like on Windows.

Pour les utiliser, installe le PACE Software Manager (le runtime iLok/PACE) dans la bouteille — mais pas la dernière version, qui ne s'installe plus sous Wine. Prends une version antérieure. Une fois PACE présent, les plugins s'autorisent et se chargent comme sous Windows.

Part 3Partie 3

Low-latency audio, native to PipeWireL'audio basse latence, natif PipeWire

By default, Ableton under Wine outputs via DirectSound → PulseAudio: it works, but latency is high — painful for recording or playing an instrument. A DAW wants ASIO.

Par défaut, Ableton sous Wine sort le son via DirectSound → PulseAudio : ça marche, mais la latence est élevée — pénible pour enregistrer ou jouer un instrument. Un DAW veut de l'ASIO.

PipeASIO is an ASIO driver that talks directly to PipeWire (no JACK layer in between). Result: low latency, native routing in the PipeWire graph. A more classic alternative: WineASIO + PipeWire's JACK bridge.

PipeASIO est un driver ASIO qui parle directement à PipeWire (pas de couche JACK intermédiaire). Résultat : latence basse, routage natif dans le graphe PipeWire. Alternative plus classique : WineASIO + le pont JACK de PipeWire.

The golden rule: build against the same Wine as the runtimeLa règle d'or : compiler contre le même Wine que le runtime

Three details, learned the hard way, that separate "won't load" from "works":

Trois détails, découverts à la dure, qui font la différence entre « ne charge pas » et « fonctionne » :

• The native half must be named per the runner's convention — here pipeasio64.so, not pipeasio64.dll.so, or Wine won't find it.
• The "fake PE" (pipeasio64.dll) must sit in the prefix's system32: it's it that Wine recognizes as builtin to trigger loading the native half.
• Registration is done in 64-bit: wine64 regsvr32 pipeasio64.dll (the 32-bit regsvr32 fails).

• La partie native doit être nommée selon la convention du runner — ici pipeasio64.so et non pipeasio64.dll.so, sinon Wine ne la trouve pas.
• Le « faux PE » (pipeasio64.dll) doit être placé dans le system32 du préfixe : c'est lui que Wine reconnaît comme builtin pour déclencher le chargement de la partie native.
• L'enregistrement se fait en 64-bit : wine64 regsvr32 pipeasio64.dll (le regsvr32 32-bit échoue).

$ flatpak override --user \
     --filesystem=xdg-run/pipewire-0 com.usebottles.bottles
# then, inside the runner's environment:
$ wine64 regsvr32 /s pipeasio64.dll   # -> "Successfully registered"

In Ableton: Preferences → Audio → Driver Type: ASIO → Audio Device: PipeASIO. Sound then flows straight through PipeWire.

Dans Ableton : Préférences → Audio → Type de pilote : ASIO → Périphérique : PipeASIO. Le son passe alors en direct par PipeWire.

A portable flake.nix (NixOS)Un flake.nix portable (NixOS)

On NixOS, a flake makes the build reproducible and ABI-correct: it uses wineWow64Packages.yabridge, which nixpkgs pins to 9.21 — exactly the version we need. Portable to any NixOS machine.

Sur NixOS, un flake rend le build reproductible et correct côté ABI : il utilise wineWow64Packages.yabridge, que nixpkgs épingle à 9.21 — pile la version qu'il faut. Portable sur toute machine NixOS.

{
  description = "PipeASIO built against Wine 9.21 (yabridge)";
  inputs.nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";

  outputs = { self, nixpkgs }:
    let
      system = "x86_64-linux";
      pkgs   = nixpkgs.legacyPackages.${system};
      # Wine 9.21 in nixpkgs — matches the kron4ek-9.21 runtime (ABI).
      wine   = pkgs.wineWow64Packages.yabridge;
    in {
      packages.${system}.default = pkgs.stdenv.mkDerivation {
        pname = "pipeasio"; version = "1.2.2";
        src = pkgs.fetchFromGitHub {
          owner = "m0n7y5"; repo = "pipeasio";
          rev = "v1.2.2"; sha256 = "…";   # nix will print the hash
        };
        # winegcc/winebuild come from `wine`; Qt6 = optional settings panel
        nativeBuildInputs = [ pkgs.cmake pkgs.ninja pkgs.pkg-config wine
                              pkgs.qt6.wrapQtAppsHook ];
        buildInputs = [ pkgs.pipewire pkgs.qt6.qtbase pkgs.qt6.qtwayland ];
        cmakeFlags = [
          "-DBUILD_TESTS=OFF"
          "-DBUILD_SETTINGS_PANEL=ON"
          # WineDLL.cmake defaults to /usr/include/wine — point it at Nix's:
          "-DWINE_INCLUDE_DIRS=${wine}/include;${wine}/include/wine/windows"
        ];
      };
    };
}

Quick startDémarrage rapide

Step-by-step installInstallation pas à pas

The whole thing, in order. Each step links to the section that explains why. Steps 6–7 are optional.

Tout le montage, dans l'ordre. Chaque étape renvoie à la section qui explique pourquoi. Les étapes 6–7 sont optionnelles.

1. 1

   Install BottlesInstaller Bottles

   flatpak install flathub com.usebottles.bottles

   Works on every distro with Flatpak. Bottles is what makes Ableton's window appear.Fonctionne sur toute distro avec Flatpak. C'est Bottles qui fait apparaître la fenêtre d'Ableton.

2. 2

   Create a bottle with a Wine ≤ 9.21 runnerCréer une bouteille avec un runner Wine ≤ 9.21

   In Bottles: new bottle (type Application) → Preferences → Runners → download a Wine 9.21 build (e.g. kron4ek 9.21 staging) → set it as the bottle's runner.

   Dans Bottles : nouvelle bouteille (type Application) → Préférences → Runners → télécharger un build Wine 9.21 (ex : kron4ek 9.21 staging) → le définir comme runner de la bouteille.

   Why 9.21 → Pourquoi 9.21 → § 02

3. 3

   Force the x11 graphics driverForcer le pilote graphique x11

   wine reg add "HKCU\Software\Wine\Drivers" /v Graphics /t REG_SZ /d "x11" /f

   So the menu bar draws → Pour que la barre de menu s'affiche → § 03

4. 4

   Install Ableton into the bottleInstaller Ableton dans la bouteille

   Download the installer ZIP from ableton.com and extract it — e.g. into the bottle's Downloads folder. Then in Bottles: open the bottle → Install a program → pick Ableton Live → when prompted, point it at the extracted installer .exe. Follow the normal Windows install.

   Télécharger le ZIP de l'installateur depuis ableton.com et l'extraire — par ex. dans le dossier Downloads de la bouteille. Puis dans Bottles : ouvrir la bouteille → Installer un programme → choisir Ableton Live → quand c'est demandé, pointer vers l'.exe de l'installateur extrait. Suivre l'installation Windows classique.

5. 5

   Launch it directlyLe lancer directement no gamescopesans gamescope

   Use the ableton-live launcher (see the scripts section) or Bottles' Run. If dropdown menus look offset, put Ableton on a 100%-scale screen.

   Utiliser le lanceur ableton-live (voir la section scripts) ou le bouton Lancer de Bottles. Si les menus déroulants semblent décalés, mettre Ableton sur un écran échelle 100 %.

   Why not gamescope → Pourquoi pas gamescope → § 04

6. 6

   Expose your Windows pluginsExposer tes plugins Windows optionaloptionnel

   Only if your plugins live in separate bottles. Run link-plugins, then in Live: Preferences → Plug-Ins → Rescan.

   Seulement si tes plugins vivent dans des bouteilles séparées. Lancer link-plugins, puis dans Live : Préférences → Plug-Ins → Rescan.

   How & why → Comment & pourquoi → Part 2

7. 7

   Low-latency audio (PipeASIO)Audio basse latence (PipeASIO) optionaloptionnel

   Build PipeASIO (NixOS flake · Arch paru -S pipeasio · else from source), run install-into-bottles.sh, then in Live: Audio → Driver Type ASIO → PipeASIO.

   Construire PipeASIO (flake NixOS · Arch paru -S pipeasio · sinon depuis les sources), lancer install-into-bottles.sh, puis dans Live : Audio → Type de pilote ASIO → PipeASIO.

   The golden rule → La règle d'or → Part 3

Reference scriptsScripts de référence

The full scripts, ready to adaptLes scripts complets, à adapter

These are the actual scripts from the reference setup (NixOS + Bottles). The paths, the runner name and the Wine user are for that machine — change them for yours. The comments explain each step.

Ce sont les vrais scripts du montage de référence (NixOS + Bottles). Les chemins, le nom du runner et l'utilisateur Wine sont ceux de cette machine — adapte-les à la tienne. Les commentaires expliquent chaque étape.

1 · LauncherLanceur — ableton-live

#!/usr/bin/env bash
# ableton-live — launch Ableton Live 12 directly on the compositor.
# Reference setup: Bottles (flatpak) + a Wine <= 9.21 runner, NO gamescope.
# Adapt RUNNER, the prefix path and EXE_REL to your machine.
set -euo pipefail

BOTTLE_ID="com.usebottles.bottles"
RUNNER="kron4ek-wine-9.21-staging-amd64"      # any Wine <= 9.21 runner
PREFIX="$HOME/WinePrefix/Ableton"
EXE_REL="drive_c/ProgramData/Ableton/Live 12 Standard/Program/Ableton Live 12 Standard.exe"

# Run inside the Bottles flatpak: that is what maps Ableton's window on
# minimal Wayland compositors. Launching the host Wine directly often shows no window.
exec flatpak run --command=bash "$BOTTLE_ID" -c '
  export WINEPREFIX="'"$PREFIX"'"
  export WINEDEBUG=-all
  # Share the pipeasio config with the native settings panel (~/.config/pipeasio):
  export XDG_CONFIG_HOME="$HOME/.config"
  R="$HOME/.var/app/'"$BOTTLE_ID"'/data/bottles/runners/'"$RUNNER"'/bin"
  exec "$R/wine" "$WINEPREFIX/'"$EXE_REL"'"
'

2 · Expose the Windows pluginsExposer les plugins Windows — link-plugins

The centerpiece: it hard-links every plugin (and its support folders) into the bottle. link-plugins --remove undoes it, --remove excepted it is idempotent.

La pièce maîtresse : elle lie en dur chaque plugin (et ses dossiers de support) dans la bouteille. link-plugins --remove annule tout ; sinon c'est idempotent (relançable).

#!/usr/bin/env bash
# link-plugins — expose the Windows plugins listed by `yabridgectl list` to the
# Ableton bottle by recreating the tree with HARD LINKS (cp -al): real folders +
# shared files (~0 disk). Ableton's scanner IGNORES symlinks/junctions, hence cp -al.
#
# It links two things:
#  1) the VST3/VST2 folders  -> C:\Program Files\Common Files\VST3 (and VST2)
#  2) the vendors' SUPPORT folders (e.g. C:\Program Files\MeldaProduction, and shared
#     DLLs under ProgramData / AppData / system32) that some plugins load from a fixed
#     path. Without them -> "missing component" / error 1114. Only folders ABSENT from
#     the Ableton prefix are linked (no clash with Windows/Ableton).
#
# Reversible via a manifest: `link-plugins --remove`. Idempotent: re-run to resync.
set -euo pipefail

PREFIX="$HOME/WinePrefix/Ableton"          # adapt to your Ableton bottle
WINE_USER="${WINE_USER:-$USER}"            # Wine user (often your login; "steamuser" for proton runners)
DRIVEC="$PREFIX/drive_c"
VST3_DST="$DRIVEC/Program Files/Common Files/VST3"
VST2_DST="$DRIVEC/Program Files/Common Files/VST2"
APPDATA="$DRIVEC/users/$WINE_USER/AppData"
MANIFEST="$PREFIX/.plugin-links.manifest"

link_tree() {  # src dst : reversible hard-link copy, recorded in the manifest
  local src="$1" dst="$2"
  rm -rf "$dst"; cp -al "$src" "$dst"
  printf '%s\n' "$dst" >> "$MANIFEST"
}

remove_all() {
  local n=0
  if [ -f "$MANIFEST" ]; then
    while IFS= read -r p; do
      [ -n "$p" ] && [ -e "$p" ] && { rm -rf "$p"; n=$((n+1)); }
    done < "$MANIFEST"
    : > "$MANIFEST"
  fi
  # safety net: remove leftover symlinks/junctions from earlier attempts
  for d in "$VST3_DST" "$VST2_DST"; do
    [ -d "$d" ] && find "$d" -maxdepth 1 -type l -exec rm -f {} + 2>/dev/null || true
  done
  echo "Removed entries: $n"
}

[ "${1:-}" = "--remove" ] && { remove_all; exit 0; }

remove_all >/dev/null
mkdir -p "$VST3_DST" "$VST2_DST"; : > "$MANIFEST"

# 1) VST3 / VST2 plugin folders
plugins=0
while IFS= read -r src; do
  [ -d "$src" ] || continue
  vendor="$(printf '%s' "$src" | sed -E 's#.*/WinePrefix/([^/]+)/drive_c/.*#\1#')"
  case "$src" in
    *VST3*)              link_tree "$src" "$VST3_DST/$vendor" ;;
    *VST2*|*VSTPlugins*) link_tree "$src" "$VST2_DST/${vendor}-vst2" ;;
    *) continue ;;
  esac
  plugins=$((plugins+1))
done < <(yabridgectl list 2>/dev/null | grep "/WinePrefix/")

# 2) vendor SUPPORT folders (fixed-path shared components)
support=0
link_support() {  # link only if absent on the Ableton side (never overwrite)
  local subdir="$1" dst="$2"
  [ -e "$subdir" ] || return 0
  [ -e "$dst" ] && return 0
  mkdir -p "$(dirname "$dst")"; link_tree "${subdir%/}" "$dst"; support=$((support+1))
}

mapfile -t roots < <(yabridgectl list 2>/dev/null | grep "/WinePrefix/" \
  | sed -E 's#(.*/WinePrefix/[^/]+)/drive_c/.*#\1#' | sort -u)
for root in "${roots[@]}"; do
  # a) Program Files\<Vendor>  (and (x86))
  for base in "Program Files" "Program Files (x86)"; do
    src="$root/drive_c/$base"; [ -d "$src" ] || continue
    for d in "$src"/*/; do [ -d "$d" ] || continue; name="$(basename "$d")"
      case "$name" in "Common Files"|"Internet Explorer"|Windows*|Microsoft*|\
        "Uninstall Information"|"Steinberg"|"Mozilla Firefox"|"Google") continue ;; esac
      link_support "$d" "$DRIVEC/$base/$name"
    done
  done
  # b) ProgramData\<Vendor>  (shared kernel DLLs, e.g. Melda)
  src="$root/drive_c/ProgramData"; [ -d "$src" ] && for d in "$src"/*/; do
    [ -d "$d" ] || continue; name="$(basename "$d")"
    case "$name" in Microsoft*|"Package Cache"|"Packages"|"Ableton"|"Temp") continue ;; esac
    link_support "$d" "$DRIVEC/ProgramData/$name"
  done
  # c) AppData\Roaming|Local\<Vendor>  (per-user data / licences)
  for u in "$root"/drive_c/users/*/; do [ -d "$u" ] || continue
    for sub in Roaming Local; do s="$u/AppData/$sub"; [ -d "$s" ] || continue
      for d in "$s"/*/; do [ -d "$d" ] || continue; name="$(basename "$d")"
        case "$name" in Microsoft*|"Packages"|"Temp"|"Ableton"|"Google"|"Mozilla") continue ;; esac
        link_support "$d" "$APPDATA/$sub/$name"
      done
    done
  done
  # d) vendor DLLs dropped in windows\system32 / syswow64 (e.g. AI runtimes).
  #    Only DLLs ABSENT from the Ableton prefix; never shadow Wine/system runtimes.
  for wdir in system32 syswow64; do
    s="$root/drive_c/windows/$wdir"; [ -d "$s" ] || continue
    for dll in "$s"/*.dll; do [ -f "$dll" ] || continue
      lname="$(basename "$dll" | tr 'A-Z' 'a-z')"
      case "$lname" in api-ms-*|ext-ms-*|vcruntime*|msvcp*|msvcr*|ucrtbase*|d3d*|dxgi*|\
        ntdll*|kernel*|user32*|gdi32*|ole32*|shell32*|advapi32*|crypt*|winmm*) continue ;; esac
      link_support "$dll" "$DRIVEC/windows/$wdir/$(basename "$dll")"
    done
  done
done

# 3) exclude plugins that hang/crash the scan (one glob per line)
EXCLUDE="${XDG_CONFIG_HOME:-$HOME/.config}/link-plugins/exclude.txt"
excluded=0
[ -f "$EXCLUDE" ] && while IFS= read -r pat; do
  pat="$(printf '%s' "$pat" | sed 's/#.*//; s/^[[:space:]]*//; s/[[:space:]]*$//')"
  [ -z "$pat" ] && continue
  while IFS= read -r -d '' hit; do rm -rf "$hit"; excluded=$((excluded+1)); done \
    < <(find "$VST3_DST" "$VST2_DST" -iname "$pat" -print0 2>/dev/null)
done < "$EXCLUDE"

echo "Plugins linked: $plugins   support folders: $support   excluded: $excluded"
echo "Then in Live: Options > Preferences > Plug-Ins > Rescan."

3 · Install PipeASIO into the bottleInstaller PipeASIO dans la bouteille — install-into-bottles.sh

Companion to the flake.nix above: it builds and registers the ASIO driver, and exposes the PipeWire socket. Re-run after a runner update.

Complément du flake.nix ci-dessus : il construit et enregistre le driver ASIO, et expose le socket PipeWire. À relancer après une màj du runner.

#!/usr/bin/env bash
# install-into-bottles.sh — build pipeasio (via the flake) and install it into the
# Bottles runner + register the ASIO driver in the prefix + expose the PipeWire socket.
# Re-run this after a runner update/reinstall. Override RUNNER / PREFIX / BOTTLE if needed.
set -euo pipefail

RUNNER="${RUNNER:-kron4ek-wine-9.21-staging-amd64}"   # MUST be Wine 9.21 (ABI match)
PREFIX="${PREFIX:-$HOME/WinePrefix/Ableton}"
BOTTLE="${BOTTLE:-com.usebottles.bottles}"
RUNNER_DIR="$HOME/.var/app/$BOTTLE/data/bottles/runners/$RUNNER"
cd "$(dirname "$0")"

OUT="$(nix build .#pipeasio --no-link --print-out-paths)"   # build the flake
[ -d "$RUNNER_DIR" ] || { echo "runner not found: $RUNNER_DIR" >&2; exit 1; }

# PE half -> runner. Unix half -> runner, RENAMED to <name>.so (kron4ek convention;
# ".dll.so" would not be found). Fake PE ALSO into the prefix system32 (that is what
# Wine recognizes as a builtin to trigger loading the unix half).
install -Dm644 "$OUT/lib/wine/x86_64-windows/pipeasio64.dll" \
               "$RUNNER_DIR/lib/wine/x86_64-windows/pipeasio64.dll"
install -Dm644 "$OUT/lib/wine/x86_64-unix/pipeasio64.dll.so" \
               "$RUNNER_DIR/lib/wine/x86_64-unix/pipeasio64.so"
install -Dm644 "$OUT/lib/wine/x86_64-windows/pipeasio64.dll" \
               "$PREFIX/drive_c/windows/system32/pipeasio64.dll"

# Let the flatpak reach the PipeWire socket.
flatpak override --user --filesystem=xdg-run/pipewire-0 "$BOTTLE"

# Register (64-bit regsvr32; the 32-bit one fails). builtin override + fresh wineserver.
flatpak run --command=bash "$BOTTLE" -c '
  set -e; export WINEPREFIX="'"$PREFIX"'"; export WINEDEBUG=-all
  R="'"$RUNNER_DIR"'"
  "$R/bin/wineserver" -k 2>/dev/null || true; sleep 2
  "$R/bin/wine" reg add "HKCU\\Software\\Wine\\DllOverrides" /v pipeasio64 /t REG_SZ /d builtin /f
  "$R/bin/wine64" C:\\windows\\system32\\regsvr32.exe /s pipeasio64.dll
  "$R/bin/wineserver" -w
'
echo "Done. In Ableton: Preferences > Audio > Driver Type ASIO > Device PipeASIO."

Quick referenceRéférence rapide

Quick fixesDépannage express

Symptom on the left, the shortest thing to try on the right.

Symptôme à gauche, l'action la plus courte à tenter à droite.

To wrap upPour finir

The checklist, and why it holdsLa checklist, et pourquoi elle tient

Trace the chain: each decision follows from the previous one.

Remonte la chaîne : chaque décision découle de la précédente.

• Bottles (flatpak) because it maps windows and makes the setup portable.
• Wine ≤ 9.21 because 9.22+ offsets the cursor.
• x11 driver because the Wayland driver doesn't draw menus.
• No gamescope because it breaks plugin editor windows.
• Ableton on a 100%-scale screen if dropdown offsets bother you.
• Plugins as hard links (never symlink/junction) + linked support folders.
• iLok works — install an older PACE Software Manager.
• PipeASIO built against the same Wine, for low-latency audio.

• Bottles (flatpak) parce qu'il mappe les fenêtres et rend le montage portable.
• Wine ≤ 9.21 parce que 9.22+ décale la souris.
• Pilote x11 parce que le pilote Wayland ne dessine pas les menus.
• Sans gamescope parce qu'il casse les fenêtres d'éditeurs de plugins.
• Ableton sur un écran à l'échelle 100 % si les menus déroulants te gênent.
• Plugins en liens durs (jamais symlink/jonction) + dossiers de support liés.
• iLok fonctionne — installer un PACE Software Manager antérieur.
• PipeASIO compilé contre le même Wine, pour l'audio basse latence.

The through-line: Ableton is a Windows guest in a Linux house. Most friction is at the door — the compositor, display scaling, audio, the translator's version. Choose those borders well, and Live behaves like a native app.

Le fil conducteur : Ableton est un invité Windows dans une maison Linux. La plupart des frictions sont à la porte — le compositeur, l'échelle des écrans, l'audio, la version du traducteur. Choisis bien ces frontières, et Live se comporte comme un logiciel natif.