TRENDING
A black manual telephone switchboard with rows of orange jacks and red patch cords plugged into the lower row, above a rotary dial and a handset
November 16, 2026
How to Route Alerts in Alertmanager So Pages Reach the On-Call and Tickets Reach the Queue, and Test Grouping, Inhibition, and Silences Before an Outage Does
A brass nail with a threaded screw section lying on graph paper, a fastener that is both nail and screw
November 16, 2026
Ai2’s XYBench Turns the XY Problem Into a Benchmark, but the Model That Drafted Every Rubric Also Judges the Answers, the Human Baseline Is Graded on Rubrics Read Off Its Own Answers, and the Emphasis Judge Disagrees With the Annotators on 20 to 26 Percent of Validation Responses
An amber warning beacon on a white surface, a flashing-light stand-in for the FBI’s FLASH alert
November 16, 2026
The FBI’s ARTEX Warning Says a Supply Chain Compromise “Enabled Access” to 2,250 Tenants Where Microsoft Counted Sign-In Attempts and Cites “Over 1,600” Consoles Where Censys Counted 1,465, and a Microsoft Post It Cites Mistypes One Indicator in Its Hunting Query
Two eggs and a colour-changing egg timer in a saucepan of water on an induction hob
November 16, 2026
How to Set gRPC Deadlines and Retries in Python, Pass Them Down a Call Chain, and Stop Retries From Charging a Card Twice
A whole lemon and a halved lemon side by side on a black background
November 16, 2026
IBM’s LLMON Turns Prompt-Injection Defense Into a Token Layout, but the “Nearly Zero” Chart Is One Benchmark, the Paper’s Own Red Team Lets 15% to 20% of Indirect Attacks Through, and the Shipped Template Lets a Document Type the Delimiters
16 Nov 2026
SXZ.io SXZ.io
  • Home
Search the Site
Popular Searches:
Technology Amazon AI
Recent Posts
A manual paper cutter with a wooden grid board, a clear plastic guard and a long cutting arm, a picture of text being trimmed to fit
How to Stop Ollama From Silently Cutting Your Prompt, Find the Real Context Window, and Set num_ctx Without Running Out of Memory
November 16, 2026
A brown llama and her gray cria walking across a salt flat beside a red lake in Bolivia
llama.cpp’s v1.0.0 Promises Major Bumps for API and ABI Breaks, but Its Rule Table Lists Only the C API, libmtmd Shares the Version While Its Header Warns of Breaking Changes, and the Release Page Carries a 7-Byte Pointer to a Nightly Build Instead of Binaries
November 16, 2026
A stack of chocolate chip cookies on a white plate beside a cup of tea
NoisyTCP Can Crash a Linux Server Over the Network, but the Fix Has Reached Only Three of the Seven Kernel Lines Still Being Released, Red Hat and Ubuntu Have No Update, and the Researcher’s Own Timings Run From 5 Seconds to 14 Hours
November 16, 2026
SXZ.io SXZ.io
  • Home

Categories

Articles 302 Posts
News 307 Posts
Learning Hub 274 Posts
Home/Articles/llama.cpp’s v1.0.0 Promises Major Bumps for API and ABI Breaks, but Its Rule Table Lists Only the C API, libmtmd Shares the Version While Its Header Warns of Breaking Changes, and the Release Page Carries a 7-Byte Pointer to a Nightly Build Instead of Binaries
Articles

llama.cpp’s v1.0.0 Promises Major Bumps for API and ABI Breaks, but Its Rule Table Lists Only the C API, libmtmd Shares the Version While Its Header Warns of Breaking Changes, and the Release Page Carries a 7-Byte Pointer to a Nightly Build Instead of Binaries

A repository audit of llama.cpp v1.0.0: its 36 removed functions were all deprecated and its bundled ggml matches in 13 of 13 releases, but struct sizes, libmtmd and the release artifacts sit outside...

November 16, 2026 19 Min Read
8

On November 13, the llama.cpp team published llama.cpp v1.0.0 on the Hugging Face blog, under the subtitle “A stronger foundation for the local AI ecosystem.” The post, by Daniel Bevenius, Georgi Gerganov and merve, announces that the project’s two libraries, libllama and libggml, are now at version 1.0.0, and it makes a compatibility promise: “Moving forward, both llama.cpp and ggml will reflect API and ABI incompatibilities with major-version bumps.” It supports the promise with a three-row rule table, an eight-channel distribution table, a claim of “more than 150 architecture variants,” and one paragraph on how the team uses LLMs in development.

Table Of Content

  • The promise is one sentence and one table
  • Four statements of scope
  • What v1.0.0 removed, and why that part holds up
  • What moved inside the releases before it
  • Where “API and ABI” becomes “C API”
  • libmtmd: the same SOVERSION, a different promise
  • The release page has no binaries
  • The guarantee that holds: the bundled ggml is the released ggml
  • Two smaller claims
  • “More than 150 architecture variants”
  • The development paragraph
  • What I could not check
  • What to do with this
  • Sources

A promise like that can be checked, because everything behind it is public. I read the post, the GitHub release notes, the repository’s docs/release.md, its CMake files and the maintainers’ versioning thread. Then I read the public headers of all 13 semantic-version tags, from v0.1.0 on August 17 to v1.0.0 on November 13, with a short script; compiled each tag’s own headers to read the size of its parameter structs; compared the ggml copy inside each tag with the ggml release it names; and asked each distribution channel in the post’s table what it serves today. This article was researched with a Claude model, so I checked each number against the repository or the channel itself instead of against what I expected to find. Every figure that comes from a script can be rerun from the code blocks below.

