Skip to main content
PromptQuorumBuilt for humans. Structured for AI.
Accueil/LLM locaux avancés
Overview & Reference

Comprendre llama.cpp : guide pratique du moteur (2026)

·12 min de lecturePar Hans Kuepper · Fondateur de PromptQuorum · Moteur de découverte de l'IA open-weight et open source

llama.cpp est un programme C/C++ gratuit et open source (licence MIT) pour exécuter des grands modèles de langage localement sur son propre CPU ou GPU, créé par Georgi Gerganov et maintenu par l'organisation ggml-org sur GitHub. Il a défini le format de fichier de modèle GGUF désormais utilisé dans tout l'écosystème de l'IA locale, prend en charge la quantification de 8 bits jusqu'à environ 1,5 bit par poids, inclut des backends d'accélération matérielle pour CUDA, Metal, Vulkan, ROCm/HIP, SYCL et CPU (AVX/AVX2/AVX512), et embarque un serveur HTTP compatible OpenAI intégré appelé llama-server. Ollama utilise llama.cpp comme moteur d'inférence sur la plupart des plateformes, en ajoutant par-dessus un registre de modèles, une CLI et un système de packaging Modelfile — choisir llama.cpp directement revient donc à échanger la simplicité d'Ollama contre un contrôle direct sur les options de compilation, la quantification et la configuration du serveur.

Points clés

  • Gratuit et open source sous licence MIT, maintenu par ggml-org sur GitHub
  • Écrit en C/C++, construit sur la bibliothèque de tenseurs ggml
  • A défini le format de fichier de modèle GGUF (.gguf) utilisé dans tout l'écosystème de l'IA locale
  • Backends matériels : CUDA, Metal, Vulkan, ROCm/HIP, SYCL et CPU (AVX/AVX2/AVX512)
  • Prise en charge de la quantification de 8 bits jusqu'à environ 1,5 bit par poids
  • Embarque llama-server, un serveur HTTP compatible OpenAI intégré avec interface web
  • Ollama utilise llama.cpp comme moteur d'inférence sur la plupart des plateformes, en ajoutant un registre de modèles et une CLI
  • Pas d'installateur graphique — utilisation via ligne de commande, interface web intégrée ou bindings de langage

📍 En une phrase

llama.cpp est un moteur d'inférence C/C++ gratuit sous licence MIT créé par Georgi Gerganov, qui exécute des LLM localement sur CPU ou GPU, a défini le format de modèle GGUF, et sert de moteur d'inférence à plusieurs outils d'IA locale — dont Ollama, sur la plupart des plateformes.

💬 En termes simples

Plutôt qu'une application clé en main, llama.cpp est le code moteur lui-même, qui charge un fichier de modèle et génère du texte — Ollama et plusieurs autres applications d'IA locale exécutent llama.cpp en coulisses et ajoutent une interface plus conviviale par-dessus.

📌Remarque: Cet article s'appuie sur le dépôt GitHub officiel de llama.cpp et sa documentation publique, pas sur un benchmark indépendant. Aucun chiffre précis de tokens par seconde n'est inclus, car aucun n'a été mesuré de façon indépendante pour cet article et ces chiffres varient fortement selon le matériel, le modèle et le format de quantification.

Lire en:
🇺🇸en🇩🇪de🇫🇷fr🇯🇵ja🇨🇳zh🇪🇸es🇧🇷pt🇸🇦ar🇰🇷ko

llama.cpp est un moteur d'inférence C/C++ gratuit sous licence MIT, créé par Georgi Gerganov et maintenu par l'organisation ggml-org sur GitHub, conçu pour exécuter des modèles de langage localement sur CPU et GPU avec un minimum de dépendances. Il a défini le format de modèle GGUF utilisé dans tout l'écosystème de l'IA locale, embarque un serveur compatible OpenAI intégré appelé llama-server, et constitue le moteur d'inférence sur lequel s'appuient plusieurs autres outils d'IA locale — dont Ollama, sur la plupart des plateformes.

