Skip to content

README.md

Latest commit

 

History

History
757 lines (567 loc) · 41 KB

README.md

File metadata and controls

757 lines (567 loc) · 41 KB

llama.cpp + TurboQuant+

Production-grade KV-cache and weight quantization for llama.cpp, with cross-backend kernel support for Apple Silicon, NVIDIA CUDA, AMD ROCm, and Vulkan.

License: MIT Status: WIP Codec papers

A fork of ggml-org/llama.cpp integrating the TurboQuant+ codec stack — Walsh-Hadamard rotated polar quantization, attention-gated sparse dequantization, and layer-aware V compression policies. The codec design, calibration, and validation papers live at TheTom/turboquant_plus; this repository is the llama.cpp runtime integration.

Lineage — why the +

TurboQuant+ is inspired by Google's original TurboQuant paper (ICLR 2026), which introduced Walsh-Hadamard-rotated polar codebook quantization for KV cache and demonstrated 4.6× compression at ~1% PPL loss. This project extends that foundation substantially — adding the asymmetric K/V policy (V is free, K is everything), layer-aware Boundary V protection, attention-gated sparse V dequantization, the TQ3_1S / TQ4_1S weight quantization formats, the turbo2 / turbo4 tier variants, the cross-backend kernel coverage (CUDA dp4a, HIP/ROCm RDNA/CDNA, Vulkan coopmat, Metal TurboFlash + V2.1 fused kernels), and a body of model-family-specific quality and operational fixes. The trailing + denotes that ongoing extension work; the original TurboQuant codec remains the foundation.

This fork is additive: every existing llama.cpp quantization, model, and backend continues to work unchanged. New types are opt-in via the standard --cache-type-k / --cache-type-v and llama-quantize interfaces.

Production deployments

This fork's TurboQuant integration is used in:

  • LocalAI — drop-in OpenAI-compatible local inference server
  • Chronara — quantum-safe fintech infrastructure with AI-driven networks
  • AtomicChat — on-device chat application
  • and other downstream projects

Status
Default branch feature/turboquant-kv-cache
Commits ahead of upstream ~300
Upstream tracking continuous sync from ggml-org/llama.cpp master
Upstream PR status not yet upstreamed; running as a long-lived feature branch

What this fork adds

Quantization types

Type Domain Approx. bits Notes Paper
TQ3_1S weights ~3.5 smaller VRAM than q8_0 weight-compression-tq4
TQ4_1S weights ~4.5 V2.1 fused Metal kernels; CUDA dp4a 3.5× faster (240 t/s vs 68 baseline) weight-compression-tq4
turbo2 KV cache ~2.0 aggressive; pair with Boundary V block-size-experiment
turbo3 KV cache ~3.5 ~4.6× compression at <1.5% PPL loss attn-rotation-and-ppl-artifact
turbo4 KV cache ~4.5 rehabilitated to beat q4_0 on fidelity turbo4-resurrection

All turbo formats use Walsh-Hadamard rotation followed by polar codebook quantization on 128-element blocks. Why this works where MSE-driven codecs fail: why-mse-fails-for-kv-quantization.

Compression policies

  • Auto-asymmetric K/V compression — recognizes that V tolerates aggressive compression while K does not; default policy picks complementary codecs rather than symmetric. asymmetric-kv-compression
  • Boundary V (experimental, layer-aware) — auto-enabled for turbo2-V. Protects layers where aggressive V quantization degrades quality, leaves the rest at full aggression. layer-aware-v-compression, moe-v-compression-frontier
  • Sparse V dequantization — skip V dequantization for positions whose softmax attention weight falls below threshold. Enabled across all Metal targets. sparse-v-dequant

Backend coverage

Backend Quant kernels Flash Attention Notes
Metal (Apple Silicon) TQ V2.1 fused, TurboFlash Yes — sparse V across the family; dk=512 FA kernels for Gemma 4 TurboFlash off by default on Apple10 (corruption regression under investigation). m5-max-stress-test
CUDA (NVIDIA) dp4a for TQ4_1S, warp-cooperative dequant (16× less compute per block), multi-token / multi-GPU Yes — turbo VEC FA (+9% decode); mixed f16/bf16 + q8_0 without GGML_CUDA_FA_ALL_QUANTS Load-time TQ4_1S → q8_0 conversion path
HIP / ROCm (AMD) Portable ggml_cuda_dp4a; scalar half path for TQ4_1S on AMD Yes — VEC FA forced for quantized KV; pool bypass for FA f16 temp buffers RDNA3 (gfx1100), RDNA4, CDNA3 (MI300X / gfx942), CDNA4 (MI355X / gfx950). cross-engine-mi300x
Vulkan TQ4_1S weights, SET_ROWS for turbo2/turbo4 coopmat flash attention with turbo3 KV Compute-shader path; nix-buildable

