Comment exécuter un modèle de 26 milliards de paramètres dans deux gigaoctets de mémoire sur un Mac ordinaire

Si vous avez un simple MacBook Air avec M2 et 8 Go de mémoire unifiée, exécuter des modèles de langage modernes devient une histoire triste. Même un modèle modeste de 14 à 20 milliards de paramètres après quantification 4 bits nécessite 10 à 16 Go de RAM. Le système commence à échanger agressivement des données sur le disque, la vitesse de génération chute à des fractions de token par seconde, et l'interface macOS commence à se figer.

L'ingénieur Andrey Mikhailov a résolu ce problème avec une astuce d'ingénierie non conventionnelle. Il a écrit de zéro un runtime appelé TurboFieldfare qui exécute le modèle d'instruction Gemma 4 26B-A4B de Google dans seulement 2 Go de RAM.

En quoi consiste l'astuce principale de l'architecture

Gemma 4 26B-A4B repose sur une architecture de mélange d'experts (MoE). Le modèle totalise 26 milliards de paramètres, mais lors du traitement d'un token spécifique, tous les calques ne sont pas activés — seulement environ 3,88 milliards de paramètres.

En règle générale, les runtimes comme llama.cpp ou MLX chargent l'intégralité des poids du modèle en mémoire avant de commencer le travail. Pour Gemma en 4 bits, cela représente environ 14,3 Go. TurboFieldfare fait les choses différemment :

• Le cœur partagé du modèle pesant 1,35 Go et le KV-cache FP16 pour le contexte sont conservés en RAM persistante.
• Le routeur du modèle à chaque calque détermine quels 8 experts sont nécessaires pour le token actuel.
• Le programme vérifie le cache local des experts en mémoire (16 emplacements avec un algorithme LFU).
• Si l'expert requis n'est pas en RAM, le runtime le charge rapidement directement depuis le SSD via des appels système parallèles pread dans des buffers accessibles à Metal.

Pendant que le GPU calcule la branche des experts partagés, un thread CPU parallèle parvient à lire les poids manquants depuis le stockage. En résultat, la consommation de mémoire maximale reste dans environ 2 Go.

Aucune dépendance envers llama.cpp et MLX

Le projet est écrit purement en Swift 6.2 et Metal 4. L'auteur n'a pas créé un autre wrapper autour de bibliothèques C++ existantes — il a écrit des noyaux GPU personnalisés pour la quantification, la multiplication matricielle (GEMV), l'attention, le MoE, la normalisation RMSNorm et RoPE.

Le dépôt inclut quatre utilitaires prêts à l'emploi :

1. TurboFieldfareMac — une application de bureau native construite avec SwiftUI et AppKit présentant un chat intégré, une surveillance de la mémoire et des paramètres de génération.
2. TurboFieldfareCLI — une interface en ligne de commande pour la génération par lots et l'exécution pilotée par des scripts via des fichiers de messages JSON.
3. TurboFieldfareServer — un serveur local avec une API compatible avec la spécification OpenAI Chat Completions (http://127.0.0.1:8080/v1).
4. TurboFieldfareRepack — un utilitaire pour le streaming des téléchargements de poids depuis Hugging Face directement dans le format personnalisé .gturbo.

L'installateur télécharge uniquement les plages d'octets requises et les assemble à la volée. Vous n'aurez pas besoin de télécharger d'abord 15 Go de poids source puis de conserver encore 15 Go du fichier converti à côté.

Performances réelles

Les lectures en streaming depuis le disque créent inévitablement une latence d'E/S. Il n'y a pas de miracles : la vitesse de génération dépend directement du débit du SSD et d'un cache rapide.

L'auteur a réalisé une série de benchmarks sur différentes générations d'Apple Silicon :

• Sur un MacBook Air M2 de base avec 8 Go de RAM, la vitesse atteint 5,1 à 6,3 tokens par seconde. C'est un rythme confortable pour lire du texte en temps réel.
• Sur un MacBook Pro avec M5 Pro et 24 Go de mémoire, la vitesse de génération atteint 31 à 35 tokens par seconde.

Pour la phase de préfill (traitement de l'invite entrante), l'auteur a implémenté un chunking à 128 tokens. Cela permet d'invoquer un seul expert chargé pour un groupe de lignes à la fois, réduisant заметно le temps jusqu'au premier token.

Comment compiler et exécuter

La compilation nécessite un Mac Apple Silicon exécutant une version actuelle de macOS et Xcode avec le support de Swift 6.2.

Clonez le dépôt et compilez le projet en mode release :

git clone https://github.com/drumih/turbo-fieldfare.git
cd turbo-fieldfare
swift build -c release

Après la compilation, lancez l'application native :

.build/release/TurboFieldfareMac

Lors du premier lancement, cliquez sur le bouton Download. L'application téléchargera le modèle (environ 15 Go d'espace disque libre requis) et préparera le répertoire scratch/gemma4.gturbo. Une fois le téléchargement terminé, cliquez sur Load Model et entrez votre requête dans le champ de saisie.

Si vous préférez la console, vous pouvez télécharger le modèle avec une commande séparée :

swift run -c release TurboFieldfareRepack \
  --output scratch/gemma4.gturbo \
  --overwrite

Puis transmettez un fichier de dialogue au CLI :

swift run -c release TurboFieldfareCLI \
  --model scratch/gemma4.gturbo \
  --messages-file messages.json

Et pour connecter des clients locaux comme OpenCode ou des scripts Python personnalisés, lancez simplement le serveur :

.build/release/TurboFieldfareServer --model scratch/gemma4.gturbo

Le serveur écoute sur le port 8080 et expose les endpoints familiers /v1/chat/completions avec support du streaming et des tool calls.

Où le projet sera utile en pratique

Ce n'est pas un moteur universel pour n'importe quels poids. TurboFieldfare est strictement adapté à un modèle spécifique — Gemma 4 26B-A4B. Mais dans sa niche, le projet couvre plusieurs scénarios concrets :

• Assistant développeur local sur des laptops d'entrée de gamme. Si vous avez 8 Go de RAM, exécuter un modèle 26B d'une autre manière sans figer l'ensemble du système est pratiquement impossible.
• Serveur d'arrière-plan pour les tool calls et le parsing de texte via l'interface loopback sans envoyer de données confidentielles vers le cloud.
• Ressource d'apprentissage pour l'optimisation Metal de bas niveau. Le dépôt inclut un journal de 103 expériences détaillées avec des benchmarks pour les vitesses de lecture, la mise en cache et les performances des noyaux GPU.

Si vous souhaitez exécuter des modèles MoE volumineux localement sur un MacBook de base ou que vous êtes intéressé par l'écriture de shaders Metal personnalisés pour le ML, le dépôt mérite certainement d'être cloné et étudié.