Il miglior LLM locale per la programmazione ad agosto 2026, in base alla VRAM: Qwen3-Coder 30B, gpt-oss-20b, Qwen 2.5 Coder 7B

Il miglior LLM locale per la programmazione ad agosto 2026 è determinato dalla tua VRAM prima di ogni altra cosa. Se hai una scheda da 24GB — una RTX 3090 o 4090 — esegui Qwen3-Coder-30B-A3B-Instruct: 30B di parametri totali con solo 3.3B attivi per token, una finestra di contesto di 262.144 token e i migliori numeri complessivi di codifica locale che possiamo verificare. Su 16GB è gpt-oss-20b, il modello Mixture-of-Experts Apache-2.0 di OpenAI che sta interamente su GPU a ~14GB e raggiunge circa 140 token/sec. Su 8GB è Qwen2.5-Coder-7B, il cavallo di battaglia affidabile a ~4.7GB. Il resto di questa pagina riguarda il ragionamento, i numeri misurati e le situazioni specifiche in cui ciascuna di queste scelte è sbagliata.

Ciò che pagina uno azzecca — e ciò che salta

La classifica del "miglior LLM locale per la programmazione" in questo momento è un mix di un articolo davvero utile e molta autorevolezza di settore. La guida di Tembo (5 giugno 2026) azzecca l'impostazione — organizza per fasce 8GB / 12–16GB / 24GB e punta sulla famiglia Qwen Coder — ma non pubblica punteggi benchmark per i modelli locali, né valori di token al secondo, né dimensioni della finestra di contesto, né scelte Apple Silicon in base alla RAM. Un harness di valutazione GitHub (gauravvij/local-llm-coding-eval) ha numeri reali ma nessun verdetto, ed è stato eseguito solo su CPU. Il resto sono articoli di opinione di un singolo autore (XDA, Yahoo Tech) e listicle scarni (apidog, Security Boulevard, SitePoint) che si posizionano in base all'autorevolezza di settore, non alla loro utilità.

Ciò che tutti saltano, in ordine di quanto ti costa:

• Il divario agentico. La generazione di codice non è la stessa abilità di guidare un agente attraverso una modifica multi-file. La prima pagina lo menziona appena; è la differenza tra un modello che tieni e un modello che disinstalli.

• Finestre di contesto. La codifica agentica consuma token caricando file e output di test. Un'affermazione come "30B sta in 24GB" non ha senso finché non si chiede in quale contesto stia.

• Matematica della quantizzazione. Nessuno spiega che la quantizzazione 4-bit richiede all'incirca tanti gigabyte quanti sono i parametri, o che Q3 compra VRAM al costo di sottili errori di sintassi.

• Velocità misurata. Pochi articoli riportano i token/sec per i modelli che raccomandano, e quelli che lo fanno differiscono enormemente, perché il contesto e la quantizzazione cambiano tutto.

• Quando il locale è la scelta sbagliata. Un test sul campo del 2026 su un'app Flutter di 15.000 righe (EPAM) mostra ancora che i modelli di frontiera cloud vincono i refactoring multi-step più difficili. Nessuno dei listicles ti dice quando fermarti.

I conti sulla VRAM che la maggior parte dei listicle salta.

La regola pratica che rende comprensibili tutti gli altri numeri in questo articolo: con quantizzazione a 4 bit, un modello richiede all'incirca tanti gigabyte quanti sono i suoi parametri — 7B ≈ 5GB, 30B ≈ 18GB+, prima dell'overhead della KV-cache. Q4 è il punto ottimale per il coding; Q3 e inferiori risparmiano VRAM ma introducono in modo misurabile sottili errori di sintassi. E la KV-cache cresce con la finestra di contesto, motivo per cui "un 30B sta in 24GB" è vero solo con un contesto che devi effettivamente specificare.

Mixture-of-Experts cambia la matematica in un modo che conta per le due grandi scelte qui sotto. I parametri totali determinano l'ingombro; i parametri attivi determinano la velocità. Ecco perché Qwen3-Coder-30B-A3B (30B totali, 3,3B attivi) e gpt-oss-20b (20,9B totali, 3,61B attivi) risultano entrambi molto più veloci di quanto il loro peso su disco suggerisca, e perché DeepSeek V4 Flash — 284B totali, 13B attivi — è una soluzione poco adatta all'esecuzione locale anche se la sua API è economica.

