llama.cpp 1.0.0 Is Here: After Three and a Half Years, the Local AI Engine Gets Its First Stable Release
On Nov 13, 2026, llama.cpp and ggml shipped v1.0.0: 35 deprecated functions removed, the speculative-decoding API promoted, and a promise that API breaks now mean a major-version bump. Local AI finally has a stable contract.

What happened: after three and a half years, the local AI engine finally has a 1.0
On November 13, 2026, llama.cpp shipped version 1.0.0, with its underlying tensor library ggml moving to 1.0.0 at the same time. The GitHub release page tagged v1.0.0 at 10:20 UTC that day, and the official Hugging Face blog post went out at 14:05 UTC, titled "llama.cpp v1.0.0: A stronger foundation for the local AI ecosystem." The project was created on GitHub on March 10, 2023, and for three and a half years it used raw commit numbers as version strings — b1234, b12359, and the like. Today, for the first time, it carries a semantic 1.0.0.
If you have never used llama.cpp directly, you have almost certainly used it anyway. Ollama, LM Studio, and a long list of tools that run models on laptops all sit on top of it. It is an inference engine written in C and C++ that uses quantization and hardware-optimized backends to run large models on everything from consumer laptops to enterprise servers. GitHub data shows the repository had reached 134,858 stars and 25,565 forks by November 13, released under the MIT license. In other words, it is the lowest-level, hardest-to-avoid brick in the local AI world.
The 1.0.0 release notes run long — over 29,000 characters, listing well over a hundred changes. But the number of changes is not what matters most. What matters is a promise: from today on, llama.cpp and ggml will signal API and ABI incompatibilities with major-version bumps, and breaking changes will only arrive with a major version. For the past three and a half years, every upgrade for downstream developers was a lucky dip — nobody knew which interface would change or which behavior would break. Version 1.0 exists to take the lucky dip away.
Three and a half years of commit numbers: why 1.0 took until now
To feel the weight of 1.0, it helps to look back at how those three and a half years went. llama.cpp began in March 2023 as Georgi Gerganov's project to make Meta's LLaMA models run on an ordinary laptop. Local AI was then a niche hobby inside enthusiast circles, and the project's version was simply its commit number — a "b" followed by digits, ticking upward with each batch of merged commits. Which version you had was a number; what changed between it and the previous one, and what broke, was something you had to dig out of the commit history yourself.
That worked while the project was small: few users, few integrations, low cost of changing an interface. But over three and a half years, things changed. Local AI grew from a niche hobby into something more and more people depend on every day, and llama.cpp's downstream grew from a handful of enthusiast projects into large-scale applications like Ollama and LM Studio, plus a long tail of smaller tools calling its C API directly. With every interface change, the blast radius got bigger; with every unannounced breaking change, a wave of repair work rippled downstream. The official blog puts it plainly: precisely because more people depend on it, having a flexible but stable API has become paramount.
There is also an organizational reason 1.0 took until now: the project is now maintained by the ggml-org team at Hugging Face. The blog describes the preparation behind 1.0: expanding continuous-integration infrastructure with HF Buckets and HF Jobs so that every change landing on the master branch is verified correct, and enrolling more self-hosted test runners across all major hardware platforms with support from NVIDIA, AMD, Qualcomm, Arm, IBM, and Intel. A foundation project can only promise "we will not move the interfaces lightly" if it can guarantee that each change does not crack the foundation — and test infrastructure is what backs that promise.
So 1.0 is not a marketing move; it is the natural result of organizational capability arriving first. The project grew up, the downstream got bigger, the testing caught up — and only then did the version change from commit numbers to semantic versioning. That order is itself worth noting. Many projects shout "1.0" first and fill in the capability later. llama.cpp did it the other way around: capability first, 1.0 second.
What 1.0 actually changes: the point is the contract, not performance
Start with the versioning rules themselves, because they are the soul of the whole announcement. The official blog gives a very simple table: MAJOR goes up in exactly one situation — a breaking change to the public C API (the headers under ./include). MINOR covers backward-compatible features, backend updates, model support, or API additions. PATCH fixes bugs with no API change. Three lines, but they answer a question that has troubled downstream developers for three years: if I upgrade to the next version, will something quietly break? From today, the answer is written in the version number — as long as the major version has not changed, the public API should not break.
Version 1.0.0 itself is a cleanup. It removes 35 deprecated public functions, along with the warmup setter llama_set_warmup and the defragmentation threshold option defrag_thold. At the same time, it promotes the NextN speculative-decoding API from the extension header llama-ext.h into the main llama.h header. The gesture is clear: 1.0 does not stamp the old stuff as-is; it throws out what should go, promotes what should be promoted, and only then lays down the rule of "we will not move things lightly from now on."
Beyond the versioning contract, 1.0.0 packs plenty of concrete features. On the inference core: OCP FP8 KV-cache support (the f8_e4m3 type), so KV caches take up less memory; a host-memory MoE expert cache with a configurable CPU share, so loading rarely-used experts no longer leaves the CPU waiting; and support for loading external PLE/engram shards from separate GGUF files. On new model support: three new text architectures (Kimi-K3.1-Pro, the 65B Ripple preview, and xing4_0), drama-3 TTS for speech, and MageVL-Cowork plus Kimi-K3.1 vision on the multimodal side.
The server-side changes deserve their own mention. llama-server received a concentrated round of security hardening in this release: fixes for CORS configuration, DNS rebinding, SSRF through the CORS proxy, and child-instance access; HF_TOKEN is now restricted to huggingface.co hosts; MCP tool calls are cancelled and the MCP server notified when a client disconnects or times out. It also gains an OpenAI-compatible /v1/audio/speech endpoint for text-to-speech. And the built-in web UI was redesigned: chats can be grouped, there is a Markdown editor, and the mobile layout was rebuilt for native use.
Why this deserves a 1.0: it is not one person's tool, it is everyone's foundation
Why does an inference engine shipping 1.0 deserve its own article? Because of what makes llama.cpp unusual: it almost never faces end users directly, yet it decides what end users can use. The official blog says it plainly: "Every new integration means more developers depending on our library interfaces and therefore having a flexible but stable API is paramount." Over three and a half years, its dependents kept growing: Ollama packages it as a ready-to-run service, LM Studio packages it as a desktop app with a UI, and hundreds of smaller tools call its C API directly. The project says it now supports more than 150 model architecture variants, along with all mainstream speculative decoding methods.
A "foundation" project's version number is not the same kind of thing as an ordinary app's. When an ordinary app ships a major version, users at most have to relearn an interface. When a foundation project changes an interface, dozens or hundreds of downstream projects may have to change code at the same time. When llama.cpp used commit numbers as versions, it effectively hid the information "what did I change" inside the commit history — downstream developers could only discover what broke by reading changelogs, or by hitting compile errors. The meaning of 1.0 is that this information is now out in the open: the version number itself is the promise. When the major version changes, go check compatibility; when it has not changed, you can upgrade with confidence.
There is another angle: local AI is moving from "geek toy" to "everyday infrastructure." More and more people run models on their own computers, not because they enjoy tinkering, but because they want privacy, offline use, and to avoid sending their data to anyone. The Hugging Face announcement put it bluntly: users can run AI on their phones, laptops, and workstations, in control of their own intelligence, without sending data to anyone. When local AI goes from hobby to dependency, the stability of the foundation stops being a nice-to-have and becomes a necessity. Version 1.0 arrives right on time.
Before you upgrade: 1.0 is itself a breaking release
But one thing has to be said up front: 1.0.0 is not a painless upgrade. Before laying down the rule of "we will not move things lightly from now on," the maintainers moved something big — the 35 deprecated functions removed, the warmup setter and defragmentation threshold taken out, are genuine breaking changes. If your project calls any of the removed APIs directly, upgrading to 1.0.0 will fail to compile. That is not a bug; it is part of 1.0: clear out the historical baggage first, then lay down the new rules.

