Inicio›Guías›MLX vs GGUF en un Mac: 7 modelos medidos, qué elige Ollama y cuál bajar

Elegir · Guía

MLX vs GGUF en un Mac: 7 modelos medidos, qué elige Ollama y cuál bajar

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.

Medido y escrito por Local AI ScopePublicado el Cifras medidas por Local AI Scope

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)MLX (mlx-lm)Ficha del programa llama.cppllama.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.json y ficheros model*.safetensors; un *.gguf ni 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 StudioLM StudioFicha del programa OllamaOllamaFicha del programa
MLX ejecutando un modelo de lenguaje en el terminal de un Mac (sesión de la WWDC25)
mlx_lm.chat en la terminal de un Mac, en la sesión de Apple sobre MLX de la WWDC25: mlx-lm lee carpetas MLX y ningún GGUF Fotograma del vídeo oficial · Apple

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.

Chips M4, M4 Pro y M4 Max de Apple
Los M4, M4 Pro y M4 Max de Apple: el procesador y la gráfica comparten una sola memoria, así que los pesos de un modelo y su contexto salen del mismo saco que tus aplicaciones Imagen: Apple

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.

Logotipo de Ollama
Logo de Ollama. Su código es MIT, y por eso pudimos leer qué versión baja un Mac y cuál recibe cualquier otro equipo Logotipo: Ollama

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.

Mac mini con M6 conectado a una pantalla
Un Mac mini con M6: MLX y llama.cpp trabajan los dos en su chip gráfico, cada uno con su propio código para Metal Foto: Apple

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.server en 127.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 pones HF_HUB_OFFLINE=1.
  • llama.cpp: 127.0.0.1:9931 desde 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 solo ollama serve, 2 tipos de llamada a ollama.com, que OLLAMA_NO_CLOUD=1 apaga; con la aplicación de escritorio, 4.
Logotipo de llama.cpp
llama.cpp, el motor de código abierto que creó GGUF: el mismo fichero funciona en un Mac, en un PC con Windows o Linux, y en LM Studio y Ollama Logotipo: ggml-org / llama.cpp

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.convert y 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.