llama.cpp 1.0: qué cambia y cómo instalarlo paso a paso en Windows, Mac y Linux

llama.cpp, el programa de código abierto que permite ejecutar modelos de IA en tu propio ordenador sin depender de la nube, ha publicado el 13 de noviembre de 2026 su versión 1.0, la primera estable después de unos tres años y medio de desarrollo. Para quien solo usa la IA local, la noticia es que el motor sobre el que se apoyan muchas aplicaciones conocidas se compromete a no romper nada sin avisar. Para quien quiere ir un paso más allá de Ollama, es el mejor momento para probarlo: trae caché FP8 para ahorrar memoria, una interfaz web renovada y un servidor más seguro. En este tutorial te explicamos qué cambia, en qué se diferencia de Ollama y LM Studio, y cómo instalarlo y usarlo paso a paso en Windows, Mac y Linux.

¿Qué es llama.cpp?

llama.cpp es un programa escrito en C y C++ para ejecutar modelos de lenguaje en tu propio equipo, de forma local y sin conexión. Nació en marzo de 2023, cuando Georgi Gerganov lo publicó para ejecutar los primeros modelos LLaMA de Meta en un portátil, y desde entonces se ha convertido en una de las piezas más importantes de la IA de código abierto. Hoy lo mantiene el grupo ggml-org, integrado en Hugging Face.

Tiene dos partes. ggml es la biblioteca de cálculo que hace las operaciones matemáticas en la tarjeta gráfica o el procesador. llama.cpp es el programa que carga los modelos, gestiona la conversación y ofrece la línea de comandos y el servidor. También ha popularizado GGUF, el formato de archivo en el que se distribuyen la mayoría de modelos para uso local.

Su gran virtud es que funciona en casi cualquier cosa: tarjetas gráficas de NVIDIA, AMD e Intel, los chips de Apple, procesadores Arm y x86, e incluso móviles. Los propios desarrolladores agradecen en el anuncio el apoyo de NVIDIA, AMD, Qualcomm, Arm, IBM e Intel. Si alguna vez has usado una aplicación de IA local, es muy probable que llama.cpp o ggml estuvieran trabajando por debajo.

Qué cambia con la versión 1.0

La versión 1.0 es, ante todo, una promesa. Los desarrolladores explican en el blog de Hugging Face que, a partir de ahora, llama.cpp y ggml usarán versionado semántico:

• Versión mayor (2.0, 3.0…): cuando un cambio rompa la interfaz pública en C.
• Versión menor (1.1, 1.2…): funciones nuevas, mejoras en los motores de cálculo y soporte de modelos nuevos.
• Parche (1.0.1, 1.0.2…): correcciones de errores sin cambios en la interfaz.

Hasta ahora, llama.cpp publicaba compilaciones casi a diario y cualquier cambio podía romper los programas que dependían de él. Para los desarrolladores de aplicaciones es un cambio enorme: ya pueden saber, mirando el número de versión, si una actualización les va a dar problemas.

Además de la promesa, la versión trae novedades concretas, según las notas de la versión en GitHub:

• Caché KV en FP8: una forma nueva de guardar la «memoria» de la conversación que ocupa la mitad que la habitual. Lo vemos más abajo.
• Caché de expertos MoE en la memoria del sistema: permite tener parte de un modelo de mezcla de expertos en la RAM del ordenador, con una proporción configurable, para ejecutar modelos mayores que la memoria de tu gráfica.
• Carga de fragmentos PLE externos: algunos modelos recientes pueden repartir parte de sus datos en archivos GGUF separados.
• Servidor más seguro: correcciones frente a falsificación de peticiones en el servidor (SSRF), configuraciones de CORS y ataques de DNS rebinding. Además, el token de Hugging Face solo se envía a los dominios de Hugging Face.
• Nuevo endpoint de voz: /v1/audio/speech, compatible con la API de OpenAI, para convertir texto en voz con modelos compatibles.
• Interfaz web rediseñada: con grupos de conversaciones y un editor de markdown.
• Modelos nuevos: entre otros, Kimi-K3.1-Pro, Ripple-65B-Preview y el modelo de voz drama-3, además de visión para Kimi-K3.1.

