Comment exécuter Qwen3.8-27B en local sur une NVIDIA RTX 5090

1. Configurer llama.cpp pour les GPU Blackwell

Pour commencer, vérifions que le GPU est bien détecté et contrôlons la version du pilote NVIDIA et de CUDA.

nvidia-smi

Vous devriez voir votre RTX 5090, la version du pilote, la version de CUDA, la mémoire GPU et l'utilisation en cours du GPU.

Remarque : cette configuration vise spécifiquement les GPU NVIDIA Blackwell, comme la RTX 5090. La build ci-dessous cible SM120, l'architecture de calcul utilisée par la RTX 5090.

Ensuite, nous allons télécharger et compiler la dernière version de llama.cpp avec la prise en charge de CUDA.

cd /workspace

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp

cmake -B build \
  -DGGML_CUDA=ON \
  -DCMAKE_CUDA_ARCHITECTURES=120

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

L'élément clé ici est -DCMAKE_CUDA_ARCHITECTURES=120. Cela indique à llama.cpp de compiler spécifiquement pour l'architecture Blackwell utilisée par la RTX 5090.

Une fois la compilation terminée, nous allons rendre llama-server accessible globalement pour pouvoir l'exécuter depuis n'importe quel dossier :

sudo ln -sf "$(realpath ./build/bin/llama-server)" /usr/local/bin/llama-server

Maintenant, vérifiez que tout fonctionne :

llama-server --version

Vous devriez obtenir une sortie similaire à :

version: 0.1.1-dev (build 10479, commit 0021a77de)
built with GNU 13.3.0 for Linux x86_64

C'est tout. Nous avons maintenant une build de llama.cpp compatible CUDA, prête à exploiter la RTX 5090 et son support NVFP4 natif Blackwell.

2. Télécharger le modèle Qwen3.8-27B NVFP4-MTP

Téléchargeons à présent le modèle Qwen3.8-27B.

D'abord, installez la CLI Hugging Face :

pip install -U huggingface_hub

Créez un dossier pour stocker le modèle :

mkdir -p /workspace/models/qwen38

Puis téléchargez le GGUF NVFP4-MTP :

hf download felippeburk/Qwen3.8-27B-NVFP4-MTP-GGUF \
  --local-dir /workspace/models/qwen38

C'est la version à privilégier pour cette configuration, car elle utilise NVFP4 et inclut la prise en charge MTP, à l'origine d'une grande partie du gain de vitesse sur la RTX 5090.

3. Démarrer le serveur Qwen3.8-27B

Passons au concret. Nous allons servir Qwen3.8-27B entièrement sur le GPU avec Flash Attention, une fenêtre de contexte de 131 K et le décodage spéculatif MTP pour accélérer la génération. 

Exécutez :

cd /workspace/llama.cpp

llama-server \
  -m /workspace/models/qwen38/qwen3.8-27b-text-nvfp4-mtp.gguf \
  --alias qwen3.8-27b \
  --host 0.0.0.0 \
  --port 8910 \
  --ctx-size 131072 \
  --n-gpu-layers all \
  --flash-attn on \
  --cache-type-k q8_0 \
  --cache-type-v q8_0 \
  --parallel 1 \
  --spec-type draft-mtp \
  --spec-draft-n-max 4 \
  --spec-draft-p-min 0.75 \
  --spec-draft-ngl all \
  --spec-draft-type-k q8_0 \
  --spec-draft-type-v q8_0 \
  --reasoning-effort medium \
  --jinja

Il y a de nombreux paramètres ici, mais la plupart servent simplement à tirer le meilleur de la 5090.

Les principaux à connaître :

• --ctx-size 131072 nous donne environ 131 K de fenêtre de contexte.

• --n-gpu-layers all maintient le modèle sur le GPU.

• --flash-attn on active la Flash Attention.

• --cache-type-k q8_0 et --cache-type-v q8_0 réduisent l'usage mémoire du cache KV.

• --spec-type draft-mtp active le décodage spéculatif MTP de Qwen3.8.

• --spec-draft-n-max 4 contrôle combien de tokens spéculatifs MTP peut proposer d'un coup.

Pour cette configuration, nous utilisons n-max 4 comme point de départ sur une RTX 5090. Vous pouvez tester des valeurs comme 2 (recommandé par la fiche du modèle pour ce GGUF) ou 3 ensuite, car le réglage le plus rapide peut varier légèrement selon votre système.

Une fois que llama-server a fini de charger le modèle, Qwen3.8 sera disponible en local à l'adresse http://127.0.0.1:8910.

Nous avons maintenant Qwen3.8-27B qui tourne en local. Ensuite, nous allons tester le modèle via l'API et l'interface navigateur intégrée.

