MLX vs llama.cpp su Mac M-series: chi vince nel 2026 ?

#I due schieramenti nel 2026

MLX è uscito alla fine del 2023, sviluppato dal team ML di Apple. È un framework Python che ricorda una fusione tra NumPy e PyTorch, progettato fin dall'inizio per la memoria unificata e Metal. Il suo campo d'applicazione è ampio: LLM, visione, audio, fine-tuning. Il pacchetto mlx-lm si occupa specificamente dell'inferenza e dell'addestramento dei modelli linguistici.

llama.cpp è un progetto C++ nato nel 2023, diventato lo standard di fatto per l'inferenza locale degli LLM su tutte le piattaforme. Su Mac, il suo backend Metal genera compute shader per sfruttare la GPU Apple Silicon. È ciò che fa funzionare Ollama, LM Studio e la maggior parte degli strumenti destinati al grande pubblico. Formato del modello: GGUF.

#1. Installazione

Con MLX, tutto passa tramite pip. Il runtime mlx-lm gestisce il download da Hugging Face, la conversione, la quantizzazione e l'inferenza.

pip install mlx-lm

# Premier test : Qwen 3.5 4B 4-bit en une commande
mlx_lm.generate --model mlx-community/Qwen3.5-4B-Instruct-4bit \
  --prompt "Explique la mémoire unifiée Apple en 3 phrases."

Per llama.cpp, hai tre opzioni: compilare dal codice sorgente con Metal attivato, usare Homebrew o ricorrere a un wrapper come Ollama o LM Studio. Per un confronto onesto, utilizziamo il binario compilato.

brew install llama.cpp

# Inférence sur un modèle GGUF déjà téléchargé
llama-cli -m ./Qwen3.5-4B-Instruct-Q4_K_M.gguf \
  -p "Explique la mémoire unifiée Apple en 3 phrases." \
  -n 256 -ngl 99

#2. Token/sec su M3 Max e M4 Pro

Ecco alcuni ordini di grandezza rappresentativi su due macchine comuni nel 2026: un MacBook Pro M3 Max da 64 GB (banda passante di 400 GB/s) e un Mac mini M4 Pro da 48 GB (273 GB/s). Modelli confrontati con quantizzazione equivalente — MLX a 4 bit vs GGUF Q4_K_M — con un prompt di 200 token e 256 token generati.

Qwen 3.5 4B — M3 Max

MLX 4-bit: 150 tok/s · llama.cpp Q4_K_M: 135 tok/s. MLX in vantaggio di circa l'11%.

Qwen 3.5 9B — M3 Max

MLX 4-bit: 72 tok/s · llama.cpp Q4_K_M: 66 tok/s. Differenza ~9% a favore di MLX.

Gemma 4 12B — M3 Max

MLX 4-bit: 48 tok/s · llama.cpp Q4_K_M: 44 tok/s. MLX +9%.

Mistral Small 24B — M3 Max

MLX 4-bit: 24 tok/s · llama.cpp Q4_K_M: 22 tok/s. MLX +9%.

Qwen 3.8 27B — M3 Max

MLX 4-bit: 21 tok/s · llama.cpp Q4_K_M: 19 tok/s. MLX +10%.

Qwen 3.5 9B — M4 Pro

MLX 4-bit : 50 tok/s · llama.cpp Q4_K_M : 46 tok/s. MLX +9%.

Il pattern è chiaro e riproducibile: MLX guadagna tra l'8% e il 15% nella sola generazione. La differenza deriva dal fatto che i kernel Metal di MLX sono scritti e ottimizzati direttamente da Apple, con una conoscenza approfondita dello scheduler della GPU e delle cache L1/L2. Anche llama.cpp utilizza kernel Metal, ma più generici.

#3. Supporto dei modelli Hugging Face

È uno dei punti in cui i due ecosistemi si differenziano in pratica. MLX ha il proprio formato dei pesi (.safetensors con configurazione MLX), llama.cpp utilizza GGUF.

MLX — disponibilità

L'organizzazione mlx-community su Hugging Face pubblica la maggior parte dei modelli popolari (Qwen 3.5/3.8, Gemma 4, Mistral, Granite 4.2) in versioni a 4 bit e a 8 bit, spesso entro una settimana dall'uscita.