Comprendre llama.cpp : guide pratique du moteur (2026)

Qu'est-ce que llama.cpp ?

llama.cpp est un moteur d'inférence gratuit et sous licence MIT, écrit en C/C++, qui exécute localement de grands modèles de langage avec un minimum de dépendances externes. Il a été créé par Georgi Gerganov en 2023 comme un portage C/C++ écrit de zéro du code d'inférence LLaMA de Meta, conçu pour tourner sur du matériel grand public ordinaire — y compris des machines sans GPU — plutôt que d'exiger un GPU de data center. Le projet est aujourd'hui maintenu par l'organisation ggml-org sur GitHub, avec les contributions d'une large communauté open source, et prend désormais en charge des modèles vision-langage en plus des LLM textuels.

  • Créé par Georgi Gerganov, aujourd'hui maintenu par l'organisation ggml-org
  • Écrit en C/C++, construit sur ggml, une bibliothèque de tenseurs maintenue par la même équipe
  • Sous licence MIT : le code source est publiquement disponible pour usage, modification et redistribution selon les termes de la licence
  • Fonctionne sur du matériel CPU seul comme sur GPU, contrairement aux moteurs qui exigent absolument un GPU compatible CUDA
  • A défini le format GGUF, un format à fichier unique stockant ensemble les poids du modèle, les données de quantification et les métadonnées
  • L'un des projets d'inférence LLM open source les plus référencés, avec largement plus de 100 000 étoiles GitHub

Quelle accélération matérielle llama.cpp prend-il en charge ?

llama.cpp prend en charge un large éventail de backends d'accélération matérielle, ce qui explique en partie pourquoi il fonctionne aussi bien sur un ordinateur portable sans GPU que sur une station de travail multi-GPU.

CUDA

Détails:
Pour les GPU NVIDIA. Décharge les couches du modèle vers la mémoire GPU pour une inférence plus rapide qu'en CPU seul, avec prise en charge des configurations multi-GPU.

Metal

Détails:
Pour les Mac Apple Silicon (M1 et ultérieurs). Utilise l'API Metal d'Apple pour exécuter l'inférence sur les cœurs GPU des puces de série M.

Vulkan

Détails:
Une API GPU multi-fournisseurs pour Windows et Linux, utilisable sur des GPU de plusieurs fabricants sans SDK propriétaire.

ROCm / HIP

Détails:
Pour les GPU AMD, via la pile de calcul ROCm d'AMD, comme alternative à une accélération limitée à CUDA.

SYCL

Détails:
Pour les GPU Intel, y compris les graphiques intégrés de certains CPU Intel, via l'implémentation oneAPI SYCL d'Intel.

CPU (AVX / AVX2 / AVX512)

Détails:
Exécution CPU seule optimisée grâce à des instructions vectorisées sur les processeurs x86 modernes — la voie de repli qui permet à llama.cpp de fonctionner sans aucun GPU.

Le projet documente aussi des backends supplémentaires et expérimentaux (dont BLAS, CANN et WebGPU) dans sa documentation de compilation sur GitHub ; cette section se concentre sur les backends entre lesquels la plupart des utilisateurs de LLM locaux choisissent réellement.

Qu'est-ce que GGUF, et quel format de quantification choisir ?

GGUF est le format de fichier de modèle que llama.cpp a défini pour stocker les poids quantifiés d'un modèle avec les métadonnées nécessaires à son exécution (tokenizer, architecture, longueur de contexte), remplaçant l'ancien format GGML du projet. La quantification réduit l'empreinte mémoire d'un modèle en stockant ses poids à une précision numérique plus basse que le format d'entraînement d'origine, au prix d'une certaine qualité de sortie contre moins de VRAM/RAM et une inférence plus rapide.

Q8_0

Détails:
Quantification 8 bits, la plus proche du modèle original non quantifié parmi les formats courants de llama.cpp, avec la plus grande taille de fichier du groupe.

Q5_K_M

Détails:
Un format « K-quant » 5 bits qui répartit la précision de façon inégale entre les couches du modèle, privilégiant la qualité plutôt que la plus petite taille de fichier possible.

Q4_K_M

Détails:
Un format K-quant 4 bits couramment utilisé comme point d'équilibre entre taille de fichier et qualité de sortie — une recommandation fréquente par défaut pour un VRAM limité.

Moins de 4 bits (Q3, Q2 et formats ~1,5 bit)

Détails:
Des formats pour faire tenir des modèles plus grands dans une mémoire très limitée. La perte de qualité devient plus perceptible à mesure que la largeur de bits diminue, donc plutôt un dernier recours qu'un choix par défaut.

Le bon format dépend de votre matériel et du modèle précis — cet article n'inclut pas de pourcentages de perte de qualité mesurés de façon indépendante pour des formats spécifiques, car ils varient selon l'architecture du modèle et la tâche. Télécharger un modèle dans plusieurs formats de quantification et comparer les sorties sur vos propres prompts reste le moyen le plus fiable d'évaluer ce compromis pour votre usage.

Que propose llama-server ?

llama-server est le binaire serveur HTTP fourni avec llama.cpp. Un seul binaire expose l'API native propre à llama.cpp, une API compatible OpenAI, une couche de compatibilité API Ollama, et une interface de chat web intégrée, le tout adossé au même modèle chargé et au même cache.

  • Points d'accès compatibles OpenAI sous /v1, permettant souvent aux outils déjà conçus pour l'API OpenAI de pointer vers une instance locale de llama-server en ne changeant que l'URL de base
  • Une interface web intégrée servie directement par le binaire, utilisable sans installer de frontend séparé
  • Une couche de compatibilité API Ollama, permettant à certains outils clients orientés Ollama de se connecter à llama-server à la place
  • Des points d'accès d'introspection comme /props et /slots pour inspecter l'état du serveur et des requêtes
  • La prise en charge de plusieurs « emplacements » de requêtes simultanés sur un même modèle chargé, plutôt qu'une seule requête à la fois

Comment compiler et lancer llama.cpp ?

llama.cpp est généralement compilé depuis les sources avec CMake, bien que le projet publie aussi des binaires précompilés pour plusieurs plateformes sur sa page de releases GitHub si vous préférez éviter de compiler vous-même.

  1. 1
    Installez une chaîne d'outils C++ et CMake pour votre système d'exploitation si ce n'est pas déjà fait.
  2. 2
    Clonez le dépôt : git clone https://github.com/ggml-org/llama.cpp.
  3. 3
    Configurez la compilation pour votre backend matériel — par exemple en activant le support CUDA, Metal ou Vulkan comme option CMake, ou en restant en CPU seul.
  4. 4
    Compilez le projet avec CMake : cmake -B build puis cmake --build build --config Release.
  5. 5
    Téléchargez un modèle au format GGUF, par exemple depuis Hugging Face, en choisissant un format de quantification adapté à votre VRAM ou RAM disponible.
  6. 6
    Exécutez le modèle en ligne de commande avec le binaire llama-cli pour un chat direct dans le terminal, ou lancez llama-server pour exposer une API HTTP compatible OpenAI et une interface web.
  7. 7
    Si vous utilisez llama-server, connectez-vous via un navigateur à son adresse locale, ou pointez n'importe quel client compatible API OpenAI vers son point d'accès /v1.

Dois-je obligatoirement compiler llama.cpp depuis les sources ?

Non — le projet publie aussi des binaires précompilés pour plusieurs plateformes sur sa page de releases GitHub, mais compiler depuis les sources permet d'activer précisément le backend matériel (CUDA, Metal, Vulkan et similaires) adapté à votre machine.

Où trouver des modèles GGUF à exécuter ?

De nombreux modèles au format GGUF sont publiés sur Hugging Face et d'autres plateformes de partage de modèles, généralement dans plusieurs formats de quantification par modèle afin que vous puissiez choisir celui adapté à votre mémoire disponible.

Quel est le rapport entre llama.cpp et Ollama ?

Ollama est l'une des façons les plus répandues d'exécuter des LLM locaux sans toucher à un système de compilation, et il est fréquemment décrit — dans des articles techniques communautaires et tiers — comme utilisant llama.cpp comme moteur d'inférence sous-jacent sur la plupart des plateformes. Ollama lui-même ne documente pas cette dépendance en détail, il faut donc la considérer comme une architecture largement rapportée plutôt qu'une spécification officielle, même si elle est cohérente avec le code source ouvert d'Ollama.

  • llama.cpp est le moteur d'inférence bas niveau ; Ollama est une couche d'empaquetage qui ajoute un registre de modèles, des téléchargements en une commande, une CLI simplifiée et son propre système de configuration Modelfile
  • Choisir llama.cpp directement donne un contrôle sur les options de compilation exactes, le format de quantification et la configuration du serveur que l'interface simplifiée d'Ollama n'expose pas
  • Choisir Ollama échange ce contrôle contre un chemin plus rapide vers un modèle opérationnel, au prix d'une certaine flexibilité sur la configuration du moteur sous-jacent
  • Les deux peuvent exposer une API compatible OpenAI — llama.cpp via llama-server, Ollama via sa propre couche API

À qui s'adresse llama.cpp directement ?

llama.cpp convient à ceux qui veulent un contrôle direct sur la façon dont un modèle s'exécute, plutôt que le chemin le plus rapide vers une fenêtre de chat fonctionnelle.

Utilisez llama.cpp directement si

  • Vous voulez choisir vous-même le format de quantification, les options de compilation et le backend matériel plutôt que d'accepter les valeurs par défaut d'un outil enveloppant
  • Vous construisez une application sur mesure ou un déploiement embarqué/edge et avez besoin d'un moteur d'inférence léger, avec peu de dépendances, plutôt que d'une application de bureau complète
  • Vous voulez brancher le llama-server compatible OpenAI intégré sur votre propre frontend ou votre outillage existant basé sur l'API OpenAI
  • Vous êtes à l'aise avec la ligne de commande et, éventuellement, avec la compilation de code C/C++ via CMake
  • Vous voulez pouvoir inspecter ou modifier le code source du moteur d'inférence lui-même, ce que la licence MIT autorise

Évitez llama.cpp directement si

  • Vous voulez une installation en une commande et un modèle opérationnel en quelques minutes sans toucher à un système de compilation — Ollama ou LM Studio répondent mieux à ce besoin
  • Vous voulez une interface de chat graphique clé en main plutôt qu'une CLI ou une interface web à lancer soi-même
  • Vous avez besoin d'un très haut débit multi-utilisateurs sur un grand cluster de GPU — un moteur dédié au serving comme vLLM est conçu spécifiquement pour cette charge intensive en batching
  • Vous n'êtes pas à l'aise pour résoudre vous-même des erreurs de compilation ou des problèmes de pilotes matériels (CUDA, ROCm)

llama.cpp vs. Ollama vs. LM Studio vs. vLLM

Ces quatre outils se situent à des points différents du spectre contrôle-contre-confort, et deux d'entre eux (Ollama et, sur Apple Silicon, une partie de l'écosystème autour de LM Studio) sont eux-mêmes construits sur des moteurs d'inférence plutôt que d'en être des alternatives conçues de zéro.

llama.cpp

Interface et installation:
CLI, interface web intégrée et API compatible OpenAI via llama-server. Compilation depuis les sources avec CMake ou binaire de release précompilé ; vous choisissez vous-même le format de quantification.
Idéal pour:
Un contrôle maximal, un déploiement embarqué/edge et des pipelines sur mesure construits directement sur le moteur.
Articles sur llama.cpp (9)

+167 autres non affichés

Ollama

Interface et installation:
CLI et API REST, généralement décrit comme fonctionnant sur la plupart des plateformes avec llama.cpp comme backend. Une commande l'installe ; une commande télécharge et lance un modèle.
Idéal pour:
Le chemin le plus rapide vers un modèle local opérationnel sans étape de compilation, pour qui n'a pas besoin de configuration au niveau du moteur.
Articles sur Ollama (10)

+310 autres non affichés

LM Studio

Interface et installation:
Application de bureau graphique pour Mac, Windows et Linux. Télécharger, installer, puis parcourir et télécharger un modèle depuis l'application.
Idéal pour:
Les utilisateurs non techniques qui veulent une application de chat clé en main plutôt qu'une ligne de commande.
Articles sur LM Studio (10)

+146 autres non affichés

vLLM

Interface et installation:
Serveur Python avec API compatible OpenAI, installé via pip dans un environnement Python/CUDA. Utilise son propre moteur de serving PagedAttention plutôt que GGUF ou llama.cpp.
Idéal pour:
Le serving GPU multi-utilisateurs à haut débit en production, pas le chat local mono-utilisateur.
Articles sur vLLM (9)

+84 autres non affichés

Cet article n'a pas benchmarké de façon indépendante la vitesse ou la qualité de sortie de ces quatre outils et n'affirme pas qu'un seul soit techniquement supérieur — la comparaison ci-dessus ne porte que sur des faits documentés d'architecture, d'installation et de mode d'accès. Pour des chiffres de débit par matériel, voir la comparaison dédiée llama.cpp vs. Ollama vs. vLLM ainsi que le guide des serveurs d'inférence d'entreprise, qui traite vLLM plus en profondeur.

Comparer dans l'annuaire

Que ne couvre pas cet article ?

Il s'agit d'un article explicatif construit à partir de la documentation publique et du dépôt de llama.cpp, pas d'un rapport de benchmark pratique.

  • Aucun chiffre de tokens par seconde ou de latence mesuré de façon indépendante — le débit dépend fortement de votre matériel précis, de votre modèle, de votre format de quantification et de vos options de compilation
  • Aucun pourcentage de perte de qualité vérifié de façon indépendante pour des formats de quantification spécifiques — ils varient selon l'architecture du modèle et la tâche
  • Aucun audit de sécurité ligne par ligne de la base de code de llama.cpp — elle est open source et sous licence MIT, le code lui-même est donc disponible pour examen
  • Aucune couverture de chaque backend ou option de compilation pris en charge par llama.cpp — cet article se concentre sur les backends et formats entre lesquels la plupart des utilisateurs de LLM locaux choisissent
  • Aucune couverture des accords de support commercial, llama.cpp étant un projet open source communautaire et non un produit éditeur avec contrat de support

Erreurs fréquentes en essayant llama.cpp

La plupart des frictions avec llama.cpp viennent du fait de le traiter comme une application grand public plutôt que comme un moteur à construire soi-même.

Erreur 1 : s'attendre à un installateur graphique

llama.cpp n'a pas d'installateur clé en main avec assistant de configuration. Vous le compilez avec CMake depuis les sources, ou téléchargez un binaire de release précompilé depuis GitHub, puis l'exécutez en ligne de commande ou via sa propre interface web intégrée.

Erreur 2 : supposer qu'Ollama et llama.cpp se comportent toujours de façon identique

Même si Ollama est généralement décrit comme fonctionnant sur la plupart des plateformes avec llama.cpp comme backend, Ollama applique ses propres réglages par défaut, son propre empaquetage de modèles et ses propres choix de quantification — la vitesse de sortie, et dans certains cas le comportement exact, peuvent donc différer de l'exécution directe du même modèle de base via llama.cpp avec d'autres réglages.

Erreur 3 : choisir un format de quantification qui ne tient pas dans la mémoire disponible

Choisir un format de quantification (comme Q8_0) plus volumineux que votre VRAM disponible force souvent un repli lent sur CPU ou une erreur de mémoire insuffisante. Adapter le format à votre matériel réel — en commençant par un format médian comme Q4_K_M en cas de doute — évite ce problème.

Questions fréquentes

Qu'est-ce que llama.cpp ?

llama.cpp est un moteur d'inférence C/C++ gratuit sous licence MIT créé par Georgi Gerganov, qui exécute de grands modèles de langage localement sur CPU ou GPU. Il est maintenu par l'organisation ggml-org sur GitHub.

llama.cpp est-il gratuit ?

Oui. llama.cpp est un logiciel gratuit et open source publié sous licence MIT, sans abonnement ni compte requis.

Qu'est-ce que GGUF ?

GGUF est le format de fichier de modèle que llama.cpp a défini pour stocker les poids quantifiés d'un modèle avec les métadonnées nécessaires à son exécution, comme le tokenizer et les détails d'architecture. Il est utilisé dans une grande partie de l'écosystème de l'IA locale, pas seulement par llama.cpp lui-même.

Ollama utilise-t-il llama.cpp ?

Ollama est fréquemment décrit, dans des articles techniques communautaires et tiers, comme utilisant llama.cpp comme moteur d'inférence sur la plupart des plateformes, en ajoutant son propre registre de modèles, sa CLI et son système Modelfile. Ollama lui-même ne documente pas cette dépendance en détail.

Quel matériel llama.cpp prend-il en charge ?

llama.cpp prend en charge l'exécution CPU seule (avec des optimisations AVX/AVX2/AVX512) ainsi que l'accélération GPU via CUDA (NVIDIA), Metal (Apple Silicon), Vulkan, ROCm/HIP (AMD) et SYCL (Intel).

Quels formats de quantification llama.cpp prend-il en charge ?

llama.cpp prend en charge la quantification de formats 8 bits comme Q8_0 jusqu'à des formats d'environ 1,5 bit, avec des formats intermédiaires très utilisés comme Q5_K_M et Q4_K_M qui équilibrent taille de fichier et qualité de sortie.

Faut-il connaître le C++ pour utiliser llama.cpp ?

Non — exécuter des modèles via les binaires llama-cli ou llama-server ne demande pas d'écrire de code. Compiler le projet depuis les sources nécessite une chaîne d'outils C++ et CMake, mais pas d'écrire soi-même du C++, sauf si vous souhaitez modifier le moteur.

llama.cpp a-t-il une interface graphique ?

llama-server inclut une interface web intégrée dans le navigateur, mais il n'existe pas d'installateur graphique séparé ni d'application de bureau comparable à LM Studio. Plusieurs applications tierces, dont des frontends compatibles Ollama et compatibles API OpenAI, peuvent se connecter à llama-server à la place.

llama.cpp est-il meilleur qu'Ollama ?

« Meilleur » dépend du besoin : llama.cpp offre un contrôle plus direct sur les options de compilation, la quantification et la configuration du serveur, tandis qu'Ollama offre un chemin plus rapide et plus simple vers un modèle opérationnel. Cet article n'affirme pas qu'un des deux soit techniquement supérieur ; voir le tableau comparatif ci-dessus et la comparaison de benchmark dédiée pour plus de détails.

llama.cpp peut-il fonctionner sans GPU ?

Oui. llama.cpp est conçu pour fonctionner sur du matériel CPU seul grâce à des instructions vectorisées (AVX/AVX2/AVX512), en plus de prendre en charge l'accélération GPU lorsqu'elle est disponible.

Sources

← Retour aux LLM locaux avancés

MCP