Latest

Artificial Intelligence

llama.cpp reaches 1.0 and will only break the API when it has to

libllama and libggml get a major release after three and a half years: the commitment is to mark every incompatibility with a major version bump.

llama.cpp reaches 1.0 and will only break the API when it has to
llama.cpp reaches 1.0 and will only break the API when it has to

Running a language model on a home computer stopped being a laboratory oddity, and much of the credit goes to a repository written in C and C++ that almost nobody installs by hand. llama.cpp reached version 1.0.0 on November 13, 2026, the same day as ggml, the tensor library that underpins it. The major version announcement does not promise more speed, but something less flashy and more useful: a number that warns when something stops working.

Behind it is a practical decision. The applications that talk to that library do not copy it: they call it, and they expect the functions they used yesterday to still respond tomorrow. The project supports compressed models, splits the work between memory and graphics cards and runs it from a laptop to a server with several graphics cards, so every new version lands in programs whose authors do not control it.

With that weight on its shoulders, a change to a function signature is a bill for third parties. Hence 1.0: from now on, any incompatibility in the public interface will require bumping the major number. The announcement does not touch the MIT license or change who runs the project, and that absence also says something about what the version is and what it is not.

Nine days separate 0.9.0 from 1.0.0

The previous tag, 0.9.0, was published on November 4, 2026, nine days earlier. Between the two, builds with bXXXXX numbering kept coming, the series with which the project has long been shipping freshly baked code. 1.0.0 shipped with b12359 as the immediate reference.

The substantive change is not a new feature. Thirty-five obsolete declarations are removed from the main header, along with the warm-up function and the cache defragmentation threshold, and the NextN speculative decoding API is promoted to the public header.

The 1.0.0 release notes detail the rest: expert cache in system memory with a configurable CPU quota, FP8 for the context cache and three new text architectures. None of those pieces justifies a major bump on its own; what justifies it is the contract they announce at the same time.

Code change Level What happens to whoever compiles
Removal of 35 functions from `llama.h` and of the defragmentation threshold Major The program stops compiling until the call is migrated
The NextN API moves from `llama-ext.h` to `llama.h` Minor A new header appears and nothing existing breaks
FP8 in the context cache with `-ctk f8_e4m3` Minor Anyone who does not enable the option does not touch a single line
Removal of the `DIAG_MASK` operations in ggml Major The custom kernels that used them stop compiling
RPC protocol that rejects incompatible peers Major Mixing versions no longer goes unnoticed

The rule that accompanies the table is explicit: an incompatible change in the public C API of `include/` means a major number, a new function or backend means a minor number, and a fix that does not touch the API means a patch. The same standard applies to ggml, the project's tensor library, which also reached 1.0.0 on November 13, 2026 with the obsolete API pruned.

The declared scope helps to gauge the risk. The project says it covers more than 150 architecture variants and all the main speculative decoding methods, a surface that grows with every model that appears. That door is how cards like the one for Nanbeige 4.3 33B and its Apache license, which are only of any use if the engine recognizes the architecture on the day of publication.

The announcement insists on a point that is not technical. The team wants to keep integrating models into its own development cycle without delegating the code to a third party, and argues that keeping the architecture under control matters more than publishing quickly. That fits with the fact that 1.0 took three and a half years to arrive.

What those who package local AI are buying

A higher number is of little use if no one can verify it. The useful part of the commitment lies in how it is split up: libllama and libggml are exposed through headers in `include/`, and the backends are compiled as dynamic libraries that the program loads at runtime. There, an ABI incompatibility does not produce an elegant message; it produces a load failure.

For a distribution packager, that turns the library version into operational information rather than a curiosity from the changelog: before uploading a package, you have to know whether the jump touches what the package already uses.

The distribution channels listed in the announcement include packages for Debian and Homebrew, artifacts for Android and iOS and a Docker image, as well as conda-forge, MacPorts and Winget. The pre-release binaries cover Linux and macOS, and also Windows, Android and iOS with the same code. Each channel carries its own freeze policy, similar to the one that governs any Linux 7.4 release cycle.

The ecosystem that relies on this library is broad and largely invisible. Ollama's documentation acknowledges llama.cpp as its backend, and the repository includes instructions for building on Android, which explains why the base is also present in mobile clients. The comparison between Ollama, llama.cpp, vLLM and TGI sets out what each engine contributes, although all of them share the same underlying dependency: someone decides when the interface changes.

For much of its history, the practical reference for anyone integrating the library was the build number. A tag like b12374 describes a specific code tree and a date, whereas a 0.x version said barely anything about what was inside. That gap is precisely what 1.0 aims to close.

The day the driver changes, not the header

The promise covers the code, not the environment. The 1.0.0 notes include a jump from the CUDA builds to 13.5, the reactivation of a matrix multiplication configuration in Vulkan only with AMD's proprietary driver 26.10.1 or higher, and an update to oneAPI 2026.2 with oneDNN 2026.1. None of that breaks the API, and all of it breaks installations.

Anyone compiling from source only needs a compiler. Anyone downloading a binary inherits the version of CUDA, Metal or the SDK that the integration server used, and that chain is what fails on a 2021 laptop.

The announcement backs that front with infrastructure. The project thanks six manufacturers for hardware, including NVIDIA and AMD, and describes a network of its own integration servers to test every change on all platforms, supported by computing resources rented by the hour. The list of manufacturers is also the list of different ways to break a binary.

An inference engine that changes a signature without warning shifts the cost onto whoever packages it: you have to read the code of every version to know whether the program still compiles. The difference with this announcement is not in the quality of the software; it is that the warning arrives before the download and not after the failure. An official binary is compiled against a fixed set of tools, so a driver older than that set can prevent the backend library from starting even if the header matches.

A figure that can be audited

1.0 does not change what the project is; it changes what it promises in writing. Any future major jump will be visible in the public header, and anyone will be able to check whether the number told the truth about what was breaking. It is a low standard and, at the same time, more demanding than that of a good part of the projects that live off the same audience.

The test will come with the next announced incompatibility, not this one. Then it will be clear whether the major number worked as a contract or only as a label with more zeros than before, and whether the distribution packages read it in time.

José Maldonado

Author

José Maldonado

Activist and blogger on technology, free software and blockchain.

The latest
From Huang to Botín, from Zara to Byron: corporate responsibility in global capitalism

Keep reading