Llamafile : un LLM complet dans un seul fichier exécutable

#Pourquoi llamafile

La plupart des outils LLM locaux demandent une installation, un service en arrière-plan, puis le téléchargement d'un modèle. Llamafile supprime toutes ces étapes : le moteur d'inférence et les poids du modèle vivent dans un unique fichier. Vous le rendez exécutable, vous le lancez, et votre navigateur ouvre une interface de chat. C'est la manière la plus courte d'aller d'un lien de téléchargement à une conversation avec un modèle en local.

Ce format brille dans trois situations. Pour tester rapidement un modèle sans polluer sa machine. Pour distribuer un LLM à des collègues ou des utilisateurs non techniques : un seul fichier à envoyer, rien à configurer. Et pour l'archivage : un llamafile fonctionnera encore dans des années, sans dépendre d'un runtime à installer ou d'un dépôt en ligne toujours accessible.

Zéro installation

Aucun paquet, aucun daemon, aucune variable d'environnement à régler.

Un seul fichier

Moteur + modèle réunis, facile à copier, sauvegarder ou partager.

Multi-OS

Le même binaire tourne sur Windows, macOS, Linux, BSD (x86-64 et ARM64).

100 % local

Aucune donnée ne quitte la machine, aucune connexion réseau requise après le téléchargement.

#Comment ça marche : le format Mozilla

Llamafile combine deux briques open source. La première est llama.cpp, le moteur d'inférence C/C++ qui exécute les modèles au format GGUF sur CPU comme sur GPU. La seconde est Cosmopolitan Libc, une bibliothèque signée Justine Tunney qui permet de compiler un exécutable « polyglotte » : un même fichier binaire reconnu et lancé nativement par plusieurs systèmes d'exploitation.

Concrètement, un fichier .llamafile est à la fois un programme et une archive. Il contient le code du serveur d'inférence et, empaqueté à l'intérieur, le fichier GGUF des poids. Au lancement, il détecte l'OS et l'architecture, charge le modèle depuis lui-même, puis démarre un serveur HTTP local avec une interface web de chat.

#Prérequis

Les besoins sont volontairement minimes. L'essentiel est d'avoir assez de mémoire pour le modèle choisi, la taille du fichier et la RAM nécessaire dépendant directement de la quantification.

OS

Windows 10+, macOS 11+, Linux récent ou BSD. x86-64 ou ARM64 (Apple Silicon inclus).

RAM

Compter grosso modo la taille du fichier + une marge. Un modèle 7B en Q4 (~5 Go) tourne confortablement sur 8 à 16 Go.

GPU (optionnel)

Accélération possible via NVIDIA (CUDA) ou Apple Metal. Sans GPU, l'inférence se fait sur CPU, plus lente mais fonctionnelle.

Espace disque

De ~500 Mo pour un petit modèle à plusieurs dizaines de Go pour un gros modèle non quantifié.

#Télécharger et lancer en quelques secondes

Le dépôt officiel Mozilla-Ocho/llamafile sur GitHub liste des llamafiles prêts à l'emploi, et Hugging Face en héberge de nombreux autres. Une fois le fichier récupéré, la marche à suivre diffère à peine selon l'OS.

1. 01
   Télécharger le fichier

   Récupérez un .llamafile depuis la page GitHub du projet ou depuis Hugging Face (cherchez « llamafile » dans la barre de recherche des modèles).
2. 02
   macOS et Linux : rendre exécutable

   Ouvrez un terminal dans le dossier de téléchargement et autorisez l'exécution avec chmod, puis lancez le fichier.
3. 03
   Windows : renommer en .exe

   Ajoutez l'extension .exe au nom du fichier, puis double-cliquez dessus (ou lancez-le depuis PowerShell).
4. 04
   Ouvrir l'interface

   Le programme démarre un serveur local et ouvre en général automatiquement votre navigateur. Sinon, rendez-vous sur http://localhost:8080.

# Rendre le fichier exécutable
chmod +x Llama-3.2-3B-Instruct.Q4_K_M.llamafile

# Lancer : ouvre l'interface web sur http://localhost:8080
./Llama-3.2-3B-Instruct.Q4_K_M.llamafile

# Renommer pour ajouter l'extension .exe
Rename-Item .\Llama-3.2-3B-Instruct.Q4_K_M.llamafile Llama-3.2-3B.exe

# Lancer
.\Llama-3.2-3B.exe

#Le même fichier sur Windows, Mac et Linux

C'est la promesse la plus surprenante de llamafile : le fichier que vous téléchargez sur Linux est exactement le même que celui qui tournera sur un Mac ou un PC Windows. Aucune version « Windows », « Mac » ou « Linux » à choisir. Cette portabilité vient de Cosmopolitan Libc, qui produit un exécutable compris par plusieurs systèmes à la fois.

En pratique, cela veut dire qu'un même llamafile posé sur une clé USB ou un partage réseau fonctionne pour toute une équipe, quels que soient leurs postes. Vous distribuez un modèle sans vous soucier de l'OS de chacun, ni demander à personne d'installer quoi que ce soit.

#Options utiles en ligne de commande

L'interface web suffit pour discuter, mais quelques options permettent d'ajuster le comportement. Elles se passent après le nom du fichier au lancement.

-ngl N

Décharge N couches du modèle sur le GPU (par exemple -ngl 999 pour tout mettre en VRAM si elle est suffisante).

