Qwen3.8-27B lokaal draaien op een NVIDIA RTX 5090

1. Stel llama.cpp in voor Blackwell-GPU's

Eerst controleren we of de GPU correct wordt gedetecteerd en controleren we de NVIDIA-driver en CUDA-versie.

nvidia-smi

Je zou je RTX 5090, driverversie, CUDA-versie, GPU-geheugen en huidig GPU-gebruik moeten zien.

Opmerking: Deze setup is specifiek voor NVIDIA Blackwell-GPU's, zoals de RTX 5090. De build hieronder richt zich op SM120, de compute-architectuur die door de RTX 5090 wordt gebruikt.

Vervolgens downloaden en compileren we de nieuwste versie van llama.cpp met CUDA-ondersteuning.

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)

Het belangrijkste onderdeel hier is -DCMAKE_CUDA_ARCHITECTURES=120. Dit vertelt llama.cpp dat het specifiek moet bouwen voor de Blackwell-architectuur die door de RTX 5090 wordt gebruikt.

Zodra de build klaar is, maken we llama-server globaal beschikbaar zodat we het vanuit elke map kunnen draaien:

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

Controleer nu of alles werkt:

llama-server --version

Je zou output moeten krijgen zoals:

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

Dat is het. We hebben nu een CUDA-ingeschakelde llama.cpp-build die kan profiteren van de RTX 5090 en de native Blackwell NVFP4-ondersteuning.

2. Download het Qwen3.8-27B NVFP4-MTP-model

Nu downloaden we het Qwen3.8-27B-model.

Installeer eerst de Hugging Face CLI:

pip install -U huggingface_hub

Maak een map waar we het model bewaren:

mkdir -p /workspace/models/qwen38

Download daarna de NVFP4-MTP GGUF:

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

Dit is de versie die we voor deze setup willen, omdat deze NVFP4 gebruikt en MTP-ondersteuning bevat, wat op de RTX 5090 voor een groot deel van de snelheidswinst zorgt.

3. Start Qwen3.8-27B-server

Nu begint het leuke werk. We serveren Qwen3.8-27B volledig op de GPU met Flash Attention, een context window van 131K en MTP-speculatieve decodering voor snellere generatie. 

Draai:

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

Er zijn hier veel opties, maar de meeste zijn er simpelweg om de beste prestaties uit de 5090 te halen.

De belangrijkste om te kennen zijn:

• --ctx-size 131072 geeft ons grofweg een contextvenster van 131K.

• --n-gpu-layers all houdt het model op de GPU.

• --flash-attn on schakelt Flash Attention in.

• --cache-type-k q8_0 en --cache-type-v q8_0 helpen het KV-cachegeheugen te beperken.

• --spec-type draft-mtp schakelt Qwen3.8's MTP-speculatieve decodering in.

• --spec-draft-n-max 4 bepaalt hoeveel speculatieve tokens MTP tegelijk kan genereren.

Voor deze setup gebruiken we n-max 4 als startpunt voor een RTX 5090. Je kunt ook experimenteren met waarden zoals 2 (wat de modelkaart voor deze GGUF aanraadt) of 3 later, omdat de snelste instelling licht kan variëren per systeem.

Zodra llama-server klaar is met het laden van het model, is Qwen3.8 lokaal beschikbaar op http://127.0.0.1:8910.

We hebben Qwen3.8-27B nu lokaal draaien. Vervolgens testen we het model via zowel de API als de ingebouwde browserinterface.

4. Test de snelheid en codeerprestaties van Qwen3.8-27B

Met de server actief, open je een andere terminal en stuur je een testverzoek naar de OpenAI-compatibele 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 deze test genereerde Qwen3.8-27B 2.000 tokens met 122 tokens/sec en een indrukwekkend MTP-acceptatiepercentage van 84,9%. 

llama.cpp bevat ook een browserinterface, zodat je het model kunt testen zonder de API te gebruiken.

Open http://127.0.0.1:8910 in je browser om de UI te zien.

Voor een complexere test gebruikte ik deze 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.

Op mijn RTX 5090 haalde ik gemiddeld rond de 142 tokens per seconde, met generatiepieken tot ongeveer 170 tokens per seconde, wat extreem snel is voor een 27B-model dat lokaal draait. 

Qwen3.8-27B genereerde een gepolijste, volledig werkende website die direct uit de doos draaide. Dit is een goede manier om snel zowel de codeercapaciteiten van het model als de snelheid van de lokale setup te testen. 

5. Gebruik Qwen3.8-27B met Pi

In deze sectie koppelen we Qwen3.8-27B aan Pi en gebruiken we het als een volledig lokale codeeragent.

Pi is een lichte, terminalgebaseerde codeeragent die je kan helpen projecten te bouwen, bewerken, testen en debuggen rechtstreeks vanuit de command line.

Installeer Pi met:

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

De installer vereist Node.js en npm. Hij installeert Pi in je globale npm-prefix. Als je nog geen Node hebt, installeer dat dan eerst met nvm of je pakketbeheerder.

Zodra de installatie is voltooid, herstart je je terminal.

Installeer vervolgens de pi-llama-extensie en wijs Pi naar onze lokale llama.cpp-server:

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

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

Maak een nieuw project en start Pi:

mkdir new-project
cd new-project

Pi

Binnen Pi voer je /model uit, zoek je naar llama-cpp en selecteer je Qwen3.8-27B.

Voor het testen gaf ik deze prompt mee:

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.

Het bouwde het hele project binnen enkele minuten. 

Daarna vroeg ik om de server te starten en zowel de frontend als de applicatielogica te testen. Het besteedde meer tijd aan debuggen en testen om zeker te zijn dat alles goed werkte.

Toen ik het dashboard zelf testte, werkte de app goed, zagen de grafieken er top uit en was de algehele ervaring soepel.

De grootste zwakte was het aanbrengen van precieze UI-wijzigingen. Na meerdere opvolgprompts begon het ongerelateerde wijzigingen te maken in plaats van precies te begrijpen wat ik bedoelde, dus daar ben ik uiteindelijk gestopt.

Laatste gedachten

Qwen3.8-27B is nog erg nieuw en de community zoekt actief naar de beste combinatie van quantization en speculatieve decodering. MTP werkt bijzonder goed, maar nieuwere benaderingen zoals DFlash 2 en DSpark worden ook getest, waarbij sommige gebruikers nog hogere snelheden rapporteren afhankelijk van hardware en workload. 

Unsloth heeft zojuist ook Dynamic v3.0-GGUF's voor Qwen3.8-27B uitgebracht, met de claim dat ze ongeveer 10% hogere nauwkeurigheid bieden bij dezelfde modelgrootte vergeleken met de vorige quants. Dit maakt Unsloth een andere zeer interessante optie als je betere kwaliteit wilt met grofweg dezelfde lokale inference-setup. 

Voor nu vind ik NVFP4 + MTP + llama.cpp een van de eenvoudigste en snelste setups voor een RTX 5090. Ongeveer 140 tokens per seconde halen uit een 27B-model, terwijl je toch een groot contextvenster hebt en genoeg capaciteit om een echte codeeragent te draaien, is indrukwekkend. De setup wordt waarschijnlijk nog sneller naarmate llama.cpp, Unsloth, DFlash 2 en DSpark blijven verbeteren.