llama.cpp and ggml both shipped v1.0.0 on November 13, 2026. The version number matters less than the contract that comes with it. Per the ggml-org announcement on the Hugging Face blog, "both llama.cpp and ggml will reflect API and ABI incompatibilities with major-version bumps." If you link against libllama in your own app, you now have a rule to pin against.

What v1.0.0 covers

Two libraries were tagged, each with its own public header directory:

Release Library Public headers
llama.cpp v1.0.0 (LLM inference in C/C++) libllama llama.cpp/include/
ggml v1.0.0 (tensor library for ML) libggml ggml/include/

The two are versioned separately. If your build links both directly, you have two compatibility surfaces to watch, not one.

The semver rules, as published

The rules apply to all ggml-org projects using semantic versioning:

Change type Bump
Breaking change to the public C API in ./include MAJOR
Backward-compatible feature, backend updates, model support, or API addition MINOR
Bug fix with no API change PATCH

The practical reading is that new model architectures and backend updates arrive as minor bumps. Only a break in the C headers forces a major. So ^1.0 style constraints, or a vendored pin at a 1.x tag, are now defensible for anything that only touches the C API.

What the rules do not say

The announcement defines the contract in terms of the public C API in ./include. It says nothing about the command-line tools, their flags, or server behaviour, and nothing about model file formats. I would not assume those carry the same guarantee. I covered a flag rename earlier in the llama.cpp MTP flag rename post, and the stated semver rules would not obviously have turned that into a major bump. If your deployment shells out to binaries rather than linking the library, keep pinning exact builds and read the release notes.

The post also says backends "can be compiled as a dynamic library and optionally loaded at runtime." If you ship backend plugins separately from the core, it does not spell out how the ABI promise applies to them. Test that combination before you mix versions.

Where you can now get it

The distribution table is the most reusable part for packaging pipelines:

Channel Platforms
Pre-release artifacts Linux, macOS, Windows, Android, iOS
Docker Linux
Debian Linux
Homebrew macOS, Linux
conda-forge Windows, macOS, Linux
MacPorts macOS
Winget Windows
XCFramework iOS, macOS

The team also points to a discussion thread for adding ggml-org projects to your own packaging and release pipelines. If you maintain a distro package or an internal artifact mirror, that is where to look.

Scale and process behind the number

The project is 3.5 years old, and the post says llama.cpp supports more than 150 architecture variants as well as all mainstream speculative decoding methods. On process, the team says it is investing in CI using HF Buckets and HF Jobs, plus self-hosted runners on hardware from NVIDIA, AMD, Qualcomm, Arm, IBM and Intel. They also say they will keep integrating LLMs into development "in a thoughtful and reasonable manner" while staying in control of the architecture. That is a statement of intent, not a measurable guarantee.

What I would do this week

  • If you embed libllama: move your pin to the v1.0.0 tag, then treat the next MAJOR as the only planned migration event.
  • If you link libggml separately: pin it independently and check both headers on upgrade.
  • If you run the CLI or server: keep exact-build pins. Nothing in the announcement promises flag stability.
  • If you package llama.cpp for others: pick up the new channels, especially the XCFramework for iOS and macOS.

One reader comment on the post asked for better prefill on very large prompts. The announcement does not address performance, so v1.0.0 is a stability milestone, not a speed one. That is the right way to read it.

Sources: