Coding & agentsggml-org / Hugging Face

llama.cpp 1.0: check API and ABI before upgrading

The November 13 llama.cpp and ggml releases introduce explicit library compatibility boundaries. For an existing integration, review removed APIs, keep headers and binaries aligned, and check RPC peers before changing the deployed build.

A moss-green coding orc measures a copper connector with a caliper beside a lavender port and a small cream ceramic llama.
Conceptual illustration.

The compatibility promise has a defined boundary

On November 13, ggml-org announced version 1.0.0 of the libllama and libggml libraries. The team says API and ABI incompatibilities will be reflected in major-version changes. Its published versioning table assigns a major bump to breaking changes in the public C API under ./include, a minor bump to backward-compatible additions and a patch bump to fixes without API changes.

For a developer maintaining an integration, API is the source-level interface used by the calling code; ABI is the binary interface between compiled components. The announcement gives those library boundaries a clearer version signal. It does not establish that every command-line option, server endpoint, internal header or downstream language binding has the same compatibility contract. Check which interface your application actually depends on.

Start with the APIs your binding calls

The llama.cpp v1.0.0 notes explicitly remove deprecated public APIs. Named changes include removal of llama_set_warmup and a rename from llama_set_embd_state_src to llama_set_ctx_state_src; the NextN/speculative API moves into llama.h. The release therefore needs a source migration review even though the new versioning policy is intended to make future compatibility boundaries clearer.

Build a small inventory of the functions, structures and headers your wrapper uses, including generated foreign-function bindings. Search that inventory against the pinned release notes and public headers before updating a package lock. If a binding vendors an older snapshot, establish which library version it supports rather than assuming that a new underlying shared library can be substituted safely.

Make headers, libraries and build options agree

Pinning a source tag is only one part of a reproducible package. A build can compile against one header set and then load a different shared library at runtime. Record the actual library files included in the application or resolved by its loader, alongside the target platform, compiler and enabled backends. These are deployment checks suggested by Codorc, rather than additional guarantees from the release announcement.

The tag-pinned build guide is a useful starting point for the backend you use. Rebuild the calling code and its binding against the intended dependency set, then run the packaged application in a clean environment. Keep a known working package available while checking model loading, context creation, generation and shutdown. Version numbers do not establish matching behavior across operating systems, drivers, models or quantization formats.

Coordinate RPC upgrades when you use remote backends

The ggml v1.0.0 notes remove legacy DIAG_MASK_INF and DIAG_MASK_ZERO operations and describe the RPC protocol moving to v9, with incompatible peers rejected. If your deployment uses RPC, check client and server protocol compatibility together. A local inference smoke test does not exercise that remote path. Plan a bounded peer-upgrade trial and retain a compatible rollback set; this is not a claim that every peer must share an identical patch version.

Keep a migration record you can reproduce

The following checks turn a version change into a reviewable integration trial. We have not executed them against these releases, and they are not a performance ranking:

  • Record the exact release or commit, wrapper version, public headers, build flags and packaged library files. Keep a checksum of the model artifact used for comparison.
  • Rebuild a minimal caller that exercises the public functions and structures your application uses. Include error and cleanup paths, not only a successful generation.
  • Run the packaged application on each supported platform and backend. Check the library that actually loads, model initialization, output handling and resource cleanup.
  • For RPC deployments, record both peers and their protocol versions. Exercise a compatible connection and a deliberately incompatible test pair without involving a production workload.
  • Compare the same model, prompts, context settings and task acceptance checks. Record load time, generation time, memory use and failures rather than attributing every change to the version number.
  • Define a rollback condition before rollout. Retain the previous compatible application, binding and library package so a failed upgrade does not require reconstructing it from an unpinned build.

Measure the result in the application you ship

The release notes also describe backend and model-support changes, but those lists do not establish a speed or quality gain for your workload. Treat support claims as maintainers’ statements until you test the relevant hardware and package. A useful upgrade decision combines the documented compatibility boundary with observed application behavior; it should not rely on the 1.0 label alone.

Event dates refer to the original announcement. Publication dates show when this article first appeared on Codorc.

Continue reading

All stories
A moss-green coding orc selects one copper-handled screwdriver from a lavender tool pegboard beside a closed plum tool chest with a copper latch.
Coding & agentsGoogle / Introducing Tool Retrieval in the Gemini API

Gemini Tool Retrieval: check the boundary between discovery and execution

Google introduced Tool Retrieval in preview on November 19. The Gemini Interactions API can load tool schemas on demand, but developers still need to distinguish discovery, execution, authorization and the full cost of a completed task.

A moss-green coding orc adjusts a copper control wired to lavender repository tiles while a separate glass scanning head rests unlit on a wooden arm.
Coding & agentsGitHub

GitHub AI Scan API: enablement is not a completed scan

GitHub’s November 13 update adds repository_scan controls to its AI Scan REST API. Teams can manage rollout settings in code, but policy inheritance, failed combined updates and manual scans still need separate checks.

A small moss-green workshop robot fits lavender interface components into a brass window frame beside organized component trays.
Coding & agentsGoogle Developers

A2UI 1.0: check renderer support before migrating

Google announced A2UI’s first stable protocol on November 11. For developers, the useful next step is a version-by-version integration check: a stable protocol does not mean every renderer or host has completed its upgrade.