También hay limpieza: desaparecen 35 funciones obsoletas, la opción --defrag-thold y el archivo clip.h, cuyas funciones pasan a la biblioteca multimodal mtmd. Si solo usas los programas, no te afecta; si programas contra la biblioteca, revisa las notas de la versión antes de actualizar.

¿Te afecta si usas Ollama o LM Studio?

De momento, poco. La versión 1.0 no cambia por sí sola ninguna aplicación de tu ordenador: es una promesa de los desarrolladores de llama.cpp hacia quienes construyen programas encima. Las aplicaciones que se apoyan en llama.cpp o en ggml irán incorporando las novedades, como la caché FP8, a su propio ritmo, y lo normal es que la estabilidad de la API haga esas actualizaciones más rápidas y con menos errores.

Si ya usas Ollama y estás contento, no tienes por qué cambiar. Nuestro tutorial para instalar Ollama en Windows 11 sigue siendo el camino más sencillo para empezar. Pero si quieres controlar cada parámetro, probar un modelo el mismo día que sale o exprimir al máximo la memoria de tu gráfica, llama.cpp te da acceso directo al motor.

llama.cpp, Ollama o LM Studio

Las tres opciones ejecutan modelos en local, pero están pensadas para perfiles distintos:

Nuestra recomendación: si nunca has usado IA local, empieza por Ollama o LM Studio. Si ya los has usado y te has topado con sus límites (un modelo que no está en el catálogo, un parámetro que no puedes cambiar, un rendimiento que no te convence), pasa a llama.cpp. En nuestra guía completa de Ollama tienes la otra cara de la comparación.

Qué necesitas

llama.cpp funciona en casi cualquier ordenador, pero lo que determina qué modelos puedes usar es la memoria: la de la tarjeta gráfica (VRAM) o, en un Mac, la memoria unificada. Esta es la guía rápida:

Lo explicamos con detalle, modelo a modelo, en nuestra guía de qué modelos de IA local usar según tu VRAM. Además, necesitarás espacio en disco: cada modelo ocupa entre 2 y 40 GB, y es fácil acumular varios.

Paso 1: instalarlo

La forma más cómoda es usar el gestor de paquetes de tu sistema. Los desarrolladores mantienen paquetes para Winget, Homebrew, conda-forge, MacPorts, Debian y Docker, además de las compilaciones que publican en GitHub.

En Windows

1. Abre la Terminal de Windows o PowerShell.
2. Escribe winget install llama.cpp y pulsa Intro.
3. Cierra la terminal y vuelve a abrirla para que reconozca los programas nuevos.
4. Comprueba que funciona con llama-cli --version.

Si prefieres descargarlo a mano, en la página de versiones del repositorio ggml-org/llama.cpp de GitHub hay archivos comprimidos para Windows con distintos motores: CUDA para gráficas NVIDIA, Vulkan para AMD e Intel, y solo procesador. Elige el que corresponda a tu gráfica, descomprímelo en una carpeta y ejecuta los programas desde ahí.

En Mac

1. Si no tienes Homebrew, instálalo desde su web oficial.
2. Abre la Terminal y escribe brew install llama.cpp.
3. Comprueba la versión con llama-cli --version.

En los Mac con chip de Apple, llama.cpp usa automáticamente la gráfica integrada a través de Metal. No tienes que configurar nada.

En Linux

Puedes usar Homebrew igual que en Mac (brew install llama.cpp), los paquetes de Debian o la imagen de Docker. Si tienes una gráfica NVIDIA y quieres el máximo rendimiento, la opción más fiable sigue siendo compilarlo tú con CUDA siguiendo las instrucciones del repositorio, porque así queda optimizado para tu tarjeta.

Paso 2: descargar un modelo y chatear

llama.cpp puede descargar modelos directamente de Hugging Face con la opción -hf. Para una primera prueba rápida, usa un modelo pequeño que funciona en cualquier equipo:

llama-cli -hf ggml-org/gemma-3-1b-it-GGUF

La primera vez descargará el modelo, que se guarda en una carpeta de caché para no bajarlo de nuevo. Cuando termine, verás un indicador para escribir. Pregúntale lo que quieras y pulsa Intro. Para salir, pulsa Ctrl + C.

Para usar otro modelo, sustituye el nombre por el del repositorio de Hugging Face que quieras, con el formato usuario/modelo-GGUF. Si el repositorio tiene varias versiones cuantizadas, puedes elegir una añadiendo dos puntos y su nombre, por ejemplo :Q4_K_M. Más abajo te explicamos cuál elegir.

