Créer un clone local de Angry Birds à l’aide de Qwen3.8-27B et d’une Pi

Angry Birds — moteur physique, mécanisme de fronde, tours qui s’effondrent, le tout — en utilisant uniquement un modèle local fonctionnant sur du matériel grand public ordinaire ? Aucune clé API cloud, aucune facturation par usage, aucun code ne quittant la machine.

Cela a fonctionné. Des oiseaux ont volé à travers l’écran, des blocs en bois se sont renversés, et des cochons ont été écrasés au moment de l’impact. Le modèle qui permettait tout cela était Qwen3.8-27B, exécuté à l’intérieur de LM Studio et géré par Pi, un agent de codage open source basé sur une interface en ligne de commande. Ce qui suit décrit l’ensemble de la configuration : une introduction au modèle et à la raison pour laquelle il offre des performances supérieures à celles attendues malgré sa taille réduite adaptée à un seul Mac, ainsi que les étapes précises pour installer LM Studio, installer Pi, et relier les deux afin que Pi envoie ses requêtes vers votre modèle local plutôt qu’à un fournisseur hébergé.

Pourquoi choisir une solution locale ?

La motivation principale est le coût et le contrôle. En exécutant tout localement, vous bénéficiez de :

• Aucun frais d’API, quel que soit le nombre d’heures passées à travailler sur un projet amateur.

Un code qui ne quitte jamais votre propre machine — un véritable avantage si vous travaillez sur des éléments que vous préférez ne pas envoyer à un tiers.

Aucune limitation de vitesse et aucune interruption liée à une « limite d’utilisation atteinte » au cours de la session.

Ce que vous sacrifiez, c’est la vitesse de génération brute et, traditionnellement, la qualité du résultat. Cependant, cet écart s’est réduit bien plus rapidement que la plupart des gens ne le pensent, et Qwen3.8-27B est une démonstration convaincante de ce à quoi peut atteindre un modèle d’environ 27 milliards de paramètres une fois qu’il a été soigneusement entraîné et quantifié pour fonctionner sur du matériel grand public.

Découvrez le modèle : Qwen3.8–27B

Qwen3.8-27B provient de l’équipe Qwen d’Alibaba. Il s’agit d’un modèle dense avec prise en charge de la vision, publié sous la licence Apache 2.0, ce qui permet son utilisation gratuite même dans des projets commerciaux. Avant de procéder à un téléchargement de plus de 16 GB, voici les spécifications importantes à connaître :

Architecture

• 27 milliards de paramètres, répartis sur 64 couches avec une dimension cachée de 5 120
• Un schéma d’attention hybride : des blocs répétés qui associent l’attention linéaire « Gated DeltaNet » à une couche d’attention à portes standard, ce qui permet au modèle de rester rapide même lorsque le contexte s’agrandit
• Une fenêtre de contexte native de 262 144 tokens, pouvant être étendue jusqu’à 1 000 000
• Un entraînement intégrant la prédiction de plusieurs tokens, ce qui améliore considérablement la vitesse d’inférence locale

Résultats des benchmarks (comme rapporté par Qwen, avec des comparaisons avec Opus 4.6 Max d’Anthropic lorsque c’est pertinent) :

Le point principal à retenir est qu’un modèle de 27 milliards d’unités parvient à égaler, voire à surpasser, un modèle à poids fixe de pointe sur les benchmarks de programmation et d’agentivité, ce qui explique pourquoi il constitue un choix viable au quotidien pour des systèmes comme l’agent Pi. Il s’agit de chiffres fournis par les développeurs eux-mêmes, ce qui justifie un certain scepticisme en attendant des tests indépendants — mais les résultats obtenus lors de la mise en œuvre d’Angry Birds, décrits plus loin, confirment ces affirmations.

Un point à prendre en compte dès le début : Qwen3.8-27B dispose par défaut d’une capacité de « réflexion » (raisonnement) étendue, configurée au niveau d’effort xhigh. Cela est utile pour des tâches véritablement difficiles, mais cela signifie également que le modèle peut consommer des milliers de tokens de raisonnement pour des demandes simples qui n’exigent pas autant de réflexion. Pour les tâches courantes d’agent de codage, il suffit de réduire l’effort de raisonnement à medium ou low dans les paramètres du modèle de LM Studio pour obtenir des réponses nettement plus rapides sans grande perte en qualité. Réservez xhigh aux problèmes qui le nécessitent vraiment.

Les quantifications disponibles pour exécuter le modèle localement incluent GGUF et MLX, chacune proposée en précision 4 bits, 5 bits, 6 bits et 8 bits. MLX est la version conçue spécifiquement pour Apple Silicon.

Pour les utilisateurs de Mac, les exigences en mémoire se répartissent approximativement comme suit, ce qui permet de déterminer quel niveau de quantification convient le mieux à votre matériel :

