Local AI & Hardware

Migliori LLM Open Source da Eseguire in Locale (2026): Guida VRAM Mac e RTX

2026-09-02·22 min di lettura min di lettura·LLMPodium Team

Risposta Rapida: Il miglior LLM open source da eseguire in locale nel 2026 dipende dalla VRAM unificata: su Mac da 16GB scegli Qwen 2.5 Coder 7B / 14B Q4_K_M (45–65 tps). Su Mac/RTX da 32GB–64GB, Qwen 2.5 Coder 32B Q4_K_M e Llama 3.3 70B IQ3_XXS garantiscono prestazioni di vertice nel codice e nel ragionamento. Con 128GB di memoria unificata, esegui DeepSeek R1 / V3 e Llama 3.3 70B Q8 a costo cloud zero.

1. Introduzione: La rivoluzione dei modelli aperti in locale nel 2026

Nel 2026, l'esecuzione locale di modelli linguistici di grandi dimensioni (LLM) di livello avanzato non è più un'attività riservata agli appassionati di sistemi operativi: è diventata un'esigenza fondamentale per le aziende. Sviluppatori software, analisti finanziari quantitativi e organizzazioni attente alla privacy stanno migrando dalle API proprietarie nel cloud (OpenAI, Anthropic, Google) verso architetture aperte auto-ospitate.

Tre fattori chiave guidano questa transizione:

  1. Sovranità dei dati e conformità: Normative severe (GDPR, HIPAA, SOC 2 Type II) vietano la trasmissione di codice proprietario, documentazione riservata e dati personali verso endpoint di inferenza di terze parti.
  2. Architettura di memoria unificata Apple Silicon (UMA): A differenza dei tradizionali PC desktop in cui la VRAM ad alta velocità è confinata nelle schede grafiche PCIe dedicate (con un tetto di 24GB sulle GeForce RTX 4090 / 5090 consumer), i processori Apple M (M3/M4 Pro, Max e Ultra) condividono da 128GB a 192GB di memoria unificata LPDDR5X ad altissima velocità, accessibile direttamente dai core GPU con larghezze di banda comprese tra 400 e oltre 800 GB/s.
  3. Algoritmi avanzati di quantizzazione matriciale (GGUF, EXL2, AWQ, MLX): Le tecniche moderne (k-quants, matrici di importanza imatrix IQ2/IQ3/IQ4) permettono a modelli da 70 miliardi di parametri di operare in meno di 38GB di RAM con un degrado della perplessità pressoché trascurabile (<0,15 punti su Wikitext-2).

Questa guida analizza i migliori modelli aperti su Apple Silicon (da 16GB a 128GB) e GPU NVIDIA RTX, fornendo formule esatte per la VRAM, velocità di generazione (tps, TTFT), valutazioni su SWE-bench, LiveCodeBench e MMLU-Pro e configurazioni pronte per la produzione.

2. Topologia hardware: Memoria Unificata Apple vs GPU Discrete NVIDIA

Comprendere la struttura della memoria è indispensabile per scegliere il numero di parametri e il formato di quantizzazione ideali. 

+-----------------------------------------------------------------------------------------+
|                                TOPOLOGIA DELLA MEMORIA HARDWARE                         |
+---------------------------------------------------+-------------------------------------+
| Memoria Unificata Apple Silicon (UMA)             | PC Desktop Tradizionale (x86_64)    |
+---------------------------------------------------+-------------------------------------+
| CPU e GPU condividono un unico pool LPDDR5X       | RAM di sistema (DDR5) separata da   |
|                                                   | VRAM                                |
| Nessun collo di bottiglia sul bus PCIe            | Trasferimento bus PCIe Gen 4/5      |
|                                                   | (32–64 GB/s)                        |
| Limite di memoria: da 16GB a 192GB (M4 Ultra)     | Limite VRAM: 16GB–24GB (singola RTX)|
| Larghezza di banda: da 150 a 800+ GB/s            | Larghezza di banda: 1.008 GB/s      |
| Accelerazione Metal Performance Shaders e MLX     | Core CUDA, Tensor Core & FlashAttn  |
| Massima capacità di contesto per euro speso       | Massima velocità di generazione pura|
+---------------------------------------------------+-------------------------------------+

