Le problème que llamafile résout

Tu veux faire tourner un LLM en local. En 2026, le parcours classique ressemble à ça :

  • Installer Python 3.x, créer un venv, pip install les dépendances
  • Ou tirer une image Docker de 8 Go
  • Configurer CUDA, cuDNN, les drivers GPU
  • Ou passer par Ollama, plus simple, mais encore un daemon à gérer

Résultat : entre 30 minutes et 2 heures avant d'obtenir un « Hello world ». Et c'est sans compter les conflits de versions, les problèmes de droits, les machines sans accès internet.

llamafile propose une alternative radicale : un seul fichier. Tu le télécharges, tu le rends exécutable, tu le lances. C'est tout.

wget https://huggingface.co/.../model.llamafile
chmod +x model.llamafile
./model.llamafile

Pas de Python. Pas de Docker. Pas de CUDA obligatoire. Pas de gestionnaire de paquets. Le modèle tourne, un serveur web démarre sur localhost:8080, et tu peux commencer à discuter avec ton LLM.

Ce qui est dans le fichier

Un llamafile est un binaire autonome qui embarque trois choses :

  • Les poids du modèle au format GGUF (quantizations Q4_K_M, Q8_0, etc.)
  • llama.cpp compilé statiquement : le runtime d'inférence
  • Un serveur HTTP compatible avec l'API OpenAI (/v1/chat/completions), avec une interface web minimale incluse

Tout est lié statiquement. Zéro dépendance externe. Si un GPU est disponible, les kernels CUDA ou Metal sont chargés dynamiquement. Sinon, ça tourne sur CPU, plus lentement, mais ça tourne.

Le truc dingue : même binaire, six OS

Voici la partie qui rend llamafile techniquement fascinant. Le même fichier s'exécute nativement sur :

  • Linux (x86_64 et ARM64)
  • macOS Intel
  • macOS Apple Silicon
  • Windows
  • FreeBSD
  • OpenBSD / NetBSD

Pas d'émulation. Pas de couche de compatibilité. Exécution native sur chaque OS. Comment c'est possible ?

Cosmopolitan Libc : le socle invisible

« Build once, run anywhere » sans JVM

Derrière llamafile, il y a Cosmopolitan Libc, un projet créé par Justine Tunney. L'idée : compiler du C une seule fois et obtenir un binaire qui tourne sur n'importe quel OS.

La différence avec Java : pas d'interpréteur, pas de machine virtuelle. C'est du code natif. Cosmopolitan remplace la libc standard par une implémentation qui détecte l'OS au runtime et redirige les appels système vers les bonnes API, POSIX sur Linux/macOS/BSD, Win32 sur Windows.

Comment ça fonctionne concrètement

Cosmopolitan intercepte les syscalls. Quand ton programme appelle open(), read() ou mmap(), Cosmopolitan détecte sur quel OS il tourne et traduit l'appel vers l'API native :

  • Sur Linux : syscalls POSIX directs
  • Sur macOS : appels Mach + POSIX
  • Sur Windows : traduction vers l'API Win32 (CreateFile, ReadFile, etc.)
  • Sur BSD : variantes POSIX spécifiques

Pour llamafile spécifiquement, Justine Tunney a ajouté le support de dlopen() dans Cosmopolitan, indispensable pour charger dynamiquement les drivers GPU (CUDA, Metal, ROCm) sans les embarquer dans le binaire.

Le format APE : Actually Portable Executable

Un fichier polyglotte

Le format APE est l'invention clé. C'est un polyglot binary : un seul fichier qui est simultanément valide comme :

  • ELF (Linux, BSD)
  • Mach-O (macOS)
  • PE (Windows)
  • ZIP (pour embarquer les ressources)
  • Script shell POSIX (pour le bootstrap)

Comment un fichier peut-il être reconnu par autant de loaders différents ? Le trick repose sur la structure des headers.

Le trick du shell script en préfixe

