llama.cpp installeren en gebruiken op Linux, macOS en Windows

llama.cpp is een open source project waarmee je Large Language Models lokaal uitvoert via C/C++. Het project is vooral populair voor GGUF-modellen: modelbestanden die geschikt zijn voor snelle en relatief lichte inference op CPU's en GPU's. 

Llama.cpp wordt door veel populaire AI apps zoals Ollama en LM Studio gebruikt als inference backend, maar gebruikt minder hardware en performt sneller wanneer je het zonder Ollama of LM Studio gebruikt. 

In deze handleiding installeer je llama.cpp op Linux, macOS of Windows. Linux is de meest relevante optie voor een server zonder GPU (bijvoorbeeld een VPS). Daarna voer je je eerste prompt uit, start je een lokale API-server en test je deze met curl. Gebruik op een server zonder GPU kleine of quantized modellen; grote modellen werken traag of passen niet in het beschikbare RAM.

Voor je begint

Voor deze handleiding heb je het volgende nodig:

• Linux: een server met Ubuntu, Debian, AlmaLinux, Rocky Linux of CentOS Stream.
• macOS: een Mac met Homebrew of de mogelijkheid om Homebrew te installeren.
• Windows: Windows 10 of 11 met Developer PowerShell for VS 2022.
• Minimaal 4GB RAM voor kleine testmodellen. Gebruik 8GB of meer wanneer je comfortabeler wilt testen met grotere modellen, zie deze handleiding voor tips om het juiste LLM en het juiste formaat server te kiezen.

GGUF is het modelbestandsformaat dat llama.cpp gebruikt en quantization toepast. Een quantized model is een kleiner modelbestand waarbij gewichten compacter zijn opgeslagen. Daardoor heeft het model minder RAM en schijfruimte nodig, wat vooral belangrijk is op een VPS zonder GPU.

OpenBLAS is vooral relevant voor CPU-only gebruik. Het helpt bij prompt processing met grotere batch sizes, maar maakt token generation niet sneller. Op macOS gebruikt llama.cpp standaard het Accelerate-framework voor BLAS en Metal voor GPU-acceleratie.

llama.cpp installeren in Linux

Gebruik deze stappen voor een Linux-server. De CPU-build met OpenBLAS is de beste start voor een VPS zonder GPU. De CUDA-build is alleen relevant wanneer je server een NVIDIA GPU heeft en de NVIDIA driver plus CUDA toolkit al aanwezig zijn.

Stap 1

Verbind met je server via SSH, de VPS-console (VPS), of OpenStack-console (OpenStack-instance).

Stap 2

Update eerst je server zodat de nieuwste software packages beschikbaar zijn.

Ubuntu / Debian:

sudo apt -y update && sudo apt -y upgrade

Controleer of een herstart vereist is en zo ja, reboot dan eerst je server:

test -f /var/run/reboot-required && echo "Herstart vereist" || echo "Geen herstart vereist gemeld"

AlmaLinux / Rocky Linux / CentOS Stream:

sudo dnf -y update

Controleer of een herstart vereist is en zo ja, reboot dan eerst je server:

sudo dnf install -y dnf-utils
sudo needs-restarting -r

Stap 3

Installeer de build-dependencies. Git downloadt de broncode, CMake maakt de build-configuratie aan en de compiler bouwt de llama.cpp-tools. De OpenBLAS package wordt gebruikt voor CPU-acceleratie bij prompt processing.

Ubuntu / Debian:

sudo apt -y install git build-essential cmake curl libcurl4-openssl-dev libssl-dev libopenblas-dev

AlmaLinux / Rocky Linux / CentOS Stream:

sudo dnf -y install git gcc gcc-c++ make cmake curl libcurl-devel openssl-devel openblas-devel

De libcurl package is nodig wanneer je modellen direct met de -hf optie van Hugging Face wilt downloaden. De OpenSSL package is nodig voor HTTPS/TLS-ondersteuning. Is openblas-devel niet beschikbaar op jouw Linux-distributie, gebruik dan de fallback-build zonder OpenBLAS in stap vijf.

Stap 4

Download de llama.cpp broncode:

cd ~
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp

Stap 5

Compileer (build) llama.cpp:

CPU-build met OpenBLAS:

cmake -B build -DCMAKE_BUILD_TYPE=Release -DGGML_BLAS=ON -DGGML_BLAS_VENDOR=OpenBLAS
cmake --build build --config Release -j "$(nproc)"

Fallback CPU-build zonder OpenBLAS:

cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release -j "$(nproc)"

NVIDIA GPU-build met CUDA:

Controleer eerst of de NVIDIA driver en CUDA toolkit beschikbaar zijn:

nvidia-smi
nvcc --version

Zie je bij beide commando's versie-informatie, build llama.cpp dan met CUDA:

