# Installation Star Citizen - GLF-OS

**URL:** <https://forum.glfos.org/t/instalation-star-citizen-glf-os/192>\
**Category:** Configuration et personnalisation\
**Created:** [Novembre 5, 2026, 12:09 UTC](https://forum.glfos.org/t/instalation-star-citizen-glf-os/192 "2026-11-05T00:09:01Z")\
**Posts on this page:** 3\
**Page:** 1

<div class="post-metadata">

**Author:** ![Kuraudo-Kouro](https://forum.glfos.org/user_avatar/forum.glfos.org/kuraudo-kouro/32/159_2.png) [@Kuraudo-Kouro](https://forum.glfos.org/u/Kuraudo-Kouro)\
**Post date:** [Novembre 5, 2026, 12:09 UTC](https://forum.glfos.org/t/instalation-star-citizen-glf-os/192/1 "2026-11-05T00:09:01Z")

</div>

# 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](https://forum.glfos.org/t/installation-npins-glf-os/178)

**Ce tuto = version sans npins.**

Version npins (maj auto) : [Star Citizen (npins)](https://forum.glfos.org/t/installation-star-citizen-npins-glf-os/193)

* * *

1. 
## Ouvrir le terminal

 ![Capture d’écran du 2026-09-20 18-24-33](https://forum.glfos.org/uploads/default/original/1X/7596d6093af5c0233811a8a74c63f65444d3683c.png)

* * *

1. 
## Créer le module

```bash
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)**
>
> ```nix
> # ------ 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.libX11
> pkgs.libXext
> pkgs.libXrandr
> pkgs.libXrender
> pkgs.libXfixes
> pkgs.libXcursor
> pkgs.libXinerama
> pkgs.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

* * *

1. 
## (optionnel) Fichier commandes

Juste pour toi, liste des commandes :

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

```

> **Texte à recopier - star-citizen-commandes.txt**
>
> ```plaintext
> 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

* * *

1. 
## glf-apps.nix (activer Star Citizen)

### Si le fichier n’existe pas

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

```

Colle :

```nix
# 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à

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

```

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

```nix
  glf.gaming.starcitizen.enable = true;

```

Ctrl + X, puis O, puis Entrée

* * *

1. 
## Import dans default.nix

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

```

```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

* * *

1. 
## Rebuild GLF-OS

```bash
glf-update --switch

```

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

* * *

1. 
## Installer Star Citizen (une seule fois)

```bash
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é) |

* * *

1. 
## 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

```bash
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

```bash
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

```bash
glf-starcitizen-hdr-

```

Puis relance.

### Erreur EAC 70003

```bash
glf-starcitizen-eac-reset

```

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

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

```bash
glf-starcitizen-nvidia-fix+

```

### Logs

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

```

* * *

## DÉSINSTALLATION

### Jeu + prefix Wine

```bash
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 :

```nix
  # glf.gaming.starcitizen.enable = true;

```

```bash
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

 ![image](https://forum.glfos.org/uploads/default/original/1X/13ac6128fe11a59285ec40a7e72184b47614a98a.png)

* * *

## Notes

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

---

<div class="post-metadata">

**Author:** ![Kuraudo-Kouro](https://forum.glfos.org/user_avatar/forum.glfos.org/kuraudo-kouro/32/159_2.png) [@Kuraudo-Kouro](https://forum.glfos.org/u/Kuraudo-Kouro)\
**Post date:** [Novembre 5, 2026, 12:09 UTC](https://forum.glfos.org/t/instalation-star-citizen-glf-os/192/2 "2026-11-05T00:09:10Z")

</div>



---

<div class="post-metadata">

**Author:** ![Kuraudo-Kouro](https://forum.glfos.org/user_avatar/forum.glfos.org/kuraudo-kouro/32/159_2.png) [@Kuraudo-Kouro](https://forum.glfos.org/u/Kuraudo-Kouro)\
**Post date:** [Novembre 5, 2026, 12:41 UTC](https://forum.glfos.org/t/instalation-star-citizen-glf-os/192/3 "2026-11-05T00:41:18Z")

</div>