4. Tester la vitesse et les performances en code de Qwen3.8-27B

Avec le serveur actif, ouvrez un autre terminal et envoyez une requête de test à l'API compatible OpenAI :

curl http://127.0.0.1:8910/v1/chat/completions \
 -H "Content-Type: application/json" \
 -d '{
   "model": "qwen3.8-27b",
   "messages": [
     {
       "role": "user",
       "content": "Write a Python FastAPI application that monitors GPU usage."
     }
   ],
   "max_tokens": 2000
 }'

Dans ce test, Qwen3.8-27B a généré 2 000 tokens à 122 tokens/s avec un excellent taux d'acceptation MTP de 84,9 %.

llama.cpp inclut aussi une interface navigateur, ce qui permet de tester le modèle sans passer par l'API.

Ouvrez http://127.0.0.1:8910 dans votre navigateur pour afficher l'interface.

Pour un test plus poussé, j'ai utilisé ce prompt :

Create a stunning single-file animated HTML website with a dark futuristic 
theme, smooth scrolling, glowing gradients, floating particles, animated cards,
hover effects, and responsive design using only HTML, CSS, and JavaScript.

Sur ma RTX 5090, j'obtenais en moyenne environ 142 tokens par seconde, avec des pointes avoisinant 170 tokens par seconde, ce qui est extrêmement rapide pour un modèle 27B exécuté en local. 

Qwen3.8-27B a produit un site web soigné et pleinement fonctionnel, opérationnel immédiatement. C'est une bonne façon d'évaluer rapidement à la fois les capacités de code du modèle et la vitesse de votre configuration locale. 

5. Utiliser Qwen3.8-27B avec Pi

Dans cette section, nous allons connecter Qwen3.8-27B à Pi et l'utiliser comme agent de code entièrement local.

Pi est un agent de code léger en ligne de commande qui vous aide à créer, modifier, tester et déboguer des projets directement depuis le terminal.

Installez Pi avec :

curl -fsSL https://pi.dev/install.sh | sh

L'installeur requiert Node.js et npm. Il installe Pi dans votre préfixe npm global. Si vous n'avez pas encore Node, installez-le d'abord avec nvm ou votre gestionnaire de paquets.

Une fois l'installation terminée, redémarrez votre terminal.

Ensuite, installez l'extension pi-llama et faites pointer Pi vers notre serveur llama.cpp local :

pi install git:github.com/huggingface/pi-llama

export LLAMA_BASE_URL=http://127.0.0.1:8910/v1

Créez un nouveau projet et lancez Pi :

mkdir new-project
cd new-project

Pi

Dans Pi, exécutez /model, recherchez llama-cpp et sélectionnez Qwen3.8-27B.

Pour tester, je lui ai donné ce prompt :

Build a polished personal finance dashboard from scratch that imports CSV 
bank statements, categorizes spending, shows monthly trends and charts, and 
detects unusual expenses; also generate a realistic sample CSV, import it, 
test the full app end-to-end, and fix any errors automatically.

Il a construit l'ensemble du projet en quelques minutes. 

Je lui ai ensuite demandé de démarrer le serveur et de tester à la fois le frontend et la logique applicative. Il a passé davantage de temps à déboguer et tester pour s'assurer que tout fonctionnait correctement.

Lors de mes propres tests, le tableau de bord fonctionnait bien, les graphiques étaient soignés et l'expérience globale fluide.

La principale faiblesse concernait les ajustements d'UI très précis. Après plusieurs relances, il a commencé à faire des modifications sans rapport au lieu de comprendre exactement ce que je voulais, j'ai donc fini par m'arrêter là.

Conclusion

Qwen3.8-27B est encore très récent et la communauté affine activement la meilleure combinaison entre quantification et décodage spéculatif. MTP fonctionne extrêmement bien, mais de nouvelles approches comme DFlash 2 et DSpark sont aussi testées, certains utilisateurs rapportant des vitesses encore plus élevées selon le matériel et la charge. 

Unsloth vient également de publier des GGUF Dynamic v3.0 pour Qwen3.8-27B, avec une hausse revendiquée d'environ 10 % de précision à taille de modèle identique par rapport à ses précédents quants. Unsloth devient ainsi une option très intéressante si vous recherchez une meilleure qualité tout en conservant une configuration d'inférence locale similaire. 

À ce stade, NVFP4 + MTP + llama.cpp me semble l'un des setups les plus simples et rapides sur une RTX 5090. Obtenir environ 140 tokens par seconde avec un modèle 27B tout en profitant d'une grande fenêtre de contexte et de capacités suffisantes pour faire tourner un véritable agent de code est impressionnant. Et ce sera probablement encore plus rapide à mesure que llama.cpp, Unsloth, DFlash 2 et DSpark continuent de progresser.