Here is what I found:

  • The removals were announced in advance. v1.0.0 removes 36 functions from llama.h, and every one of them was already declared with DEPRECATED( at v0.9.0. Thirty-five were marked by build b6000 on July 27, 2025, more than 15 months before the tag. The release notes’ “llama_set_warmup, 35 deprecated functions” adds up to 36, which matches.
  • The ggml guarantee holds. The thread says release tags are cut only when the bundled ggml copy is identical to the released one. In all 13 tags, the include, src and cmake trees and CMakeLists.txt have the same hashes as the ggml release named in the tag’s own CMake file.
  • The prose says API and ABI; the table says C API. By-value parameter structs grew in 3 of the 12 version steps: llama_model_params and llama_model_quantize_params in v0.4.0, llama_context_params and llama_perf_context_data in v0.7.0, and llama_context_params again in v1.0.0 (168 to 176 bytes). The table’s MINOR row says “API addition,” and nothing in it mentions struct growth or enum insertion. A ggml minor release also inserted an op in the middle of an enum.
  • libmtmd shares the version, not the promise. CMake gives the multimodal library the same SOVERSION as libllama and installs its two headers, while mtmd.h warns that its API “is experimental and subject to many BREAKING CHANGES.” A struct in mtmd-helper.h was replaced on master the day after the tag.
  • The v1.0.0 release page has no binaries. Its only asset is a 7-byte nightly-tag.txt that reads b12359. Of the eight channels in the post’s table, Homebrew and MacPorts serve 1.0.0 on November 16, Debian serves 0.9.0, conda-forge and winget serve build numbers (12418 and b12395), and Docker has version-tagged images for three releases, with the v1.0.0 tags carrying a build number and a commit hash too.
  • The “Development” paragraph is one paragraph; the commit log has numbers. 65 of the 248 non-merge commits since v0.9.0, or 26.2 percent, carry an Assisted-by trailer, as do 395 of 1,895 since v0.1.0.

None of this makes the promise empty. The removals followed a long deprecation path, the bundled-ggml guarantee holds in every release, and a Debian maintainer reports that the ggml major-version upgrade worked well. What the evidence shows is a promise whose text is narrower than its sentence: it defines breakage by the C functions in one folder, while the history shows parameter structs, enums and the multimodal library moving in 0.x releases, and several channels in the post’s own table carry a build number instead of the version.

The promise is one sentence and one table

The sentence is the one quoted above. The table follows under the heading “Semantic version update rules,” and the post introduces it with “The following 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 post lists the public headers as llama.cpp/include/ for libllama and ggml/include/ for libggml. At v1.0.0 the first folder holds llama.h and llama-cpp.h, and the second holds 22 headers, among them ggml.h, gguf.h and one for most backends. The Semantic Versioning specification, which the post links, says “Version 1.0.0 defines the public API” and “Software using Semantic Versioning MUST declare a public API.” In this project that declaration lives in four places, and they do not say the same thing.

Four statements of scope

Where What it says is covered
The Hugging Face post A breaking change to the C API in ./include. libllama’s headers are llama.cpp/include/ and libggml’s are ggml/include/. libmtmd is not listed.
docs/release.md at v1.0.0 “Breaking change to the public C API (include/llama.h)” is MAJOR.
The versioning thread, August 10 Georgi Gerganov: “we can have a single semantic version that tracks both libllama and libmtmd,” so that “Changes in either API results in version update.” About llama-ext.h: “The llama-ext.h is not public.”
CMake at v1.0.0 libllama, libmtmd and the ggml libraries all take their SOVERSION from their major version, and the package config files use SameMajorVersion.

Two things sit outside every one of those statements. The first is llama-server’s REST API. The thread’s August 7 draft from ngxson proposed that only breaking changes to the inference endpoints (completions, embeddings) count as major, with router, tools and CORS-proxy changes as patches; the published table drops the server entirely. The second is the command line. The release notes file the removal of --defrag-thold, a new /v1/audio/speech endpoint and changes to mtmd.h under the heading “API changes,” and the table does not say what a removed flag or endpoint costs in version terms.

What v1.0.0 removed, and why that part holds up

The release notes open by saying v1.0.0 “removes the deprecated public API and promotes the NextN/speculative API to llama.h,” and the first API bullet reads “remove llama_set_warmup, 35 deprecated functions, defrag_thold and --defrag-thold.” That can be checked by listing every LLAMA_API function in include/llama.h at each ref. The script below does it in under 50 lines of standard-library Python, and it reads the header with git show from a blobless clone, so nothing but commit metadata and the headers is downloaded.

# apidiff.py: which public llama.h functions appear or disappear from one git ref to the next
#   python apidiff.py REPO REF1 REF2 ...                    chain: compare each ref with the one before it
#   python apidiff.py REPO --track OLD NEW REF1 REF2 ...    take the functions OLD has and NEW lacks, and count how many
#                                                          were already declared with DEPRECATED( at each REF
import re
import subprocess
import sys
import textwrap

repo, args = sys.argv[1], sys.argv[2:]


def api(ref):
    text = subprocess.run(["git", "-C", repo, "show", f"{ref}:include/llama.h"],
                          capture_output=True, text=True, check=True).stdout
    text = re.sub(r"/\*.*?\*/|//[^\n]*", "", text, flags=re.S)  # drop comments
    text = re.sub(r"^[ \t]*#.*$", "", text, flags=re.M)         # drop preprocessor lines
    found = {}
    pattern = r"(DEPRECATED\(\s*)?LLAMA_API\s+(DEPRECATED\s*\(\s*)?[^;]*?\b(\w+)\s*\("
    for m in re.finditer(pattern, text):
        found[m.group(3)] = bool(m.group(1) or m.group(2))  # True = declared with DEPRECATED(...)
    return found


if args[0] == "--track":
    old, new, refs = args[1], args[2], args[3:]
    gone = set(api(old)) - set(api(new))
    print(f"{len(gone)} functions are in {old} and not in {new}")
    for ref in refs:
        a = api(ref)
        here = gone & set(a)
        print(f"{ref:<8} declares {len(here):>2} of them, {sum(a[n] for n in here):>2} marked DEPRECATED")
    sys.exit()

prev = api(args[0])
print(f"{args[0]:<8} {len(prev):>4} functions")
for ref in args[1:]:
    cur = api(ref)
    removed = sorted(set(prev) - set(cur))
    added = sorted(set(cur) - set(prev))
    was_deprecated = sum(prev[n] for n in removed)
    print(f"{ref:<8} {len(cur):>4} functions   removed {len(removed):>2} (already DEPRECATED: {was_deprecated:>2})   added {len(added):>2}")
    last_removed = removed
    prev = cur
print()
print("removed in the last step:")
print(textwrap.fill(", ".join(last_removed), width=100, initial_indent="  ", subsequent_indent="  "))
git clone --bare --filter=blob:none https://github.com/ggml-org/llama.cpp.git llama.git
python apidiff.py llama.git b4000 b6000 b9000 v0.1.0 v0.1.1 v0.1.2 v0.2.0 v0.3.0 v0.4.0 v0.4.1 v0.5.0 v0.6.0 v0.7.0 v0.8.0 v0.9.0 v1.0.0
python apidiff.py llama.git --track v0.9.0 v1.0.0 b4000 b6000 b9000 b10000 v0.9.0
b4000     166 functions
b6000     219 functions   removed 27 (already DEPRECATED:  3)   added 80
b9000     231 functions   removed 19 (already DEPRECATED: 15)   added 31
v0.1.0    240 functions   removed  0 (already DEPRECATED:  0)   added  9
v0.1.1    240 functions   removed  0 (already DEPRECATED:  0)   added  0
v0.1.2    240 functions   removed  0 (already DEPRECATED:  0)   added  0
v0.2.0    240 functions   removed  0 (already DEPRECATED:  0)   added  0
v0.3.0    240 functions   removed  0 (already DEPRECATED:  0)   added  0
v0.4.0    240 functions   removed  0 (already DEPRECATED:  0)   added  0
v0.4.1    240 functions   removed  0 (already DEPRECATED:  0)   added  0
v0.5.0    241 functions   removed  0 (already DEPRECATED:  0)   added  1
v0.6.0    255 functions   removed  0 (already DEPRECATED:  0)   added 14
v0.7.0    255 functions   removed  0 (already DEPRECATED:  0)   added  0
v0.8.0    255 functions   removed  0 (already DEPRECATED:  0)   added  0
v0.9.0    255 functions   removed  0 (already DEPRECATED:  0)   added  0
v1.0.0    237 functions   removed 36 (already DEPRECATED: 36)   added 18

removed in the last step:
  llama_add_bos_token, llama_add_eos_token, llama_copy_state_data, llama_free_model,
  llama_get_state_size, llama_load_model_from_file, llama_load_session_file, llama_n_ctx_train,
  llama_n_embd, llama_n_head, llama_n_layer, llama_n_vocab, llama_new_context_with_model,
  llama_sampler_init_grammar_lazy, llama_save_session_file, llama_set_state_data, llama_set_warmup,
  llama_token_bos, llama_token_cls, llama_token_eos, llama_token_eot, llama_token_fim_mid,
  llama_token_fim_pad, llama_token_fim_pre, llama_token_fim_rep, llama_token_fim_sep,
  llama_token_fim_suf, llama_token_get_attr, llama_token_get_score, llama_token_get_text,
  llama_token_is_control, llama_token_is_eog, llama_token_nl, llama_token_pad, llama_token_sep,
  llama_vocab_cls
36 functions are in v0.9.0 and not in v1.0.0
b4000    declares 33 of them,  5 marked DEPRECATED
b6000    declares 36 of them, 35 marked DEPRECATED
b9000    declares 36 of them, 35 marked DEPRECATED
b10000   declares 36 of them, 36 marked DEPRECATED
v0.9.0   declares 36 of them, 36 marked DEPRECATED

The chain shows three eras. Between build b4000 (October 31, 2024) and b9000 (May 1, 2026), functions left llama.h in bulk: 27 by b6000 (July 27, 2025), only 3 of them marked deprecated at b4000, and 19 more by b9000. Then the pace stopped. From b9000 to v0.9.0 on November 4 nothing was removed, and the 11 steps from v0.1.0 to v0.9.0 only added functions, 1 at v0.5.0 and 14 at v0.6.0. v1.0.0 then removed 36 in one step.

The second command takes those 36 functions and counts how many each earlier ref still declared and how many carried the deprecation wrapper: 5 of 33 at b4000, 35 of 36 at b6000, and all 36 at b10000 (July 14, 2026). The function marked last was llama_set_warmup; it was still unmarked at b9000 on May 1, 2026. So 35 of the 36 had more than 15 months of warning before the tag, and the last had at least four. A consumer who ignored compiler warnings will still be surprised, but one who read them will not.

ggml’s pruning had less notice. The notes say ggml 1.0.0 “prunes the deprecated public API and the legacy DIAG_MASK ops.” A longer parser than the one printed here finds 13 functions and 4 enum constants removed from ggml.h, among them ggml_add1, ggml_diag_mask_inf and ggml_rope_custom. Two of the 13, ggml_mul_mat_set_prec and ggml_flash_attn_ext_set_prec, were marked deprecated only in v0.4.1 on September 14, two months before removal. The next section shows the knock-on effect of removing ops from the middle of an enum.

What moved inside the releases before it

Functions are only part of an ABI. A header also defines structs that callers receive by value and enums whose numbers are baked into compiled code. llama_model_default_params(), llama_context_default_params(), llama_model_quantize_default_params() and llama_perf_context() each return a struct by value. The probe below compiles each tag’s own headers and prints the size of those four structs, plus three enum values that change when ops or types are added.

/* probe.c: sizes of the by-value parameter structs and three enum values, as one release's headers define them */
#include <stdio.h>
#include "llama.h"

int main(void) {
    printf("model=%zu context=%zu quantize=%zu perf=%zu   GGML_OP_UNARY=%d GGML_OP_COUNT=%d GGML_TYPE_COUNT=%d\n",
           sizeof(struct llama_model_params), sizeof(struct llama_context_params),
           sizeof(struct llama_model_quantize_params), sizeof(struct llama_perf_context_data),
           (int) GGML_OP_UNARY, (int) GGML_OP_COUNT, (int) GGML_TYPE_COUNT);
    return 0;
}
for t in v0.1.0 v0.1.1 v0.1.2 v0.2.0 v0.3.0 v0.4.0 v0.4.1 v0.5.0 v0.6.0 v0.7.0 v0.8.0 v0.9.0 v1.0.0; do
  mkdir -p hdr/$t && git -C llama.git archive $t include ggml/include | tar -x -C hdr/$t
  cc -w -I hdr/$t/include -I hdr/$t/ggml/include probe.c -o probe_$t
  printf "%-8s" "$t"; ./probe_$t
done
v0.1.0  model=72 context=160 quantize=56 perf=48   GGML_OP_UNARY=91 GGML_OP_COUNT=101 GGML_TYPE_COUNT=43
v0.1.1  model=72 context=160 quantize=56 perf=48   GGML_OP_UNARY=91 GGML_OP_COUNT=101 GGML_TYPE_COUNT=43
v0.1.2  model=72 context=160 quantize=56 perf=48   GGML_OP_UNARY=91 GGML_OP_COUNT=101 GGML_TYPE_COUNT=43
v0.2.0  model=72 context=160 quantize=56 perf=48   GGML_OP_UNARY=91 GGML_OP_COUNT=101 GGML_TYPE_COUNT=43
v0.3.0  model=72 context=160 quantize=56 perf=48   GGML_OP_UNARY=91 GGML_OP_COUNT=101 GGML_TYPE_COUNT=43
v0.4.0  model=80 context=160 quantize=64 perf=48   GGML_OP_UNARY=91 GGML_OP_COUNT=101 GGML_TYPE_COUNT=43
v0.4.1  model=80 context=160 quantize=64 perf=48   GGML_OP_UNARY=91 GGML_OP_COUNT=101 GGML_TYPE_COUNT=43
v0.5.0  model=80 context=160 quantize=64 perf=48   GGML_OP_UNARY=91 GGML_OP_COUNT=101 GGML_TYPE_COUNT=43
v0.6.0  model=80 context=160 quantize=64 perf=48   GGML_OP_UNARY=91 GGML_OP_COUNT=101 GGML_TYPE_COUNT=43
v0.7.0  model=80 context=168 quantize=64 perf=56   GGML_OP_UNARY=91 GGML_OP_COUNT=101 GGML_TYPE_COUNT=43
v0.8.0  model=80 context=168 quantize=64 perf=56   GGML_OP_UNARY=92 GGML_OP_COUNT=102 GGML_TYPE_COUNT=43
v0.9.0  model=80 context=168 quantize=64 perf=56   GGML_OP_UNARY=92 GGML_OP_COUNT=102 GGML_TYPE_COUNT=44
v1.0.0  model=80 context=176 quantize=64 perf=56   GGML_OP_UNARY=89 GGML_OP_COUNT=99 GGML_TYPE_COUNT=44

Any C compiler will do. The output above came from zig cc 0.17.1 targeting x86-64 Windows, run in place of cc; the sizes depend only on fixed-width types, pointers and padding, so they should agree on common 64-bit targets. One caveat before reading it: the Semantic Versioning specification says “Major version zero (0.y.z) is for initial development. Anything MAY change at any time.” None of the changes below broke a promise. They show what the new promise will have to decide.

Release (date) What moved in the public headers
v0.4.0 (September 4) llama_model_params 72 to 80 bytes; llama_model_quantize_params 56 to 64
v0.5.0 and v0.6.0 (September 23, October 5) 1 and 14 functions added; no sizes changed
v0.7.0 (October 15) llama_context_params 160 to 168; llama_perf_context_data 48 to 56
v0.8.0 (October 28) GGML_OP_UNARY 91 to 92 and GGML_OP_COUNT 101 to 102: a ggml op inserted in the middle of the enum
v0.9.0 (November 4) GGML_TYPE_COUNT 43 to 44
v1.0.0 (November 13) 36 functions removed, 18 added; llama_context_params 168 to 176; GGML_OP_UNARY 92 to 89 after three ops were removed
v0.1.1 to v0.3.0, v0.4.1 Nothing moved in these columns

Four structs changed size, in three of the 12 steps: v0.4.0, v0.7.0 and v1.0.0. The two 0.x cases removed no function and would be MINOR under the table’s wording. Each is a new field: lazy_mode and max_buf_size in v0.4.0, moe_cache_size and two counters in llama_perf_context_data in v0.7.0, and moe_cache_cpu_share in v1.0.0, which the release notes list among the “API changes.” The enum case is v0.8.0: ggml 0.28.0, bundled in that release, put a new op before GGML_OP_UNARY and moved ten later ops, plus the count, up by one.

Where “API and ABI” becomes “C API”

The post’s sentence promises major bumps for “API and ABI incompatibilities.” The table’s MAJOR row says “Breaking change to the public C API,” and its MINOR row includes “API addition.” A new field in llama_context_params is an addition to the API, but the function that fills the struct, llama_context_default_params(), returns it by value. An application compiled against the v0.9.0 headers reserves 168 bytes for that return value, and a libllama built from v1.0.0 writes 176. That is arithmetic from the sizes above and the usual C calling convention for large structs; I did not run an old binary against a new library. Whether it counts as an incompatibility is the question the table leaves open.

The maintainers have discussed it. On August 7, ngxson’s draft rules said that for the ABI “adding a new enum value will still be a breaking change.” The table the post published says only “API addition.” For enums the probe shows why it matters: a backend or application compiled against the old ggml.h and run against a library with the new numbering would read op numbers differently.

Three more things the table does not say. The header carries 10 [EXPERIMENTAL] markers, including two fields of llama_context_params, moe_cache_size and moe_cache_cpu_share, and the table does not say whether experimental parts are covered. The staging header src/llama-ext.h, which calls itself “a staging header for new llama.cpp API” where “breaking changes and C++ are allowed,” is outside the promise by location; the NextN API left it for llama.h in this release. And nothing enforces the table yet. docs/release.md says “TODO: add PR labels (semver: patch, semver: minor, semver: major) to help identify which PRs require a version bump before cutting a release,” and the root CMake file carries “# TODO: check that the current commit is tagged correctly according to the version specified above.” The first three days after the tag are consistent with the table: at commit 6b01a47, the head of master when I cloned on November 16, llama.h had gained one function and one enum and lost nothing, and llama_context_params was still 176 bytes.

libmtmd: the same SOVERSION, a different promise

The multimodal library lives in tools/mtmd/, so the post’s “./include” rule does not mention it. But tools/mtmd/CMakeLists.txt sets libmtmd’s VERSION to the llama.cpp version and its SOVERSION to the llama.cpp major version, and installs mtmd.h and mtmd-helper.h as public headers. A distribution that reads soname 1 as a compatibility statement will read it for libmtmd too. The headers say otherwise. mtmd.h opens with “WARNING: This API is experimental and subject to many BREAKING CHANGES,” and mtmd-helper.h says “Please note that these helpers are not guaranteed to be stable.”

The history agrees with the headers. In v0.8.0, mtmd_gen_inp lost its seed field in a minor release. After the tag, commit e3483e40b (“mtmd : allow custom video decoder (#32188),” November 14) replaced struct mtmd_helper_video_src with mtmd_helper_video_stream_info in mtmd-helper.h. Neither contradicts the warnings in the headers. Both sit awkwardly beside the August 10 proposal for one version across both libraries, which the CMake files implement and the post does not mention. The open question for the maintainers is whether libmtmd.so.1 and libllama.so.1 are meant to move together or to mean different things.

The release page has no binaries

GitHub’s v1.0.0 release has notes and one asset: nightly-tag.txt, 7 bytes, containing b12359. The thread explains the design. In September Georgi Gerganov wrote that “the point releases are just a semantic version tag. Each such release also points to a respective nightly build.” The tag and the nightly are the same commit, b1b770d. The nightly’s own release, b12359, is marked pre-release and carries 38 assets, from Windows and Ubuntu archives to an XCFramework zip. docs/release.md still says “Currently releases are not published to github releases, only nightly/development builds are available there,” which the v1.0.0 page, with its notes, contradicts. The same document says a default build reports itself as a development build, and distributors “must pass -DLLAMA_BUILD_IS_DEV=OFF” to get a clean version string.

So whether a user gets 1.0.0 depends on the channel. I asked each of the eight channels in the post’s table on November 16, between about 10:40 and 11:05 UTC, and a second pass at 11:01 UTC gave the same answers.

Channel (platforms in the post) What it served on November 16 How I checked
Pre-release artifacts (Linux, macOS, Windows, Android, iOS) Nightly builds, by design: b12359 for v1.0.0, and build b12432 was already tagged on November 16 GitHub release API, repository tags
Docker (Linux) Version-tagged images for three releases: v0.4.1 and v0.5.0 (24 tags each) and v1.0.0 (30 tags named like server-cuda13-v1.0.0-b12359-b1b770d); 13,412 of 13,572 tags end in a build number ghcr.io registry tag list
Debian (Linux) llama.cpp 1:0.9.0+dfsg-1 in unstable; ggml 1.0.0-1~exp3 and libggml1 in experimental ftp-master madison, snapshot.debian.org
Homebrew (macOS, Linux) llama.cpp 1.0.0, built from tag v1.0.0; ggml 1.0.0; whisper.cpp 1.9.5 revision 2, which depends on ggml and llama.cpp formulae.brew.sh API
conda-forge (Windows, macOS, Linux) llama.cpp 12418, a build number; no ggml package anaconda.org API
MacPorts (macOS) llama.cpp 1.0.0 MacPorts API
Winget (Windows) b12395, a November 15 nightly; the installers are the Vulkan zips for x64 and arm64 winget-pkgs manifests
XCFramework (iOS, macOS) llama-b12359-xcframework.zip, an asset of the nightly release GitHub release API

Three of these rows show the cost of changing a version scheme in the middle of a release stream. Debian’s llama.cpp package went from 10438+dfsg-1, a build number, to 1:0.1.2+dfsg-1~exp1; the 1: is an epoch, Debian’s way of making a smaller number sort above earlier uploads with larger ones. conda-forge is still on 12418, and by conda’s number-by-number ordering 1.0.0 would sort below it, so that channel would need an epoch as well (I did not test a conda upload). And the thread’s first post says of winget, as of August: “Publishes the nightly builds instead of the official releases (TODO: switch to official releases?)”; the b12395 manifest is consistent with that.

Two release-week problems are in the thread too. On November 14 a user asked for a Docker tag that matches the git tag, because the real one, server-cuda13-v1.0.0-b12359-b1b770d, means pulling “information from 3 different places.” A collaborator answered “The complex tag was unintentional,” and on November 16 Georgi Gerganov wrote that pull request 32388 should fix it: “in the future the tags of the docker images for each release will be simple vX.Y.Z.”

The other is Homebrew. Also on November 16, Georgi Gerganov reported “There seems to be an issue with the Homebrew packaging.” Installing the latest llama.cpp bumped ggml to v1.0.0, and “the whisper.cpp package now also links to ggml v1.0.0 even though it has not yet been updated to use ggml v1.0.0.” He asked whether “the formula has to be aware of which major ggml version the package depends on.” The Homebrew API that day lists whisper.cpp 1.9.5, revision 2, with ggml and llama.cpp as dependencies. I have no Mac to reproduce the link; the report is his, with the otool output he pasted. It is the situation a major bump exists to flag: the library name in his output, libggml.1.dylib, shows the whisper.cpp binary now sits on the new major while its source has not been updated for it. Whether the fix belongs in the formula or in a version check on the ggml side was still open when I read the thread.

Debian shows the same transition working. On November 15 a Debian maintainer wrote “the major version update worked well,” with the removed symbols visible and “the new SOVER.” He had updated the standalone ggml package, not yet llama.cpp. Because libggml0 and libggml1 can be installed side by side, “nothing breaks for current users of libggml0 until the upgrade and/or rebuild their stuff against the newer version.”

The guarantee that holds: the bundled ggml is the released ggml

The thread’s first post says llama.cpp release tags “are created on the condition that the internal ggml copy is identical to the released ggml copy,” which “guarantees that a downstream building from the release tags and linking to a system-wide ggml will be compatible.” That is testable with tree hashes: if two directories have the same Git tree hash, their contents are identical. The script reads each tag’s ggml version from its own ggml/CMakeLists.txt, finds the ggml tag with that version, and compares four paths.

# ggmlsync.py: is the ggml copy inside each llama.cpp release identical to the ggml release it names?
import re
import subprocess
import sys

llama, ggml = sys.argv[1], sys.argv[2]


def git(repo, *args):
    r = subprocess.run(["git", "-C", repo, *args], capture_output=True, text=True)
    return r.stdout.strip() if r.returncode == 0 else None


tags = [t for t in git(llama, "tag", "--list", "v*", "--sort=creatordate").split() if re.fullmatch(r"v\d+\.\d+\.\d+", t)]
pairs = [("ggml/include", "include"), ("ggml/src", "src"), ("ggml/cmake", "cmake"), ("ggml/CMakeLists.txt", "CMakeLists.txt")]
same_all = 0
for tag in tags:
    cmake = git(llama, "show", f"{tag}:ggml/CMakeLists.txt")
    ver = ".".join(re.search(rf"set\(GGML_VERSION_{k}\s+(\d+)\)", cmake).group(1) for k in ("MAJOR", "MINOR", "PATCH"))
    diffs = [lp for lp, gp in pairs if git(llama, "rev-parse", f"{tag}:{lp}") != git(ggml, "rev-parse", f"v{ver}:{gp}")]
    same_all += not diffs
    print(f"{tag:<8} bundles ggml {ver:<7}", "identical to the ggml release" if not diffs else "DIFFERS in " + ", ".join(diffs))
print(f"{same_all} of {len(tags)} releases are identical")
git clone --bare --filter=blob:none https://github.com/ggml-org/ggml.git ggml.git
python ggmlsync.py llama.git ggml.git
v0.1.0   bundles ggml 0.20.1  identical to the ggml release
v0.1.1   bundles ggml 0.20.1  identical to the ggml release
v0.1.2   bundles ggml 0.20.2  identical to the ggml release
v0.2.0   bundles ggml 0.21.0  identical to the ggml release
v0.3.0   bundles ggml 0.22.0  identical to the ggml release
v0.4.0   bundles ggml 0.23.0  identical to the ggml release
v0.4.1   bundles ggml 0.24.0  identical to the ggml release
v0.5.0   bundles ggml 0.25.1  identical to the ggml release
v0.6.0   bundles ggml 0.26.0  identical to the ggml release
v0.7.0   bundles ggml 0.27.0  identical to the ggml release
v0.8.0   bundles ggml 0.28.0  identical to the ggml release
v0.9.0   bundles ggml 0.29.0  identical to the ggml release
v1.0.0   bundles ggml 1.0.0   identical to the ggml release
13 of 13 releases are identical

All 13 releases pass. The output also shows that the two version lines are not in step: llama.cpp v0.1.0 bundles ggml 0.20.1, and v0.4.1 bundles ggml 0.24.0, so a llama.cpp patch release can carry a ggml minor release. The guarantee covers tags only. The thread says nightly builds use an internal copy that “may deviate from the official released version.”

Two smaller claims

“More than 150 architecture variants”

The post links the src/models folder for this. The name table in src/llama-arch.cpp at v1.0.0 has 173 entries, one of them the UNKNOWN placeholder, so 172 named architectures; the folder itself holds 177 files. The claim holds with room to spare.

The development paragraph

The post gives the team’s use of LLMs one paragraph, ending with “Maintaining a high quality codebase, staying in control of the architecture and understanding the implementation details will remain our top priorities.” The repository gives it two files. AGENTS.md opens with “AI-generated code is allowed,” lists as prohibited “AI-written PR descriptions, commit messages, or reviewer responses,” and tells agents that when a user explicitly asks them to commit, they should use Assisted-by: <assistant name> and “do NOT use Co-authored-by:.” CONTRIBUTING.md repeats that contributors must disclose how AI was used.

# ai_trailers.py: how many commits in a range carry an Assisted-by trailer, and which assistants they name
import collections
import re
import subprocess
import sys

repo = sys.argv[1]
for rng in sys.argv[2:]:
    log = subprocess.run(["git", "-C", repo, "log", rng, "--no-merges", "--format=%x1e%B"],
                         capture_output=True, text=True, encoding="utf-8", errors="replace").stdout
    commits = [c for c in log.split("\x1e") if c.strip()]
    names = collections.Counter()
    tagged = 0
    for c in commits:
        found = re.findall(r"^Assisted-by:\s*(.+)$", c, flags=re.M | re.I)
        if found:
            tagged += 1
            for first in {re.split(r"[\s(:]", f.strip())[0].lower() for f in found}:
                names[first] += 1
    print(f"{rng}: {tagged} of {len(commits)} non-merge commits carry Assisted-by ({100 * tagged / len(commits):.1f}%)")
    print("   assistants named (commits):", dict(names.most_common(6)))
python ai_trailers.py llama.git v0.1.0..v1.0.0 v0.9.0..v1.0.0
v0.1.0..v1.0.0: 395 of 1895 non-merge commits carry Assisted-by (20.8%)
   assistants named (commits): {'claude': 148, 'pi': 110, 'codex': 63, 'dsh': 34, 'opencode': 17, 'openai': 5}
v0.9.0..v1.0.0: 65 of 248 non-merge commits carry Assisted-by (26.2%)
   assistants named (commits): {'claude': 35, 'dsh': 15, 'codex': 14, 'glm': 1, 'gemini': 1, 'gpt-6-astra': 1}

The trailer is in wide use. A quarter of the commits in the last release window carry it. Over the whole window the trailers name Claude in 148 commits, a pi label in 110, Codex in 63 and a dsh label in 34, and the labelled ones are followed by a model path: pi:llama.cpp/Qwen3.8-27B and dsh:llama.cpp/ggml-org/Qwen3.8-Flash-Next-GGUF (MacBook, M5 Max, 128GB) are two of the strings. The count is a floor, because a commit with no trailer may still have had help. Eleven commits in the window name an AI tool in a Co-authored-by line, which AGENTS.md asks agents not to use.

What I could not check

  • I did not run an old binary against a new library, so the consequence of struct growth is arithmetic from compiler-reported sizes and the calling convention, not an observed crash.
  • I have no Mac, so the Homebrew link problem rests on the maintainer’s report and the formula API.
  • The function counts come from a regular expression over llama.h, not a C parser. Its 36 removals match the release notes, and the struct sizes come from the compiler. The longer parser behind the ggml and mtmd counts is not printed here, and I confirmed each named example by reading the headers.
  • I did not examine llama-server’s REST API, the command-line flags or ggml’s backend plugin interface, only what the post, the release notes and the thread say about the first two.
  • Channel contents are a snapshot from November 16, between about 10:40 and 11:05 UTC. The Debian listing shows suites, not upload plans, and the Docker fix the thread promises may already have landed.

What to do with this

This is my reading of the evidence, not the project’s advice.

  • To get the binaries for v1.0.0, fetch nightly-tag.txt from the release, read the build number in it, and download from that nightly release. To build from source, pass -DLLAMA_BUILD_IS_DEV=OFF, or the version string will carry a -dev suffix.
  • If you link libllama dynamically, treat a new minor version as a reason to rebuild against its headers until the maintainers write down whether struct growth counts as breaking. Always fill parameter structs from the *_default_params() functions rather than your own initializers.
  • Pin libmtmd and the llama-server flags to an exact version. Nothing in the rules covers either.
  • If you package llama.cpp, plan the version-scheme change before the major bump lands: Debian used an epoch, and Homebrew’s whisper.cpp link shows what an unversioned dependency does when the major version moves.

Sources

  • Daniel Bevenius, Georgi Gerganov and merve, llama.cpp v1.0.0: A stronger foundation for the local AI ecosystem, Hugging Face blog, November 13, 2026.
  • llama.cpp v1.0.0 release notes and its nightly-tag.txt, and the b12359 nightly release.
  • Georgi Gerganov and others, Releases and versioning of ggml-org projects, ggml discussion 1579, August 7 to November 16, 2026.
  • llama.cpp at tag v1.0.0: docs/release.md, CMakeLists.txt, tools/mtmd/CMakeLists.txt, tools/mtmd/mtmd.h, AGENTS.md and CONTRIBUTING.md.
  • Semantic Versioning 2.0.0.
  • Channel checks: Homebrew llama.cpp formula and whisper.cpp formula, conda-forge llama.cpp, MacPorts llama.cpp, Debian madison for llama.cpp, snapshot.debian.org for llama.cpp, winget-pkgs manifests for ggml.llamacpp, and the ghcr.io tag list for ggml-org/llama.cpp.
  • Earlier sxz.io coverage of AI disclosure in open-source commits: Linux retires its Assisted-by tag.

Tags:

API Designggmlllama.cppLLM InferenceLocal LLMOpen SourceSemantic Versioning

Share

A stack of chocolate chip cookies on a white plate beside a cup of tea
Previous Post

NoisyTCP Can Crash a Linux Server Over the Network, but the Fix Has Reached Only Three of the Seven Kernel Lines Still Being Released, Red Hat and Ubuntu Have No Update, and the Researcher’s Own Timings Run From 5 Seconds to 14 Hours

A manual paper cutter with a wooden grid board, a clear plastic guard and a long cutting arm, a picture of text being trimmed to fit
Next Post

How to Stop Ollama From Silently Cutting Your Prompt, Find the Real Context Window, and Set num_ctx Without Running Out of Memory

No Comment! Be the first one.

Leave a Reply Cancel reply

Your email address will not be published. Required fields are marked *

Latest
16 Nov
How to Stop Ollama From Silently Cutting Your Prompt, Find the Real Context Window, and Set num_ctx Without Running Out of Memory
16 Nov
llama.cpp’s v1.0.0 Promises Major Bumps for API and ABI Breaks, but Its Rule Table Lists Only the C API, libmtmd Shares the Version While Its Header Warns of Breaking Changes, and the Release Page Carries a 7-Byte Pointer to a Nightly Build Instead of Binaries
Trending
November 16, 2026
How to Stop Ollama From Silently Cutting Your Prompt, Find the Real Context Window, and Set num_ctx Without Running Out of Memory
November 16, 2026
llama.cpp’s v1.0.0 Promises Major Bumps for API and ABI Breaks, but Its Rule Table Lists Only the C API, libmtmd Shares the Version While Its Header Warns of Breaking Changes, and the Release Page Carries a 7-Byte Pointer to a Nightly Build Instead of Binaries
November 16, 2026
NoisyTCP Can Crash a Linux Server Over the Network, but the Fix Has Reached Only Three of the Seven Kernel Lines Still Being Released, Red Hat and Ubuntu Have No Update, and the Researcher’s Own Timings Run From 5 Seconds to 14 Hours
November 15, 2026
How to Route Alerts in Alertmanager So Pages Reach the On-Call and Tickets Reach the Queue, and Test Grouping, Inhibition, and Silences Before an Outage Does
November 15, 2026
Ai2’s XYBench Turns the XY Problem Into a Benchmark, but the Model That Drafted Every Rubric Also Judges the Answers, the Human Baseline Is Graded on Rubrics Read Off Its Own Answers, and the Emphasis Judge Disagrees With the Annotators on 20 to 26 Percent of Validation Responses
November 15, 2026
The FBI’s ARTEX Warning Says a Supply Chain Compromise “Enabled Access” to 2,250 Tenants Where Microsoft Counted Sign-In Attempts and Cites “Over 1,600” Consoles Where Censys Counted 1,465, and a Microsoft Post It Cites Mistypes One Indicator in Its Hunting Query

Related Posts

Blue-lit server racks in a modern data center, illustrating the compute infrastructure behind the AI boom.
Articles

The AI Boom Is Spending Real Money Before Proving Real Returns

June 7, 2026
Technician working with a laptop beside server racks, representing enterprise AI retrieval infrastructure
Articles

Google’s Agentic RAG Push Makes Enterprise AI Less of a One-Shot Guess

June 7, 2026
A person with a laptop and smartphone, representing digital attention and AI-assisted work
Articles

AI Chatbots Are Making Attention a Design Problem

June 7, 2026
A customer-support representative wearing a headset against a dark studio background.
Articles

The Meta AI Support Hack Was a Plain Old Authorization Failure

June 7, 2026
SXZ.io SXZ.io
  • [email protected]

Categories

Articles
Learning Hub
News

All Rights Reserved by SXZ.io ©2026