Games on Whales
Installation Wolf (Multi-User Cloud Gaming)
Objectif : Faire tourner plusieurs instances de Steam indépendantes sur un ou plusieurs GPU, accessibles via Moonlight avec support manettes, en utilisant Wolf et la méthode Nvidia (Manual) sur Unraid.
1. Prérequis Système (Unraid)
A. Plugin Nvidia
Installer le plugin "Nvidia Driver" (par ich777) depuis les Community Applications.
B. Correctifs NVENC et NvFBC pour les pilotes Nvidia
Nvidia bloque le nombre de flux NVENC au-delà de 3. Pour lever cette limite, on applique un patch au chargement du driver.
Installer le plugin "User Scripts" depuis les Community Applications. Créer ensuite un script, par exemple nommé "Nvidia NVENC Patch" avec comme contenu :
#!/bin/bash
wget https://raw.githubusercontent.com/keylase/nvidia-patch/master/patch.sh -O /tmp/nvidia-patch.sh
chmod +x /tmp/nvidia-patch.sh
/tmp/nvidia-patch.sh
À lancer une première fois manuellement. Dans User Scripts, régler le script pour qu’il s’exécute à chaque démarrage de l’Array .
C. Activation du "Kernel Mode Setting" (KMS)
Wolf a besoin de contrôler l’affichage au niveau du noyau pour créer les sessions graphiques. Sans ça, on risque l’écran noir.
Aller dans Main > Flash > Syslinux Configuration .
Dans l’entrée Unraid OS , ajouter à la fin de la ligne :
nvidia-drm.modeset=1
Redémarrer Unraid .
Vérifier que le KMS est bien activé :
cat /sys/module/nvidia_drm/parameters/modeset
Il doit renvoyer : Y
D. Persistance des Manettes (uinput / uhid)
Pour que Unraid recrée correctement les règles de manettes virtuelles à chaque démarrage (sinon elles disparaissent après reboot).
Ouvrir le terminal Unraid.
Éditer le fichier de boot : nano /boot/config/go
Ajouter ce bloc à la fin du fichier :
# --- Wolf : Support Manettes Virtuelles ---
# 1. Permissions uinput
chmod 666 /dev/uinput || true
# 2. Règles UDEV
cat << 'EOF' > /etc/udev/rules.d/85-wolf-virtual-inputs.rules
KERNEL=="uinput", SUBSYSTEM=="misc", MODE="0660", GROUP="input", OPTIONS+="static_node=uinput"
KERNEL=="uhid", TAG+="uaccess"
SUBSYSTEMS=="input", ATTRS{id/vendor}=="ab00", MODE="0660", GROUP="input", ENV{ID_SEAT}="seat9"
SUBSYSTEMS=="input", ATTRS{name}=="Wolf X-Box One (virtual) pad", MODE="0660", GROUP="input"
SUBSYSTEMS=="input", ATTRS{name}=="Wolf PS5 (virtual) pad", MODE="0660", GROUP="input"
SUBSYSTEMS=="input", ATTRS{name}=="Wolf gamepad (virtual) motion sensors", MODE="0660", GROUP="input"
SUBSYSTEMS=="input", ATTRS{name}=="Wolf Nintendo (virtual) pad", MODE="0660", GROUP="input"
EOF
# 3. Recharger les règles
udevadm control --reload-rules && udevadm trigger
2. Installation de Wolf (Méthode Nvidia Manual sur Unraid)
Avec la méthode Nvidia Manual, on va :
Construire une image Docker qui contient les fichiers du driver Nvidia.
Pré-remplir un volume Docker nvidia-driver-vol avec ces fichiers.
Monter ce volume dans le conteneur Wolf via un template Unraid.
A. Construire l’image gow/nvidia-driver:latest
Dans le terminal Unraid :
cd /root
curl https://raw.githubusercontent.com/games-on-whales/gow/master/images/nvidia-driver/Dockerfile \
| docker build -t gow/nvidia-driver:latest -f - --build-arg NV_VERSION=$(cat /sys/module/nvidia/version) .
Cela crée l’image locale gow/nvidia-driver:latest avec la version de driver actuellement chargée.
B. Créer / mettre à jour le volume Docker nvidia-driver-vol
On pré-popule un volume Docker avec les libs Nvidia :
docker create --rm \
--mount source=nvidia-driver-vol,destination=/usr/nvidia \
gow/nvidia-driver:latest sh
Vérifier qu’il existe :
docker volume ls | grep nvidia-driver
Il doit afficher : nvidia-driver-vol
C. Script User Scripts : reconstruire le volume après chaque reboot
Important : à chaque mise à jour du driver Nvidia, il faut reconstruire l’image et repopuler le volume, sinon Wolf utilise des libs qui ne correspondent plus au driver chargé.
Le plus simple sur Unraid : utiliser le plugin User Scripts avec un script lancé au démarrage de l’Array.
Dans User Scripts, créer un script nommé par exemple "Wolf - Rebuild Nvidia driver volume" .
Contenu du script :
#!/bin/bash
# Wolf - (Re)construction de l'image et du volume driver Nvidia + restart Wolf
WOLF_CONTAINER_NAME="wolf"
DRIVER_IMAGE="gow/nvidia-driver:latest"
DRIVER_VOLUME="nvidia-driver-vol"
NOTIFY="/usr/local/emhttp/webGui/scripts/notify"
notify_msg() {
# $1 = niveau (normal|warning|alert)
# $2 = sujet
# $3 = description
if [ -x "${NOTIFY}" ]; then
"${NOTIFY}" -e "Wolf Nvidia" -s "$2" -d "$3" -i "$1"
fi
}
echo ">>> [Wolf] $(date) - Début de la reconstruction Nvidia (image + volume)"
notify_msg "normal" "Début mise à jour Wolf Nvidia" "Reconstruction de l'image Nvidia et du volume ${DRIVER_VOLUME} en cours..."
# Vérif rapide de la version de driver en cours
if [ -r /sys/module/nvidia/version ]; then
DRV_VER=$(cat /sys/module/nvidia/version)
echo ">>> [Wolf] Driver Nvidia détecté : ${DRV_VER}"
else
echo "!!! [Wolf] Impossible de lire /sys/module/nvidia/version (driver Nvidia non chargé ?)"
notify_msg "warning" "Driver Nvidia introuvable" "Impossible de lire /sys/module/nvidia/version. Vérifiez que le driver est bien chargé avant de relancer le script."
fi
echo ">>> [Wolf] Reconstruction de l'image ${DRIVER_IMAGE}..."
curl -s https://raw.githubusercontent.com/games-on-whales/gow/master/images/nvidia-driver/Dockerfile \
| docker build -t "${DRIVER_IMAGE}" -f - \
--build-arg NV_VERSION=$(cat /sys/module/nvidia/version) \
.
if [ $? -ne 0 ]; then
echo "!!! [Wolf] Échec du build de l'image ${DRIVER_IMAGE}"
notify_msg "alert" "Échec build image Nvidia" "Le build de l'image ${DRIVER_IMAGE} a échoué. Consultez les logs du script / de Docker pour plus de détails."
exit 1
fi
echo ">>> [Wolf] (Re)population du volume ${DRIVER_VOLUME}..."
# On crée un conteneur temporaire pour initialiser le volume,
# comme dans la doc officielle Wolf, sans jamais l'exécuter.
CID=$(docker create \
--mount source=${DRIVER_VOLUME},destination=/usr/nvidia \
"${DRIVER_IMAGE}" sh 2>/dev/null)
if [ -z "${CID}" ]; then
echo "!!! [Wolf] Échec de la création du conteneur temporaire pour le volume ${DRIVER_VOLUME}"
notify_msg "alert" "Échec initialisation volume Nvidia" "Impossible de créer un conteneur temporaire pour le volume ${DRIVER_VOLUME}. Vérifiez Docker et le volume."
exit 1
fi
echo ">>> [Wolf] Conteneur temporaire ${CID} créé pour initialiser le volume ${DRIVER_VOLUME}"
# On supprime tout de suite le conteneur (le volume, lui, reste)
docker rm "${CID}" >/dev/null 2>&1 || true
echo ">>> [Wolf] Conteneur temporaire ${CID} supprimé"
echo ">>> [Wolf] Redémarrage du conteneur ${WOLF_CONTAINER_NAME}..."
# On essaye de le stopper (au cas où il tourne déjà)
if docker stop "${WOLF_CONTAINER_NAME}" 2>/dev/null; then
echo ">>> [Wolf] Conteneur ${WOLF_CONTAINER_NAME} stoppé."
else
echo ">>> [Wolf] Conteneur ${WOLF_CONTAINER_NAME} n'était pas en cours d'exécution."
fi
# Puis on le démarre
if docker start "${WOLF_CONTAINER_NAME}" 2>/dev/null; then
echo ">>> [Wolf] Conteneur ${WOLF_CONTAINER_NAME} démarré."
notify_msg "normal" "Wolf Nvidia en place" "La mise en place des bibliothèques Nvidia et le redémarrage de Wolf se sont terminés avec succès."
else
echo "!!! [Wolf] Impossible de démarrer le conteneur ${WOLF_CONTAINER_NAME} (à vérifier dans l'UI Docker)."
notify_msg "alert" "Échec redémarrage Wolf" "Impossible de démarrer le conteneur ${WOLF_CONTAINER_NAME}. Vérifiez la configuration dans l'UI Docker."
exit 1
fi
echo ">>> [Wolf] $(date) - Opération terminée."
Configurer le script pour s’exécuter à chaque démarrage de l’Array .
À chaque reboot (après une maj de driver par exemple), le volume sera automatiquement synchronisé avec la bonne version.
Ce que fait le script : - Vérifie la version du driver Nvidia actuellement chargée sur Unraid. - Rebuild l’image Docker gow/nvidia-driver:latest avec cette version de driver. - (Re)inititialise le volume Docker nvidia-driver-vol avec les librairies Nvidia de l’image. - Redémarre automatiquement le conteneur wolf pour qu’il utilise les librairies à jour. - Logue chaque étape pour faciliter le debug en cas de problème.
D. Création automatique du template Unraid my-wolf.xml
On va créer directement le template Unraid via une commande dans le terminal, pour qu’il apparaisse dans Docker > Add Container .
Dans le terminal Unraid, lancer :
mkdir -p /boot/config/plugins/dockerMan/templates-user
cat << 'EOF' > /boot/config/plugins/dockerMan/templates-user/my-wolf.xml
wolf
ghcr.io/games-on-whales/wolf:stable
https://ghcr.io/
host
bash
true
https://games-on-whales.github.io/wolf/stable/
https://github.com/games-on-whales/wolf
Wolf est un serveur de streaming Moonlight permettant de partager un hôte pour plusieurs sessions de jeu et bureaux virtuels.
GameServers:
http://[IP]:8080/
https://games-on-whales.github.io/assets/favicon.png
-v nvidia-driver-vol:/usr/nvidia:rw --device-cgroup-rule="c 13:* rmw"
0
Wolf est un serveur de streaming Moonlight permettant de partager un hôte pour plusieurs sessions de jeu et bureaux virtuels.
host
/mnt/user/appdata/wolf
/etc/wolf
rw
/var/run/docker.sock
/var/run/docker.sock
rw
/dev
/dev
rw
/run/udev
/run/udev
rw
nvidia-driver-vol
NVIDIA_DRIVER_VOLUME_NAME
/mnt/user/appdata/wolf
/var/run/docker.sock
/dev
/run/udev
nvidia-driver-vol
/dev/dri
/dev/nvidiactl
/dev/nvidia0
/dev/nvidia-uvm
/dev/nvidia-uvm-tools
/dev/nvidia-caps/nvidia-cap1
/dev/nvidia-caps/nvidia-cap2
/dev/uinput
/dev/uhid
EOF
Aller dans Docker > Add Container et choisir le template wolf dans la liste déroulante. Normalement, tout est déjà correctement renseigné.
Cliquer sur Apply pour créer et lancer le conteneur Wolf.
Note GPU : ce template est prévu pour une configuration avec un seul GPU Nvidia : il expose explicitement le device /dev/nvidia0 . Si tu ajoutes un second GPU, il suffira d’ajouter aussi le device /dev/nvidia1 Via l’interface Unraid : Docker → Éditer le conteneur → “Add another device” pour le rendre visible dans le conteneur Wolf. J'explique plus loin le multi GPU. (en cours de rédaction)
3. Configuration de Wolf (config.toml & utilisateurs)
A. Préparation des permissions aux répertoires (méthode recommandée : ACL)
Par défaut, Unraid utilise l’utilisateur nobody:users (99:100) pour les partages. Plutôt que de faire des chown/chmod -R à chaque nouvel utilisateur ou nouveau jeu, on peut utiliser les ACL pour donner en plus tous les droits au groupe 1000 (celui utilisé par les containers Wolf/Steam).
Donner les droits rwx au groupe 1000 sur l’appdata Wolf
setfacl -R -m g:1000:rwx /mnt/user/appdata/wolf
setfacl -R -d -m g:1000:rwx /mnt/user/appdata/wolf
Donner les droits rwx au groupe 1000 sur le dossier de jeux
setfacl -R -m g:1000:rwx /mnt/user/Games
setfacl -R -d -m g:1000:rwx /mnt/user/Games
Certains outils Unraid comme “New Permissions” ou des scripts maison peuvent écraser les ACL si tu les lances sur ces dossiers → dans ce cas, il faudra relancer les setfacl . Si tu déplaces des données entre disques via certains outils externes (rsync sans -A , cp, etc.), les ACL peuvent ne pas être copiées.
Modifier le config.toml
Fichier cible (côté host) :
nano /mnt/user/appdata/wolf/cfg/config.toml
À titre perso, pour le moment, j’ai choisi d’épurer totalement l’affichage dans Moonlight. Mais il est possible de laisser l’app Wolf UI présente, qui permet de classer les apps par utilisateur.
Dans ce fichier, vous supprimez tout ce qu’il y a entre :
[[profiles]]
id = 'moonlight-profile-id'
et
[[profiles]]
id = 'user'
name = 'User'
Et vous collez à la place la configuration de votre premier utilisateur suivante :
Remplacez bien les quatre . Remplacez par une image PNG. Dimension idéale width=112px height=150px (facilement reconnaissable dans Moonlight).
# --- Utilisateur 1 : ---
[[profiles.apps]]
icon_png_path = ''
start_virtual_compositor = true
title = ''
[profiles.apps.runner]
base_create_json = '''{
"HostConfig": {
"IpcMode": "host",
"CapAdd": ["SYS_ADMIN", "SYS_NICE", "SYS_PTRACE", "NET_RAW", "MKNOD", "NET_ADMIN"],
"SecurityOpt": ["seccomp=unconfined", "apparmor=unconfined"],
"Ulimits": [{"Name":"nofile", "Hard":10240, "Soft":10240}],
"Privileged": false,
"DeviceCgroupRules": ["c 13:* rmw", "c 244:* rmw"]
}
}
'''
devices = []
env = [
'PROTON_LOG=1',
'RUN_SWAY=true',
'GOW_REQUIRED_DEVICES=/dev/input/* /dev/dri/* /dev/nvidia*',
'XKB_DEFAULT_LAYOUT=fr',
'TZ=Europe/Paris'
]
image = 'ghcr.io/games-on-whales/steam:edge'
mounts = [
'/mnt/user/Games:/home/retro/games-unraid:rw',
'/mnt/user/appdata/wolf/:/home/retro/.steam:rw'
]
name = ''
ports = []
type = 'docker'
'XKB_DEFAULT_LAYOUT=fr' → clavier AZERTY français. 'TZ=Europe/Paris' → heure correcte dans l’app.
'/mnt/user/Games:/home/retro/games-unraid:rw' → point de montage du répertoire d’installation des jeux. '/mnt/user/appdata/wolf/:/home/retro/.steam:rw' → rend l’installation de Steam persistante par utilisateur.
3b. Variante des gestions d’utilisateurs
Wolf UI
Wolf UI permet d’avoir un répertoire par utilisateur.
Ranger toutes les apps par utilisateur.
Utiliser le mode co-op (deux utilisateurs sur la même session en coop locale).
Activation de Wolf UI
Faire apparaître le menu Wolf UI dans Moonlight
Pour activer Wolf UI, il faut modifier config.toml , repérer la partie :
[[profiles]]
id = 'moonlight-profile-id'
Directement dessous, collez :
[[profiles.apps]]
icon_png_path = 'https://raw.githubusercontent.com/games-on-whales/wolf-ui/refs/heads/main/src/Icons/wolf_ui_icon.png'
start_virtual_compositor = true
title = 'Wolf UI'
[profiles.apps.runner]
base_create_json = '''{
"HostConfig": {
"IpcMode": "host",
"CapAdd": ["NET_RAW", "MKNOD", "NET_ADMIN", "SYS_ADMIN", "SYS_NICE"],
"Privileged": false,
"DeviceCgroupRules": ["c 13:* rmw", "c 244:* rmw"]
}
}'''
devices = []
env = [
'GOW_REQUIRED_DEVICES=/dev/input/event* /dev/dri/* /dev/nvidia*',
'WOLF_SOCKET_PATH=/var/run/wolf/wolf.sock',
'WOLF_UI_AUTOUPDATE=False',
'LOGLEVEL=INFO',
'XKB_DEFAULT_LAYOUT=fr'
]
image = 'ghcr.io/games-on-whales/wolf-ui:main'
mounts = [ '/var/run/wolf/wolf.sock:/var/run/wolf/wolf.sock' ]
name = 'Wolf-UI'
ports = []
type = 'docker'
Création des espaces utilisateur
De base, dans config.toml , un utilisateur user est créé avec toutes les apps dedans.
Vous pouvez créer un nouvel espace en ajoutant :
[[profiles]]
id = 'user'
name = ''
icon_png_path = 'url_de_votre_image.png'
pin = [ 3, 2, 1, 4 ]
L' id doit être unique, exemple : user1 , user2 , etc... Le pin est facultatif, il permet de mettre un password de 4 chiffres pour accéder à l'espace de l'utilisateur.
Toutes les apps de cet utilisateur doivent être présentes sous ces lignes.
4. Configuration Post-Installation
A. Appairage Moonlight
Lancer Moonlight sur le client (PC, TV, Tablette).
Noter le code PIN affiché.
Consulter les logs Docker : docker logs -f wolf
Cliquer sur le lien http://IP_UNRAID:47989/pin/ID visible dans les logs et entrer le code PIN à 4 chiffres affiché dans Moonlight.
La page web vous demande de renseigner le PIN pour déverrouiller Moonlight.
À la première ouverture de Steam, le dépôt s’installe, puis il faut vous connecter à votre compte avec Steam Guard.
B. Déclaration des jeux dans Steam
Par défaut, Steam ne connaît pas le disque d’installation des jeux configuré dans config.toml . Si vous laissez tel quel, il va installer les jeux dans le répertoire appdata (non partagé entre utilisateurs).
Fermer Big Picture.
Dans Steam, aller dans Paramètres > Stockage .
Ajouter un lecteur > remonter à /Home > sélectionner le dossier /games-unraid .
Le définir comme lecteur par défaut (étoile).
À faire pour chaque compte Steam.
C. MangoHud
L’overlay Steam ne fonctionne pas dans le conteneur Wolf. Pour voir les FPS et autres stats, on utilise MangoHud .
Il est déjà installé et activé par défaut pour tous les jeux Vulkan (y compris les jeux Proton).
Jeux OpenGL (Linux natif)
Pour les jeux OpenGL, vous pouvez l’activer jeu par jeu en ajoutant :
mangohud %command%
Activation et configuration
En jeu, vous pouvez appuyer sur Maj droite + F12 pour afficher/masquer MangoHud. Et sur Maj droite + F11 pour changer sa position à l’écran.
5. Accès à Distance (Ouverture de Ports)
Wolf ne gère pas l’UPnP. Pour jouer depuis l’extérieur, deux options :
Option A : VPN (Recommandé)
Utiliser Tailscale ou Wireguard (plugins Unraid). C’est plus sécurisé et ne nécessite aucune ouverture de port. (Plus chiant côté FireTV ou autre, mais c’est la vie 😄)
Option B : Ouverture de Ports (NAT)
Sans VPN, rediriger les ports suivants sur votre routeur vers l’IP du serveur Unraid :
TCP 47984 : HTTPS (sécurité)
TCP 47989 : HTTP (appairage Web)
TCP 48010 : RTSP (initialisation du stream)
UDP 47999 : Contrôle (manettes)
UDP 48100 : Flux vidéo (RTP - spécifique Wolf)
UDP 48200 : Flux audio (RTP - spécifique Wolf)
Applications
Voici la liste des applications utilisables.
Heroic Games Launcher
Un lanceur open source pour gérer et jouer aux jeux Epic Games Store , GOG et Amazon Prime Games sous Linux.
Configuration par défaut
Voici le bloc de configuration par défaut qui sera utilisé dans Wolf. Vous pouvez le remplacer en éditant le fichier config.toml .
[[profiles.apps]]
icon_png_path = 'https://games-on-whales.github.io/wildlife/apps/heroic-games-launcher/assets/icon.png'
start_virtual_compositor = true
title = 'Heroic'
[profiles.apps.runner]
base_create_json = '''{
"HostConfig": {
"IpcMode": "host",
"CapAdd": ["SYS_ADMIN", "SYS_NICE", "SYS_PTRACE", "NET_RAW", "MKNOD", "NET_ADMIN"],
"SecurityOpt": ["seccomp=unconfined", "apparmor=unconfined"],
"Ulimits": [{"Name":"nofile", "Hard":10240, "Soft":10240}],
"Privileged": false,
"DeviceCgroupRules": ["c 13:* rmw", "c 244:* rmw"]
}
}'''
devices = []
env = [ 'RUN_SWAY=true', 'GOW_REQUIRED_DEVICES=/dev/input/* /dev/dri/* /dev/nvidia*' ]
image = 'ghcr.io/games-on-whales/heroic-games-launcher:edge'
mounts = []
name = 'WolfHeroic'
ports = []
type = 'docker'
Pensez à ajouter dans les variables d'environnement : 'XKB_DEFAULT_LAYOUT=fr' pour le clavier AZERTY
Si vous avez suivi mon tutoriel pour Wolf. Il faudra ajouter les points de montage suivant mounts = [ '/mnt/cache/Games:/home/retro/games-unraid:rw', '/mnt/user/appdata/wolf/:/home/retro/.heroic:rw' ]
Premier lancement
Voici l'interface au démarrage de Heroic.
Association des comptes
Connecter vos différents comptes EPIC / GOG / Amazon, afin de récupérer vos bibliothèques de jeux.
Ajout du répertoire d'installation des jeux
Nous allons maintenant faire en sorte que les jeux installés depuis Heroic se fassent dans le même répertoire commun.
Allez dans le menu Options puis Général .
Dans la section Chemin d'installation par défaut , mettez
/home/retro/games-unraid
C'est le chemin du répertoire que nous avons utilisé dans le tuto d'installation de Wolf. Il faudra l'adapter si vous avez choisi un autre répertoire.
Utilisation de GE-PROTON
Pour faire fonctionner les jeux Windows (exécutable en .exe). Nous allons utiliser PROTON. J'ai noté une meilleure compatibilité qu'avec Wine qui est utilisé par défaut dans Heroic.
Allez dans le menu Gestion de Wine
Choisir l'onglet GE-Proton
Cliquez sur la flèche de téléchargement pour la version GE-Proton-Latest
Utilisation de Proton par dédaut :
Allez dans le menu Options puis Paramètre de jeu par défaut .
Choisissez Proton - GE - Proton - Latest dans la version de Wine
Ajout des jeux Heroic dans Steam
Dans le but de simplifier l'accès à notre bibliothèque de jeux. Nous allons ajouter les jeux téléchargés depuis les différentes plateformes, à Steam. Ce qui permettra de centraliser sur Steam l'ensemble de nos jeux.
Au lancement de Steam, quittez le mode Big Picture.
Allez dans le menu Steam puis Paramètres .
Dans les paramètres, allez dans le menu Bibliothèque , ensuite cliquez Ajouter un jeu non Steam
Cliquez sur Parcourir... Et naviguez dans /home/retro/games-unraid (le répertoire de notre tuto)
Sélectionner les .exe des jeux que vous voulez importer dans Steam.
Ne pas oublier de cliquer Ajouter la sélection une fois fait.
Les jeux seront désormais dans la section NON STEAM de votre bibliothèque.
Prérequis pour lancer les jeux
Si vos jeux sont des installations Windows (executable en .exe). Il faudra les forcer en compatibilité PROTON
Dans Steam, allez dans les Propriétés... de votre jeu.
Dans le menu Compatibilité , cochez forcer l'utilisation d'un outil... Et choisissez Proton Expérimental