Installation Star Citizen - GLF-OS

Kuraudo-Kouro · Novembre 5, 2026, 12:09

Installation Star Citizen - GLF-OS

Installe Star Citizen (LUG Helper + lug-wine-tkg) sur GLF-OS.

2 versions au choix : une seule

Version	Fichier	Maj
sans npins	`star-citizen.nix`	tu mets à jour `rev` + `hash` à la main
avec npins	`star-citizen-npins.nix`	maj auto via `glf-sha` / npins

Prérequis npins : sources.nix + verify-sources.nix déjà branchés.
Sinon : tuto npins

Ce tuto = version sans npins.

Version npins (maj auto) : Star Citizen (npins)

Ouvrir le terminal

Créer le module

sudo nano /etc/nixos/customConfig/star-citizen.nix

Recopiez/collez le code.
(Clic droit dans le terminal, puis Coller.)

Code à recopier - star-citizen.nix (sans npins)

# ------ Star Citizen GLF-OS (sans npins) ------

{ config, pkgs, lib, pkgs-unstable, ... }:

let

  # ------ Source nix-citizen (fetch fixe) ------
  # Maj manuelle : change rev + hash (erreur nix au rebuild donne le bon hash)
  nix-citizen-src = pkgs.fetchFromGitHub {
    owner = "LovingMelody";
    repo = "nix-citizen";
    rev = "f9a3b08ea31c586ffee0e604af9dc7ffc22e9723";
    hash = "sha256-rdq2yGEPkX4pOZJ+7MvUgZuA9OzwEimx01JjoOX+GQ8=";
  };
  hasNixCitizen = true;

  # ------ Fake zenity ------
  fake-zenity = pkgs.writeShellScriptBin "zenity" ''
    type=""
    for arg in "$@"; do
      case "$arg" in
        --question)        type="question" ;;
        --info)            type="info" ;;
        --warning)         type="warning" ;;
        --error)           type="error" ;;
        --list)            type="list" ;;
        --file-selection)  type="file-selection" ;;
        --progress)        type="progress" ;;
      esac
    done

    case "$type" in
      question)
        exit 0
        ;;
      list)
        exit 1
        ;;
      file-selection)
        echo "$HOME/Games/star-citizen"
        exit 0
        ;;
      progress)
        cat > /dev/null
        exit 0
        ;;
      *)
        exit 0
        ;;
    esac
  '';

  # ------ Libs Wine NixOS ------
  sc-libs = [
    pkgs.libunwind
    pkgs.glib
    pkgs.freetype
    pkgs.fontconfig
    pkgs.xorg.libX11
    pkgs.xorg.libXext
    pkgs.xorg.libXrandr
    pkgs.xorg.libXrender
    pkgs.xorg.libXfixes
    pkgs.xorg.libXcursor
    pkgs.xorg.libXinerama
    pkgs.xorg.libXi
    pkgs.vulkan-loader
  ];

  # ------ Library path ------
  sc-libraryPath = lib.makeLibraryPath sc-libs;

  # ------ lug-helper ------
  lug-helper-pkg = if hasNixCitizen
    then (pkgs.callPackage "${nix-citizen-src}/pkgs/lug-helper" {
    winetricks = pkgs-unstable.winetricks;
  }).overrideAttrs (old: {
    nativeBuildInputs = (old.nativeBuildInputs or []) ++ [ pkgs.makeWrapper ];
    postInstall = (old.postInstall or "") + ''
      sed -i 's|^exec |export WINEDLLOVERRIDES="mscoree=d;winemenubuilder.exe=d"\nexport WINEESYNC=1\nexport WINEDEBUG=-all\nexport LD_LIBRARY_PATH="${sc-libraryPath}:$LD_LIBRARY_PATH"\nif [ "''${GLF_SC_AUTO:-0}" = "1" ]; then export PATH="${fake-zenity}/bin:$PATH"; fi\nexec |' $out/bin/lug-helper

      sed -i 's|winetricks |winetricks --unattended |g' $out/bin/lug-helper
    '';
  })
   else pkgs.lug-helper;

  # ------ Detect GPU ------
  detect-gpu = pkgs.writeShellScript "detect-gpu" ''
    if ${pkgs.pciutils}/bin/lspci 2>/dev/null | grep -qi "NVIDIA"; then
      echo "nvidia"
    else
      echo "amd"
    fi
  '';

  # ------ Detect NVIDIA gen ------
  detect-nvidia-gen = pkgs.writeShellScript "detect-nvidia-gen" ''
    chipset=$(${pkgs.pciutils}/bin/lspci 2>/dev/null \
      | grep -iE "VGA|3D controller" | grep -i NVIDIA | head -1)

    if echo "$chipset" | grep -qiE "\bGB[0-9]"; then
      echo "rtx50"
    elif echo "$chipset" | grep -qiE "\bAD[0-9]"; then
      echo "rtx40"
    elif echo "$chipset" | grep -qiE "\bGA[0-9]"; then
      echo "rtx30"
    elif echo "$chipset" | grep -qiE "\bTU[0-9]"; then
      echo "rtx20"
    elif echo "$chipset" | grep -qiE " 5[0-9]{3}"; then
      echo "rtx50"
    elif echo "$chipset" | grep -qiE " 4[0-9]{3}"; then
      echo "rtx40"
    elif echo "$chipset" | grep -qiE " 3[0-9]{3}"; then
      echo "rtx30"
    elif echo "$chipset" | grep -qiE " 2[0-9]{3}"; then
      echo "rtx20"
    else
      echo "unknown"
    fi
  '';

  # ------ HDR on ------
  glf-starcitizen-hdr-on = pkgs.writeShellScriptBin "glf-starcitizen-hdr+" ''
    set -eu
    LAUNCH_SCRIPT="$HOME/Games/star-citizen/sc-launch.sh"
    CFG_FILE="$HOME/Games/star-citizen/drive_c/Program Files/Roberts Space Industries/StarCitizen/LIVE/USER.cfg"

    if [ ! -f "$LAUNCH_SCRIPT" ]; then
      echo "✗ Star Citizen n'est pas installé. Lance d'abord : glf-starcitizen"
      exit 1
    fi

    if [ "''${XDG_SESSION_TYPE:-}" != "wayland" ]; then
      echo "⚠ Session = ''${XDG_SESSION_TYPE:-inconnue} — le HDR SC Linux exige Wayland."
      echo "  Connecte-toi en session Wayland puis relance cette commande."
    fi

    DE=other
    case "''${XDG_CURRENT_DESKTOP:-}''${XDG_SESSION_DESKTOP:-}" in
      *[Kk][Dd][Ee]*|*[Pp]lasma*) DE=kde ;;
      *[Gg][Nn][Oo][Mm][Ee]*)     DE=gnome ;;
    esac

    HAS_COLOR_MGR=0
    if command -v wayland-info >/dev/null 2>&1; then
      if wayland-info 2>/dev/null | grep -q 'wp_color_manager_v1'; then
        HAS_COLOR_MGR=1
      fi
    elif [ -x "${pkgs.wayland-utils}/bin/wayland-info" ]; then
      if ${pkgs.wayland-utils}/bin/wayland-info 2>/dev/null | grep -q 'wp_color_manager_v1'; then
        HAS_COLOR_MGR=1
      fi
    fi

    MESA_OK=0
    mesa_ver=$(glxinfo 2>/dev/null | sed -n 's/.*Mesa \([0-9][0-9]*\.[0-9][0-9]*\).*/\1/p' | head -1)
    if [ -n "$mesa_ver" ]; then
      major=''${mesa_ver%%.*}
      minor=''${mesa_ver#*.}; minor=''${minor%%.*}
      if [ "$major" -gt 25 ] || { [ "$major" -eq 25 ] && [ "$minor" -ge 1 ]; }; then
        MESA_OK=1
      fi
    fi

    GPU=$(${detect-gpu})
    echo "→ GPU : $GPU | DE : $DE | wp_color_manager_v1 : $HAS_COLOR_MGR | Mesa : ''${mesa_ver:-?} (≥25.1=$MESA_OK)"

    if grep -q "PROTON_ENABLE_NGX_UPDATER\|DXVK_NVAPI_DRS_NGX" "$LAUNCH_SCRIPT"; then
      echo "⚠  DLSS actif — HDR + DLSS incompatibles (DX11 vs Vulkan)."
      echo "   Désactive : glf-starcitizen-dlss-  /  glf-starcitizen-dlss-sr-"
      echo ""
    fi

    sed -i '/PROTON_ENABLE_WAYLAND\|PROTON_ENABLE_HDR\|DXVK_HDR\|ENABLE_HDR_WSI\|^unset DISPLAY/d' "$LAUNCH_SCRIPT"

    NEED_HDR_WSI=0
    if [ "$HAS_COLOR_MGR" -eq 0 ]; then
      NEED_HDR_WSI=1
      echo "ℹ wp_color_manager_v1 absent → ENABLE_HDR_WSI=1 (+ vk-hdr-layer si besoin)"
    elif [ "$GPU" = "nvidia" ] && [ "$MESA_OK" -eq 0 ]; then
      NEED_HDR_WSI=1
      echo "ℹ NVIDIA sans Mesa récent détecté → ENABLE_HDR_WSI=1 (désactive si couleurs délavées)"
    else
      echo "ℹ HDR natif compositeur OK — pas de ENABLE_HDR_WSI (évite couleurs délavées)"
    fi

    if [ "$NEED_HDR_WSI" -eq 1 ]; then
      sed -i '/^export WINEPREFIX=/i unset DISPLAY\nexport DXVK_HDR=1\nexport ENABLE_HDR_WSI=1' "$LAUNCH_SCRIPT"
      echo "✓ HDR : unset DISPLAY + DXVK_HDR=1 + ENABLE_HDR_WSI=1"
    else
      sed -i '/^export WINEPREFIX=/i unset DISPLAY\nexport DXVK_HDR=1' "$LAUNCH_SCRIPT"
      echo "✓ HDR : unset DISPLAY + DXVK_HDR=1"
    fi

    if ! grep -q 'in-process-gpu' "$LAUNCH_SCRIPT"; then
      sed -i 's|"C:\\Program Files\\Roberts Space Industries\\RSI Launcher\\RSI Launcher.exe"|"C:\\Program Files\\Roberts Space Industries\\RSI Launcher\\RSI Launcher.exe" --in-process-gpu --disable-gpu|' "$LAUNCH_SCRIPT"
    fi
    echo "✓ Flags launcher : --in-process-gpu --disable-gpu"

    if [ -f "$CFG_FILE" ]; then
      if grep -q "r\.graphicsRenderer" "$CFG_FILE"; then
        current=$(grep "r\.graphicsRenderer" "$CFG_FILE" | grep -oE "[0-9]" | head -1)
        if [ "$current" != "0" ]; then
          sed -i 's|r\.graphicsRenderer = .*|r.graphicsRenderer = 0|' "$CFG_FILE"
          echo "⚠  USER.cfg → DX11 (r.graphicsRenderer = 0)"
        else
          echo "✓ USER.cfg : DX11 déjà actif"
        fi
      else
        printf '\n; HDR requiert DX11\nr.graphicsRenderer = 0\n' >> "$CFG_FILE"
        echo "⚠  USER.cfg : r.graphicsRenderer = 0 ajouté"
      fi
    else
      echo "  ℹ USER.cfg absent — lance glf-starcitizen et choisis DX11 (0)."
    fi

    echo ""
    case "$DE" in
      gnome)
        echo "  GNOME : Paramètres → Affichage → active HDR sur ton moniteur (toggle par écran)."
        echo "  Requis : GNOME/Mutter ≥ 48 (tu as GNOME Shell $(gnome-shell --version 2>/dev/null | awk '{print $NF}' || echo '?'))."
        echo "  ⚠ Gamescope HDR est souvent « washed out » sous GNOME — préfère Wine Wayland natif."
        ;;
      kde)
        echo "  KDE : Configuration système → Affichage et moniteur → active HDR."
        echo "  Requis : Plasma ≥ 6.1. Si wp_color_manager absent : vk-hdr-layer-kwin6."
        ;;
      *)
        echo "  DE non détecté — active le HDR dans les réglages d'affichage Wayland."
        echo "  Compositeurs OK : GNOME ≥ 48, KDE Plasma ≥ 6.1."
        ;;
    esac
    echo "  ⚠ Si launcher noir malgré les flags : glf-starcitizen-hdr- puis relancer"
    echo "  ⚠ HDR incompatible avec DLSS"
  '';

  # ------ HDR off ------
  glf-starcitizen-hdr-off = pkgs.writeShellScriptBin "glf-starcitizen-hdr-" ''
    set -eu
    LAUNCH_SCRIPT="$HOME/Games/star-citizen/sc-launch.sh"

    if [ ! -f "$LAUNCH_SCRIPT" ]; then
      echo "✗ Star Citizen n'est pas installé. Lance d'abord : glf-starcitizen"
      exit 1
    fi

    sed -i '/PROTON_ENABLE_WAYLAND\|PROTON_ENABLE_HDR\|DXVK_HDR\|ENABLE_HDR_WSI\|^unset DISPLAY/d' "$LAUNCH_SCRIPT"
    echo "✓ HDR désactivé (Wine X11 / pas de DXVK_HDR)"
    echo "  ℹ Les flags --in-process-gpu du launcher sont conservés"
  '';

  # ------ AMD zerovram on ------
  glf-starcitizen-amd-zerovram-on = pkgs.writeShellScriptBin "glf-starcitizen-amd-zerovram+" ''
    set -eu
    LAUNCH_SCRIPT="$HOME/Games/star-citizen/sc-launch.sh"

    if [ ! -f "$LAUNCH_SCRIPT" ]; then
      echo "✗ Star Citizen n'est pas installé. Lance d'abord : glf-starcitizen"
      exit 1
    fi

    GPU=$(${detect-gpu})
    if [ "$GPU" != "amd" ]; then
      echo "✗ GPU NVIDIA détecté — ce fix est réservé aux GPU AMD."
      exit 1
    fi

    sed -i '/RADV_DEBUG/d' "$LAUNCH_SCRIPT"
    sed -i '/^export WINEPREFIX=/i export RADV_DEBUG=zerovram' "$LAUNCH_SCRIPT"
    echo "✓ Fix zerovram activé : corrige le flickering et artefacts Vulkan (Unreal Engine)"
  '';

  # ------ AMD zerovram off ------
  glf-starcitizen-amd-zerovram-off = pkgs.writeShellScriptBin "glf-starcitizen-amd-zerovram-" ''
    set -eu
    LAUNCH_SCRIPT="$HOME/Games/star-citizen/sc-launch.sh"

    if [ ! -f "$LAUNCH_SCRIPT" ]; then
      echo "✗ Star Citizen n'est pas installé."
      exit 1
    fi

    sed -i '/RADV_DEBUG/d' "$LAUNCH_SCRIPT"
    echo "✓ Fix zerovram désactivé"
  '';

  # ------ AMD nogttspill on ------
  glf-starcitizen-amd-nogttspill-on = pkgs.writeShellScriptBin "glf-starcitizen-amd-nogttspill+" ''
    set -eu
    LAUNCH_SCRIPT="$HOME/Games/star-citizen/sc-launch.sh"

    if [ ! -f "$LAUNCH_SCRIPT" ]; then
      echo "✗ Star Citizen n'est pas installé. Lance d'abord : glf-starcitizen"
      exit 1
    fi

    GPU=$(${detect-gpu})
    if [ "$GPU" != "amd" ]; then
      echo "✗ GPU NVIDIA détecté — ce fix est réservé aux GPU AMD."
      exit 1
    fi

    sed -i '/RADV_PERFTEST/d' "$LAUNCH_SCRIPT"
    sed -i '/^export WINEPREFIX=/i export RADV_PERFTEST=nogttspill' "$LAUNCH_SCRIPT"
    echo "✓ Fix nogttspill activé : réduit les chutes de FPS (GTT spill, surtout < 8 GB VRAM)"
  '';

  # ------ AMD nogttspill off ------
  glf-starcitizen-amd-nogttspill-off = pkgs.writeShellScriptBin "glf-starcitizen-amd-nogttspill-" ''
    set -eu
    LAUNCH_SCRIPT="$HOME/Games/star-citizen/sc-launch.sh"

    if [ ! -f "$LAUNCH_SCRIPT" ]; then
      echo "✗ Star Citizen n'est pas installé."
      exit 1
    fi

    sed -i '/RADV_PERFTEST/d' "$LAUNCH_SCRIPT"
    echo "✓ Fix nogttspill désactivé"
  '';

  # ------ AMD fixes on ------
  glf-starcitizen-amd-on = pkgs.writeShellScriptBin "glf-starcitizen-amd+" ''
    set -eu
    LAUNCH_SCRIPT="$HOME/Games/star-citizen/sc-launch.sh"

    if [ ! -f "$LAUNCH_SCRIPT" ]; then
      echo "✗ Star Citizen n'est pas installé. Lance d'abord : glf-starcitizen"
      exit 1
    fi

    GPU=$(${detect-gpu})
    if [ "$GPU" != "amd" ]; then
      echo "✗ GPU NVIDIA détecté — ces fixes sont réservés aux GPU AMD."
      exit 1
    fi

    sed -i '/RADV_DEBUG\|RADV_PERFTEST/d' "$LAUNCH_SCRIPT"
    sed -i '/^export WINEPREFIX=/i export RADV_DEBUG=zerovram\nexport RADV_PERFTEST=nogttspill' "$LAUNCH_SCRIPT"

    echo "✓ Fixes AMD activés :"
    echo "  RADV_DEBUG=zerovram       → corrige le flickering et artefacts Vulkan (Unreal Engine)"
    echo "  RADV_PERFTEST=nogttspill  → réduit les chutes de FPS (utile si VRAM < 8 GB)"
  '';

  # ------ AMD fixes off ------
  glf-starcitizen-amd-off = pkgs.writeShellScriptBin "glf-starcitizen-amd-" ''
    set -eu
    LAUNCH_SCRIPT="$HOME/Games/star-citizen/sc-launch.sh"

    if [ ! -f "$LAUNCH_SCRIPT" ]; then
      echo "✗ Star Citizen n'est pas installé."
      exit 1
    fi

    sed -i '/RADV_DEBUG\|RADV_PERFTEST/d' "$LAUNCH_SCRIPT"
    echo "✓ Fixes AMD désactivés (zerovram + nogttspill)"
  '';

  # ------ NVIDIA DLSS 4 on ------
  glf-starcitizen-dlss-on = pkgs.writeShellScriptBin "glf-starcitizen-dlss+" ''
    set -eu
    LAUNCH_SCRIPT="$HOME/Games/star-citizen/sc-launch.sh"

    if [ ! -f "$LAUNCH_SCRIPT" ]; then
      echo "✗ Star Citizen n'est pas installé. Lance d'abord : glf-starcitizen"
      exit 1
    fi

    GPU=$(${detect-gpu})
    if [ "$GPU" != "nvidia" ]; then
      echo "✗ GPU AMD détecté — DLSS est réservé aux GPU NVIDIA."
      exit 1
    fi

    GEN=$(${detect-nvidia-gen})
    if [ "$GEN" != "rtx40" ] && [ "$GEN" != "rtx50" ]; then
      echo "⚠ Génération détectée : $GEN"
      echo "  Frame Generation (FG) n'est disponible que sur RTX 40/50."
      echo "  Pour RTX 20/30, utilise : glf-starcitizen-dlss-sr+"
      exit 1
    fi

    sed -i '/PROTON_ENABLE_NGX_UPDATER\|DXVK_NVAPI_DRS_NGX/d' "$LAUNCH_SCRIPT"

    sed -i '/^export WINEPREFIX=/i export PROTON_ENABLE_NGX_UPDATER="1"\nexport DXVK_NVAPI_DRS_NGX_DLSS_SR_OVERRIDE="on"\nexport DXVK_NVAPI_DRS_NGX_DLSS_RR_OVERRIDE="on"\nexport DXVK_NVAPI_DRS_NGX_DLSS_FG_OVERRIDE="on"\nexport DXVK_NVAPI_DRS_NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION="render_preset_latest"\nexport DXVK_NVAPI_DRS_NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION="render_preset_latest"' "$LAUNCH_SCRIPT"

    echo "✓ DLSS 4 complet activé (RTX $GEN) : SR + RR + Frame Generation"
    echo ""

    if grep -qE "PROTON_ENABLE_WAYLAND|DXVK_HDR" "$LAUNCH_SCRIPT"; then
      echo "  ⚠ HDR est actif — HDR + DLSS sont incompatibles sur SC Linux :"
      echo "    DLSS requiert Vulkan, mais Vulkan + HDR = crash (bug swapchain SC Linux)."
      echo "    Désactive HDR si tu veux utiliser DLSS : glf-starcitizen-hdr-"
      echo ""
    fi

    echo "  Prérequis si pas encore fait :"
    echo "    1. lug-helper → Manage DXVK → installer DXVK-NVAPI"
    echo "    2. In-game : options graphiques → activer DLSS 3+"
  '';

  # ------ NVIDIA DLSS off ------
  glf-starcitizen-dlss-off = pkgs.writeShellScriptBin "glf-starcitizen-dlss-" ''
    set -eu
    LAUNCH_SCRIPT="$HOME/Games/star-citizen/sc-launch.sh"

    if [ ! -f "$LAUNCH_SCRIPT" ]; then
      echo "✗ Star Citizen n'est pas installé."
      exit 1
    fi

    sed -i '/PROTON_ENABLE_NGX_UPDATER\|DXVK_NVAPI_DRS_NGX\|DXVK_NVAPI_SET_NGX_DEBUG/d' "$LAUNCH_SCRIPT"
    echo "✓ DLSS désactivé"
  '';

  # ------ NVIDIA DLSS SR on ------
  glf-starcitizen-dlss-sr-on = pkgs.writeShellScriptBin "glf-starcitizen-dlss-sr+" ''
    set -eu
    LAUNCH_SCRIPT="$HOME/Games/star-citizen/sc-launch.sh"

    if [ ! -f "$LAUNCH_SCRIPT" ]; then
      echo "✗ Star Citizen n'est pas installé. Lance d'abord : glf-starcitizen"
      exit 1
    fi

    GPU=$(${detect-gpu})
    if [ "$GPU" != "nvidia" ]; then
      echo "✗ GPU AMD détecté — DLSS est réservé aux GPU NVIDIA."
      exit 1
    fi

    sed -i '/PROTON_ENABLE_NGX_UPDATER\|DXVK_NVAPI_DRS_NGX/d' "$LAUNCH_SCRIPT"

    sed -i '/^export WINEPREFIX=/i export PROTON_ENABLE_NGX_UPDATER="1"\nexport DXVK_NVAPI_DRS_NGX_DLSS_SR_OVERRIDE="on"\nexport DXVK_NVAPI_DRS_NGX_DLSS_RR_OVERRIDE="on"\nexport DXVK_NVAPI_DRS_NGX_DLSS_SR_OVERRIDE_RENDER_PRESET_SELECTION="render_preset_latest"\nexport DXVK_NVAPI_DRS_NGX_DLSS_RR_OVERRIDE_RENDER_PRESET_SELECTION="render_preset_latest"' "$LAUNCH_SCRIPT"

    echo "✓ DLSS SR + RR activé (sans Frame Generation)"
    echo "  ℹ Frame Generation disponible uniquement sur RTX 40/50 series"
    echo ""

    if grep -qE "PROTON_ENABLE_WAYLAND|DXVK_HDR" "$LAUNCH_SCRIPT"; then
      echo "  ⚠ HDR est actif — HDR + DLSS sont incompatibles sur SC Linux :"
      echo "    DLSS requiert Vulkan, mais Vulkan + HDR = crash (bug swapchain SC Linux)."
      echo "    Désactive HDR si tu veux utiliser DLSS : glf-starcitizen-hdr-"
      echo ""
    fi

    echo "  Prérequis si pas encore fait :"
    echo "    1. lug-helper → Manage DXVK → installer DXVK-NVAPI"
    echo "    2. In-game : options graphiques → activer DLSS 3+"
  '';

  # ------ NVIDIA DLSS SR off ------
  glf-starcitizen-dlss-sr-off = pkgs.writeShellScriptBin "glf-starcitizen-dlss-sr-" ''
    set -eu
    LAUNCH_SCRIPT="$HOME/Games/star-citizen/sc-launch.sh"

    if [ ! -f "$LAUNCH_SCRIPT" ]; then
      echo "✗ Star Citizen n'est pas installé."
      exit 1
    fi

    sed -i '/PROTON_ENABLE_NGX_UPDATER\|DXVK_NVAPI_DRS_NGX\|DXVK_NVAPI_SET_NGX_DEBUG/d' "$LAUNCH_SCRIPT"
    echo "✓ DLSS SR désactivé"
  '';

  # ------ NVIDIA Smooth Motion on ------
  glf-starcitizen-smooth-on = pkgs.writeShellScriptBin "glf-starcitizen-smooth+" ''
    set -eu
    LAUNCH_SCRIPT="$HOME/Games/star-citizen/sc-launch.sh"

    if [ ! -f "$LAUNCH_SCRIPT" ]; then
      echo "✗ Star Citizen n'est pas installé. Lance d'abord : glf-starcitizen"
      exit 1
    fi

    GPU=$(${detect-gpu})
    if [ "$GPU" != "nvidia" ]; then
      echo "✗ GPU AMD détecté — Smooth Motion est réservé aux GPU NVIDIA."
      exit 1
    fi

    GEN=$(${detect-nvidia-gen})
    if [ "$GEN" != "rtx40" ] && [ "$GEN" != "rtx50" ]; then
      echo "✗ Smooth Motion n'est disponible que sur RTX 40/50 series."
      echo "  Génération détectée : $GEN"
      exit 1
    fi

    sed -i '/NVPRESENT_ENABLE_SMOOTH_MOTION\|NVPRESENT_QUEUE_FAMILY/d' "$LAUNCH_SCRIPT"
    sed -i '/^export WINEPREFIX=/i export NVPRESENT_ENABLE_SMOOTH_MOTION=1\nexport NVPRESENT_QUEUE_FAMILY=1' "$LAUNCH_SCRIPT"

    echo "✓ Smooth Motion NVIDIA activé (RTX $GEN)"
    echo ""
    echo "  ⚠ Attention :"
    echo "    • Désactiver VSync dans les options graphiques du jeu"
    echo "    • MangoHud et DLSS peuvent provoquer des crashs — les désactiver si instable"
  '';

  # ------ NVIDIA Smooth Motion off ------
  glf-starcitizen-smooth-off = pkgs.writeShellScriptBin "glf-starcitizen-smooth-" ''
    set -eu
    LAUNCH_SCRIPT="$HOME/Games/star-citizen/sc-launch.sh"

    if [ ! -f "$LAUNCH_SCRIPT" ]; then
      echo "✗ Star Citizen n'est pas installé."
      exit 1
    fi

    sed -i '/NVPRESENT_ENABLE_SMOOTH_MOTION\|NVPRESENT_QUEUE_FAMILY/d' "$LAUNCH_SCRIPT"
    echo "✓ Smooth Motion désactivé"
  '';

  # ------ EAC reset ------
  glf-starcitizen-eac-reset = pkgs.writeShellScriptBin "glf-starcitizen-eac-reset" ''
    set -eu
    INSTALL_DIR="$HOME/Games/star-citizen"
    LIVE_EAC="$INSTALL_DIR/drive_c/Program Files/Roberts Space Industries/StarCitizen/LIVE/EasyAntiCheat"
    APPDATA_BASE="$INSTALL_DIR/drive_c/users"

    if [ ! -d "$INSTALL_DIR" ]; then
      echo "✗ Star Citizen n'est pas installé dans $INSTALL_DIR"
      exit 1
    fi

    echo "→ Arrêt des processus Wine du prefix..."
    if [ -f "$INSTALL_DIR/sc-launch.sh" ]; then
      wine_bin=$(grep -E '^export wine_path=' "$INSTALL_DIR/sc-launch.sh" | head -1 | sed 's/.*=//;s/"//g')
      if [ -n "''${wine_bin:-}" ] && [ -x "$wine_bin/wineserver" ]; then
        WINEPREFIX="$INSTALL_DIR" "$wine_bin/wineserver" -k 2>/dev/null || true
      fi
    fi
    pkill -f "Games/star-citizen" 2>/dev/null || true
    sleep 1

    echo "→ Suppression des dossiers EasyAntiCheat..."
    rm -rf "$LIVE_EAC"
    if [ -d "$APPDATA_BASE" ]; then
      find "$APPDATA_BASE" -type d -path "*/AppData/Roaming/EasyAntiCheat" -exec rm -rf {} + 2>/dev/null || true
    fi

    echo "✓ EAC purgé."
    echo ""
    echo "  Prochaines étapes :"
    echo "    1. Lance le RSI Launcher → Verify (fichiers du jeu)"
    echo "    2. Relance le jeu (EAC sera retéléchargé)"
    echo "    3. Si 70003 persiste : change de région serveur"
    echo "    4. Vérifie DNS : dig modules-cdn.eac-prod.on.epicgames.com"
    echo "    5. NE PAS désactiver IPv6 (wiki LUG actuel)"
    echo "    6. NVIDIA 575+/595+ : essaie aussi glf-starcitizen-nvidia-fix+"
  '';

  # ------ NVIDIA libcuda fix ------
  glf-starcitizen-nvidia-fix-on = pkgs.writeShellScriptBin "glf-starcitizen-nvidia-fix+" ''
    set -eu
    INSTALL_DIR="$HOME/Games/star-citizen"
    LAUNCH_SCRIPT="$INSTALL_DIR/sc-launch.sh"
    CFG_FILE="$INSTALL_DIR/drive_c/Program Files/Roberts Space Industries/StarCitizen/LIVE/USER.cfg"
    SYS32="$INSTALL_DIR/drive_c/windows/system32"
    SYSWOW="$INSTALL_DIR/drive_c/windows/syswow64"
    CACHE_DIR="''${XDG_CACHE_HOME:-$HOME/.cache}/glf-starcitizen"
    DXVK_VER="2.6.2"
    DXVK_URL="https://github.com/doitsujin/dxvk/releases/download/v''${DXVK_VER}/dxvk-''${DXVK_VER}.tar.gz"

    if [ ! -f "$LAUNCH_SCRIPT" ]; then
      echo "✗ Star Citizen n'est pas installé. Lance d'abord : glf-starcitizen"
      exit 1
    fi

    GPU=$(${detect-gpu})
    if [ "$GPU" != "nvidia" ]; then
      echo "✗ GPU non-NVIDIA détecté — ce fix est réservé aux GPU NVIDIA."
      exit 1
    fi

    mkdir -p "$CACHE_DIR"
    if [ ! -d "$CACHE_DIR/dxvk-$DXVK_VER" ]; then
      echo "→ Téléchargement DXVK $DXVK_VER..."
      ${pkgs.curl}/bin/curl -fL "$DXVK_URL" -o "$CACHE_DIR/dxvk-$DXVK_VER.tar.gz"
      ${pkgs.gnutar}/bin/tar -xzf "$CACHE_DIR/dxvk-$DXVK_VER.tar.gz" -C "$CACHE_DIR"
    fi

    echo "→ Installation DXVK $DXVK_VER dans le prefix Wine..."
    mkdir -p "$SYS32" "$SYSWOW"
    for f in d3d11 dxgi d3d10core d3d9; do
      cp -f "$CACHE_DIR/dxvk-$DXVK_VER/x64/$f.dll" "$SYS32/$f.dll"
      cp -f "$CACHE_DIR/dxvk-$DXVK_VER/x32/$f.dll" "$SYSWOW/$f.dll"
    done

    mkdir -p "$(dirname "$CFG_FILE")"
    if [ -f "$CFG_FILE" ] && grep -q "r\.graphicsRenderer" "$CFG_FILE"; then
      sed -i 's|r\.graphicsRenderer = .*|r.graphicsRenderer = 0|' "$CFG_FILE"
    else
      echo "r.graphicsRenderer = 0" >> "$CFG_FILE"
    fi

    sed -i '/DXVK_ENABLE_NVAPI\|NVIDIA_WINE_DLL_DIR\|XL_NVNGXPATH/d' "$LAUNCH_SCRIPT"
    if [ -d /run/opengl-driver/lib/nvidia/wine ]; then
      sed -i '/^export WINEPREFIX=/i export DXVK_ENABLE_NVAPI=1\nexport NVIDIA_WINE_DLL_DIR=/run/opengl-driver/lib/nvidia/wine\nexport XL_NVNGXPATH=/run/opengl-driver/lib/nvidia/wine' "$LAUNCH_SCRIPT"
    else
      sed -i '/^export WINEPREFIX=/i export DXVK_ENABLE_NVAPI=1' "$LAUNCH_SCRIPT"
    fi

    echo "✓ Fix NVIDIA appliqué :"
    echo "  • DXVK $DXVK_VER installé dans system32/syswow64"
    echo "  • USER.cfg : r.graphicsRenderer = 0 (DX11)"
    echo "  • DXVK_ENABLE_NVAPI=1 (+ NVIDIA_WINE_DLL_DIR si dispo)"
    echo ""
    echo "  ⚠ DLSS / Vulkan natif restent incompatibles avec ce workaround."
    echo "  ⚠ Relancer lug-helper → Manage DXVK peut réécraser les DLL —"
    echo "    rejoue cette commande après une maj DXVK via lug-helper."
  '';

  # ------ Install / config ------
  glf-starcitizen = pkgs.writeShellScriptBin "glf-starcitizen" ''
    set -eu

    INSTALL_DIR="$HOME/Games/star-citizen"
    LAUNCH_SCRIPT="$INSTALL_DIR/sc-launch.sh"
    DESKTOP_FILE="$HOME/.local/share/applications/rsi launcher.exe.desktop"

    # ------ patch desktop ------
    patch_desktop() {
      mkdir -p "$HOME/.local/share/applications"
      cat > "$DESKTOP_FILE" << EOF
[Desktop Entry]
Name=Star Citizen
Exec=${pkgs.steam-run}/bin/steam-run $LAUNCH_SCRIPT
Icon=rsi-launcher
Type=Application
Categories=Game;
EOF
      if [ -d "$HOME/Bureau" ]; then
        cp "$DESKTOP_FILE" "$HOME/Bureau/rsi launcher.exe.desktop"
        chmod +x "$HOME/Bureau/rsi launcher.exe.desktop"
      fi
      ${pkgs.desktop-file-utils}/bin/update-desktop-database "$HOME/.local/share/applications" 2>/dev/null || true
    }

    # ------ patch EAC ------
    patch_eac() {
      sed -i '/EAC_LAUNCHERDIR\|DOTNET_SYSTEM_GLOBALIZATION_INVARIANT\|^export WINEFSYNC=\|^export WINEESYNC=\|MEMORY_PRESSURE_WATCH\|MEMORY_PRESSURE_WRITE/d' "$LAUNCH_SCRIPT"

      local eac_dir=""
      for ch in LIVE PTU EPTU; do
        if [ -d "$INSTALL_DIR/drive_c/Program Files/Roberts Space Industries/StarCitizen/$ch" ]; then
          eac_dir="$INSTALL_DIR/drive_c/Program Files/Roberts Space Industries/StarCitizen/$ch"
          break
        fi
      done
      if [ -z "$eac_dir" ]; then
        eac_dir="$INSTALL_DIR/drive_c/Program Files/Roberts Space Industries/StarCitizen/LIVE"
      fi

      sed -i "/^export WINEPREFIX=/i # GLF EAC / Wine IPC (nix-citizen#94)\nunset MEMORY_PRESSURE_WATCH MEMORY_PRESSURE_WRITE\nexport WINEFSYNC=1\nexport WINEESYNC=1\nexport DOTNET_SYSTEM_GLOBALIZATION_INVARIANT=true\nexport EAC_LAUNCHERDIR=\"$eac_dir\"" "$LAUNCH_SCRIPT"

      if grep -q 'WINEDLLOVERRIDES=' "$LAUNCH_SCRIPT"; then
        sed -i 's/;icu=b//;s/;icuuc=b//;s/;icuin=b//' "$LAUNCH_SCRIPT"
        sed -i 's|WINEDLLOVERRIDES="\(.*\)"|WINEDLLOVERRIDES="\1;icu=b;icuuc=b;icuin=b"|' "$LAUNCH_SCRIPT"
      fi

      echo "✓ Patch EAC : EAC_LAUNCHERDIR + WINEFSYNC/ESYNC + ICU + DOTNET invariant"
      echo "  → $eac_dir"
    }

    # ------ patch NVIDIA env ------
    patch_nvidia_env() {
      local gpu
      gpu=$(${detect-gpu})
      if [ "$gpu" != "nvidia" ]; then
        return 0
      fi

      sed -i '/DXVK_ENABLE_NVAPI\|^export NVIDIA_WINE_DLL_DIR=\|^export XL_NVNGXPATH=/d' "$LAUNCH_SCRIPT"
      if [ -d /run/opengl-driver/lib/nvidia/wine ]; then
        sed -i '/^export WINEPREFIX=/i export DXVK_ENABLE_NVAPI=1\nexport NVIDIA_WINE_DLL_DIR=/run/opengl-driver/lib/nvidia/wine\nexport XL_NVNGXPATH=/run/opengl-driver/lib/nvidia/wine' "$LAUNCH_SCRIPT"
        echo "✓ Vars NVIDIA : DXVK_ENABLE_NVAPI + NVIDIA_WINE_DLL_DIR"
      else
        sed -i '/^export WINEPREFIX=/i export DXVK_ENABLE_NVAPI=1' "$LAUNCH_SCRIPT"
        echo "✓ Vars NVIDIA : DXVK_ENABLE_NVAPI=1"
        echo "  ℹ /run/opengl-driver/lib/nvidia/wine absent — DLSS peut nécessiter un rebuild NVIDIA"
      fi
      echo "  ℹ Drivers 575+/595+ : si le jeu ne démarre pas → glf-starcitizen-nvidia-fix+"
    }

    # ------ patch runner / launch ------
    patch_steam_run() {
      chmod +x "$LAUNCH_SCRIPT"

      LUG_RUNNER=$(ls "$INSTALL_DIR/runners/" 2>/dev/null | grep "lug-wine" | sort -V | tail -1)

      if [ -n "$LUG_RUNNER" ]; then
        sed -i "s|^export wine_path=.*|export wine_path=\"$INSTALL_DIR/runners/$LUG_RUNNER/bin\"|" "$LAUNCH_SCRIPT"
        echo "✓ Runner : $LUG_RUNNER"
      else
        echo "⚠ Aucun runner trouvé dans $INSTALL_DIR/runners/"
        echo "  Lance : lug-helper → Manage Runners → Install a runner"
        echo "  Puis relance : glf-starcitizen"
      fi

      if ! grep -q 'in-process-gpu' "$LAUNCH_SCRIPT"; then
        sed -i 's|"C:\\Program Files\\Roberts Space Industries\\RSI Launcher\\RSI Launcher.exe"|"C:\\Program Files\\Roberts Space Industries\\RSI Launcher\\RSI Launcher.exe" --in-process-gpu --disable-gpu|' "$LAUNCH_SCRIPT"
        echo "✓ Flags launcher : --in-process-gpu --disable-gpu"
      fi

      patch_eac
      patch_nvidia_env
    }

    # ------ patch shader cache ------
    patch_shader_cache() {
      local gpu cache_dir
      gpu=$(${detect-gpu})

      if [ "$gpu" = "amd" ]; then
        cache_dir="$INSTALL_DIR/amdcache"
        mkdir -p "$cache_dir"
        sed -i '/MESA_SHADER_CACHE_DIR\|MESA_SHADER_CACHE_MAX_SIZE\|__GL_SHADER_DISK_CACHE/d' "$LAUNCH_SCRIPT"
        sed -i "/^export WINEPREFIX=/i export MESA_SHADER_CACHE_DIR=\"$cache_dir\"\nexport MESA_SHADER_CACHE_MAX_SIZE=12G" "$LAUNCH_SCRIPT"
        echo "✓ Cache shaders Mesa (AMD) configuré : $cache_dir (12G max)"
      else
        cache_dir="$INSTALL_DIR/nvidiacache"
        mkdir -p "$cache_dir"
        sed -i '/MESA_SHADER_CACHE_DIR\|MESA_SHADER_CACHE_MAX_SIZE\|__GL_SHADER_DISK_CACHE/d' "$LAUNCH_SCRIPT"
        sed -i "/^export WINEPREFIX=/i export __GL_SHADER_DISK_CACHE=1\nexport __GL_SHADER_DISK_CACHE_PATH=\"$cache_dir\"\nexport __GL_SHADER_DISK_CACHE_SKIP_CLEANUP=1" "$LAUNCH_SCRIPT"
        echo "✓ Cache shaders NVIDIA configuré : $cache_dir"
      fi
    }

    # ------ patch USER.cfg ------
    patch_usercfg() {
      local cfg_dir="$INSTALL_DIR/drive_c/Program Files/Roberts Space Industries/StarCitizen/LIVE"
      local cfg_file="$cfg_dir/USER.cfg"

      echo ""
      echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
      echo "  Configuration USER.cfg (réglages automatiques au lancement)"
      echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"

      echo ""
      echo "[ VSync ] r_VSync — Synchronisation verticale"
      echo "  0 = désactivé  ← recommandé avec Smooth Motion, G-Sync ou FreeSync"
      echo "  1 = activé     ← évite le tearing sans tech de sync adaptative"
      echo "  r = recommandé (0 — désactivé)"
      echo "(0 / 1 / r)"
      read -r answer
      case "$answer" in
        r|R) vsync=0 ;;
        0|1) vsync="$answer" ;;
        *) vsync=0 ; echo "→ Valeur non reconnue, r_VSync = 0 appliqué" ;;
      esac

      echo ""
      echo "[ FPS max ] sys_MaxFPS — Limite de framerate"
      echo "  Entrer un nombre : 60, 120, 144, 165, 240..."
      echo "  0 = illimité (déconseillé — GPU surchauffé pour rien dans les menus)"
      echo "  r = recommandé (120)"
      echo "(chiffre / r)"
      read -r answer
      case "$answer" in
        r|R) maxfps=120 ;;
        ""|*[!0-9]*) maxfps=120 ; echo "→ Valeur non reconnue, sys_MaxFPS = 120 appliqué" ;;
        *) maxfps="$answer" ;;
      esac

      echo ""
      echo "[ Fenêtre ] r_WindowMode — Mode d'affichage"
      echo "  0 = fenêtré"
      echo "  1 = borderless (sans bordures)"
      echo "  2 = plein écran"
      echo "  r = recommandé (1 — borderless)"
      echo "(0 / 1 / 2 / r)"
      read -r answer
      case "$answer" in
        r|R) windowmode=1 ;;
        0|1|2) windowmode="$answer" ;;
        *) windowmode=1 ; echo "→ Valeur non reconnue, r_WindowMode = 1 appliqué" ;;
      esac

      echo ""
      echo "[ Renderer ] r.graphicsRenderer — Moteur de rendu"
      echo "  0 = DX11    (plus stable, requis si HDR activé)"
      echo "  1 = Vulkan  (meilleures performances CPU, requis pour DLSS/Smooth Motion)"
      echo "  ⚠ Incompatibilité SC Linux : Vulkan + HDR = crash — choisir l'un ou l'autre"
      echo "      HDR  → utiliser DX11 (0)"
      echo "      DLSS → utiliser Vulkan (1)"
      echo "  r = recommandé (1 — Vulkan, sauf si HDR activé)"
      echo "(0 / 1 / r)"
      read -r answer
      case "$answer" in
        r|R) renderer=1 ;;
        0|1) renderer="$answer" ;;
        *) renderer=1 ; echo "→ Valeur non reconnue, r.graphicsRenderer = 1 appliqué" ;;
      esac

      mkdir -p "$cfg_dir"
      cat > "$cfg_file" << EOF
