llama.cpp: ¿qué es y hay que abandonar Ollama? ?

llama.cpp (también escrito llamacpp o llama cpp) es el motor en C y C++ que ejecuta modelos GGUF en CPU y GPU; Ollama, LM Studio y KoboldCpp se basan en él. La versión 1.0.0, publicada el 13 de noviembre de 2026, estabiliza sobre todo la API para desarrolladores. Quedarse en Ollama sigue siendo razonable; llama.cpp tiene sentido si quieres ajustar tú mismo la memoria, el contexto y la caché KV.
llama.cpp (también escrito llamacpp o llama cpp) es el motor en C y C++ que ejecuta modelos GGUF en CPU y GPU; Ollama, LM Studio y KoboldCpp se basan en él. La versión 1.0.0, publicada el 13 de noviembre de 2026, estabiliza sobre todo la API para desarrolladores. Quedarse en Ollama sigue siendo razonable; llama.cpp tiene sentido si quieres ajustar tú mismo la memoria, el contexto y la caché KV.
#llama.cpp en pocas palabras
El proyecto lo lanzó Georgi Gerganov en marzo de 2023 con un objetivo sencillo: ejecutar el modelo LLaMA de Meta en un MacBook, sin Python ni dependencias pesadas. Se publica bajo licencia MIT. El repositorio, que pasó a la organización ggml-org, publicó su versión 1.0.0 el 13 de noviembre de 2026. El anuncio oficial habla de más de 150 variantes de arquitectura compatibles, y el formato de archivo definido en agosto de 2023, GGUF, se ha convertido en el estándar de facto para distribuir un modelo cuantizado.
Dos decisiones técnicas explican este éxito. La primera es la cuantización: llama.cpp puede ejecutar pesos comprimidos de 2 a 8 bits, lo que permite que un modelo de 8 mil millones de parámetros quepa en 5 GB en lugar de 16. La segunda es el reparto entre procesador y tarjeta gráfica: cuando un modelo no cabe completamente en la VRAM, parte de las capas permanece en la RAM y el resto se carga en la GPU. Es más lento que cargar todo el modelo en la GPU, pero funciona, y pocos motores lo ofrecen.
Lo verás escrito llama.cpp, llama cpp, llamacpp o incluso «lama.cpp»: es el mismo proyecto. Si buscabas «ollama cpp» o «llm.cpp», se trata de llama.cpp; Ollama es otro software, que se basa en él, entre otros.
#llama.cpp 1.0.0: lo que cambia para ti
Aprovecha nuestra experiencia y un recorrido guiado para crear tu asistente local y usar tu IA en el día a día.
- Espacio en línea de por vida
- PDF + archivos
- Reembolsado 30 d
El 13 de noviembre de 2026, el proyecto publicó la versión 1.0.0 de llama.cpp y de la biblioteca ggml. El objetivo declarado es ofrecer a los desarrolladores una API estable: a partir de ahora, las rupturas de compatibilidad de la API de C se anunciarán con un cambio de versión mayor, según el versionado semántico. Para un usuario que simplemente ejecuta llama-server, el cambio visible no es tanto una interfaz nueva como un marco más claro.
- Un instalador oficial
- El README ofrece un script de una sola línea (macOS, Linux, Windows) que instala el comando llama, con llama cli para chatear en la terminal y llama serve para iniciar el servidor compatible con OpenAI. El propio script elige la variante Metal, CUDA, ROCm, Vulkan o CPU. Homebrew, winget, conda-forge, MacPorts y Nix siguen disponibles.
- Caché KV en FP8
- Las opciones -ctk y -ctv ahora aceptan f8_e4m3, además de f16, bf16, q8_0 y los formatos de 4 y 5 bits. La ventaja: reducir la memoria de la caché en contextos largos.
- Caché de expertos para los MoE
- Se añade una caché de expertos en la memoria del host para los modelos de expertos (MoE), con parte del cálculo delegada a la CPU cuando el experto solicitado no está en caché.
- Servidor reforzado
- Las herramientas sin autenticación y las direcciones privadas para los medios pasan a ser opciones que hay que activar explícitamente (--allow-unauthenticated-tools, --media-allow-private-urls). También se han endurecido el acceso CORS, la protección contra el DNS rebinding y el token de Hugging Face.
- Voz y audio
- El servidor añade un endpoint /v1/audio/speech compatible con OpenAI para los modelos capaces de hablar, así como compatibilidad con la entrada de audio en streaming de Gemma 4.
- Interfaz web rediseñada
- Barra lateral reorganizada, chats agrupados, editor de entrada con vista previa de Markdown, diseño adaptado a teléfonos.
- Lo que se ha eliminado
- La API pública obsoleta, incluida la opción --defrag-thold. Si alguno de tus scripts todavía la usa, elimínala.
- llama-server: montar una API de OpenAI local
- Ollama frente a llama.cpp: la comparativa completa
- Notas de versión oficiales de llama.cpp 1.0.0
- Anuncio de llama.cpp 1.0 en Hugging Face
#Qué hay en la caja
- llama
- El comando único instalado por el script oficial: llama cli para el chat en la terminal, llama serve para el servidor compatible con OpenAI. Los binarios llama-cli y llama-server siguen existiendo cuando compilas o descargas los archivos comprimidos.
- llama-cli
- El chat en la línea de comandos. Útil para probar un modelo o un ajuste en unos segundos.
- llama-server
- Un servidor HTTP con una API compatible con OpenAI y una interfaz web integrada, en 127.0.0.1 y el puerto 9931 por defecto según la documentación actual. Es la pieza que la mayoría de los usuarios avanzados mantiene en ejecución de forma permanente.
- llama-bench
- La herramienta de medición. Da por separado la velocidad de lectura del prompt y la velocidad de generación, lo que permite comparar dos ajustes sin autoengañarse.
- llama-quantize
- Convierte un GGUF de precisión completa a una cuantización más ligera (Q4_K_M, Q5_K_M, Q8_0).
- llama-server: crear paso a paso una API local de OpenAI
- GGUF y safetensors: entender los formatos de los modelos
- Documentación oficial del formato GGUF — Hugging Face
#Lo que añaden y ocultan las capas adicionales
Ollama, LM Studio y KoboldCpp aportan lo que llama.cpp no hace: un catálogo de modelos, la descarga con un solo comando, una interfaz y la carga y descarga automáticas. A cambio, fijan valores predeterminados. La tabla siguiente no compara el rendimiento, sino que indica quién decide qué.
| Ajuste | llama.cpp sin capas adicionales | Ollama | LM Studio | KoboldCpp |
|---|---|---|---|---|
| Tamaño del contexto | Opción -c, libre | Valor predeterminado prudente, modificable mediante una variable o un Modelfile | Control deslizante por modelo | Opción al iniciar |
| Elección de la cuantización | Cualquier archivo GGUF | Etiqueta del catálogo, Q4 por defecto | Lista disponible para descargar | Cualquier archivo GGUF |
| Capas enviadas a la GPU | Opción -ngl: un número, auto (predeterminado) o all | Automático | Control deslizante | Opción al iniciar |
| Cuantización de la caché KV | Opciones -ctk y -ctv (f16 por defecto) | Variable de entorno global | Configuración avanzada | Opción al iniciar |
| API | llama-server, compatible con OpenAI (puerto 9931 por defecto) | API limpia + compatibilidad con OpenAI | Servidor compatible con OpenAI | API limpia + compatibilidad con OpenAI |
| Actualizaciones del motor | El mismo día, en cada commit | Con retraso | Con retraso | Con retraso |
La última línea importa más de lo que parece. Cuando aparece una nueva arquitectura de modelo, primero se incorpora su soporte en llama.cpp y después, unos días o semanas más tarde, en las herramientas construidas sobre él. Si quieres probar un modelo la semana de su publicación, a menudo es la única vía.
#Los cuatro ajustes que lo cambian todo
- -ngl (n-gpu-layers)
- El número de capas del modelo que se colocan en la VRAM: un número, auto o all. El valor predeterminado es auto. Si fuerzas un valor y el modelo supera tu VRAM, redúcelo hasta que la carga funcione: cada capa que se queda en la CPU ralentiza la generación, pero un modelo que funciona lento es mejor que uno que no arranca.
- -c (ctx-size)
- La ventana de contexto asignada. Por defecto, el valor se lee del modelo (0), y --fit puede reducirlo para que quepa en memoria. La caché KV crece con ella: asigna lo que necesites, no el máximo anunciado por el modelo.
- -fa (flash-attn)
- Flash Attention reduce la memoria y acelera la lectura de prompts largos. Los valores son on, off o auto; auto es el valor predeterminado, así que por lo general no hay que añadir nada.
- --n-cpu-moe
- En los modelos MoE, mantiene los expertos de las N primeras capas en la RAM y deja el resto en la GPU (-cmoe mantiene todos los expertos en la CPU). Es lo que permite que quepa un MoE más grande que la VRAM.
- Flash Attention: activarlo en llama.cpp, Ollama y vLLM
- Cuantizar la caché KV para ahorrar VRAM
- Distribuir un modelo entre varias GPU con tensor-split
- Documentación oficial de llama-server (lista completa de opciones)
#Lo que ha cambiado: --fit ajusta -ngl por ti
Durante mucho tiempo, ajustar -ngl a mano fue el primer reflejo de cualquier guía de llama.cpp: poner 99 para enviarlo todo a la GPU y luego ir bajando a base de prueba y error si la carga fallaba. Ya no es un paso obligado. La opción --fit, activada por defecto, ajusta automáticamente los parámetros no especificados (entre ellos -ngl y el tamaño del contexto) para que el modelo quepa en la memoria disponible. Mantiene un margen de 1 024 MB por dispositivo (-fitt) y no baja de 4 096 tokens de contexto (-fitc), valores que se pueden modificar. En una tarjeta modesta, esto evita el habitual ir y venir entre un lanzamiento que falla y un -ngl reducido a mano.
#¿Qué backend para tu tarjeta?
llama.cpp se compila, o se descarga, para un backend de cómputo determinado. La elección correcta depende únicamente de tu hardware. La tabla recoge las familias de nuestra base de 90 configuraciones. Con el script de instalación oficial, esta elección se hace por ti; los binarios y las opciones de compilación solo sirven si quieres forzar un backend.
| Tu hardware | Backend recomendado | Nota |
|---|---|---|
| NVIDIA GTX 10 a RTX 50, de sobremesa y para portátiles | CUDA | El backend que conviene elegir en una tarjeta NVIDIA. |
| AMD Radeon RX 7000 y RX 9000 | ROCm (HIP) o Vulkan | ROCm es más rápido cuando funciona. Vulkan se instala sin complicaciones, incluso en Windows. |
| AMD Radeon RX 6000 y anteriores | Vulkan | Compatibilidad con ROCm parcial o inexistente según la tarjeta. |
| Apple M1 a M5 | Metal | Activado por defecto en los binarios de macOS. Se puede utilizar toda la memoria unificada. |
| GPU integrada Intel o AMD, Intel Arc | Vulkan o SYCL | Mejora real frente al uso exclusivo de la CPU en modelos pequeños. |
| Ninguna GPU | CPU (AVX2, AVX-512, NEON) | Funciona en cualquier equipo. Busca modelos de hasta 8 mil millones de parámetros. |
- Compilar llama.cpp con CUDA
- Compilar llama.cpp con Metal en Mac
- llama.cpp con Vulkan, el backend universal
#Nuestras mediciones con llama.cpp
llama.cpp es el motor de referencia de nuestro banco de pruebas, precisamente porque funciona de forma idéntica en todas las plataformas. Estas son las velocidades de generación registradas con Llama 3.1 8B en Q4, con un contexto de 2 048 tokens, una sola solicitud y Flash Attention activada.
| Máquina | Memoria | Llama 3.1 8B Q4 |
|---|---|---|
| RTX 5090 | 32 GB | 172 tok/s |
| RTX 4090 | 24 GB | 128 tok/s |
| RTX 4070 | 12 GB | 76 tok/s |
| Mac M3 Max | 64 GB unificados | 64 tok/s |
| RTX 3060 | 12 GB | 44 tok/s |
| Ryzen 7 7700, solo CPU | RAM del sistema | 7,8 tok/s |
Dos lecturas. Primero, la diferencia entre una RTX 3060 y un procesador solo es de un factor de cinco a seis: incluso una tarjeta de gama de entrada cambia la experiencia. Segundo, estas cifras serían prácticamente las mismas en Ollama o LM Studio en las mismas máquinas, ya que el motor de cálculo es el mismo. Estas mediciones son de abril de 2026, anteriores a la versión 1.0.0: tómalas como un orden de magnitud, no como una promesa para la última versión.
#Quedarse con Ollama o pasar a llama.cpp
¿Hay que dejar Ollama por llama.cpp 1.0? No. La 1.0.0 es un hito de estabilidad de la API, no una ruptura: Ollama sigue apoyándose, entre otros, en llama.cpp (sus notas de versión mencionan su actualización) y ofrece lo que llama.cpp no tiene, como el catálogo, la aplicación de escritorio o los modelos en la nube. Pásate a llama.cpp si uno de los casos de la columna derecha es el tuyo; si no, ambos conviven sin conflicto de puertos por defecto (11434 para Ollama, 9931 para llama-server).
| Quédate con Ollama o LM Studio si… | Pásate a llama.cpp si… |
|---|---|
| Quieres hablar con un modelo sin leer documentación. | Tu modelo supera la capacidad de la VRAM y quieres ajustar con precisión la distribución entre GPU y CPU. |
| Cambias de modelo a menudo y valoras el catálogo integrado. | Quieres probar una arquitectura publicada esta semana. |
| Tus herramientas (Open WebUI, extensiones del editor) esperan la API de Ollama. | Estás montando un servidor para usarlo a largo plazo y quieres controlar cada opción, desde el contexto hasta la caché KV. |
| Usas la aplicación de Ollama, sus modelos en la nube o sus integraciones. | Quieres una versión concreta del motor o las últimas correcciones publicadas en compilación nocturna. |
#Empezar en diez minutos
No hace falta compilar para probarlo. El README oficial ofrece un script de instalación de una línea, y se publican binarios precompilados para Windows, macOS y Linux. Los gestores de paquetes también sirven. Los siguientes comandos instalan llama.cpp, descargan un modelo pequeño desde Hugging Face e inician el servidor, cuya interfaz web se abre en http://localhost:9931.
Para un modelo más capaz, el mismo mecanismo funciona con llama-server y el repositorio GGUF que elijas. Sin la opción -ngl, --fit coloca las capas por ti; añade -c para fijar el contexto.
Si ya has descargado un archivo GGUF, apunta a él con la opción -m. Compilar desde el código fuente solo resulta útil para activar un backend concreto o seguir el desarrollo día a día.
#Los errores de carga más comunes
La mayoría de los problemas con llama.cpp se reducen a tres causas: superar la memoria disponible, un archivo GGUF incompatible con la compilación instalada o una opción mal escrita. El mensaje de error mostrado en la línea de comandos indica casi siempre cuál de las tres es la causa, siempre que lo leas hasta el final en lugar de cerrar la ventana y volver a ejecutar el programa.
| Mensaje o síntoma | Causa probable | Para probar |
|---|---|---|
| cudaMalloc failed: out of memory | El modelo, con el contexto solicitado, supera la VRAM disponible | Reducir -c, dejar que --fit ajuste -ngl o elegir una cuantización más ligera |
| unknown model architecture | El archivo GGUF utiliza una arquitectura más reciente que el binario instalado | Actualizar a la última versión publicada; las nuevas arquitecturas llegan primero a llama.cpp |
| Generación muy lenta a pesar de tener una GPU reciente | No todas las capas se han transferido a la GPU, a menudo por falta de VRAM libre | Comprobar la salida de carga (línea «offloaded»), cerrar las demás aplicaciones que ocupan la tarjeta |
| error: invalid argument | Una opción renombrada o mal escrita en el comando | Comparar con llama-server --help, que enumera los alias cortos y largos actualizados |
| Un script falla con --defrag-thold | La opción se eliminó con la versión 1.0.0 | Quitar la opción del comando |
| Conexión rechazada en el puerto 8080 | El puerto predeterminado documentado ahora es el 9931 | Usa http://localhost:9931 o fija --port 8080 |
Vale la pena leer entera, al menos una vez, la línea de carga que aparece al iniciar el servidor: indica el número de capas que realmente se envían a la GPU, el tamaño de contexto efectivo y el tipo de caché KV utilizado. Suele ser más rápido que añadir opciones al azar hasta que funcione. Vigila también la versión instalada: llama.cpp publica compilaciones nocturnas (numeradas bNNNN) con mucha frecuencia, además de las versiones v1.x, y a veces ya ha salido una corrección para tu tarjeta o tu modelo que todavía no ha llegado al paquete de Homebrew o winget que instalaste la semana anterior.
#FAQ
¿Es llama.cpp más rápido que Ollama?+
¿Hay que saber compilar para utilizar llama.cpp?+
¿Se puede usar llama.cpp sin tarjeta gráfica?+
¿Qué diferencia hay entre llama.cpp y vLLM?+
¿Y en Mac, llama.cpp o MLX?+
llamacpp, llama cpp, llama.cpp: ¿son lo mismo?+
¿Qué aporta llama.cpp 1.0?+
¿Hay que dejar Ollama por llama.cpp?+
#Fuentes y verificación del 16 de noviembre de 2026
Los comandos, los valores predeterminados y las novedades de la versión 1.0.0 se revisaron el 16 de noviembre de 2026 en las notas de la versión oficiales, el README del repositorio, la documentación de llama-server y el anuncio publicado por el equipo del proyecto.
- Notas de la versión llama.cpp v1.0.0 (13 de noviembre de 2026)
- Anuncio de llama.cpp 1.0 — Hugging Face
- README oficial del repositorio de llama.cpp
- Documentación de llama-server (opciones y API)
- Instalar una versión precompilada de llama.cpp
- Compilar llama.cpp: guía oficial
- Documentación oficial del formato GGUF — Hugging Face
¿Un comentario, un error, una precisión? Avísanos, eso mejora la guía para todos.