-c N

Fixe la taille de la fenêtre de contexte en tokens (ex. -c 4096).

--host / --port

Change l'adresse et le port d'écoute du serveur (par défaut localhost:8080).

-m fichier.gguf

Utilise un fichier de poids externe plutôt que celui embarqué — utile pour contourner la limite Windows des 4 Go.

--server --nobrowser

Démarre en mode serveur sans ouvrir de navigateur, pratique pour un usage headless.

# Tout charger sur le GPU, contexte 8k, port personnalisé
./Llama-3.2-3B-Instruct.Q4_K_M.llamafile -ngl 999 -c 8192 --port 8090

# Serveur headless avec un GGUF externe (contourne la limite 4 Go)
./llava-v1.5-7b-q4.llamafile --server --nobrowser -m modele.gguf

Le serveur expose aussi une API compatible OpenAI sur /v1/chat/completions. Vous pouvez donc brancher un llamafile derrière n'importe quel client qui parle le protocole OpenAI, en pointant simplement l'URL de base sur http://localhost:8080/v1.

#Créer son propre llamafile

Vous n'êtes pas limité aux fichiers préparés par d'autres : n'importe quel modèle GGUF peut être empaqueté. Le projet fournit un binaire zipalign et un exécutable « vide » (le moteur seul) auquel on ajoute le fichier de poids et un fichier d'arguments par défaut.

1. 01
   Récupérer les outils

   Téléchargez la dernière release depuis GitHub : elle contient le binaire llamafile (moteur seul) et l'utilitaire zipalign.
2. 02
   Avoir un GGUF

   Procurez-vous le fichier .gguf du modèle voulu depuis Hugging Face, dans la quantification de votre choix (Q4_K_M est un bon compromis).
3. 03
   Écrire les arguments par défaut

   Créez un fichier .args listant les options à appliquer au lancement (modèle, interface web, etc.).
4. 04
   Empaqueter avec zipalign

   Copiez le moteur sous un nouveau nom, puis injectez-y le GGUF et le fichier .args avec zipalign.
5. 05
   Tester

   Rendez le résultat exécutable et lancez-le comme n'importe quel llamafile.

# Fichier d'arguments par défaut
cat > .args <<'EOF'
-m
modele.Q4_K_M.gguf
--host
0.0.0.0
...
EOF

# Copier le moteur, puis y injecter poids + args
cp llamafile mon-modele.llamafile
zipalign -j0 mon-modele.llamafile modele.Q4_K_M.gguf .args

# Tester
chmod +x mon-modele.llamafile
./mon-modele.llamafile

#Llamafile vs Ollama : deux philosophies

Llamafile et Ollama répondent au même besoin — faire tourner un LLM en local — mais avec des logiques opposées. Ollama installe un daemon qui écoute sur http://localhost:11434 et gère une bibliothèque de modèles téléchargés à la demande. Llamafile ne gère rien : chaque modèle est un fichier autonome que vous lancez directement.

Modèle mental

Ollama = gestionnaire de modèles avec daemon central. Llamafile = un fichier = un modèle, sans service.

Installation

Ollama s'installe une fois puis « pull » les modèles. Llamafile ne s'installe pas du tout.

Distribution

Partager un modèle Ollama suppose que l'autre installe Ollama. Un llamafile se donne tel quel, il tourne partout.

Gestion de plusieurs modèles

Ollama excelle : un daemon, une commande run, swap instantané. Llamafile devient vite lourd (un gros fichier par modèle).

Intégration

Les deux exposent une API compatible OpenAI. Ollama a un écosystème d'interfaces plus riche.

Le partage se résume ainsi : llamafile gagne pour tester ponctuellement, distribuer à des non-techniciens ou archiver un modèle figé ; Ollama gagne dès qu'on jongle avec plusieurs modèles au quotidien ou qu'on intègre un LLM dans une stack durable avec une interface comme Open WebUI ou LM Studio.

#Dépannage

« run-detectors » ou refus de lancement (Linux)

Un binutils/binfmt trop zélé peut bloquer le format polyglotte. Solution : installer le paquet APE loader, ou lancer via sh -c "./fichier.llamafile".

Fichier trop gros sur Windows

Au-delà de 4 Go, gardez le GGUF séparé et passez-le avec -m à un petit llamafile « moteur seul ».

Pas d'accélération GPU

Vérifiez que les pilotes CUDA (NVIDIA) sont présents et ajoutez -ngl 999. Sur Mac, Metal est utilisé automatiquement.

Port déjà occupé

Un autre service tourne sur 8080 : changez avec --port 8090 par exemple.

Réponses lentes

Sur CPU seul, c'est attendu pour les gros modèles. Choisissez une quantification plus légère ou un modèle plus petit (3B plutôt que 7B).

#Pour aller plus loin

Llamafile est une porte d'entrée idéale. Pour un usage local plus complet et durable, ces guides prolongent le sujet.

Installer un LLM en local

Le panorama des méthodes et outils pour bien démarrer et choisir la bonne approche selon sa machine.

Ollama vs llama.cpp

Comprendre le moteur qui fait tourner llamafile, et quand passer à llama.cpp nu pour plus de contrôle.

Alternatives à Ollama

Le tour d'horizon 2026 des outils LLM locaux, où llamafile trouve sa place aux côtés de LM Studio, Jan et vLLM.