Qwen3.8-27B lokal auf einer NVIDIA RTX 5090 ausführen

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

Zuerst stellen wir sicher, dass die GPU korrekt erkannt wird, und prüfen die 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 untenstehende Build zielt auf SM120 ab – die Compute-Architektur der RTX 5090.

Als Nächstes laden wir die aktuelle Version von llama.cpp herunter und kompilieren sie 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 baut llama.cpp gezielt für die Blackwell-Architektur der RTX 5090.

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

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

Prüfe nun, ob alles läuft:

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 ihr natives Blackwell-NVFP4 nutzt.

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

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

Installiere zuerst die Hugging Face CLI:

pip install -U huggingface_hub

Lege einen Ordner an, in dem wir das Modell ablegen:

mkdir -p /workspace/models/qwen38

Dann lade das NVFP4-MTP-GGUF:

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

Diese Version ist für unser Setup ideal, weil sie NVFP4 nutzt und MTP unterstützt – der Hauptgrund für den großen Geschwindigkeitsschub auf der RTX 5090.

3. Qwen3.8-27B-Server starten

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

Führe aus:

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 vollständig 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 schaltet das MTP-Spekulations-Decoding von Qwen3.8 ein.

• --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 Startwert für eine RTX 5090. Du kannst mit Werten wie 2 (vom Model-Card für dieses GGUF empfohlen) oder 3 experimentieren, da das schnellste Setting je nach System leicht variiert.

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

Qwen3.8-27B läuft jetzt lokal. Als Nächstes testen wir das Modell sowohl über die API als auch über 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. und einer beeindruckenden MTP-Akzeptanzrate von 84,9%. 

llama.cpp enthält auch ein Browser-Interface, sodass du das Modell ohne API testen kannst.

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

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

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 Durchschnitt bei rund 142 Tokens pro Sekunde, mit Spitzen bis etwa 170 Tokens pro Sekunde – extrem schnell für ein lokales 27B-Modell. 

Qwen3.8-27B erzeugte eine saubere, voll funktionsfähige Website, die sofort lief. So lässt sich sowohl die Coding-Fähigkeit des Modells als auch die Geschwindigkeit des lokalen Setups schnell testen. 

5. Qwen3.8-27B mit Pi nutzen

In diesem Abschnitt verbinden wir Qwen3.8-27B mit Pi und nutzen 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. Falls du Node noch nicht hast, installiere es zuerst mit nvm oder deinem Paketmanager.

Starte nach Abschluss der Installation dein Terminal neu.

Installiere anschließend die pi-llama-Erweiterung und verweise 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

Erstelle ein neues Projekt und starte Pi:

mkdir new-project
cd new-project

Pi

Führe in Pi /model aus, suche nach llama-cpp und wähle Qwen3.8-27B.

Zum Testen 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 komplette Projekt war in wenigen Minuten gebaut. 

Anschließend ließ ich den Server starten und sowohl Frontend als auch Logik testen. Es verbrachte mehr Zeit mit Debugging und Tests, um sicherzugehen, dass alles korrekt läuft.

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

Die größte Schwäche waren präzise UI-Anpassungen. Nach mehreren Nachfragen nahm es teils unzusammenhängende Änderungen vor, statt genau zu verstehen, was ich wollte – dort habe ich schließlich aufgehört.

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 – teils mit noch höheren Geschwindigkeiten, abhängig von Hardware und Workload. 

Unsloth hat außerdem gerade Dynamic v3.0-GGUFs für Qwen3.8-27B veröffentlicht und beansprucht etwa 10% höhere Genauigkeit bei gleicher Modellgröße gegenüber den bisherigen 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. Rund 140 Tokens pro Sekunde aus einem 27B-Modell, dazu ein großes Kontextfenster und genug Fähigkeiten für einen echten Coding-Agenten – das ist beeindruckend. Mit weiteren Verbesserungen bei llama.cpp, Unsloth, DFlash 2 und DSpark dürfte das Setup noch schneller werden.