Model-family support

  • Gemma 4 — dk=512 Metal FA kernels, MoE token routing, op-concurrency handling
  • Large MoE — kernel instantiations for up to 256-expert routing
  • Hybrid architectures (GDN, Mamba) — speculative decoding cherry-picked from upstream feature branches
  • All existing llama.cpp model families remain fully supported

Operational fixes carried by this fork

  • CPU vec_dot heap-allocation fix for turbo / TQ types at n > 4096
  • Apple Silicon unified-memory explosion fix
  • RPC GGML_OP_COUNT assertion fix
  • Cross-vendor -Werror build fixes
  • Defensive xxd.cmake handling for missing input files

Quick start

Standard llama.cpp build flags. TurboQuant types become available automatically once the matching backend is compiled in.

# Apple Silicon (Metal)
cmake -B build -DGGML_METAL=ON && cmake --build build -j

# NVIDIA CUDA
cmake -B build -DGGML_CUDA=ON && cmake --build build -j

# AMD HIP / ROCm (multi-arch fat binary)
cmake -B build -DGGML_HIP=ON -DCMAKE_HIP_ARCHITECTURES="gfx1100;gfx942;gfx950" && cmake --build build -j

# Vulkan
cmake -B build -DGGML_VULKAN=ON && cmake --build build -j

Usage

KV-cache quantization (runtime)

KV-cache types are selected per-side via the standard --cache-type-k / --cache-type-v flags.

Start light, then compress. Some model families — small models, certain MoE configurations, quant-sensitive instruction-tuned variants — are more delicate than others. Pick a light asymmetric configuration first, verify output quality (eyeball + PPL on a hold-out set) on your specific model, then ratchet up V aggression if you have memory headroom to gain. Do not start at maximum compression and work backwards.

The core finding from the asymmetric-kv-compression paper — Asymmetric K/V Cache Compression: Why V is Free and K is Everything — drives all the configs below: V tolerates aggressive compression, K does not. Always keep K at higher precision than V; never start symmetric. That paper documents the specific failure modes you'll hit if you ignore this and compress K aggressively (PPL blow-up on certain model families, attention-rotation interaction with low-bit K, etc.) — read it before considering step 6.

Higher turbo number = more bits per element = less aggressive compression. The V-side compression ladder is turbo4 (lightest) → turbo3 → turbo2 (heaviest). On the K side, prefer f16 or q8_0; never lead with a turbo K.

Recommendations, ordered from most conservative to most aggressive:

Step --cache-type-k --cache-type-v When Notes
1. Safest start f16 turbo4 First contact with any new model K untouched, V at the lightest turbo tier. If output isn't faithful at this step, the model is unusually quant-sensitive — stop and investigate before escalating.
2. Conservative q8_0 turbo4 Verified safe at step 1, want a memory win without much risk Light on both sides. Typically near-indistinguishable from f16/f16 outputs.
3. Recommended default q8_0 turbo3 Most dense models, most production workloads The "asymmetric turbo" sweet spot from the asymmetric-kv-compression paper. Near-lossless K, ~4.6× compressed V. Total KV ~3-4× smaller than f16/f16.
4. Aggressive V q8_0 turbo2 Memory-bound long context, after validating quality at step 3 Boundary V auto-engages and protects sensitive layers. Expect <2% PPL loss on dense models outside the protected layers.
5. MoE-aware aggressive q8_0 turbo2 Large MoE models (DeepSeek, Qwen3.6, Mixtral-style) Same flags; Boundary V's per-expert-boundary protection is what makes this work on MoE. See moe-v-compression-frontier.
6. Discouraged: symmetric K compression any turbo* any turbo* Only with model-specific quality validation in hand Compressing K is where models break. The asymmetric paper documents the failure modes. Not a starting point.

