En un Mac con Apple Silicon, baja MLX si vas a usar mlx-lm o el motor MLX de LM Studio: en 6 de los 7 modelos que medimos, el MLX de 4 bits ocupa un 4-8 % menos que el GGUF Q4_K_M. Baja GGUF para llama.cpp, para otro ordenador o para más niveles de compresión. Ollama elige por ti.
Esa última frase esconde lo más curioso de esta página, y llegaremos a ello. Antes, el método. El 27 de octubre de 2026 medimos en Hugging Face el tamaño real de los mismos 7 modelos en los dos formatos, leímos el código de Ollama 0.40.11 donde decide qué fichero baja tu Mac y le pedimos 9 modelos a su catálogo igual que se los pide el propio Ollama. Las versiones de ese día: mlx-lm 0.32.2 con mlx 0.32.4, llama.cpp v0.7.0, Ollama 0.40.11 y LM Studio 0.4.26. Lo que no hemos hecho es cronometrar MLX contra llama.cpp en un Mac nuestro, así que aquí no vas a encontrar un ganador en velocidad; más abajo te contamos por qué.
MLX (mlx-lm)Ficha del programa
llama.cppFicha del programa
| MLX | GGUF | |
|---|---|---|
| Qué es | El framework de aprendizaje automático de Apple y su formato de modelo: una carpeta con config.json, el tokenizador y los pesos en ficheros safetensors |
El formato que creó llama.cpp: 1 fichero con los pesos, el tokenizador y los ajustes (los modelos grandes vienen partidos en trozos) |
| Dónde funciona | Macs con Apple Silicon y macOS 14 o posterior; en Linux, con CUDA o solo con el procesador mediante paquetes extra | Windows, macOS (en los Mac Intel, solo con el procesador), Linux y Android |
| Programas que lo ejecutan | mlx-lm, el motor MLX de LM Studio y Ollama en Apple Silicon | llama.cpp, LM Studio y Ollama; mlx-lm no |
| Versiones a 27 de octubre de 2026 | mlx-lm 0.32.2, mlx 0.32.4 | llama.cpp v0.7.0 (compilación b11669) |
| Niveles de compresión | 2, 3, 4, 5, 6 u 8 bits, más mxfp4, nvfp4 y mxfp8, recetas mixtas y versiones DWQ | 25 ficheros de Qwen3 8B en un solo repositorio, desde IQ1_S hasta Q8_0 y BF16 |
| El mismo modelo a 4 bits (Qwen3 Coder 30B) | 16,00 GiB, 4,50 bits por peso | 17,28 GiB en Q4_K_M, 4,86 bits por peso |
| Modelos que entienden imágenes | La parte de imagen va dentro de la misma carpeta | Un fichero mmproj aparte, 0,87 GiB en Qwen3.6 27B |
| En Ollama 0.40.11 | Lo baja un Mac con Apple Silicon cuando la etiqueta tiene versión MLX | Lo baja cualquier otro equipo, y el Mac cuando la etiqueta no tiene versión MLX |
| Hacerte el tuyo | mlx_lm.convert -q a partir de los pesos originales |
El script convert_hf_to_gguf.py del repositorio de llama.cpp y luego su cuantizador |
| Servidor local | mlx_lm.server en 127.0.0.1:8080 |
llama serve en 127.0.0.1:9931 |
| Velocidad | No la hemos medido | No la hemos medido |
2 formatos y 4 programas: quién lee qué
La comparación se enreda porque MLX son 2 cosas a la vez. Es el framework de Apple, la capa de cálculo que trabaja en el chip gráfico del Mac aprovechando su memoria unificada, y también es el nombre que se da a los modelos convertidos para él. GGUF es solo un formato de fichero, el que inventó llama.cpp, y los 3 programas de esta página que lo leen llevan llama.cpp dentro.
En un Mac leen estos ficheros 4 programas, y cada uno se pone de un lado:
- mlx-lm ejecuta MLX y nada más. Carga una carpeta con
config.jsony ficherosmodel*.safetensors; un*.ggufni siquiera está en la lista de ficheros que descarga. Sabe exportar un modelo a GGUF, pero solo modelos tipo Mistral, Mixtral y Llama en fp16. - llama.cpp ejecuta GGUF y nada más, en el chip gráfico del Mac a través de Metal. Un modelo en safetensors hay que convertirlo antes.
- LM Studio ejecuta los dos. Su buscador enseña GGUF y MLX juntos; el GGUF va a su motor llama.cpp y el MLX a su propio motor MLX, que es de código abierto con licencia MIT.
- Ollama también ejecuta los dos, pero elige por ti: en un Mac con Apple Silicon baja la versión MLX de un modelo cuando la hay, y si no, la GGUF.
LM StudioFicha del programa
OllamaFicha del programa

