llama.cpp and ggml reach version 1.0.0

The Hugging Face team behind llama.cpp released version 1.0.0 of both the inference library and its underlying ggml tensor library on November 13.

The milestone comes three and a half years after the project's inception and represents the first formal compatibility contract for downstream developers.

The project has grown from a single-person experiment by Georgi Gerganov to a foundational piece of the local AI ecosystem.

More than 150 model architecture variants are now supported, and the libraries run on NVIDIA, AMD, Qualcomm, Arm, IBM, and Intel hardware through dedicated ggml backends that can be compiled as dynamic libraries and loaded at runtime.

"We believe this is the most lightweight, versatile and sensible platform for building cross-platform and private AI products," the team wrote in the release announcement.

"Every new integration means more developers depending on our library interfaces and therefore having a flexible but stable API is paramount."

The dual v1.0.0 release covers both llama.cpp (the LLM inference engine, distributed as libllama) and ggml (the machine learning tensor library underneath it, distributed as libggml).

The coordinated milestone signals that both layers of the stack are now subject to the same compatibility rules.

Semantic versioning brings API stability

The headline change in v1.0.0 is the adoption of semantic versioning for both libraries. The rules are straightforward: a MAJOR bump signals a breaking change to the public C API in the `./include` directory.

A MINOR bump means a backward-compatible feature, backend update, model support addition, or API addition. A PATCH bump covers bug fixes with no API change.

Before v1.0.0, downstream projects faced an unpredictable upgrade path. Commits that changed function signatures or removed deprecated interfaces arrived without a clear signal, forcing maintainers of desktop clients, server deployments, and language bindings to test every update against their code.

The semantic versioning contract changes that calculus: a MAJOR bump now communicates risk explicitly.

The rule applies equally to both libraries. If ggml changes its tensor operation signatures in a way that breaks existing compiled code, downstream users see a MAJOR version increment before anything breaks.

If llama.cpp adds support for a new model architecture without touching existing interfaces, it ships as a MINOR bump.

Distribution expands to package managers

The v1.0.0 release dramatically expands the ways developers can install llama.cpp. Pre-built artifacts are now available for Linux, macOS, Windows, Android, and iOS.

Distribution channels include Docker images based on Debian Linux, Homebrew for macOS and Linux, conda-forge across all three desktop platforms, MacPorts for macOS, Winget for Windows, and XCFramework for iOS and macOS.

The multi-channel approach reflects the project's growing user base, which spans hobbyists running models on consumer hardware, researchers prototyping on workstations, and enterprises deploying inference servers.

Packaging through standard package managers lowers the barrier to entry for developers who do not want to compile from source.

The team said they are actively exploring additional distribution methods and invited community discussion on new packaging and release pipelines.

More than 150 model architectures supported

llama.cpp now supports more than 150 model architecture variants, covering the vast majority of openly available large language models. The list includes all major Llama derivatives, Mistral, Qwen, DeepSeek, Phi, Gemma, Command R, Falcon, and dozens of specialized architectures.

The breadth of support makes llama.cpp the most widely compatible local inference engine available.

A developer can download an open-weight model from Hugging Face in GGUF format and run it on anything from a Raspberry Pi to a multi-GPU server without changing a single line of code.

All mainstream speculative decoding methods are also supported. Speculative decoding accelerates inference by using a small draft model to predict the main model's outputs, and llama.cpp's implementation works across the supported architecture range.

Server security hardening

The llama-server component received security fixes addressing three attack vectors. Server-side request forgery protections prevent the server from being tricked into making requests to internal network resources.

Cross-origin resource sharing configuration has been tightened to prevent unauthorized cross-origin access. DNS rebinding protections block an attack class where a malicious domain changes its DNS resolution after passing a same-origin check.

The release also restricts the HF_TOKEN environment variable to huggingface.co hosts only, preventing credential leakage if the server is pointed at a malicious endpoint.

Backend architecture and hardware support

The key to llama.cpp's hardware flexibility is ggml's backend architecture. Each backend is implemented as a dynamic library that can be compiled and loaded at runtime, allowing the same binary to target different hardware without recompilation.

The currently supported backends cover NVIDIA CUDA, AMD ROCm, Qualcomm Hexagon, Arm NEON, IBM Power, Intel oneAPI, Apple Metal, and general CPU fallbacks.

The ggml v1.0.0 release removes deprecated APIs and legacy DIAG_MASK operations, adds configurable YaRN truncation for extended context positions, and introduces FP8 support on compatible hardware.

The team also fixed an issue where scheduler inputs that were never read were still being uploaded.

CI infrastructure scales with vendor backing

To maintain code quality at a faster development pace, the project has invested heavily in CI infrastructure. Using Hugging Face's HF Buckets and HF Jobs services, the team can run comprehensive test suites across hardware from every major vendor.

NVIDIA, AMD, Qualcomm, Arm, IBM, and Intel have all contributed self-hosted runners, ensuring that every change is tested on the hardware it targets before landing on the master branch.

The CI pipeline now covers correctness, performance regression, and cross-platform compatibility checks.

"Maintaining a high quality codebase, staying in control of the architecture and understanding the implementation details will remain our top priorities," the team wrote.

"To reinforce the faster pace of development we continue to invest more and more resources in improving the CI infrastructure behind the projects."

The broader impact on local AI

The v1.0.0 release comes at a time when local AI is gaining mainstream traction.

Privacy regulations, data sovereignty requirements, and the cost of cloud API calls are driving more organizations to run models on their own hardware. llama.cpp, as the most widely deployed local inference engine, sits at the center of that shift.

The project's adoption of semantic versioning removes one of the key friction points for enterprise adoption: the risk that a routine update breaks a production deployment.

With clear MAJOR, MINOR, and PATCH signals, organizations can plan upgrade cycles instead of reacting to silent breakage.

Desktop applications built on llama.cpp, including the official Llama desktop apps for macOS and Windows shipped by Hugging Face, benefit directly from the stability contract.

So do language bindings in Python, Rust, Node.js, and Go, each of which wraps the C API that is now under semantic versioning.

What comes next

The v1.0.0 release does not freeze the API. Backward-compatible additions will continue in MINOR releases, and the project plans to keep expanding model architecture support and backend coverage.

The team said they will restrict major version bumps to genuine breaking changes, meaning downstream projects that pin to the 1.x line can expect long periods of stable compatibility.

The project's role as the de facto standard for local LLM inference means the semantic versioning contract could have outsize impact on the broader ecosystem.

Downstream applications — from desktop chat clients to enterprise deployment tools to mobile apps — now have a predictable upgrade path instead of gambling on each commit.

Common questions

What does llama.cpp v1.0.0 mean for developers?

It introduces semantic versioning rules for both llama.cpp (libllama) and ggml (libggml). A MAJOR version bump signals breaking changes to the public C API, MINOR means backward-compatible additions, and PATCH covers bug fixes.

Downstream projects can now plan upgrades with clear compatibility expectations.

What hardware does llama.cpp v1.0.0 support?

Through dedicated ggml backends compiled as dynamic libraries, llama.cpp runs on NVIDIA, AMD, Qualcomm, Arm, IBM, and Intel hardware.

The project reports expanded CI infrastructure using self-hosted runners across all major platforms, supported by NVIDIA, AMD, Qualcomm, Arm, IBM, and Intel.

What security fixes are in the v1.0.0 release?

The llama-server component addresses server-side request forgery, cross-origin resource sharing misconfiguration, and DNS-rebinding issues. The release also restricts HF_TOKEN to huggingface.co hosts only.

Sources & further reading

  1. Hugging Face - llama.cpp v1.0.0 : A stronger foundation for the local AI ecosystem ↗
  2. Unite.AI - Llama.cpp V1.0.0 Sets API Stability Rules for Local AI Tools ↗
  3. dev.to - llama.cpp and ggml ship v1.0.0 — semantic versioning comes to the local AI stack ↗
How this story was made

Written by Kristian Kostov with AI assistance and checked against the linked sources. Company performance claims are attributed to the company. Analysis reflects AiLookout’s interpretation; we have not independently tested the products discussed. The cover is an AI-generated editorial illustration, not a photograph or evidence of an actual event.

Our editorial standards
Back to all stories