Intermedio 11 minllama.cpp

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

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

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.

Por Mohamed Meguedmi·Actualización 2026-11-19·Probado en macOS 14+

#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

El kit completo para crear tu propio asistente de IA.

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.
i
Lo que sigue siendo cierto
llama-server mantiene su API compatible con OpenAI, y las opciones -ngl, -c, -fa, -ctk, -ctv y --n-cpu-moe siguen figurando en la documentación. Solo se han eliminado la API C pública obsoleta y la opción --defrag-thold. Nada te obliga a migrar ese mismo día.

#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).

#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é.

Comparativa de control, no de velocidad · situación a 16/11/2026
Ajustellama.cpp sin capas adicionalesOllamaLM StudioKoboldCpp
Tamaño del contextoOpción -c, libreValor predeterminado prudente, modificable mediante una variable o un ModelfileControl deslizante por modeloOpción al iniciar
Elección de la cuantizaciónCualquier archivo GGUFEtiqueta del catálogo, Q4 por defectoLista disponible para descargarCualquier archivo GGUF
Capas enviadas a la GPUOpción -ngl: un número, auto (predeterminado) o allAutomáticoControl deslizanteOpción al iniciar
Cuantización de la caché KVOpciones -ctk y -ctv (f16 por defecto)Variable de entorno globalConfiguración avanzadaOpción al iniciar
APIllama-server, compatible con OpenAI (puerto 9931 por defecto)API limpia + compatibilidad con OpenAIServidor compatible con OpenAIAPI limpia + compatibilidad con OpenAI
Actualizaciones del motorEl mismo día, en cada commitCon retrasoCon retrasoCon 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.

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

→
-ngl 99 sigue siendo válido
Si prefieres forzar una asignación concreta, -ngl 99 (o -ngl all) sigue funcionando; --fit solo se aplica a los parámetros que no hayas fijado tú mismo. El cambio de comportamiento afecta al valor predeterminado, no al comando.

#¿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.

Familias extraídas de la base de hardware de QuelLLM (90 GPU y chips) · 16/11/2026
Tu hardwareBackend recomendadoNota
NVIDIA GTX 10 a RTX 50, de sobremesa y para portátilesCUDAEl backend que conviene elegir en una tarjeta NVIDIA.
AMD Radeon RX 7000 y RX 9000ROCm (HIP) o VulkanROCm es más rápido cuando funciona. Vulkan se instala sin complicaciones, incluso en Windows.
AMD Radeon RX 6000 y anterioresVulkanCompatibilidad con ROCm parcial o inexistente según la tarjeta.
Apple M1 a M5MetalActivado por defecto en los binarios de macOS. Se puede utilizar toda la memoria unificada.
GPU integrada Intel o AMD, Intel ArcVulkan o SYCLMejora real frente al uso exclusivo de la CPU en modelos pequeños.
Ninguna GPUCPU (AVX2, AVX-512, NEON)Funciona en cualquier equipo. Busca modelos de hasta 8 mil millones de parámetros.

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

Medido · banco de pruebas de QuelLLM, llama.cpp b4280, mediciones del 18/04/2026 · tabla completa en la página Benchmarks
MáquinaMemoriaLlama 3.1 8B Q4
RTX 509032 GB172 tok/s
RTX 409024 GB128 tok/s
RTX 407012 GB76 tok/s
Mac M3 Max64 GB unificados64 tok/s
RTX 306012 GB44 tok/s
Ryzen 7 7700, solo CPURAM del sistema7,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.

Instalar y luego iniciar el servidor
# Script officiel (macOS et Linux) : installe la commande llama dans ~/.local/bin
curl -LsSf https://llama.app/install.sh | sh

# Windows (PowerShell)
irm https://llama.app/install.ps1 | iex

# Ou via un gestionnaire de paquets
brew install llama.cpp        # macOS et Linux
winget install llama.cpp      # Windows

# Télécharger un petit modèle depuis Hugging Face et lancer le serveur
llama serve -hf ggml-org/Qwen3.5-0.8B-GGUF

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.

llama-server con un modelo Gemma 4
llama-server -hf ggml-org/gemma-4-E4B-it-GGUF -c 8192

# Tester l'API compatible OpenAI (port par défaut : 9931)
curl http://localhost:9931/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"messages":[{"role":"user","content":"Bonjour"}]}'
!
No abras el servidor a la red sin clave
De forma predeterminada, llama-server solo escucha en 127.0.0.1. Si cambias --host para abrirlo a tu red, define también --api-key y restringe el acceso CORS con --cors-origins.

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.

