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.
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.
- 1Installez une chaîne d'outils C++ et CMake pour votre système d'exploitation si ce n'est pas déjà fait.
- 2Clonez le dépôt :
git clone https://github.com/ggml-org/llama.cpp. - 3Configurez 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.
- 4Compilez le projet avec CMake :
cmake -B buildpuiscmake --build build --config Release. - 5Té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.
- 6Exécutez le modèle en ligne de commande avec le binaire
llama-clipour un chat direct dans le terminal, ou lancezllama-serverpour exposer une API HTTP compatible OpenAI et une interface web. - 7Si 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.
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.
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.
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.
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.
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.
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.
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.