MLX — modelli rari

Per un fine-tune particolare o un modello poco conosciuto, dovrai effettuare tu stesso la conversione con mlx_lm.convert. Conversione tipica: 2-10 minuti a seconda delle dimensioni.

llama.cpp — disponibilità

I GGUF sono ovunque. Bartowski, TheBloke (archivi), Unsloth e gli editori ufficiali pubblicano molti modelli in formato GGUF prima ancora che in formato MLX.

llama.cpp — modelli molto recenti

Quando esce una nuova architettura (ad esempio una MoE inedita o un meccanismo di attenzione insolito), llama.cpp deve implementarla in C++. Tempi tipici: da pochi giorni a 2 settimane. MLX, essendo basato su Python + Metal, a volte si adegua più rapidamente quando Apple l'ha già preparata.

mlx_lm.convert \
  --hf-path Qwen/Qwen3.5-9B-Instruct \
  --mlx-path ./qwen3.5-9b-mlx-4bit \
  -q --q-bits 4 --q-group-size 64

#4. Quantizzazioni disponibili

È probabilmente l'ambito in cui llama.cpp domina nettamente. GGUF offre una dozzina di varianti di quantizzazione (Q2_K, Q3_K_S/M/L, Q4_K_S/M, Q5_K_M, Q6_K, Q8_0, più gli I-quants da IQ2_XXS a IQ4_NL) che permettono di regolare finemente il compromesso tra dimensione e qualità.

MLX

Quantizzazione a 4, 6 e 8 bit. Parametro principale: group-size (32, 64, 128). Non esiste un equivalente diretto dei K-quants misti (Q4_K_M conserva una maggiore precisione su alcuni strati).

llama.cpp

GGUF Q4_K_M (consigliato), Q5_K_M, Q6_K, Q8_0, FP16, oltre agli I-quants per scendere ancora di più. Calibrazione possibile tramite imatrix.

Qualità osservata

A parità di dimensioni, GGUF Q4_K_M e MLX 4-bit offrono una perplessità molto simile (scarto < 1%). Per far stare un modello di grandi dimensioni in una RAM limitata (Qwen 3.8 27B su 16 GB), le I-quants di llama.cpp consentono una quantizzazione più fine.

#5. Memoria unificata: chi la sfrutta meglio?

Sui Mac della serie M, CPU e GPU condividono la stessa RAM. Nessuna copia, nessun trasferimento tramite PCIe, solo un unico pool. È il vantaggio strutturale dei chip Apple per l'inferenza LLM, e i due framework ne beneficiano, ma in modo diverso.

MLX

Progettato nativamente per la memoria unificata. I tensori risiedono in uno spazio indirizzabile sia dalla CPU sia dalla GPU, senza distinzione. Conversione senza copia tra NumPy e MLX. È il principale punto di forza architetturale di Apple.

llama.cpp Metal

Alloca MTLBuffer condivisi. Funziona, ma aggiunge un livello di astrazione. Per i modelli che superano la quantità di VRAM allocata per impostazione predefinita, a volte è necessario regolare manualmente il limite tramite sudo sysctl iogpu.wired_limit_mb.

Grandi modelli su 64 GB

Nel 2026, anche il modello leader generale Qwen 3.8 27B pesa soltanto circa 18 GB in 4-bit: 64 GB di RAM unificata lasciano largamente spazio a un grande MoE come Qwen 3.6 35B-A3B (~23 GB) o a una versione identica in Q8 per la qualità massima. Su 128 GB (M3 Max top spec o M2 Ultra), si possono caricare diversi modelli in parallelo senza compromessi.

#6. Integrazione Python

Se programmi un agente, una pipeline RAG o doti il tuo LLM di strumenti tramite LangChain / LlamaIndex / il tuo codice, l'esperienza con Python conta quanto i token al secondo.

from mlx_lm import load, stream_generate

model, tokenizer = load("mlx-community/Qwen3.5-9B-Instruct-4bit")

