llama.cpp and ggml reached library version 1.0.0 on November 13, 2026. For teams building local AI applications, the useful change is a clearer compatibility contract, not a promise that every upgrade is risk-free or that a model suddenly runs faster.
The maintainers say API and ABI incompatibilities will receive major-version bumps. Their versioning table scopes breaking changes to the public C API in the include directory; compatible additions, model support and backend updates receive minor bumps, while fixes without API changes receive patch bumps. That gives downstream developers a more meaningful signal when deciding which update deserves migration work.
What version 1.0 does and does not guarantee
API compatibility concerns how software calls a library. ABI compatibility concerns the binary interface between compiled components. A version number helps you organize those expectations, but it does not certify your complete application, model, hardware backend or operating environment.
Our recommendation is to separate three decisions: whether to adopt the new library release, whether to change a model, and whether to change serving configuration. Combining them in one rollout makes it harder to identify why quality, latency or memory use changed.
Concrete migration items in the release notes
The official v1.0.0 notes list removal of 35 deprecated functions, llama_set_warmup, defrag_thold and the --defrag-thold option. They also move the NextN API from llama-ext.h into llama.h and rename llama_set_embd_state_src to llama_set_ctx_state_src.
The same release adds moe_cache_size and moe_cache_cpu_share to context parameters. It includes server hardening involving SSRF, CORS, DNS rebinding and MCP tool cancellation. These are selected release items, not a complete migration map or a claim that every previous deployment was vulnerable.
A successful rebuild is only the first check. If an application wraps these libraries through another language, test the wrapper and its generated bindings too. A wrapper can lag a library release or encode assumptions about structures that your application never references directly.
A migration checklist for a real deployment
- Record the working baseline. Capture library revision, wrapper version, model file and quantization, operating system, backend, build flags and serving configuration. Save a reproducible configuration rather than just a screenshot of throughput.
- Inspect your actual dependency boundary. Determine whether you compile against public headers, load shared libraries, call a server API or consume a packaged application. Those paths have different owners and failure modes.
- Search for removed interfaces. Check your code, generated bindings and launch scripts against the release notes. Make a narrow migration branch; do not rewrite unrelated application behavior while upgrading.
- Keep the model fixed initially. Compare the new runtime using the same model, quantization, prompts and representative requests. Introduce new architectures or cache settings as separate experiments.
- Exercise failure paths. Include cancellation, malformed requests, long inputs, concurrent work and restarting during a request. Test access boundaries in the environment you will actually operate.
- Retain a usable rollback. Keep the previous artifact and configuration together. Define a rollback trigger based on errors or user outcomes, not an arbitrary desire to remain on the newest release.
Measure accepted work, not only tokens per second
For a hypothetical document-extraction application, start with a fixed, permissioned set of documents and expected fields. Count correct outputs, malformed outputs, retries and human corrections. Also measure time to first output, end-to-end latency and peak memory under the concurrency you expect.
For example, imagine two configurations each complete 100 requests. One returns 92 usable results and the other 98. If their total operating costs are equal, the second has a lower cost per usable result even if its token throughput is lower. Conversely, a fast configuration that needs frequent manual correction may be a poor business choice. This is an illustrative evaluation method, not a Nerova benchmark or a reported llama.cpp performance result.
Use repeated runs and representative task types rather than one favorable prompt. Keep warm and cold starts separate. Treat a difference smaller than your run-to-run variation as inconclusive until more evidence is available.
Local inference is not automatically a private application
Keeping inference on your own machine can reduce one external data path, but privacy still depends on the surrounding system. Inventory logging, crash reports, model downloads, remote tools and any network-enabled connectors. Check model licenses and data retention separately from the runtime license.
Do not expose a local server publicly merely to make an integration convenient. Review authentication, network boundaries and allowed tool operations before expanding access. A release that includes hardening work does not remove those responsibilities.
Who should act now?
Maintainers of bindings and applications that compile against the public library interfaces have the clearest immediate reason to assess migration. Teams using a packaged local-AI product should first check what runtime version that product actually includes, rather than replacing its bundled components blindly.
For a business evaluating automation, choose the runtime after defining the task and acceptable quality, latency, cost and operating burden. Nerova's operational-improvement projects start from that outcome rather than treating a new release as a reason to automate everything.
This guide was published November 15, following the November 13 release. It is based on maintainer documentation and original rollout recommendations; we have not benchmarked this release or certified a Nerova integration.