Les premières lignes du fichier sont du shell script POSIX valide. Le fichier commence par #!/bin/sh ou un équivalent. Sur un système Unix, si le kernel ne reconnaît pas le format binaire, il tombe sur le shebang et exécute le script, qui à son tour lance le binaire correctement.

Mais ces mêmes octets sont aussi interprétés différemment par les autres loaders :

  • Linux : le kernel reconnaît le magic ELF plus loin dans le fichier, charge directement
  • macOS : le loader Mach-O trouve son header à l'offset attendu
  • Windows : le PE header (MZ) est positionné pour que CreateProcess l'accepte

Le résultat : chaque OS exécute le même fichier via son loader natif, sans savoir que les autres formats sont également présents dans le même binaire.

Le ZIP embarqué

Le format ZIP a une particularité utile : le répertoire central est à la fin du fichier, pas au début. Cosmopolitan en profite pour coller les headers ELF/Mach-O/PE au début et les données ZIP à la fin. C'est dans cette archive ZIP que llamafile stocke les poids du modèle au format GGUF, parfois plusieurs gigaoctets.

Limitations à connaître

llamafile n'est pas parfait. Quelques points à garder en tête :

  • Windows : limite de taille : les anciens systèmes de fichiers (FAT32, certains NTFS) limitent les fichiers à 4 Go. Pour les gros modèles, il faut parfois séparer poids et runtime.
  • Performance GPU : légèrement en retrait par rapport à llama.cpp compilé nativement sur certaines configurations. L'overhead de la couche Cosmopolitan existe, même s'il reste marginal.
  • Mise à jour : pas de hot-swap des poids. Nouveau modèle = nouveau fichier à télécharger.
  • Apple Silicon : Metal est supporté, les performances sont correctes, mais pas aussi optimisées qu'un llama.cpp compilé spécifiquement pour M1/M2/M3.

Malgré ces limites, pour le cas d'usage visé, déploiement rapide, démo, environnement isolé, le compromis est largement acceptable.

Cas d'usage concrets

Concrètement

llamafile transforme un LLM en outil CLI distribuable. Même modèle mental qu'un binaire Go ou Rust : tu donnes le fichier, ça marche.

  • Démo client : tu arrives avec ton laptop, tu double-cliques, le LLM tourne. Pas de « attendez, je configure le Docker ».
  • Environnement air-gapped : réseaux déconnectés, zones sensibles, machines sans internet. Un fichier sur clé USB, c'est tout.
  • POC interne : pas besoin de provisionner un serveur cloud ou de demander des droits admin. Le dev lance le fichier sur sa machine.
  • Formation : distribuer un LLM fonctionnel à 20 participants en 3 minutes au lieu de 2 heures de setup.

Qui est derrière

Justine Tunney n'est pas une inconnue. Anciennement chez Google, elle est l'autrice de Cosmopolitan Libc et de Redbean, un serveur web distribué comme un seul fichier ZIP exécutable, déjà basé sur le format APE.

llamafile est né chez Mozilla Ocho (la branche innovation de Mozilla), le repo initial étant hébergé sur Mozilla-Ocho/llamafile. Il a depuis migré vers mozilla-ai/llamafile, signe d'une intégration plus formelle dans la stratégie IA de Mozilla.

Le projet est open source (licence Apache 2.0) et activement maintenu.

Pour aller plus loin

  • Compiler son propre llamafile : tu peux prendre n'importe quel modèle GGUF et le packager en llamafile avec l'outil zipalign fourni dans le repo
  • Ajouter des fichiers statiques : le ZIP embarqué accepte des ressources supplémentaires (fichiers de config, prompts système, pages HTML custom pour l'interface web)
  • Mode serveur : llamafile peut tourner comme serveur permanent avec l'API OpenAI-compatible, remplaçant Ollama pour les setups minimalistes
Le meilleur outil, c'est celui que tu n'as pas besoin d'installer.
#LLM #OpenSource #Cosmopolitan #llamafile #DevTools #legeektech