llama.cpp 1.0.0 Is Here: Local AI Gets a Stable API After 3.5 Years

llama.cpp is a free, open-source C/C++ inference engine that runs large language models on ordinary local hardware, mostly in GGUF format, and ggml is the tensor library underneath it. On 13 November 2026, after about 3.5 years, both reached version 1.0.0 and the headline is not a speed record or a new model. It is a promise: from now on, the project will use semantic versioning, so a breaking change to its public interface will arrive as a major-version bump instead of hiding inside a routine update. The GitHub release, tagged v1.0.0 at 10:20 UTC that day as nightly build b12359, also removes 35 deprecated public functions, adds FP8 key-value caches and a host-memory cache for mixture-of-experts models, and hardens its built-in server.

Why 1.0.0 matters more than the version number

Until now, llama.cpp was versioned by build numbers. The last numbered releases were llama.cpp v0.9.0 and ggml v0.29.0, and in between, users tracked builds such as b12359 — numbers that told you nothing about whether an update might break your code. That worked while llama.cpp was a fast-moving experiment. It stopped working once the project became infrastructure. Ollama, LM Studio and a long list of other apps that run models on laptops all sit on top of llama.cpp, and the Hugging Face announcement says many downstream applications already depend on its library interfaces. When a library becomes infrastructure, changing its interface without warning breaks someone else's product.

Version 1.0.0 answers that with a formal rule, published in the Hugging Face blog post "llama.cpp v1.0.0: A stronger foundation for the local AI ecosystem". The project is now maintained by the ggml-org team at Hugging Face, which frames the release as a responsibility to developers, not a marketing anniversary. The team also expanded continuous-integration infrastructure and added self-hosted test runners across major hardware platforms. The project says it supports more than 150 architecture variants and all mainstream speculative-decoding methods, and ships through eight distribution channels, including Debian, Homebrew, conda-forge, MacPorts, Winget, Docker and XCFramework — the kind of foundation the Impeccable GitHub skill community builds on.

The semantic-versioning promise, in plain language

Semantic versioning, or semver, is a simple idea: the version number tells you what kind of change an update contains. The team published three rules, and the scope is deliberately narrow. A major bump means a breaking change to the public C API — the headers in ./include. A minor bump means a backward-compatible feature, a backend update, new model support, or an API addition. A patch means a bug fix with no API change.

Version partWhat it means for llama.cpp and ggml
MAJOR (1.0.0 to 2.0.0)A breaking change to the public C API in ./include
MINOR (1.0.0 to 1.1.0)A backward-compatible feature, backend update, new model support, or API addition
PATCH (1.0.0 to 1.0.1)A bug fix with no API change

The narrow scope is the point, and the trap for anyone who reads too much into it. The promise covers the public C API and ABI — whether your code compiles and links. It does not promise identical model outputs, that every GGUF file will load forever, or that every command-line flag and HTTP response will stay fixed. The announcement never makes those promises. So 1.0.0 tells you when an update may break code that calls the library directly. It does not tell you nothing else will change.

A developer working on a laptop with code on the screen in a dark home office at night
AI-generated illustration (generated 15 Nov 2026)


The first 1.0 release already breaks old code

Here is the irony at the heart of this release: the first tag under the new stability policy is itself a breaking change. The GitHub notes say v1.0.0 "removes the deprecated public API and promotes the NextN/speculative API to llama.h". Pull request #30565 removes llama_set_warmup, 35 deprecated functions, the defrag_thold option and its --defrag-thold flag, promotes the NextN speculative-decoding API from llama-ext.h into the main llama.h header, and renames llama_set_embd_state_src to llama_set_ctx_state_src. If your project calls any removed function, or still passes --defrag-thold, upgrading will fail to compile until you change your code.

That is a deliberate cleanup. The team removed the old functions before making the stability promise, so the promise starts from a clean interface. It means developers should treat 1.0.0 as a migration, not a drop-in update: check PR #30565, search your code for the removed names, and update any calls first. The same release prunes ggml's own deprecated public API and its legacy DIAG_MASK operations. For most home users, none of this is visible — if you run models through an app, that app's developers do the migration, and you simply get a newer bundled version.