Example invocations:

# Step 1 — safest start (first contact with a new model)
llama-cli -m model.gguf --cache-type-k f16 --cache-type-v turbo4 -p "..."

# Step 3 — recommended default (asymmetric turbo)
llama-cli -m model.gguf --cache-type-k q8_0 --cache-type-v turbo3 -p "..."

# Step 4 — aggressive V at long context
llama-cli -m model.gguf --cache-type-k q8_0 --cache-type-v turbo2 -c 131072 -p "..."

If output quality drops between steps, walk back to the previous step. The compression frontier is per-model — there is no global "best" setting.

Weight quantization (offline)

Weight quantization is selected at conversion time via llama-quantize:

# TQ4_1S — recommended for most CUDA / HIP deployments (dp4a 3.5× faster than baseline)
llama-quantize model.f16.gguf model.tq4_1s.gguf TQ4_1S

# TQ3_1S — smaller, accept ~1-2 PPL bump
llama-quantize model.f16.gguf model.tq3_1s.gguf TQ3_1S

Automatic behavior

The following activate based on the selected types — no flags required:

  • Auto-asymmetric K/V — when both sides are turbo / TQ types, the policy picks complementary configurations rather than symmetric.
  • Boundary V (layer-aware) — auto-enables for any turbo2-V selection.
  • Sparse V dequantization — on Metal targets, sparse V activates for all turbo V types.
  • Flash Attention — auto-enabled for turbo KV with the relevant backend kernel.

See the linked papers above for parameter selection guidance on a per-model basis.

Citation

If this fork or any of its quantization types is used in your work, please cite the corresponding paper from the TurboQuant+ paper corpus.

License

MIT, same as upstream llama.cpp.

Recent API changes

Hot topics

Quick start

Getting started with llama.cpp is straightforward. Here are several ways to install it on your machine:

Once installed, you'll need a model to work with. Head to the Obtaining and quantizing models section to learn more.

Example command:

# Use a local model file
llama-cli -m my_model.gguf

# Or download and run a model directly from Hugging Face
llama-cli -hf ggml-org/gemma-3-1b-it-GGUF

# Launch OpenAI-compatible API server
llama-server -hf ggml-org/gemma-3-1b-it-GGUF

Description

The main goal of llama.cpp is to enable LLM inference with minimal setup and state-of-the-art performance on a wide range of hardware - locally and in the cloud.

  • Plain C/C++ implementation without any dependencies
  • Apple silicon is a first-class citizen - optimized via ARM NEON, Accelerate and Metal frameworks
  • AVX, AVX2, AVX512 and AMX support for x86 architectures
  • RVV, ZVFH, ZFH, ZICBOP and ZIHINTPAUSE support for RISC-V architectures
  • 1.5-bit, 2-bit, 3-bit, 4-bit, 5-bit, 6-bit, and 8-bit integer quantization for faster inference and reduced memory use
  • Custom CUDA kernels for running LLMs on NVIDIA GPUs (support for AMD GPUs via HIP and Moore Threads GPUs via MUSA)
  • Vulkan and SYCL backend support
  • CPU+GPU hybrid inference to partially accelerate models larger than the total VRAM capacity

The llama.cpp project is the main playground for developing new features for the ggml library.

Models

Typically finetunes of the base models below are supported as well.

Instructions for adding support for new models: HOWTO-add-model.md

Text-only

Multimodal

Bindings
UIs

(to have a project listed here, it should clearly state that it depends on llama.cpp)

Tools
  • akx/ggify – download PyTorch models from Hugging Face Hub and convert them to GGML
  • akx/ollama-dl – download models from the Ollama library to be used directly with llama.cpp
  • crashr/gppm – launch llama.cpp instances utilizing NVIDIA Tesla P40 or P100 GPUs with reduced idle power consumption
  • gpustack/gguf-parser - review/check the GGUF file and estimate the memory usage
  • Styled Lines (proprietary licensed, async wrapper of inference part for game development in Unity3d with pre-built Mobile and Web platform wrappers and a model example)
  • unslothai/unsloth – 🦥 exports/saves fine-tuned and trained models to GGUF (Apache-2.0)
Infrastructure
  • Paddler - Open-source LLMOps platform for hosting and scaling AI in your own infrastructure
  • GPUStack - Manage GPU clusters for running LLMs
  • llama_cpp_canister - llama.cpp as a smart contract on the Internet Computer, using WebAssembly
  • llama-swap - transparent proxy that adds automatic model switching with llama-server
  • Kalavai - Crowdsource end to end LLM deployment at any scale
  • llmaz - ☸️ Easy, advanced inference platform for large language models on Kubernetes.
  • LLMKube - Kubernetes operator for llama.cpp with multi-GPU and Apple Silicon Metal support"
Games
  • Lucy's Labyrinth - A simple maze game where agents controlled by an AI model will try to trick you.

Supported backends

Backend Target devices
Metal Apple Silicon
BLAS All
BLIS All
SYCL Intel and Nvidia GPU
OpenVINO [In Progress] Intel CPUs, GPUs, and NPUs
MUSA Moore Threads GPU
CUDA Nvidia GPU
HIP AMD GPU
ZenDNN AMD CPU
Vulkan GPU
CANN Ascend NPU
OpenCL Adreno GPU
IBM zDNN IBM Z & LinuxONE
WebGPU [In Progress] All
RPC All
Hexagon [In Progress] Snapdragon
VirtGPU VirtGPU APIR

Obtaining and quantizing models

The Hugging Face platform hosts a number of LLMs compatible with llama.cpp:

You can either manually download the GGUF file or directly use any llama.cpp-compatible models from Hugging Face or other model hosting sites, by using this CLI argument: -hf <user>/<model>[:quant]. For example:

llama-cli -hf ggml-org/gemma-3-1b-it-GGUF

By default, the CLI would download from Hugging Face, you can switch to other options with the environment variable MODEL_ENDPOINT. The MODEL_ENDPOINT must point to a Hugging Face compatible API endpoint.

After downloading a model, use the CLI tools to run it locally - see below.

llama.cpp requires the model to be stored in the GGUF file format. Models in other data formats can be converted to GGUF using the convert_*.py Python scripts in this repo.

The Hugging Face platform provides a variety of online tools for converting, quantizing and hosting models with llama.cpp:

To learn more about model quantization, read this documentation

llama-cli

A CLI tool for accessing and experimenting with most of llama.cpp's functionality.

  • Run in conversation mode

    Models with a built-in chat template will automatically activate conversation mode. If this doesn't occur, you can manually enable it by adding -cnv and specifying a suitable chat template with --chat-template NAME

    llama-cli -m model.gguf

# > hi, who are you?
# Hi there! I'm your helpful assistant! I'm an AI-powered chatbot designed to assist and provide information to users like you. I'm here to help answer your questions, provide guidance, and offer support on a wide range of topics. I'm a friendly and knowledgeable AI, and I'm always happy to help with anything you need. What's on your mind, and how can I assist you today?
#
# > what is 1+1?
# Easy peasy! The answer to 1+1 is... 2!
  • Run in conversation mode with custom chat template 
    # use the "chatml" template (use -h to see the list of supported templates)
llama-cli -m model.gguf -cnv --chat-template chatml

# use a custom template
llama-cli -m model.gguf -cnv --in-prefix 'User: ' --reverse-prompt 'User:'
  • Constrain the output with a custom grammar 
    llama-cli -m model.gguf -n 256 --grammar-file grammars/json.gbnf -p 'Request: schedule a call at 8pm; Command:'

# {"appointmentTime": "8pm", "appointmentDetails": "schedule a a call"}

    The grammars/ folder contains a handful of sample grammars. To write your own, check out the GBNF Guide.

    For authoring more complex JSON grammars, check out https://grammar.intrinsiclabs.ai/

llama-server

A lightweight, OpenAI API compatible, HTTP server for serving LLMs.

  • Start a local HTTP server with default configuration on port 8080 
    llama-server -m model.gguf --port 8080

# Basic web UI can be accessed via browser: http://localhost:8080
# Chat completion endpoint: http://localhost:8080/v1/chat/completions
  • Support multiple-users and parallel decoding 
    # up to 4 concurrent requests, each with 4096 max context
llama-server -m model.gguf -c 16384 -np 4
  • Enable speculative decoding 
    # the draft.gguf model should be a small variant of the target model.gguf
llama-server -m model.gguf -md draft.gguf
  • Serve an embedding model 
    # use the /embedding endpoint