Formula matematica per il calcolo della VRAM nei modelli locali

Per determinare l'ingombro di memoria richiesto evitando arresti anomali o swap su disco:

$$\text{VRAM Totale (GB)} = \left( \frac{\text{Parametri (Miliardi)} \times \text{Bit per Peso}}{8} \times 1.15 \right) + \text{KV Cache (GB)} + \text{Overhead OS (GB)}$$

Variabili della formula:

  • Parametri (Miliardi): Dimensione del modello (7B, 14B, 32B, 70B).
  • Bit per Peso: 16 per FP16, 8 per Q8_0, 4.5 per Q4_K_M, 3.2 per IQ3_M.
  • Moltiplicatore 1.15: Margine di sicurezza del 15% per attivazioni e buffer di calcolo.
  • Ingombro KV Cache: $\text{KV Cache} = 2 \times \text{Layer} \times \text{Teste} \times \text{Dimensione Testa} \times \text{Finestra Contesto} \times \text{Byte per Elemento}$. Per 8k token su un modello 70B, la cache FP16 occupa circa 2,5GB; la quantizzazione a 4 bit (--cache-type-k q4_0 --cache-type-v q4_0) la riduce a 0,7GB.
  • Overhead del Sistema Operativo: macOS riserva 4GB–6GB per WindowServer e servizi di sistema. Linux headless richiede circa 1,2GB.

3. Matrice comparativa dei benchmark: Modelli locali nel 2026

Abbiamo testato i principali modelli open-weight su programmazione, ragionamento logico, invocazione di strumenti e throughput di generazione.

Piattaforme di test:

  • Rig A (Apple Silicon Ultra): Mac Studio M3/M4 Ultra, 128GB Memoria Unificata, banda 800 GB/s.
  • Rig B (Apple Silicon Max): MacBook Pro M4 Max, 48GB Memoria Unificata, banda 410 GB/s.
  • Rig C (Apple Silicon Pro): MacBook Pro M4 Pro, 24GB Memoria Unificata, banda 273 GB/s.
  • Rig D (Dual NVIDIA RTX): 2x NVIDIA GeForce RTX 4090 24GB (48GB VRAM totale), AMD Ryzen 9 9950X, 64GB DDR5.
Modello Architettura e Parametri Formato Quantizzazione VRAM Min. Richiesta SWE-bench Verified LiveCodeBench v4 MMLU-Pro Velocità (Mac Studio 128GB) Velocità (Dual RTX 4090)
Qwen 2.5 Coder 32B Denso / 32.5B Q4_K_M (19.8 GB) 24 GB UMA / VRAM 43.6% 51.2% 68.4% 38.2 tps 76.4 tps
Llama 3.3 70B Instruct Denso / 70.6B Q4_K_M (42.5 GB) 48 GB UMA / Dual GPU 41.2% 48.7% 73.1% 18.5 tps 42.1 tps
DeepSeek R1 Distill 32B Denso Ragionamento/32B Q4_K_M (20.1 GB) 24 GB UMA / VRAM 42.8% 49.5% 71.8% 37.8 tps 74.2 tps
DeepSeek Coder V2.5 MoE (21B att. / 236B) IQ3_XXS (88.4 GB) 96 GB–128 GB UMA 39.4% 46.8% 66.2% 14.2 tps Limite bus PCIe
Qwen 2.5 Coder 14B Denso / 14.7B Q4_K_M (9.2 GB) 16 GB UMA / VRAM 33.8% 40.1% 58.6% 62.4 tps 112.5 tps
Qwen 2.5 Coder 7B Denso / 7.6B Q8_0 (8.1 GB) 12 GB UMA / VRAM 27.4% 34.2% 51.3% 94.1 tps 168.0 tps
GLM-4 9B Chat Denso / 9.2B Q4_K_M (5.8 GB) 10 GB UMA / VRAM 26.8% 32.7% 54.2% 86.5 tps 148.2 tps
Llama 3.2 3B Denso / 3.2B FP16 (6.4 GB) 8 GB UMA / VRAM 16.2% 21.4% 39.8% 145.0 tps 240.0 tps