; USER.cfg — Star Citizen sur GLF-OS
; Généré par glf-starcitizen — relance la commande pour modifier.

; Synchronisation verticale (0 = off, 1 = on)
r_VSync = $vsync

; Limite de FPS (0 = illimité)
sys_MaxFPS = $maxfps

; Mode d'affichage (0 = fenêtré, 1 = borderless, 2 = plein écran)
r_WindowMode = $windowmode

; Moteur de rendu (0 = DX11, 1 = Vulkan)
r.graphicsRenderer = $renderer
EOF

      echo ""
      echo "✓ USER.cfg écrit : $cfg_file"
      echo "  r_VSync            = $vsync"
      echo "  sys_MaxFPS         = $maxfps"
      echo "  r_WindowMode       = $windowmode"
      echo "  r.graphicsRenderer = $renderer"
    }

    # ------ ask options GPU ------
    ask_options() {
      local gpu gen
      gpu=$(${detect-gpu})
      echo ""
      echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
      echo "  Configuration GPU : $gpu"
      echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"

      echo ""
      echo "[ HDR ] Voulez-vous activer le HDR ? (o/n)"
      read -r answer
      if [ "$answer" = "o" ] || [ "$answer" = "O" ] || [ "$answer" = "oui" ]; then
        ${glf-starcitizen-hdr-on}/bin/glf-starcitizen-hdr+
      else
        ${glf-starcitizen-hdr-off}/bin/glf-starcitizen-hdr-
        echo "→ HDR non activé. Commande : glf-starcitizen-hdr+"
        echo "  ℹ Sans HDR, Vulkan est recommandé (plus performant, requis pour DLSS)"
      fi

      if [ "$gpu" = "amd" ]; then

        echo ""
        echo "[ AMD ] Fix 1 — RADV_DEBUG=zerovram"
        echo "  Corrige le flickering et artefacts visuels en mode Vulkan (Unreal Engine)."
        echo "  Recommandé pour tous les GPU AMD, quelle que soit la VRAM."
        echo "(o/n)"
        read -r answer
        if [ "$answer" = "o" ] || [ "$answer" = "O" ] || [ "$answer" = "oui" ]; then
          ${glf-starcitizen-amd-zerovram-on}/bin/glf-starcitizen-amd-zerovram+
        else
          ${glf-starcitizen-amd-zerovram-off}/bin/glf-starcitizen-amd-zerovram-
          echo "→ zerovram non activé. Commande : glf-starcitizen-amd-zerovram+"
        fi

        echo ""
        echo "[ AMD ] Fix 2 — RADV_PERFTEST=nogttspill"
        echo "  Réduit les chutes de FPS liées au débordement mémoire GTT."
        echo "  Principalement utile si votre GPU a moins de 8 GB de VRAM."
        echo "  (Inoffensif avec 8 GB+ mais sans bénéfice notable)"
        echo "(o/n)"
        read -r answer
        if [ "$answer" = "o" ] || [ "$answer" = "O" ] || [ "$answer" = "oui" ]; then
          ${glf-starcitizen-amd-nogttspill-on}/bin/glf-starcitizen-amd-nogttspill+
        else
          ${glf-starcitizen-amd-nogttspill-off}/bin/glf-starcitizen-amd-nogttspill-
          echo "→ nogttspill non activé. Commande : glf-starcitizen-amd-nogttspill+"
        fi

      else
        gen=$(${detect-nvidia-gen})
        echo ""
        echo "  Génération NVIDIA détectée : $gen"
        echo ""
        echo "[ NVIDIA ] Appliquer le fix libcuda (DXVK 2.6.2 + DX11) ?"
        echo "  Requis sur drivers NVIDIA 575+/595+ si le jeu refuse de démarrer"
        echo "  (dialog « vendor id = 0x0000 » / fenêtre noire — nix-citizen#122)."
        echo "  ⚠ Force DX11 et désactive DLSS/Vulkan tant que le bug NVIDIA existe."
        echo "(o/n)"
        read -r answer
        if [ "$answer" = "o" ] || [ "$answer" = "O" ] || [ "$answer" = "oui" ]; then
          ${glf-starcitizen-nvidia-fix-on}/bin/glf-starcitizen-nvidia-fix+
          echo "→ Fix NVIDIA appliqué — DLSS/Vulkan sautés (incompatibles avec ce workaround)."
        else
          echo "→ Fix NVIDIA non appliqué. Commande : glf-starcitizen-nvidia-fix+"

          if [ "$gen" = "rtx40" ] || [ "$gen" = "rtx50" ]; then
            echo ""
            echo "[ NVIDIA $gen ] Activer DLSS 4 (Super Resolution + Ray Reconstruction + Frame Generation) ?"
            echo "  Prérequis : lug-helper → Manage DXVK → installer DXVK-NVAPI"
            echo "  puis activer DLSS 3+ dans les options graphiques du jeu"
            echo "  ⚠ Si crash au lancement : glf-starcitizen-nvidia-fix+ à la place"
            echo "(o/n)"
            read -r answer
            if [ "$answer" = "o" ] || [ "$answer" = "O" ] || [ "$answer" = "oui" ]; then
              ${glf-starcitizen-dlss-on}/bin/glf-starcitizen-dlss+
            else
              ${glf-starcitizen-dlss-off}/bin/glf-starcitizen-dlss-
              echo "→ DLSS 4 non activé. Commande : glf-starcitizen-dlss+"
            fi

            echo ""
            echo "[ NVIDIA $gen ] Activer Smooth Motion ?"
            echo "  ⚠ Désactiver VSync dans le jeu"
            echo "  ⚠ Incompatible avec MangoHud et DLSS (risque de crash)"
            echo "(o/n)"
            read -r answer
            if [ "$answer" = "o" ] || [ "$answer" = "O" ] || [ "$answer" = "oui" ]; then
              ${glf-starcitizen-smooth-on}/bin/glf-starcitizen-smooth+
            else
              ${glf-starcitizen-smooth-off}/bin/glf-starcitizen-smooth-
              echo "→ Smooth Motion non activé. Commande : glf-starcitizen-smooth+"
            fi

          else
            echo ""
            if [ "$gen" = "rtx20" ] || [ "$gen" = "rtx30" ]; then
              echo "[ NVIDIA $gen ] Activer DLSS (Super Resolution + Ray Reconstruction) ?"
              echo "  ℹ Frame Generation non disponible sur RTX 20/30 series"
            else
              echo "[ NVIDIA ] Activer DLSS (Super Resolution + Ray Reconstruction) ?"
              echo "  ℹ Génération non identifiée — Frame Generation désactivé par précaution"
            fi
            echo "  Prérequis : lug-helper → Manage DXVK → installer DXVK-NVAPI"
            echo "  puis activer DLSS 3+ dans les options graphiques du jeu"
            echo "(o/n)"
            read -r answer
            if [ "$answer" = "o" ] || [ "$answer" = "O" ] || [ "$answer" = "oui" ]; then
              ${glf-starcitizen-dlss-sr-on}/bin/glf-starcitizen-dlss-sr+
            else
              ${glf-starcitizen-dlss-sr-off}/bin/glf-starcitizen-dlss-sr-
              echo "→ DLSS non activé. Commande : glf-starcitizen-dlss-sr+"
            fi
            echo "  ℹ Smooth Motion : disponible uniquement sur RTX 40 et 50 series"
          fi
        fi
      fi

      echo ""
      echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    }

    if [ -f "$LAUNCH_SCRIPT" ]; then
      echo "→ RSI Launcher déjà installé dans $INSTALL_DIR"
      patch_steam_run
      patch_shader_cache
      patch_desktop
      ask_options
      patch_usercfg
      echo "✓ Prêt. Lance Star Citizen depuis le menu des applications."
      exit 0
    fi

    echo "→ Lancement de lug-helper pour installer Star Citizen..."
    echo "  (réponses auto via fake-zenity — pas de barre de progression visible)"
    echo "  Indices de progression : apparition de ~/Games/star-citizen + activité wine/winetricks"

    if [ -d "$HOME/.config/starcitizen-lug" ] && [ ! -f "$LAUNCH_SCRIPT" ]; then
      echo "⚠ Config lug orpheline détectée (pas de sc-launch.sh) — reset..."
      rm -rf "$HOME/.config/starcitizen-lug"
    fi

    (
      WIN=$(timeout 3600 ${pkgs.xdotool}/bin/xdotool search --sync --name "Mono" 2>/dev/null | head -1)
      if [ -n "$WIN" ]; then
        ${pkgs.wmctrl}/bin/wmctrl -i -c "$WIN" 2>/dev/null || true
      fi
    ) &
    MONO_CLOSER_PID=$!

    (
      while true; do
        sleep 0.5
        WID=$(${pkgs.wmctrl}/bin/wmctrl -l 2>/dev/null \
              | grep -i "distance\|remote desktop" \
              | awk '{print $1}' | head -1)
        [ -n "$WID" ] && ${pkgs.wmctrl}/bin/wmctrl -i -c "$WID" 2>/dev/null || true
      done
    ) &
    REMOTE_CLOSER_PID=$!

    export GLF_SC_AUTO=1
    export WINEDLLOVERRIDES="mscoree=d;winemenubuilder.exe=d"
    export WINEESYNC=1
    export WINEDEBUG=-all
    export LD_LIBRARY_PATH="${sc-libraryPath}:''${LD_LIBRARY_PATH:-}"

    ${lug-helper-pkg}/bin/lug-helper &
    LUG_PID=$!
    echo "  lug-helper PID=$LUG_PID (popups zenity auto — GLF_SC_AUTO=1)"

    elapsed=0
    while [ ! -f "$LAUNCH_SCRIPT" ] && [ $elapsed -lt 3600 ]; do
      if ! kill -0 $LUG_PID 2>/dev/null; then
        echo "✗ lug-helper s'est arrêté sans créer $LAUNCH_SCRIPT"
        echo "  Essaie : rm -rf ~/.config/starcitizen-lug && glf-starcitizen"
        echo "  Ou lance interactif : lug-helper  (sans fake-zenity)"
        break
      fi
      if [ $((elapsed % 30)) -eq 0 ]; then
        if [ -d "$INSTALL_DIR" ]; then
          echo "  … en cours ($elapsed s) — prefix présent, taille : $(du -sh "$INSTALL_DIR" 2>/dev/null | cut -f1)"
        else
          echo "  … en cours ($elapsed s) — création du prefix Wine / winetricks…"
        fi
      fi
      sleep 3
      elapsed=$((elapsed + 3))
    done

    timeout_clean=30
    while kill -0 $LUG_PID 2>/dev/null && [ $timeout_clean -gt 0 ]; do
      sleep 1
      timeout_clean=$((timeout_clean - 1))
    done
    kill $LUG_PID 2>/dev/null || true
    wait $LUG_PID 2>/dev/null || true

    kill $MONO_CLOSER_PID 2>/dev/null || true
    wait $MONO_CLOSER_PID 2>/dev/null || true
    kill $REMOTE_CLOSER_PID 2>/dev/null || true
    wait $REMOTE_CLOSER_PID 2>/dev/null || true

    if [ -f "$LAUNCH_SCRIPT" ]; then
      patch_steam_run
      patch_shader_cache
      patch_desktop
      ask_options
      patch_usercfg
      echo "✓ Installation terminée. Lance Star Citizen depuis le menu des applications."
    else
      echo "⚠ Installation annulée ou incomplète."
      exit 1
    fi
  '';