What else actually changed in v1.0.0

On memory, the release adds OCP FP8 key-value caches, which store a compressed memory of tokens already processed, and a host-memory mixture-of-experts expert cache with a configurable CPU share (moe_cache_size and moe_cache_cpu_share). It also adds loading of external PLE shards from separate GGUF files. The release puts no number on any of this: neither the announcement nor the notes give before-and-after speed or memory figures for the new caches, so this article gives none either.

On models, v1.0.0 adds three text architectures — Kimi-K3.1-Pro, Ripple-65B-Preview and xing4_0 — plus drama-3 text-to-speech and vision support for MageVL-Cowork and Kimi-K3.1. The Kimi K3.1 Pro addition is the most notable here, because local support widens the choice of models you can run without a cloud account. Ripple is a dense 65-billion-parameter architecture. Support does not mean a model runs well on every machine — a 65-billion-parameter model still needs serious memory — but it does mean the engine can load and run it at all.

On the server, llama-server gets meaningful hardening: fixes for server-side request forgery, --cors-origins handling, DNS rebinding and child-instance access, plus opt-in flags for unauthenticated tools and private media URLs. It cancels MCP tool calls when a client disconnects, and adds an OpenAI-compatible /v1/audio/speech endpoint. An app written against OpenAI's speech endpoint can now talk to a local llama.cpp server with less custom code. The security fixes are a reason to update rather than stay on an older build if you expose a server on a network.

A small home server and laptop on a desk running local AI software, warm LED lights
AI-generated illustration (generated 15 Nov 2026)


The new interface, and what to do before you upgrade

The release ships a redesigned web interface: chats can be gathered into named groups, the sidebar can fold and rearrange, and the chat input has a live-preview markdown editor. PDF attachments now show text and page thumbnails, and a search_chats tool was added. Underneath, ggml 1.0.0 brings FP8 support, configurable YaRN truncation, and backend work across CUDA, Metal, Vulkan, SYCL, OpenCL, WebGPU and Hexagon. No single speed figure summarises it honestly across that many backends. The Hallmark GitHub skill is a reminder of how much of open source is built from projects like this — small, focused, heavily starred, and easy to overlook until they change something underneath you.


If you use llama.cpp through an app, wait for that app to ship 1.0.0, then update normally. If you build against the library directly, read PR #30565, update the NextN calls that moved into llama.h, rename llama_set_embd_state_src, and test on a copy of your service before deploying. The announcement gives no support window for older major versions, and it does not say when Debian, Homebrew or downstream apps will ship 1.0.0.
Close-up of hands typing on a laptop keyboard beside a notebook and coffee mug
AI-generated illustration (generated 15 Nov 2026)


Key Takeaways



  • llama.cpp and ggml reached v1.0.0 on 13 November 2026 (GitHub tag at 10:20 UTC, build b12359), after about 3.5 years of build-number versioning.
  • The headline is semantic versioning: a breaking change to the public C API in ./include will arrive as a major-version bump.
  • The promise is narrow — it covers the public C API and ABI, not identical outputs, unchanged CLI flags or identical HTTP responses.
  • v1.0.0 itself breaks old code: it removes 35 deprecated functions, llama_set_warmup and defrag_thold / --defrag-thold, and moves the NextN API into llama.h.
  • New features include OCP FP8 KV caches, a host-memory MoE expert cache, Kimi-K3.1-Pro / Ripple / xing4_0 support, drama-3 TTS, and a hardened llama-server with a new /v1/audio/speech endpoint.
  • No speed or memory figures are published in the announcement or release notes.

Conclusion

llama.cpp 1.0.0 is not the most exciting release of the year, and that is exactly why it matters. Local AI runs on infrastructure, and infrastructure earns trust by changing predictably. By adopting semantic versioning, cleaning out 35 deprecated functions before the promise takes effect, and shipping real improvements to memory, model support and server security in the same release, the ggml-org team has given developers a foundation they can plan around. The next test is the release after this one: when the team next needs to break the public API, will it really wait for v2.0.0? If it does, the version number will have earned its meaning — the same steady-foundation lesson behind the claude-seo plugin.

Sources

Comments