À titre de référence, un Mac mini équipé du processeur M4 et disposant de 32 gigaoctets de mémoire système partagée peut exécuter la version quantisée en 4 bits à un rythme d’environ 5 à 6 tokens générés par seconde. Ce n’est pas très rapide en termes absolus, mais c’est tout à fait suffisant pour un agent dont la tâche est d’écrire et de modifier du code plutôt que de diffuser du texte en direct. Avec des processeurs Apple Silicon plus puissants — les modèles Max ou Ultra — ou une carte graphique Nvidia performante, le débit augmente considérablement ; certaines études indiquent que les performances quantisées atteignent une fourchette de 15 à 30 tokens par seconde sur des configurations grand public plus robustes.

Étape 1 : Installer LM Studio

LM Studio est l’application de bureau chargée de charger le modèle localement et de le rendre accessible via un serveur API compatible avec OpenAI. C’est ce serveur avec lequel Pi communiquera réellement.

Téléchargez-le depuis la page officielle de téléchargement — des versions pour macOS, Windows et Linux sont disponibles.

Installez-le comme n’importe quel autre programme de bureau, puis lancez-le.

Étape 2 : Télécharger Qwen3.8–27B depuis LM Studio

1. Dans LM Studio, ouvrez le panneau de recherche/découverte des modèles.
2. Recherchez qwen/qwen3.8-27b, ou accédez directement à sa page de modèle sur le site de LM Studio.

Choisissez le niveau de quantification adapté à votre matériel en fonction de la répartition mémoire mentionnée précédemment — pour la plupart des ordinateurs disposant de 24 à 32 Go de RAM, la version MLX 4 bits offre un bon équilibre. Si vous souhaitez examiner les poids avant téléchargement, les mêmes fichiers quantifiés par la communauté peuvent être consultés directement sur Hugging Face.

Téléchargez le modèle, puis chargez-le depuis l’onglet Chat ou l’onglet Mes modèles. Pendant le chargement, définissez une longueur de contexte qui reste confortablement dans les limites de votre mémoire disponible — 16 K constitue une valeur par défaut raisonnable, et vous pouvez l’augmenter si vous avez de la marge.

Au préalable, ouvrez le panneau de configuration du modèle et réduisez le niveau d’effort de raisonnement de xhigh à medium ou low pour les tâches de codage et d’agent, pour les mêmes raisons évoquées précédemment.

Étape 3 : Démarrer le serveur local de LM Studio

Cette étape pose problème à beaucoup de personnes — charger un modèle dans l’interface de chat ne le rend pas automatiquement disponible en tant qu’API.

1. Passez à l’onglet Développeur dans LM Studio.
2. Activez Démarrer le serveur.
3. Par défaut, cela publie une extrémité compatible OpenAI à l’adresse http://localhost:1234/v1.

curl http://localhost:1234/v1/models

La réponse JSON doit lister qwen/qwen3.8-27b (ou l’identifiant exact qui sera utilisé) — notez bien cette chaîne de caractères, car vous en aurez besoin bientôt.

Étape 4 : Installer Pi

Pi est un agent de codage open source basé sur la ligne de commande. Il prend en charge le principe « bring-your-own-key » et est indépendant des modèles, conçu dès le départ pour fonctionner aussi bien avec les fournisseurs de services cloud qu’avec des serveurs locaux compatibles OpenAI tels que LM Studio ou Ollama.

L’installateur officiel :

curl -fsSL https://pi.dev/install.sh | sh

Ou, si vous préférez utiliser npm :

npm install -g @earendil-works/pi-coding-agent

Vérifiez que l’installation a réussi :

pi --version

La documentation complète est disponible à pi.dev/docs/latest.

Étape 5 : Diriger Pi vers votre modèle local LM Studio

Pi stocke sa configuration de fournisseur dans ~/.pi/agent/models.json. Ouvrez ce fichier (en le créant si nécessaire) et ajoutez une entrée qui fait référence au serveur local de LM Studio :

{
  "providers": {
    "lmstudio": {
      "baseUrl": "http://localhost:1234/v1",
      "api": "openai-completions",
      "apiKey": "lm-studio",
      "models": [
        {
          "id": "qwen/qwen3.8-27b",
          "input": ["text"],
          "contextWindow": 65536,
          "reasoning": true
        }
      ]
    }
  }
}

Quelques détails ici peuvent facilement être mal compris :

• baseUrl doit correspondre exactement à l’adresse affichée dans l’onglet Développeur de LM Studio, qui est par défaut http://localhost:1234/v1.
• apiKey peut contenir n’importe quel texte de remplacement — le serveur local de LM Studio ne le validera pas, mais Pi ne affichera pas le modèle tant que ce champ n’est pas rempli.
• models[].id doit correspondre, caractère par caractère, à ce que LM Studio renvoie avec curl http://localhost:1234/v1/models. Une petite différence à cet égard est la cause la plus fréquente pour laquelle un modèle local n’apparaît pas à l’endroit attendu.
• contextWindow doit refléter la longueur de contexte que vous avez réellement configurée lors du chargement du modèle, et non sa valeur maximale absolue.

~/.pi/agent/settings.json :

{
  "defaultProvider": "lmstudio",
  "defaultModel": "qwen/qwen3.8-27b"
}

