LLM locali per programmare: come far girare un modello di codice sulla tua macchina (2026)
Puoi far girare un modello di codice valido interamente sulla tua macchina — senza chiave API, senza cloud, senza che il codice lasci il computer. Un portatile con 8 GB di VRAM fa girare un buon modello di codice 7B; una GPU o un Mac da 24–32 GB fanno girare qualcosa di vicino a un assistente ospitato. Questa guida spiega cosa può davvero fare un LLM di codice locale, come sceglierne uno per il tuo hardware, come installare un runtime e come collegarci un vero agente di codice.
In breve: scegli un runtime (Ollama è il più semplice), scarica un modello di codice dimensionato alla tua VRAM e punta un editor o un agente agnostico all'endpoint locale. L'inferenza avviene allora sulla tua CPU/GPU e nulla viene inviato a un fornitore. L'unico vero vincolo è la memoria — decide quanto grande, e quindi quanto buono, può essere il modello.
Cosa può (e non può) fare un modello di codice locale
Un LLM di codice locale è un modello che gira sul tuo hardware invece che sui server di un fornitore. Nel 2026 il divario con i modelli ospitati si è ridotto nettamente per il lavoro quotidiano:
- Bravo in: autocompletamento, scrivere funzioni e test, spiegare codice, piccoli refactor, boilerplate, frammenti di shell e config, e fare da cervello a un agente su un compito ben definito.
- Più debole in: ragionamento multi-file molto ampio, i framework più nuovi e lunghe esecuzioni autonome — dove i modelli ospitati più grandi sono ancora avanti.
Il compromesso è semplice. I modelli ospitati sono più grandi e non richiedono setup, ma il tuo prompt e spesso i file circostanti lasciano la macchina (vedi Gli strumenti di coding con AI inviano il tuo codice al cloud?). Un modello locale è più piccolo ma privato, gratuito da usare e funziona offline. Per codice proprietario, di clienti o regolamentato, il compromesso di solito conviene.
Passo 1 — Abbina il modello alla tua VRAM
La memoria è il fattore decisivo. I pesi di un modello occupano all'incirca:
GB di pesi ≈ (parametri in miliardi × bit per peso) ÷ 8
I più usano la quantizzazione a 4 bit (le build Q4_K_M), che mantiene alta la qualità riducendo la dimensione di ~4×. Un modello 7B in Q4 pesa solo ~4–5 GB di pesi. Lascia margine sopra per la finestra di contesto (la cache KV) e l'overhead del runtime — se un modello è esattamente al limite della VRAM, sfora nella RAM di sistema e rallenta moltissimo.
Fasce pratiche per il codice (Q4_K_M), come punto di partenza:
| Il tuo hardware | Dimensione modello | Buone scelte 2026 |
|---|---|---|
| 8 GB VRAM / Mac 16 GB | 7–8B | Qwen2.5-Coder 7B; 1.5B per solo autocompletamento |
| 12–16 GB VRAM | 13–14B | Qwen2.5-Coder 14B, Codestral 22B (al limite) |
| 24–32 GB VRAM / Mac 32 GB | 27–32B | Qwen3-Coder 30B (MoE, veloce), Devstral Small 2 (agentico) |
Due avvertenze. Apple Silicon usa memoria unificata, quindi questi numeri di VRAM non si traducono uno a uno — un Mac da 32 GB fa girare comodamente un modello 27–32B. E la gamma di modelli cambia in fretta: tratta i nomi sopra come punto di partenza e controlla i tag attuali sulla libreria Ollama o su Hugging Face prima di impegnarti. I punteggi dei benchmark sono per lo più autodichiarati dai creatori — provane due o tre sul tuo codice e giudica tu.
Passo 2 — Installa un runtime
Un runtime carica il modello e lo espone tramite un'API locale. Quattro scelte comuni, dalla più semplice:
- Ollama — un comando per scaricare ed eseguire; espone un endpoint compatibile OpenAI su
http://localhost:11434. La migliore scelta di default. - LM Studio — una GUI con browser dei modelli e server locale con un clic; ottimo se preferisci evitare il terminale.
- llama.cpp — il motore di basso livello su cui si basa la maggior parte degli strumenti; massimo controllo su thread, contesto e offload GPU.
- vLLM — serving ad alto throughput per una workstation o una macchina condivisa con una GPU grande.
Installa ed esegui un modello di codice con Ollama:
# installazione (macOS/Linux); Windows ha un installer su ollama.com
curl -fsSL https://ollama.com/install.sh | sh
# scarica un modello di codice dimensionato alla tua macchina
ollama pull qwen2.5-coder:7b # 8-16 GB
# ollama pull qwen2.5-coder:14b # 16 GB+
# ollama pull qwen3-coder:30b # 24-32 GB
# eseguilo — avvia anche l'API locale su :11434
ollama run qwen2.5-coder:7b
Aumenta la finestra di contesto. Ollama usa di default un contesto troppo corto per codice vero. Impostane uno più grande per esecuzione, o inseriscilo in un Modelfile:
# una tantum: contesto più grande per questa sessione
OLLAMA_CONTEXT_LENGTH=16384 ollama serve
# oppure un Modelfile riutilizzabile
printf 'FROM qwen2.5-coder:7b\nPARAMETER num_ctx 16384\n' > Modelfile
ollama create qwen-coder-16k -f Modelfile
Verifica che l'endpoint risponda — parla l'API OpenAI, quindi qualsiasi strumento agnostico può usarlo:
curl http://localhost:11434/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{"model":"qwen2.5-coder:7b","messages":[{"role":"user","content":"Write a Python function that reverses a string."}]}'
Passo 3 — Punta un agente al modello locale
Un modello grezzo in un terminale è solo chat. Il valore arriva da un agente o editor di codice agnostico capace di leggere i tuoi file, eseguire comandi e applicare modifiche — puntato al tuo endpoint locale invece che a una chiave cloud. Poiché l'endpoint è compatibile OpenAI, la configurazione di solito sta in tre campi:
- URL di base:
http://localhost:11434/v1 - Chiave API: qualsiasi cosa (i runtime locali la ignorano)
- Modello: il tag scaricato, es.
qwen2.5-coder:7b
Questo è tutto il cablaggio. Ora il ragionamento dell'agente gira sulla tua GPU, e il codice non lascia mai la macchina. Tieni un modello locale più grande per i compiti pesanti e uno piccolo per l'autocompletamento inline — molte configurazioni usano entrambi.
Dove si colloca NoTrack Coder
NoTrack Coder è un agente di codice autonomo e local-first per Windows, costruito esattamente per questa configurazione: puntalo a un runtime locale — Ollama, LM Studio, llama.cpp o vLLM — ed esegue strumenti reali, shell e modifiche ai file sulla tua macchina mentre il modello resta locale, con zero telemetria e redazione dei segreti così che file .env, token e chiavi non viaggino mai in un prompt. È agnostico al modello per progetto: tutto locale per il lavoro privato, o passa a un endpoint ospitato per singolo compito, senza lock-in. È un esempio onesto dell'approccio locale — guarda come si confronta nelle pagine di confronto, leggi la documentazione o vedi i prezzi.
Vuoi che il codice resti sulla tua macchina? Scarica per Windows.
Domande frequenti
Qual è il miglior LLM di codice locale nel 2026?
Per la maggior parte delle macchine un modello di codice della famiglia Qwen è la scelta costante: Qwen2.5-Coder 7B su 8–16 GB e Qwen3-Coder 30B o Devstral Small 2 su una GPU da 24–32 GB o un Mac da 32 GB. I benchmark sono per lo più autodichiarati, quindi provane due o tre sul tuo codice prima di decidere.
Quanta VRAM serve per far girare un modello di codice in locale?
Grosso modo: 8 GB per un modello 7–8B a 4 bit, 16 GB per un 13–14B e 24 GB+ per un 27–32B — sempre in quantizzazione Q4_K_M e lasciando margine per la finestra di contesto. La memoria unificata di Apple Silicon va oltre quanto suggeriscono i numeri grezzi.
Posso usare un LLM di codice locale completamente offline?
Sì. Una volta scaricato il modello, un runtime come Ollama o llama.cpp lo esegue senza alcuna rete — l'inferenza avviene sulla tua CPU/GPU, quindi funziona in aereo o su una macchina isolata.
Come collego un modello locale al mio editor o agente?
La maggior parte dei runtime espone un endpoint compatibile OpenAI (Ollama su http://localhost:11434/v1). In un editor o agente agnostico, imposta l'URL di base su quell'indirizzo, un segnaposto qualsiasi come chiave API e scegli il tag del modello scaricato.
I modelli di codice locali sono buoni come ChatGPT o Claude?
Non proprio ai vertici — i modelli ospitati più grandi sono ancora avanti sul grande ragionamento multi-file e sulle lunghe esecuzioni autonome. Ma per autocompletamento, funzioni, test, spiegazioni e compiti di agente ben definiti, un modello locale da 14–32B nel 2026 è abbastanza vicino per il lavoro quotidiano, ed è privato e gratuito da usare.
La quantizzazione peggiora la qualità del codice?
Appena, con Q4_K_M. La quantizzazione a 4 bit è il compromesso standard per l'uso locale: riduce un modello di ~4× con un piccolo costo di qualità che quasi nessuno nota sui compiti di codice. Scendi sotto i 4 bit solo su hardware molto limitato.