So before upgrading, do two things. First, open the full release notes on GitHub and check the APIs you call: whether any of the 35 removed functions are among them, and whether the NextN API's move from the extension header to the main header affects your includes. Second, do not rush it into production — compile it on a development machine first and run your tests. The promise of 1.0 is stability "from now on," not a painless "this time." The versioning table in the official blog only covers compatibility of the public C API; it promises nothing about model outputs, performance, every command-line option, or every HTTP response staying identical forever. The benefits of upgrading are real, but count the cost yourself first.
For ordinary users, this warning barely applies: the Ollama or LM Studio you use will decide for itself when to adopt 1.0.0 — you just wait for the update. But if you depend on the llama.cpp library directly, or your project embeds its C API, this upgrade is a job that needs time set aside: read the release notes first, then act.
What it means for vibe developers running models locally: your local backend just got sturdier
If you build projects with Claude Code or Cursor and like running models locally, this news concerns you directly. A common setup is to start a llama-server and treat it as a local, OpenAI-compatible backend that your tools, scripts, and agents all call. Version 1.0.0 makes that setup sturdier in three ways.
First, the interfaces are stable. Before, every script you wrote against llama-server carried a nagging question: will the next upgrade change an interface? Now the project has made an explicit promise: breaking changes to the public API only arrive with a major-version bump. Your scripts, your toolchains, and the call wrappers you wrote for your agents finally have a contract to rely on. That matters especially for vibe developers — your projects already iterate fast, and you do not want to spend time chasing a moving low-level interface.
Second, the server is safer. Version 1.0.0 fixes a batch of llama-server security issues: SSRF, CORS, DNS rebinding, and the cancellation mechanism for MCP tool calls. Exposing llama-server to a local network — or briefly to the public internet — used to be a nerve-wracking thing; after this release, the risk is considerably smaller. But note that "considerably smaller" is not "safe to expose carelessly": the fixes cover known classes of issues, and exposing a service in production still calls for authentication, a firewall, and least privilege. Do not let one security update make you relax.
Third, it can do more. The new /v1/audio/speech endpoint means your local backend can now do speech synthesis too; FP8 KV caches and the MoE expert cache mean bigger models and longer contexts fit in the same memory; and the redesigned web UI (chat groups, a Markdown editor, mobile support) means you no longer need a separate client just to poke at a model — a browser is enough. For anyone building a local AI workflow, this is an update that upgrades the backend and, as a bonus, the frontend too.
Where to start: three paths for three kinds of people
If you want to try 1.0.0 after reading this, the official paths number three, matching three different needs. The easiest: use the Llama desktop app, available for Mac and Windows — the official blog explicitly recommends llama.app. Download it, install it, open it, and run. That suits users who just want to run models locally without touching a command line. The second path is a package manager: Homebrew, Winget, conda-forge, MacPorts, Debian, and Docker are all on the official distribution list — good for developers who already maintain their environment that way, with standard flows for upgrades and removal. The third path is building from source: clone the repository, check out the v1.0.0 tag, and compile — for people who need custom backends, tuned compile options, or maximum performance on specific hardware.
The three paths are not ranked; they just fit different people. Ordinary users get the best deal from the first path, and problems are easiest to pin down there. Developers fit the second path, consistent with how they maintain their daily toolchain. Tinkerers take the third path: maximum freedom, but you own the problems too. One thing to note: the distribution table describes channels the project is "looking forward to expanding," so 1.0.0 packages may not all land on every channel on release day. If your package manager does not show 1.0.0 yet, wait a day or two, or grab the pre-built artifacts from the GitHub releases page — they cover Linux, macOS, Windows, Android, and iOS.
One easily missed point: 1.0.0 covers more platforms than many people assume. Pre-built artifacts exist for Linux, macOS, Windows, Android, and iOS, and the official blog's distribution list also includes Docker, Debian, Homebrew, conda-forge, MacPorts, Winget, and XCFramework. Local AI stopped being "a toy on a laptop" a while ago — it runs on phones, on servers, on hardware you would and would not expect. The 1.0 promise covers the public API on all of those platforms, which is part of why it dares to call itself 1.0.
Verdict: the meaning of a version number is not the number, it is the promise
Here is the verdict, in three layers. The fact layer: llama.cpp and ggml shipped 1.0.0 on November 13, 2026, removing 35 deprecated functions, promoting the NextN API, and laying down semantic versioning rules; the repository has 134,858 stars and is MIT-licensed. All of this is backed by the official blog and the GitHub release page — it is settled. The progress layer: 1.0 is a "break first, then build" update — clearing historical baggage first, promising future stability second; upgrading has a cost, but the cost is one-time and the benefit is long-term. The trend layer: local AI is moving from geek toy to everyday infrastructure, and the stability of the foundation is becoming as important as the capability of the models themselves. Version 1.0 is the marker of that shift.
For ordinary developers, the practical advice is just three lines: direct users should wait for upstream tools to adopt it — no need to act yourself. Developers who depend on the llama.cpp library directly should read the release notes first and then upgrade, and never upgrade bare in production. People running models locally can treat 1.0.0 as a checkpoint — your local backend, your call wrappers, and your security configuration are all worth reviewing as part of this upgrade. A version changing from a string of commit numbers to 1.0.0 looks like nothing more than a number changing, but behind it sits a promise: from today on, this foundation will not quietly move again. Whether that promise holds depends on whether 1.1, 1.2, and 2.0 really follow the rules — that is a question for the next verification.
One last point: the way 1.0.0 was shipped is itself a signal of how mature the local AI ecosystem has become. Three years ago, running models locally was a pastime for a handful of enthusiasts, with a scattered toolchain and documentation passed around by word of mouth. Today, a low-level inference engine ships a 1.0 with formal versioning rules, complete release notes, pre-built artifacts for many platforms, systematic test infrastructure, and a major platform maintaining it behind the scenes. That says local AI is no longer an "alternative option" — it is a serious route running parallel to cloud AI, with its own foundation, its own rules, and its own future. Version 1.0.0 is the milestone marking that route.
Comments (0)
Sources
Related articles
On 17 November 2026, Microsoft launched MAI Code 2 and Code 2 Flash: the larger model has 77 billion active parameters and a one-million-token context, averaging 63.2% across four benchmarks — close to GPT-6.1 Sol and Claude Opus 5.5 — at $0.309 per task. Read the three caveats first: promotional pricing, the lowest score of the three, and no long-horizon work.
On 11 November 2026, AWS open-sourced UAEF: adapters turn traces from LangGraph, LangChain, Strands and Bedrock AgentCore into one format, then 36 metrics across 7 dimensions score them, flagging regressions past 5%. The judge model is hardened too — scores must cite verbatim evidence, and never decide safety.
On 17 November 2026, Perplexity launched the Orchestrator API: one interface reaching OpenAI, Anthropic, Google, xAI and open-weight models such as GLM, Kimi and DeepSeek, billed at the answering model's published rate with no platform fee. When one provider fails, the same model retries on another deployment, and preview routing assigns requests to models by task.