Migliore LLM locale per programmare: Devstral, Qwen3-Coder

#Perché un LLM locale per programmare nel 2026

Scrivere codice con un assistente IA è diventato un'abitudine. Ma inviare codice proprietario, segreti, percorsi interni o semplicemente proprietà intellettuale a un servizio cloud rimane un problema — per i freelance vincolati da un NDA, per le aziende soggette al RGPD e per gli sviluppatori indipendenti che vogliono semplicemente mantenere il controllo.

La buona notizia: dal 2025 i modelli open-weight per la programmazione hanno recuperato buona parte del ritardo. Devstral raggiunge punteggi SWE-bench degni dei migliori modelli cloud, Qwen3-Coder tiene testa a Claude nel refactoring, e persino un Qwen 3.5 9B su una RTX 3060 svolge un lavoro utile nel quotidiano. Il costo iniziale dell'hardware è diminuito, la qualità è aumentata.

Cosa si intende per "migliore LLM locale per programmare nel 2026"

Si parla di modelli a pesi aperti (Apache 2.0 o MIT), eseguibili su GPU consumer o Mac Apple Silicon, senza inviare un solo token a un server di terze parti. Niente "open source ma solo tramite API", niente licenze non commerciali.

#I criteri giusti per scegliere

Il kit Copilota Locale

Devstral o Qwen3-Coder: hai fatto la tua scelta. Il kit Copilote Locale lo mette al lavoro in trenta minuti (cap. 2), verifica che sia quello giusto per la tua memoria video (cap. 5) e ti fa misurare le prestazioni della tua macchina anziché fidarti della scheda tecnica (cap. 18).

Spazio online a vita
PDF + file
Aggiornamenti a vita

Il kit Copilote Local →o tutti i kit a vita — 49 € →

Un benchmark in una classifica non dice tutto. Per un utilizzo reale, ecco cosa conta.

Qualità del codice generato: Capacità di scrivere una patch che compila e supera i test, non solo codice «che sembra corretto». HumanEval/MBPP danno un'idea, SWE-bench Verified è più rappresentativo delle attività reali.
Supporto per il Fill-in-the-Middle (FIM): Indispensabile per l'autocompletamento nell'IDE. Non tutti i modelli lo supportano — Devstral è debole su questo aspetto, e per il FIM puro qwen2.5-coder:7b-base resta il punto di riferimento nel 2026.
Finestra di contesto: Per comprendere un file di 2000 righe o un progetto intero, considera almeno 32k token. Qwen3-Coder sale a 256k, Devstral a 128k.
Velocità di inferenza: Un modello denso da 30B produce 15-25 token/s su una RTX 4090. Un modello MoE come Qwen3-Coder 30B-A3B produce 60-80 token/s con qualità equivalente — la differenza cambia la vita alla tastiera.
Licenza: Apache 2.0 e MIT non creano problemi per l'uso commerciale. Fai attenzione a Codestral (non commerciale) o ai vecchi Code Llama (licenza Meta restrittiva).
Linguaggi supportati: La maggior parte dei buoni modelli supporta correttamente Python, JS/TS, Go, Rust, Java, C/C++. Per PHP, Ruby o Swift, verifica i benchmark per linguaggio.

#Devstral, lo specialista dei sistemi agentici (Mistral AI)

Devstral è il modello di Mistral per la programmazione, specificamente addestrato per il lavoro con agenti — cioè con un agente come Aider, OpenHands o SWE-agent che interviene sul codice in modo iterativo, esegue i test, legge l'output e apporta correzioni. Su SWE-bench Verified, Devstral Small si classifica tra i migliori modelli open-weight, in una posizione che un anno fa sarebbe stata impossibile da raggiungere.

Variante consigliata: Devstral Small (~24B, denso). Apache 2.0. Disponibile su Hugging Face e Ollama.
VRAM in Q4_K_M: Circa 14 GB. Entra comodamente in una RTX 4080 da 16 GB o in un Mac serie M da 24 GB. È possibile anche con 12 GB, ma al limite e con un contesto ridotto.
Finestra di contesto: 128k token. Più che sufficienti per caricare un repository di medie dimensioni.
Punto di forza: Eccellente per i flussi di lavoro agentici in più fasi: leggere una segnalazione di bug, esplorare il codice, scrivere una patch, far superare i test.
Debolezza: Non progettato per il FIM (completamento automatico riga per riga). Se vuoi usarlo in Continue.dev per il completamento, passa a qwen2.5-coder:7b-base per questa parte.