in
{

  # ------ Options ------
  options.glf.gaming.starcitizen.enable = lib.mkOption {
    description = "Enable Star Citizen support (lug-helper + glf-starcitizen + HDR/AMD/DLSS toggles + sysctl)";
    type = lib.types.bool;
    default = false;
  };

  # ------ Config ------
  config = lib.mkIf config.glf.gaming.starcitizen.enable {

    environment.systemPackages = [
      lug-helper-pkg
      glf-starcitizen
      pkgs.wayland-utils
      glf-starcitizen-hdr-on
      glf-starcitizen-hdr-off
      glf-starcitizen-amd-zerovram-on
      glf-starcitizen-amd-zerovram-off
      glf-starcitizen-amd-nogttspill-on
      glf-starcitizen-amd-nogttspill-off
      glf-starcitizen-amd-on
      glf-starcitizen-amd-off
      glf-starcitizen-dlss-on
      glf-starcitizen-dlss-off
      glf-starcitizen-dlss-sr-on
      glf-starcitizen-dlss-sr-off
      glf-starcitizen-smooth-on
      glf-starcitizen-smooth-off
      glf-starcitizen-nvidia-fix-on
      glf-starcitizen-eac-reset
    ];

    boot.kernel.sysctl = {
      "vm.max_map_count" = lib.mkDefault 16777216;
      "fs.file-max"      = lib.mkDefault 524288;
    };

    environment.sessionVariables = lib.mkIf (lib.elem "nvidia" (config.services.xserver.videoDrivers or [])) {
      NVIDIA_WINE_DLL_DIR = "${config.hardware.nvidia.package}/lib/nvidia/wine/";
      XL_NVNGXPATH = "${config.hardware.nvidia.package}/lib/nvidia/wine/";
      DXVK_ENABLE_NVAPI = "1";
    };

    hardware.nvidia.gsp.enable = lib.mkIf (lib.elem "nvidia" (config.services.xserver.videoDrivers or [])) (
      lib.mkDefault true
    );

  };
}