4. Guida all'hardware: Quale modello scegliere per il tuo Mac o PC?

Fascia 1: 16GB di Memoria Unificata (MacBook Air e Pro base M2/M3/M4)

  • VRAM sfruttabile per i modelli: 11GB–12GB (macOS ne riserva ~4GB).
  • Modello principale: Qwen 2.5 Coder 7B (Q8_0 o Q4_K_M) oppure Qwen 2.5 Coder 14B (Q3_K_M / Q4_K_S).
  • Alternativa: Llama 3.2 3B (Q8_0) per compiti di supporto rapidi e sintesi di commit git.
  • Prestazioni: 55–90 token/sec. Ottimo per autocompletamento del codice, documentazione e refactoring di funzioni.

Fascia 2: 24GB–36GB di Memoria Unificata (M3/M4 Pro e base Max, singola RTX 3090/4090)

  • VRAM sfruttabile per i modelli: 18GB–28GB.
  • Modello principale: Qwen 2.5 Coder 32B Instruct (Q4_K_M) — il punto di riferimento assoluto per lo sviluppo locale.
  • Alternativa: DeepSeek R1 Distill Qwen 32B (Q4_K_M) per ragionamenti complessi, debug di algoritmi e architettura software.
  • Prestazioni: 28–38 token/sec su Apple Silicon; 70–80 token/sec su RTX 4090. Risolve con precisione problemi distribuiti su più file.

Fascia 3: 48GB–64GB di Memoria Unificata (M3/M4 Max 48GB/64GB, Dual RTX 3090/4090)

  • VRAM sfruttabile per i modelli: 38GB–52GB.
  • Modello principale: Llama 3.3 70B Instruct (Q4_K_M) e Qwen 2.5 Coder 32B (Q8_0).
  • Alternativa: Command R+ (Q3_K_S) per l'analisi di grandi volumi di documenti con contesti fino a 128k.
  • Prestazioni: 16–22 token/sec su M4 Max; 40–48 token/sec su due RTX 4090. Livello di ragionamento paragonabile ai modelli commerciali.

Fascia 4: 96GB–128GB+ di Memoria Unificata (Mac Studio M2/M3/M4 Ultra, Mac Pro)

  • VRAM sfruttabile per i modelli: 80GB–110GB.
  • Modello principale: Llama 3.3 70B Instruct (Q8_0), DeepSeek Coder V2.5 MoE (IQ3_M / Q4_K_M) e DeepSeek R1 671B quantizzato (IQ1_S / IQ2_XXS).
  • Prestazioni: 14–20 token/sec su architetture MoE estese. Possibilità di gestire contesti ampi (64k+) interamente in locale senza esaurire la memoria.

5. Approfondimento sui modelli di punta

5.1 Qwen 2.5 Coder 32B: Il punto di riferimento nel codice

Addestrato su 5,5 trilioni di token e 92 linguaggi di programmazione, questo modello di Alibaba elimina la necessità di abbonamenti cloud a pagamento per molti sviluppatori.

  • Vantaggio architetturale: Frequenza RoPE ottimizzata a 1M per garantire la massima accuratezza da 32k a 128k token di contesto.
  • SWE-bench Verified: 43,6% (superiore alle versioni native di GPT-4 e Claude 3 Sonnet).
  • Compatibilità con agenti: Eccellente rispetto degli schemi JSON e chiamate affidabili agli strumenti in ambienti come Cline, Roo Code e OpenCode.

5.2 Llama 3.3 70B Instruct: Il campione open weight di Meta

Il modello di Meta offre le capacità della precedente versione da 405B con un fabbisogno di risorse notevolmente inferiore.

  • Vantaggio architetturale: Grouped-Query Attention (GQA) con 8 teste KV per ridurre del 75% la memoria allocata alla cache.
  • MMLU-Pro: 73,1%, alla pari con Claude 3.5 Sonnet in ingegneria dei sistemi, logica e diritto.
  • Qualità di quantizzazione: Preserva il 99,1% dell'accuratezza FP16 nel formato compresso Q4_K_M (42,5GB).

5.3 DeepSeek R1 Distill Qwen 32B: Ragionamento avanzato sulla scrivania

Modello compatto arricchito con catene di pensiero generate tramite apprendimento per rinforzo (...).

  • Punti di forza: Ottimale nell'individuazione di race condition in codice asincrono e nella verifica di protocolli crittografici.
  • Caratteristica: Genera una quantità elevata di token a causa della formulazione dei passaggi logici; richiede almeno 30 tps per lavorare fluidamente.

6. Motori di inferenza: Ollama vs llama.cpp vs vLLM vs MLX

La scelta del runtime condiziona la velocità di generazione, i tempi di latenza e la facilità di manutenzione. 

+-----------------------------------------------------------------------------------------+
|                                CLASSIFICAZIONE DEI RUNTIME                              |
+-------------------+-------------------+------------------------+------------------------+
| Motore            | Piattaforma       | Punto di Forza         | Scenario Ottimale      |
+-------------------+-------------------+------------------------+------------------------+
| **Ollama**        | macOS, Linux, Win | Semplicità CLI e API   | Sviluppo locale        |
| **llama.cpp**     | Multipiattaforma  | Efficienza C++ e GGUF  | Massima quantizzazione |
| **vLLM**          | Linux / NVIDIA    | PagedAttention ed elev.| Server con alto carico |
|                   |                   | elevato throughput     |                        |
| **MLX / LM-Studio**| Apple Silicon Mac | Ottimizzazione Metal   | GUI e memoria unificata|
+-------------------+-------------------+------------------------+------------------------+

Configurazione pratica: Avviare Qwen 2.5 Coder 32B con Ollama

Installazione e configurazione per una finestra di contesto da 32k con KV-cache a 4 bit: 

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

# 2. Scarica Qwen 2.5 Coder 32B Q4_K_M
ollama run qwen2.5-coder:32b-instruct-q4_K_M

# 3. Definisci un Modelfile personalizzato per contesto 32k
cat << 'EOF' > Modelfile-Coder
FROM qwen2.5-coder:32b-instruct-q4_K_M
PARAMETER num_ctx 32768
PARAMETER num_predict 4096
PARAMETER stop "<|im_end|>"
PARAMETER temperature 0.2
PARAMETER top_p 0.95
EOF

ollama create local-coder-32k -f Modelfile-Coder
ollama serve

Esecuzione nativa su Mac con Apple MLX

Per sfruttare pienamente i chip Apple Silicon con Metal: 

# Installa MLX-LM
pip install mlx-lm

# Esecuzione ottimizzata di Qwen 2.5 Coder 32B 4-bit
python -m mlx_lm.generate   --model mlx-community/Qwen2.5-Coder-32B-Instruct-4bit   --prompt "Scrivi un pattern actor ad alta concorrenza in Rust con Tokio."   --max-tokens 2048   --temp 0.2

7. Analisi dei costi e ritorno sull'investimento: Hardware locale vs API Cloud

Investire in un Mac Studio ($3.999) o in una workstation con 2x RTX 4090 ($3.500) conviene rispetto all'acquisto di token API su Claude 3.7 Sonnet o OpenAI o3? 

+-----------------------------------------------------------------------------------------+
|                                COSTO CUMULATIVO SU 24 MESI                              |
|                                                                                         |
| $15.000 |                                                API Cloud (Uso Intensivo)      |
|         |                                                .................../           |
| $10.000 |                                  ............./                               |
|         |                    ............./                                             |
|  $5.000 |      ............/                      Mac Studio M4 Ultra Locale ($3.999)   |
|         | ----/------------------------------------------------------------------------ |
|      $0 +------------------------------------------------------------------------------ |
|         Mese 0             Mese 6             Mese 12            Mese 18       Mese 24  |
+-----------------------------------------------------------------------------------------+
Profilo del Team Consumo Mensile Token Costo API Cloud (Sonnet/o3) Costo Mac Studio 128GB Locale Ritorno Investimento
Sviluppatore Singolo 15M token/mese $85 / mese $3.999 iniziale + $8/mese energia 48 mesi
Team Agile (5 devs) 120M token/mese $680 / mese $3.999 iniziale + $18/mese energia 5,8 mesi
Reparto IT (20 devs) 850M token/mese $4.850 / mese Cluster 2x Mac Studio ($7.998) 1,7 mesi

Verdetto economico: Per un utilizzo occasionale, i servizi API cloud rimangono più accessibili. Per team di sviluppo attivi che impiegano agenti autonomi (Cline, Roo Code o Aider con un consumo tra 500k e 2M token per attività), l'hardware locale si ripaga in meno di sei mesi assicurando totale riservatezza sui dati.

8. Linee guida per l'adozione aziendale

  1. Per Mac portatili da 16GB: Privilegia Qwen 2.5 Coder 14B Q4_K_M o 7B Q8_0. Evita modelli da 32B su macchine da 16GB: l'eccessivo ricorso alla memoria swap rallenta il sistema (<2 tps) e usura il disco.
  2. Per postazioni da 32GB–48GB: Utilizza Qwen 2.5 Coder 32B Instruct (Q4_K_M) per la scrittura di codice e Llama 3.3 70B (IQ3_XXS) per le scelte architetturali.
  3. Gestione della KV Cache: Attiva la quantizzazione a 4 bit (q4_0) su llama.cpp e Ollama per recuperare da 3GB a 8GB di memoria con finestre estese da oltre 32k token.
  4. Integrazione con agenti: Collega l'endpoint locale di Ollama (http://localhost:11434/v1) ai client VS Code compatibili con le API di OpenAI per creare un flusso di sviluppo sicuro e totalmente offline.

9. Domande frequenti (FAQ)

Il chip Apple Silicon M4 Pro supporta Llama 3.3 70B?

Un M4 Pro con 24GB o 36GB di memoria non può eseguire Llama 3.3 70B senza un livello estremo di quantizzazione (IQ2_XXS) e un continuo rallentamento dovuto allo swap del disco (<1 tps). Per ottenere una velocità adeguata di 18–22 tps con profilo Q4_K_M occorrono almeno 48GB–64GB di memoria unificata.

Perché la memoria unificata Apple è più indicata di NVIDIA per modelli 70B+?

Per un fattore di costo e scalabilità della memoria. Eseguire un modello 70B in formato Q8 o modelli MoE di grandi dimensioni richiede tra 60GB e 120GB di VRAM. Nei sistemi PC tradizionali servono più schede professionali NVIDIA (A100/H100) con costi compresi tra $6.000 e oltre $30.000. Un Mac Studio da 128GB mette a disposizione questa memoria in un dispositivo desktop silenzioso per meno di $4.000.

Qual è il miglior modello locale per agenti di programmazione autonomi?

Qwen 2.5 Coder 32B Instruct è il punto di riferimento. Ottiene il 43,6% su SWE-bench Verified, gestisce con rigore le chiamate di strumenti in formato JSON e può essere eseguito in 24GB di memoria con quantizzazione Q4_K_M.

← Tutti gli Articoli
0 / 4
Confronta ora →