MLX versus llama.cpp em Macs com chips da série M: quem vence em 2026 ?

#Os dois lados em 2026

MLX saiu no final de 2023, desenvolvido pela equipe de ML da Apple. É um framework Python que parece uma fusão entre NumPy e PyTorch, projetado desde o início para memória unificada e Metal. Sua abrangência é ampla: LLM, visão, áudio, fine-tuning. O pacote mlx-lm cuida especificamente da inferência e do treinamento de modelos de linguagem.

llama.cpp é um projeto C++ criado em 2023 que se tornou o padrão de fato para inferência local de LLM em todas as plataformas. No Mac, seu backend Metal gera shaders de computação para aproveitar a GPU Apple Silicon. É ele que faz rodar Ollama, LM Studio e a maioria das ferramentas voltadas ao público em geral. Formato de modelo: GGUF.

#1. Instalação

No MLX, tudo passa por pip. O runtime mlx-lm gerencia o download do Hugging Face, a conversão, a quantização e a inferência.

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."

Quanto ao llama.cpp, você tem três opções: compilar a partir do código-fonte com Metal ativado, usar o Homebrew ou usar um wrapper como Ollama ou LM Studio. Para comparar de forma honesta, usamos o binário compilado.

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. Tokens/segundo no M3 Max e M4 Pro

Aqui estão ordens de grandeza representativas para duas máquinas comuns em 2026: um MacBook Pro M3 Max de 64 GB (banda passante de 400 GB/s) e um Mac mini M4 Pro de 48 GB (273 GB/s). Modelos comparados com quantização equivalente — MLX de 4 bits versus GGUF Q4_K_M — usando um prompt de 200 tokens e 256 tokens gerados.

Qwen 3.5 4B — M3 Max

MLX 4-bit: 150 tok/s · llama.cpp Q4_K_M: 135 tok/s. MLX com ~11% de vantagem.

Qwen 3.5 9B — M3 Max

MLX 4-bit: 72 tok/s · llama.cpp Q4_K_M: 66 tok/s. Diferença ~9% a favor do 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%.

O padrão é claro e reprodutível: o MLX ganha entre 8 e 15% na geração pura. A diferença vem do fato de que os kernels Metal do MLX são escritos e otimizados diretamente pela Apple, com conhecimento aprofundado do escalonador da GPU e dos caches L1/L2. O llama.cpp também utiliza kernels Metal, mas eles são mais genéricos.

#3. Suporte a modelos Hugging Face

Esse é um dos pontos em que os dois ecossistemas divergem na prática. O MLX tem seu próprio formato de pesos (.safetensors com configuração MLX), e o llama.cpp utiliza GGUF.

MLX — disponibilidade

A organização mlx-community no Hugging Face publica a maioria dos modelos populares (Qwen 3.5/3.8, Gemma 4, Mistral, Granite 4.2) em versões de 4 e 8 bits, frequentemente na semana do lançamento.

MLX — modelos raramente encontrados

Para um fine-tune incomum ou um modelo pouco conhecido, você terá que fazer a conversão por conta própria com mlx_lm.convert. Conversão típica: 2 a 10 minutos conforme o tamanho.

llama.cpp — disponibilidade

Os GGUF estão em todos os lugares. Bartowski, TheBloke (arquivos), Unsloth e os editores oficiais publicam em GGUF antes mesmo do MLX para muitos modelos.

llama.cpp — modelos muito recentes

Quando uma nova arquitetura é lançada (ex.: MoE inédita, atenção exótica), o llama.cpp precisa implementá-la em C++. Prazo típico: de alguns dias a 2 semanas. O MLX, por usar Python + Metal, às vezes acompanha mais rapidamente quando a Apple já preparou essa arquitetura.

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. Quantizações disponíveis

É provavelmente o tema em que o llama.cpp domina sem contestação. O GGUF oferece uma dúzia de variantes de quantização (Q2_K, Q3_K_S/M/L, Q4_K_S/M, Q5_K_M, Q6_K, Q8_0, mais os I-quants IQ2_XXS a IQ4_NL) que permitem ajustar com precisão o equilíbrio entre tamanho e qualidade.

MLX

Quantização de 4 bits, 6 bits e 8 bits. Parâmetro principal: group-size (32, 64, 128). Não há equivalente direto para os K-quants mistos (Q4_K_M conserva mais precisão em certas camadas).

llama.cpp

GGUF Q4_K_M (recomendado), Q5_K_M, Q6_K, Q8_0, FP16, além dos I-quants para chegar a níveis de quantização ainda menores. Calibração possível via imatrix.

Qualidade observada

Com tamanhos equivalentes, GGUF Q4_K_M e MLX 4-bit apresentam uma perplexidade muito próxima (diferença < 1%). Para fazer um modelo grande caber em uma quantidade limitada de RAM (Qwen 3.8 27B em 16 GB), os I-quants do llama.cpp continuam oferecendo opções mais granulares.