cmake -B build-cuda -DCMAKE_BUILD_TYPE=Release -DGGML_CUDA=ON
cmake --build build-cuda --config Release -j "$(nproc)"

De CUDA-build gebruikt build-cuda in plaats van build. Voeg bij het uitvoeren van llama-cli of llama-server de optie -ngl 99 toe om model layers naar de GPU te offloaden. Lukt GPU-offloading niet of is het VRAM vol, gebruik dan een lager getal.

Stap 6

Controleer of llama-cli en llama-server correct zijn gebouwd:

CPU-build:

./build/bin/llama-cli --help
./build/bin/llama-server --help

CUDA-build:

./build-cuda/bin/llama-cli --help
./build-cuda/bin/llama-server --help

Zie je de helptekst van beide programma's, dan is de installatie gelukt.

Stap 7

Voeg tot slot de llama.cpp-programma's toe aan je PATH. Daarna kun je llama-cli en llama-server vanuit elke map uitvoeren.

Gebruik je de CPU-build, voer dan uit:

mkdir -p ~/.local/bin
ln -sf "$HOME/llama.cpp/build/bin/llama-cli" "$HOME/.local/bin/llama-cli"
ln -sf "$HOME/llama.cpp/build/bin/llama-server" "$HOME/.local/bin/llama-server"

Gebruik je de CUDA-build, voer dan in plaats daarvan uit:

mkdir -p ~/.local/bin
ln -sf "$HOME/llama.cpp/build-cuda/bin/llama-cli" "$HOME/.local/bin/llama-cli"
ln -sf "$HOME/llama.cpp/build-cuda/bin/llama-server" "$HOME/.local/bin/llama-server"

Controleer daarna of ~/.local/bin in je PATH staat en zo niet, corrigeer dit direct:

echo "$PATH" | grep -q "$HOME/.local/bin" || echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.profile export PATH="$HOME/.local/bin:$PATH"

Test tot slot of de commando's vanuit elke map beschikbaar zijn:

cd ~
llama-cli --help
llama-server --help

Open een nieuwe SSH-sessie wanneer llama-cli of llama-server nog niet direct wordt gevonden.

llama.cpp installeren in macOS

Op macOS gebruikt llama.cpp standaard het Accelerate-framework voor BLAS en Metal voor GPU-acceleratie op ondersteunde Apple-hardware. Je hoeft OpenBLAS daarom niet apart te installeren.

Stap 1

Controleer of Homebrew beschikbaar is:

brew --version

Is Homebrew nog niet geïnstalleerd, installeer het dan via het officiële installer-script:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Stap 2

Installeer Git en CMake:

brew install git cmake

Stap 3

Download en compileer (build) llama.cpp:

cd ~
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release -j "$(sysctl -n hw.logicalcpu)"

Wil je expliciet zonder Metal bouwen, voeg dan -DGGML_METAL=OFF toe aan het CMake-commando.

Stap 4

Controleer of llama-cli en llama-server zijn gebouwd:

./build/bin/llama-cli --help
./build/bin/llama-server --help

Stap 5

Voeg de llama.cpp-programma's toe aan je PATH. Daarna kun je llama-cli en llama-server vanuit elke map uitvoeren.

Maak hiervoor symbolic links aan in de Homebrew bin-map:

ln -sf "$HOME/llama.cpp/build/bin/llama-cli" "$(brew --prefix)/bin/llama-cli"
ln -sf "$HOME/llama.cpp/build/bin/llama-server" "$(brew --prefix)/bin/llama-server"

Test daarna of de commando's vanuit elke map beschikbaar zijn:

cd ~
llama-cli --help
llama-server --help

Worden de commando's niet gevonden? Sluit je terminalvenster, open een nieuw terminalvenster en probeer het opnieuw.

llama.cpp installeren in Windows

Gebruik in Windows de Visual Studio Build Tools. OpenBLAS op Windows vraagt om extra handmatige library-configuratie. Voor een eenvoudige installatie gebruik je daarom de standaard CPU-build, of de CUDA-build wanneer je een NVIDIA GPU gebruikt.

Stap 1

Open PowerShell als administrator en installeer Git, CMake en Visual Studio 2022 Build Tools:

winget install --id Git.Git -e
winget install --id Kitware.CMake -e
winget install --id Microsoft.VisualStudio.2022.BuildTools -e --override "--wait --add Microsoft.VisualStudio.Workload.VCTools --includeRecommended"

Mocht je een venster te zien krijgen waarin wordt aangegeven dat een update beschikbaar is, installeer dan ook de update. Sluit PowerShell na de installatie.

Stap 2

Open ‘Developer PowerShell for VS 2022’ via het startmenu. Gebruik dit venster voor de rest van de Windows-stappen.

Stap 3