Estas son las opciones más útiles al arrancar un modelo:

• -ngl 99: carga todas las capas del modelo en la tarjeta gráfica. Si el modelo no cabe entero, baja el número para dejar parte en la RAM.
• -c 16384: fija el tamaño del contexto, es decir, cuánto texto «recuerda» la conversación. Más contexto ocupa más memoria.
• -t 8: número de hilos del procesador, útil si trabajas sin gráfica.

Paso 3: el servidor con interfaz web

Si prefieres chatear en el navegador, llama.cpp incluye un servidor con interfaz web, renovada en la versión 1.0:

llama-server -hf ggml-org/gemma-3-1b-it-GGUF --port 8080

Cuando aparezca el mensaje de que el servidor está escuchando, abre el navegador y entra en http://localhost:8080. Verás una interfaz de chat sencilla, parecida a la de los asistentes en la nube, con historial de conversaciones, grupos para organizarlas y un editor de markdown. Todo se ejecuta en tu ordenador: nada de lo que escribas sale de él.

El servidor admite las mismas opciones que llama-cli (-ngl, -c, etc.), así que puedes ajustar el uso de memoria igual.

Paso 4: usarlo como API

El mismo servidor expone una API compatible con la de OpenAI. Eso significa que cualquier programa, extensión o script preparado para ChatGPT puede usar tu modelo local cambiando solo la dirección. Una prueba desde la terminal:

curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"messages": [{"role": "user", "content": "Explícame qué es un GGUF en una frase"}]}'

En herramientas como editores de código con IA o clientes de chat, busca la opción de «proveedor compatible con OpenAI» o «URL base personalizada» y escribe http://localhost:8080/v1. Si el programa pide una clave, puedes poner cualquier texto, salvo que hayas configurado una en el servidor (lo vemos en el apartado de seguridad).

La novedad de la versión 1.0 es el endpoint /v1/audio/speech, que convierte texto en voz con modelos compatibles, siguiendo el mismo formato que la API de voz de OpenAI.

Elegir la cuantización

Los modelos se publican en varias versiones «cuantizadas», que reducen la precisión de los números para que ocupen menos. El nombre lo indica: Q4 usa unos 4 bits por parámetro, Q8 unos 8 y F16 16, la precisión original. Las letras K_M o K_S indican variantes del método de cuantización.

La regla práctica:

• Q4_K_M: el mejor equilibrio para casi todo el mundo. Pierde muy poca calidad y ocupa menos de un tercio que el original.
• Q5_K_M o Q6_K: si te sobra memoria y quieres un poco más de calidad.
• Q8_0: prácticamente igual que el original. Solo compensa con mucha memoria disponible.
• Q3 o menos: solo para meter a la fuerza un modelo grande en poca memoria. La calidad se resiente.

Si dudas entre un modelo grande muy cuantizado o uno más pequeño con mejor cuantización, normalmente gana el grande a Q4 frente al pequeño a Q8.

Ahorrar memoria con la caché FP8

Además del propio modelo, llama.cpp guarda en memoria una «caché KV» con la información de todo el texto de la conversación. Con contextos largos, esa caché puede ocupar tanto como el modelo. Hasta ahora se podía comprimir en formatos como Q8_0; la versión 1.0 añade FP8 (el formato f8_e4m3), un tipo de número de 8 bits que reduce la caché a la mitad respecto a F16.

Se activa con las opciones -ctk y -ctv, que eligen el tipo para las claves y los valores de la caché:

llama-server -hf usuario/modelo-GGUF:Q4_K_M -c 32768 -ctk f8_e4m3 -ctv f8_e4m3

En un modelo de 8.000 millones de parámetros como Llama 3.1 8B, con 32.000 tokens de contexto, la caché pasa de unos 4,3 GB en F16 a unos 2,1 GB en FP8, según nuestro cálculo con la arquitectura del modelo. En una gráfica de 12 o 16 GB, esos 2 GB son la diferencia entre poder usar un contexto largo o no. La calidad apenas cambia en la mayoría de usos, pero si notas respuestas raras en conversaciones muy largas, vuelve a F16.