Ctrl + X, puis O, puis Entrée

(optionnel) Fichier commandes

Juste pour toi, liste des commandes :

sudo nano /etc/nixos/customConfig/star-citizen-commandes.txt

Texte à recopier - star-citizen-commandes.txt

Star Citizen  -  commandes GLF-OS
================================

MODULE (ce tuto = sans npins)
-----------------------------------------
star-citizen.nix
  Sans npins. Fetch GitHub figé (rev + hash). Tu mets à jour le hash à la main.
  Version npins : voir le tuto Star Citizen (npins).

+ glf-apps.nix : glf.gaming.starcitizen.enable = true;


INSTALL / CONFIG
----------------
glf-starcitizen
  Installe (lug-helper auto) ou reconfigure HDR / AMD / NVIDIA / USER.cfg.

lug-helper
  Menu LUG : runners Wine, DXVK, maintenance. Sans auto (popups normales).


HDR
---
glf-starcitizen-hdr+
  Active le HDR (Wine Wayland + DXVK_HDR). Détecte GNOME/KDE.
  Force DX11. Sur GNOME : active aussi HDR dans Paramètres  :  Affichage.

glf-starcitizen-hdr-
  Désactive le HDR. À utiliser si le RSI Launcher reste noir.


AMD
---
glf-starcitizen-amd-zerovram+
  Fix flickering / artefacts Vulkan (recommandé tous AMD).

