r/LLM · u/admin · 2026-09-27

Compiler Stable Diffusion avec CUDA sur Linux ( en cours de rédaction)

Bonjour,

Aujourd'hui, nous allons voir comment installer et compiler Stable Diffusion directement sur Linux, afin de pouvoir générer des images avec notre carte graphique NVIDIA.

L'objectif ici n'est pas simplement d'installer une interface graphique toute faite : nous allons compiler le moteur nous-mêmes et activer le support CUDA pour exploiter le GPU.

Pour cela, nous allons utiliser :

Stable Diffusion.cpp ;
CMake pour configurer le projet ;
CUDA pour l'accélération GPU NVIDIA ;
le pilote NVIDIA ;
Git pour récupérer les sources ;
un compilateur C/C++.

Ce tutoriel concerne l'utilisation de Stable Diffusion.cpp et de son outil en ligne de commande sd-cli.

1. Vérifier le GPU NVIDIA

Avant de commencer, vérifiez que le pilote NVIDIA fonctionne correctement :

nvidia-smi

Vous devez obtenir les informations concernant votre GPU ainsi que la version du pilote.

Si cette commande ne fonctionne pas, commencez par régler le problème du pilote NVIDIA. Il est inutile de compiler Stable Diffusion avec CUDA si le système ne voit même pas correctement le GPU.

2. Vérifier CUDA

Nous allons également vérifier que CUDA est disponible :

nvcc --version

Selon votre distribution, nvcc peut nécessiter l'installation du toolkit CUDA en plus du pilote NVIDIA.

Le pilote et le toolkit CUDA sont donc deux composants différents.

3. Installer les dépendances de compilation

Avant de compiler Stable Diffusion, installez les outils nécessaires selon votre distribution :

Distribution	Commande
Arch Linux / Manjaro	`sudo pacman -S --needed base-devel cmake git`
Debian / Ubuntu	`sudo apt update && sudo apt install -y build-essential cmake git`
Fedora	`sudo dnf install -y gcc-c++ make cmake git`
CentOS / RHEL	`sudo dnf groupinstall -y "Development Tools" && sudo dnf install -y cmake git`

CentOS anciennes versions : si dnf n'est pas disponible, utilisez yum à la place.

4. Récupérer les sources

Nous allons maintenant récupérer le projet :

git clone https://github.com/leejet/stable-diffusion.cpp.git
cd stable-diffusion.cpp

Le projet contient notamment le moteur Stable Diffusion ainsi que sd-cli, qui permet d'utiliser Stable Diffusion directement depuis le terminal.

Il faut également disposer du toolkit CUDA correspondant à votre environnement NVIDIA.

Vérifiez ensuite :

cmake --version
gcc --version
nvcc --version

Les trois commandes doivent fonctionner.

5. Compiler avec CUDA

C'est ici que cela devient intéressant.

cmake -S . -B build \
  -G Ninja \
  -DCMAKE_BUILD_TYPE=Release \
  -DSD_CUDA=ON

-DSD_CUDA=ON

Cette option indique simplement à CMake de compiler Stable Diffusion avec le support CUDA activé.

Le principe est le même quel que soit le système d'exploitation : on ajoute cette option à la configuration de compilation du projet.

Puis nous lançons la compilation :

cmake --build build --config Release -j$(nproc)

La compilation peut prendre quelques minutes selon votre machine.

6. Vérifier le résultat

Une fois la compilation terminée, recherchez sd-cli :

find build -type f -name 'sd-cli'

Vous devriez obtenir le chemin vers le binaire compilé.

Par exemple :

build/bin/sd-cli

Vous pouvez ensuite vérifier qu'il fonctionne :

./build/bin/sd-cli --help

Si l'aide s'affiche, notre compilation est terminée.

7. Télécharger un modèle

Compiler le moteur ne suffit évidemment pas : Stable Diffusion a besoin d'un modèle.

Les modèles sont généralement distribués sous différents formats et peuvent avoir des architectures différentes.

Il faut donc choisir un modèle compatible avec le moteur que nous allons utiliser.

Une fois le modèle téléchargé, placez-le par exemple dans :

models/
  └── model.gguf

Le chemin dépendra évidemment du modèle utilisé.

8. Générer notre première image

Une fois le modèle installé, nous pouvons lancer sd-cli.

La commande exacte dépend du format du modèle et de la version du projet, mais le principe est le suivant :

./build/bin/sd-cli \
 -m models/model.gguf \
 -p "a futuristic city at night, cinematic lighting"

Le moteur va alors charger le modèle et commencer la génération.

9. Pourquoi compiler soi-même ?

On pourrait évidemment utiliser une interface graphique ou un conteneur Docker.

Mais compiler le projet soi-même permet notamment de :

contrôler les options de compilation ;
activer CUDA explicitement ;
adapter la compilation à son matériel ;
utiliser une version précise du moteur ;
comprendre les dépendances ;
intégrer ensuite Stable Diffusion dans ses propres applications.

C'est également une bonne manière de comprendre ce qui se passe réellement derrière une interface de génération d'images.

10. Et Docker dans tout ça ?

Docker est une autre possibilité.

L'avantage est d'avoir un environnement isolé et reproductible.

L'installation native reste cependant particulièrement intéressante lorsqu'on veut compiler, modifier ou intégrer le moteur directement dans son environnement Linux.

Conclusion

Nous avons maintenant :

vérifié le GPU NVIDIA ;
vérifié CUDA ;
récupéré les sources de Stable Diffusion.cpp ;
installé les outils de compilation ;
configuré CMake ;
compilé Stable Diffusion avec CUDA ;
obtenu sd-cli ;
préparé un modèle ;
lancé une première génération.

Dans la prochaine partie, nous pourrons aller plus loin et voir comment optimiser la compilation CUDA, vérifier que Stable Diffusion utilise réellement le GPU, choisir le bon modèle et régler la consommation de VRAM.

autre lien youtube pour AMD: https://www.youtube.com/watch?v=GeIegX8gdR4

Vous pouvez également consulter ce topic pour découvrir comment installer Stable Diffusion sur une ancienne carte graphique NVIDIA : https://infos.center/r/llm/comments/88/comment-faire-fonctionner-stable-diffusion-sur-des-anciens-c