---
type: "BlogPosting"
title: "Qwen 3.8 27B: guida hardware, dalla RTX 3090 al DGX Spark"
description: "Qwen3.8-27B gira su una gamma sorprendente di hardware – ma a che velocità reale? Benchmark baseline vs ottimizzati dalla community (al 19/08/2026): una RTX 3090 a ~1.000 tok/s su 64 flussi paralleli, una RTX 5090 a 148 tok/s, un DGX Spark a 210 tok/s aggregati, DFlash 2 a 3,4x su H200 – più RTX 5080 laptop, Mac mini, MacBook Pro, Mac Studio e AMD Strix Halo con prefill, decode e concorrenza."
resource: "https://www.contextstudios.ai/it/blog/qwen-3-8-27b-hardware-guide"
language: "it"
tags: ["AI", "Local LLM", "Hardware", "Qwen", "Benchmarks"]
generated:
  by: "process:contextstudios-md/1"
  at: "2026-10-06T03:55:56.083Z"
status: "stable"
---

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

Published: 2026-08-19
Tags: AI, Local LLM, Hardware, Qwen, Benchmarks

![Qwen 3.8 27B: guida hardware, dalla RTX 3090 al DGX Spark](https://wary-platypus-754.convex.cloud/api/storage/3c0ded64-1517-470c-a615-0636ece2a365)

# 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:

| Formato | Dimensione file | Memoria totale realistica |
|---|---|---|
| UD-Q2_K_XL (2 bit) | 10,7 GB | 16–24 GB |
| UD-Q3_K_XL (3 bit) | 13,4 GB | 24 GB |
| Q4_K_M (4 bit standard) | 17,1 GB | 24–32 GB |
| UD-Q4_K_XL (4 bit dinamico) | 17,9 GB | 24–32 GB |
| Q6_K | 22,9 GB | 32–48 GB |
| Q8_0 | 29,1 GB | 48–64 GB |
| NVFP4 (solo Blackwell) | ~16,5 GB | 24–32 GB VRAM |
| BF16 | ~56 GB | da 64 GB |

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)

| Contesto | RTX 3090 (24 GB) – Prefill / Decode | RTX 4090 (24 GB) – Prefill / Decode | RTX 5090 (32 GB) – Prefill / Decode |
|---|---|---|---|
| 4k | 1.308 / 40,3 t/s | 2.963 / 46,2 t/s | 3.750 / 74,8 t/s |
| 32k | 977 / 37,0 t/s | 2.367 / 42,2 t/s | 1.146 / 29,0 t/s |
| 64k | 767 / 34,0 t/s | 1.918 / 38,4 t/s | 718 / 26,2 t/s |
| 128k | – (limite VRAM) | – (limite VRAM) | 461 / 22,8 t/s |

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.

| Configurazione | Banda | Cosa gira | Verdetto |
|---|---|---|---|
| M4, 16 GB | 120 GB/s | solo 2 bit, contesto corto | esperimento, non un consiglio d'acquisto |
| M4, 24–32 GB | 120 GB/s | Q3/Q4 | gira, ma lento (t/s a una cifra realistici) |
| M4 Pro, 48 GB | 273 GB/s | da Q4 a Q8 con margine | **miglior rapporto qualità-prezzo Mac** |
| M4 Pro, 64 GB | 273 GB/s | Q8 + vision + contesto ampio | comodo |

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)

| Contesto | Prefill (t/s) | Decode (t/s) |
|---|---|---|
| 4k | 834 | 31,4 |
| 16k | 544 | 23,6 |
| 32k | 517 | 21,6 |
| 64k | 425 | 18,2 |

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)

| Configurazione | Banda | Verdetto |
|---|---|---|
| M4 Max, 36 GB | 410 GB/s | Q4/Q5 veloci; Q8 diventa stretto |
| M4 Max (GPU 40 core), 64 GB | 546 GB/s | **sweet spot**: Q8, vision, contesto lungo, spazio per altre app |
| M3 Ultra, 96 GB+ | 819 GB/s | il decode Mac più veloce, perfino BF16 possibile – overkill per un singolo 27B |

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)

| Contesto | Prefill (t/s) | Decode (t/s) |
|---|---|---|
| 4k | 813 | 12,2 |
| 64k | 576 | 9,7 |
| 128k | 442 | 8,0 |
| 256k | 228 | 5,9 |

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:

