Cet article existe aussi en anglais : lire la version anglaise.
On descend d'un cran : #005 Herbert meilleur que Llama.cpp ?

En bref
- J'ai mesuré Herbert face à Llama.cpp 1.0 sur 2 processeurs, avec le même fichier Q4_0 de Qwen3.6 : il lit les prompts 1,5 à 2 fois plus vite et écrit les réponses 8 à 13 % plus vite ; il n'est pas devant dans tous les cas.
- Le même fichier, parce que comparer un Q4_0 à un Q4_K_M, c'est comparer deux modèles différents : le Q4_K_M que la plupart d'entre vous téléchargent est près de 4 fois plus fidèle au modèle d'origine et il se paie en vitesse.
- Avec le même Q4_0, Herbert et Llama.cpp perdent autant de qualité l'un que l'autre ; garder la fidélité du Q4_K_M à la vitesse du Q4_0, c'est mon prochain chantier.
Cet article a deux niveaux. D'abord le texte de la vidéo, qui se suffit. Ensuite le détail, en sections qui se lisent seules : les tableaux, la façon de mesurer, les limites et de quoi tout rejouer chez vous.
Ce que j'ai dit dans la vidéo
Llama.cpp v1.0 est sorti ! Ce projet incroyable est la référence pour servir les IA locales et open source. Beaucoup d'autres projets comme Ollama reposent dessus.
La question qui nous intéresse aujourd'hui, c'est de savoir s'il est possible de concevoir un moteur d'IA plus rapide, en Rust, mais sans aucune ligne d'assembleur (ou presque). Herbert, mon moteur d'inférence, le peut et sur certains tests, il est même 2 fois plus rapide. Je vous raconte et précise ce qu'il en est vraiment.
Rappelez-vous, un modèle de langage, ce sont des milliards de nombres rangés dans quelques fichiers. On appelle ces nombres les poids du modèle. Ils prennent beaucoup de place dans la mémoire de votre ordinateur, ou dans celle de la carte graphique.
Alors, on cherche à réduire cette taille : on enregistre chaque nombre avec moins de précision. C'est ce qu'on appelle la quantification. L'idée ne vient pas des modèles de langage : on le faisait déjà sur des réseaux de neurones en 2015. Mais Llama.cpp, publié en mars 2023 par Georgi Gerganov, l'a rendue courante sur nos ordinateurs : son but affiché était de faire tourner un modèle quantifié sur un MacBook.
Je vous explique ça simplement. Quantifier, c'est ranger les poids d'un modèle dans un encodage plus petit. La plupart des modèles sont encodés en 16 bits : chaque nombre peut prendre 65 536 valeurs différentes. Ici on va s'intéresser à la quantification en 4 bits, où chaque nombre n'a plus que 16 valeurs possibles, soit 4 096 fois moins.
Alors autant vous dire qu'on y perd forcément quelque chose : on trahit un peu le modèle d'origine. En contrepartie, il tourne plus vite et on peut en lancer de plus gros sur la même machine.
Bah oui, pour écrire un seul token, le moteur relit tous les poids, c'est ce que je vous répète depuis quelques semaines. Alors, passer de 16 bits à 4 bits, normalement on devrait avoir 4 fois moins d'octets à relire. Mais en pratique c'est un peu plus de 3 fois moins, parce que tous les poids du modèle ne sont pas quantifiés et qu'en vrai, on quantifie autour d'une valeur de référence, par bloc. En conséquence, le moteur doit alors, en principe, écrire la réponse à une question 3 fois plus vite.
Et vous commencez à me connaître : comme tout ce que je fais dans cette série, il faut vérifier et mesurer. Avec Herbert, sur un même processeur, le modèle Gemma4 E4B, qui pèse environ 16 Go, passe de 5,65 tokens par seconde en 16 bits à 17,5 en 4 bits. Le modèle Qwen3.6 35B, qui pèse à peu près 72 Go en 16 bits, ne tient même pas dans les 67 Go disponibles dans la mémoire de ma machine. En 4 bits, il en occupe 25.
Herbert fait donc aussi tourner ces modèles en 4 bits, sur le processeur, sans carte graphique. Je l'ai testé sur plusieurs modèles : Qwen3, Gemma4 ou même LFM de LiquidAI. Ça fonctionne aussi pour les cartes graphiques, mais on en reparle dans les semaines à venir.
Pour vérifier si Herbert est correct et performant, je l'ai comparé à Llama.cpp, dont la version 1.0 date du 13 novembre 2026. C'est le moteur contre lequel je me mesure depuis le début de la série. Quand j'ai comparé les deux, Herbert lisait la question 2 fois plus vite et écrivait la réponse 1,5 fois plus vite.
Avec un tel écart, je me suis dit qu'il y avait forcément une erreur, même si le texte semblait cohérent. En cherchant, j'ai réalisé que je ne comparais pas tout à fait la même chose. Le fichier qu'on télécharge d'habitude pour Llama.cpp s'appelle Q4_K_M. Il annonce 4 bits, mais une partie des poids est gardée en 8 bits. Il est plus lourd et il reste plus fidèle au modèle d'origine. Quant à Herbert, il range tout sur 4 bits, comme le format le plus simple de Llama.cpp, le Q4_0. Pour écrire la réponse, une partie de son avance venait donc de là : il relisait moins d'octets. Et forcément, il devait le payer en fidélité.
Il me fallait donc aussi mesurer cette fidélité. On fait lire un texte au modèle non quantifié et on note à chaque mot ce qu'il aurait écrit ensuite. Puis on fait pareil avec la version en 4 bits et on regarde de combien elle s'écarte. Il faut le dire : le Q4_K_M s'écarte mathématiquement presque 4 fois moins que le Q4_0. Ça fait peur, non ?
Pourtant, sur des réponses entières, j'ai posé 15 questions aux différentes versions. À « quelle est la plus grande ville du Canada », le modèle en 16 bits répond Toronto. Toutes les versions en 4 bits répondent Montréal, le Q4_K_M aussi. Sur une question d'économie, Herbert et Llama.cpp en Q4_0 donnent la même réponse au mot près, un peu moins bonne que celle du modèle d'origine, que le Q4_K_M reproduit exactement. Et 3 fois, c'est le modèle en 16 bits qui se trompe et les versions en 4 bits qui tombent juste. C'est presque une surprise, assez incongru finalement. Mais ce qu'on mesure, ce n'est pas si la quantification donne plus de mauvaises réponses : c'est si le modèle quantifié s'éloigne beaucoup du modèle d'origine.
Au final, ce qu'il faut retenir, c'est que pour les tests que j'ai faits, la quantification n'est pas affreuse du tout.
Ce qu'on veut faire ici, c'est voir si, à quantification similaire, Herbert reste aussi performant face à Llama.cpp. J'ai donc refait la comparaison en donnant à Llama.cpp le même format qu'à Herbert, fabriqué à partir des mêmes poids. La qualité est alors la même, à 1 % près.
Et même là, Herbert lit toujours la question environ 2 fois plus vite sur un processeur et 1,5 fois sur l'autre. Ça n'a presque pas bougé. Pour écrire la réponse, son avance n'est plus que de 8 à 13 %, mais il reste devant. Sauf pour Gemma4 E2B, un petit modèle de Google, où Llama.cpp lit la question plus vite qu'Herbert. Je n'ai pas encore eu l'occasion de regarder pourquoi.
Pour garder une certaine objectivité, il me faut reconnaître qu'il existe un fork de Llama.cpp, ik_llama.cpp, écrit par Iwan Kawrakow, l'auteur du format Q4_K_M. À format égal, il est au niveau d'Herbert pour écrire la réponse, à quelques pour cent près. Pour lire la question, il est derrière Herbert sur les courtes et devant sur les longues, jusqu'à 30 % sur un des 2 processeurs. J'ai clairement encore du boulot.
Quatre bits contre seize bits
Le même moteur, la même machine, la même fenêtre : un EPYC 4344P à 8 fils, Herbert dans ses deux formats, une invite d'environ 630 tokens. Les mêmes fichiers servent aux deux : Herbert quantifie au chargement, à partir des poids d'origine. Il n'y a donc aucun gain de disque à attendre du 4 bits, seulement de mémoire et de vitesse.
| Modèle | Format | Écriture (tokens/s) | Octets relus par token | Mémoire au repos |
|---|---|---|---|---|
| Qwen3.5-2B | 16 bits | 13,9 | 3,76 Go | 6,4 Go |
| Qwen3.5-2B | 4 bits | 43,2 | 1,18 Go | 3,4 Go |
| Gemma 4 E4B | 16 bits | 5,65 | 9,29 Go | 21,7 Go |
| Gemma 4 E4B | 4 bits | 17,5 | 2,90 Go | 15,6 Go |
L'écriture va environ 3 fois plus vite en 4 bits : c'est bien le rapport des octets relus par token (0,31). Les deux formats lisent la mémoire à la même vitesse : le décodage suit les octets, ce qui recoupe #001. La mémoire au repos est à peu près divisée par deux sur le 2B, mais ne baisse que d'un quart sur Gemma 4 E4B : une table de 9,3 Go y reste lue en place dans les deux formats.
La contrepartie se voit au démarrage : quantifier au chargement prend du temps. Le chargement est environ deux fois plus long en 4 bits.
Ce que contient un fichier Q4_K_M
Un fichier « Q4 » n'est pas tout en 4 bits. J'ai ouvert les deux fichiers de Qwen3.6-35B-A3B, tenseur par tenseur. Dans les deux, les experts, qui font l'essentiel du modèle, sont en 4 bits. La différence est ailleurs : dans le Q4_K_M, tout ce qui n'est pas un expert est gardé en 8 bits (les couches récurrentes, la tête de sortie, l'attention, l'expert partagé). Le fichier fait 20,5 Go contre 19,6 Go pour le Q4_0 pur.
La différence de taille paraît faible. Elle ne l'est pas pour l'écriture : à chaque token, seuls quelques experts sont relus, alors que tout ce qui n'est pas un expert l'est à chaque fois. Ce sont justement ces parties qui sont en 8 bits.
Ces formats ont une histoire : le Q4_0 date du premier jour de Llama.cpp (le fichier d'exemple s'appelait déjà ggml-model-q4_0.bin) ; les formats K, dont le Q4_K_M, sont arrivés en juin 2023 avec la proposition « k-quants » d'Iwan Kawrakow.
Mesurer la fidélité
On compare chaque version quantifiée à une référence : le même modèle en 16 bits, calculé par transformers, la bibliothèque de référence. Toutes les versions reçoivent exactement les mêmes tokens, un texte de wikitext en anglais et un texte en français. À chaque position, on garde toute la distribution du token suivant, puis on mesure de combien elle s'écarte de celle de la référence (la divergence de Kullback-Leibler, KL : 0 si les deux distributions sont identiques). On compte aussi combien de fois le premier choix est le même.
| Modèle | Herbert, Q4_0 | Llama.cpp, Q4_0 | Llama.cpp, Q4_K_M |
|---|---|---|---|
| Qwen3.6 | 0,072 ; 87,8 % | 0,072 ; 87,6 % | 0,019 ; 94,2 % |
| Gemma 4 E4B | 0,041 ; 90,2 % | 0,038 ; 90,3 % | |
| Gemma 4 E2B | 0,057 ; 88,2 % | 0,053 ; 88,3 % |
KL sur wikitext, puis part des premiers choix identiques, mesurées sur le Ryzen 9 9900X. À format égal, Herbert et Llama.cpp s'écartent autant l'un que l'autre de la référence. C'est le format Q4_0 qui est moins fidèle, pour tous les moteurs ; le Q4_K_M est près de 4 fois plus fidèle (0,019 contre 0,072).
Un premier choix différent n'est pas une faute. Plus de 80 % des bascules tombent là où la référence hésitait déjà entre deux tokens presque à égalité.
Des réponses entières
Une mesure moyenne ne dit pas à quoi ressemble une réponse. J'ai posé 15 questions à cinq versions de Qwen3.6, aux entrées identiques : la référence en 16 bits, Herbert en Q4_0, Llama.cpp et ik_llama.cpp sur le même Q4_0, puis Llama.cpp en Q4_K_M.
- Les cinq versions sont identiques sur 3 questions.
- Herbert et Llama.cpp en Q4_0 sont identiques jusqu'au bout sur 8 questions ; dans 10 écarts sur 11, ils quittent la référence au même endroit avec le même mot.
- La plus grande ville du Canada : toutes les versions quantifiées répondent Montréal au lieu de Toronto, dès le 8e token. La référence hésitait déjà : 54,7 % contre 42,6 %.
- L'inflation : Herbert et Llama.cpp en Q4_0 donnent la même réponse, mot pour mot. Elle quitte la référence au 30e token en prenant son second choix (16,5 % contre 74 %) ; la troisième phrase perd l'indice des prix. Le Q4_K_M rend la réponse de la référence au token près.
- Sur 5 questions, le fond change. En pire sur 2 (l'inflation, le Canada), en mieux sur 3, où c'est la référence qui se trompait. Ce jugement sur le fond est le mien, à lire comme tel.
S'écarter de la référence n'est donc pas toujours faire moins bien. Et l'erreur la plus nette, le Canada, ne distingue ni les moteurs ni les formats.
La comparaison à format égal
Pour comparer ce qui est comparable, j'ai fabriqué un Q4_0 pur de Qwen3.6-35B-A3B à partir des mêmes poids, puis je l'ai donné à Llama.cpp et à ik_llama.cpp. Herbert, lui, quantifie au chargement selon la même règle. Deux exceptions : Herbert garde la table d'embeddings en 16 bits et deux projections des couches récurrentes en 32 bits, là où le fichier les met en Q4_0.
Prefill / décodage en tokens par seconde, médianes de 3, 128 tokens produits.
EPYC 4344P, 8 fils :
| Moteur | 627 tokens | 6 131 tokens |
|---|---|---|
| Herbert | 335 / 25,9 | 306 / 23,9 |
| Llama.cpp, Q4_0 pur | 171 / 23,9 | 156 / 20,8 |
| ik_llama.cpp, Q4_0 pur | 312 / 26,6 | 303 / 24,7 |
ik_llama.cpp -rtr, Q4_0 pur | 368 / 26,8 | 351 / 24,9 |
| Llama.cpp, Q4_K_M | 157 / 16,6 | 141 / 14,6 |
Ryzen 9 9900X, 12 fils :
| Moteur | 217 tokens | 621 tokens | 6 125 tokens |
|---|---|---|---|
| Herbert | 376 / 21,3 | 371 / 21,1 | 389 / 18,9 |
| Llama.cpp, Q4_0 pur | 239 / 18,7 | 260 / 18,6 | 248 / 17,2 |
| ik_llama.cpp, Q4_0 pur | 325 / 22,3 | 407 / 22,1 | 456 / 20,5 |
ik_llama.cpp -rtr, Q4_0 pur | 350 / 22,3 | 436 / 22,0 | 500 / 20,5 |
| Llama.cpp, Q4_K_M | 199 / 13,4 | 221 / 13,3 | 208 / 12,5 |
Face à Llama.cpp sur le même fichier, Herbert lit environ 2 fois plus vite sur l'EPYC et environ 1,5 fois sur le 9900X. Il écrit 8 à 13 % plus vite à environ 630 tokens. Face au Q4_K_M, l'écriture va environ moitié plus vite (25,9 contre 16,6), mais l'essentiel de cet écart vient du format : sur le même Q4_0, Llama.cpp passe de 16,6 à 23,9.
Face à ik_llama.cpp, c'est plus serré. Sur l'EPYC, Herbert est entre ses deux variantes en prefill (335, entre 312 et 368) et 3 % derrière en écriture. Sur le 9900X, Herbert est devant aux petites invites (376 contre 350) et derrière aux longues (389 contre 500) ; en écriture, il est de 4 à 8 % derrière.
Gemma 4, à poids QAT, EPYC 4344P, 8 fils, environ 630 tokens :
| Modèle | Herbert | Llama.cpp | ik_llama.cpp | ik_llama.cpp -rtr |
|---|---|---|---|---|
| E4B | 398 / 17,5 | 279 / 16,3 | ||
| 26B-A4B | 349 / 20,1 | 140 / 18,7 | 301 / 19,8 | 358 / 19,9 |
| E2B | 798 / 35,5 | 969 / 30,9 | 1 908 / 35,1 | 2 004 / 35,0 |
Sur Gemma 4 E2B, Llama.cpp est devant en prefill de 20 % et ik_llama.cpp va deux fois et demie plus vite qu'Herbert ; Herbert reste devant en écriture de 15 % sur Llama.cpp.
Ce que je n'explique pas encore
D'où vient le « 2 fois » en prefill sur Llama.cpp. J'ai fait les profils, je n'ai pas encore attribué l'écart.
Pourquoi le prefill d'ik_llama.cpp monte avec la longueur de l'invite sur le 9900X (325 puis 456) alors que celui d'Herbert reste à plat (376 puis 389).
Gemma 4 E2B : Llama.cpp devant de 20 %, ik_llama.cpp deux fois et demie plus rapide. C'est un modèle à étudier pour lui-même.
Les limites
Deux processeurs, tous deux avec AVX-512 : un EPYC 4344P et un Ryzen 9 9900X, sous Linux. La qualité n'est mesurée qu'en AVX-512. Une seule invite de banc, une requête à la fois. La comparaison à format égal porte sur Qwen3.6 et sur Gemma 4 à poids QAT.
Les moteurs de comparaison bougent de 2 à 4 % d'un passage à l'autre : c'est pour ça que je donne des rapports arrondis (« environ 2 fois ») plutôt que des décimales. Le banc de débit du 13 novembre n'avait pas de prédictions écrites avant ; ceux du 14 novembre en avaient : elles sont publiées avec le code (5 justes ou en partie, 2 fausses).
Versions mesurées : Llama.cpp 5676dfbe0, 7 commits avant son étiquette v1.0.0 (intégration continue, exemples retirés, numéros de version : aucun fichier de calcul touché) ; ik_llama.cpp 7aa7e014. Les deux sont sous licence MIT. Ces chiffres valent à la publication de cet article : les moteurs évoluent, certains ne seront peut-être plus vrais quand vous lirez ceci.
Reproduire chez soi
Le code est en ligne, sous licence MIT : github.com/xigh/herbert-jit-q4, étiquette v0.1.0. Le moteur, le serveur et tout le banc sont dans le même dépôt : les scripts tels qu'ils ont tourné, les données brutes et les prédictions écrites avant de mesurer, dans bench/.
git clone --branch v0.1.0 https://github.com/xigh/herbert-jit-q4.git cd herbert-jit-q4 && cargo build --release --locked --features serve target/release/herbert-jit-chat Qwen/Qwen3.5-0.8B --q4 --no-think --max-tokens 64 --ask "Quelle est la capitale de la France ?"
Il faut Rust stable et l'éditeur de liens du système. Les modèles se téléchargent avec l'outil de Hugging Face, hf ; le README du dépôt donne la commande exacte, le serveur compatible OpenAI et la façon de rejouer une ligne du banc. Le Q4_0 par défaut est celui de cet article. Si un chiffre vous semble faux, vous avez de quoi le vérifier.
La suite
Le prochain chantier pour Herbert, c'est d'avoir la fidélité du Q4_K_M en conservant au mieux les performances. Aujourd'hui ce format coûte de la vitesse d'écriture à tous les moteurs que j'ai mesurés : la question ouverte est d'avoir cette fidélité sans relire plus d'octets.
Il faudra aussi que je vous montre ce qu'il se passe quand on traite plusieurs requêtes à la fois. Herbert n'en sert qu'une pour l'instant. Relire les poids une seule fois pour écrire plusieurs tokens devrait rapporter, au moins pour écrire la réponse. Sauf pour les modèles à experts, où deux requêtes n'empruntent pas les mêmes experts au même moment. Et Qwen3.6, le modèle de cet article, en est justement un. Sur ce plan, pour le moment, tous les autres moteurs de la série sont bien plus performants.
Pour conclure, après plusieurs mois de travail, Herbert sort enfin publiquement. Il est déjà en production chez quelques-uns de nos clients et il est maintenant le cœur de mAIstrow.
Il reste beaucoup à faire, mais les fondations sont solides.
On descend d'un cran, ou plusieurs...
- On descend d'un cran : #000 un moteur d'inférence qui écrit son propre code · 03-oct-2026
- On descend d'un cran : #001 un compilateur pour moteur de LLM · 11-oct-2026
- On descend d'un cran : #002 le même compilateur sur un GPU · 18-oct-2026
- On descend d'un cran : #002.1 complément, l'Arc en f16 · 02-nov-2026
- On descend d'un cran : #003 ce que CUDA a et que Vulkan n'a pas · 25-oct-2026
- On descend d'un cran : #004 le même compilateur sur les puces d'Apple · 01-nov-2026
- On descend d'un cran : #005 Herbert meilleur que Llama.cpp ? · 15-nov-2026