llama.cpp v1.0.0 arrived on 13 November 2026, and it is the most consequential release in the project’s three-and-a-half-year history — not because it adds a headline feature, but because it changes what the version number means. For the first time, the engine that powers a large share of local AI software carries a semantic version, and with it a written promise: breaking changes to the public C API will arrive only with a major-version bump. The release itself is also a cleanup, removing 35 deprecated functions and promoting the speculative-decoding API into the main header, so existing users should read the fine print before upgrading.
What llama.cpp v1.0.0 actually is
llama.cpp is an open-source inference engine written in C and C++ that makes it possible to run multi-modal large language models across a wide range of hardware, from consumer-grade local machines to high-end enterprise servers. It does this through quantization, optimized backends, and a portable C/C++ implementation. Underneath it sits ggml, the tensor library that provides the machine-learning engine. The v1.0.0 release covers both libraries together: libllama, the LLM inference library with public headers in llama.cpp/include/, and libggml, the tensor library with headers in ggml/include/.
The project’s own description of the release is deliberately modest about features and emphatic about responsibility. As the Hugging Face announcement puts it: “We believe this is the most lightweight, versatile and sensible platform for building cross-platform and private AI products.” The 1.0 label is a statement about the interface developers build against, and the team behind it — the ggml-org team at Hugging Face — is explicit that the release highlights its responsibility to the developers who depend on those interfaces.
Why 1.0.0, and why now
For most of its life, llama.cpp shipped continuous, build-numbered releases — tags like b12359 — rather than semantic versions. The project began three and a half years ago, and over that time it grew into infrastructure that many downstream applications depend on. Every new integration means more developers depending on the library interfaces.
That dependence is the reason for 1.0.0 now. With local AI and privacy becoming increasingly important in everyday life, the trend of downstream dependence is expected to continue, and a flexible but stable API is paramount as more developers come to depend on those interfaces. The release is therefore less a celebration than a contract — the point at which the project accepts that its public interface is a promise to others, not just its own implementation detail.
Behind the release, the team says it continues to invest in the continuous-integration infrastructure that keeps the project correct at its current pace, using Hugging Face technologies such as HF Buckets and HF Jobs to scale the capacity needed to guarantee correctness for every change that lands on the master branches. Hardware support spans NVIDIA, AMD, Qualcomm, Arm, IBM, and Intel, with self-hosted runners enrolled across all major hardware platforms.
The new versioning rules
The versioning rules apply to all ggml-org projects that use semantic versioning, and they are refreshingly specific. The entire contract fits in three rows:
- MAJOR — a breaking change to the public C API in
./include. - MINOR — a backward-compatible feature, backend update, model support addition, or API addition.
- PATCH — a bug fix with no API change.
The key sentence in the announcement is the one that gives the number its meaning going forward: “Moving forward, both llama.cpp and ggml will reflect API and ABI incompatibilities with major-version bumps.” As adoption grows, the team says it will be stricter about making those boundaries visible to downstream consumers.
Note the scope of the promise. The rule is written about the public C API — the headers under ./include. It is a commitment about the interface your code compiles against, not a guarantee that every behaviour of the tools built on top of the libraries will stay identical. That distinction matters when you plan an upgrade, as the next sections show.
What runs on it: backends and model coverage
The breadth the stable API now covers is the other half of the story. The underlying engine, ggml, is designed to run across a wide range of hardware, and it achieves that by implementing dedicated backends for each hardware target. Each backend can be compiled as a dynamic library and optionally loaded at runtime, so the same library adapts to the machine it finds itself on.
On model coverage, llama.cpp currently supports more than 150 architecture variants as well as all mainstream speculative decoding methods. The v1.0.0 release itself adds three new text architectures — Kimi-K3.1-Pro, Ripple-65B-Preview (a dense 65-billion-parameter architecture), and xing4_0 — along with drama-3 text-to-speech and vision support for MageVL-Cowork and Kimi-K3.1.
Speculative decoding also moves up a level in this release. The NextN speculative-decoding API is promoted from llama-ext.h into the main llama.h header, which signals that it is now part of the stable public surface rather than an extension. The rename of llama_set_embd_state_src to llama_set_ctx_state_src arrives in the same cleanup.
How to get llama.cpp v1.0.0
The release is available through the project’s existing distribution channels. Pre-release artifacts cover Linux, macOS, Windows, Android, and iOS; packages are available through Docker, Debian, Homebrew (macOS and Linux), conda-forge (Windows, macOS, and Linux), MacPorts (macOS), Winget (Windows), and XCFramework (iOS and macOS). The team says it looks forward to expanding the ways ggml-org software is distributed and reaches developers and end users, and points to a public discussion for adding ggml-org projects to packaging and release pipelines — but no timeline for that expansion is given.
For a precise v1.0.0 source build, the release tag is the reference point:
git clone https://github.com/ggml-org/llama.cpp.git
cd llama.cpp
git checkout v1.0.0Pre-built binaries are on the GitHub releases page.
What this means if you build on llama.cpp
Start with the uncomfortable part: v1.0.0 is itself a breaking release, and it is not a drop-in upgrade for every existing application. The 1.0 milestone is used to remove the deprecated public API — 35 deprecated functions, the warmup setter llama_set_warmup, and the defragmentation-threshold option defrag_thold are all gone. If your code calls any of the removed functions, it will break at compile time, and the rename of llama_set_embd_state_src needs the same attention. Check the release notes against your codebase before upgrading, and treat the removal list as the first thing to verify.
Once you are past 1.0.0, the new contract is what you plan around. MAJOR bumps mean a breaking change to the public C API; MINOR releases are intended to be backward-compatible and PATCH releases carry no API change — but downstream users should still validate each upgrade in their own application rather than assuming it is safe to take blindly. The versioning rules describe the public interface, not runtime behaviour, and the announcement itself leaves open whether a given release changes runtime defaults. Pinning to a major version and testing upgrades against your own workloads remains the sensible discipline.
The release also brings capabilities worth knowing about beyond the versioning story. FP8 KV caches arrive with OCP FP8 support, and a host-memory cache for mixture-of-experts models lets you configure how much of the expert cache lives on the CPU:
# FP8 KV cache (OCP f8_e4m3, optional static per-tensor scales)
-ctk f8_e4m3 -ctv f8_e4m3
# MoE expert cache: size and CPU share
moe_cache_size
moe_cache_cpu_shareExternal PLE shards can now be loaded from separate GGUF files with --shard and --ple. On the server side, llama-server is hardened against server-side request forgery, cross-origin issues, DNS rebinding, and MCP tool cancellation, with new opt-ins for unauthenticated tools and private media URLs, and it gains an OpenAI-compatible /v1/audio/speech endpoint. The web UI is redesigned with chat groups and a live-preview markdown editor. And ggml itself ships as v1.0.0, pruning its deprecated public API and legacy operations while adding configurable YaRN truncation, FP8 support, and backend performance work across CUDA, Metal, Vulkan, SYCL, OpenCL, WebGPU, and Hexagon.
The honest summary is that llama.cpp v1.0.0 is two things at once: a cleanup that breaks code still using the deprecated API, and a promise that future breaks will be visible in the version number. The first part demands a careful upgrade; the second part is what makes the upgrade worth doing. For the local AI ecosystem — the applications, tools, and products built on this engine — a stable public interface is the foundation the next three and a half years will stand on.