| Setup | Decode (t/s) | Fonte |
|---|---|---|
| Giorno del rilascio, Q5 / Q8, senza tuning | 10,5 / 7,5 | Reddit r/StrixHalo |
| Baseline Q4_K_M vs MTP ottimizzato | 10,7 → **30,3** (fattore 2,83) | Hugging Face (kingjones777) |
| AMD ufficiale, llama.cpp Vulkan, MTP=4 | fino a 24,5 | Blog AMD (day 0) |
| Build community ROCmFP4 + MTP | 30,6–36,0 | GitHub (julianmb/q38rocm) |
| Stack di speculation (MTP n12 + ngram), ctx 96k | 59,7–64 a freddo / **11–24 in chat reale** | GitHub (KyaniteLabs) |

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:

| Sistema | Flusso singolo | Aggregato in concorrenza | Fonte |
|---|---|---|---|
| RTX 3090 (250 W!), vLLM ottimizzato | ~114 t/s | **~1.000 t/s @ 64 richieste** | syv-ai |
| DGX Spark, SGLang + MTP | 33–35 t/s | **195–210 t/s @ 10 flussi** | Mia AI Lab |
| DGX Spark, SGLang + DFlash 2 / EAGLE | 28 / 26 t/s | 92 / **124 t/s @ c8** | r0b0tlab |
| H200, SGLang + DFlash 2 | 184–236 t/s | 1.090–1.368 @ c8 · **1.525–1.952 @ c32** | model card z-lab |
| H200 (endpoint community), spec decoding | 70 → **126 t/s** | – | V. Mustar (HF) |

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)

| Hardware | Memoria | Decode baseline | Ottimizzato community | Contesto max pratico | Carattere |
|---|---|---|---|---|---|
| RTX 3090 | 24 GB | 40 t/s | **114 t/s singolo · ~1.000 t/s @64** | 150k–262k (ottimizzato) | vincitore qualità-prezzo **e** serving |
| RTX 4090 | 24 GB | 46 t/s | ricette 3090 trasferibili, più veloce | 64k+ | la scheda 24 GB più veloce |
| RTX 5090 | 32 GB | 75 t/s | **148 t/s** (spec) · 200+ (NVFP4/SGLang) | 128k+ | re della velocità |
| RTX 5080 Laptop | 16 GB | Q3 in VRAM o ~4 t/s (offload) | – | 8–16k | la via di mezzo infelice |
| RTX 5090 Laptop | 24 GB | ~baseline 3090 (limitata termicamente) | ricette desktop trasferibili | 64k | la vera scelta laptop |
| Mac mini M4 Pro 48 GB | 273 GB/s | t/s a due cifre basse | MLX +~40 % | 64k+ | miglior Mac d'ingresso |
| MacBook Pro M5 Pro/Max | fino a 128 GB | 28–31 t/s (GGUF) | **~40 t/s (M5 Pro, MLX)** · 33+ (M5 Max, MLX 4 bit) · DFlash 2 via oMLX | 128k+ | tuttofare mobile |
| Mac Studio M4 Max 64 GB | 546 GB/s | ~classe baseline 3090 | MLX + DFlash 2 | 128k+ | workstation silenziosa |
| DGX Spark (GB10) | 128 GB | 12 t/s | **33–35 t/s singolo · 195–210 t/s @10** | **256k–1M** | nodo di serving a contesto lungo |
| Strix Halo 128 GB | 256 GB/s | 8–11 t/s | 24–36 t/s (MTP), reali 11–24 in chat | 96k+ | memoria unificata qualità-prezzo |

## 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](https://huggingface.co/Qwen/Qwen3.8-27B) · [benchmark Hardware Corner](https://www.hardware-corner.net/qwen3-8-27b-hardware-tests/) · [Simon Willison](https://simonwillison.net/2026/Aug/16/qwen-38-27b/) · [syv-ai/qwen38-27b-rtx3090 (GitHub)](https://github.com/syv-ai/qwen38-27b-rtx3090) · [MiaAI-Lab/Qwen3.8-27B-SGLang-DGX-Spark (GitHub)](https://github.com/MiaAI-Lab/Qwen3.8-27B-SGLang-DGX-Spark) & [@MiaAI_lab su X](https://x.com/miaai_lab) · [r0b0tlab/qwen38-27b-nvfp4-sm121-sglang (GitHub)](https://github.com/r0b0tlab/qwen38-27b-nvfp4-sm121-sglang) · [Inco AI: DFlash 2](https://inco.ai/blog/dflash2/) & [z-lab/Qwen3.8-27B-DFlash2 (benchmark H200)](https://huggingface.co/z-lab/Qwen3.8-27B-DFlash2) · [setup speculativo RTX 5090 (note.com)](https://note.com/unco3/n/n50897cea0ae5) · [50 t/s su Blackwell 24 GB a 256k (piszczek.pl)](https://piszczek.pl/blog/qwen38-27b-256k-50-tps-24gb-gpu) · [KGP Talkie: 45 configurazioni llama.cpp](https://kgptalkie.com/tutorials/generative-ai/qwen-3-8-27b-llama-cpp-speed-settings) · [@witcheer](https://x.com/witcheer/status/2088316316205907970), [@victormustar](https://x.com/victormustar/status/2088753441304727779) & [@0xSero](https://x.com/0xSero/status/2089421053852258334) su X · [misure MLX M5 Max](https://huggingface.co/malekoo/Qwen3.8-27B-MLX-8bit) & [mlx-community](https://huggingface.co/mlx-community/Qwen3.8-27B-8bit) · [repo & guida GGUF Unsloth](https://unsloth.ai/docs/models/qwen3.8) · [blog AMD day 0](https://www.amd.com/en/blogs/2026/run-qwen-3-8-27b-on-amd-ryzen-ai-max-and-radeon-graphics-cards-day-0.html) · [julianmb/q38rocm](https://github.com/julianmb/q38rocm) & [KyaniteLabs](https://github.com/KyaniteLabs/qwen38-27b-strix-halo) (GitHub) · [cookbook SGLang](https://docs.sglang.io/cookbook/autoregressive/Qwen/Qwen3.8-27B) · [guida hardware Kingy.ai](https://kingy.ai/blog/qwen3-8-27b-local-hardware-requirements/) · [VentureBeat](https://venturebeat.com/technology/qwen3-8-27b-runs-frontier-class-coding-agents-and-reasoning-locally-no-cloud-api-required). Tutti i valori sono misure della community o dei produttori dei primi cinque giorni dopo il rilascio; gli stati del software cambiano ogni giorno.*

## Sources

- [model card Qwen3.8-27B](https://huggingface.co/Qwen/Qwen3.8-27B)
- [benchmark Hardware Corner](https://www.hardware-corner.net/qwen3-8-27b-hardware-tests/)
- [Simon Willison](https://simonwillison.net/2026/Aug/16/qwen-38-27b/)
- [syv-ai/qwen38-27b-rtx3090 (GitHub)](https://github.com/syv-ai/qwen38-27b-rtx3090)
- [MiaAI-Lab/Qwen3.8-27B-SGLang-DGX-Spark (GitHub)](https://github.com/MiaAI-Lab/Qwen3.8-27B-SGLang-DGX-Spark)
- [@MiaAI_lab su X](https://x.com/miaai_lab)
- [r0b0tlab/qwen38-27b-nvfp4-sm121-sglang (GitHub)](https://github.com/r0b0tlab/qwen38-27b-nvfp4-sm121-sglang)
- [Inco AI: DFlash 2](https://inco.ai/blog/dflash2/)

---

## Portare l'IA locale nel vostro team

Progettiamo e installiamo setup LLM locali per le aziende: scelta dell'hardware (DGX Spark, RTX, Mac Studio), scelta del modello, deployment privato e passaggio di consegne. Ottenete un sistema che gira sul vostro hardware e tiene i dati in casa.

Si parte da un workshop, poi scoping e offerta a prezzo fisso.

**[Richiedi un workshop →](https://www.contextstudios.ai/it/servizi/ai-workshop?utm_source=blog&utm_medium=cta&utm_campaign=qwen-3-8-27b-hardware-guide)**


## Related

- [Sviluppo AI](https://www.contextstudios.ai/it/sviluppo-ia.md)
- [Sviluppo agenti AI](https://www.contextstudios.ai/it/sviluppo-agente-ia.md)
- [Consulenza AI](https://www.contextstudios.ai/it/consulenza-ia.md)
- [Agenzia AI](https://www.contextstudios.ai/it/agenzia-ia.md)