Download de llama.cpp broncode:

cd $env:USERPROFILE
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp

Stap 4

cmake -B build -DLLAMA_BUILD_BORINGSSL=ON
cmake --build build --config Release 

nvidia-smi
nvcc --version

cmake -B build-cuda -DGGML_CUDA=ON -DLLAMA_BUILD_BORINGSSL=ON
cmake --build build-cuda --config Release

Stap 5

Controleer of llama-cli en llama-server correct zijn gebouwd:

CPU-build:

.\build\bin\Release\llama-cli.exe --help
.\build\bin\Release\llama-server.exe --help

CUDA-build:

.\build-cuda\bin\Release\llama-cli.exe --help
.\build-cuda\bin\Release\llama-server.exe --help

Stap 6

Voeg de llama.cpp-programma's toe aan je gebruikers-PATH. Daarna kun je llama-cli.exe en llama-server.exe vanuit elke map uitvoeren.

Gebruik je de CPU-build, voer dan uit in Developer PowerShell for VS 2022:

$llamaBin = "$env:USERPROFILE\llama.cpp\build\bin\Release"
$userPath = [Environment]::GetEnvironmentVariable("Path", "User") 

if (($userPath -split ';') -notcontains $llamaBin) { $newPath = if ([string]::IsNullOrWhiteSpace($userPath)) { $llamaBin } else { "$userPath;$llamaBin" } [Environment]::SetEnvironmentVariable("Path", $newPath, "User") }

$env:Path = "$env:Path;$llamaBin"

Gebruik je de CUDA-build, voer dan in plaats daarvan uit:

$llamaBin = "$env:USERPROFILE\llama.cpp\build-cuda\bin\Release"
$userPath = [Environment]::GetEnvironmentVariable("Path", "User")

if (($userPath -split ';') -notcontains $llamaBin) { $newPath = if ([string]::IsNullOrWhiteSpace($userPath)) { $llamaBin } else { "$userPath;$llamaBin" } [Environment]::SetEnvironmentVariable("Path", $newPath, "User") }

$env:Path = "$env:Path;$llamaBin"

Test daarna of de commando's vanuit elke map beschikbaar zijn:

cd $env:USERPROFILE
llama-cli.exe --help
llama-server.exe --help

Wordt llama-cli.exe of llama-server.exe nog niet direct gevonden? Open dan een nieuw PowerShell-venster.

Je eerste prompt uitvoeren

In dit voorbeeld laat je llama.cpp automatisch een klein GGUF-model van Hugging Face downloaden. Het model wordt daarna gebruikt om een korte prompt te beantwoorden.

llama-cli -hf ggml-org/gemma-3-1b-it-GGUF -p "Leg in drie zinnen uit wat llama.cpp is." -n 128

llama-cli.exe -hf ggml-org/gemma-3-1b-it-GGUF -p "Leg in drie zinnen uit wat llama.cpp is." -n 128

./build-cuda/bin/llama-cli -hf ggml-org/gemma-3-1b-it-GGUF -p "Leg in drie zinnen uit wat llama.cpp is." -n 128 -ngl 99

.\build-cuda\bin\Release\llama-cli.exe -hf ggml-org/gemma-3-1b-it-GGUF -p "Leg in drie zinnen uit wat llama.cpp is." -n 128 -ngl 99

Interactief chatten

Start llama-cli zonder vaste prompt om interactief te chatten.

Linux / macOS:

cd ~/llama.cpp
./build/bin/llama-cli -hf ggml-org/gemma-3-1b-it-GGUF -cnv

Windows:

cd $env:USERPROFILE\llama.cpp
.\build\bin\Release\llama-cli.exe -hf ggml-org/gemma-3-1b-it-GGUF -cnv

De optie -cnv activeert conversation mode. Modellen met een ingebouwde chat template gebruiken die template automatisch. Stop de interactieve sessie met ctrl + c.

Een lokale API-server starten

llama-server start een lokale HTTP-server. Die server heeft endpoints die lijken op de OpenAI Chat Completions API, waardoor je eigen scripts of applicaties er makkelijk requests naartoe sturen.

Start de server alleen op 127.0.0.1.

Linux / macOS:

llama-server -hf ggml-org/gemma-3-1b-it-GGUF --host 127.0.0.1 --port 8080

Windows:

llama-server.exe -hf ggml-org/gemma-3-1b-it-GGUF --host 127.0.0.1 --port 8080

Open daarna een tweede terminalvenster en controleer of de server reageert:

curl http://127.0.0.1:8080/health

Test daarna een chat request:

curl http://127.0.0.1:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer no-key" \
  -d '{
    "model": "gpt-3.5-turbo",
    "messages": [
      {
        "role": "user",
        "content": "Schrijf een korte samenvatting van wat llama.cpp doet."
      }
    ]
  }'

