Come eseguire Qwen3.8-27B in locale su una NVIDIA RTX 5090

1. Configura llama.cpp per GPU Blackwell

Per prima cosa, assicuriamoci che la GPU venga rilevata correttamente e verifichiamo versione del driver NVIDIA e di CUDA.

nvidia-smi

Dovresti vedere la tua RTX 5090, la versione del driver, la versione di CUDA, la memoria GPU e l’utilizzo corrente della GPU.

Nota: questa configurazione è specifica per le GPU NVIDIA Blackwell, come la RTX 5090. La build qui sotto è mirata a SM120, l’architettura di calcolo usata dalla RTX 5090.

Poi scaricheremo e compileremo l’ultima versione di llama.cpp con supporto 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)

La parte importante qui è -DCMAKE_CUDA_ARCHITECTURES=120. Questo dice a llama.cpp di compilare specificamente per l’architettura Blackwell usata dalla RTX 5090.

Una volta terminata la build, renderemo llama-server disponibile globalmente così da poterlo eseguire da qualsiasi cartella:

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

Ora verifica che tutto funzioni:

llama-server --version

Dovresti ottenere un output simile a:

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

Ecco fatto. Ora abbiamo una build di llama.cpp con CUDA in grado di sfruttare la RTX 5090 e il supporto NVFP4 nativo di Blackwell.

2. Scarica il modello Qwen3.8-27B NVFP4-MTP

Ora scaricheremo il modello Qwen3.8-27B.

Per prima cosa, installa la CLI di Hugging Face:

pip install -U huggingface_hub

Crea una cartella in cui conserveremo il modello:

mkdir -p /workspace/models/qwen38

Poi scarica il GGUF NVFP4-MTP:

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

Questa è la versione che vogliamo per questa configurazione perché usa NVFP4 e include il supporto MTP, da cui deriva gran parte del miglioramento di velocità sulla RTX 5090.

3. Avvia il server Qwen3.8-27B

Ora arriva la parte divertente. Serviremo Qwen3.8-27B completamente su GPU con Flash Attention, una finestra di contesto da 131K e MTP speculative decoding per una generazione più veloce. 

Esegui:

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

Ci sono molte opzioni qui, ma la maggior parte serve semplicemente a ottenere le migliori prestazioni dalla 5090.

Le principali da conoscere sono:

• --ctx-size 131072 ci dà una finestra di contesto di circa 131K.

• --n-gpu-layers all mantiene il modello sulla GPU.

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

• --cache-type-k q8_0 e --cache-type-v q8_0 aiutano a ridurre l’uso di memoria della KV cache.

• --spec-type draft-mtp abilita l’MTP speculative decoding di Qwen3.8.

• --spec-draft-n-max 4 controlla quanti token speculativi MTP può generare alla volta.

Per questa configurazione usiamo n-max 4 come punto di partenza per una RTX 5090. Puoi sperimentare con valori come 2 (che la scheda del modello consiglia per questo GGUF) o 3 in seguito, dato che l’impostazione più veloce può variare leggermente a seconda del sistema.

Una volta che llama-server ha finito di caricare il modello, Qwen3.8 sarà disponibile in locale su http://127.0.0.1:8910.

Ora abbiamo Qwen3.8-27B in esecuzione in locale. Successivamente, testeremo il modello sia tramite API che tramite l’interfaccia browser integrata.

4. Testa velocità e prestazioni di coding di Qwen3.8-27B

Con il server attivo, apri un altro terminale e invia una richiesta di test all’API compatibile con 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
 }'

In questo test, Qwen3.8-27B ha generato 2.000 token a 122 token/sec con un impressionante tasso di accettazione MTP dell’84,9%. 

llama.cpp include anche un’interfaccia browser, così puoi testare il modello senza usare l’API.

Apri http://127.0.0.1:8910 nel browser per vedere la UI.

Per un test più complesso, ho usato questo 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.

Sulla mia RTX 5090, in media ottenevo circa 142 token al secondo, con picchi di generazione intorno ai 170 token al secondo, che è estremamente veloce per un modello 27B in locale. 

Qwen3.8-27B ha generato un sito web rifinito e perfettamente funzionante subito, senza ulteriori interventi. È un buon modo per testare rapidamente sia la capacità di coding del modello sia la velocità della configurazione locale. 

5. Usa Qwen3.8-27B con Pi

In questa sezione collegheremo Qwen3.8-27B a Pi e lo useremo come agente di coding completamente locale.

Pi è un agente di coding leggero basato su terminale che può aiutarti a creare, modificare, testare ed effettuare il debug dei progetti direttamente dalla riga di comando.

Installa Pi con:

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

L’installer richiede Node.js e npm. Installa Pi nel prefisso npm globale. Se non hai ancora Node, installalo prima con nvm o con il tuo gestore pacchetti.

Al termine dell’installazione, riavvia il terminale.

Poi installa l’estensione pi-llama e punta Pi al nostro server locale di llama.cpp:

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

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

Crea un nuovo progetto e avvia Pi:

mkdir new-project
cd new-project

Pi

Dentro Pi, esegui /model, cerca llama-cpp e seleziona Qwen3.8-27B.

Per i test, gli ho dato questo 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.

Ha costruito l’intero progetto in pochi minuti. 

Gli ho poi chiesto di avviare il server e testare sia il frontend sia la logica dell’applicazione. Ha passato più tempo a fare debugging e test per assicurarsi che tutto funzionasse correttamente.

Quando ho testato il dashboard personalmente, l’app funzionava bene, i grafici erano ottimi e l’esperienza generale fluida.

La principale debolezza è stata l’esecuzione di modifiche di UI precise. Dopo diversi prompt di follow-up, ha iniziato a fare cambiamenti non correlati invece di capire esattamente cosa volessi, quindi alla fine mi sono fermato lì.

Considerazioni finali

Qwen3.8-27B è ancora molto nuovo e la community sta attivamente individuando la migliore combinazione di quantizzazione e speculative decoding. MTP funziona estremamente bene, ma si stanno testando anche approcci più recenti come DFlash 2 e DSpark, con alcuni utenti che riportano velocità ancora maggiori a seconda dell’hardware e del carico di lavoro. 

Unsloth ha appena rilasciato anche i GGUF Dynamic v3.0 per Qwen3.8-27B, dichiarando circa il 10% di accuratezza in più a parità di dimensione del modello rispetto ai precedenti quant. Questo rende Unsloth un’altra opzione molto interessante se vuoi una qualità migliore mantenendo grosso modo la stessa configurazione di inference locale. 

Per ora, penso che NVFP4 + MTP + llama.cpp sia una delle configurazioni più semplici e veloci per una RTX 5090. Ottenere intorno ai 140 token al secondo da un modello 27B, pur mantenendo una finestra di contesto ampia e abbastanza capacità per eseguire un vero agente di coding, è notevole. La configurazione probabilmente diventerà ancora più veloce man mano che llama.cpp, Unsloth, DFlash 2 e DSpark continueranno a migliorare.