Así que «¿MLX o GGUF?» son en realidad 2 preguntas: qué fichero y qué programa lo va a ejecutar. Si el programa es llama.cpp, la respuesta es GGUF y aquí se acaba la página. Lo divertido empieza con los otros 3.
Mismo modelo, 2 tamaños: lo que medimos en 7 modelos
Cogimos 7 modelos que existen en los dos formatos y sumamos los bytes de todos sus ficheros de pesos en Hugging Face el 27 de octubre de 2026: la versión MLX de 4 bits de la organización mlx-community contra el GGUF Q4_K_M de los repositorios que ya usa nuestro buscador de modelos, para que las cifras se puedan cotejar con él.
| Modelo | MLX 4 bits | GGUF Q4_K_M | Diferencia |
|---|---|---|---|
| Qwen3 8B | 4,29 GiB | 4,68 GiB | −0,39 GiB (−8,4 %) |
| Qwen3.5 9B* | 5,54 GiB | 5,29 GiB | +0,25 GiB (+4,7 %) |
| Gemma 4 12B | 6,28 GiB | 6,63 GiB | −0,35 GiB (−5,3 %) |
| gpt-oss-20b | 10,41 GiB | 10,83 GiB | −0,42 GiB (−3,8 %) |
| Qwen3.6 27B* | 14,95 GiB | 15,66 GiB | −0,71 GiB (−4,5 %) |
| Qwen3 Coder 30B A3B | 16,00 GiB | 17,28 GiB | −1,28 GiB (−7,4 %) |
| Qwen3.6 35B A3B* | 19,00 GiB | 20,61 GiB | −1,61 GiB (−7,8 %) |
Medido: tamaño de los ficheros de pesos en Hugging Face el 27 de octubre de 2026, en GiB (la unidad de nuestro buscador de modelos). MLX: mlx-community, versiones de 4 bits (afín, grupos de 64; en gpt-oss-20b, su versión MXFP4-Q4). GGUF: unsloth, Q4_K_M (UD-Q4_K_M en Qwen3.6 35B A3B, el fichero que cuenta nuestro catálogo). *La carpeta MLX de estos 3 incluye la parte que lee imágenes; en GGUF es un fichero aparte de 0,84-0,87 GiB que solo hace falta para imágenes. La carpeta MLX de Gemma 4 12B también lleva una pequeña parte de imagen y audio; su fichero de imagen GGUF aparte ocupa 0,16 GiB.
MLX sale más ligero en 6 de 7, entre 0,35 y 1,61 GiB. El raro, Qwen3.5 9B, no rompe la regla: su carpeta MLX lleva dentro el lector de imágenes, y en cuanto sumas al GGUF su fichero de imagen aparte (0,86 GiB), MLX vuelve a ser más ligero, un 9,9 %.
¿Cuál responde mejor «a 4 bits»? Q4_K_M gasta más bits, pero cómo se nota eso en las respuestas no lo hemos medido, y el tamaño de un fichero no lo dice. Lo que sí podemos decirte es que las 2 etiquetas, «4-bit» y «Q4», no describen lo mismo.
Qué cabe en tu Mac: la misma cuenta, con MLX casi siempre del lado seguro
Nuestro buscador de modelos y nuestras fichas de equipo suman el fichero GGUF Q4_K_M, la memoria del contexto para la longitud que elijas y un margen para el programa, y apartan 3 GiB de memoria unificada para macOS y tus aplicaciones abiertas. Esos tamaños son de GGUF. En 6 de los 7 modelos de arriba la versión MLX de 4 bits pesó menos, así que en esos la cuenta del buscador se queda del lado seguro en lo que toca al fichero; Qwen3.5 9B, con su lector de imágenes dentro, pesa 0,25 GiB más en MLX. Para un modelo que no hemos medido en los dos formatos, mira el tamaño de los ficheros MLX antes de fiarte de la cuenta del GGUF.
El contexto cuesta lo mismo en los dos. mlx-lm guarda la caché del contexto a precisión completa salvo que le pidas --kv-bits, y llama.cpp la guarda en 16 bits por defecto, así que la memoria que ocupa una conversación larga depende del modelo y de la longitud, no del formato.

Hay una pega que es solo de MLX. mlx-lm le pregunta a macOS cuánta memoria recomienda para el chip gráfico y fija hasta esa cantidad, y en un Mac de 16 GB esa recomendación se queda bastante por debajo de los 13 GiB que nuestras fichas dejan para el modelo. Cuando los pesos pasan del 90 % de esa cifra, mlx-lm te avisa antes del primer token; si la pasan, todo va más lento o se cae. Las cifras reales de un Mac de 16 GB, el aviso y cómo subir ese techo están en nuestra guía de errores de MLX. Y si prefieres medir a calcular, mlx_lm.generate imprime Peak memory (en GB de 10^9 bytes) después de cada respuesta: lo que el modelo y la conversación ocuparon de verdad en tu Mac.
Ollama elige por ti: MLX en el Mac, GGUF en todo lo demás
Aquí va lo curioso. Desde la 0.40.0, una etiqueta del catálogo de Ollama puede ser una lista con 2 versiones: una MLX, hecha de safetensors, y una GGUF. En el código de la 0.40.11, la función runnerPreferences() decide el orden: en macOS con Apple Silicon, primero MLX y después llama.cpp; en cualquier otro sistema, primero llama.cpp y MLX la última. Al cargar el modelo, un GGUF va al propio servidor de llama.cpp y un modelo MLX al ejecutor MLX de Ollama.
Le pedimos 9 etiquetas al catálogo de Ollama con la misma petición que manda Ollama, la que acepta una lista. 6 volvieron con 2 versiones, y esto es lo que baja cada equipo:
| Etiqueta | Mac con Apple Silicon (MLX) | Windows, Linux, Mac Intel (GGUF) |
|---|---|---|
qwen3.5:9b |
7,11 GiB | 6,10 GiB |
gemma4:e4b |
8,81 GiB | 6,13 GiB |
gemma4:12b |
7,18 GiB | 7,47 GiB |
qwen3.6:27b |
17,49 GiB | 16,55 GiB |
qwen3.6:35b |
21,98 GiB | 21,07 GiB |
flint:latest |
21,03 GiB | 21,29 GiB |
Medido: suma de las capas de cada versión en el registro de Ollama el 27 de octubre de 2026, con las partes de imagen y de apoyo incluidas. Las otras 3 etiquetas que pedimos, qwen3:8b, gpt-oss:20b y qwen3-coder:30b, tienen una sola versión GGUF, el mismo fichero en todos los equipos.
Fíjate bien: en 4 de las 6, el Mac baja el fichero más grande, hasta 2,68 GiB más en gemma4:e4b. El motivo es que las versiones MLX de Ollama no son las de 4 bits de mlx-community de la sección anterior. Casi todas están hechas con la herramienta ModelOpt de NVIDIA en NVFP4, un formato de 4 bits propio de NVIDIA, y algunas dejan partes del modelo en 8 bits o más; la versión MLX de Flint usa enteros de 4 bits sin más. Así que «MLX ocupa menos» vale para los ficheros que eliges tú, no para lo que elige Ollama por ti.

Las etiquetas con una sola versión GGUF también funcionan en el Mac: Ollama se las pasa a llama.cpp, que usa el chip gráfico a través de Metal. El motor no lo eliges tú; lo elige la etiqueta. El motor MLX de Ollama es código propio, no mlx-lm, y nuestra comparativa MLX vs Ollama mira qué modelos conoce cada uno.
Niveles de compresión: 25 ficheros GGUF contra un puñado de versiones MLX
Aquí GGUF gana en variedad. De Qwen3 8B, un solo repositorio GGUF tiene 25 ficheros: los i-quants de IQ1_S a IQ4_NL, los k-quants de Q2_K a Q6_K, Q4_1, Q8_0 y BF16, más versiones mixtas «XL». Esa escalera tan fina te deja encajar un modelo en la memoria exacta que tienes, peldaño a peldaño. Cuánto pesa cada peldaño, a qué velocidad escribe y cuánto se aparta del original lo medimos en nuestra guía de cuantizaciones GGUF: en Qwen2.5 1.5B, Q4_K_M tuvo la misma primera opción que el modelo sin cuantizar en el 89 % de los tokens.
Del lado de MLX, la organización mlx-community tiene Qwen3 8B en 3, 4, 6 y 8 bits y en bf16, más un par de versiones especiales de 4 bits: AWQ y DWQ. DWQ es el truco propio de mlx-lm: a un modelo ya comprimido se le entrena para que imite al original, de modo que mantiene el tamaño de 4 bits mientras intenta recuperar parte de lo que se llevó la compresión. Cuánto recupera no lo hemos medido.
Convertir un modelo tú mismo es más fácil en MLX. 1 orden baja los pesos originales y los comprime:
mlx_lm.convert --model Qwen/Qwen3-8B -q
-q a secas significa 4 bits en grupos de 64, en modo affine; --q-bits cambia los bits, --q-mode admite mxfp4, nvfp4 y mxfp8, y --quant-predicate acepta 4 recetas mixtas, de mixed_2_6 a mixed_4_6. Para GGUF, pasas el script convert_hf_to_gguf.py del repositorio de llama.cpp y después su cuantizador. En los dos casos bajas primero los pesos originales: unos 15 GiB para un modelo de 8B en BF16.
Si prefieres verlo antes, la sesión de Apple sobre modelos de lenguaje con MLX enseña a mlx-lm generando texto y, en su capítulo de cuantización, este mismo mlx_lm.convert. Se grabó con un mlx-lm anterior: donde sus opciones y esta página no coincidan, esta página sigue la 0.32.2.
Se abre en YouTube (sin cookies) solo si pulsas. Más vídeos en su ficha →
Velocidad: por qué en esta página no hay ganador
Nos encantaría darte aquí un número, y no nos lo vamos a inventar. No hemos medido MLX contra llama.cpp en un Mac nuestro, y una cifra de velocidad solo significa algo con la máquina, el modelo, la compresión, el contexto y las 2 versiones escritas al lado. Los dos trabajan en el mismo chip gráfico y con la misma memoria, y MLX es el framework que hace Apple para sus propios chips; eso es un motivo para probarlo, no una medida.
La buena noticia es que lo resuelves en tu propio Mac con 2 ejecuciones. mlx_lm.generate imprime los tokens por segundo al leer la pregunta y al escribir la respuesta en cada ejecución; dale a llama.cpp el mismo modelo en GGUF y la misma pregunta, y créete a tu máquina antes que a cualquier gráfica, incluida la nuestra.

Si quieres ver motores lado a lado antes de probar, esta prueba hace pasar 5 modelos por 3 motores de inferencia en un Mac mini M6. Sus cifras salen de su máquina y sus versiones, que no son las de esta página.
Se abre en YouTube (sin cookies) solo si pulsas. Más vídeos en su ficha →
Portabilidad, puertas abiertas y lo que manda cada uno
Un fichero GGUF va a cualquier parte: el mismo fichero funciona en llama.cpp en Windows, en Linux, en un Mac Intel o en un móvil Android, y también en LM Studio y en Ollama. Una carpeta MLX está hecha para Apple Silicon. El framework mlx tiene además versiones para Linux con CUDA o solo con el procesador, y mlx-lm ofrece allí los extras cuda12, cuda13 y cpu, pero en Windows pip install mlx-lm instala las herramientas sin el motor. Si tus modelos viven en un disco que compartes con un PC, GGUF es el que funciona en los dos.
El formato en sí no escucha a nadie ni manda nada: lo hace el programa. Cada uno abre una puerta distinta en tu equipo, y de fábrica todas solo dentro del propio equipo:
- mlx-lm:
mlx_lm.serveren127.0.0.1:8080, sin clave y con CORS abierto a cualquier página web. Por su cuenta no hace ninguna llamada; la librería de Hugging Face con la que descarga le pregunta a huggingface.co si un modelo ha cambiado cada vez que lo cargas por su nombre, hasta que ponesHF_HUB_OFFLINE=1. - llama.cpp:
127.0.0.1:9931desde la v0.7.0, sin clave salvo que añadas--api-key, con CORS abierto a cualquier página web, y no manda nada por su cuenta. - LM Studio: su servidor en
127.0.0.1:1234, con el CORS desactivado por defecto. Según su fabricante, la aplicación comprueba si hay actualizaciones y sus motores se actualizan solos; su código es cerrado, así que eso es todo lo que se puede decir desde fuera. - Ollama:
127.0.0.1:11434, con CORS abierto solo a páginas de localhost, 127.0.0.1 y 0.0.0.0. Con soloollama serve, 2 tipos de llamada a ollama.com, queOLLAMA_NO_CLOUD=1apaga; con la aplicación de escritorio, 4.

Cada destino, con su fuente y su fecha, está en nuestras páginas de MLX, llama.cpp, LM Studio y Ollama.
Qué bajaríamos nosotros, según tu caso
- Un Mac con Apple Silicon y una ventana para chatear: LM Studio, con versiones MLX donde las haya. Normalmente te llevas el fichero más pequeño, y el GGUF está a 1 clic cuando un modelo no tiene versión MLX.
- Un Mac y la terminal: mlx-lm con las versiones de 4 bits de mlx-community; nuestra guía para instalar MLX te lleva de la instalación al servidor.
- Un Mac con Ollama: deja que elija, pero cuenta la descarga: en 4 de las 6 etiquetas que medimos, su versión MLX es la más grande.
- Los mismos modelos en un Mac y en un PC, o un Mac Intel: GGUF, con llama.cpp, LM Studio u Ollama.
- Poca memoria y necesitas que el modelo quepa hasta el último giga: GGUF, por su escalera de 25 ficheros.
- Tus propias compresiones o ajuste fino en el Mac: MLX, con
mlx_lm.converty su DWQ.
Si algo falla por el camino, tenemos guías para cuando MLX no funciona y cuando llama.cpp no funciona. ¿Dudas entre programas más que entre ficheros? Nuestras comparativas LM Studio vs Ollama y llama.cpp vs Ollama los ponen frente a frente, y el buscador de modelos te dice qué modelos caben en tu Mac. Si la elección es entre mlx-lm y llama.cpp, nuestra comparativa MLX vs llama.cpp cuenta cuáles de nuestros 27 modelos conoce cada motor.