24GB di VRAM: Qwen3-Coder 30B

Qwen3-Coder-30B-A3B-Instruct è il più forte modello locale per la programmazione a tutto tondo che possiamo indicare al momento. Rilasciato a luglio 2025 dal team Qwen di Alibaba sotto Apache 2.0, è un modello Mixture-of-Experts con 30B parametri totali e 3.3B attivi per token, una finestra di contesto di 262.144 token e un ingombro a 4 bit di circa 17–20GB — che lascia un margine reale su una scheda da 24GB per la cache KV necessaria a una lunga sessione di programmazione.

Nell'harness locale indipendente di cui ci fidiamo di più (gauravvij/local-llm-coding-eval, quattro modelli eseguiti localmente via Ollama su CPU), qwen3-coder:30b ha ottenuto 80% nella generazione di codice, 77% nella selezione degli strumenti e 80% di accuratezza dell'agente — il risultato più equilibrato dei quattro, e l'unico modello che è stato forte in tutti e tre i compiti contemporaneamente. I tracker di terze parti compilano il suo SWE-bench Verified intorno a 50.3, Aider Polyglot a 66.2 e LiveCodeBench v6 a 58.9; trattali come dati compilati, non come numeri ufficiali di Alibaba, che è tutto ciò che Qwen ha pubblicato per questo modello.

La velocità misurata varia molto in base all'hardware. I punti dati più utili: una configurazione TurboQuant della community lo esegue su una RTX 3060 Ti da 8GB a ~29 token/sec in generazione con un contesto completo di 262K, e il benchmark oMLX ha misurato la build MLX a 4 bit su un M4 Pro (48GB) a 73.6 token/sec con un contesto di 1K, scendendo a 13.5 token/sec a 64K. Su una scheda da 24GB con una configurazione Ollama standard dovresti aspettarti un range di decine di token al secondo, non centinaia — è il compromesso per eseguire a casa un coder quasi di frontiera.

Il caveat onesto: non è il coder locale più veloce, ed esiste un più recente Qwen3-Coder-Next pensato per l'uso hostato e da CLI piuttosto che per installazioni locali quantizzate. Ma per lavoro agentico su scala di repository su una singola scheda, Qwen3-Coder-30B è la scelta di oggi.

16GB di VRAM: gpt-oss-20b

Su una scheda da 16GB, la risposta è gpt-oss-20b — e non c'è gara. Rilasciato il 5 agosto 2025 da O​penAI con licenza Apache 2.0, è un modello Mixture-of-Experts con 20,9 miliardi di parametri totali e 3,61 miliardi attivi per token, una finestra di contesto di 131.072 token, e la sua quantizzazione nativa MXFP4 occupa circa 14GB. Questo è il fatto decisivo: gira al 100% sulla GPU di una scheda da 16GB, senza che nulla venga scaricato nella RAM di sistema.

Perché la residenza sulla GPU conta più di qualsiasi benchmark: un modello che entra nella VRAM è 3–11 volte più veloce di uno che fa offload. Un benchmark indipendente ha registrato 139,93 token/sec per gpt-oss-20b su una RTX 4080 — circa 2,8 volte rispetto a un'alternativa densa con lo stesso ingombro — e il punteggio di un tester del 2026 gli ha assegnato un "indice di intelligenza" di 52,1, definendolo senza pari nella classe 16GB per programmazione e debugging professionale. Ci sta appena, quindi eseguilo da solo e mantieni il contesto contenuto; la qualità degrada verso l'estremità superiore della finestra.

L'alternativa agentica su 16GB è Devstral 24B (devstral-small-2:24b), che registra l'unico numero SWE-bench Verified pubblicato tra i modelli di codifica locali di classe 16GB — 46,8% — ma è lento, richiedendo spesso l'offload della CPU a circa 18 token/sec. Se il tuo lavoro consiste in modifiche agentiche multi-file e puoi accettare la lentezza, Devstral si guadagna il suo posto; se vuoi velocità e codice pulito, gpt-oss-20b è la scelta predefinita migliore. I modelli densi da 14B — Qwen3-Coder 14B o Qwen2.5-Coder 14B a Q5 — sono le soluzioni di ripiego comode ed economiche.

8GB VRAM: Qwen 2.5 Coder 7B