glf-starcitizen-amd-zerovram-
  Désactive zerovram.

glf-starcitizen-amd-nogttspill+
  Réduit chutes FPS (surtout VRAM < 8 Go).

glf-starcitizen-amd-nogttspill-
  Désactive nogttspill.

glf-starcitizen-amd+
  Active zerovram + nogttspill d’un coup.

glf-starcitizen-amd-
  Désactive les deux fixes AMD.


NVIDIA
------
glf-starcitizen-dlss+
  DLSS 4 complet (SR + RR + Frame Gen)  -  RTX 40/50. Vulkan requis.
  Prérequis : DXVK-NVAPI via lug-helper.

glf-starcitizen-dlss-
  Désactive DLSS 4.

glf-starcitizen-dlss-sr+
  DLSS SR + RR sans Frame Gen  -  RTX 20/30.

glf-starcitizen-dlss-sr-
  Désactive DLSS SR.

glf-starcitizen-smooth+
  Smooth Motion  -  RTX 40/50. Pas avec DLSS / MangoHud. VSync off in-game.

glf-starcitizen-smooth-
  Désactive Smooth Motion.

glf-starcitizen-nvidia-fix+
  Fix bug libcuda (drivers 575+/595+) : DXVK 2.6.2 + force DX11.
  Si le jeu ne démarre pas (écran noir / vendor id 0x0000).


EAC
---
glf-starcitizen-eac-reset
  Purge EasyAntiCheat (erreur 70003 / 70004). Puis Verify dans le launcher.
  Ne pas désactiver IPv6.


RAPPELS
-------
- HDR  :  renderer DX11 (0)
- DLSS  :  renderer Vulkan (1)
- HDR et DLSS : incompatibles ensemble
- Logs : ~/Games/star-citizen/sc-launch.log

Ctrl + X, puis O, puis Entrée

glf-apps.nix (activer Star Citizen)

Si le fichier n’existe pas

sudo nano /etc/nixos/customConfig/glf-apps.nix

Colle :

# glf-apps.nix
# Activation des modules / applis GLF-OS
{ config, pkgs, ... }:

{
  # Star Citizen
  glf.gaming.starcitizen.enable = true;
}

Ctrl + X, puis O, puis Entrée

Si le fichier existe déjà

sudo nano /etc/nixos/customConfig/glf-apps.nix

Ajoute juste cette ligne dans le bloc { ... } :

  glf.gaming.starcitizen.enable = true;

Ctrl + X, puis O, puis Entrée

Import dans default.nix

sudo nano /etc/nixos/customConfig/default.nix

  imports = [
    ./star-citizen.nix
    ./glf-apps.nix
  ];

Un seul module Star Citizen. Pas les deux (ne mets pas aussi star-citizen-npins.nix).

Si glf-apps.nix est déjà importé, n’ajoute que ./star-citizen.nix.

Ctrl + X, puis O, puis Entrée

Rebuild GLF-OS

glf-update --switch

Les commandes glf-starcitizen, lug-helper, etc. sont installées.

Installer Star Citizen (une seule fois)

glf-starcitizen

Les fenêtres lug-helper sont validées automatiquement
Progression visible dans le terminal (dossier ~/Games/star-citizen)
À la fin : questions HDR / AMD / NVIDIA / USER.cfg

Conseils de choix :

Question	Recommandation
HDR	`o` si ton écran / session Wayland le gère (GNOME 48+ ou KDE Plasma 6.1+)
AMD zerovram	`o` (tous les GPU AMD)
AMD nogttspill	`o` surtout si VRAM < 8 Go
Renderer	0 (DX11) si HDR ; 1 (Vulkan) sinon / pour DLSS
VSync / FPS / Fenêtre	`r` (recommandé)

Lancer le jeu

Menu : Star Citizen / RSI Launcher.

Dans le RSI Launcher :

Connecte-toi
Installe le jeu
Ne change pas le chemin : C:\Program Files\Roberts Space Industries

Commandes utiles

glf-starcitizen                 # installer / reconfigurer
lug-helper                      # menu LUG (runners, DXVK)

glf-starcitizen-hdr+            # activer HDR
glf-starcitizen-hdr-            # désactiver HDR (si launcher noir)

glf-starcitizen-amd-zerovram+
glf-starcitizen-amd-zerovram-
glf-starcitizen-amd-nogttspill+
glf-starcitizen-amd-nogttspill-
glf-starcitizen-amd+
glf-starcitizen-amd-

glf-starcitizen-dlss+           # DLSS 4 (RTX 40/50), Vulkan
glf-starcitizen-dlss-
glf-starcitizen-dlss-sr+        # DLSS SR+RR (RTX 20/30)
glf-starcitizen-dlss-sr-
glf-starcitizen-smooth+
glf-starcitizen-smooth-
glf-starcitizen-nvidia-fix+     # fix libcuda (DXVK 2.6.2 + DX11)

glf-starcitizen-eac-reset       # purge EAC (70003 / 70004) puis Verify

Rappels :

HDR : renderer DX11
DLSS : renderer Vulkan
HDR et DLSS : incompatibles ensemble
hdr et vulkan incompatible
Logs : ~/Games/star-citizen/sc-launch.log

Mise à jour du module

nix-prefetch-github LovingMelody nix-citizen --rev master

Copie rev + sha256 (ou hash) dans star-citizen.nix, puis glf-update --switch.

Problèmes fréquents

Launcher écran noir

glf-starcitizen-hdr-

Puis relance.

Erreur EAC 70003

glf-starcitizen-eac-reset

Puis RSI Launcher : Verify.
Ne désactive pas IPv6.

NVIDIA : jeu qui ne démarre pas (vendor id 0x0000)

glf-starcitizen-nvidia-fix+

Logs

tail -f ~/Games/star-citizen/sc-launch.log

DÉSINSTALLATION

Jeu + prefix Wine

rm -rf ~/Games/star-citizen
rm -f ~/.local/share/applications/starcitizen.exe.desktop
rm -f ~/.local/share/applications/"rsi launcher.exe.desktop"
rm -f ~/Bureau/"rsi launcher.exe.desktop"
rm -rf ~/.config/starcitizen-lug

Puis glf-starcitizen pour réinstaller.

Module Nix

Retire l’import dans default.nix.
Dans glf-apps.nix, commente :

  # glf.gaming.starcitizen.enable = true;

sudo rm -f /etc/nixos/customConfig/star-citizen.nix
sudo rm -f /etc/nixos/customConfig/star-citizen-commandes.txt
glf-update --switch

(Ne supprime glf-apps.nix que s’il ne sert plus à rien d’autre.)

Icone

Notes

Basé sur LUG Helper + runner lug-wine-tkg.
Espace disque : ~150 Go libres recommandés.
Wiki LUG : https://wiki.starcitizen-lug.org/

Installation Star Citizen - GLF-OS

Installation Star Citizen - GLF-OS

Ouvrir le terminal

Créer le module

(optionnel) Fichier commandes

glf-apps.nix (activer Star Citizen)

Si le fichier n’existe pas

Si le fichier existe déjà

Import dans default.nix

Rebuild GLF-OS

Installer Star Citizen (une seule fois)

Lancer le jeu

Commandes utiles

Mise à jour du module

Problèmes fréquents

Launcher écran noir

Erreur EAC 70003

NVIDIA : jeu qui ne démarre pas (vendor id 0x0000)

Logs

DÉSINSTALLATION

Jeu + prefix Wine

Module Nix

Icone

Notes