Installare Devstral con Ollama

ollama pull devstral:24b
ollama run devstral:24b "Écris un parseur CSV en Rust qui gère les guillemets échappés."

#Qwen3-Coder, il coltellino svizzero (Alibaba)

Qwen3-Coder è la generazione 2025 della famiglia Coder di Alibaba, in architettura Mixture-of-Experts (MoE). È il modello che molti considerano lo stato dell'arte open-weight per la generazione di codice nel 2026, in tutti i formati. Disponibile sotto licenza Apache 2.0.

Variante per il grande pubblico: Qwen3-Coder 30B-A3B: 30 miliardi di parametri in totale, ma solo 3 miliardi attivi per token. In pratica, offre la qualità di un modello denso 14-22B con la velocità di un 3B.
VRAM in Q4_K_M: Circa 18 GB per la 30B-A3B. Entra appena nella memoria di una RTX 4090 da 24 GB o di un Mac M-Pro/M-Max da 24-32 GB.
Variante di frontiera: Qwen3-Coder 480B-A35B. Livello Claude/GPT-5 sul codice, ma riservato ai Mac Studio Ultra 256-512 GB o a configurazioni multi-GPU H100.
Contesto: 256k token in modo nativo, estendibile. Puoi letteralmente incollare un intero repo dentro.
Punti di forza: Eccellente nel refactoring su più file, gestisce bene i linguaggi "di nicchia" (Elixir, Zig, OCaml), è molto valido nei compiti agentici e il MoE lo rende eccezionalmente veloce.
Debolezza: Il 30B-A3B rimane un MoE: se hai poca VRAM disponibile, il maggiore consumo di memoria rispetto a un modello denso da 9B si fa sentire. Con 12 GB, resta su un Qwen 3.5 9B (se necessario in Q8).

Installa Qwen3-Coder 30B-A3B

ollama pull qwen3-coder:30b
ollama run qwen3-coder:30b "Refactor cette fonction pour utiliser async/await sans changer le comportement."

→

Perché il MoE A3B è così veloce

Con 3B di parametri attivi per token, il calcolo necessario per ogni generazione è quello di un 3B — ma con la "conoscenza" di un 30B. Su una RTX 4090, puoi aspettarti da 60 a 80 token al secondo, mentre un modello denso 32B si ferma a 25-30. Nella pratica quotidiana, è la differenza tra "scrivo con il modello" e "aspetto il modello".

#Qwen 3.5, la scelta affidabile per le piccole configurazioni

La famiglia Qwen 3.5 (2B, 4B, 9B) è nel 2026 l'opzione più versatile per le configurazioni modeste. Licenza Apache 2.0, ampio contesto (fino a 256k), capacità multimodali nelle taglie medie e varianti che rientrano in 4–12 GB di VRAM. Per la sola autocompletazione inline (FIM), teniamo separato qwen2.5-coder:7b-base, che resta il riferimento per questo caso specifico.

Qwen 3.5 4B: VRAM Q4 ≈ 3,4 GB (ollama run qwen3.5:4b). Ideale per RTX 3060 8 GB, RTX 4060, MacBook Air serie M 16 GB. Il nuovo modello piccolo da usare per impostazione predefinita, discreto nelle chat sul codice.
Qwen 3.5 9B: VRAM Q4 ≈ 6,6 GB (ollama run qwen3.5:9b). LA scelta del 2026 per 8 GB: 256k di contesto, visione, qualità nettamente superiore al 4B. Il modello da usare ogni giorno sulle schede da 8–12 GB.
Qwen 3.5 9B in Q8: VRAM ≈ 11 GB (ollama run qwen3.5:9b-q8_0). La qualità massima della fascia, perfetta per 12 GB di VRAM (RTX 3060 12 GB, RTX 4070).
Autocompletamento (FIM): Qwen2.5-Coder 7B base resta IL riferimento FIM nel 2026: ollama run qwen2.5-coder:7b-base (≈ 4,7 GB). Da conservare per il tabAutocomplete di VS Code (Continue.dev, Tabby).

Qwen 3.5 vs Qwen3-Coder

Qwen 3.5 (denso, generalista) è consigliato per le configurazioni più piccole (≤16 GB di VRAM), con qwen2.5-coder:7b-base come supporto per il FIM. Qwen3-Coder (MoE specializzato nel codice) è pensato per macchine con più risorse (24 GB+) e per il lavoro con agenti. I due coesistono.

#Alternative significative

gpt-oss 20B (OpenAI): Modello open-weight di OpenAI, quantizzato in MXFP4, molto veloce, 131k di contesto. VRAM ≈ 14 GB (ollama run gpt-oss:20b). Buon compromesso su 16 GB se vuoi un modello generalista reattivo e orientato al codice.
GLM 4.7 Flash (Zhipu AI): MoE 30B-A3B, licenza MIT, ≈ 19 GB in Q4 (ollama run glm-4.7-flash). Molto solido nelle chat tecniche, nel debug e nell'uso con agenti. Adatto se combini francese e codice — le spiegazioni vengono formulate naturalmente in francese.
Mistral Small 24B: Modello generalista denso, ≈ 14 GB in Q4 (ollama run mistral-small). Buono in francese, utile come supporto per la documentazione e le spiegazioni su una configurazione da 16 GB.
Codestral 22B (Mistral): Tecnicamente valido, ma con licenza Mistral non-production: vietato in ambiente lavorativo. Da escludere al di fuori dell'uso strettamente personale o della ricerca.
DeepSeek-Coder V2, Code Llama, StarCoder 2: Questi modelli di base del 2023-2024 sono superati in qualità da tutti quelli citati sopra. Da saltare: un Qwen 3.5 9B o un Granite 4.2 8B fa meglio con meno VRAM.

#Quale scegliere in base alla tua GPU

Consiglio pratico in base alla VRAM disponibile. I modelli citati sono in quantizzazione Q4_K_M, il migliore compromesso qualità/memoria per il codice.

8 GB (RTX 3060 8 GB, 4060, 5050, 5060): Qwen 3.5 9B (256k ctx, vision). Già molto utilizzabile per l'autocompletamento e la chat tecnica. Per il FIM puro, aggiungi qwen2.5-coder:7b-base. Contesto 16-32k.
12 GB (RTX 3060 12 GB, 4070, 5070): Qwen 3.5 9B in Q8 (11 GB) per l'uso quotidiano, oppure Gemma 4 12B (7,6 GB, multimodale). Devstral in Q4 entra in memoria con un contesto ridotto.
16 GB (RTX 4080, 4070 Ti Super, 5070 Ti, 5080): Devstral 24B per le attività agentiche, gpt-oss 20B o Mistral Small 24B come modelli generalisti e qwen2.5-coder:7b-base per il FIM. È la prima configurazione in cui hai davvero la possibilità di scegliere.
24 GB (RTX 3090, 4090, RX 7900 XTX): Qwen3-Coder 30B-A3B (codice) o Qwen 3.8 27B (generalista, il più vicino a un Copilot) come modello principale per l'uso quotidiano. Devstral come alternativa per le attività agentiche, GLM 4.7 Flash per gli agenti. È la configurazione in cui i modelli locali rivaleggiano con il cloud nell'uso quotidiano.
32 GB (RTX 5090) o Mac M-series 36-48 GB: Qwen3-Coder 30B-A3B in Q8 (32 GB), oppure Qwen 3.6 35B-A3B (23 GB, MoE veloce, la scelta affidabile della fascia). Ottima comodità d'uso, contesto 128k+. Si punta al top senza compromessi.
Mac Studio Ultra 128 GB+: Qwen3-Coder 30B-A3B in Q8 a piena qualità con il contesto completo di 256k, oppure le varianti frontier di Qwen3-Coder (480B-A35B) se punti al livello delle API. È l'unico modo accessibile (al di fuori dei data center) per eseguire in locale un modello frontier per il codice.

#Collegare tutto questo a VS Code

La soluzione più semplice: Ollama è in ascolto su http://localhost:11434 e Continue.dev (estensione di VS Code) può comunicare con questo endpoint in modo nativo. Ecco una configurazione minima che combina qwen2.5-coder:7b-base per l'autocompletamento (veloce, FIM) e Qwen3-Coder per la chat (potente).

Recuperare i modelli

ollama pull qwen2.5-coder:7b-base
ollama pull qwen3-coder:30b

~/.continue/config.json (estratto)

{
  "models": [
    {
      "title": "Qwen3-Coder 30B (chat)",
      "provider": "ollama",
      "model": "qwen3-coder:30b",
      "apiBase": "http://localhost:11434"
    }
  ],
  "tabAutocompleteModel": {
    "title": "Qwen2.5-Coder 7B base (autocomplete)",
    "provider": "ollama",
    "model": "qwen2.5-coder:7b-base",
    "apiBase": "http://localhost:11434"
  }
}

Per i workflow agentici (refactoring su più file, risoluzione di bug), Aider da CLI si distingue particolarmente con Devstral:

Aider + Devstral

pip install aider-chat
export OLLAMA_API_BASE=http://localhost:11434
aider --model ollama/devstral

#Suggerimenti e insidie comuni

Contesto troppo breve di default su Ollama: Ollama ha un limite di contesto predefinito di 2048 token. Per il codice, è ridicolo. Configura num_ctx tramite un Modelfile o tramite i parametri di Continue.dev e porta il contesto almeno a 16k o 32k token.
FIM vs chat — non mescolare: Devstral e Qwen3-Coder non sono ottimizzati per il FIM. Se li usi per l'autocompletamento, otterrai risultati strani (risposte in stile chat nel mezzo di una funzione). Usa sempre un modello adatto al FIM (qwen2.5-coder:7b-base) per tabAutocomplete.
Quantizzazione eccessivamente aggressiva: Per il codice, Q3 e le quantizzazioni inferiori degradano visibilmente la qualità (sintassi errata, identificatori inventati). Usa almeno Q4_K_M. Q5_K_M se hai abbastanza VRAM.
Prestazioni che crollano dopo pochi minuti: Ollama rimuove dalla memoria i modelli inattivi dopo 5 minuti. Se programmi a intermittenza, avvia Ollama con OLLAMA_KEEP_ALIVE=1h per mantenere il modello caricato e pronto.
Modello che risponde sempre in inglese: Aggiungi un system prompt in Continue.dev o nel Modelfile: «Rispondi sempre in francese, codice e commenti in inglese.» Qwen 3.5 / 3.8 e Devstral seguono questa istruzione senza problemi.
Qwen 3.8 27B che riflette eccessivamente: Con l'impostazione di ragionamento predefinita, Qwen 3.8 27B tende a ragionare troppo sui compiti semplici e ad aumentare la latenza. Per programmare ogni giorno, imposta il suo sforzo di ragionamento su low (o disattiva il thinking): guadagni in reattività senza perdite significative nei compiti comuni.

#Per approfondire

Hai scelto il tuo modello per la programmazione ed è in esecuzione. Ecco alcuni suggerimenti per andare oltre:

Copilot locale con Continue.dev: La guida dettagliata per configurare Continue.dev in VS Code con Ollama, modelli separati per l'autocompletamento e la chat e scorciatoie.
Usare Ollama in Claude Code e Cursor: Per collegare Devstral o Qwen3-Coder a Cursor o Claude Code tramite l'endpoint di Ollama compatibile con OpenAI e utilizzare questi IDE di fascia alta senza cloud.
Scegliere la quantizzazione (Q4, Q5, Q8, FP16): Per capire esattamente cosa perdi o guadagni passando da un Q4_K_M a un Q5_K_M su un modello per il codice, e quando ha senso passare a una quantizzazione con più bit.

Questa guida ti è stata utile?

Un feedback, un errore, una precisazione? Facci sapere, così la guida migliora per tutti.

I kit QuelLLMLa guida di riferimento per ogni uso

Copilota Locale IA locale Agenti Locali RAG Locale IA in Azienda IA Senza Filtri Mac Immagini IA

Tutti i kit a vita — 49 €

Prossimo passo logico

Casi d’uso · 20 min