Su 8GB, la risposta onesta è Qwen2.5-Coder-7B: parametri 7B a ~4,7GB in Q4_K_M, un contesto nativo di 32.768 token estendibile fino a 128K, e i punteggi più alti nei benchmark di completamento del codice nella classe 7B. È un modello più vecchio — rilasciato a novembre 2024 — e va bene così, perché nulla di più recente nella fascia 8GB lo ha detronizzato. I test della community lo collocano intorno ai 50 token/sec su una RTX 4060 o 3070; un test indipendente su RTX 4060 del marzo 2026 ha misurato 28–35 token/sec, una variazione determinata quasi interamente dalle impostazioni del contesto.

Tre cose contano su 8GB che non contano altrove. Primo, limita il contesto a 4–8K: è la cache KV che fa andare in OOM una scheda da 8GB, non i pesi — un benchmark ha visto la velocità saltare da ~3.6 a ~37 token/sec semplicemente limitando il contesto. Secondo, verifica con ollama ps che il modello sia al 100% su GPU; qualsiasi parte su CPU significa che la velocità crolla. Terzo, Q4_K_M, non Q3 — gli errori di sintassi del Q3 ti costano più di quanto risparmi in VRAM.

La notevole novità del 2026 è che Qwen3-Coder-30B-A3B-Instructora può essere fatto rientrare in 8GB grazie alla compressione TurboQuant KV-cache — una configurazione della community ha misurato ~7.5GB e ~29 token/sec su una RTX 3060 Ti con contesto completo di 256K. Funziona, ed è abbastanza complesso da non raccomandarlo come impostazione predefinita. Se si desidera un'opzione più recente pronta all'uso, Qwen3 8B (~5.2GB, modalità di pensiero ibrida) rappresenta un piccolo passo avanti rispetto a Qwen2.5-Coder-7B nel ragionamento generale, pur restando leggermente indietro sul codice puro.

E che dire di Apple Silicon?

La memoria unificata cambia l'equazione in una direzione: la capacità sale, la velocità di generazione scende. Un M4 Pro da 48GB può contenere modelli che una scheda Windows da 16GB non può reggere, ma a contesto lungo genera token molto più lentamente. I numeri che abbiamo: la build MLX a 4 bit di Qwen3-Coder-30B-A3B-Instruct ha usato 16,6GB con contesto 1K e 25,5GB con contesto 64K su un M4 Pro, con la generazione scesa da 73,6 token/sec a 13,5 man mano che il contesto cresceva (benchmark oMLX). gpt-oss-20b rientra comodamente in 16GB di memoria unificata ed è un'ottima scelta per Mac. Se vuoi il multimodale su Apple Silicon, Gemma 4 12B gira in circa 16GB di memoria unificata con un contesto di 256K — l'opzione locale più potente se il tuo lavoro di programmazione si svolge accanto a documenti ricchi di immagini.

I numeri indipendenti: codegen non è l'abilità che conta.

I dati più chiari che abbiamo trovato sono un singolo benchmark locale che vale la pena citare per intero. gauravvij/local-llm-coding-eval ha eseguito quattro modelli localmente tramite Ollama, su CPU, senza cloud — generazione di codice, chiamate di funzioni e un task agente multi-step — con risultati che vanno contro l'istinto "numero di codegen più grande vince":

• Qwen3.6 27B (qwen3.6:27b, dense, ~17GB): 80,0% codegen, 84,6% tools, 100% agent — il migliore tuttofare.

• Qwen3.6 35B A3B (qwen3.6:35b-a3b, MoE, ~18GB): 70,0% codegen, 84,6% strumenti, 100% agente.

• Qwen3-Coder-30B-A3B-Instruct (qwen3-coder:30b, MoE, ~17GB): 80.0% codegen, 76.9% tools, 80% agent — il più bilanciato.

• DeepSeek-Coder-V2 33B (deepseek-coder:33b, denso, ~18GB): 90,0% codegen — il migliore dei quattro — ma 10% agente, ultimo assoluto nel lavoro multi-step.

Quell'ultima riga è l'intera lezione. Un modello che eccelle nella pura generazione di codice ma crolla nei compiti da agente è il modello che disinstallerai dopo il primo ciclo "leggi questo file, modifica questa funzione, esegui il test". Giudica un coder locale dalla colonna agentica, non da quella codegen.

Quando eseguire in locale è la scelta sbagliata

Local-first è l'impostazione predefinita giusta per la privacy, il lavoro offline, il costo marginale zero dei token e l'autocompletamento dove la latenza conta più della qualità massima. È la scelta sbagliata in situazioni specifiche e riconoscibili — e questa è la sezione che tutti saltano.

• Il lavoro agentico più difficile ti batte ancora. Il test sul campo di EPAM del 2026 su un'app Flutter da 15.000 righe ha rilevato che i modelli frontier del cloud (GPT-5.3-codex) superano ancora i modelli locali nel refactoring multi-step più complesso. Se la tua giornata è fatta di otto ore di refactoring di codice legacy, i modelli locali non sono pronti.

• Le tue esigenze di contesto superano la capacità della tua scheda. Un agente di codifica che carica un intero repository supererà la cache KV che una scheda da 16GB può contenere. Il contesto da 256K di Qwen3-Coder-30B è il motivo per cui vince nella fascia da 24GB — le schede più piccole perdono questa partita in anticipo.

• Non puoi fare da babysitter all'hardware. L'hardware è denaro reale: una scheda da 24GB è nella fascia $700–1.600, più elettricità e manutenzione. A basso volume, chiamare un'API è più economico del consumo energetico.

• DeepSeek V4 Flash è la prova. Con 284B di parametri totali, i soli pesi a 4 bit di DeepSeek V4 Flash sono circa 140GB — non è un modello per schede consumer, punto e basta. Il suo design con 13B attivi è esattamente il motivo per cui la sua API è veloce ed economica a $0,15 / $0,29 per 1M di token (MIT, contesto 1M). Per quel modello, "eseguirlo localmente" è la domanda sbagliata; l'API è il punto.

• I team hanno bisogno di coerenza. Se quattro ingegneri eseguono ciascuno una diversa quantizzazione di un modello diverso, "sulla mia macchina funziona" diventa un rischio per la build. Endpoint API condivisi ti danno un unico target deterministico.

Se vuoi la risposta lato API a questa stessa domanda — quale modello di coding cloud è quello predefinito quando il locale non è il compromesso giusto — ne abbiamo parlato separatamente nella nostra guida best-LLM-for-coding, e il nostro articolo AI-coding-agents copre harness come Cline e OpenCode che funzionano con questi modelli locali.

Come testare la carta prima di acquistarla

Il modo più economico per decidere è eseguire i propri prompt prima di investire nell'hardware. Ollama o LM Studio fanno girare una qualsiasi delle tre opzioni in pochi minuti, e il test che conta sono i file reali del tuo repository, non un benchmark. Un router si guadagna il suo posto nella decisione adiacente: quando confronti un candidato locale con modelli frontier ospitati, un unico endpoint ti permette di eseguire lo stesso prompt su entrambi senza dover destreggiarti tra le chiavi. Su OrcaRouter, DeepSeek V4 Flash è servito al prezzo di listino del provider, trasferito invariato — $0,15 / $0,29 per 1M di token, ricarico 0% — con failover automatico, il che lo rende un metro di paragone economico e onesto per "il mio modello locale è davvero migliore dell'API da $0,15?"

Un'avvertenza onesta: {{1}}OrcaRouter{{/1}} non ospita {{2}}Qwen3-Coder-30B-A3B-Instruct{{/2}} né {{3}}gpt-oss-20b{{/3}}. Se il tuo obiettivo è strettamente offline, un router è irrilevante per te — fai self-hosting e hai finito. Se il tuo obiettivo è fare un test A/B dello stesso modello open-weight contro i modelli frontier prima di investire in una scheda, il compito del router è il confronto, non l'hosting.

La conclusione

La tua VRAM decide per prima, la qualità del modello viene seconda. Con 24GB, esegui Qwen3-Coder-30B-A3B-Instruct — il modello locale di coding più completo in assoluto, con i 256K di contesto che il lavoro agentico richiede. Con 16GB, esegui gpt-oss-20b — il raro modello che è sia veloce che completamente su GPU. Con 8GB, esegui Qwen2.5-Coder-7B e mantieni un contesto contenuto. Valutali in base alla colonna agentica, non a quella codegen, e accetta che il refactoring multi-file più difficile appartenga ancora al cloud. I numeri sopra sono aggiornati al 10 agosto 2026 — riverifica la gamma e i prezzi di listino prima di spendere, perché questo settore si muove di settimana in settimana.