Après avoir redémarré le Pi — ou exécuté /model au sein d’une session déjà ouverte — sélectionnez lmstudio / qwen/qwen3.8-27b. À partir de ce moment, toutes les requêtes envoyées par le Pi restent sur votre propre machine ; rien n’est transmis en dehors de votre réseau local.

Création de l’étape Angry Birds

Lorsque tout était prêt, l’étape suivante consistait à donner au Pi une consigne délibérément floue : créer un seul niveau jouable dans un navigateur, dans le style d’Angry Birds — avec une mécanique de fronde, des lois physiques pour les projectiles, une pile de blocs pouvant être détruite, et un cochon à faire tomber — tout cela regroupé dans une seule page HTML/JS/Canvas autonome.

Ce qui était intéressant, ce n’était pas seulement le fait qu’il ait généré une version fonctionnelle dès la première tentative sérieuse — ce qui n’est arrivé qu’après avoir réduit l’effort de raisonnement à medium. À xhigh, le modèle a consommé un nombre énorme de tokens à remettre en question des constantes physiques élémentaires avant même d’écrire une seule ligne de code. Une fois correctement ajusté, il a pu raisonner de manière cohérente sur :

• La mécanique de lancement par tir et le mouvement des projectiles pour la fronde
• Un cycle physique de base couvrant la gravité, les collisions et le renversement des blocs
• Le fait de conserver tout le système dans un seul fichier JavaScript propre, qu’il pouvait réviser au fil des essais sans perdre trace de ce qu’il avait déjà écrit

C’est précisément le type de travail de codage par agent que des outils d’évaluation tels que SWE-bench Pro, Terminal-Bench et LiveCodeBench sont conçus pour mesurer, et le comportement observé correspond à ce que ces scores laissent supposer. Il ne s’agit pas d’un simple tour de passe-passe de chatbot — c’est un modèle capable de mener à bien une session de codage en plusieurs fichiers et tours, du début à la fin, entièrement hors ligne, sur le matériel que vous avez déjà sur votre bureau.

Conseils pratiques si vous installez cela vous-même

• Préférez un effort de raisonnement moyen par défaut. Réservez xhigh aux défis architecturaux ou algorithmiques vraiment difficiles. Dans les boucles de codage par agent courantes, cela ne fait qu’augmenter la latence sans améliorer les résultats.

Adaptez la taille de votre fenêtre de contexte en fonction de la RAM disponible, et non selon le plafond théorique du modèle. Une fenêtre de contexte de 262 K – ou l’option étendue à 1 M – semble impressionnante sur papier, mais avec environ 64 KB de cache KV par token, les contextes longs consomment de la mémoire extrêmement rapidement. Une plage de 16 K à 64 K constitue un objectif plus réaliste pour la plupart des ordinateurs dotés d’une seule GPU ou des systèmes Apple Silicon.

Vérifiez soigneusement l’identifiant du modèle. La raison la plus fréquente d’échec d’une configuration locale est une entrée dans models.json qui ne correspond pas précisément à l’ID indiqué par LM Studio.

Calibrez vos attentes en termes de débit. Vous pouvez vous attendre à des vitesses comprises entre une dizaine et une vingtaine de tokens par seconde, et non au rythme d’une API cloud. C’est un compromis raisonnable pour fonctionner gratuitement sans que les données quittent votre machine, mais il convient de le prendre en compte, surtout sur du matériel moins performant.

En résumé

Il n’y a pas si longtemps, demander à un modèle entièrement local de créer un jeu jouable basé sur la physique aurait semblé ambitieux. Aujourd’hui, un modèle de 27 milliards de paramètres quantifié pour fonctionner correctement sur un seul Mac, associé à un agent terminal open source léger, a réussi à le créer en une après-midi. Si vous disposez de 24 Go ou plus de mémoire unifiée, ou d’une GPU suffisamment puissante qui reste inutilisée, cette configuration constitue un moyen vraiment agréable et sans coût marginal pour mesurer l’évolution des outils de programmation en IA locale.

Ressources mentionnées dans ce guide :

La page de téléchargement de LM Studio se trouve à lmstudio.ai/download, et sa fiche pour ce modèle en particulier est accessible sous lmstudio.ai/models/qwen/qwen3.8-27b. Les poids MLX quantifiés sont eux-mêmes hébergés sur Hugging Face dans l’espace de noms lmstudio-community, sous le nom Qwen3.8-27B-MLX-4bit. L’agent de codage Pi dispose de son propre site à pi.dev, avec une documentation associée disponible à pi.dev/docs/latest.

Lectures complémentaires

• Création d’interfaces d’agents IA à plusieurs étapes avec Next.js et l’AI SDK — Apprenez comment concevoir une interface d’agent IA prête pour la production en utilisant des outils typés, des boucles à plusieurs étapes et des composants UI génératifs en flux dans Next.js.

ReAct expliqué : comment les agents IA combinent le raisonnement avec des actions dans le monde réel — Découvrez comment le framework ReAct associe raisonnement et utilisation d’outils pour donner de l’efficacité aux agents IA, ainsi ses différences par rapport aux modèles Chain-of-Thought, RL et de raisonnement.