De Authorization-header is in dit lokale voorbeeld een placeholder. Gebruik een echte beveiligingslaag voordat je de server beschikbaar maakt voor andere systemen.

De API-server via een SSH-tunnel gebruiken

Omdat de server alleen op 127.0.0.1 luistert, is poort 8080 niet direct vanaf internet bereikbaar. Maak vanaf je eigen computer een SSH-tunnel om de lokale API op een remote Linux-server veilig te gebruiken:

ssh -N -L 8080:127.0.0.1:8080 gebruiker@123.123.123.123

Vervang gebruiker door je Linux-gebruiker en 123.123.123.123 door het IP-adres van je server. Zolang de tunnel actief is, bereik je de API vanaf je eigen computer via http://127.0.0.1:8080.

llama-server automatisch starten in Linux

Wil je llama-server op een Linux-server automatisch starten na een reboot? Maak dan een systemd-service aan. De service hieronder gebruikt de CPU/OpenBLAS-build. Gebruik je de CUDA-build, vervang build/bin door build-cuda/bin en voeg -ngl 99 toe aan het eind van de ExecStart= regel.

Stap 1

Maak het servicebestand aan:

cd ~/llama.cpp
LLAMA_DIR="$(pwd)"
LLAMA_USER="$(whoami)"

sudo tee /etc/systemd/system/llama-server.service > /dev/null <<EOF
[Unit]
Description=llama.cpp API server
After=network-online.target
Wants=network-online.target

[Service]
Type=simple
WorkingDirectory=$LLAMA_DIR
ExecStart=$LLAMA_DIR/build/bin/llama-server -hf ggml-org/gemma-3-1b-it-GGUF --host 127.0.0.1 --port 8080
Restart=on-failure
RestartSec=5
User=$LLAMA_USER

[Install]
WantedBy=multi-user.target
EOF

Stap 2

Activeer en start de service:

sudo systemctl daemon-reload
sudo systemctl enable --now llama-server

Stap 3

Controleer de status en logs:

systemctl status llama-server
journalctl -u llama-server -f

Stop de logweergave met ctrl + c.

llama.cpp bijwerken

Werk llama.cpp bij door de nieuwste code op te halen en opnieuw te builden.

Linux:

cd ~/llama.cpp
git pull
cmake --build build --config Release -j "$(nproc)"

Gebruik je op Linux de CUDA-build, vervang build dan door build-cuda. Gebruik je de systemd-service uit deze handleiding op Linux, herstart de service daarna:

sudo systemctl restart llama-server

macOS:

cd ~/llama.cpp
git pull
cmake --build build --config Release -j "$(sysctl -n hw.logicalcpu)"

Windows:

cd $env:USERPROFILE\llama.cpp
git pull
cmake --build build --config Release

Gebruik je build-cuda, vervang build dan door build-cuda.

Veelvoorkomende problemen

• cmake: command not found: installeer de build dependencies opnieuw.
• llama.cpp built without libcurl: installeer libcurl4-openssl-dev of libcurl-devel en build llama.cpp opnieuw.
• OpenBLAS wordt niet gevonden: installeer libopenblas-dev of openblas-devel. Lukt dat niet, gebruik dan de fallback CPU-build zonder OpenBLAS.
• nvidia-smi of nvcc wordt niet gevonden: installeer of herstel eerst de NVIDIA driver en CUDA toolkit. Gebruik daarna pas de CUDA-build.
• De build wordt afgebroken door te weinig geheugen: sluit andere processen, vergroot je swap-geheugen of gebruik een VPS met meer RAM.
• Het model reageert traag: gebruik een kleiner of sterker quantized model. CPU-inference is merkbaar trager dan GPU-inference.
• Poort 8080 is niet bereikbaar vanaf je eigen computer: dit is verwacht wanneer llama-server alleen op 127.0.0.1 luistert. Gebruik de SSH-tunnel uit deze handleiding wanneer de server op een remote Linux-server draait.
• Een Hugging Face-download werkt niet: controleer de modelnaam. Sommige modellen vereisen dat je eerst licentievoorwaarden accepteert of inlogt met een Hugging Face-token.
• HTTPS is not supported: rebuild llama.cpp met -DLLAMA_BUILD_BORINGSSL=ON (zie de installatieinstructie in dit artikel). Zonder HTTPS-ondersteuning werkt de -hf optie niet, omdat llama.cpp het model dan niet direct van Hugging Face kan downloaden.

Je hebt llama.cpp nu geïnstalleerd op Linux, macOS of Windows, een GGUF-model gestart en een lokale API-server opgezet. Gebruik kleine quantized modellen op een VPS zonder GPU en houd de API-server afgeschermd wanneer je hiermee experimenteert of eigen applicaties koppelt.