Qwen 3.8 27B: guida hardware, dalla RTX 3090 al DGX Spark

Qwen 3.8 27B: guida hardware, dalla RTX 3090 al DGX Spark

Il 14 agosto 2026 il team Qwen di Alibaba ha pubblicato i pesi di Qwen3.8-27B con licenza Apache 2.0 su Hugging Face – rendendolo il modello locale più interessante del momento nella classe 27B. Un modello vision-language denso e nativamente multimodale (testo, immagini, video), con un contesto nativo di 262.144 token (estendibile a 1M via YaRN), una testa di multi-token prediction (MTP) integrata e un punteggio Artificial Analysis di 52 – che sull'Agentic Index lo colloca davanti a modelli frontier ben più grandi. Su X lo sviluppatore Sero (@0xSero) ha riassunto così: un modello che gira su ~3.000 $ di hardware batte all'improvviso tutto ciò che quattro mesi fa era lo stato dell'arte.

La domanda decisiva per chi vuole ospitarlo in locale: su quale hardware gira – e a che velocità? La risposta onesta ha due livelli. I benchmark di base del weekend di rilascio (llama.cpp senza tuning) e ciò che la community ci ha costruito sopra in soli cinque giorni. A seconda della piattaforma, la differenza è di un fattore da 2 a 8. Abbiamo raccolto entrambi: le serie di misure di Hardware Corner, i test di Simon Willison, i repository GitHub di Mia AI Lab, r0b0tlab e syv-ai, le discussioni su Hugging Face, il rilascio di DFlash 2 da parte di z-lab/Inco AI e i post su X dei primi giorni.

⚡ Aggiornato al 19 agosto 2026. Questo ecosistema si muove ogni giorno – tutti i numeri sono istantanee con fonte indicata.

Il modello in 60 secondi

• 27,8 miliardi di parametri, denso – niente mixture-of-experts. Ogni token generato attraversa l'intera rete. Questo rende la banda di memoria il fattore decisivo – e lo speculative decoding la leva più grande, perché verifica più token per forward pass.
• Architettura: 64 layer, di cui 48 Gated DeltaNet e 16 full attention, più una testa MTP addestrata inclusa nel checkpoint.
• Multimodale: comprensione nativa di immagini e video (gli utenti GGUF hanno bisogno in più del vision projector da ~0,93 GB).
• Modalità di ragionamento: xhigh (default!), medium, low. Il default pensa in modo eccessivo – a Simon Willison sono serviti 21 minuti per un prompt SVG con esso, poco più di 2 minuti senza reasoning. Per hardware locale: low o medium.

Requisiti di memoria: il vero biglietto d'ingresso

Il checkpoint BF16 completo pesa ~56 GB. Solo la quantizzazione lo trasforma in un modello consumer:

A questo si aggiunge la KV cache: con una build Q4, Hardware Corner ha misurato 18 GB a 4k, 22 GB a 64k, 26 GB a 128k e 34 GB a 256k di contesto. La community ha già spostato questi limiti – con KV cache in FP8 (metà dell'ingombro), embedding quantizzati (2,6 GB risparmiati, dettagli sotto) e quantizzazione KV in llama.cpp. Regola pratica comunque:

24 GB di VRAM = 64k di contesto out of the box. 32 GB = 128k. I 262k completi su 24 GB solo con tuning – oppure con memoria unificata.

---

1. PC desktop classico con GPU (RTX 3090 / 4090 / 5090)

Baseline: llama.cpp, Q4, MTP disattivato (Hardware Corner)

Questo è ciò che si ottiene avviando semplicemente llama-server. Solido – ma molto al di sotto di ciò che l'hardware può fare.

Cosa ne ha fatto la community (al 19/08)

RTX 3090 – la star della settimana. Il repo syv-ai/qwen38-27b-rtx3090 mostra cosa ottiene uno stack vLLM ottimizzato su una singola 3090, perfino limitata a 250 W: ~114 t/s single-user con sampling di default (118–124 t/s greedy) con contesto 64k, ancora 95–100 t/s a 150k di contesto – e in modalità batch ~1.000 t/s aggregati su 64 richieste parallele. Gli ingredienti: GEMM int8 sui tensor core, draft MTP con vocabolario ridotto, LM head int4 calibrata e un trucco che libera 2,6 GB di VRAM: Qwen3.8 ha embedding non legati, e i quant W4A16 pubblici si portano dietro due matrici BF16 da 2,5 GB non quantizzate – il repo le riquantizza entrambe in int8 senza perdita di qualità misurabile.

RTX 5090. Uno sviluppatore giapponese (note.com) aveva il modello nel proprio setup quotidiano circa un'ora dopo il rilascio e misura 148,3 t/s sul codice e 128,6 t/s su prosa giapponese con una configurazione di speculative decoding messa a punto. Una discussione su Hugging Face riporta 98 t/s con il quant Q6 più MTP, e il team SGLang 200+ t/s con NVFP4 + speculative decoding. La serie di misure di KGP Talkie (45 configurazioni) conferma il meccanismo: --spec-type draft-mtp con profondità di draft 3 = un fattore 1,81 gratis, senza perdite, perché i token speculativi vengono verificati.

La prova Blackwell da 24 GB. Su una RTX PRO 4000 (24 GB) il modello gira a 50,4 t/s di media in produzione – con l'intero contesto da 256k, grazie a patch llama.cpp bloccate su commit precisi. L'MTP integrato ha portato lì il throughput da 21,2 a 59,5 t/s (2,81x); la build custom ha aggiunto un ulteriore +22 % rispetto al master pulito.

Nuovo verdetto: la 3090 non è più solo la scelta economica – con lo stack giusto è un nodo di serving a tutti gli effetti. La 4090 beneficia delle stesse leve. La 5090 resta la singola GPU più veloce, ma il divario si riduce non appena la speculation gira ovunque.

---

2. Laptop con GPU: il caso RTX 5080 (16 GB)

Qui resta scomodo, per un solo motivo: la RTX 5080 Laptop ha 16 GB di VRAM – e il più piccolo file 4 bit utilizzabile pesa 17,1 GB. Il Q4 non entra completamente nella scheda. Tre opzioni realistiche:

1. UD-Q3_K_XL (13,4 GB) interamente in VRAM. Gira pulito con contesto 8–16k e beneficia dei ~896 GB/s della scheda. Misure affidabili per esattamente questa combinazione mancano ancora; l'aritmetica della banda suggerisce velocità di decode nella lega della baseline desktop da 24 GB – con la perdita di qualità di un quant a 3 bit.
2. Q4 con offload parziale nella RAM di sistema. Una prova di pazienza: il test di riferimento su una RTX 5070 Ti Laptop (12 GB) ha dato 3,3–4,5 t/s in decode e 20–27 t/s in prefill. Su 16 GB la quota in offload è minore, ma lo schema resta: appena i pesi vivono nella RAM di sistema, la velocità crolla a una cifra.
3. NVFP4 (~16,5 GB di pesi) è anch'esso troppo stretto su 16 GB una volta aggiunti KV cache e runtime.

Verdetto laptop: 16 GB è la via di mezzo infelice per questo modello. Chi compra un laptop apposta punta alla RTX 5090 Laptop (24 GB) – lì Q4/Q5 stanno interamente in VRAM, e le ricette di tuning desktop (MTP, DFlash 2) si trasferiscono, limitate da power limit e raffreddamento. Sulla 5080 il modello resta un esperimento, non un daily driver.

---

3. Mac mini (M4 / M4 Pro)

Apple Silicon ribalta la logica: invece di un limite VRAM rigido c'è la memoria unificata, quasi tutta disponibile alla GPU. Il prezzo è la banda.

Punto di riferimento per il limite inferiore: un M2 Pro con 16 GB ha raggiunto 7,1 t/s misurati con il quant a 2 bit – la stessa macchina è fallita del tutto a 4 bit. Solo l'M4 Pro, con 2,3 volte la banda, trasforma il Mac mini in un host Qwen serio. Importante per tutti i Mac: usare MLX invece di GGUF (dettagli nella sezione MacBook) – sui chip M5 porta circa il 40 % di decode in più.

---

4. MacBook Pro (M4 Pro / M4 Max / M5 Pro / M5 Max)

Baseline: llama.cpp/LM Studio su M5 Max (128 GB)

Simon Willison conferma l'ordine di grandezza nella pratica: 15–30 t/s in LM Studio – sufficienti per chat, coding agent (testati con Pi) e compiti vision, ma sensibilmente più lenti delle API hosted.

Il salto MLX

La community MLX ha rilanciato subito: una conversione MLX misurata raggiunge ~33 t/s a 4 bit sull'M5 Max con solo 15,5 GB di memoria di picco (8 bit: ~18 t/s a 28,9 GB, BF16: ~10 t/s a 54 GB). Sull'M5 Pro un test di deployment documenta +40 % rispetto al GGUF: da ~28 a ~40 t/s – i neural accelerator della GPU M5 pagano direttamente. Due avvertenze: la conversione mlx-lm pura è solo testo (vision encoder e drafter MTP vengono rimossi); chi ha bisogno delle immagini usa le build mlx-vlm della mlx-community. E dal 18/08 lo speculative decoding esiste anche su Mac: la build oMLX con supporto DFlash 2 gira, secondo la demo di Inco, sull'M5 Max con il modello MLX a 4 bit più il drafter DFlash 2 – portando anche su Apple Silicon valori ben oltre i 40 t/s a portata di mano.

Collocare le varianti: un MacBook Pro con M4 Pro (24–48 GB) si comporta come il Mac mini M4 Pro. M4 Max / M5 Max da 36–48 GB è la scelta laptop Apple comoda. Il grande vantaggio rispetto a qualsiasi laptop Windows resta: 64–128 GB di memoria unificata permettono Q8, vision e contesti lunghi insieme – in silenzio, a batteria.

---

5. Mac Studio (M4 Max / M3 Ultra)

Il Mac Studio è la via workstation silenziosa. A 546 GB/s l'M4 Max si colloca ben sopra il livello MacBook, e le velocità di decode salgono di conseguenza – verso il territorio della baseline RTX 3090, senza rumore di ventole. Vale la stessa regola: usare build MLX, e con oMLX + DFlash 2 si aggiunge la speculation. L'M3 Ultra quasi raddoppia la banda; difficile da giustificare economicamente per il solo Qwen 3.8 27B, interessante se sulla stessa macchina devono girare anche modelli 70B+.

---

6. NVIDIA DGX Spark (GB10): da sorvegliato speciale a nodo di serving

Lo Spark è il miglior esempio di quanto in fretta il quadro si sia ribaltato in cinque giorni.

Baseline: llama.cpp, Q4 (Hardware Corner, Dell Pro Max GB10)

Con 273 GB/s di banda LPDDR5x, il 27B denso è fiacco in llama.cpp stock – Simon Willison otteneva 15–30 t/s in LM Studio e guadagnava già +72 % con --spec-type draft-mtp.

Stato della community al 19/08: SGLang + NVFP4 + speculation

Mia AI Lab (MiaAI-Lab/Qwen3.8-27B-SGLang-DGX-Spark) ha trasformato lo Spark in un vero server: ~33–35 t/s a flusso singolo con MTP e ~195–210 t/s aggregati su 10 flussi paralleli – con fino a 1M di contesto via YaRN, senza differenza di velocità tra 256k e 1M. In più, fix di sistema concreti: il GB10 nasconde 10 core CPU veloci e 10 lenti – il pinning del server sui veloci ha portato +5 %, e la correzione di una doppia riserva di memoria nel pool di stato GDN ha liberato altre risorse. Il repo gemello fornisce l'equivalente vLLM con NVFP4 di Unsloth, KV cache FP8 e MTP.

r0b0tlab (qwen38-27b-nvfp4-sm121-sglang) fornisce le valutazioni accuratamente appaiate sullo Spark (NVFP4, think-off): DFlash 2 vincitore in produzione con 28,4 t/s a flusso singolo e una scala di concorrenza da 23,5 (c1) a 55,0 (c4) fino a 92,1 t/s a c8 – la variante EAGLE/MTP raggiunge perfino 123,9 t/s a c8. Sul set reale di 200 task di qualità, DFlash 2 ha fatto in media 47,5 t/s end-to-end, +40 % rispetto al precedente setup DSpark, con punteggi GSM8K/HumanEval/IFEval identici.

Nuovo verdetto Spark: non più una lumaca, ma un nodo di serving silenzioso da 128 GB per piccoli team – e resta unico nel fatto che contesti da 256k–1M semplicemente ci stanno.

---

7. AMD Strix Halo (Ryzen AI Max+ 395)

Strix Halo (Radeon 8060S, fino a 128 GB LPDDR5X, 256 GB/s) è la risposta x86 alla memoria unificata di Apple – con una community di tuning molto attiva:

I punti chiave:

• L'MTP è la singola leva più grande su Strix Halo – fino a un fattore 2,83. Ma: la profondità di draft di default di llama.cpp (16) dimezza il throughput; l'ottimo è 3–4.
• Split di backend: ROCm offre il prefill migliore da 16k in su (~330 vs ~267 t/s), Vulkan il decode migliore.
• Il prefill è il tallone d'Achille: un prompt da 32k richiede circa due minuti prima del primo token.
• Attenzione ai record: i valori da 60 t/s sono massimi a freddo; la speculation n-gram può inoltre falsare i benchmark, perché i prompt ripetuti addestrano la cache – un tester ha visto ~180 t/s apparenti dove i reali erano ~47. Il realistico è 11–24 t/s in chat effettiva – dopo il tuning, livello MacBook, con 128 GB di memoria a un prezzo molto più basso. Si delinea un percorso DFlash 2 per ROCm (la PR llama.cpp è agnostica al backend); mancano ancora misure Strix.

---

Tuning di velocità: le quattro leve che funzionano ovunque

1. Abbassare reasoning_effort. Il default xhigh è inutilizzabile su hardware consumer. Misurato: reasoning spento = risposta visibile 10 volte più veloce, medium costa quasi nulla. Perfino l'endpoint community gratuito di HF è passato nel frattempo a medium di default.
2. DFlash 2 (nuovo, 18/08) – la nuova leva di punta. Il drafter block-diffusion di z-lab/Inco AI (z-lab/Qwen3.8-27B-DFlash2, mirror di incoai/…) è un modello di draft separato da 2B (~4 GB) che abbozza interi blocchi di token in parallelo; un selettore leggero sceglie il percorso coerente, il modello target verifica – output dimostrabilmente identico (rejection sampling). La misura della model card su una H200 (SGLang, blocco 8): flusso singolo da 69 t/s autoregressivi a 184–236 t/s a seconda del task (2,67–3,43x) – la testa MTP nativa lì arriva a 135–179 t/s. Lunghezza di accettazione media: 4,80 token per verifica contro 4,28 dell'MTP. Disponibile in SGLang (PR #35371, merged il 19/08), vLLM, llama.cpp (--spec-type draft-dflash) e via oMLX su Apple Silicon.
3. Attivare l'MTP quando non c'è un drafter DFlash 2 a portata (--spec-type draft-mtp, profondità 3–4): +72 % sullo Spark, +81 % sulla 5090, +183 % su Strix Halo. La testa è già nel GGUF (layer 64) – nessun secondo download necessario.
4. Liberare memoria: quantizzare la KV cache (q8_0/q4_0, oppure FP8 in vLLM/SGLang – metà dell'ingombro KV) e, sui quant W4A16, riquantizzare in int8 le due matrici di embedding da 2,5 GB non quantizzate (2,6 GB di VRAM recuperati, nessuna perdita di qualità misurabile). Esattamente questa combinazione porta 150k–262k di contesto sulle schede da 24 GB.

Concorrenza: dal posto singolo al serving – ora con numeri veri

Poiché Qwen 3.8 27B è denso, ogni token legge tutti i 27B di parametri – il flusso singolo è limitato dalla banda. È esattamente per questo che il batching scala in modo più che proporzionale: le letture dei pesi vengono ammortizzate sul batch. La community ora l'ha misurato:

Tre regole ne derivano:

• La speculation perde valore al crescere del carico – ma a ritmi diversi. Sulla 3090 il punto di crossover verso il puro continuous batching stava intorno a ~8 utenti paralleli (syv-ai). La misura H200 di z-lab mostra lo stesso schema con precisione: a c32 MTP/DSpark scendono a 0,77–1,13x (a volte più lenti dell'autoregressivo), mentre DFlash 2 tiene ancora 1,16–1,45x – un drafter migliore sposta il crossover molto più in là.
• Il budget KV determina la concorrenza: ~64 KB/token in BF16 per sequenza nei 16 layer full attention (FP8: la metà) – su una 5090, dopo i pesi NVFP4, abbastanza per 20+ sessioni 8k parallele. Insidia SGLang su questo modello ibrido GDN: --mamba-full-memory-ratio (default 0,9) sovradimensiona il pool KV e limita silenziosamente la concorrenza.
• Ollama/LM Studio elaborano le richieste in modo largamente sequenziale – la scelta sbagliata per il serving. Su Mac e Strix Halo, 2–4 flussi paralleli restano il massimo sensato.

Confronto complessivo (al 19/08/2026)

Conclusione

Qwen 3.8 27B è il primo modello aperto a racchiudere vision, 262k di contesto, tool calling e serie capacità di coding in un file da 17 GB. La lezione più importante della prima settimana: l'hardware è raramente il collo di bottiglia – lo è lo stack di inferenza. Tra llama.cpp stock e un setup vLLM/SGLang ottimizzato con MTP o DFlash 2 c'è un fattore da 2 a 8, a parità di hardware.

• Serving & qualità-prezzo: una RTX 3090 usata + lo stack syv-ai – 114 t/s singolo, ~1.000 t/s in batch, per una frazione di un setup datacenter.
• Massima velocità mono-utente: RTX 5090 con NVFP4 + speculation (148–200+ t/s).
• Mac: Mac mini M4 Pro 48 GB per iniziare, Mac Studio M4 Max 64 GB per il comfort – in ogni caso MLX invece di GGUF, e tenere d'occhio oMLX + DFlash 2.
• In mobilità: MacBook Pro M5 Pro/Max da 48 GB (~40 t/s con MLX) o RTX 5090 Laptop – non la 5080.
• Contesto lungo & piccoli team: DGX Spark con la ricetta di Mia AI Lab o r0b0tlab – 210 t/s aggregati fino a 1M di contesto.
• 128 GB a budget: Strix Halo, a livello MacBook dopo il tuning MTP.

E ovunque giri: reasoning_effort su low/medium, attivare DFlash 2 o MTP, quantizzare KV cache ed embedding. Queste mosse contano più della prossima generazione di GPU.

---

Fonti (consultate dal 15 al 19/08/2026): model card Qwen3.8-27B · benchmark Hardware Corner · Simon Willison · syv-ai/qwen38-27b-rtx3090 (GitHub) · MiaAI-Lab/Qwen3.8-27B-SGLang-DGX-Spark (GitHub) & @MiaAI_lab su X · r0b0tlab/qwen38-27b-nvfp4-sm121-sglang (GitHub) · Inco AI: DFlash 2 & z-lab/Qwen3.8-27B-DFlash2 (benchmark H200) · setup speculativo RTX 5090 (note.com) · 50 t/s su Blackwell 24 GB a 256k (piszczek.pl) · KGP Talkie: 45 configurazioni llama.cpp · @witcheer, @victormustar & @0xSero su X · misure MLX M5 Max & mlx-community · repo & guida GGUF Unsloth · blog AMD day 0 · julianmb/q38rocm & KyaniteLabs (GitHub) · cookbook SGLang · guida hardware Kingy.ai · VentureBeat. Tutti i valori sono misure della community o dei produttori dei primi cinque giorni dopo il rilascio; gli stati del software cambiano ogni giorno.