Modelos MoE más grandes que tu VRAM

Muchos modelos recientes usan la arquitectura de «mezcla de expertos» (MoE): tienen muchos parámetros en total, pero en cada paso solo activan una parte. Por ejemplo, el modelo Edge0-145B, presentado el 12 de noviembre, tiene 145.000 millones de parámetros, pero activa unos 10.000 millones en cada paso, según la empresa que lo ha creado.

La nueva caché de expertos de llama.cpp 1.0 aprovecha justo eso: mantiene en la memoria del sistema los expertos que no caben en la gráfica, con una proporción configurable, y trae a la tarjeta los que necesita. El resultado es que un ordenador con una gráfica modesta y mucha RAM puede ejecutar modelos que antes eran impensables. Edge0 asegura que su modelo se queda en 29 GB de pico en un portátil con 48 GB de memoria, aunque son cifras de la propia empresa y todavía no hay pruebas independientes.

Si te interesan estos modelos, en nuestro análisis de Kimi K3.1 Pro, uno de los que estrena soporte en esta versión, explicamos qué ofrece frente a los modelos cerrados.

Seguridad del servidor

La versión 1.0 corrige varios fallos de seguridad del servidor, pero lo más importante depende de ti. Por defecto, llama-server solo escucha en tu propio ordenador (127.0.0.1), y así debe seguir salvo que sepas lo que haces.

• Para usarlo desde otros equipos de casa, añade --host 0.0.0.0, pero solo en una red de confianza.
• Pon una clave con --api-key seguida de una contraseña larga. Los programas tendrán que enviarla para usar el servidor.
• No lo abras a internet redirigiendo puertos en el router. Si necesitas acceder desde fuera, usa una VPN.
• Actualiza. Las correcciones de SSRF, CORS y DNS rebinding de la 1.0 protegen justamente frente a webs maliciosas que intentan hablar con tu servidor local desde el navegador.

Problemas habituales

• Va muy lento: casi siempre es porque el modelo se está ejecutando en el procesador. Comprueba que tu versión es la de tu gráfica (CUDA, Vulkan o Metal) y añade -ngl 99.
• Error de memoria al cargar: el modelo o el contexto no caben. Usa una cuantización menor, reduce -c, activa la caché FP8 o baja -ngl para dejar capas en la RAM.
• No reconoce el comando en Windows: cierra y abre la terminal tras instalar con Winget. Si sigue sin funcionar, reinicia la sesión.
• El modelo responde en bucle o mezcla idiomas: suele ser una plantilla de chat mal detectada. Prueba con la versión GGUF oficial del modelo o con otra cuantización.
• No arranca un modelo muy nuevo: espera a la siguiente versión menor. Con el nuevo versionado, el soporte de modelos llega en las 1.x.

Qué hardware conviene

Si vas a montar o mejorar un equipo para IA local, la prioridad es la memoria de la gráfica. Lo analizamos pieza a pieza en qué PC montar para IA local y, si prefieres Apple, en qué Mac comprar para IA local. Estas son nuestras opciones de referencia:

• Para empezar con buen margen: la ASUS Dual RTX 5060 Ti de 16 GB, la forma más asequible de tener 16 GB de VRAM con CUDA.
• Más velocidad con 16 GB: la MSI RTX 5070 Ti Shadow 3X de 16 GB.
• Alternativa AMD: la Sapphire Pulse RX 9070 XT de 16 GB, que funciona con el motor Vulkan de llama.cpp.
• Lo máximo en una sola gráfica: la ASUS TUF Gaming RTX 5090 de 32 GB.
• RAM para modelos MoE: un kit Corsair Vengeance DDR5 de 64 GB o, si quieres ir a por los modelos grandes con la nueva caché de expertos, el Corsair Vengeance DDR5 de 96 GB (2 × 48 GB).
• Espacio para los modelos: un SSD rápido como el WD_Black SN7100 de 2 TB hace que cargar modelos de 20 o 30 GB tarde segundos.

Comparamos más tarjetas en nuestra guía de las mejores gráficas para IA local.

Fuentes: blog de ggml-org en Hugging Face y notas de la versión v1.0.0 en GitHub (13 de noviembre de 2026), Unite.AI y Edge0. Los cálculos de memoria son nuestros, a partir de la arquitectura publicada de cada modelo.