llama-server -m model.gguf --embedding --pooling cls -ub 8192
  • Serve a reranking model 
    # use the /reranking endpoint
llama-server -m model.gguf --reranking
  • Constrain all outputs with a grammar 
    # custom grammar
llama-server -m model.gguf --grammar-file grammar.gbnf

# JSON
llama-server -m model.gguf --grammar-file grammars/json.gbnf

llama-perplexity

A tool for measuring the perplexity 1 (and other quality metrics) of a model over a given text.

  • Measure the perplexity over a text file 
    llama-perplexity -m model.gguf -f file.txt

# [1]15.2701,[2]5.4007,[3]5.3073,[4]6.2965,[5]5.8940,[6]5.6096,[7]5.7942,[8]4.9297, ...
# Final estimate: PPL = 5.4007 +/- 0.67339
  • Measure KL divergence 
    # TODO

llama-bench

Benchmark the performance of the inference for various parameters.

  • Run default benchmark 
    llama-bench -m model.gguf

# Output:
# | model               |       size |     params | backend    | threads |          test |                  t/s |
# | ------------------- | ---------: | ---------: | ---------- | ------: | ------------: | -------------------: |
# | qwen2 1.5B Q4_0     | 885.97 MiB |     1.54 B | Metal,BLAS |      16 |         pp512 |      5765.41 ± 20.55 |
# | qwen2 1.5B Q4_0     | 885.97 MiB |     1.54 B | Metal,BLAS |      16 |         tg128 |        197.71 ± 0.81 |
#
# build: 3e0ba0e60 (4229)

llama-simple

A minimal example for implementing apps with llama.cpp. Useful for developers.

  • Basic text completion 
    llama-simple -m model.gguf

# Hello my name is Kaitlyn and I am a 16 year old girl. I am a junior in high school and I am currently taking a class called "The Art of

Contributing

  • Contributors can open PRs
  • Collaborators will be invited based on contributions
  • Maintainers can push to branches in the llama.cpp repo and merge PRs into the master branch
  • Any help with managing issues, PRs and projects is very appreciated!
  • See good first issues for tasks suitable for first contributions
  • Read the CONTRIBUTING.md for more information
  • Make sure to read this: Inference at the edge
  • A bit of backstory for those who are interested: Changelog podcast

Other documentation

Development documentation

Seminal papers and background on the models

If your issue is with model generation quality, then please at least scan the following links and papers to understand the limitations of LLaMA models. This is especially important when choosing an appropriate model size and appreciating both the significant and subtle differences between LLaMA models and ChatGPT:

XCFramework

The XCFramework is a precompiled version of the library for iOS, visionOS, tvOS, and macOS. It can be used in Swift projects without the need to compile the library from source. For example:

// swift-tools-version: 5.10
// The swift-tools-version declares the minimum version of Swift required to build this package.

import PackageDescription

let package = Package(
    name: "MyLlamaPackage",
    targets: [
        .executableTarget(
            name: "MyLlamaPackage",
            dependencies: [
                "LlamaFramework"
            ]),
        .binaryTarget(
            name: "LlamaFramework",
            url: "https://github.com/ggml-org/llama.cpp/releases/download/b5046/llama-b5046-xcframework.zip",
            checksum: "c19be78b5f00d8d29a25da41042cb7afa094cbf6280a225abe614b03b20029ab"
        )
    ]
)

The above example is using an intermediate build b5046 of the library. This can be modified to use a different version by changing the URL and checksum.

Completions

Command-line completion is available for some environments.

Bash Completion

$ build/bin/llama-cli --completion-bash > ~/.llama-completion.bash
$ source ~/.llama-completion.bash

Optionally this can be added to your .bashrc or .bash_profile to load it automatically. For example:

$ echo "source ~/.llama-completion.bash" >> ~/.bashrc

Dependencies

  • yhirose/cpp-httplib - Single-header HTTP server, used by llama-server - MIT license
  • stb-image - Single-header image format decoder, used by multimodal subsystem - Public domain
  • nlohmann/json - Single-header JSON library, used by various tools/examples - MIT License
  • miniaudio.h - Single-header audio format decoder, used by multimodal subsystem - Public domain
  • subprocess.h - Single-header process launching solution for C and C++ - Public domain

Footnotes

  1. https://huggingface.co/docs/transformers/perplexity ↩