llama.cpp hits 1.0: a milestone for running AI on your own machine

What's happening

The open-source project llama.cpp released version 1.0.0 on November 13, 2026. At the same time, ggml, the compute library llama.cpp is built on, also moved to 1.0.0. It's the first time the project has had a one in front of the decimal point. The previous numbered release, v0.9.0, only dates from November 4. The matching rolling build is b12359. You can download everything from the release page on GitHub.

The release note itself is short: "New version released" and "More info at 3 p.m. CET". It doesn't yet explain why the developers are going to 1.0 now, or whether the version number comes with any stability guarantees. The changelog since v0.9.0 is a different story, with well over 200 entries. Here's what's in it.

What llama.cpp is and why it matters

llama.cpp is a lean C++ program that lets you run language models on ordinary hardware: your laptop, your gaming PC, your Mac or even your phone. The project started in 2023. According to an NVIDIA blog post, it has no external dependencies and is very frugal with memory. Models are stored in GGUF, a file format created specifically for the project: a single file that holds the model along with all its metadata. Most of these models are quantized, meaning they've been shrunk by storing their numbers at lower precision.

Plenty of people have used llama.cpp without knowing it. According to NVIDIA, popular apps like Ollama and LM Studio are built on it, along with more than 50 other applications, including Brave's Leo AI assistant, Opera's local models and the Sourcegraph Cody coding assistant. NVIDIA has contributed optimizations of its own, such as CUDA Graphs, which batch compute steps on the GPU ahead of time so there's less idle time between them. By NVIDIA's own measurements, an RTX 4090 running Llama 3 8B managed around 150 tokens per second at the time.

New models: Kimi K3.1 Pro, Ripple and more audio

The changelog lists several new models:

• Kimi K3.1 Pro from Moonshot, as a text model and with image understanding ("Kimi K3.1 vision")
• Ripple from ricursiveai
• xing4_0, MageVL-Cowork, plus fixes for HunyuanVL, MiniCPM-V and the Qwen-VL vision modules
• Drama-3 for speech output (text-to-speech), plus a temperature setting for Pocket TTS via the API
• Streaming audio input for Gemma 4

A blog post by Japanese author YaroTech on note.com shows how long it takes for a new model to reach everyday users. He initially wrote that Ripple-65B wasn't supported yet, then had to correct himself: support had already been merged into the main branch on November 6, with Kimi K3.1 Pro following on November 7 in build b12180. Neither made it into v0.9.0. The author describes five stages of "supported": a proposal, the merge into the main branch, daily builds (the b numbers), numbered releases and, finally, updates to apps like Ollama or LM Studio. With v1.0.0, both models have now reached stage 4.

The author also puts the sizes in perspective. Kimi K3.1 Pro weighs in at about 1.56 TB in total. Unofficial GGUF files from volunteers range from 580 GB to 1.51 TB, and some are labeled "very experimental". None of that fits on a machine with 128 GB of RAM. For Ripple-65B, he used a 31 GB Q3_K_M file. His verdict on Kimi: the tools are ready, but there's nowhere to put it.

Under the hood: FP8, expert cache and new hardware

Most of the changes are about speed and hardware support:

• FP8 KV cache: The KV cache is the model's short-term memory of the conversation so far. It can now be stored in a compact 8-bit floating-point format, which saves VRAM (video memory) on long texts. OCP FP8 support on CUDA is new as well.
• MoE cache: Mixture-of-Experts models are made up of many sub-networks ("experts"), only a few of which do any work for each token. A new cache keeps frequently used experts on the GPU. If an expert isn't there, the CPU does the math instead. The eviction strategy is described as "LRFU/MQ-like" and blends how recently and how often an expert was used. A tuning script is included. This is mainly interesting if your GPU is short on memory.
• NVIDIA: Several optimizations for NVFP4 models (a 4-bit format from NVIDIA), faster matrix math at small batch sizes, CUDA 13.5 for the release builds and a fix for older Maxwell cards.
• AMD: Optimizations for RDNA3/4 on Vulkan, better BLAS memory handling on ROCm and a compute kernel for CDNA2-generation data center cards.
• Intel: A Flash Attention kernel for Vulkan during prompt processing (Flash Attention is a memory-efficient way to compute the attention mechanism), plus lots of SYCL fixes and an MoE scheduler that runs directly on the GPU.
• Mobile and exotic: Qualcomm Hexagon (Q5_0/Q5_1, Windows on ARM), Adreno graphics via OpenCL, WebGPU, SpacemiT RISC-V chips and IBM's zDNN accelerator.
• Apple: Metal fixes for out-of-bounds memory access and batched MoE computation for DeepSeek-V4/V4.1 and GLM.

There's also some housekeeping. Entries like "llama : prune", "ggml : prune" and "examples : clean-up old/obsolete stuff" suggest that old baggage was cleared out for the version bump. If you have scripts that rely on older example programs, check them.

Server and web UI: more features, better security

The built-in llama-server has long been more than a bare API. New this time is an OpenAI-compatible /v1/audio/speech endpoint for speech output. The Realtime API has been improved and now reports errors instead of crashing. Tool calls via MCP (a standard that lets AI models use external tools) are now canceled when the client disconnects.

The security fixes matter most:

• An SSRF vulnerability in the CORS proxy and in media URLs has been closed. SSRF means an attacker can trick the server into sending requests to internal addresses.
• Protection against DNS rebinding has been added. In this attack, a malicious website redirects your browser to your local server.
• Tools now have to be explicitly enabled when the server is reachable from beyond localhost.
• Your Hugging Face access token is now only sent to huggingface.co addresses.

If you run llama-server on your home network, you should update.

The web UI has picked up plenty too: you can organize chats into named groups, there's a tool for searching old chats, a Markdown editor with live preview, thumbnails for PDF attachments and a mobile interface that's meant to feel like a native app.

What didn't make it: the NUMA example

An older article on Semiconductor Engineering shows how the project sets its priorities. In it, Arm describes a patch for servers with multiple NUMA nodes, meaning groups of processors that each have their own memory. On a Neoverse N2 system, it sped up text generation by up to 55 percent (41.15 instead of 26.52 tokens per second). According to the article, the patch was reviewed but not merged because there was little interest in server and cloud scenarios. llama.cpp remains firmly focused on local use.

The bottom line

The jump to 1.0 is mostly symbolic: a project that a big chunk of the local AI world rests on apparently considers itself mature. Technically, v1.0.0 is a dense bundle of improvements rather than a radical overhaul. For users, the biggest wins are the MoE cache and FP8 KV cache for tight VRAM budgets, support for new models and the security fixes to the server.

What's still unclear is what the promised "more info" will contain: whether there will be API stability guarantees, how much the cleanup affects existing projects and how quickly Ollama and LM Studio catch up. If you want to use the new models right away, you can install llama.cpp directly. If you stick with your usual apps, you'll have to wait for their updates. And for giant models like Kimi K3.1 Pro, the same rule still applies: being supported doesn't mean it'll fit on a regular home PC.