#5. Memória unificada: quem a explora melhor?

Nos Macs da série M, CPU e GPU compartilham a mesma RAM. Sem cópia, sem transferência via PCIe, apenas um único pool de memória. Essa é a vantagem estrutural dos chips Apple para a inferência de LLMs, e os dois frameworks se beneficiam dela — mas de formas diferentes.

MLX

Projetado desde o início para a memória unificada. Os tensores ficam em um espaço endereçável pela CPU e pela GPU, sem distinção. Conversão sem cópia entre NumPy e MLX. Esse é o principal argumento arquitetural da Apple.

llama.cpp Metal

Aloca objetos MTLBuffer compartilhados. Funciona, mas adiciona uma camada de abstração. Para modelos que ultrapassam a VRAM alocada por padrão, às vezes é necessário ajustar manualmente o limite via sudo sysctl iogpu.wired_limit_mb.

Modelos grandes com 64 GB

Em 2026, mesmo o modelo líder geral Qwen 3.8 27B pesa apenas ~18 GB em 4 bits: 64 GB de RAM unificada deixam espaço para um grande MoE como Qwen 3.6 35B-A3B (~23 GB) ou para a mesma versão em Q8 para qualidade máxima. Em 128 GB (M3 Max com especificação máxima ou M2 Ultra), você carrega vários modelos em paralelo sem comprometer.

#6. Integração Python

Se você desenvolver um agente, um pipeline RAG, ou instrumentar seu LLM com LangChain / LlamaIndex / seu próprio código, a experiência em Python conta tanto quanto os tokens por segundo.

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)

No caso do llama.cpp, a integração com Python é feita por meio de llama-cpp-python (bindings oficiais). A API é mais verbosa, mais próxima do C++, mas é compatível com a API da OpenAI depois que o servidor é iniciado.

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 — conforto

API muito limpa, sintaxe semelhante à do NumPy, integração nativa com o HF Hub. Para um cientista de dados, é imediato.

MLX — limites

Ainda não há endpoint oficial compatível com a OpenAI integrado. Para servir um modelo para vários clientes, você deve montar seu próprio wrapper FastAPI.

llama.cpp — conforto

A API Python é razoável, mas o uso real em produção passa pelo llama-server (binário), que expõe nativamente o endpoint /v1/chat/completions compatível com a OpenAI.

llama.cpp — limites

O wheel llama-cpp-python deve ser recompilado com o flag Metal correto (CMAKE_ARGS="-DGGML_METAL=on" pip install llama-cpp-python --force-reinstall --no-cache-dir). Isso pode dificultar o uso.

#7. Ecossistema e ferramentas

Além do runtime em si, é o ecossistema que determina o que você poderá fazer concretamente.

Ollama

Baseado em llama.cpp. A forma mais simples de ter um LLM rodando no Mac com uma API compatível com a OpenAI no localhost:11434.

LM Studio

Suporta os dois motores desde 2025: llama.cpp por padrão, MLX como opção para modelos compatíveis. Muda em um clique.

Fine-tuning LoRA

O MLX conta com mlx_lm.lora nativo, uma implementação bem feita que roda na GPU integrada sem gambiarras. O llama.cpp não faz fine-tuning — é necessário usar Unsloth ou MLX.

Servir um modelo

llama.cpp vence sem discussão com llama-server: suporte a múltiplos clientes, processamento em lotes, slots e compatibilidade com OAI. No caso do MLX, mlx_lm.server existe desde 2025, mas continua básico.

Visão e áudio

MLX tem extensões (mlx-vlm, mlx-whisper) bem mantidas. O llama.cpp abrange a visão por meio dos modelos LLaVA / Qwen-VL, com suporte que depende do build.

#Veredito por caso de uso

Você quer o máximo de tokens por segundo em chat local

MLX. +10% grátis, e a diferença se acentua nos grandes modelos. Principalmente em 4-bit.

Você quer servir um endpoint para vários clientes (equipe, aplicativo)

llama.cpp (llama-server ou Ollama). Com suporte a múltiplos slots, processamento em lotes, compatibilidade com a API da OpenAI e estabilidade consolidada há muito tempo.

Você testa cerca de dez modelos diferentes por semana

llama.cpp. O ecossistema GGUF é imbatível em cobertura e atualização das quantizações.

Você desenvolve um projeto em Python (agente, RAG, pipeline)

MLX se tudo for local e apenas para Mac. llama-cpp-python ou um cliente Ollama se você quiser código portável para Linux/Mac.

Você quer fazer fine-tuning de um modelo de 7 a 13B no seu Mac

MLX. mlx_lm.lora funciona muito bem no M3 Max / M4 Pro com 32 GB+.

Você está começando e quer apenas um LLM que funcione

Ollama (portanto, llama.cpp). Um comando e pronto.

#Para se aprofundar

Algumas leituras relacionadas para aprofundar o tema: