Miglior LLM locale per coding: dagli 8 ai 24 GB di VRAM

Il miglior LLM locale per programmare in questo momento è Qwen3 Coder 30B A3B su una scheda da 24 GB, Qwen2.5 Coder 14B in Q4 su 12–16 GB e Qwen2.5 Coder 7B in Q4 su 8 GB. Ognuno gira completamente offline, completa e rifattorizza codice vero e non costa nulla a token. Se la tua GPU ha meno VRAM di quanta ne serve al modello, scendi di una quant prima di scendere di taglia. Questa guida abbina i modelli alle fasce di VRAM, confronta le due famiglie di coding su cui si discute davvero e chiude con comandi pronti: in circa cinque minuti stai generando codice in locale.

Quale LLM locale usare per programmare sulla tua GPU?

Scegli prima per VRAM, poi per modello — il modello entra solo se pesi più contesto stanno in memoria. Questa è la shortlist che continua a primeggiare nei benchmark della community nel 2026 e nell’uso quotidiano:

VRAM	Modello	Quant	Pesi su disco	Perché vince questa fascia
8 GB	Qwen2.5 Coder 7B Instruct	Q4_K_M	~4,7 GB	Miglior rapporto tra token al secondo e qualità per autocomplete e piccoli refactor
12 GB	Qwen2.5 Coder 14B Instruct	Q4_K_M	~9,0 GB	Le modifiche a file intero entrano nel contesto; comunque 30+ tok/s su una scheda classe 3060
16 GB	Qwen3 14B o gpt-oss-20b	Q4_K_M	~9–12 GB	Miglior ragionamento su specifiche ambigue; le schede classe 4090 lo tengono veloce
24 GB	Qwen3 Coder 30B A3B	Q4_K_M	~18,6 GB	MoE: solo ~3B di parametri attivi per token, quindi la velocità resta utilizzabile

Due regole rendono questa tabella funzionante nella pratica:

1. Lascia 1–2 GB di VRAM di margine per la KV cache. Un modello 14B in Q4 più un contesto da 8K token non entra in un budget da 10 GB — il contesto conta nel totale.
2. Scendi di una quant prima di scendere di una taglia di modello. Le quant Q5/Q4 costano qualche punto percentuale di qualità; passare da un 14B a un 7B costa molto di più.

Quanta VRAM serve per un LLM locale da coding?

La regola pratica onesta: VRAM necessaria ≈ pesi quantizzati + 0,125 GB per 1K token di contesto con KV cache a 8 bit. In numeri concreti:

• 8 GB fanno girare comodi modelli 7B–8B in Q4. Aspettati risposte della lunghezza di un autocomplete, contesto 4K–8K.
• 12 GB è il punto dolce per un 14B in Q4 — spazio per il modello più un contesto da coding realistico di 8K–16K.
• 16 GB apre i modelli densi classe 20B e Qwen3 14B con contesto più lungo.
• 24 GB fa girare il Qwen3 Coder 30B A3B MoE in Q4, la cosa più vicina a un modello di coding di qualità cloud che puoi ospitare da te.

Solo CPU? Si può — llama.cpp gira tranquillamente un 7B Q4 su una CPU da laptop a 5–10 tok/s — ma trattalo come un esercizio di pazienza, non come driver quotidiano. Per il lato strumenti, il confronto Ollama vs LM Studio copre quale applicazione mettere sotto i tuoi modelli.

Qwen3 Coder vs DeepSeek: quale è meglio per programmare?

È il duello di cui chiedono davvero le barre di autocomplete, e la risposta si divide con nettezza:

• Qwen3 Coder (30B A3B) è costruito per il ciclo di modifica: rispetta le convenzioni di formato per il tool calling, produce diff consistenti e — la parte decisiva — il design MoE attiva solo ~3B di parametri per token, quindi una singola scheda da 24 GB raggiunge 40–60 tok/s. Nell’uso in stile IDE, la reattività è qualità.
• La linea DeepSeek V3/R1 ragiona a un livello più alto: decisioni di architettura, algoritmi tosti, ragionamento multi-step. Ma il modello di punta supera i 600B di parametri; in locale lo esegui solo fortemente quantizzato su configurazioni multi-GPU o con memoria unificata Mac, e scrive prosa sul codice più in fretta di quanto scriva codice.

Scelta locale: Qwen3 Coder come driver quotidiano, DeepSeek solo se hai l’hardware per ospitarlo quasi a precisione piena. Con 8–16 GB la discussione è oziosa — i modelli Qwen2.5/3 Coder sono la cosa più forte che ci entra.

Come eseguire il miglior LLM locale per coding con Ollama?

Cinque comandi, dal nulla a un’API compatibile OpenAI che il tuo editor può usare:

# 1. Installa Ollama (Linux)
curl -fsSL https://ollama.com/install.sh | sh

# 2. Scarica il modello adatto alla tua fascia di VRAM (scheda da 8 GB)
ollama pull qwen2.5-coder:7b

# 3. Chiacchiera con il modello in modo interattivo
ollama run qwen2.5-coder:7b

# 4. Usalo come API compatibile OpenAI da qualunque strumento
curl http://localhost:11434/v1/chat/completions 
  -d '{
    "model": "qwen2.5-coder:7b",
    "messages": [{"role": "user", "content": "Refactor this fn to be async: add(a,b){return a+b}"}]
  }'

# 5. Punta qui gli strumenti che si aspettano OPENAI_BASE_URL
export OPENAI_BASE_URL=http://localhost:11434/v1

Nessuna API key, nessun rate limit, nessun conto per token. Su Linux l’installer registra una unità systemd, quindi se il server dovesse comportarsi male, journalctl ti dice perché — il journalctl cheat sheet ha i filtri esatti per il debugging dei servizi.

Un LLM locale è abbastanza buono per il lavoro vero?

Sì per il ciclo di modifica, no per i problemi difficili — e questa divisione è esattamente come devi usarlo. Un modello locale 14B–30B gestisce refactor, boilerplate, impalcature di test, regex e «spiegami questa funzione legacy» più in fretta di quanto la maggior parte delle API cloud faccia avanti e indietro. Dove perde contro i grandi modelli ospitati è nel ragionamento multi-file lungo e nelle curiosità oscure dei framework — un 30B semplicemente sa meno di un modello di frontiera.

Il flusso che funziona: tieni un modello locale acceso per il 90% dei tuoi tasti premuti e rivolgiti a un modello di frontiera ospitato solo per le domande di design osticate. Per il lavoro di routine il tuo codice non lascia mai la macchina — cosa che conta col codice dei clienti — e la VRAM che possiedi già sostituisce in silenzio un abbonamento.