DIRTY STATIC / DISPATCH Tools15 NOV 2026 • 10 MIN READ
A concrete foundation slab carrying laptops, phones, and a small server, each screen showing a glowing caution yellow geometric llama head, lowered by crane cables in a brutalist concrete hall with hazard stripes on the floor
ToolsINTELLIGENCE FOR THE MACHINE AGE

llama.cpp 1.0: Local Inference Reaches Stable

llama.cpp, the C and C++ engine that runs large language models on ordinary hardware, reached version 1.0.0 on November 13, 2026, together with its ggml tensor library. This profile covers what the stable line actually promises, the semantic versioning rules behind it, what the release removed and added, the server hardening and speech endpoint that shipped with it, and who should upgrade now and who should plan the move.

Start reading ↓

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 site

An 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.

Platforms
Linux, macOS, Windows, Android, and iOS; prebuilt artifacts, plus Docker, Debian, Homebrew, conda-forge, MacPorts, Winget, and XCFramework channels
Pricing
Free and open source under the MIT licence; costs are your hardware and the models you run
The GitHub repository card for ggml-org llama.cpp, described as LLM inference in C and C++, with contributor, star, and fork counts
The repository card tells the scale story on its own: a plain C and C++ inference project that a large share of the local AI world now builds on. Image: ggml-org on GitHub

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.

ChangeVersion bump
Breaking change to the public C API in the include directoryMajor
New feature, backend update, model support, or API addition that keeps compatibilityMinor
Bug fix with no API changePatch

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

■

END OF TRANSMISSION

Stay curious. Question everything.

CONTINUE THE DESCENT

MORE FROM DIRTY STATIC ↘