El equipo de ggml-org publicó el 13 de noviembre la v1.0.0 de llama.cpp y de ggml. Después de tres años y medio, el proyecto que sostiene buena parte de la IA local promete algo que hasta ahora no prometía: avisar cuando rompa su propia interfaz.
Qué es llama.cpp y por qué casi nadie lo ve
llama.cpp es un motor de inferencia escrito en C y C++. Carga modelos cuantizados, es decir, modelos comprimidos para ocupar menos memoria, y los ejecuta en portátiles, móviles, placas del tamaño de una Raspberry Pi y servidores. Es la razón por la que un modelo de 7B puede funcionar sin conexión en un equipo que ya tienes.
Casi nadie lo usa directamente. Lo usan las aplicaciones que hay encima: clientes de escritorio, apps de Android, servidores domésticos y algún producto comercial que prefiere no depender de la nube. La expresión local inference, inferencia local, describe justo eso: ejecutar el modelo en hardware propio sin mandar los datos a un servidor.
Debajo hay otra pieza. ggml es la biblioteca de tensores sobre la que se apoya llama.cpp, y GGUF es el formato de archivo que el motor lee. Tres nombres que suelen aparecer juntos y que no son lo mismo. ggml no es un modelo. Es la capa de cálculo.
Qué cambia con la v1.0.0 de llama.cpp y ggml
El anuncio salió en el blog de Hugging Face el 13 de noviembre de 2026, firmado por Daniel Bevenius, Georgi Gerganov y merve. Las dos bibliotecas suben a la vez: llama.cpp con libllama y sus cabeceras en llama.cpp/include, y ggml con libggml y las suyas en ggml/include.
El proyecto tiene tres años y medio y muchas aplicaciones dependen de esas interfaces. Ahí está el cambio real. Hasta ahora una modificación interna podía llegar sin aviso y aparecer como un fallo de compilación un martes por la mañana, en el portátil de alguien que solo quería actualizar.
La publicación no anuncia un modelo nuevo ni una mejora de velocidad. Habla de interfaz y de empaquetado, que es menos vistoso y afecta a más gente.
Cómo se aplica el versionado semántico a la API en C
Las reglas son las habituales de semver y conviene leerlas con cuidado, porque marcan lo que viene. Un salto MAJOR significa un cambio incompatible en la API pública en C que vive en ./include. Un salto MINOR añade funciones compatibles hacia atrás: funciones nuevas, backends nuevos, soporte para más modelos o ampliaciones de la API. Un PATCH corrige errores sin tocar la API.
Las dos bibliotecas siguen la misma regla. Si un backend cambia de nombre o una firma se rompe, toca MAJOR. Si solo se añade capacidad, toca MINOR.
¿Y si el cambio altera el comportamiento sin tocar la firma? Ahí semver no dice nada, y el anuncio tampoco. Para quien mantiene un binding de Python, un paquete de Node o una app de Android, la conversación cambia igual: antes había que leer el historial de commits para saber si una actualización dolía, y ahora el número lo dice.
GGUF no se toca, y eso también cuenta
GGUF sigue siendo lo que era: el formato de archivo que el motor carga. Este anuncio no lo cambia. Tampoco convierte a llama.cpp en el inventor del formato, porque no lo es.
La estabilidad del formato importa por una razón práctica. Los modelos cuantizados se distribuyen como archivos GGUF en Hugging Face y en discos externos. Si el formato se moviera con cada versión, cada actualización del motor invalidaría la biblioteca de modelos de medio internet.
En español hay bastantes modelos afinados que la comunidad publica en GGUF. Que el archivo siga sirviendo después de un salto de versión es la diferencia entre descargar 4 GB otra vez y no descargar nada.
Los canales de distribución que salen ganando
El anuncio enumera los canales que ahora quedan cubiertos por la promesa. Hay artefactos de prepublicación para Linux, macOS, Windows, Android e iOS. Y hay paquetes para Docker, Debian, Homebrew, conda-forge, MacPorts, Winget y un XCFramework para proyectos de Apple.
Esa lista es el motivo por el que la versión importa más allá del código. Cada canal tiene su propio ciclo de publicación, y un paquete de Homebrew que salta a una versión rota deja a un usuario sin forma sencilla de volver atrás, salvo que el número de versión le diga qué está instalando.
La infraestructura que hace creíble la promesa
Prometer compatibilidad es fácil. Sostenerla exige probar cada backend en cada cambio, y eso cuesta dinero y máquinas.
El equipo explica cómo lo hace: capacidad de integración continua escalada con Hugging Face Buckets y HF Jobs, y runners autoalojados con hardware de NVIDIA, AMD, Qualcomm, Arm, IBM e Intel. La lógica es simple. No puedes garantizar una API estable mientras envías backends sin probar, porque el fallo aparecerá en el equipo de otro y con otra tarjeta gráfica.
Las nightlies siguen: b12445 del 16 de noviembre
Tres días después del anuncio, el proyecto publicó la build b12445 en GitHub, el 16 de noviembre. Las compilaciones nocturnas no se detuvieron.
Ese detalle importa porque desmonta la lectura equivocada. La v1.0.0 no congela el desarrollo ni convierte el proyecto en algo conservador. Congela la forma de avisar cuando algo se rompe.
Una promesa de estabilidad que parase el trabajo sería inútil. El valor está en seguir moviéndose con un número que informe del riesgo.
Qué significa para quien ya tiene una app montada
Si mantienes una aplicación que enlaza contra libllama, la tarea de esta semana es aburrida y útil: fijar la versión en tu gestor de dependencias y leer las notas antes de subir de MINOR. La promesa cubre la API pública, no el comportamiento interno de cada backend.
En un equipo pequeño de Valencia que empaqueta un asistente offline para Android, eso se traduce en algo concreto. La actualización deja de ser una apuesta y pasa a ser una decisión con información. Si el número sube de MINOR, tus llamadas siguen compilando. Si sube de MAJOR, ya sabes que hay trabajo.
Queda una zona gris que el anuncio no resuelve. La API en C es la que tiene garantía. Las interfaces de más arriba, incluidas las herramientas de línea de comandos y algunos bindings mantenidos fuera del repositorio, dependen de otros equipos y de otros ritmos.
El primer salto MAJOR será la prueba
Un número de versión es una promesa sobre el código de otros. Cualquiera puede escribir 1.0.0. Lo difícil es el día en que toque decir 2.0.0, explicar qué se rompe, dar tiempo y no dejar a medio mundo compilando a ciegas.
Hasta entonces, la v1.0.0 ya ha conseguido algo pequeño y real: quien actualice llama.cpp o ggml puede mirar el número y saber qué esperar. En un proyecto del que depende tanta IA local, eso no es cosmética.






