Construye una aplicación de IA local hace un año y la construiste sobre un suelo que se movía. El motor bajo la mayoría de esas aplicaciones, llama.cpp, salía como una corriente de compilaciones numeradas. Un número de compilación decía cuándo llegó el código. No decía nada sobre si ese código rompería el tuyo.
La versión 1.0.0, publicada el 13 de noviembre de 2026, es la respuesta del proyecto a ese problema. No es un modelo nuevo y no es una promesa de velocidad. Es un contrato: la API pública ahora es estable, y cualquier cambio que la rompa llegará como una nueva versión mayor, donde puedes verlo venir.
llama.cpp
Sitio oficialUn motor de inferencia escrito en C y C++ que ejecuta grandes modelos de lenguaje, y ahora modelos de visión y audio, en hardware que va de teléfonos a servidores. Caso de uso principal: dar a aplicaciones de escritorio, herramientas privadas de chat, asistentes de código y servidores locales un motor portable que ejecuta modelos GGUF sin una cuenta en la nube.
Funciones clave: soporte para más de 150 variantes de arquitectura de modelos y todos los métodos comunes de decodificación especulativa, según el proyecto; cuantización y respaldos optimizados por medio de ggml; un servidor integrado con una API compatible con OpenAI; y distribución por artefactos precompilados y ocho canales de paquetes.
Ventajas: una API pública estable desde la 1.0, una gama enorme de hardware, ningún costo de licencia, y un número de versión que ahora te dice si una actualización puede romper tu código. Límites: la actualización a la 1.0 en sí rompe el código que todavía llama a la API retirada, y las reglas de versión cubren la API pública en C tal como está escrita, no cada opción, cada salida ni cada rasgo de rendimiento.
Qué es
llama.cpp no es un modelo. Es el motor que ejecuta los modelos. Tú traes un archivo de modelo, por lo general en formato GGUF, y el motor lo carga y genera salida en el hardware que haya a mano: una CPU de portátil, un teléfono, una GPU o un servidor. La cuantización, que achica un modelo para que quepa en menos memoria, y un conjunto de respaldos de hardware en ggml, la biblioteca de tensores bajo el motor, hacen el trabajo pesado.
Ese trabajo sin glamour es la razón por la que el proyecto importa. El equipo nota que muchas aplicaciones posteriores ya dependen de sus interfaces de biblioteca, y que cada integración nueva sube el costo de un rompimiento descuidado. Nuestro perfil de Open Code Review planteaba un punto parecido desde el otro lado: el valor duradero en esta capa de la pila está en la estructura alrededor del modelo, y la estructura solo gana confianza cuando deja de moverse sin aviso.
El proyecto comenzó en marzo de 2023 como una forma de ejecutar el modelo LLaMA original en C y C++ simples. Tres años y medio después soporta modelos multimodales, más de 150 variantes de arquitectura, y hardware que va de portátiles de consumo a servidores de empresa, en palabras del equipo. Los números de versión, hasta ahora, eran conteos de compilación.
La promesa, por escrito
El anuncio en Hugging Face, publicado por el equipo ggml-org el 13 de noviembre, pone las reglas nuevas en una tabla corta. libllama y libggml están ambos en 1.0.0, y las reglas se aplican a los proyectos ggml-org que usan versionado semántico.
| Cambio | Salto de versión |
|---|---|
| Rompimiento de la API pública en C en el directorio include | Mayor |
| Función nueva, actualización de respaldo, soporte de modelo o agregado de API que mantiene la compatibilidad | Menor |
| Corrección de error sin cambio de API | Parche |
Lee esa tabla de cerca, porque sus límites son parte de la historia. La promesa cubre la API pública en C, los encabezados contra los que otros proyectos construyen. Es una promesa fuerte y útil para los desarrolladores de aplicaciones, que ahora pueden fijar una versión mayor y tomar las actualizaciones menores y de parche con mucho menos miedo. No promete, tal como está escrita, que la salida del modelo, la velocidad, el uso de memoria, las opciones de línea de comandos o las respuestas del servidor se queden idénticas para siempre. Quien te venda la 1.0 como estabilidad total te vende más de lo que el equipo escribió.
El equipo también dice que reflejará las incompatibilidades de API y ABI en saltos mayores, y que será más estricto con esos límites a medida que crece la adopción. ABI es el contrato a nivel binario que permite que el código compilado se enlace y funcione junto. Esa frase, más la infraestructura de pruebas ampliada que describe la nota, con ejecutores autoalojados en las plataformas grandes de hardware y apoyo nombrado de NVIDIA, AMD, Qualcomm, Arm, IBM e Intel, es la mitad operativa de la promesa. Las reglas sin pruebas son solo intenciones.
Lo que la versión en sí cambia
Una línea estable empieza con una limpieza, y esta es honesta al respecto. La versión 1.0.0 quita la API pública obsoleta: 35 funciones obsoletas desaparecen, junto con el ajuste de calentamiento llama_set_warmup y la opción de umbral de desfragmentación. La API de decodificación especulativa NextN pasa al encabezado principal llama.h, y una función de estado cambia de nombre en el paso. El código que llamaba a las funciones quitadas no compilará, y ese fallo es el punto: el rompimiento pasa una vez, en voz alta, al inicio de la línea estable, en lugar de pasar en pedazos pequeños para siempre.
Más allá de la poda, las notas de la versión enumeran trabajo real:
- Cachés KV en FP8, en el formato E4M3, con escalas estáticas opcionales. La caché KV es el contexto guardado que un modelo reutiliza mientras genera, y una caché más pequeña significa contexto más largo o modelos más grandes en la misma memoria.
- Una caché en memoria del anfitrión para modelos de mezcla de expertos, con una parte configurable a cargo de la CPU. Los modelos de mezcla de expertos guardan muchas subredes especialistas y usan unas pocas por token, así que guardar en caché las que están ociosas en la memoria del sistema es una forma práctica de ejecutarlos en hardware modesto.
- Carga de fragmentos PLE externos, para que partes de un modelo puedan enviarse y cargarse como archivos GGUF separados.
- Soporte para modelos nuevos, entre ellos las arquitecturas de texto Kimi-K3.1-Pro, Ripple y xing4_0, el modelo de texto a voz drama-3, y visión para MageVL-Cowork y Kimi-K3.1.
- Una interfaz web del servidor rediseñada, con grupos de chat y un editor de Markdown con vista previa en vivo.
ggml llega a 1.0.0 al mismo paso. Sus notas podan su propia API obsoleta y operaciones heredadas, agregan soporte FP8 y truncamiento YaRN configurable, y traen trabajo de rendimiento en los respaldos CUDA, Metal, Vulkan, SYCL, OpenCL, WebGPU y Hexagon.
El servidor recibió una pasada de seguridad
Mucha gente conoce llama.cpp por llama-server, el servidor integrado que expone una API compatible con OpenAI a las aplicaciones locales. Las notas de la 1.0 dan a ese servidor una ronda seria de refuerzo: correcciones para la falsificación de peticiones del lado del servidor por el proxy CORS y las URL de medios, para el reenlace de DNS, y para el acceso directo por navegador a instancias hijas, más un manejo más estricto de los orígenes CORS.
Las herramientas y los medios ahora se inclinan hacia la activación voluntaria en lugar de lo contrario, con opciones requeridas para permitir herramientas sin autenticación o URL de medios privadas, y el token de Hugging Face restringido a los anfitriones de Hugging Face. Las llamadas de herramientas MCP se cancelan cuando un cliente se desconecta o agota el tiempo, que es el tipo de corrección sin glamour que evita que un servidor local haga un trabajo que ya nadie escucha.
El servidor también gana un punto de conexión /v1/audio/speech compatible con OpenAI, con una opción de temperatura para texto a voz. Eso convierte un servidor local de modelos en una fuente local de voz para aplicaciones que ya hablan esa forma de API. Nuestro tutorial sobre dar herramientas reales a un modelo local con Ollama y MCP cubre el terreno vecino: una vez que un motor local expone puntos de conexión estándar, las aplicaciones a su alrededor se multiplican rápido.
Lo que funciona
- Versionado semántico con reglas escritas, para que los rompimientos ahora lleguen como saltos mayores visibles
- Una API pública en C estable para las muchas aplicaciones que construyen sobre libllama y libggml
- Cachés KV en FP8 y una caché de expertos en memoria del anfitrión que ayudan a que los modelos grandes quepan en hardware modesto
- Refuerzo del servidor, un punto de conexión de voz y distribución en cinco sistemas operativos y ocho canales, gratis bajo MIT
Lo que no funciona
- La actualización rompe el código que todavía llama a las 35 funciones quitadas o a las opciones abandonadas
- La promesa de versión cubre la API pública en C tal como está escrita, no la salida, la velocidad, las opciones ni el comportamiento del servidor
- Las compilaciones nocturnas todavía se mueven rápido, así que quienes siguen la punta todavía viven sobre suelo movedizo
- Tú aportas y administras el hardware, los modelos y las actualizaciones
Cuál deberías elegir
Actualiza ahora si construyes sobre la biblioteca. Si tu aplicación se enlaza con libllama o libggml, la 1.0 es la línea contra la que se medirán tus actualizaciones futuras. Moverte temprano, mientras la lista de retiros es corta y está documentada, cuesta menos que moverte después bajo presión.
Actualiza con una lista de control si ejecutas el servidor. Toma las correcciones de seguridad, y luego revisa las opciones nuevas de activación para herramientas y URL de medios según cómo está expuesto tu servidor. Un servidor ligado a tu propia máquina y un servidor alcanzable en una red son historias de riesgo distintas, y la 1.0 las trata de esa manera.
Quédate un poco más si dependes de las llamadas quitadas. Si tu código se apoya en la API podada, fija la última compilación que funciona, lee la superficie de migración en las notas de la versión, y muévete en tu propio horario. La línea estable seguirá ahí, y ese es justamente el punto.
Mira los envoltorios si nunca quieres ver nada de esto. Las aplicaciones construidas sobre llama.cpp esconden el motor detrás de un instalador normal y un selector de modelos. Renuncias al control sobre versiones y respaldos, y ganas una vida tranquila. Para una herramienta privada de chat en una sola portátil, ese intercambio suele ser el correcto. Nuestra mirada a Kilo Desktop muestra hasta dónde puede llevar esa idea un buen banco de trabajo.
Reflexiones finales
La mayoría de las versiones 1.0 son marketing. Esta se parece más a una constitución. llama.cpp pasó tres años y medio como el suelo que más rápido se movía en la IA local, y mucho software ahora está parado sobre ese suelo. La versión 1.0.0 no frena tanto el proyecto como promete anunciar los terremotos por adelantado, en el número de versión, donde cada desarrollador puede verlos.
Es una promesa modesta y valiosa. La IA local vende privacidad y control, y ninguno de los dos significa mucho si el motor de abajo puede romper tu aplicación en una actualización de rutina. Si el equipo mantiene sus propias reglas, y la inversión en pruebas del anuncio sugiere que piensa hacerlo, la 1.0 será recordada menos por lo que agregó que por lo que dejó de hacer sin aviso.
Sources
- Release notes, API changes, new models, server changes, and ggml changes: Release v1.0.0, ggml-org/llama.cpp, on GitHub
- Announcement, versioning rules, distribution channels, and backend and model coverage: llama.cpp v1.0.0: A stronger foundation for the local AI ecosystem, ggml-org on Hugging Face
- Repository, licence, and documentation: ggml-org/llama.cpp repository on GitHub
- Repository card image: ggml-org on GitHub
- Hero illustration: Dirty Static, generated in house style
FIN DE LA TRANSMISIÓN
Mantén la curiosidad. Cuestiónalo todo.