Leer el mensaje antes de cambiar un ajuste
Mensaje o síntomaCausa probablePara probar
cudaMalloc failed: out of memoryEl modelo, con el contexto solicitado, supera la VRAM disponibleReducir -c, dejar que --fit ajuste -ngl o elegir una cuantización más ligera
unknown model architectureEl archivo GGUF utiliza una arquitectura más reciente que el binario instaladoActualizar a la última versión publicada; las nuevas arquitecturas llegan primero a llama.cpp
Generación muy lenta a pesar de tener una GPU recienteNo todas las capas se han transferido a la GPU, a menudo por falta de VRAM libreComprobar la salida de carga (línea «offloaded»), cerrar las demás aplicaciones que ocupan la tarjeta
error: invalid argumentUna opción renombrada o mal escrita en el comandoComparar con llama-server --help, que enumera los alias cortos y largos actualizados
Un script falla con --defrag-tholdLa opción se eliminó con la versión 1.0.0Quitar la opción del comando
Conexión rechazada en el puerto 8080El puerto predeterminado documentado ahora es el 9931Usa 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?+
Con los mismos ajustes, la diferencia es pequeña: Ollama se basa, entre otros, en llama.cpp, cuyo motor actualiza de versión en versión. La diferencia viene de los ajustes. llama.cpp te permite elegir con precisión el número de capas en la GPU, el tamaño del contexto y la cuantización de la caché, lo que a veces permite que quepa en la VRAM un modelo que Ollama habría dejado parcialmente en la CPU.
¿Hay que saber compilar para utilizar llama.cpp?+
No. Con cada versión se publican binarios precompilados para Windows, macOS y Linux, el README ofrece un script de instalación de una línea y el paquete está disponible en Homebrew, winget, conda-forge, MacPorts y Nix: basta un comando, sin compilador. Compilar desde el código fuente solo resulta útil para activar un backend concreto que no incluye el binario oficial, aplicar un parche local o seguir la rama de desarrollo.
¿Se puede usar llama.cpp sin tarjeta gráfica?+
Sí, de hecho es su uso original: el proyecto se diseñó para ejecutar un modelo solo con un procesador, sin GPU ni Python. En un procesador reciente, un modelo 8B en Q4 genera alrededor de 8 tokens por segundo en nuestro banco de pruebas, lo que sigue siendo lento pero permite leer las respuestas para conversar o resumir. Por encima de 14 mil millones de parámetros, la espera se vuelve tediosa sin aceleración por hardware.
¿Qué diferencia hay entre llama.cpp y vLLM?+
llama.cpp está orientado a un equipo personal, sea cual sea su hardware, con modelos cuantizados en GGUF. vLLM está orientado a un servidor GPU que atiende muchas solicitudes en paralelo, con los pesos de Hugging Face. El primero maximiza lo que puedes ejecutar en tu equipo; el segundo, la capacidad de procesamiento de una GPU compartida.
¿Y en Mac, llama.cpp o MLX?+
Ambos aprovechan la GPU de Apple mediante la memoria unificada. MLX es la biblioteca diseñada por Apple para sus propios chips; llama.cpp cuenta a su favor con el inmenso catálogo de archivos GGUF ya cuantizados y con ajustes finos del contexto y la caché KV. Muchos usuarios de Mac conservan ambos y eligen según el formato disponible para el modelo que quieren. La guía MLX frente a llama.cpp en Mac detalla la elección.
llamacpp, llama cpp, llama.cpp: ¿son lo mismo?+
Sí. Son cuatro grafías del mismo proyecto, el motor de inferencia de la organización ggml-org. No hay que confundirlo con Ollama, un software distinto que lo utiliza.
¿Qué aporta llama.cpp 1.0?+
La versión 1.0.0, publicada el 13 de noviembre de 2026, estabiliza la API pública y retira la API obsoleta. También añade la caché KV en FP8, una caché de expertos para los modelos MoE, un servidor reforzado, un endpoint /v1/audio/speech y una interfaz web rediseñada. Los detalles figuran en la sección dedicada de esta guía.
¿Hay que dejar Ollama por llama.cpp?+
No necesariamente. Quédate con Ollama si su catálogo, su aplicación y sus modelos en la nube te bastan; pasa a llama.cpp para controlar cada opción del motor, probar una arquitectura muy reciente o montar un servidor duradero. Ambos pueden coexistir en la misma máquina.

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


¿Esta guía te ha ayudado?

¿Un comentario, un error, una precisión? Avísanos, eso mejora la guía para todos.