prompt = tokenizer.apply_chat_template(
    [{"role": "user", "content": "Résume MLX en 3 phrases."}],
    tokenize=False, add_generation_prompt=True,
)

for chunk in stream_generate(model, tokenizer, prompt, max_tokens=256):
    print(chunk.text, end="", flush=True)

Per llama.cpp, l'integrazione con Python avviene tramite llama-cpp-python (binding ufficiali). L'API è più verbosa, più vicina al C++, ma è compatibile con OpenAI una volta avviato il server.

from llama_cpp import Llama

llm = Llama(
    model_path="./Qwen3.5-9B-Instruct-Q4_K_M.gguf",
    n_gpu_layers=-1,   # tout sur Metal
    n_ctx=8192,
    flash_attn=True,
)

for chunk in llm.create_chat_completion(
    messages=[{"role": "user", "content": "Résume llama.cpp en 3 phrases."}],
    stream=True,
):
    delta = chunk["choices"][0]["delta"].get("content", "")
    print(delta, end="", flush=True)

MLX — comodità

API molto pulita, sintassi simile a NumPy, integrazione nativa con HF Hub. Per un data scientist, l'utilizzo è immediato.

MLX — limiti

Non c'è (ancora) un endpoint ufficiale integrato compatibile con OpenAI. Per servire un modello a più client, devi creare il tuo wrapper FastAPI.

llama.cpp — comodità

L'API Python è adeguata, ma l'uso effettivo in produzione passa per llama-server (binario), che espone nativamente l'endpoint /v1/chat/completions compatibile con OpenAI.

llama.cpp — limiti

Il wheel llama-cpp-python deve essere ricompilato con il flag Metal corretto (CMAKE_ARGS="-DGGML_METAL=on" pip install llama-cpp-python --force-reinstall --no-cache-dir). Una complicazione.

#7. Ecosistema e strumenti

Al di là del solo runtime, è l'ecosistema a determinare ciò che potrai fare concretamente.

Ollama

Basato su llama.cpp. Il modo più semplice per avere un LLM che funziona su Mac con un'API compatibile con OpenAI su localhost:11434.

LM Studio

Supporta i due motori dal 2025: llama.cpp di default, MLX opzionale per modelli compatibili. Cambio in un clic.

Fine-tuning LoRA

MLX dispone di mlx_lm.lora nativo, con un'implementazione molto pulita, che gira sulla GPU integrata senza dover ricorrere ad accorgimenti artigianali. llama.cpp non esegue il fine-tuning — bisogna usare Unsloth o MLX.

Esporre un modello come servizio

llama.cpp vince senza discussioni con llama-server: supporto per più client, elaborazione in batch, slot, compatibilità con OAI. Sul versante MLX, mlx_lm.server esiste dal 2025 ma rimane essenziale.

Visione e audio

MLX ha estensioni (mlx-vlm, mlx-whisper) ben mantenute. llama.cpp supporta la visione tramite i modelli LLaVA / Qwen-VL, con un supporto che dipende dalla build.

#Verdetto per caso d'uso

Vuoi il massimo numero di token al secondo nella chat locale

MLX. Un 10% in più senza costi aggiuntivi, e il divario aumenta con i modelli più grandi. Soprattutto a 4 bit.

Vuoi mettere a disposizione un endpoint per più client (team, app)

llama.cpp (llama-server o Ollama). Multislot, batched, compatibile con OpenAI, stabile da tempo.

Provi una decina di modelli diversi a settimana

llama.cpp. L'ecosistema GGUF è imbattibile per copertura e disponibilità di quantizzazioni aggiornate.

Scrivi un progetto Python (agente, RAG, pipeline)

MLX se tutto è locale e solo per Mac. llama-cpp-python o un client Ollama se vuoi codice portabile tra Linux e Mac.

Vuoi fare fine-tuning di un modello da 7-13B sul tuo Mac

MLX. mlx_lm.lora funziona molto bene su M3 Max / M4 Pro con 32 GB+.

Sei alle prime armi e vuoi semplicemente un LLM che funzioni

Ollama (quindi llama.cpp). Basta un comando e il gioco è fatto.

#Per approfondire

Alcuni approfondimenti correlati per sviluppare il tema: