Build a local AI app a year ago and you built it on ground that moved. The engine under most of those apps, llama.cpp, shipped as a stream of numbered builds. A build number told you when code landed. It told you nothing about whether that code would break yours.
Version 1.0.0, released on November 13, 2026, is the project answer to that problem. It is not a new model and it is not a speed claim. It is a contract: the public API is now stable, and any change that breaks it will arrive as a new major version, where you can see it coming.
llama.cpp
Official siteAn inference engine written in C and C++ that runs large language models, and now vision and audio models, on hardware from phones to servers. Primary use case: giving desktop apps, private chat tools, coding assistants, and local servers a portable engine that runs GGUF models without a cloud account.
Key features: support for more than 150 model architecture variants and all mainstream speculative decoding methods, per the project; quantization and optimized backends through ggml; a built in server with an OpenAI compatible API; and distribution through prebuilt artifacts and eight package channels.
Advantages: a stable public API from 1.0 onward, a huge hardware range, no licence cost, and a version number that now tells you whether an upgrade can break your code. Limitations: the 1.0 upgrade itself breaks code that still calls the removed API, and the version rules cover the public C API as written, not every flag, output, or performance trait.
What it is
llama.cpp is not a model. It is the engine that runs models. You bring a model file, usually in GGUF format, and the engine loads it and generates output on whatever hardware is at hand: a laptop CPU, a phone, a GPU, or a server. Quantization, which shrinks a model so it fits in less memory, and a set of hardware backends in ggml, the tensor library under it, do the heavy lifting.
That unglamorous job is why the project matters. The team notes that many downstream applications already depend on its library interfaces, and that each new integration raises the cost of a careless break. Our profile of Open Code Review made a similar point from the other side: the durable value in this layer of the stack sits in the structure around the model, and structure only earns trust when it stops shifting without warning.
The project began in March 2023 as a way to run the original LLaMA model in plain C and C++. Three and a half years later it supports multimodal models, more than 150 architecture variants, and hardware from consumer laptops to enterprise servers, in the team wording. Version numbers, until now, were build counts.
The promise, in writing
The Hugging Face announcement, published by the ggml-org team on November 13, puts the new rules in a short table. Both libllama and libggml sit at 1.0.0, and the rules apply to ggml-org projects that use semantic versioning.
| Change | Version bump |
|---|---|
| Breaking change to the public C API in the include directory | Major |
| New feature, backend update, model support, or API addition that keeps compatibility | Minor |
| Bug fix with no API change | Patch |
Read that table closely, because its limits are part of the story. The promise covers the public C API, the headers other projects build against. It is a strong and useful promise for app developers, who can now pin a major version and take minor and patch updates with far less fear. It does not, as written, promise that model output, speed, memory use, command line flags, or server responses will stay identical forever. Anyone selling you 1.0 as total stability is selling you more than the team wrote down.
The team also says it will reflect API and ABI incompatibilities in major bumps, and get stricter about those boundaries as adoption grows. ABI is the binary level contract that lets compiled code link and run together. That sentence, plus expanded test infrastructure the post describes, with self hosted runners across major hardware platforms and support named from NVIDIA, AMD, Qualcomm, Arm, IBM, and Intel, is the operational half of the promise. Rules without testing are just intentions.
What the release itself changes
A stable line starts with a cleanup, and this one is honest about it. Version 1.0.0 removes the deprecated public API: 35 deprecated functions are gone, along with the warmup setter llama_set_warmup and the defragmentation threshold option. The NextN speculative decoding API moves into the main llama.h header, and one state function is renamed in the move. Code that called the removed functions will fail to build, and that failure is the point: the break happens once, loudly, at the start of the stable line, instead of in small pieces forever.
Past the pruning, the release notes list real work:
- FP8 KV caches, using the E4M3 format, with optional static scales. The KV cache is the stored context a model reuses while it generates, and a smaller cache means longer context or larger models in the same memory.
- A host memory cache for mixture of experts models, with a configurable share handled by the CPU. Mixture of experts models keep many specialist subnetworks and use a few per token, so caching the idle ones in system memory is a practical way to run them on modest hardware.
- Loading of external PLE shards, so parts of a model can ship and load as separate GGUF files.
- New model support, including the text architectures Kimi-K3.1-Pro, Ripple, and xing4_0, the drama-3 text to speech model, and vision support for MageVL-Cowork and Kimi-K3.1.
- A redesigned server web UI, with chat groups and a live preview markdown editor.
ggml reaches 1.0.0 in step. Its notes prune its own deprecated API and legacy operations, add FP8 support and configurable YaRN truncation, and carry performance work across the CUDA, Metal, Vulkan, SYCL, OpenCL, WebGPU, and Hexagon backends.
The server got a security pass
Many people meet llama.cpp through llama-server, the built in server that exposes an OpenAI compatible API to local apps. The 1.0 notes give that server a serious hardening round: fixes for server side request forgery through the CORS proxy and media URLs, for DNS rebinding, and for direct browser access to child instances, plus tighter handling of CORS origins.
Tools and media now lean toward opt in rather than opt out, with flags required to allow unauthenticated tools or private media URLs, and the Hugging Face token restricted to Hugging Face hosts. MCP tool calls are cancelled when a client disconnects or times out, which is the sort of unglamorous fix that stops a local server from doing work nobody is listening to anymore.
The server also gains an OpenAI compatible /v1/audio/speech endpoint, with a temperature option for text to speech. That turns a local model server into a local voice source for apps that already speak that API shape. Our tutorial on giving a local model real tools with Ollama and MCP covers the adjacent ground: once a local engine exposes standard endpoints, the apps around it multiply fast.
What Works
- Semantic versioning with written rules, so breaking changes now arrive as visible major bumps
- A stable public C API for the many apps that build on libllama and libggml
- FP8 KV caches and a host memory expert cache that help large models fit modest hardware
- Server hardening, a speech endpoint, and distribution across five operating systems and eight channels, free under MIT
What Does Not
- The upgrade breaks code that still calls the 35 removed functions or the dropped options
- The version promise covers the public C API as written, not output, speed, flags, or server behaviour
- Nightly builds still move fast, so users who track the tip still live on moving ground
- You supply and manage the hardware, the models, and the updates yourself
Which should you choose
Upgrade now if you build on the library. If your app links libllama or libggml, 1.0 is the line your future updates will be measured against. Moving early, while the removed list is short and documented, is cheaper than moving later under pressure.
Upgrade with a checklist if you run the server. Take the security fixes, then review the new opt in flags for tools and media URLs against how your server is exposed. A server bound to your own machine and a server reachable on a network are different risk stories, and 1.0 treats them that way.
Stay put a little longer if you depend on removed calls. If your code leans on the pruned API, pin the last build that works, read the migration surface in the release notes, and move on your own schedule. The stable line will still be there, and that is rather the point of it.
Look at the wrappers if you never want to see any of this. Apps built on llama.cpp hide the engine behind a normal installer and a model picker. You give up control over versions and backends, and you gain a quiet life. For a private chat tool on one laptop, that trade is often the right one. Our look at Kilo Desktop shows how far a good workbench can take that idea.
Final thoughts
Most 1.0 releases are marketing. This one is closer to a constitution. llama.cpp spent three and a half years as the fastest moving floor in local AI, and a lot of software now stands on that floor. Version 1.0.0 does not slow the project down so much as it promises to announce the earthquakes in advance, in the version number, where every developer can see them.
That is a modest promise and a valuable one. Local AI sells privacy and control, and neither means much if the engine underneath can break your app in a routine update. If the team holds its own rules, and the testing investment in the announcement suggests it intends to, 1.0 will be remembered less for what it added than for what it stopped doing without warning.
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
END OF TRANSMISSION
Stay curious. Question everything.


