On November 13, 2026, ggml-org released v1.0.0 of llama.cpp, an inference engine for running AI models locally, and of ggml, the library that handles its tensor operations. It is the first major release for both projects. They have also adopted a policy of bumping the major version whenever a change breaks compatibility in the public C API or ABI. The update removes legacy functions such as the older model-loading function from the C side, yet the Python bindings still expose functions with the same names. Some of those functions carry on the old behavior, while others now only emit a warning, so what you need to check when updating depends on your language and how you obtain the software.

AD

Compatibility of the public C API and ABI is now tracked through version numbers

ggml-org applies semantic versioning to the public C interfaces of libllama and libggml. The public C API, which defines function names, argument types and the like, is specified in the public header files in each library's include/ directory. The ABI, which determines compatibility between compiled applications and libraries, also covers function symbol names and the memory layout of structs. As a result, even if the same function can be called at the source level, a change in a struct's field layout may mean a prebuilt application cannot use a new shared library as is.

Under the new policy, the major version is bumped when a change breaks public C API or ABI compatibility. New features, backends, supported models and API additions that preserve existing compatibility go into a minor version, and bug fixes that do not change the API go into a patch version. This makes it easier for application developers to tell from a release's version number whether an update needs a compatibility check.

v1.0.0 removes several functions that had been deprecated. For example, llama_load_model_from_file, which loads a model file, was deprecated as of v0.9.0, and its replacement, llama_model_load_from_file, had already been introduced. The public header in v1.0.0 keeps only the new function name. In the pull request covering the migration, the removals included 35 functions that llama.h had marked as deprecated, as well as llama_set_warmup, used for warmup.

The defrag_thold field was removed from the struct that holds inference-time settings, and the corresponding command-line option --defrag-thold was discontinued. If you redefine the C structs in another language such as Python, you need to update the struct field definitions to the new specification, not just the function names.

The public API also gains new functions. One group relates to speculative decoding such as NextN. Speculative decoding speeds up generation by having the actual model verify candidate tokens produced in advance and adopting the approved ones. Some of the functions that handle passing state for this process have now moved from the internal header llama-ext.h to the public header llama.h. Along with this, llama_set_embd_state_src has been renamed llama_set_ctx_state_src.

ggml is distributed differently in release and development builds

When publishing a release, ggml-org now makes the ggml source bundled with llama.cpp match the published ggml release. llama.cpp v1.0.0 incorporates ggml v1.0.0, so the two versions are aligned.

Development builds generated from the master branch, whose numbers begin with b, continue to be offered. The ggml bundled with these may differ from the release version. For developers who distribute llama.cpp linked against an external ggml library, the release tag serves as the reference for keeping the source code of the two projects at matching versions.

The difference in distribution methods also shows up in package managers. In Homebrew's package information, the stable version of llama.cpp is 1.0.0 and ggml is listed as a dependency. In the build configuration, BUILD_SHARED_LIBS, which produces shared libraries, and LLAMA_USE_SYSTEM_GGML, which uses the ggml installed on the system, are enabled, while settings for development builds are disabled in the stable version.

ggml-org also cites Winget as an example of distributing development builds together with the bundled ggml. In other words, the ggml that llama.cpp actually uses depends on the distribution method. With a bundled setup, the code included in the distributed build is used, while in a configuration like Homebrew's, the ggml from a separate package specified by the distributor as a dependency is used.

AD

In the Python bindings, compatibility differs by legacy function

When using llama.cpp from Python, you need to distinguish between the version of the Python package itself and the version of llama.cpp vendored inside it.

llama-cpp-python v0.3.37, tagged on November 15, points vendor/llama.cpp at commit a956a852c. According to GitHub's commit comparison, this code corresponds to llama.cpp v1.0.0 plus 28 further commits.

In the llama_cpp.py from the pull request that brought in this commit, the handling of the legacy functions removed on the C side varies. For example, llama_load_model_from_file remains on the Python side; it emits a deprecation warning and then passes its arguments to the new llama_model_load_from_file to do the work. Even if you keep using the old function name, the model is still loaded.

llama_set_warmup, by contrast, was changed into a function that only emits a warning. Previously, this function was used to configure the warmup process that preloads model weights during decoding. Calling the same-named function left on the Python side, however, no longer passes the warmup setting to the inference engine. So even if importing an old function name succeeds after updating the package, the same processing as before is not necessarily carried out.

On the Python side as well, defrag_thold has been removed from the ctypes definition corresponding to the C struct. The NextN-related bindings were also updated to match the definitions in the new public header.

For the HTTP server, mind the authentication requirements and new features

Applications that use llama-server over HTTP send requests to endpoints such as the OpenAI-compatible /v1/chat/completions. In this setup, the C library that runs inference is built into the server, so the points of contact with the client are the server's URL and each endpoint's specification.

v1.0.0 also adds a new /v1/audio/speech endpoint for speech generation. Using it, however, requires loading a compatible speech model into the server.

The server's startup conditions have changed as well. In v1.0.0, when llama-server is bound to a non-loopback network address and any of the built-in tools, an MCP server, or the MCP proxy for the web UI is enabled, either an API key or the --allow-unauthenticated-tools flag is required. If neither is specified, the server refuses to start.

Specifying --allow-unauthenticated-tools lets the server start without an API key, but the developers advise using it only on trusted networks. If you use the tool features from another device on your LAN, check the startup requirements after updating.

When accessing the server from a browser, CORS settings also come into play. The localhost setting that restricts access to the same origin also checks the port number, so even on the same PC, a frontend and server on different ports are treated as different origins. In that case, you need to list the frontend's origin explicitly in --cors-origins.

Inference-related settings have also been expanded. For the KV cache, which holds information about past tokens, the 8-bit floating-point format f8_e4m3 can now be specified for both keys and values. The KV cache stores the keys and values the attention mechanism uses to refer to past tokens, and its data format affects memory usage and inference processing.

For MoE (Mixture of Experts) models, which switch among multiple experts, a new setting has been added to the feature that caches expert weights placed on the CPU in GPU memory. In v1.0.0, when the GPU cache is full and the required weights are not in it, you can specify the share of work computed on the CPU instead of transferring the weights to the GPU. This lets you balance the amount of data transferred to the GPU against the computational load on the CPU.

When evaluating the effect of the update, it is effective to first confirm that your existing launch commands still provide the features you need, and then compare cache settings using the same model, hardware and context length. This makes it easier to separate problems caused by changes in connection or startup conditions from effects on memory consumption, generation speed and output results.