Qwen3.8-27B lokal auf einer NVIDIA RTX 5090 ausführen: Schritt-für-Schritt-Anleitung

1. llama.cpp für Blackwell-GPUs einrichten

Zuerst stellen wir sicher, dass die GPU korrekt erkannt wird, und prüfen NVIDIA-Treiber sowie CUDA-Version.

nvidia-smi

Du solltest deine RTX 5090, die Treiberversion, die CUDA-Version, den GPU-Speicher und die aktuelle GPU-Auslastung sehen.

Hinweis: Dieses Setup ist speziell für NVIDIA-Blackwell-GPUs wie die RTX 5090. Der folgende Build zielt auf SM120 ab, also die Compute-Architektur der RTX 5090.

Als Nächstes laden und kompilieren wir die aktuelle Version von llama.cpp mit CUDA-Unterstützung.

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)

Wichtig ist hier -DCMAKE_CUDA_ARCHITECTURES=120. Damit baust du llama.cpp gezielt für die Blackwell-Architektur der RTX 5090.

Sobald der Build fertig ist, machen wir llama-server global verfügbar, sodass wir es aus jedem Ordner starten können:

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

Jetzt prüfen wir, ob alles funktioniert:

llama-server --version

Die Ausgabe sollte in etwa so aussehen:

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

Das war’s. Wir haben jetzt einen CUDA-fähigen llama.cpp-Build, der die RTX 5090 und das native Blackwell-NVFP4 nutzen kann.

2. Qwen3.8-27B NVFP4-MTP-Modell herunterladen

Jetzt laden wir das Qwen3.8-27B-Modell.

Installiere zuerst die Hugging Face CLI:

pip install -U huggingface_hub

Lege einen Ordner für das Modell an:

mkdir -p /workspace/models/qwen38

Dann lade das NVFP4-MTP-GGUF herunter:

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

Diese Version wollen wir für dieses Setup, da sie NVFP4 nutzt und MTP-Unterstützung enthält – der Hauptgrund für den großen Geschwindigkeitsgewinn auf der RTX 5090.

3. Qwen3.8-27B-Server starten

Jetzt kommt der spannende Teil. Wir serven Qwen3.8-27B vollständig auf der GPU mit Flash Attention, einem Kontextfenster von 131K und MTP-Spekulationsdecoding für schnellere Generierung. 

Starte:

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

Es gibt hier viele Optionen, aber die meisten dienen einfach dazu, das Maximum aus der 5090 herauszuholen.

Die wichtigsten sind:

• --ctx-size 131072 gibt uns etwa ein 131K-Kontextfenster.

• --n-gpu-layers all hält das Modell komplett auf der GPU.

• --flash-attn on aktiviert Flash Attention.

• --cache-type-k q8_0 und --cache-type-v q8_0 reduzieren den Speicherbedarf des KV-Caches.

• --spec-type draft-mtp aktiviert das MTP-Spekulationsdecoding von Qwen3.8.

• --spec-draft-n-max 4 steuert, wie viele spekulative Tokens MTP auf einmal vorschlagen kann.

Für dieses Setup nutzen wir n-max 4 als Ausgangspunkt für eine RTX 5090. Du kannst auch mit Werten wie 2 (vom Model Card für dieses GGUF empfohlen) oder 3 experimentieren. Die schnellste Einstellung hängt leicht von deinem System ab.

Sobald llama-server das Modell geladen hat, ist Qwen3.8 lokal unter http://127.0.0.1:8910 erreichbar.

Wir haben Qwen3.8-27B nun lokal am Start. Als Nächstes testen wir das Modell über die API und die integrierte Browseroberfläche.

4. Geschwindigkeit und Coding-Performance von Qwen3.8-27B testen

Mit laufendem Server öffnest du ein weiteres Terminal und sendest eine Testanfrage an die OpenAI-kompatible API:

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
 }'

In diesem Test generierte Qwen3.8-27B 2.000 Tokens mit 122 Tokens/Sek. bei einer beeindruckenden MTP-Akzeptanzrate von 84,9%. 

llama.cpp enthält auch eine Browseroberfläche, sodass du das Modell ohne API testen kannst.

Öffne http://127.0.0.1:8910 im Browser, um die UI zu sehen.

Für einen komplexeren Test habe ich diesen Prompt verwendet:

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.

Auf meiner RTX 5090 lag der Schnitt bei rund 142 Tokens pro Sekunde, mit Peaks von etwa 170 Tokens pro Sekunde – extrem schnell für ein 27B-Modell auf lokaler Hardware. 

Qwen3.8-27B hat eine saubere, sofort lauffähige Website erzeugt. So testest du schnell sowohl die Coding-Fähigkeiten des Modells als auch die Geschwindigkeit deines lokalen Setups. 

5. Qwen3.8-27B mit Pi nutzen

In diesem Abschnitt verbinden wir Qwen3.8-27B mit Pi und verwenden es als vollständig lokalen Coding-Agenten.

Pi ist ein schlanker, terminalbasierter Coding-Agent, der dir hilft, Projekte direkt in der Kommandozeile zu bauen, zu bearbeiten, zu testen und zu debuggen.

Installiere Pi mit:

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

Der Installer benötigt Node.js und npm. Er installiert Pi in deinem globalen npm-Prefix. Wenn du Node noch nicht hast, installiere es zuerst mit nvm oder deinem Paketmanager.

Sobald die Installation abgeschlossen ist, starte dein Terminal neu.

Als Nächstes installierst du die pi-llama-Erweiterung und verweist Pi auf unseren lokalen llama.cpp-Server:

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

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

Lege ein neues Projekt an und starte Pi:

mkdir new-project
cd new-project

Pi

In Pi führst du /model aus, suchst nach llama-cpp und wählst Qwen3.8-27B aus.

Zum Test habe ich diesen Prompt verwendet:

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.

Das gesamte Projekt war in wenigen Minuten gebaut. 

Anschließend habe ich es den Server starten lassen und sowohl Frontend als auch Logik testen. Es hat mehr Zeit mit Debugging und Tests verbracht, um sicherzustellen, dass alles sauber läuft.

Bei meinem eigenen Test lief das Dashboard gut, die Diagramme sahen stark aus und das Gesamterlebnis war rund.

Die Hauptschwäche lag bei sehr präzisen UI-Änderungen. Nach mehreren Nachfragen nahm es teils unzusammenhängende Änderungen vor, statt exakt zu verstehen, was ich wollte – dort habe ich dann abgebrochen.

Fazit

Qwen3.8-27B ist noch sehr neu, und die Community lotet aktiv die beste Kombination aus Quantisierung und spekulativem Decoding aus. MTP funktioniert extrem gut, aber neuere Ansätze wie DFlash 2 und DSpark werden ebenfalls getestet – mit Berichten über noch höhere Geschwindigkeiten je nach Hardware und Workload. 

Unsloth hat außerdem gerade Dynamic v3.0-GGUFs für Qwen3.8-27B veröffentlicht und beansprucht rund 10% höhere Genauigkeit bei gleicher Modellgröße gegenüber früheren Quants. Wenn du bei ähnlichem lokalen Inference-Setup mehr Qualität willst, ist Unsloth damit eine sehr interessante Option. 

Aktuell halte ich NVFP4 + MTP + llama.cpp für eines der einfachsten und schnellsten Setups auf einer RTX 5090. Etwa 140 Tokens pro Sekunde aus einem 27B-Modell bei großem Kontextfenster und genug Power für einen echten Coding-Agenten sind beeindruckend. Wahrscheinlich wird das Setup noch schneller, wenn llama.cpp, Unsloth, DFlash 2 und DSpark weiter reifen.