Category: Notes

  • Strata – une IA puissante sur votre ordinateur

    Strata est un moteur open source permettant d’exécuter de grands modèles de langage sur du matériel standard. Le projet a un objectif simple : faire fonctionner le modèle puissant localement, sans cloud, sans compte et sans payer de tokens. L’installation est réduite à un seul installateur et après le lancement, vous pouvez discuter, travailler avec du code et même recevoir des images sur votre ordinateur.

    Sous le capot, Strata possède son propre moteur d’inférence et, à l’extérieur, il expose une API compatible avec OpenAI et Anthropic à une adresse locale. Cela signifie que vous pouvez y connecter vos outils préférés – Claude Code, Codex CLI, OpenCode et autres agents – et ils penseront qu’ils parlent au fournisseur de cloud. Les données ne quittent pas votre machine.

    Dans cet article, je vais expliquer ce que Strata peut faire, quels modèles sont pris en charge, comment l’installer et comment le connecter à vos instruments.

    Qu’est-ce que c’est

    Strata est un projet gratuit sous licence MIT. Cela résout trois problèmes :

    • Lancement local des modèles. Le moteur est conçu pour les cartes vidéo grand public et la mémoire combinée, et non pour les accélérateurs de serveur.
    • Interface unique. En externe, il s’agit d’une API compatible OpenAI et Anthropic sur localhost, donc presque tout ce qui peut fonctionner avec ces protocoles peut être connecté.
    • Simplicité. L’application de bureau et l’installateur du terminal suppriment le travail avec les dépendances, les pilotes et l’assemblage des sources.

    Par ailleurs, il convient de noter la saisie facultative d’images. Le modèle peut fonctionner non seulement avec du texte, mais également avec des images, ce qui rend le chat local beaucoup plus utile pour analyser des captures d’écran et des documents.

    Modèles

    La principale recommandation du projet est Qwen3.8-Flash-Next. Plusieurs ensembles de quantification sont proposés par différents fournisseurs :

    • ISTA-DASLab – option recommandée : Q2_0, IQ2_XS, IQ3_XXS, IQ3_S et pour le code, un codeur séparé IQ1_M.
    • Unsloth – UD-IQ4_XS, UD-Q4_K_XL, UD-Q5_K_XL, UD-Q6_K_XL, Q8_0.
    • Gyro d’agentionai – Gyro-S et Gyro-M : moins de mémoire, mais plus lent.

    En plus du modèle phare, Qwen3.6-35B-A3B et DeepSeekV4.1-Flash-1017 sont pris en charge. Ce dernier est intéressant car les parties du modèle qui ne rentrent pas dans la mémoire sont lues directement depuis le SSD, cela nécessite donc beaucoup d’espace disque libre. Il existe des options pour 239, 257 et 274 Go, ainsi qu’une version légère de Coder d’environ 191 Go, où la moitié des experts ont été supprimés.

    Le lancement de DeepSeek depuis le terminal ressemble à ceci :

    strata launch --family deepseek41 --model ist-das-2.00bpw --plan
    

    L’indicateur –plan affiche le plan de démarrage avant le début du téléchargement. Pour les grands ensembles, cela est utile : vous pouvez immédiatement voir la quantité de mémoire et de disque qui seront nécessaires.

    Exigences matérielles

    Strata prend en charge une large gamme d’équipements :

    • NVIDIA GeForce RTX séries 20, 30, 40 et 50.
    • AMD Radeon RX 7700, 7800, 7900, RX 9060, 9070 et AI PRO R9700.
    • AMD Radeon RX 6800 et 6900 – expérimental.
    • Intel Arc pour Linux.
    • Apple Silicon à partir de M1 et versions ultérieures.
    • AMD Ryzen AI Max (Strix Halo).
    • NVIDIA DGX Spark pour Linux.

    Pour référence, voici quelques mesures de DeepSeekV4.1-Flash sur un ensemble de 2,00 bpw. Dans la colonne “sortie” – la vitesse de génération de la réponse, dans la colonne “invite” – la vitesse de lecture de votre entrée.

    • RTX 5070 12 Go, 64 Go de RAM – 4 à 6 jetons/s, invite environ 110 jetons/s.
    • RTX 3060 12 Go, 46 Go de RAM – 9 à 11 jetons/s, invite environ 155 jetons/s.
    • 1 x Radeon AI PRO R9700, 251 Go de RAM – 21 à 25 jetons/s, invite 320 à 360 jetons/s.
    • 4 x Radeon AI PRO R9700 – 74 à 77 jetons/s, invite 400 à 450 jetons/s.
    • Ryzen AI Max+ 395 (Strix Halo), 128 Go de mémoire combinée – 19 à 21 jetons/s sur le code et 11 sur le chat.

    Si vous n’êtes pas sûr de ce qui conviendra, le projet propose un guide distinct pour choisir un modèle en fonction de la quantité de mémoire.

    Installer une application de bureau

    Le moyen le plus simple consiste à télécharger le programme d’installation prêt à l’emploi à partir de la page des versions. Chaque système possède son propre fichier :

    Strata-0.2.13-windows-x64-setup.exe
    Strata-0.2.13-linux-x86_64.AppImage
    Strata-0.2.13-macos-arm64.dmg
    

    Installez l’application, sélectionnez un modèle et commencez à communiquer. Lorsque vous lancez l’application pour la première fois, elle télécharge automatiquement le moteur de votre carte vidéo. Il n’est pas nécessaire de configurer séparément les pilotes ou de compiler quoi que ce soit à partir des sources.

    Dans la fenêtre de l’application, le chat, les fichiers et l’aperçu du code en direct sont situés à proximité, ce qui est pratique lorsque vous travaillez sur un projet.

    Installation dans le terminal

    Si vous préférez la console, installez Strata avec le script d’installation, puis exécutez la commande de lancement de strata.

    Sous Linux et macOS :

    curl -fsSL https://github.com/Niko1221/Strata/releases/latest/download/install.sh -o install.sh && sh install.sh
    

    Sous Windows PowerShell :

    irm https://github.com/Niko1221/Strata/releases/latest/download/install.ps1 | iex
    

    Une fois installé sous Windows, ouvrez une nouvelle fenêtre de terminal et exécutez :

    strata launch
    

    Le programme posera des questions, téléchargera le modèle souhaité et le lancera. Pendant le fonctionnement, l’activité, la vitesse, la consommation de mémoire et les dernières requêtes du modèle sont affichées – ce qui est pratique pour comprendre ce qui se passe avec le matériel.

    Pour ceux qui souhaitent tout construire eux-mêmes, il existe une version à partir des sources, une option via Docker et un guide d’installation détaillé.

    Connexion des instruments

    La principale force de Strata est qu’elle expose une API locale compatible avec OpenAI et Anthropic. Grâce à cela, des outils d’agent populaires y sont connectés : Claude Code, Codex CLI, OpenCode, oh-my-pi, pi.dev, Hermes Agent, OpenClaw et autres.

    Pour savoir comment configurer un outil spécifique, il suffit de lancer :

    strata connect
    

    L’équipe vous montrera des instructions prêtes à l’emploi pour votre candidature. Ensuite, tout est comme avec un fournisseur de cloud classique : le point de terminaison local Strata est spécifié comme adresse de base et ce que le moteur produit est spécifié comme clé. Aucun Internet n’est requis pour l’inférence.

    À quoi faire attention

    Fonctionner localement est un compromis, et il vaut la peine d’en être conscient à l’avance.

    • La vitesse dépend du matériel. Sur les cartes vidéo faibles, les grands modèles répondront lentement, surtout si une partie des poids est lue à partir du disque. Les mesures ci-dessus donnent une idée approximative.
    • Les modèles sont encore volumineux. Le disque et la mémoire sont les principaux limitateurs. DeepSeek nécessite des centaines de gigaoctets d’espace libre.
    • Qualité de quantification. Les ensembles hautement compressés économisent de la mémoire, mais peuvent perdre en qualité. Si votre matériel le permet, prenez l’option avec un bpw plus élevé.
    • Téléchargement initial. Au premier lancement, les poids du moteur et du modèle sont téléchargés. Vous avez donc besoin d’une connexion et d’un espace disque stables.

    En même temps, vous bénéficiez d’un contrôle total : pas de limites, d’abonnements ou de fuites de données. Tout compte sur votre machine.

    À qui est-ce destiné ?

    Strata est logique si vous souhaitez conserver vos données professionnelles locales, ne comptez pas sur des forfaits cloud ou si vous aimez simplement expérimenter l’IA locale. Pour un programmeur, c’est aussi un moyen de connecter un agent familier à un modèle qui travaille à proximité, sans délais de réseau et sans payer pour chaque requête.

    Le projet se développe activement : des dizaines de milliers d’étoiles, des milliers de forks, des versions fréquentes et une documentation détaillée pour chaque type de matériel. Le moyen le plus simple de commencer est d’utiliser l’application de bureau, puis, si vous l’aimez, d’accéder au terminal et de connecter vos outils.

    Liens

    https://github.com/niko1221/strata
    https://github.com/Niko1221/Strata/releases/latest
    https://github.com/Niko1221/Strata/blob/main/docs/INSTALL.md
    https://github.com/Niko1221/Strata/blob/main/docs/MODELS.md
    https://github.com/Niko1221/Strata/blob/main/docs/TERMINAL_LAUNCH.md
    https://github.com/Niko1221/Strata/blob/main/docs/DEEPSEEK41.md
    https://github.com/Niko1221/Strata/blob/main/docs/HOW_IT_WORKS.md
    https://github.com/Niko1221/Strata/blob/main/docs/TROUBLESHOOTING.md

    Sources

    https://github.com/niko1221/strata
    https://github.com/Niko1221/Strata/blob/main/README.md
    https://github.com/Niko1221/Strata/blob/main/docs/INSTALL.md
    https://github.com/Niko1221/Strata/blob/main/docs/MODELS.md
    https://github.com/Niko1221/Strata/blob/main/docs/DEEPSEEK41.md
    https://github.com/Niko1221/Strata/blob/main/docs/AMD_HIP.md
    https://github.com/Niko1221/Strata/blob/main/docs/STRIX_HALO.md

  • REA et OpenCode : installation et première enquête

    REA (Reverse Engineer Anything) est un serveur MCP qui vous permet de procéder à l’ingénierie inverse des applications logicielles, des binaires et des comportements en temps réel. L’outil couvre le chemin allant du comportement de l’application au code machine, et il est pratique d’utiliser OpenCode comme agent qui le gère.

    OpenCode est un agent de programmation ouvert qui réside dans le terminal. Il lit les fichiers de projet, édite le code, exécute des commandes et des tests et, plus important encore, il prend en charge MCP dès le départ, donc REA s’y connecte directement.

    Ce qui rend REA unique

    REA se démarque dans le domaine de l’ingénierie inverse avec un support complet de plusieurs plateformes et types d’analyses :

    • Binaires natifs : Hopper, Ghidra, IDA ou Kuna pour le démontage et la décompilation
    • Applications JavaScript et Electron : analyse statique des modules Electron, importations et limites
    • Code managé : analyse des assemblys .NET
    • Analyse en temps réel : surveillance du comportement des processus
    • Trafic réseau : capture et analyse des requêtes et réponses HTTP/S
    • Applications mobiles : analyse des fichiers APK et IPA pour Android et iOS
    • Logiciel embarqué : analyse des systèmes embarqués et des appareils IoT
    • Fichiers modèles : extraction des métadonnées GGUF et safetensors
    • Objets de code GPU : analyse des noyaux CUDA et HIP
    • Sauvegarde de jeux : restauration de la logique du jeu et des fichiers exécutables

    Architecture de base et philosophie

    REA suit un processus de recherche en trois étapes qui rend la rétro-ingénierie accessible aux développeurs :

    1. Inspection : REA se connecte aux outils d’analyse et examine les cibles (binaires, applications, sites Web)
    2. Analyse : trace à travers le code, déterminant les règles et les comportements
    3. Récupération : l’agent utilise les résultats pour expliquer le comportement et créer ou tester une implémentation

    Ce processus permet à l’agent IA de répondre à des questions complexes, telles que : « Comprendre le fonctionnement de la recherche dans l’application Notes, me montrer les preuves et créer une fonctionnalité similaire pour mon projet. »

    Exemples pratiques d’utilisation

    1. Analyse des applications mobiles

    REA peut analyser les fichiers APK Android pour la récupération :

    • déclarations et autorisations dans le manifeste ;
    • Méthodes de classe et dépendances ;
    • liens vers des bibliothèques natives ;
    • Points de terminaison du réseau et flux de données.

    Par exemple, une analyse d’Aegis Authenticator a montré comment les codes d’autorisation à six chiffres changent toutes les 30 secondes : elle a examiné le fonctionnement de la génération de code basée sur le temps (TOTP).

    2. Extraction de fonctions d’application de bureau

    L’analyse du bouton % dans la calculatrice Windows démontre les capacités de REA :

    • définir un comportement différent selon le contexte (après + ou ×) ;
    • analyser les instructions d’assemblage pour comprendre la logique ;
    • extraire et expliquer des opérations mathématiques ;
    • rétablir les règles : “Après + : 10 % du premier nombre” et “Après × : convertir 10 % en 0,1.”

    3. Restauration de l’API de l’application Web

    REA peut enregistrer une session de navigateur et la reconstruire sous la forme d’un environnement RL dans lequel l’agent IA effectue des tâches telles que travailler avec des dossiers sans exécuter l’application d’origine.

    4. Restaurer la logique du jeu

    Le cas DX-Ball a montré comment REA a restauré le calcul du paysage sonore du jeu Windows de 1996 en procédant à une ingénierie inverse du code C qui s’exécute sur 3 205 cas de test et correspond au code compilé d’origine.

    Capacités techniques

    Analyse native

    • Fonctionne avec Hopper, Ghidra, IDA ou Kuna pour une analyse approfondie des fichiers binaires
    • Prend en charge ELF, PE, Mach-O et d’autres formats de fichiers exécutables
    • Extrait le pseudocode, l’assembleur, les symboles et les appels
    • Effectue une analyse hors ligne sans avoir à lancer les outils d’origine

    Analyse JavaScript

    • Analyse les applications Node.js et Electron
    • Suivre les importations et les dépendances du module
    • Capture le comportement en temps réel via une connexion à un navigateur
    • Извлекает source maps и минифицированный код

    Sécurité

    • Analyse statique des certificats PE (Authenticode)
    • Analyse des mécanismes de défense (PIE, NX, RELRO, CFG)
    • Mappage des importations et des DLL
    • Analyse des rapports d’erreur (Apple IPS)

    Que renvoie REA

    REA ne donne pas à l’agent des conclusions toutes faites sans raison. Le résultat de chaque requête correspond aux conclusions ainsi qu’aux preuves sur lesquelles elles sont fondées. Selon la finalité, la réponse comprend :

    • Liens vers le code – fichiers et lignes spécifiques où la fonction étudiée est implémentée.
    • Pseudocode et assembleur – pour les binaires natifs : fonctions décompilées, instructions et connexions entre les appels.
    • Structure de l’application – pour JavaScript et Electron : modules, importations, routes, IPC et connexions avec des modules complémentaires natifs.
    • Métadonnées et faits : manifestes, certificats, signatures, en-têtes de format et autres données statiques.
    • Restrictions : lieux qui n’ont pas pu être identifiés, avec une note sur ce qui reste exactement inconnu.

    L’agent utilise ces données pour expliquer son comportement, répondre à des questions de clarification ou assembler et tester sa mise en œuvre. C’est la présence de preuves et de limites explicites qui distingue un résultat REA d’une simple estimation du modèle.

    Avant de commencer

    On suppose qu’OpenCode est déjà installé et que le modèle y est connecté. Node.js 22.23.4+, 24.22.1+ ou 26.12.1+ est nécessaire à REA lui-même, alors vérifiez la version :

    node -v
    

    Étape 1 : Connecter REA à OpenCode

    REA s’enregistre auprès d’OpenCode en tant que serveur MCP. Exécuter dans le terminal :

    npx rea-agents@latest setup
    

    Pour spécifier directement OpenCode, utilisez son identifiant opencode :

    npx rea-agents@latest setup --client opencode
    

    Que fait la configuration :

    • enregistre REA en tant que serveur MCP ;
    • ajoute des instructions de workflow ;
    • fait une copie de sauvegarde de la configuration existante ;
    • demande une confirmation avant d’appliquer les modifications.

    Point important :
    Pour la première expérience, vous pouvez ignorer l’installation facultative de Hopper. Une fois la configuration terminée, redémarrez OpenCode : quittez la session et exécutez à nouveau opencode.

    Vérifiez la connexion :

    npx -y rea-agents@latest doctor --client opencode --json
    

    Résultat réussi : "healthy": true.

    Demandez ensuite à l’agent :

    « Vérifiez que REA est connecté et montrez-moi quels outils REA vous pouvez utiliser. »

    Étape 2 : Première enquête

    REA peut analyser les applications sans les lancer.

    1. Téléchargez l’exemple :
      Download https://rea.tools/examples/notes-example.zip
      

      Décompressez l’archive dans le dossier notes-example.

    2. Donner une tâche à l’agent :

      “Utilisez REA pour inspecter l’application sur /absolute/path/to/notes-example. Découvrez ce qui se passe lorsque je clique sur Exporter les notes. Montrez où notes.csv est écrit, quels champs il contient, ainsi que les fichiers et lignes pertinents. “

    Réponse attendue :

    “Le bouton envoie un message notes:export. Le processus principal formate les notes au format CSV et écrit notes.csv dans le dossier Téléchargements de l’utilisateur. Les colonnes sont id et title.”

    Étape 3 : installation de Ghidra et analyse native

    Pour analyser les binaires natifs (exécutables et bibliothèques), REA utilise un fournisseur d’analyse. L’option gratuite la plus abordable est Ghidra de la NSA. L’outil est installé une fois sur l’ordinateur sur lequel REA s’exécute.

    Ce dont vous avez besoin

    • JDK 21 64 bits ou version ultérieure, y compris le compilateur Java (javac).
    • Archive Ghidra de la page des versions.

    Installation

    1. Installez le JDK 21 64 bits ou une version ultérieure. Sélectionnez un package pour votre architecture informatique.
    2. Téléchargez Ghidra depuis la liste des ressources sur la page des versions et décompressez l’archive ghidra_…_PUBLIC_….zip. Prenez l’archive de la version, pas le “Code source”.
    3. Recherchez le dossier décompressé qui contient ghidraRun ou ghidraRun.bat. Ce chemin sera nécessaire pour la variable GHIDRA_INSTALL_DIR.

    Découvrez Java. La première commande imprime java.home – ce chemin est nécessaire pour JAVA_HOME. La seconde confirme que le compilateur est installé :

    java -XshowSettings:properties -version
    javac -version
    

    Connexion Ghidra

    Windows (PowerShell) :

    $env:GHIDRA_INSTALL_DIR = "C:/tools/ghidra_12.1.4_PUBLIC"
    $env:JAVA_HOME = "C:/tools/jdk-21"
    npx -y rea-agents@latest doctor --provider ghidra --json
    npx -y rea-agents@latest setup
    

    macOS/Linux :

    export GHIDRA_INSTALL_DIR="/absolute/path/to/ghidra_12.1.4_PUBLIC"
    export JAVA_HOME="/absolute/path/to/jdk-21"
    npx -y rea-agents@latest doctor --provider ghidra --json
    npx -y rea-agents@latest setup
    

    Remplacez les chemins par les vôtres. Conservez les commandes dans une seule session de terminal : après avoir défini les variables d’environnement, réexécutez l’installation, confirmez la mise à jour de la configuration et redémarrez OpenCode.

    La vérification du fournisseur devrait renvoyer un rapport réussi :

    npx -y rea-agents@latest doctor --provider ghidra --json
    

    Exemple d’analyse native

    Donnez à l’agent le chemin complet du fichier exécutable et spécifiez le fournisseur :

    “Utilisez REA avec un fournisseur configuré pour explorer /absolute/path/to/program. Répertoriez les fonctions et les lignes, puis expliquez la partie qui gère les entrées de l’utilisateur, avec des références au code.”

    Ou exécutez la commande directement depuis le terminal :

    npx -y rea-agents@latest function "/absolute/path/to/program" main --provider ghidra --json
    

    Remplacez main par le nom ou l’adresse de la fonction de la liste des fonctions du programme cible. Le résultat contient du pseudocode, un assembleur et des références entre les appels.

    Analyse d’un autre type de logiciel

    Sélectionnez la catégorie de logiciel cible :

    • JavaScript/Electron – nécessite Node.js et npm. Guide.
    • Sites Web : nécessite le navigateur Chrome, Chromium ou Edge. Guide.
    • APK Android – nécessite JADX et JDK 17+. Manuel.
    • Exécutables natifs – nécessite Hopper, Ghidra ou IDA. Guide.
    • Assemblages .NET : nécessite Node.js et npm. Manuel.

    Utiliser REA depuis le terminal

    Analyse statique de l’application JavaScript/Electron

    npx -y rea-agents@latest analyze-javascript-application "/absolute/path/to/app" --json
    

    Remplacez le chemin par le dossier contenant l’application ou le fichier .asar.

    Où trouver le fichier .asar de l’application Electron :

    • Windows: C:\Users\<you>\AppData\Local\Programs\<App>\resources\app.asar
    • macOS: /Applications/<App>.app/Contents/Resources/app.asar
    • Linux: /opt/<App>/resources/app.asar

    Installation globale de la commande rea

    npm install --global rea-agents
    

    Après cela, la commande rea --help est disponible.

    Installation via curl (macOS / Linux)

    curl -fsSL https://raw.githubusercontent.com/morluto/rea/main/install.sh | bash
    

    Après l’installation, suivez les instructions pour configurer l’agent. Si le menu de configuration n’apparaît pas, exécutez rea setup.

    Mettre à jour et supprimer

    Mise à jour REA

    npx rea-agents@latest setup
    

    Pour une installation globale : rea update

    Suppression de REA

    npx rea-agents@latest uninstall
    

    Obtenir de l’aide

    Problèmes typiques

    OpenCode ne voit pas REA

    Redémarrez OpenCode après l’installation. Utilisez la commande doctor pour tester la connexion :

    npx -y rea-agents@latest doctor --client opencode --json
    

    Le fournisseur nécessite une configuration

    Pour la course Ghidra :

    npx -y rea-agents@latest doctor --provider ghidra --json
    

    Le rapport affichera le test ayant échoué et la prochaine étape suggérée.

    Windows, WSL et chemins avec espaces

    • Utiliser PowerShell pour les clients Windows
    • Si l’agent s’exécute dans WSL, installez Node.js et REA dans ce système Linux et utilisez les chemins Linux
    • Dans le terminal, placez les chemins avec des espaces entre guillemets

    Configurer Hopper sur macOS

    Si macOS vous demande d’autoriser l’automatisation, autorisez l’application qui exécute REA dans les Préférences Système : Préférences Système → Confidentialité et sécurité → Automatisation, puis réessayez.

    Liens

    https://github.com/morluto/rea
    https://rea.tools/
    https://rea.tools/get-started/
    https://rea.tools/guides/
    https://opencode.ai/
    https://opencode.ai/docs/
    https://opencode.ai/docs/mcp-servers/

  • Chaînes DemensDeum Telegram : logiciels, jeux et vibecoding

    Le blog et le site Internet ne sont pas les seuls endroits où sont publiées des notes et des actualités. La plupart des documents apparaissent immédiatement dans Telegram : il est plus pratique de recevoir des notifications sur les nouvelles publications, versions et flux, et vous pouvez également poser une question directement dans le chat. Le projet compte désormais trois sites, et chacun a son propre rôle. Dans cette note, je vais vous dire brièvement ce qui est publié, où et où vous devez vous abonner.

    DemensDeum – Logiciels et jeux

    Il s’agit de la principale chaîne en langue russe. Voici les annonces de nouveaux articles de blog et de sorties de programmes : générateurs locaux d’images, de vidéos et de musique, outils pour travailler avec la vidéo et la musique, applications dans Flutter et React Native, ainsi que des nouvelles de jeux comme Donki Hills et Flame Steel. Si vous lisez un blog en russe et que vous ne souhaitez pas consulter le site manuellement, c’est le moyen le plus simple de vous assurer de ne rien manquer.

    https://t.me/demensdeum_channel

    DemensDeum – Logiciels et jeux

    Il s’agit de la version anglaise de la chaîne principale. Les mêmes annonces sont reproduites ici, mais avec des traductions des articles et des descriptions en anglais. La chaîne sera utile à ceux qui sont plus à l’aise pour lire en anglais, ainsi qu’à ceux qui souhaitent partager du matériel avec un public anglophone : chaque entrée a un lien vers la version anglaise correspondante du message.

    https://t.me/demensdeum_channel_en

    Chat Vibecodage

    Une plateforme distincte pour discuter du développement utilisant l’IA. Ici, vous pouvez poser des questions sur les modèles et les agents locaux, partager votre expérience avec OpenCode, Claude Code, DeepSeek et d’autres outils, discuter des paramètres, des invites et des pièges du vibecoding. Il ne s’agit pas d’un canal d’annonces, mais d’un chat : communication, questions et échange de résultats.

    https://t.me/justvibecode

    Que choisir

    Si vous n’avez besoin que d’actualités et de communiqués en russe, la chaîne principale suffit. Si vous lisez en anglais ou dirigez un projet en anglais, abonnez-vous à la version en anglais. Si vous êtes intéressé par une discussion en direct sur le développement de l’IA, et pas seulement par des annonces, rendez-vous sur le chat des codeurs de vibrations. Les chaînes ne se dupliquent pas complètement, l’expérience la plus complète est donc la chaîne principale plus le chat.

    Liens

    https://t.me/demensdeum_channel
    https://t.me/demensdeum_channel_en
    https://t.me/justvibecode
    https://demensdeum.com/

  • MCP en OpenCode sur DeepSeek : comment connecter des outils externes

    MCP (Model Context Protocol) est un protocole ouvert qui décrit comment connecter des outils et des sources de données externes au modèle de langage : un système de fichiers, une documentation, un suivi des tâches, un suivi des bogues ou votre propre service. Au lieu d’intégrer chaque outil dans l’agent, vous configurez un serveur MCP distinct et l’agent communique avec lui selon le schéma standard.

    OpenCode prend en charge MCP dès le départ : à la fois les serveurs locaux, qui sont lancés par un processus enfant, et les serveurs distants, accessibles via HTTP. Un point important est que l’ensemble de la couche MCP est implémentée du côté d’OpenCode lui-même, et non du côté du fournisseur de modèles. Par conséquent, DeepSeek reçoit les outils MCP comme fonctions normales dans la requête et n’a pas besoin de connaître quoi que ce soit sur le protocole lui-même.

    Dans cet article, je vais voir comment ajouter un serveur local et distant, comment obtenir une autorisation, comment ne pas se noyer sous les jetons et ce qu’il faut prendre en compte lorsque l’on travaille avec des modèles DeepSeek.

    Ce dont vous avez besoin

    Pour travailler, vous avez besoin de trois choses :

    • OpenCode installé. Si l’agent n’est pas encore configuré, j’ai discuté de la procédure d’installation et de connexion de DeepSeek dans une note séparée.
    • Node.js et npx. Nécessaire pour les serveurs MCP locaux, qui sont distribués sous forme de packages npm.
    • Clés d’accès. Uniquement pour les serveurs distants qui nécessitent une autorisation. Les serveurs publics comme Context7 fonctionnent sans clé, mais avec des limites inférieures.

    Comment ça marche

    Les serveurs sont décrits dans la configuration OpenCode dans le bloc mcp. Chaque serveur possède un nom unique sous lequel il peut être mentionné dans une requête. Les outils serveur sont enregistrés avec ce préfixe de nom, il n’y a donc aucun conflit entre les différents serveurs.

    Après la connexion, les outils MCP deviennent disponibles pour les modèles avec ceux intégrés : lecture de fichiers, édition de code et exécution de commandes. Du point de vue de DeepSeek, il s’agit de fonctions ordinaires qu’un agent peut appeler – c’est pourquoi le bundle fonctionne sans aucune prise en charge MCP du côté de l’API du modèle.

    Serveur local

    Le moyen le plus simple de se familiariser avec le mécanisme est d’utiliser le serveur de test @modelcontextprotocol/server-everything. Ajoutons-le au fichier opencode.json à la racine du projet :

    {
      "$schema": "https://opencode.ai/config.json",
      "mcp": {
        "mcp_everything": {
          "type": "local",
          "command": ["npx", "-y", "@modelcontextprotocol/server-everything"]
        }
      }
    }
    

    Le champ commande est la commande de démarrage du serveur et ses arguments sous forme de tableau. Après avoir redémarré OpenCode, les outils apparaîtront dans la session et pourront être demandés explicitement :

    используй инструмент mcp_everything, чтобы сложить 3 и 4
    

    Le serveur local possède plusieurs champs plus utiles. environment définit les variables d’environnement du processus, cwd – le répertoire de travail, timeout – le délai d’attente de la demande en millisecondes, et enabled vous permet de désactiver temporairement le serveur sans le supprimer de la configuration.

    Serveur distant

    Les serveurs distants sont plus pratiques : vous n’avez pas besoin d’exécuter quoi que ce soit localement et ils sont accessibles via une URL. Un bon exemple est Context7, qui recherche une documentation de bibliothèque à jour. Il se connecte sans clé :

    {
      "$schema": "https://opencode.ai/config.json",
      "mcp": {
        "context7": {
          "type": "remote",
          "url": "https://mcp.context7.com/mcp"
        }
      }
    }
    

    Si vous disposez d’un compte Context7 gratuit, la clé est d’augmenter les limites. Les en-têtes sont transmis via le bloc headers, et il est pratique de conserver la clé elle-même dans une variable d’environnement :

    {
      "$schema": "https://opencode.ai/config.json",
      "mcp": {
        "context7": {
          "type": "remote",
          "url": "https://mcp.context7.com/mcp",
          "headers": {
            "CONTEXT7_API_KEY": "{env:CONTEXT7_API_KEY}"
          }
        }
      }
    }
    

    La construction {env:NAME} remplace la valeur de la variable d’environnement lors du chargement de la configuration, afin que la clé ne finisse pas dans le référentiel. Avant de démarrer l’agent, la variable doit être exportée dans le terminal.

    Un autre serveur public utile est Grep de Vercel, recherchez des exemples de code sur GitHub :

    {
      "$schema": "https://opencode.ai/config.json",
      "mcp": {
        "gh_grep": {
          "type": "remote",
          "url": "https://mcp.grep.app"
        }
      }
    }
    

    Autorisation via OAuth

    Certains serveurs distants nécessitent OAuth. OpenCode peut réaliser lui-même ce scénario : il remarque la réponse 401, déclenche l’autorisation et enregistre les tokens. Pour Sentry, précisez simplement le serveur :

    {
      "$schema": "https://opencode.ai/config.json",
      "mcp": {
        "sentry": {
          "type": "remote",
          "url": "https://mcp.sentry.dev/mcp",
          "oauth": {}
        }
      }
    }
    

    Après cela, l’autorisation peut être démarrée manuellement – le navigateur s’ouvrira :

    opencode mcp auth sentry
    

    Les commandes de service sont également utiles dans le travail quotidien. La liste mcp opencode affiche les serveurs et l’état d’autorisation, la déconnexion opencode mcp supprime les jetons stockés et le débogage mcp opencode vérifie la connectivité réseau et la découverte OAuth pour un serveur spécifique. Les jetons sont stockés localement dans le fichier ~/.local/share/opencode/mcp-auth.json.

    Si le serveur n’utilise pas OAuth, mais une clé API standard, l’autorisation automatique doit être désactivée, sinon OpenCode essaiera de transmettre OAuth là où il n’est pas nécessaire :

    {
      "$schema": "https://opencode.ai/config.json",
      "mcp": {
        "my-api-key-server": {
          "type": "remote",
          "url": "https://mcp.example.com/mcp",
          "oauth": false,
          "headers": {
            "Authorization": "Bearer {env:MY_API_KEY}"
          }
        }
      }
    }
    

    Gestion des outils

    Les outils MCP consomment du contexte : chaque serveur ajoute des descriptions de ses fonctions à la requête. Par conséquent, il est préférable de garder les serveurs rarement utilisés éteints. Cela peut être fait globalement via le bloc tools :

    {
      "$schema": "https://opencode.ai/config.json",
      "mcp": {
        "my-mcp-foo": {
          "type": "local",
          "command": ["npx", "-y", "my-mcp-command-foo"]
        },
        "my-mcp-bar": {
          "type": "local",
          "command": ["npx", "-y", "my-mcp-command-bar"]
        }
      },
      "tools": {
        "my-mcp*": false
      }
    }
    

    Le modèle my-mcp* désactive tous les outils dont le nom commence par ce préfixe. S’il existe de nombreux serveurs, il est plus judicieux de les désactiver globalement et de les activer localement pour un agent spécifique :

    {
      "$schema": "https://opencode.ai/config.json",
      "mcp": {
        "my-mcp": {
          "type": "local",
          "command": ["npx", "-y", "my-mcp-command"],
          "enabled": true
        }
      },
      "tools": {
        "my-mcp*": false
      },
      "agent": {
        "my-agent": {
          "tools": {
            "my-mcp*": true
          }
        }
      }
    }
    

    Fonctionnalités DeepSeek

    La connexion avec DeepSeek fonctionne car les modèles prennent en charge les fonctions d’appel et les outils MCP correspondants ressemblent à des fonctions ordinaires. DeepSeek lui-même ne connecte pas les serveurs MCP et ne devrait pas le faire : la connexion est gérée par OpenCode.

    Ce à quoi vous devez faire attention :

    • Sélection d’un modèle. Pour les modifications de routine et petites, deepseek-flash est suffisant. Pour les tâches où vous devez garder beaucoup de contexte en tête et sélectionner soigneusement un outil, il est préférable de donner deepseek-v4-pro.
    • Taille du contexte. Les serveurs lourds comme GitHub MCP ajoutent beaucoup de jetons et, avec un grand projet, atteignent facilement la limite. Activez-les uniquement pendant la durée d’une tâche spécifique.
    • Les schémas d’outillage

    • Coût sont envoyés avec chaque requête. Ainsi, plus il y a de serveurs inclus, plus chaque itération est coûteuse. Vous payez directement le fournisseur, de sorte que les serveurs supplémentaires sont visibles sur votre facture.
    • Conseils pour l’agent. Il est plus sûr de ne pas se fier à l’ingéniosité du modèle, mais de nommer directement le serveur dans la requête ou d’écrire une règle dans AGENTS.md.

    Un exemple de règle pour AGENTS.md, afin que l’agent accède lui-même à la source requise :

    Когда нужно посмотреть документацию библиотеки, используй инструменты context7.
    

    Recette pratique

    Pour le travail quotidien, deux serveurs suffisent généralement : Context7 pour la documentation et un serveur restreint pour une tâche spécifique – par exemple, Sentry pour analyser les erreurs ou Grep pour rechercher des exemples de code. Il est préférable de garder le reste éteint et de l’allumer si nécessaire.

    Ma procédure est la suivante : j’ajoute le serveur à opencode.json, redémarre OpenCode, vérifie la liste via la opencode mcp list, puis pose une question test qui mentionne explicitement le serveur. Si l’outil n’est pas appelé, je regarde vers le débug opencode mcp et le délai d’attente – un serveur lent peut ne pas avoir le temps de répondre dans les 30 secondes imparties.

    À quoi faire attention

    Quelques points pratiques. Les serveurs MCP sont du code de confiance : le serveur local s’exécute sur votre machine avec vos droits et vous envoyez les données de requête au serveur distant. Par conséquent, l’installation de serveurs aléatoires à partir d’Internet doit être effectuée avec la même prudence que n’importe quelle CLI tierce.

    Conservez les clés et les jetons dans les variables d’environnement et ne vous engagez pas dans le référentiel. OpenCode stocke les jetons OAuth localement, mais sur une machine partagée, cela vaut également la peine d’être pris en compte : la déconnexion opencode mcp les supprime lorsque l’accès n’est plus nécessaire.

    Et encore une chose : n’allumez pas tout en même temps. MCP ajoute des outils au contexte, et le contexte est synonyme d’argent et de qualité de réponse. Deux ou trois serveurs vraiment nécessaires fonctionnent bien mieux que dix connectés au cas où.

    Liens

    https://opencode.ai/docs/mcp-servers/
    https://opencode.ai/docs/config/
    https://modelcontextprotocol.io/
    https://github.com/upstash/context7
    https://mcp.sentry.dev
    https://mcp.grep.app
    https://github.com/anomalyco/opencode

    Sources

    https://opencode.ai/docs/mcp-servers/
    https://modelcontextprotocol.io/
    https://api-docs.deepseek.com/
    https://api-docs.deepseek.com/quick_start/agent_integrations/opencode

  • DeepSeek Harness : installation, capacités et premier lancement

    DeepSeek Harness, ou dsh en abrégé, est un harnais d’agent IA open source de DeepSeek AI. Si le modèle répond aux questions, alors le harnais lui donne la main : lit et édite des fichiers, exécute des commandes, organise des sessions, montre la trajectoire d’exécution et se permet d’être étendu avec des plugins. Le projet est distribué sous licence MIT et est en préversion publique.

    L’idée principale de DeepSeek Harness est formulée comme « tout est un plugin » – littéralement « tout est un plugin ». L’ensemble du produit est construit sur cela : des adaptateurs de modèle, un registre d’outils, un journal de session, une interface et même le cycle d’agent lui-même. Il est basé sur le framework Cordis, donc un développeur peut non seulement ajouter une nouvelle commande, mais remplacer l’intégralité du comportement de l’agent sans bifurquer le noyau.

    Vous pouvez travailler avec dsh de plusieurs manières : via l’interface Web locale, via une application de bureau, depuis la ligne de commande en mode sans tête ou depuis le SDK Python. Vous trouverez ci-dessous l’installation, le premier lancement et un aperçu des fonctionnalités.

    Ce dont vous avez besoin

    L’interface Web et la CLI nécessitent Node.js. Le projet a des exigences strictes :

    • Node.js 22.19.0 ou version ultérieure dans la ligne 22.x.
    • Node.js 24.0.0 ou version ultérieure dans la ligne 24.x.
    • Node.js 23.x n’est pris en charge dans aucun patch : cette ligne n’est pas LTS et a déjà été abandonnée.

    En plus de Node.js, vous aurez besoin de la clé API DeepSeek. Il est créé dans votre compte personnel sur platform.deepseek.com. L’application de bureau n’a pas besoin de Node.js – l’environnement y est déjà packagé.

    Vous pouvez vérifier la version avec la commande :

    node -v
    

    Installation via npx

    Le moyen le plus rapide de connaître le projet est de ne rien installer globalement. Exécutez simplement :

    npx @deepseek-ai/dsh web
    

    La commande téléchargera le package @deepseek-ai/dsh depuis npm, configurera un serveur Web local et ouvrira l’interface dans le navigateur. Par défaut, il écoute l’adresse :

    Si vous n’avez pas besoin d’ouvrir le navigateur, par exemple sur une machine distante, ajoutez le flag –no-open :

    npx @deepseek-ai/dsh web --no-open
    

    Lorsqu’il est lancé via SSH, dsh imprime l’adresse mais ne tente pas d’ouvrir le navigateur : l’adresse locale appartient au client ou à l’éditeur SSH.

    Installation globale

    Si vous avez constamment besoin d’un outil, il est plus pratique de l’installer globalement. Le package fournit le binaire dsh :

    npm install -g @deepseek-ai/dsh
    dsh web
    

    Après cela, la commande dsh est disponible depuis n’importe quel répertoire. La mise à jour s’effectue de la manière habituelle :

    npm install -g @deepseek-ai/dsh@latest
    

    Application de bureau

    Pour ceux qui ne souhaitent pas détenir de terminal et Node.js, DeepSeek publie des versions de bureau. Ils sont disponibles sur la page de téléchargement officielle :

    • macOS – Apple Silicon, macOS 13 ou version ultérieure, format DMG.
    • Windows – Assemblage 64 bits, format EXE.

    L’application fonctionne avec les mêmes fichiers locaux, peut effectuer des tâches en arrière-plan et stocke les sessions de la même manière que la version Web. C’est une option pratique pour le travail quotidien, lorsque vous ne souhaitez pas élever le serveur manuellement à chaque fois.

    Construire à partir des sources

    Si vous avez besoin d’un contrôle total sur le code, vos propres correctifs ou le développement de plugins, le projet est collecté à partir du référentiel. Vous aurez besoin de pnpm et le référentiel corrige une version spécifique, vous devez donc d’abord activer Corepack :

    corepack enable
    git clone https://github.com/deepseek-ai/deepseek-harness.git
    cd deepseek-harness
    pnpm install
    pnpm run build
    pnpm dsh web
    

    La commande pnpm run build prépare les artefacts du package et du frontend, et pnpm dsh web exécute la version déjà construite sans reconstruction. Pour le développement, il existe un mode pnpm run dev:web : il construit, démarre le serveur et reconstruit les bundles clients lorsque les sources changent.

    Premier lancement

    Après avoir démarré l’interface web, la procédure est la suivante.

    Tout d’abord, ouvrez Paramètres → Modèles et saisissez la clé API DeepSeek. La clé est enregistrée dans le fichier $DSH_HOME/.credentials.yaml, et seul un lien vers celle-ci reste dans les paramètres. La page des paramètres reçoit une description déjà masquée du secret, il est donc impossible de relire la clé depuis l’interface. Les modifications du modèle sont appliquées à partir de la demande suivante ; il n’est pas nécessaire de redémarrer le serveur.

    Sélectionnez ensuite votre dossier de travail via Choisir un espace de travail. Tant que l’espace de travail n’est pas sélectionné, le champ de saisie de la tâche reste grisé. Ceci est fait intentionnellement : l’agent doit comprendre les limites dans lesquelles il est autorisé à lire et à modifier des fichiers.

    Après cela, vous pouvez soumettre la première tâche. Par exemple:

    Summarize this repository and identify its main packages.
    

    L’agent lira le projet, établira un plan, appellera les outils nécessaires et montrera le résultat. Pour les opérations qui nécessitent une confirmation basée sur la politique d’accès actuelle, dsh demandera avant de s’exécuter.

    Modèles et fournisseurs

    DeepSeek se connecte en une seule étape : la fiche du fournisseur dans les paramètres ne contient qu’un champ pour la clé API. De plus, vous pouvez ajouter des services tiers. Le répertoire intégré connaît des identifiants tels que anthropic, openai, moonshotai pour Kimi et zai pour GLM.

    Pour votre propre passerelle, proxy d’entreprise ou serveur local, il existe un mode API de modèle personnalisé. Il demande :

    • identifiant permanent du fournisseur ;
    • nom d’affichage ;
    • Adresse de base de l’API ;
    • protocole : achèvements de chat OpenAI, réponses OpenAI ou messages anthropiques ;
    • clé et liste des modèles.

    Le protocole est important : un fournisseur parle un protocole. Si une passerelle prend en charge à la fois OpenAI et Anthropic, elle devra être décrite par deux fournisseurs. Pour les modèles, vous pouvez spécifier la taille de la fenêtre contextuelle, le nombre maximum de jetons de sortie et les types de données d’entrée pris en charge, y compris les images.

    Les modèles DeepSeek ont ​​des niveaux de raisonnement off, faible, élevé et max. Le niveau est sélectionné dans le menu Effort à côté du modèle. Pour les tâches de routine dans le référentiel, un modèle rapide suffit, mais pour les tâches architecturales complexes, il est logique d’augmenter l’effort ou d’utiliser un modèle de classe supérieure.

    Plugins et mode Créateur

    Les plugins sont la principale fonctionnalité de DeepSeek Harness. Grâce à eux, des outils, des compétences, des éléments d’interface et des applications entières sont ajoutés. L’interface dispose d’un gestionnaire de plugins avec des ensembles officiels et expérimentaux : commandes d’agent, auto-confirmation, tâches planifiées, saisie vocale, terminal, sous-agents.

    Le mode Créateur se démarque séparément. Dans ce mode, vous pouvez demander à l’agent d’écrire un plugin directement dans le chat. Il téléchargera la compétence de développement du plugin Cordis, créera une structure de package, écrira du code, installera le plugin et vérifiera son statut. Il y a un exemple sur la page officielle du projet où une minuterie Pomodoro flottante est assemblée de cette manière.

    Les plugins peuvent également être installés à partir de la ligne de commande. Pour un profil Web, la commande ressemble à ceci :

    dsh plugin --profile web add some-dsh-plugin
    

    Les packages Npm, les liens comme github:owner/repo, les répertoires locaux et les archives tgz sont pris en charge. Après installation, il est utile de vérifier que la couche plugin est bien incluse dans la configuration :

    dsh --profile web --dump-config
    

    La commande imprime l’arborescence des plugins assemblée sans démarrer le serveur. S’il n’y a pas de nouvelle couche, le bundle n’a probablement pas déclaré de manifeste dsh.bundle et n’a pas été installé en tant que bibliothèque standard plutôt qu’en tant que plugin inclus.

    Les paramètres expérimentaux incluent les marchés de plugins personnalisés. Il s’agit d’un fichier d’index JSON avec une liste de plugins, leurs versions, icônes et sources. En activant l’ensemble, vous obtenez un onglet Découvrir sur la page des plugins et la possibilité de connecter des marchés tiers. Comme toute source tierce, un tel marché ne doit être ajouté que si vous faites confiance à ses auteurs.

    Trajectoire et audit

    Pour chaque session, dsh écrit un journal des événements en ajout uniquement – Trajectoire. Il stocke l’invite du système, le raisonnement, les appels d’outils et leurs résultats, la planification des sous-agents et les insertions de contexte. La reprise de session, les forks, la recherche et la relecture sont construits sur ce journal.

    L’avantage pratique est que la conversation cesse d’être une boîte noire. Dans l’interface, vous pouvez ouvrir la trajectoire et voir quels outils ont été appelés, combien de temps a duré chaque étape, quels fichiers ont été modifiés et combien de jetons ont été dépensés pour la demande. Si un agent s’est comporté de manière étrange, la raison est généralement visible ici, et non dans une courte réponse dans le chat.

    Les sessions se trouvent dans ~/.dsh/sessions sous la forme de logs JSONL. Vous pouvez les lire, les rechercher et créer vos propres analyses. Cela permet également de calculer avec précision les dépenses et les accès au cache qui ne sont pas visibles dans une facture API classique.

    Tâches et plannings en arrière-plan

    DeepSeek Harness peut fonctionner non seulement en mode « demander et recevoir une réponse ». Les tâches peuvent être lancées en arrière-plan et planifiées. Par exemple, demandez à l’agent de collecter un rapport hebdomadaire à partir des notes de projet tous les vendredis à 17h00. Dans l’interface, ces tâches sont visibles séparément : vous pouvez vérifier l’état, afficher l’historique et ouvrir les détails de l’exécution.

    Il existe un profil sans tête pour l’automatisation. Il démarre une session, imprime la réponse finale et quitte :

    dsh --profile headless "run the tests"
    

    Ce mode est pratique pour les CI, cron et les scripts pour lesquels une interface Web n’est pas nécessaire. En plus du headless, les profils sdk et acp sont disponibles : le premier sert les clients SDK via JSON-RPC, le second sert les clients d’automatisation via ACP stdio.

    Sous-agents, MCP et compétences

    Une tâche complexe peut être décomposée en sous-agents. L’agent principal planifie le travail et les sous-agents individuels travaillent sur leurs zones. Cela permet de garder le contexte compact et de ne pas faire glisser l’intégralité de l’historique dans chaque requête.

    Les outils externes et les sources de données sont connectés via MCP. La documentation comprend un guide distinct sur la mémoire MCP, ainsi que des intégrations telles que les sessions de révision GitHub. Les compétences décrivent des procédures reproductibles que l’agent charge selon les besoins, plutôt que de conserver en permanence toutes les instructions dans une invite système.

    Profils, bundles et correctifs

    La configuration dsh est assemblée à partir de trois couches. Bundle est un ensemble de lignes de configuration et de code de plugin, c’est-à-dire une fonctionnalité prête à l’emploi. Profil est une composition nommée de bundles, qui est stockée dans $DSH_HOME/profiles/. Patch est un fichier YAML qui modifie les lignes déjà chargées par identifiant, les désactive ou en ajoute de nouvelles.

    L’ordre d’application est le suivant : d’abord les bundles par ordre de profil, puis le patch de profil, puis le patch général $DSH_HOME/cordis.patch.yml et à la fin les overlays transmis via –patch. Cela signifie que presque tous les paramètres peuvent être remplacés sans toucher aux sources du bundle. Vous pouvez visualiser l’arborescence résultante avec la commande :

    dsh --profile web --dump-config
    

    Un profil Web standard est appelé web, un profil sans serveur est appelé headless. Leurs fichiers de paramètres se trouvent dans $DSH_HOME/profiles/web/cordis.patch.yml et $DSH_HOME/profiles/headless/cordis.patch.yml. C’est ici que dsh écrit les modifications apportées via l’interface des paramètres.

    SDK Python

    Il existe un SDK officiel pour les projets Python. Il est installé dans un environnement virtuel et apporte un runtime natif, de sorte que le système Node.js n’est pas nécessaire pour le travail normal :

    python -m venv .venv
    .venv\Scripts\Activate.ps1
    python -m pip install deepseek-harness-sdk
    

    Un exemple de démarrage minimal ressemble à ceci :

    from pathlib import Path
    
    from deepseek_harness import DeepSeekHarness
    
    workspace = Path("C:/work/disposable-workspace").resolve()
    dsh_home = Path("C:/work/example-dsh-home").resolve()
    
    with DeepSeekHarness(
        provider="deepseek-official",
        model="deepseek-v4-flash",
        max_tokens=49_152,
        cwd=str(workspace),
        dsh_home=str(dsh_home),
        profile="sdk-minimal",
    ) as harness:
        result = harness.run(
            "Inspect the repository and fix the failing tests.",
            session_id="example-001",
        )
    
    print(result.final_response)
    

    Le SDK démarre le processus dsh fourni avec le profil sdk-minimal et le réutilise avant de quitter le gestionnaire de contexte. Le profil minimal est intentionnellement limité : il comporte bash ou pwsh, une lecture d’images et un répertoire de travail, mais aucun outil Web, sous-agent ou certains outils de fichiers. Pour les tâches ponctuelles, c’est un plus : il y a moins de surface à contrôler.

    À quoi faire attention

    DeepSeek Harness est une aperçu pour les développeurs version 0.1.0-rc.x. Le README avertit explicitement que la compatibilité sera rompue. Pour les expériences, les projets personnels et l’automatisation, c’est très bien, mais pour un processus qui rapporte de l’argent en ce moment, cela vaut la peine de peser les risques et de conserver un plan de sauvegarde.

    Le deuxième point est Node.js. Si vous disposez de 22.18 ou 23.x, l’installation plantera ou se comportera de manière imprévisible. Vérifiez la version à l’avance : le projet utilise node:sqlite et l’effacement intégré de TypeScript des types nécessitant une nouvelle branche.

    Le troisième point concerne le bac à sable et les droits. Par défaut, l’agent fonctionne dans une politique proche de l’écriture de l’espace de travail : il peut modifier les fichiers du dossier sélectionné et les opérations potentiellement dangereuses nécessitent une confirmation. Le mode danger-accès complet donne plus de liberté, mais le risque devient plus élevé. Avant d’expérimenter avec un véritable référentiel, il est utile d’effectuer un commit ou une sauvegarde.

    Le quatrième point est le coût. DSH lui-même est gratuit, mais pour en déduire, vous payez le fournisseur en jetons. Pour les longues sessions, la mise en cache des préfixes est importante : dsh compose les requêtes de manière à ce que l’historique et les schémas des outils restent inchangés le plus longtemps possible. Si le score s’avère plus élevé que prévu, regardez non seulement le prix par token, mais également la part des cash hits dans la trajectoire.

    Est-ce que ça vaut la peine d’essayer

    DeepSeek Harness intéresse principalement ceux qui souhaitent non seulement « une autre conversation avec un modèle », mais également un environnement contrôlé pour les agents. Il y a une trajectoire transparente, un travail normal avec des fichiers et des commandes, des tâches en arrière-plan, des sous-agents et une expansion vraiment profonde via des plugins. La possibilité de remplacer une boucle d’agent par la vôtre est rare et potentiellement très utile pour la recherche et l’orchestration personnalisée.

    Si vous avez besoin d’un outil stable pour un travail rémunéré quotidien, il est désormais plus sage de traiter dsh comme un deuxième agent à côté du principal : essayez-le sur un projet personnel, comparez le coût et la qualité de vos tâches, et transférez-le ensuite seulement vers le workflow.

    Liens

    https://www.deepseek.com/harness/
    https://www.deepseek.com/download/
    https://github.com/deepseek-ai/deepseek-harness
    https://deepseek-harness.github.io/deepseek-harness/en/guide/quickstart
    https://deepseek-harness.github.io/deepseek-harness/en/guide/providers
    https://deepseek-harness.github.io/deepseek-harness/en/guide/python-sdk
    https://platform.deepseek.com/

    Sources

    https://github.com/deepseek-ai/deepseek-harness/blob/master/README.md
    https://github.com/deepseek-ai/deepseek-harness/blob/master/apps/cli/README.md
    https://deepseek-harness.github.io/deepseek-harness/en/guide/quickstart
    https://deepseek-harness.github.io/deepseek-harness/en/guide/providers
    https://deepseek-harness.github.io/deepseek-harness/en/guide/python-sdk
    https://deepseek-harness.github.io/deepseek-harness/en/guide/plugin-market
    https://dshdocs.com/getting-started/installation/
    https://dshdocs.com/concepts/profiles-bundles-patches/
    https://dshdocs.com/guides/dsh-vs-claude-code/

  • Modèles de solutions Jev dans Ollama : utilisation pratique /v1/systemone

    À partir de la version 0.35, Ollama prend en charge les modèles de décision basés sur l’API Jev de TypeSafe. Ce ne sont pas des modèles de chat au sens habituel du terme : ils n’écrivent pas de texte, mais répondent à un ensemble de questions tapées sur l’état transféré. Pour la classification, le routage, la modération et le tri, cela s’avère plus rapide et plus fiable que de demander à un LLM classique de renvoyer du JSON puis d’analyser sa réponse.

    Dans cet article, j’examinerai ce que sont les modèles de décision, comment ils fonctionnent au niveau HTTP, quels modèles sont déjà disponibles et comment les intégrer dans le code existant afin que les modèles génératifs réguliers continuent de fonctionner.

    En quoi les modèles de décision diffèrent-ils des modèles classiques

    Un LLM standard reçoit une invite et génère du texte jeton par jeton. Même si vous lui demandez de répondre en un mot, la génération se produit toujours à l’intérieur et le format de la réponse doit être contrôlé par un diagramme, des instructions et une vérification ultérieure. Le modèle de décision fonctionne différemment : vous transmettez l’état et les questions avec des types, et le modèle renvoie les probabilités et les options sélectionnées. Pas de texte libre, pas d’analyse JSON de la réponse.

    Le nouveau point de terminaison s’appelle /v1/systemone. Dans une seule demande, vous pouvez poser plusieurs questions à la fois et le modèle répondra à toutes. Ceci est pratique pour les tâches où vous devez prendre plusieurs décisions connexes : par exemple, déterminer l’équipe, la nécessité d’un retour et l’urgence du ticket.

    Quels modèles sont disponibles

    Vous pouvez désormais exécuter trois modèles de décision via Ollama :

    • nimble est un modèle ouvert avec 9 milliards de paramètres de Bespoke Labs. Il s’agit du plus grand et du plus précis disponible.
    • tev1 est un modèle expérimental avec 4 milliards de paramètres de Together AI.
    • tev1:0.8b est un modèle expérimental avec 0,8 milliard de paramètres de Together AI. Le plus rapide et le plus simple.

    Ils travaillent tous localement, ne nécessitent aucun paiement et n’envoient pas de données à un service externe. Ollama 0.35 et versions ultérieures sont pris en charge.

    Installation

    Vérifiez d’abord la version Ollama :

    ollama --version
    

    Téléchargez ensuite le modèle souhaité. Pour le plus simple :

    ollama pull tev1:0.8b
    

    Pour la version complète de tev1 :

    ollama pull tev1
    

    Pour les agiles :

    ollama pull nimble
    

    Le modèle agile occupe environ 9,5 Go d’espace disque, c’est donc une bonne idée de libérer de l’espace avant le téléchargement. tev1:0.8b occupe moins d’un gigaoctet.

    Première requête via curl

    L’exemple le plus simple consiste à déterminer si un texte est une offre d’emploi :

    curl http://localhost:11434/v1/systemone -d '{
      "model": "tev1:0.8b",
      "state": {
        "message": "Senior Swift developer, Berlin, remote friendly"
      },
      "questions": {
        "isJob": {
          "type": "noul",
          "instructions": "Does the message advertise a job posting that someone can apply to?"
        }
      }
    }'
    

    La réponse ressemble à ceci :

    {
      "model": "tev1:0.8b",
      "answers": {
        "isJob": {
          "type": "noul",
          "noul": 0.921
        }
      },
      "usage": {
        "input_tokens": 42,
        "output_tokens": 0
      }
    }
    

    Le champ nul est une probabilité de 0 à 1. La décision est prise par comparaison avec un seuil, généralement 0,5. Contrairement au modèle génératif, il n’est pas nécessaire de demander une réponse au format JSON puis de vérifier que le modèle ne l’a pas cassée.

    Types de questions

    Les modèles de décision prennent en charge trois types de questions.

    noul est une question binaire. Renvoie la probabilité qu’une affirmation soit vraie :

    {
      "questions": {
        "refund": {
          "type": "noul",
          "instructions": "Does the customer explicitly ask for a refund?"
        }
      }
    }
    

    choix – sélection d’une option dans un ensemble donné. Renvoie l’option sélectionnée, les probabilités de toutes les options et la confiance :

    {
      "questions": {
        "team": {
          "type": "choice",
          "instructions": "Which team should handle this ticket?",
          "criteria": {
            "billing": "Payments and refunds",
            "technical": "Bugs and integrations",
            "other": "None of the above"
          }
        }
      }
    }
    

    score – note sur une échelle. Renvoie le nombre, la légende et les probabilités pour chaque point d’échelle :

    {
      "questions": {
        "urgency": {
          "type": "score",
          "instructions": "How urgent is this ticket?",
          "criteria": ["Routine", "Soon", "Urgent"]
        }
      }
    }
    

    Une demande peut contenir plusieurs questions de types différents à la fois. C’est ce qui rend les modèles de décision pratiques pour le tri : une opération, un état, plusieurs décisions indépendantes.

    Python sans bibliothèques supplémentaires

    Pour les requêtes, l’urllib standard est suffisante ; un SDK distinct n’est pas requis :

    import json
    from urllib.request import Request, urlopen
    
    OLLAMA_DECISION_URL = "http://localhost:11434/v1/systemone"
    
    def ask_decision(state, questions, model="tev1:0.8b"):
        payload = {
            "model": model,
            "state": state,
            "questions": questions,
        }
        request = Request(
            OLLAMA_DECISION_URL,
            data=json.dumps(payload).encode(),
            headers={"Content-Type": "application/json"},
            method="POST",
        )
        with urlopen(request, timeout=3600) as response:
            return json.loads(response.read().decode())["answers"]
    

    Usage:

    answers = ask_decision(
        {"message": "Senior Swift developer, Berlin, remote friendly"},
        {
            "isJob": {
                "type": "noul",
                "instructions": "Does the message advertise a job posting that someone can apply to?"
            }
        },
    )
    
    probability = answers["isJob"]["noul"]
    is_job = probability >= 0.5
    

    Si vous avez besoin d’un SDK Python officiel, il s’appelle typesafe-sdk. Pour localhost, il peut être dirigé vers Ollama avec les variables d’environnement TYPESAFE_BASE_URL, TYPESAFE_API_KEY et TYPESAFE_DEFAULT_MODEL. Mais pour des tâches simples, une requête HTTP directe suffit.

    Comment comprendre qu’un modèle soutient la décision

    Les modèles de décision ne peuvent pas répondre via /api/generate ou /api/chat. Si vous envoyez une telle demande, Ollama renverra une erreur 400 avec un texte comme :

    "tev1:0.8b" does not support generate
    

    Ceci est important si vous disposez déjà d’un code qui fonctionne avec des modèles standards via /api/generate : si vous changez le modèle en modèle de décision, il cessera de fonctionner. Il est préférable de connaître à l’avance les capacités du modèle via /api/show et de choisir la méthode d’appel appropriée :

    import json
    from urllib.request import Request, urlopen
    
    OLLAMA_SHOW_URL = "http://localhost:11434/api/show"
    
    def supports_decision(model):
        request = Request(
            OLLAMA_SHOW_URL,
            data=json.dumps({"model": model}).encode(),
            headers={"Content-Type": "application/json"},
            method="POST",
        )
        try:
            with urlopen(request, timeout=30) as response:
                capabilities = json.loads(response.read().decode()).get("capabilities", [])
        except (OSError, TypeError, ValueError):
            return False
        return "decision" in capabilities
    

    Les modèles de décision n’auront que la décision dans leurs capacités. Les modèles réguliers auront des complétions, des outils ou d’autres fonctionnalités. Si Ollama n’est pas disponible, il est raisonnable de considérer le modèle comme normal et d’utiliser le chemin génératif.

    Comment intégrer dans du code existant

    Le plus simple n’est pas de réécrire le classificateur, mais de le diviser en deux stratégies. La stratégie générative fonctionne comme avant : elle collecte l’invite, l’envoie à /api/generate et analyse le JSON. La stratégie de décision envoie l’état et la question saisie à /v1/systemone et compare la probabilité avec un seuil.

    Le choix de la stratégie s’effectue en un seul endroit, lors de la création d’un classificateur :

    def create_classifier(model):
        if supports_decision(model):
            return DecisionClassifier(model)
        return GenerativeClassifier(model)
    

    Cette approche présente plusieurs avantages. Les modèles génératifs continuent de fonctionner sans changement. Le modèle de décision peut être activé en modifiant une variable d’environnement. Et toute la différence entre les deux méthodes est concentrée dans deux petites classes et n’est pas répartie dans toute l’application.

    Pour une classification binaire, la stratégie de décision ressemble à ceci :

    async def classify(text):
        answers = await ask_decision(
            {"message": text},
            {
                "isJob": {
                    "type": "noul",
                    "instructions": instructions,
                }
            },
            model,
        )
        probability = answers["isJob"]["noul"]
        return probability >= 0.5, probability
    

    Veuillez noter que le modèle de décision ne renvoie pas d’explication. Si votre format de résultat comporte un champ de raison, vous pouvez le construire à partir de la probabilité : par exemple, stockez la probabilité elle-même ou une chaîne telle que « le modèle a évalué le message à 0,935 comme poste vacant ». C’est plus honnête que d’inventer une raison que le modèle n’a pas donnée.

    Les instructions devraient être une question

    C’est la conclusion pratique la plus importante. Les modèles de décision ne comprennent pas les longues invites du style « vous classez les messages, répondez vrai si…, faux sinon ». Ils veulent une question courte et directe.

    Sur le même message concernant un poste vacant, j’ai reçu les probabilités suivantes :

    • Question directe : “Ce message est-il une offre d’emploi ?” — 0,921.
    • De longues instructions expliquant ce qui est considéré comme un poste vacant – 0,026.
    • Des instructions longues avec une question à la fin – 0,391.

    La différence est presque trente fois supérieure. Le modèle ne se trompe pas dans la classification, il ne comprend tout simplement pas ce qu’il en attend lorsque la question est cachée à l’intérieur d’un paragraphe. Par conséquent, pour les modèles de décision, il vaut la peine de conserver des instructions courtes séparées et de laisser de longues invites pour les modèles génératifs.

    Il est pratique de créer une variable d’environnement distincte :

    OLLAMA_JOB_CLASSIFIER_DECISION_INSTRUCTIONS=Does the message advertise a job posting that someone can apply to?
    

    Et utilisez une invite régulière uniquement pour le chemin génératif.

    Seuil et probabilités

    Le seuil de 0,5 convient comme valeur par défaut, mais il est utile de l’inclure dans la configuration. Pour différentes tâches, le coût d’une réponse faussement positive et faussement négative est différent. Pour la modération, il est plus sûr de relever le seuil ; pour rechercher des postes vacants, il est plus sûr de le baisser, afin de ne pas manquer de messages utiles.

    Il est également utile d’enregistrer la probabilité elle-même, et pas seulement le booléen résultant. Lorsque le classificateur fait une erreur, le journal indique s’il s’agit d’une réponse sûre ou d’une décision à la frontière. Pour les questions de choix, il vaut la peine de conserver les probabilités et la confiance : elles montrent à quel point le modèle fluctue entre les options.

    Performances et mémoire

    La vitesse dépend grandement de la taille du modèle et du matériel. Sur le CPU, lors de mes tests, j’ai obtenu les chiffres suivants :

    • tev1:0.8b – fractions de secondes à résoudre, s’intègre facilement dans la mémoire.
    • tev1 – 4B, nettement plus lent, mais toujours adapté aux tâches interactives.
    • agile – 9 B en Q8_0, environ 10 Go de mémoire. La première requête, y compris le chargement du modèle, a pris environ 137 secondes, les solutions suivantes ont pris entre 12 et 32 ​​secondes sur le processeur.

    Nimble nécessite beaucoup de RAM. Sur une machine avec 16 Go et Docker/WSL avec une limite d’environ 8 Go, le modèle ne rentre pas : le système commence à permuter et les conteneurs ne répondent plus. L’augmentation de la limite WSL à 12 Go via le fichier .wslconfig a aidé :

    [wsl2]
    memory=12GB
    swap=8GB
    

    Après le changement, vous avez besoin de wsl –shutdown et redémarrez Docker Desktop. Mais même avec 12 Go, la réserve reste faible : le modèle occupe environ 10 Go, et il ne reste plus grand chose pour le système.

    Par défaut, Ollama décharge le modèle après cinq minutes d’inactivité, libérant ainsi de la mémoire. C’est pratique : Nimble ne garde pas 10 Go occupés en permanence, mais chaque nouveau lancement après une pause recommence à charger le modèle.

    Quand utiliser des modèles de décision

    Les modèles de décision sont bien adaptés aux tâches pour lesquelles vous avez besoin d’une réponse rapide et peu coûteuse à une question clairement formulée :

    • Classification des messages, tickets et demandes.
    • Routage par commandes ou exécuteurs.
    • Modération du contenu et contrôles de sécurité.
    • Solutions binaires et multivariées rapides dans les applications de jeux ou interactives.

    Ils sont mal adaptés aux tâches où un texte détaillé est nécessaire : explication, extraction de champs, résumé, génération de réponses. Pour cela, les modèles génératifs habituels restent. Le meilleur résultat est obtenu lorsqu’il est combiné : un modèle de décision prend une décision et un modèle génératif l’explique ou extrait des données.

    Total

    Les modèles de décision dans Ollama sont un outil distinct et plus restreint que les LLM classiques. Ils ne remplacent pas les modèles génératifs, mais ils suppriment la partie routinière du travail : réponses saisies, probabilités au lieu de l’analyse de texte et format prévisible. Si vous disposez déjà d’un pipeline de classification, la transition se résume à vérifier les capacités du modèle, une stratégie d’appel distincte et de courtes questions pédagogiques.

    Sources
    https://ollama.com/blog/ollama-now-supports-jev-style-decision-models
    https://ollama.com/library/nimble
    https://ollama.com/library/tev1
    https://typesafe.ai

  • Modèles gratuits pour OpenCode via FreeLLMAPI

    OpenCode est un agent de programmation ouvert qui fonctionne dans le terminal : lit les fichiers de projet, édite le code, exécute des commandes et des tests, recherche dans le référentiel et fonctionne avec git. Il n’est pas lié à un seul fournisseur de modèles, donc presque tous les services compatibles OpenAI peuvent y être connectés.

    FreeLLMAPI est un routeur ouvert auto-hébergé qui collecte les plans gratuits de dizaines de fournisseurs d’IA sous une seule adresse /v1 compatible OpenAI. Au lieu de trente clés, trente limites et trente endroits où une requête peut échouer, vous disposez d’une passerelle locale et d’une clé unifiée. Le routeur sélectionne lui-même un modèle disponible, passe au suivant lorsque l’erreur 429 ou 5xx se produit et s’assure que les demandes ne dépassent pas les quotas des tarifs gratuits.

    Dans cet article, je décrirai l’installation de FreeLLMAPI, l’ajout de fournisseurs et la connexion de la passerelle à OpenCode.

    Ce dont vous avez besoin

    Pour travailler, vous avez besoin de quatre choses :

    • OpenCode installé. Si l’agent n’est pas encore installé, j’ai discuté de la procédure d’installation dans une note séparée sur OpenCode et DeepSeek.
    • FreeLLMAPI en cours d’exécution. Le moyen le plus simple consiste à installer une application de bureau ou un conteneur Docker.
    • Node.js 20.18 ou version ultérieure. Ceci est nécessaire pour le générateur CLI qui configure OpenCode. OpenCode lui-même peut être installé sans Node.
    • Clés d’au moins un fournisseur. Les forfaits gratuits de Google AI Studio, Groq, Cerebras, Mistral, OpenRouter, NVIDIA, HuggingFace et d’autres services du catalogue conviennent.

    Installation de FreeLLMAPI

    Le projet comporte plusieurs chemins d’installation. Choisissez celui qui convient le mieux à votre système.

    Application de bureau

    L’option la plus simple pour Windows et macOS est le programme d’installation prêt à l’emploi de la page des versions. Sous Windows, il s’agit de .exe, sur macOS, il s’agit de .dmg pour Apple Silicon ou Intel. L’application réside dans le bac et élève localement le routeur ainsi que le panneau de commande.

    Aucun mot de passe n’est nécessaire pour la version de bureau : le panneau se connecte tout seul via un compte local masqué. Les seules informations d’identification dont vous aurez besoin sont la clé unifiée de la fenêtre contextuelle de la barre d’état système ou de l’en-tête de la page Clés.

    Les données de l’application se trouvent dans un répertoire :

    • Windows — %APPDATA%\FreeLLMAPI\
    • macOS — ~/Library/Application Support/FreeLLMAPI/
    • Linux — ~/.config/FreeLLMAPI/

    Docker

    Si Docker est déjà installé, le serveur est lancé avec une seule commande. Le script crée le répertoire ~/freellmapi, génère une clé de chiffrement, télécharge l’image et démarre le conteneur :

    curl -fsSL https://freellmapi.co/install.sh | bash
    

    La réexécution du script est sécurisée : le fichier .env et la clé de chiffrement sont enregistrés et le conteneur est mis à jour vers la dernière version. Sous Windows, cette méthode fonctionne dans WSL ou dans n’importe quel environnement bash.

    Après le lancement, le panneau s’ouvre à :

    http://localhost:3001
    

    Pour l’installation du serveur, vous devez créer un compte avec un email et un mot de passe. En cas d’oubli du mot de passe, le code de réinitialisation est imprimé dans le journal du conteneur :

    docker compose logs -f freellmapi
    

    Docker Compose

    Si vous souhaitez conserver la configuration dans git et gérer le lancement manuellement, Compose standard fera l’affaire. Sous macOS et Linux :

    git clone https://github.com/tashfeenahmed/freellmapi.git
    cd freellmapi
    ENCRYPTION_KEY="$(openssl rand -hex 32)"
    printf "ENCRYPTION_KEY=%s\nPORT=3001\n" "$ENCRYPTION_KEY" > .env
    docker compose up -d
    

    Sous Windows PowerShell :

    git clone https://github.com/tashfeenahmed/freellmapi.git
    cd freellmapi
    $Bytes = New-Object Byte[] 32
    [Security.Cryptography.RandomNumberGenerator]::Create().GetBytes($Bytes)
    $ENCRYPTION_KEY = -join ($Bytes | ForEach-Object { "{0:x2}" -f $_ })
    "ENCRYPTION_KEY=$ENCRYPTION_KEY`nPORT=3001" | Out-File -Encoding utf8 .env
    docker compose up -d
    

    La clé ENCRYPTION_KEY est obligatoire : elle permet de chiffrer les clés du fournisseur dans la base de données SQLite. Vous ne pouvez pas le modifier à la volée – les anciens secrets ne seront plus déchiffrés. Pour la rotation, le projet dispose d’une commande séparée rotate-encryption-key.

    Exécuter à partir des sources

    Pour le développement ou le débogage, vous pouvez exécuter le projet via Node.js :

    git clone https://github.com/tashfeenahmed/freellmapi.git
    cd freellmapi
    npm install
    ENCRYPTION_KEY="$(node -e 'console.log(require("crypto").randomBytes(32).toString("hex"))')"
    printf "ENCRYPTION_KEY=%s\nPORT=3001\n" "$ENCRYPTION_KEY" > .env
    npm run dev
    

    Dans ce mode, l’API et le panneau sont activés sur le port 3001 et l’interface Vite est activée sur le port 5173.

    Premier lancement et clés du fournisseur

    Ouvrez le panneau, accédez à la page Clés et ajoutez les clés des services que nous utilisons. Pour chaque fournisseur, l’interface propose un lien vers l’inscription et une indication où obtenir la clé. Il suffit de commencer par un ou deux : par exemple, Google AI Studio et Groq.

    Une fois ajoutée, la clé subit un bilan de santé. Si le fournisseur a répondu par une erreur, la clé restera dans la liste, mais sera marquée comme non saine – elle peut être vérifiée à nouveau ou supprimée.

    Ensuite, vous devez accéder à la page Modèles et voir quels modèles sont disponibles. Là, vous pouvez également configurer la stratégie de routage et l’ordre de la Chaîne de secours – la chaîne le long de laquelle le routeur parcourt en cas d’erreurs et de limites. Le modèle auto signifie que le choix est fait par le routeur lui-même. En plus de cela, des options telles que auto:fast, auto:smart et des profils nommés pour des tâches spécifiques sont disponibles.

    Il convient également de vérifier qu’il existe des modèles dans la chaîne prenant en charge les outils. OpenCode utilise activement les appels d’outils, et un modèle sans cette fonctionnalité ne pourra pas lire les fichiers ou exécuter des commandes normalement.

    La clé unifiée se trouve là, sur la page Clés ou dans la barre d’état de l’application de bureau. Cela ressemble à une chaîne avec un préfixe :

    freellmapi-...
    

    C’est cette clé, et non les clés des fournisseurs individuels, qui est indiquée dans OpenCode.

    Connectez-vous à OpenCode

    FreeLLMAPI dispose d’un générateur de configuration qui lit lui-même le répertoire modèle de la passerelle en cours d’exécution, crée une copie de sauvegarde de la configuration existante et y ajoute soigneusement le fournisseur.

    Tout d’abord, définissons la clé unifiée sur la variable d’environnement. Le générateur le lit au lieu d’un indicateur séparé, de sorte que le secret ne se retrouvera pas dans l’historique des commandes.

    Sous macOS et Linux :

    export FREELLMAPI_API_KEY=freellmapi-YOUR_KEY
    

    Sous Windows PowerShell :

    $env:FREELLMAPI_API_KEY="freellmapi-YOUR_KEY"
    

    Voyons maintenant ce qui sera exactement enregistré :

    npx freellmapi setup-opencode --url http://localhost:3001 --dry-run
    

    Si diff est satisfaisant, répétez la commande sans le flag :

    npx freellmapi setup-opencode --url http://localhost:3001
    

    Le générateur écrit la configuration globale OpenCode :

    ~/.config/opencode/opencode.json
    

    Le fournisseur freellmapi y apparaît avec le package @ai-sdk/openai-compatible, l’adresse de base http://localhost:3001/v1 et une carte des modèles du catalogue live. Le modèle par défaut devient freellmapi/auto.

    La clé elle-même ne finit pas dans le fichier : la config contient la substitution {env:FREELLMAPI_API_KEY}. Par conséquent, la variable doit rester définie au démarrage de l’agent :

    opencode
    

    Cette méthode est également pratique car le secret ne se retrouve pas dans la configuration et ne se retrouvera pas dans git. Pour les exécutions CI et uniques, c’est plus correct que de stocker la clé dans un fichier.

    Réglage manuel

    Si vous ne souhaitez pas exécuter le générateur, vous pouvez décrire manuellement le fournisseur dans opencode.json. L’option minimale ressemble à ceci :

    {
      "$schema": "https://opencode.ai/config.json",
      "model": "freellmapi/auto",
      "provider": {
        "freellmapi": {
          "npm": "@ai-sdk/openai-compatible",
          "name": "FreeLLMAPI",
          "options": {
            "baseURL": "http://localhost:3001/v1",
            "apiKey": "{env:FREELLMAPI_API_KEY}"
          },
          "models": {
            "auto": {
              "name": "FreeLLMAPI Auto Router",
              "limit": { "context": 1048576, "output": 65536 }
            }
          }
        }
      }
    }
    

    Le champ modèle au niveau supérieur est important : sans lui, OpenCode peut continuer à utiliser le modèle précédent ou ne rien sélectionner sur une nouvelle installation. Il est préférable de prendre le contexte et les limites de sortie de la réponse de la passerelle, plutôt que de les inventer :

    curl http://localhost:3001/v1/models
    

    Vous pouvez ajouter des identifiants spécifiques à la liste des modèles si vous devez y accéder manuellement. Mais pour le travail quotidien, l’auto suffit : le routeur lui-même sélectionnera un modèle vivant et commutera lorsque la limite sera atteinte.

    Comment l’utiliser

    Après avoir lancé opencode, la liste des modèles s’ouvre avec une commande familière :

    /models
    

    Il aura un fournisseur FreeLLMAPI et un modèle automatique. Ensuite, le travail se déroule comme d’habitude : nous décrivons la tâche, spécifions les fichiers via @, changeons de mode de planification avec la touche Tab, annulons les modifications avec la commande /undo. Pour un nouveau projet, il est utile d’exécuter /init pour que l’agent crée AGENTS.md.

    Quelques conseils pratiques :

    • Routage. Pour la routine, laissez-le sur automatique. Si vous avez besoin de rapidité, essayez auto:fast, si la qualité est auto:smart ou un modèle puissant spécifique du catalogue.
    • Diagnostics Chaque réponse de passerelle contient un en-tête X-Routed-Via avec le nom du fournisseur et le modèle qui a réellement servi la requête. Il montre où le routeur a envoyé la tâche.
    • Analytics. Sur la page Analytics, le panneau affiche le volume de demandes, le succès, les retards p50/p95 et la consommation de jetons par fournisseur.
    • Continuité du dialogue. Lors du changement de modèle au milieu d’une conversation, la passerelle peut ajouter une courte note sur le transfert de contexte. Activé par la variable FREELLMAPI_CONTEXT_HANDOFF=on_model_switch.

    Si OpenCode s’exécute dans un conteneur et que FreeLLMAPI s’exécute sur un hôte, localhost pointera vers le conteneur lui-même. Dans ce cas, vous devez utiliser host.docker.internal ou une autre adresse accessible depuis le conteneur dans la baseURL.

    À quoi faire attention

    FreeLLMAPI ne remplace pas les modèles payants et n’est pas un service avec un SLA. C’est un moyen de regrouper les forfaits gratuits en une seule passerelle soignée. Il y a donc plusieurs restrictions :

    • La qualité fluctue. Les tarifs gratuits prennent fin et, tard dans la soirée, à l’approche de l’épuisement des quotas quotidiens, le routeur peut passer à des modèles plus faibles. Les quotas sont généralement réinitialisés à minuit UTC.
    • Les latences sont variables. Différents fournisseurs réagissent différemment et lors du passage à un modèle de sauvegarde, la demande peut prendre sensiblement plus de temps.
    • Il n’existe pas de modèles phares. De bons modèles, mais pas haut de gamme, sont disponibles dans les forfaits gratuits. Pour les architectures complexes, cela vaut la peine d’être pris en compte.
    • La passerelle doit être en cours d’exécution. Si l’application ou le conteneur est arrêté, OpenCode ne recevra pas de réponse. Le démarrage automatique de l’application dans la barre d’état ou le redémarrage de la stratégie du conteneur résout ce problème.
    • Le projet est conçu pour un seul utilisateur. Les clés du fournisseur sont stockées localement et cryptées, mais un panneau partagé pour plusieurs personnes n’est pas le scénario pour cet outil. La clé unifiée et .env doivent être protégés de la même manière qu’un secret ordinaire.

    Et encore une nuance : le catalogue de modèles se met à jour tout seul, mais l’installation gratuite reçoit un instantané du catalogue avec un délai d’une trentaine de jours. Le forfait payant Premium accélère la mise à jour, mais il n’est pas nécessaire de se familiariser avec le projet – le routeur lui-même reste gratuit et ouvert.

    Liens

    https://github.com/tashfeenahmed/freellmapi
    https://freellmapi.co/
    https://freellmapi.co/models
    https://github.com/tashfeenahmed/freellmapi/releases/latest
    https://github.com/tashfeenahmed/freellmapi/blob/main/docs/en/install/01-install.md
    https://github.com/tashfeenahmed/freellmapi/blob/main/docs/en/clients/01-agent-clients.md
    https://github.com/tashfeenahmed/freellmapi/blob/main/cli/README.md
    https://opencode.ai/
    https://opencode.ai/docs/
    https://opencode.ai/docs/providers/

    Sources

    https://github.com/tashfeenahmed/freellmapi
    https://github.com/tashfeenahmed/freellmapi/blob/main/README.ru.md
    https://github.com/tashfeenahmed/freellmapi/blob/main/docs/en/install/01-install.md
    https://github.com/tashfeenahmed/freellmapi/blob/main/docs/en/clients/01-agent-clients.md
    https://github.com/tashfeenahmed/freellmapi/blob/main/docs/en/clients/02-supported-agents.md
    https://github.com/tashfeenahmed/freellmapi/blob/main/cli/README.md
    https://opencode.ai/docs/providers/

  • Fournisseurs d’IA russes pour OpenCode

    OpenCode est un agent de programmation ouvert qui fonctionne directement dans le terminal : lit les fichiers du projet, édite le code, exécute des commandes et des tests, recherche dans le référentiel et fonctionne avec git. Sa force réside dans le fait qu’il n’est pas lié à un seul fournisseur modèle et qu’il peut connecter des dizaines de fournisseurs.

    GigaChat est un grand modèle de langage de Sber. Il ne figure pas dans la liste prête des fournisseurs OpenCode, mais ce n’est pas un problème : OpenCode connecte des fournisseurs arbitraires via les packages Vercel AI SDK. Pour GigaChat, il existe un package gigachat-ai-sdk-provider, qui s’occupe de l’autorisation OAuth et de la mise à jour du jeton d’accès. Une nuance distincte concerne les certificats du ministère du Développement numérique : sans eux, Node ne fait pas confiance aux serveurs GigaChat et les demandes échouent avec une erreur de vérification du certificat.

    Dans cet article, je vais décrire comment obtenir une clé, installer des certificats et connecter GigaChat à OpenCode.

    Ce dont vous avez besoin

    Pour travailler, vous avez besoin de trois choses :

    • OpenCode installé. Si l’agent n’est pas encore installé, j’ai discuté de la procédure d’installation dans une note séparée sur OpenCode et DeepSeek.
    • Compte GigaChat. Inscription dans GigaChat Studio et clé d’autorisation : vous aurez besoin de l’identifiant Sber pour vous connecter.
    • Terminal moderne. WezTerm, Alacritty, Ghostty, Kitty ou tout autre feront l’affaire.

    Clé d’autorisation GigaChat

    La clé est créée dans votre compte personnel GigaChat Studio. Accédez à Developers.sber.ru/studio, connectez-vous et créez un projet dans la section API GigaChat. Dans les paramètres du projet, il y a un bloc avec les données d’autorisation : la ligne qui est copiée à partir de là est une clé d’autorisation prête à l’emploi en base64. C’est celle-ci qui est substituée dans la variable d’environnement, et non la paire client-secret séparément.

    Avec la clé, la portée est spécifiée – la zone d’accès :

    • GIGACHAT_API_PERS – pour les particuliers.
    • GIGACHAT_API_B2B – pour les entrepreneurs individuels et les personnes morales.
    • GIGACHAT_API_CORP – accès d’entreprise.

    La valeur de clé affichée doit être enregistrée immédiatement : elle ne sera plus affichée plus tard, et si nécessaire, une nouvelle devra être émise.

    Il est important de comprendre quelle est cette ligne. La clé d’autorisation n’est pas un secret distinct, mais une paire de client_id:client_secret déjà encodé en base64. La bibliothèque gigachat-js remplace cet en-tête dans la requête OAuth :

    Authorization: Basic ваш_ключ_авторизации
    

    En réponse, un jeton d’accès JWE a une durée de vie d’environ une demi-heure, puis la bibliothèque le met à jour automatiquement. Le package lui-même vérifie que la valeur est similaire à base64 et avertit si la variable contient accidentellement un secret client « brut ». Par conséquent, il est nécessaire de transférer la chaîne base64 prête à l’emploi du compte vers la variable de configuration et d’environnement, et non la paire client_id et client_secret séparément.

    Certificats du Ministère du Développement Numérique

    L’API GigaChat utilise des certificats du ministère du Développement numérique de la NCA. Le magasin de racines de confiance standard ne les a pas, donc lorsque vous essayez d’obtenir un jeton d’accès, la demande échoue avec une erreur telle que :

    self-signed certificate in certificate chain
    

    Les certificats peuvent être installés au niveau du système d’exploitation – ils seront alors approuvés par le navigateur et les utilitaires système. Mais OpenCode fonctionne sur Node et Bun, il est donc plus sûr et plus facile de spécifier le fichier de certificat directement dans la variable NODE_EXTRA_CA_CERTS. Téléchargez les certificats racine et émetteur et placez-les dans un seul fichier PEM :

    curl -s https://gu-st.ru/content/lending/russian_trusted_root_ca_pem.crt -o russian_trusted_root_ca_pem.crt
    curl -s https://gu-st.ru/content/lending/russian_trusted_sub_ca_pem.crt -o russian_trusted_sub_ca_pem.crt
    cat russian_trusted_root_ca_pem.crt russian_trusted_sub_ca_pem.crt > russian_trusted_ca_bundle.pem
    

    Le fichier peut être placé dans un emplacement pratique et son chemin complet peut être spécifié lors du démarrage de l’agent.

    Il y a un piège ici. Les fichiers téléchargés utilisent des sauts de ligne CRLF et le certificat racine n’a pas de saut de ligne de fin. Par conséquent, un chat ordinaire concatène la fin du premier certificat et le début du second en une seule ligne :

    -----END CERTIFICATE----------BEGIN CERTIFICATE-----
    

    LibreSSL – et le système openssl sur macOS, je vous le rappelle, est exactement LibreSSL – n’accepte pas un tel fichier et répond par une erreur :

    PEM routines:CRYPTO_internal:bad end line
    

    Cela signifie que le chat seul ne suffit pas. Chaque certificat doit d’abord être exécuté via openssl : il le recodera en PEM canonique avec des sauts de ligne LF et un saut de ligne final, puis fusionné :

    openssl x509 -in russian_trusted_root_ca_pem.crt -out russian_trusted_root_ca.pem
    openssl x509 -in russian_trusted_sub_ca_pem.crt -out russian_trusted_sub_ca.pem
    cat russian_trusted_root_ca.pem russian_trusted_sub_ca.pem > russian_trusted_ca_bundle.pem
    

    Vous pouvez vérifier que le fichier est lu comme ceci :

    openssl x509 -in russian_trusted_ca_bundle.pem -noout -subject
    

    Si les certificats proviennent d’une autre source et sont au format DER ou PKCS#7, ils peuvent également être recodés en PEM :

    openssl x509 -in cert.crt -inform DER -outform PEM -out cert.pem
    openssl pkcs7 -print_certs -in bundle.p7b -out cert.pem
    

    Connectez-vous à OpenCode

    Le fournisseur est décrit dans le fichier de configuration opencode.jsonc. OpenCode lui-même téléchargera et connectera le package npm spécifié dans le champ npm, y trouvera l’usine createGigaChat et lui transmettra les options. Il suffit de lister les modèles par leurs identifiants depuis l’API.

    Le fichier peut être placé à deux endroits :

    • Global – ~/.config/opencode/opencode.jsonc. Les paramètres s’appliquent à tous les projets utilisateur.
    • Dans le projet – opencode.jsonc à la racine du projet. Cette configuration a une priorité plus élevée et peut être validée en toute sécurité sur git.

    Les deux fichiers utilisent le même schéma et sont combinés : le fichier de projet chevauche le fichier global uniquement avec les clés correspondantes, les paramètres restants sont enregistrés. L’extension .jsonc est également prise en charge. Si GigaChat n’est nécessaire que pour certains référentiels, il est plus pratique de conserver le fournisseur dans la configuration du projet plutôt que dans la configuration globale.

    {
      "$schema": "https://opencode.ai/config.json",
      "provider": {
        "gigachat": {
          "npm": "gigachat-ai-sdk-provider",
          "name": "GigaChat",
          "models": {
            "GigaChat-2-Max": { "name": "GigaChat 2 Max" },
            "GigaChat-2-Pro": { "name": "GigaChat 2 Pro" },
            "GigaChat-2": { "name": "GigaChat 2 Lite" },
            "GigaChat": { "name": "GigaChat" }
          }
        }
      }
    }
    

    Les modèles disponibles avec une clé personnelle sont répertoriés ici. Si vous avez un projet pour un entrepreneur individuel ou une personne morale ayant accès à GigaChat 3, ajoutez les identifiants nécessaires de la méthode modèles au bloc modèles.

    Il est plus pratique de ne pas stocker la clé elle-même dans un fichier, mais de la transmettre à une variable d’environnement : le package gigachat-js la lit automatiquement. La valeur de portée peut également être définie sur une variable. Il ne reste plus qu’à définir le chemin d’accès aux certificats et à lancer l’agent :

    export GIGACHAT_CREDENTIALS=ваш_ключ_авторизации
    export GIGACHAT_SCOPE=GIGACHAT_API_PERS
    export NODE_EXTRA_CA_CERTS=/путь/к/russian_trusted_ca_bundle.pem
    opencode
    

    Cette option est également intéressante car le secret ne se retrouve pas dans le stockage local auth.json : il vit uniquement dans l’environnement du processus. Ceci est plus pratique pour les lancements CI et ponctuels.

    Modèles

    L’ensemble des modèles disponibles dépend de la clé de portée. La clé personnelle (GIGACHAT_API_PERS) est disponible pour la famille GigaChat et GigaChat 2 :

    • GigaChat – modèle de base.
    • GigaChat-2 : un modèle rapide et léger pour les tâches quotidiennes, affiché en version Lite dans l’interface.
    • GigaChat-2-Pro : un modèle amélioré pour les tâches gourmandes en ressources.
    • GigaChat-2-Max est le plus puissant disponible en utilisant une clé personnelle.

    La famille GigaChat 3 (GigaChat-3-Ultra, GigaChat-3-Pro, modèles ouverts comme GigaChat3.5-432B-A28B-Reasoning) est visible dans le catalogue de la console, mais elle n’est pas disponible à la clé personnelle : elle nécessite un projet d’entrepreneur individuel ou une personne morale de portée GIGACHAT_API_B2B ou GIGACHAT_API_CORP et un tarif adapté. Sur une clé personnelle, un tel modèle répond par une erreur :

    {"status":404,"message":"No such model"}
    

    Vous pouvez vérifier ce que votre clé génère réellement en interrogeant la liste des modèles :

    curl -H "Authorization: Bearer <токен_доступа>" https://gigachat.devices.sberbank.ru/api/v1/models
    

    Encore deux points. Les ID de modèle dans l’API ne correspondent pas aux noms affichés : le modèle léger est appelé GigaChat-2 et non GigaChat-2-Lite. Et le catalogue dans la console ne montre pas la même chose que ce qui est disponible sur votre clé, vous devez donc vous concentrer sur la réponse de la méthode des modèles, et non sur la liste avec les prix.

    Dans l’interface, la liste des modèles s’ouvre avec la commande :

    /models
    

    Pour le travail de routine dans le référentiel – navigation dans les fichiers, modifications mineures, exécution de tests – GigaChat-2 est largement suffisant. Pour les tâches et la conception complexes, il est logique de passer à Pro ou Max.

    Premier lancement dans le projet

    Accédez au répertoire du projet et lancez l’agent :

    cd ваш_проект
    opencode
    

    La première étape consiste à initialiser l’agent :

    /init
    

    OpenCode analysera la structure du projet et créera un fichier AGENTS.md – instructions pour l’agent. Ce fichier vaut la peine d’être engagé dans git : il aide l’agent à comprendre les conventions et les modèles adoptés dans le projet.

    Alternative : proxy local

    Si, pour une raison quelconque, vous ne souhaitez pas utiliser le fournisseur npm, un proxy local donne le même résultat. L’équipe GigaChat dispose d’un service officiel gpt2giga – FastAPI qui traduit les requêtes au format OpenAI, Anthropic et Gemini dans l’API GigaChat et met à jour le jeton d’accès lui-même. Il est généré localement sur le port 8090, après quoi un fournisseur compatible OpenAI standard est configuré dans OpenCode via le package @ai-sdk/openai-compatible avec l’adresse de base http://localhost:8090/v1. L’inconvénient de cette voie est que vous devez également conserver un service Python en cours d’exécution à côté d’OpenCode.

    {
      "$schema": "https://opencode.ai/config.json",
      "provider": {
        "gigachat": {
          "npm": "@ai-sdk/openai-compatible",
          "name": "GigaChat (proxy)",
          "options": {
            "baseURL": "http://localhost:8090/v1"
          },
          "models": {
            "GigaChat-2-Max": { "name": "GigaChat 2 Max" }
          }
        }
      }
    }
    

    DeepSeek et autres modèles via Cloud.ru

    L’API GigaChat elle-même n’a pas de modèles DeepSeek : il existe uniquement la famille GigaChat et des modèles pour les intégrations. Si vous avez besoin de DeepSeek dans OpenCode, mais via une passerelle cloud russe, le service Foundation Models de Cloud.ru convient. Il fournit des modèles utilisant le protocole compatible OpenAI, il est donc connecté à l’aide du package standard @ai-sdk/openai-compatible.

    Dans le catalogue Cloud.ru Foundation Models, il existe, par exemple, les modèles suivants :

    deepseek-ai/DeepSeek-V4.1-Flash
    deepseek-ai/DeepSeek-V4-Flash
    deepseek-ai/DeepSeek-V4-Pro
    

    La clé est émise dans la console Cloud.ru : section Utilisateurs, onglet Comptes de service. Nous créons un compte de service au niveau du projet, puis dans ses informations d’identification, nous créons une clé API avec le service Foundation Models. La clé secrète est affichée une fois et nous la sauvegardons.

    La configuration du fournisseur dans opencode.json ressemble à ceci :

    {
      "$schema": "https://opencode.ai/config.json",
      "provider": {
        "cloudru": {
          "npm": "@ai-sdk/openai-compatible",
          "name": "Cloud.ru Foundation Models",
          "options": {
            "baseURL": "https://foundation-models.api.cloud.ru/v1",
            "apiKey": "{env:CLOUDRU_API_KEY}"
          },
          "models": {
            "deepseek-ai/DeepSeek-V4.1-Flash": { "name": "DeepSeek V4.1 Flash", "limit": { "context": 1048576, "output": 1048576 } },
            "deepseek-ai/DeepSeek-V4-Flash": { "name": "DeepSeek V4 Flash", "limit": { "context": 1048576, "output": 1048576 } },
            "deepseek-ai/DeepSeek-V4-Pro": { "name": "DeepSeek V4 Pro", "limit": { "context": 1048576, "output": 1048576 } }
          }
        }
      }
    }
    

    On passe la clé à la variable d’environnement :

    export CLOUDRU_API_KEY=ваш_ключ_cloudru
    opencode
    

    Les certificats du ministère du Développement numérique ne sont pas nécessaires ici : le domaine api.cloud.ru a un TLS régulier, contrairement à GigaChat. Mais cela vaut la peine de surveiller le reste du projet. Si le compte est nul, l’autorisation est acceptée et les demandes sont abandonnées avec la réponse de facturation :

    {"message":"Not enough money"}
    

    Ce n’est pas une erreur de configuration, mais un signal indiquant que vous devez mettre à jour le projet dans la console Cloud.ru.

    À quoi faire attention

    Quelques points pratiques qui gênent le plus souvent lors de la première mise en place :

    • Erreur de vérification du certificat. Le message concernant le certificat auto-signé dans la chaîne signifie que la variable NODE_EXTRA_CA_CERTS n’a pas été récupérée. Vérifiez le chemin d’accès au fichier, que l’agent s’exécute dans le même environnement, ainsi que le fichier lui-même : si, lors de la fusion de deux certificats à l’aide de cat, leurs extrémités se retrouvent sur la même ligne, LibreSSL renverra une mauvaise ligne de fin et le bundle devra être reconstruit via openssl, comme dans la section sur les certificats.
    • Erreur 401. En règle générale, il s’agit d’une clé d’autorisation incorrecte ou d’un champ d’application incompatible : pour un individu, vous avez besoin de GIGACHAT_API_PERS.
    • Erreur 404 avec le texte Aucun modèle de ce type. Il ne s’agit pas d’un échec de connexion, mais d’un manque d’accès à un modèle spécifique. Supprimez-le de la configuration ou remplacez-le par un disponible. Dans un message tel que GigaChat 404 : Erreur inconnue, la même réponse GigaChat est à blâmer : le fournisseur n’a tout simplement pas pu analyser le corps de l’erreur.
    • Coût. OpenCode ne nécessite pas d’abonnement : vous payez GigaChat directement lorsque vous dépensez des jetons, le prix des longues sessions est donc prévisible.
    • Qualité du modèle. Pour les tâches architecturales complexes, les modèles de différentes classes diffèrent. Par conséquent, pour la conception, il est logique de prendre un modèle plus solide et de confier la routine à un modèle plus rapide.

    Liens

    https://opencode.ai/
    https://opencode.ai/docs/providers/
    https://developers.sber.ru/studio/
    https://developers.sber.ru/docs/ru/gigachat/guides/main
    https://github.com/nyddle/gigachat-ai-sdk-provider
    https://github.com/ai-forever/gpt2giga
    https://cloud.ru/docs/foundation-models/ug/topics/quickstart

    Sources

    https://opencode.ai/docs/providers/#custom-provider
    https://developers.sber.ru/docs/ru/gigachat/certificates
    https://developers.sber.ru/docs/ru/gigachat/models/main
    https://developers.sber.ru/docs/ru/gigachat/guides/selecting-a-model
    https://github.com/nyddle/gigachat-ai-sdk-provider
    https://github.com/ai-forever/gpt2giga
    https://cloud.ru/docs/foundation-models/ug/topics/quickstart
    https://cloud.ru/docs/foundation-models/ug/topics/overview__available__models

  • AirLLM : de grands modèles de langage sur une carte graphique faible

    En règle générale, l’exécution d’un modèle de langage volumineux comportant 70 milliards de paramètres nécessite plusieurs dizaines de gigaoctets de mémoire vidéo. AirLLM aborde ce problème plus sereinement et propose une manière différente : un tel modèle peut être exécuté sur une carte vidéo avec seulement 4 Go de mémoire, et sans quantification, distillation et découpage. Dans cette note, je vais essayer de vous expliquer sans hâte comment fonctionne AirLLM, comment l’utiliser, et je partagerai mon petit projet AirLLM-experiments, qui rend le travail avec cette bibliothèque un peu plus pratique.

    Qu’est-ce qu’AirLLM

    AirLLM est une bibliothèque open source pour l’inférence de grands modèles de langage écrite par Gavin Li. Son idée est simple et pourtant élégante : au lieu de stocker tous les poids du modèle en même temps dans la mémoire vidéo, la bibliothèque ne charge qu’une seule couche à la fois sur le GPU. Les poids sont stockés sur le disque sous forme de fragments découpés en couches, et lors de la génération, chaque couche est chargée, traitée et déchargée tour à tour.

    Il s’ensuit que la quantité de mémoire vidéo requise ne dépend pas de la taille globale du modèle, mais de la taille d’une de ses couches. C’est pourquoi le modèle 70B tient dans 4 Go, le DeepSeek-V3 sur 671B tient dans environ 12 Go et le Qwen3-235B tient dans environ 3 Go. Mais la taille du modèle lui-même est limitée principalement par l’espace disque, et non par les capacités de la carte vidéo.

    Ces économies de mémoire se font au détriment de la vitesse : chaque couche est lue sur le disque lorsque chaque jeton est généré, la sortie est donc lente, environ quelques secondes par jeton. AirLLM concerne donc moins une discussion interactive rapide que la possibilité de lancer un modèle qui, autrement, ne rentrerait pas dans le matériel.

    Installation

    La bibliothèque s’installe depuis PyPI à l’aide de la commande habituelle :

    pip install airllm
    

    Lors du premier lancement, le modèle sera téléchargé depuis Hugging Face et sera décomposé en couches. Ce processus est lent et occupe beaucoup d’espace disque, vous devez donc préparer l’espace libre à l’avance. Si vous le souhaitez, vous pouvez activer la compression 4 bits ou 8 bits – la quantification par blocs sera alors appliquée aux poids, ce qui accélère le chargement des couches à partir du disque d’environ trois fois, et la précision est considérablement perdue.

    Exemple de base

    Vous pouvez travailler avec AirLLM presque de la même manière qu’avec un modèle classique de transformateurs. Il suffit de saisir une fois l’ID du modèle sur Hugging Face, et tout vous sera alors familier :

    from airllm import AutoModel
    
    MAX_LENGTH = 128
    model = AutoModel.from_pretrained("Qwen/Qwen3-32B")
    
    input_text = ['What is the capital of United States?']
    
    input_tokens = model.tokenizer(
        input_text,
        return_tensors="pt",
        return_attention_mask=False,
        truncation=True,
        max_length=MAX_LENGTH,
        padding=False)
    
    generation_output = model.generate(
        input_tokens['input_ids'].cuda(),
        max_new_tokens=20,
        use_cache=True,
        return_dict_in_generate=True)
    
    print(model.tokenizer.decode(generation_output.sequences[0]))
    

    La classe AutoModel elle-même détermine le type de modèle, la même ligne peut donc être utilisée pour Llama, Qwen et DeepSeek. Et si vous prenez un modèle comme DeepSeek-V3 avec des paramètres 671B, il pourra également contenir environ 12 Go de mémoire vidéo – c’est en grande partie ce qui rend le projet attrayant.

    Lancer sur macOS

    AirLLM fonctionne non seulement sur CUDA, mais également sur Apple Silicon. Sur macOS, il utilise le backend MLX, il faudra donc que mlx et torch soient installés et ne prend en charge que les puces Apple. Il existe également une petite limitation : l’implémentation MLX ne prend en charge que les architectures de type Llama, donc Qwen et les modèles similaires ne peuvent pas être lancés sur un MacBook de cette manière.

    Utiliser un exemple

    Les expériences AirLLM sont deux petits utilitaires de console interactifs permettant d’exécuter localement de grands modèles de langage. Ils éliminent le besoin d’écrire le même code à chaque fois pour charger le modèle et organiser le chat.

    Le premier outil, airllm-lib-usage.py, exécute la bibliothèque AirLLM directement dans le processus Python actuel. Il affiche une liste numérotée de modèles du catalogue général, si nécessaire, il installe les dépendances manquantes et ouvre une session de chat. Le runtime MLX est utilisé sur macOS, torch est utilisé sur d’autres plates-formes.

    Le deuxième outil, airllm-openai-server-client.py, vous aide à travailler avec le serveur airllm-openai-server, qui s’exécute dans Docker et fournit une API compatible OpenAI. Lorsque vous le lancez pour la première fois, l’utilitaire demande des paramètres, collecte l’image, récupère le conteneur et ouvre une discussion en streaming sur le serveur en cours d’exécution. Lorsqu’il est lancé à plusieurs reprises, il trouve un conteneur existant et le réutilise simplement, et stocke le cache du modèle dans un volume Docker séparé afin de ne pas télécharger à nouveau le modèle.

    La liste des modèles disponibles est incluse dans le module commun model_catalog.py, donc les deux outils fonctionnent avec le même ensemble. Les commandes de discussion sont également courantes : /help, /clear, /exit. Le code source et les instructions sont dans le dépôt :

    https://github.com/zefir1990/AirLLM-experiments

    À quoi faire attention

    La préparation de la première réponse peut prendre plusieurs minutes : tout d’abord, AirLLM télécharge le modèle et le découpe en couches, puis commence seulement à générer. De plus, la vitesse reste également faible – il s’agit d’un compromis délibéré dans un souci d’économie de mémoire. Pour les modèles fermés comme le méta-llama, vous devez accepter les conditions de Hugging Face et transmettre un jeton d’accès. Il est préférable de ne pas supprimer le cache des modèles et fragments téléchargés, sinon tout devra être téléchargé à nouveau.

    Liens

    https://github.com/lyogavin/airllm
    https://github.com/mkamranr/airllm-openai-server
    https://github.com/zefir1990/AirLLM-experiments
    https://pypi.org/project/airllm/
    https://huggingface.co/

    Sources

    https://github.com/lyogavin/airllm
    https://github.com/zefir1990/AirLLM-experiments

  • Installer OpenCode et connecter DeepSeek

    OpenCode est un agent de programmation ouvert qui réside directement dans le terminal. Il peut lire des fichiers de projet, éditer du code, exécuter des commandes et des tests, rechercher dans le référentiel et travailler avec git – à peu près la même chose que Claude Code et d’autres agents de console. La principale différence est qu’OpenCode n’est pas lié à un seul fournisseur de modèle : des dizaines de fournisseurs peuvent être connectés via lui, y compris DeepSeek. Dans cet article, je décrirai l’installation de l’agent et la connexion de DeepSeek à celui-ci.

    Ce dont vous avez besoin

    Vous n’avez besoin que de deux choses pour fonctionner :

    • Terminal moderne. WezTerm, Alacritty, Ghostty, Kitty ou tout autre feront l’affaire.
    • Clé API du fournisseur. Dans notre cas, DeepSeek.

    Node.js n’est pas requis si vous installez l’agent avec un script d’installation standard : le binaire arrive prêt à l’emploi.

    Installation

    Le moyen le plus simple est le script d’installation officiel :

    curl -fsSL https://opencode.ai/install | bash
    

    Il détectera la plateforme elle-même et placera le fichier exécutable dans PATH. Après l’installation, vous devez vérifier que tout est en place :

    opencode --version
    

    Si la commande affiche la version, l’installation a réussi.

    Installation à l’aide d’autres méthodes

    Si vous préférez les gestionnaires de packages, il existe plusieurs options. Via Node.js :

    npm install -g opencode-ai
    

    Bun, pnpm et Yarn peuvent faire la même chose :

    bun install -g opencode-ai
    pnpm install -g opencode-ai
    yarn global add opencode-ai
    

    macOS et Linux ont Homebrew. Attention : c’est le tap des développeurs qui est recommandé, et non la formule officielle – il est mis à jour moins fréquemment :

    brew install anomalyco/tap/opencode
    

    Sous Arch Linux :

    sudo pacman -S opencode
    paru -S opencode-bin
    

    La première commande installe la version stable du référentiel, la seconde – la dernière de l’AUR.

    Installation sous Windows

    Sous Windows, il est recommandé de travailler via WSL : de cette façon, les performances sont plus élevées et la compatibilité avec les capacités de l’agent est complète. Mais il existe aussi des méthodes natives. Via Chocolatey, Scoop ou npm :

    choco install opencode
    scoop install opencode
    npm install -g opencode-ai
    

    Il existe également une option via Mise, ainsi qu’un conteneur Docker :

    mise use -g github:anomalyco/opencode
    docker run -it --rm ghcr.io/anomalyco/opencode
    

    Enfin, le binaire terminé peut toujours être extrait de la page des versions sur GitHub.

    Clé DeepSeek

    La clé est créée dans votre compte personnel DeepSeek. Accédez à platform.deepseek.com, ouvrez la section avec les clés API et cliquez sur créer une nouvelle clé. Il est préférable de sauvegarder immédiatement la chaîne résultante : elle ne sera affichée qu’une seule fois.

    Connexion DeepSeek

    Ensuite, tout se fait à l’intérieur de l’agent lui-même. Lancez OpenCode dans le terminal :

    opencode
    

    Dans l’interface, nous exécutons la commande de connexion :

    /connect
    

    Dans la liste des fournisseurs qui s’ouvre, recherchez DeepSeek, sélectionnez-le et insérez la clé API. Les clés ajoutées de cette manière sont enregistrées dans un fichier :

    ~/.local/share/opencode/auth.json
    

    Après connexion, il ne reste plus qu’à sélectionner le modèle avec la commande :

    /models
    

    Les modèles DeepSeek seront disponibles dans la liste, notamment deepseek-v4-pro, deepseek-flash et deepseek-v4-flash. Pour le travail de routine dans le référentiel, l’option flash est suffisante ; Pour les tâches complexes, il est judicieux de passer au pro.

    Configuration via config

    Si vous ne souhaitez pas stocker la clé via un maître ou si vous devez définir votre propre adresse API, le fournisseur est décrit directement dans le fichier de configuration opencode.json :

    {
      "$schema": "https://opencode.ai/config.json",
      "provider": {
        "deepseek": {
          "options": {
            "baseURL": "https://api.deepseek.com"
          }
        }
      }
    }
    

    Le champ baseURL est utile si vous passez par un proxy ou votre propre passerelle. Dans ce cas, il est pratique de transférer la clé elle-même vers une variable d’environnement :

    export DEEPSEEK_API_KEY=ваш_ключ_deepseek
    opencode
    

    Cette option convient aux lancements CI et ponctuels : la clé ne finit pas dans le stockage, mais vit uniquement dans l’environnement du processus.

    Premier lancement dans le projet

    Accédez au répertoire du projet et lancez l’agent :

    cd ваш_проект
    opencode
    

    La première étape consiste à l’initialiser :

    /init
    

    OpenCode analysera la structure du projet et créera un fichier AGENTS.md – un analogue des instructions pour l’agent. Ce fichier vaut la peine d’être engagé dans git : il aide l’agent à comprendre les conventions et les modèles adoptés dans le projet.

    Comment l’utiliser

    Le travail est structuré à peu près de la même manière que celui des autres agents. Quelques astuces que vous devriez connaître tout de suite :

    • Mode planification. La touche Tabulation fait basculer l’agent entre les modes planification et assemblage. Dans le premier, il suggère uniquement comment résoudre le problème et ne change rien – il est pratique de vérifier l’idée avant d’apporter des modifications.
    • Liens vers des fichiers. La touche @ ouvre une recherche floue dans les fichiers du projet pour transférer un fichier spécifique à l’agent dans le contexte.
    • Annuler les modifications. La commande /undo annule les dernières modifications et renvoie la demande d’origine, /redo les renvoie. Vous pouvez revenir en arrière de plusieurs étapes d’affilée.
    • Partager une conversation. La commande /share crée un lien vers la conversation en cours et la copie dans le presse-papiers. Par défaut, les conversations ne sont publiées nulle part.

    Pour des modifications simples, vous n’êtes pas obligé de passer en mode planification, mais décrivez immédiatement ce qui doit être fait et spécifiez les fichiers via @.

    À quoi faire attention

    Quelques points pratiques. OpenCode ne nécessite pas d’abonnement : vous payez directement le fournisseur lorsque vous dépensez des jetons, donc les longues sessions avec DeepSeek sont, comme on pouvait s’y attendre, moins chères que les meilleurs modèles. La clé est stockée localement dans auth.json – cela vaut la peine d’être pris en compte sur une machine partagée, mais pour les environnements d’autres personnes, une variable d’environnement est plus fiable.

    Et encore une chose : la qualité des réponses à des problèmes architecturaux complexes diffère selon les modèles de différentes classes, donc pour la conception, il est logique de prendre un modèle plus solide et de céder la routine à un modèle rapide et bon marché.

    Liens

    https://opencode.ai/
    https://opencode.ai/docs/
    https://opencode.ai/docs/providers/
    https://github.com/anomalyco/opencode
    https://platform.deepseek.com/api_keys
    https://api-docs.deepseek.com

    Sources

    https://opencode.ai/docs/
    https://opencode.ai/docs/providers/#deepseek
    https://github.com/anomalyco/opencode/releases
    https://models.dev/

  • Installer Asahi Linux sur un MacBook avec un processeur M2

    Sur un Mac équipé d’un processeur Apple Silicon, vous ne pouvez pas installer Linux de la manière habituelle : démarrer à partir d’une clé USB est ici impossible, et le bootloader est signé par Apple. Le projet Asahi Linux a entrepris de contourner ce problème : ses participants ont utilisé l’ingénierie inverse pour faire fonctionner le matériel M1 et M2 sous Linux classique. Désormais, la distribution phare du projet est Fedora Asahi Remix, et elle fonctionne de manière assez fiable sur le M2. Dans cet article, je décrirai l’installation étape par étape.

    Qu’est-ce qu’Asahi Linux

    Le projet a débuté en 2020, lorsque Apple est passé à ses propres puces et avec elles un système de démarrage fermé : l’appareil exécute uniquement du code signé par Apple. Les participants à Asahi Linux ont écrit leur chargeur de démarrage m1n1, sur lequel ils ont écrit U-Boot et un environnement UEFI. Ensuite, le système ARM64 le plus courant est chargé, mais avec un noyau Linux-asahi, auquel sont ajoutés des pilotes pour le matériel Apple non standard : GPU, vidéo, son, unités de caméra.

    En pratique, cela ressemble à ceci : vous exécutez l’installateur depuis macOS, il partitionne le disque, installe la chaîne de démarrage et le système. macOS reste en place, vous bénéficiez du double démarrage et choisissez votre système lorsque vous l’allumez.

    Exigences

    • Mac sur puce M2 : MacBook Air, MacBook Pro 13 “, ainsi que 14” et 16 ″ avec M2 Pro et M2 Max. Les voitures M1 sont également prises en charge.
    • MacOS actuel. Le programme d’installation nécessite la dernière version du système, donc mettez-le à jour avant de commencer.
    • Espace libre. Minimum environ 30 Go, confortable – 100 Go ou plus. L’espace est coupé du conteneur APFS et ne reviendra pas tout seul.
    • Mot de passe de l’administrateur macOS. Vous en aurez besoin à la fois lors du partitionnement et lors du premier démarrage en mode de récupération.
    • Sauvegarde. Le partitionnement de disque est une opération qu’il est préférable de démarrer avec une nouvelle sauvegarde.

    Étape 1. Sauvegarde et mise à jour

    Faites une copie via Time Machine ou toute autre méthode. Mettez à jour macOS vers la dernière version disponible et redémarrez. Si FileVault est activé, le mot de passe correspondant sera toujours nécessaire au démarrage en mode de récupération – le programme d’installation doit déverrouiller le lecteur.

    Étape 2. Lancez le programme d’installation

    Ouvrez le Terminal sur macOS et exécutez une commande :

    curl https://alx.sh | sh
    

    Il s’agit de l’installateur officiel du projet. Il se téléchargera tout seul, vérifiera votre modèle de Mac et vous proposera de choisir une distribution. Il existe également une option directement pour Fedora :

    curl https://fedora-asahi-remix.org/install | sh
    

    La première option est préférable : elle indique quels systèmes sont actuellement disponibles et elle propose également un choix de bureau.

    Étape 3. Partition de disque

    Le programme d’installation demandera le mot de passe administrateur et affichera la disposition actuelle. Le dialogue ressemble alors à ceci :

    • Appuyez sur r pour redimensionner la partition macOS.
    • Entrez la taille de la nouvelle partition Linux. Cela peut être en gigaoctets, cela peut être en pourcentage du disque, ou vous pouvez écrire min – alors le plus petit morceau possible sera coupé.
    • Confirmez le marquage avec la lettre y. Cette étape est la plus longue : le système déplace physiquement les données dans le conteneur APFS ; sur un disque volumineux, cela prend plusieurs minutes.
    • Appuyez sur f pour diriger le programme d’installation vers la partition libre nouvellement créée.

    Il est important de comprendre ce qui se passe : Linux n’est pas installé dans APFS, mais sur une partition distincte à côté de celui-ci. C’est pourquoi macOS reste intact et le rollback se réduit à la suppression de cette section.

    Étape 4. Sélection de la distribution et du bureau

    Ensuite, le programme d’installation proposera l’environnement système et de bureau. Fedora Asahi Remix est livré par défaut avec KDE Plasma – c’est l’option phare qui reçoit les mises à jour en premier. Une alternative est GNOME, qui est plus proche de macOS. Il existe également une image minimale si vous n’avez pas besoin d’un environnement graphique.

    Étape 5. Premier démarrage en mode de récupération

    Après le partitionnement, le programme d’installation vous demandera de continuer et le Mac s’éteindra. Voici la partie la plus inhabituelle :

    • Attendez au moins 25 secondes : c’est la condition requise par Apple pour passer en mode de récupération.
    • Maintenez enfoncé le bouton d’alimentation jusqu’à ce que les options de démarrage apparaissent.
    • Sélectionnez le volume d’installation et saisissez votre mot de passe macOS.

    A cette étape, la chaîne de démarrage est installée dans la partition de service : environnement m1n1, U-Boot et UEFI. Ensuite, la machine redémarrera à nouveau – maintenez à nouveau le bouton d’alimentation enfoncé et sélectionnez un nouveau volume, cette fois pour accéder au système. Il y aura plusieurs redémarrages de ce type, chacun nécessitant une sélection manuelle : par défaut, le Mac continue de charger macOS.

    Étape 6. Installation du système

    Ensuite, l’assistant de configuration initiale démarre : nom du système, utilisateur, mot de passe, fuseau horaire, disposition du clavier. Après cela, l’installation elle-même commence, et elle provient déjà d’Internet – vous aurez besoin d’une connexion stable et, avec le temps, cela prend de quinze minutes à une demi-heure.

    Une fois l’installation terminée, redémarrez et sélectionnez Linux dans le menu de démarrage. Lorsque vous vous connectez pour la première fois, le système vous invite à terminer la configuration et la mise à jour.

    Ce qui fonctionne et ce qui ne fonctionne pas

    Avant l’installation, vous devez évaluer sobrement ce que vous allez perdre. Sur les ordinateurs portables M2, la situation est la suivante :

    Travaux:

    • Wi-Fi et Bluetooth – sans restrictions.
    • Écran et graphiques intégrés – accélération matérielle, y compris OpenGL et Vulkan.
    • Webcam, microphone et haut-parleurs sur MacBook Air et MacBook Pro.
    • Mode veille : fonctionne normalement.
    • Décodage vidéo matériel : les lecteurs ne chargent pas le processeur.
    • Ports USB, notamment USB 2 et USB 3 via des connecteurs Thunderbolt.

    Ne fonctionne pas ou fonctionne partiellement :

    • Touch ID. L’empreinte digitale n’est pas disponible sous Linux – connectez-vous avec un mot de passe.
    • Thunderbolt (USB4). Statut – en développement. Malheureusement, les appareils qui nécessitent spécifiquement Thunderbolt ne fonctionneront pas.
    • Moniteur externe via USB-C. Le mode DisplayPort Alt est également opérationnel. Les ordinateurs portables M2 n’ont pas de port HDMI, vous ne pouvez donc pas connecter un écran externe. Les modèles avec M2 Pro et M2 Max ont HDMI, et cela fonctionne. Une solution de contournement pour l’USB-C se trouve dans la section Fairydust Core ci-dessous.
    • L’encodage vidéo matériel est prévu, le décodage est déjà en place.

    En termes simples, c’est un excellent système pour travailler avec du code, un terminal, un navigateur et des modèles locaux, mais pas pour une station d’accueil pour moniteur externe.

    Moniteur externe via Fairydust Core

    La sortie d’image USB-C est disponible dans la branche expérimentale du noyau Fairydust de l’équipe Asahi Linux. Son assemblage manuel prend beaucoup de temps, il est donc plus facile d’utiliser le script wrapper du projet asahi-fairydust-display :

    git clone https://github.com/bharambetejas/asahi-fairydust-display
    cd asahi-fairydust-display
    chmod +x asahi-fairydust-build.sh
    ./asahi-fairydust-build.sh
    

    Le script clone la branche fairydust, configure et assemble le noyau, le place à côté du noyau standard et édite GRUB. Vous avez besoin de 15 Go d’espace libre, d’un adaptateur USB-C → HDMI ou DisplayPort et de 60 à 90 minutes pour l’assemblage. Après le redémarrage, sélectionnez le noyau intitulé -fairydust dans GRUB et insérez l’adaptateur dans le port USB-C le plus en avant.

    Vérifiez après le téléchargement :

    uname -r
    glxinfo | grep "OpenGL renderer"
    xrandr
    

    La première commande doit afficher la version avec le suffixe -fairydust, la seconde doit afficher l’Apple M2, pas llvmpipe, la troisième doit afficher la sortie DP-1 connectée.

    Réservations. La branche est expérimentale et n’est pas officiellement prise en charge. La sortie ne fonctionne que via un seul port USB-C et ne résiste pas toujours au branchement à chaud : il est plus sûr de redémarrer avec l’adaptateur déjà inséré. Le script ne configure pas automatiquement l’affichage : l’étape correspondante est désactivée car elle a provoqué une boucle de connexion sur Wayland. La mise à jour du noyau d’origine via dnf réorganise le lien symbolique /boot/dtb, c’est pourquoi la sortie peut cesser de fonctionner silencieusement – la construction doit alors être répétée.

    Le noyau standard n’est pas touché : pour y revenir, il suffit de le sélectionner dans le menu GRUB.

    Disque externe au lieu d’une mise à niveau

    Voici le bon côté. Le MacBook ne peut pas être mis à niveau : la mémoire et le stockage sont soudés sur la carte, et leur capacité est sélectionnée une fois lors de l’achat. Sous macOS, le disque externe reste externe : le système et les applications ne peuvent pas vraiment y être transférés.

    Sous Linux, cette limitation est supprimée : un SSD externe via USB est un périphérique de bloc standard, et n’importe quel point de montage peut y être transféré via /etc/fstab. Si vous souhaitez transférer votre répertoire personnel, votre bibliothèque Steam, des images de machine virtuelle ou des modèles locaux, veuillez le faire. Il s’avère que c’est exactement la mise à niveau que cette voiture n’a pas.

    Cela ressemble à ceci. Tout d’abord, regardez l’UUID de la partition souhaitée :

    lsblk -f
    sudo blkid
    

    Ajoutez ensuite la ligne dans /etc/fstab :

    UUID=ваш-uuid  /home  ext4  defaults,nofail  0  2
    

    Le transfert lui-même se fait par copie : les données sont déplacées vers un disque externe, après quoi elles sont montées à l’endroit souhaité. Le plus souvent, ce n’est pas le /home entier qui est supprimé de cette façon, mais des répertoires individuels lourds – de cette façon, il y a moins de risques.

    Quelques mises en garde. Le paramètre nofail mérite d’être paramétré dans les options : sans lui, le système ne démarrera pas si le disque n’est pas connecté. La vitesse d’une clé USB est toujours inférieure à celle du NVMe intégré, il est donc préférable de laisser de l’espace sur le disque interne pour les opérations d’E/S fréquentes. Et il n’est pas nécessaire de retirer le disque lors du déplacement avec les répertoires qui y sont montés – démontez-le d’abord.

    Comment basculer entre les systèmes

    Lorsque vous l’allumez, maintenez le bouton d’alimentation enfoncé – le menu de démarrage apparaîtra, il contiendra macOS et Linux. Vous pouvez sélectionner le système par défaut dans macOS : « Préférences Système » → « Général » → « Disque système ». Linux dispose également des paramètres correspondants, vous pouvez donc basculer dans les deux sens sans terminal.

    Liens

    https://asahilinux.org/fedora/
    https://asahilinux.org/docs/
    https://asahilinux.org/docs/platform/feature-support/m2/
    https://fedoraproject.org/asahi-remix
    https://github.com/bharambetejas/asahi-fairydust-display
    https://github.com/AsahiLinux/linux/tree/fairydust

    Sources

    https://asahilinux.org/docs/platform/feature-support/m2/
    https://discussion.fedoraproject.org/t/fedora-asahi-remix-installation-guide/
    https://github.com/AsahiLinux/docs
    https://github.com/bharambetejas/asahi-fairydust-display/blob/main/README.md
    https://github.com/bharambetejas/asahi-fairydust-display/blob/main/asahi-fairydust-build.sh

  • Installation de VirtualBox avec des ajouts d’invités sur un Mac ARM

    Instructions pour installer Ubuntu Server dans VirtualBox sur un Mac avec un processeur ARM64 et connecter les suppléments invité.

    Installer VirtualBox

    Téléchargez la version ARM64 de VirtualBox, montez l’image et transférez VirtualBox.app vers Applications.

    Configurer une machine virtuelle

    Nous créons une nouvelle machine, spécifions le type Linux et la version Ubuntu (ARM 64 bits). Dans les paramètres, nous définissons :

    • TPM – désactiver
    • UEFI – désactiver
    • RAM – 4 096 Mo.
    • Contrôleur graphique – VMSVGA (pour VBoxLinuxAdditions).
    • Processeur – 4 cœurs.

    Installer le serveur Ubuntu

    Montez l’image ISO du serveur Ubuntu pour ARM64 dans le lecteur de CD-ROM. Dans la section de téléchargement, placez le lecteur optique en premier dans la liste. Nous démarrons la machine et procédons à l’installation d’Ubuntu Server.

    Installer xubuntu-desktop

    Installez l’environnement graphique XFCE :

    sudo apt update
    sudo apt install -y xubuntu-desktop
    

    Dans la boîte de dialogue de sélection du gestionnaire de connexion, sélectionnez lightdm.

    Redémarrez le système invité :

    sudo reboot
    

    Ajouts d’invités

    Après le premier démarrage, installez les packages pour créer les modules du noyau :

    sudo apt update
    sudo apt install -y build-essential linux-headers-$(uname -r)
    

    Nous montons le disque avec les suppléments invité via le menu VirtualBox : Périphériques → Monter l’image disque des suppléments invité. Le disque apparaîtra à l’intérieur de l’invité dans le répertoire /media/$USER.

    Ouvrez un terminal dans Xubuntu, allez dans le répertoire du disque monté et exécutez l’installateur :

    cd /media/$USER/*
    sudo ./VBoxLinuxAdditions-arm64.run
    

    Redémarrez le système invité :

    sudo reboot
    

    Qu’est-ce qui devrait fonctionner après l’installation

    On vérifie que les modules du noyau sont chargés :

    lsmod | grep vbox
    

    La sortie doit inclure vboxguest et vboxsf.

    Ajoutez un dossier partagé dans les propriétés de la machine et montez-le dans l’invité :

    sudo mkdir -p /media/sf_shared
    sudo mount -t vboxsf shared /media/sf_shared
    

    Caractéristiques de travail :

    • Dossiers partagés : le répertoire hôte est visible dans l’invité via vboxsf.
    • Presse-papiers partagé : copiez le texte entre l’hôte et l’invité.
    • Intégration de la souris : le curseur s’étend librement en dehors de la fenêtre de la machine.
    • Changement automatique de résolution : l’écran invité s’ajuste à la taille de la fenêtre.
    • Synchronisation de l’heure : l’heure de l’invité est ajustée à celle de l’hôte.

    Sources

    https://www.virtualbox.org/manual/topics/guestadditions.html
    https://forums.virtualbox.org/viewtopic.php?t=112886

  • Comment connecter DeepSeek à Claude Code

    Claude Code est un agent console d’Anthropic qui peut lire des fichiers de projet, éditer du code, exécuter des commandes et des tests, rechercher dans le référentiel et travailler avec git. Le principal inconvénient lors de son utilisation est le coût : de longues sessions avec beaucoup de contexte engloutissent vite le budget de l’abonnement.

    Il existe une solution. DeepSeek fournit un point de terminaison compatible avec l’API Anthropic. Il suffit de changer l’adresse de base et le jeton, et Claude Code commencera à fonctionner sur les modèles DeepSeek, sans nécessiter de réinstallation ni de correctif. Dans cet article, je décrirai comment configurer cela sur macOS, Linux et Windows.

    Pourquoi est-ce nécessaire

    Les raisons peuvent être différentes :
    – Prix. Les modèles DeepSeek sont nettement moins chers que Claude, et pour les tâches de routine des agents – navigation dans un projet, modifications mineures, exécution de tests – une qualité optimale n’est pas toujours nécessaire.
    – Disponibilité. Si vous n’avez pas d’abonnement ou si le paiement avec une carte Anthropic n’est pas disponible pour une raison quelconque, DeepSeek devient une option fonctionnelle.
    – Expériences. Il est intéressant de comparer la façon dont différents modèles gèrent la même base de code dans le même environnement.

    Ce dont vous avez besoin

    Vous devez installer Claude Code et la clé API DeepSeek. Si Claude Code n’est pas déjà installé, l’ordre est le suivant :
    1. Installez Node.js 18 ou version ultérieure. Sous Windows, vous aurez également besoin de Git pour Windows.
    2. Installez Claude Code lui-même à l’aide de la commande ci-dessous.
    3. Vérifiez l’installation.

    npm install -g @anthropic-ai/claude-code
    claude --version
    

    Si la version s’affiche, l’installation a réussi. La clé API est créée dans votre compte personnel DeepSeek sur la page des clés.

    Configuration via variables d’environnement

    Toute intégration se résume à des variables d’environnement. Pour macOS et Linux, cela ressemble à ceci :

    export ANTHROPIC_BASE_URL=https://api.deepseek.com/anthropic
    export ANTHROPIC_AUTH_TOKEN=ваш_ключ_deepseek
    
    export ANTHROPIC_MODEL=deepseek-flash[1m]
    export ANTHROPIC_DEFAULT_OPUS_MODEL=deepseek-flash[1m]
    export ANTHROPIC_DEFAULT_SONNET_MODEL=deepseek-flash[1m]
    export ANTHROPIC_DEFAULT_HAIKU_MODEL=deepseek-flash
    export CLAUDE_CODE_SUBAGENT_MODEL=deepseek-flash
    
    export CLAUDE_CODE_EFFORT_LEVEL=max
    export CLAUDE_CODE_AUTO_COMPACT_WINDOW=786432
    

    Pour Windows dans PowerShell, la syntaxe est différente, mais les noms de variables sont les mêmes :

    $env:ANTHROPIC_BASE_URL="https://api.deepseek.com/anthropic"
    $env:ANTHROPIC_AUTH_TOKEN="ваш_ключ_deepseek"
    $env:ANTHROPIC_MODEL="deepseek-flash[1m]"
    

    Voyons ce qui se passe ici. La variable `ANTHROPIC_BASE_URL` redirige les requêtes des serveurs Anthropic vers DeepSeek. `ANTHROPIC_AUTH_TOKEN` remplace votre clé. Les variables restantes déterminent quel modèle est utilisé dans quel rôle. Il existe des modèles avec le suffixe « [1m] » – il s’agit d’une option avec une fenêtre contextuelle d’environ un million de jetons, qui permet à l’agent de conserver beaucoup plus de fichiers de projet à la fois. En conséquence, `CLAUDE_CODE_AUTO_COMPACT_WINDOW` est défini sur la taille de cette fenêtre afin que la compression automatique de l’historique ne fonctionne pas trop tôt.

    Il est pratique de ne pas exporter manuellement les variables à chaque fois, mais de les enregistrer dans la configuration de Claude Code. Ensuite, les paramètres seront récupérés automatiquement au démarrage.

    {
      "env": {
        "ANTHROPIC_BASE_URL": "https://api.deepseek.com/anthropic",
        "ANTHROPIC_AUTH_TOKEN": "ваш_ключ_deepseek",
        "ANTHROPIC_MODEL": "deepseek-flash[1m]",
        "ANTHROPIC_DEFAULT_HAIKU_MODEL": "deepseek-flash",
        "CLAUDE_CODE_SUBAGENT_MODEL": "deepseek-flash"
      }
    }
    

    Après cela, allez dans le répertoire du projet et exécutez l’agent :

    cd ваш_проект
    claude
    

    Claude Code dans VS Code

    Claude Code est disponible non seulement dans le terminal, mais également en tant qu’extension pour VS Code. Il s’installe normalement : ouvrez le panneau des extensions en utilisant Cmd+Shift+X, recherchez “Claude Code” et cliquez sur Installer. L’extension est produite par Anthropic lui-même.

    L’extension contient sa propre copie de la CLI et lit le même fichier ~/.claude/settings.json que la version du terminal. Les paramètres de la section précédente s’appliquent également ici – mais avec une mise en garde, qui prête le plus souvent à confusion.

    La vérification des entrées a lieu avant le lancement

    Avant de démarrer, l’extension vérifie les informations d’identification à partir de son propre paramètre « claudeCode.environmentVariables », et non à partir de settings.json. Les valeurs de settings.json atteignent le processus en cours – c’est-à-dire que l’adresse API et les modèles sélectionnés sont correctement récupérés – mais elles ne passent pas le contrôle de connexion de l’extension. Si vous voyez l’écran de connexion alors que tout fonctionne déjà dans le terminal, c’est la raison.

    Cela peut être guéri avec quelques lignes dans les paramètres de VS Code : dupliquez les variables dans `claudeCode.environmentVariables` et désactivez la demande de connexion.

    {
      "claudeCode.environmentVariables": [
        { "name": "ANTHROPIC_BASE_URL", "value": "https://api.deepseek.com/anthropic" },
        { "name": "ANTHROPIC_AUTH_TOKEN", "value": "ваш_ключ_deepseek" },
        { "name": "ANTHROPIC_MODEL", "value": "deepseek-flash[1m]" }
      ],
      "claudeCode.disableLoginPrompt": true
    }
    

    nuance macOS

    Si vous lancez VS Code depuis le Dock ou le Finder, il n’hérite pas des variables d’environnement de ~/.zshrc. Il s’agit d’un comportement standard de macOS et est spécifiquement abordé dans la documentation Claude Code. Autrement dit, `export ANTHROPIC_BASE_URL=…` dans votre shell pour l’extension ne fonctionnera tout simplement pas – cette variable ne sera pas dans son environnement.

    Il y a deux conclusions à en tirer. Premièrement, les paramètres de `claudeCode.environmentVariables` sont plus fiables que les variables shell. Deuxièmement, si vous préférez toujours un shell, lancez l’éditeur depuis le terminal, où les variables sont déjà exportées :

    code .
    

    Ce qui ne fonctionnera pas

    Sur un fournisseur tiers, certaines fonctionnalités d’extension ne sont pas disponibles car elles nécessitent un compte claude.ai :
    – il n’y aura pas de barre d’utilisation du forfait, de saisie vocale et d’onglet Web pour les sessions cloud ;
    – les commandes de déconnexion ne sont pas affichées dans le menu ;
    – `/usage` affichera la consommation et le nombre de jetons de la session en cours au lieu des limites du plan ;
    – La télécommande ne fonctionne pas si l’adresse de base n’est pas anthropique.

    Il s’agit d’un comportement attendu et non d’un signe d’échec de l’installation.

    Par ailleurs, je voudrais ajouter que JetBrains possède son propre plugin, mais il est conçu différemment : il ne contient pas de CLI intégrée, mais en lance une déjà installée dans le terminal intégré. Il n’y a pas de paramètres pour les variables d’environnement, vous devez donc lancer l’EDI à partir du terminal avec les variables déjà exportées.

    Comment DeepSeek comprend les noms de modèles de Claude

    Claude Code fait référence en interne aux modèles par des noms comme claude-opus, claude-sonnet et claude-haiku. DeepSeek intercepte ces noms et les remplace par les siens :
    – tout ce qui commence par claude-opus va vers deepseek-v4-pro ;
    – tout ce qui commence par claude-sonnet ou claude-haiku va vers deepseek-flash ;
    – le nom du modèle inconnu est également réduit à deepseek-flash.

    Cela signifie que même sans spécifier explicitement les modèles, l’intégration fonctionnera – mais il est préférable de contrôler explicitement quels modèles et à quel tarif répondront à la demande. C’est pourquoi, dans les paramètres, tous les rôles sont écrits manuellement.

    À quoi faire attention

    La compatibilité est incomplète et vous devez le savoir à l’avance. DeepSeek ignore simplement certaines des capacités de l’API Anthropic :

    – Invites de mise en cache. Le champ `cache_control` n’est pas pris en charge. Claude Code utilise activement le cache afin de ne pas payer trop cher pour envoyer le même contexte à plusieurs reprises. Cela n’arrivera pas ici, donc les longues sessions sont plus chères que ce à quoi on pourrait s’attendre du prix par jeton. Commencez périodiquement un nouveau dialogue au lieu de poursuivre sans fin l’ancien.
    – Thinking Budget. Le paramètre `thinking` est pris en charge, mais les `budget_tokens` qu’il contient sont ignorés.
    – Divers. Les champs `top_k`, `service_tier`, `container` et la connexion des serveurs MCP depuis l’API sont également ignorés.
    – MCP. Le mécanisme du serveur MCP intégré côté DeepSeek ne fonctionne pas, bien que les outils habituels de l’agent – lecture de fichiers, édition, exécution de commandes, recherche – fonctionnent normalement.

    Séparément, il convient de mentionner les procurations. Il existe des projets dans la communauté comme « ds-cc-proxy », qui sont placés entre Claude Code et DeepSeek et se chargent de lisser les incompatibilités mineures, ainsi que de séparer la session principale et les sous-agents en différents modèles. Si la configuration standard se comporte de manière instable, une telle couche intermédiaire peut aider.

    Claude Code Routeur

    La méthode décrite ci-dessus met un modèle sur toutes les tâches. Mais l’agent fait des choses très différentes : il comprend la structure du projet, corrige de petites choses et résout parfois un problème vraiment complexe. Il est logique que différents modèles soient utilisés pour différents types de travaux. C’est exactement ce que peut faire le claude-code-router (CCR) : une passerelle locale qui se situe entre Claude Code et les fournisseurs de modèles.

    Ça donne quoi

    – Routage par règles. Vous pouvez définir quel modèle sert la session principale, lequel sert les tâches en arrière-plan, lequel sert le mode de planification. Il est logique d’utiliser un modèle coûteux uniquement pour des raisonnements complexes et de confier la routine à un modèle bon marché.
    – Options de sauvegarde. Si le fournisseur renvoie une erreur, la requête est transmise au modèle suivant dans la chaîne, plutôt que d’abandonner la session.
    – Observabilité. L’interface affiche le journal des demandes, les retards, la consommation de jetons et le coût – quelque chose que vous ne pouvez deviner qu’avec une connexion directe.
    – Une adresse pour plusieurs agents. Les fournisseurs, les clés et les règles résident au même endroit, et les clients se connectent à une seule adresse locale.

    Tout d’abord à propos des versions : c’est important

    Cela vaut la peine d’être averti ici car cela vous fera gagner du temps. CCR a été fortement repensé au cours de son histoire, et presque tous les articles que vous trouvez dans une recherche décrivent la version obsolète.

    Dans les anciennes versions, la configuration était dans le fichier ~/.claude-code-router/config.json avec les blocs Providers et Router, et tout était lancé avec la commande `ccr code`. Maintenant, cela ne fonctionne plus ainsi. La version actuelle (3.x) stocke les paramètres dans la base de données SQLite et est gérée via une interface Web. L’ancien config.json est lu exactement une fois comme source de migration s’il n’y a pas encore de base de données – après cela, les modifications qui y sont apportées n’affectent rien.

    Autrement dit, si vous avez trouvé des instructions sur Internet pour éditer config.json et la commande `ccr code` et que rien n’a fonctionné pour vous, vous éditez un fichier que personne ne lit plus. Ce n’est pas ta faute.

    Installation

    Vous aurez besoin de Node.js 22 ou version ultérieure.

    npm install -g @musistudio/claude-code-router
    ccr ui
    

    La commande `ccr ui` fait apparaître le service en arrière-plan et ouvre l’interface de gestion dans le navigateur. Il est utile de connaître les autres commandes : `ccr start` démarre un service, `ccr stop` l’arrête, `ccr serve` fonctionne au premier plan et est pratique lorsque vous avez besoin de voir les journaux.

    Par défaut, l’interface de gestion réside sur le port 3458 et la passerelle elle-même pour les modèles réside sur le port 3456.

    Paramètres

    Tout se fait dans l’interface web, sans édition manuelle des fichiers :
    1. Dans la section Fournisseurs, ajoutez le fournisseur DeepSeek et spécifiez sa clé. Remarque : l’adresse complète jusqu’au point de discussion/d’achèvement est nécessaire ici, pas seulement le domaine.
    2. Dans la section Modèles, décrivez ce qu’est ce modèle – la description facilite le routage.
    3. Dans la section Agent Config, définissez le modèle par défaut.
    4. Dans la section Routage, configurez les règles : quel modèle répond à quelles requêtes.
    5. Sur la page Clés API, créez une clé client CCR – c’est ce que Claude Code utilisera, pas la clé DeepSeek.

    Après cela, il ne reste plus qu’à envoyer Claude Code à la passerelle : préciser l’adresse de la passerelle affichée dans l’interface comme adresse de base, et la clé client CCR comme token.

    Une bonne chose : les règles de routage peuvent être écrites non seulement avec des champs, mais également avec un script JavaScript, si la logique est plus complexe que la comparaison d’un champ.

    Est-ce que ça vaut la peine de l’utiliser

    Connecter DeepSeek à Claude Code est avant tout un moyen de réduire les coûts sans renoncer à un environnement d’agent pratique. Vous obtenez la même interface, les mêmes outils et le même workflow, mais sur un modèle différent. La configuration prend quelques minutes et est totalement réversible : il suffit de supprimer les variables d’environnement pour revenir aux modèles Anthropic.

    Les limites sont également claires : il n’y a pas de cache d’invite, une compatibilité incomplète en ce qui concerne les champs de l’API et la qualité du modèle peut différer pour des tâches architecturales complexes. Pour le travail de routine dans le référentiel – navigation, refactoring, exécution de tests – c’est plus que suffisant.

    Exemple : Oni-Extended

    Un exemple vivant d’une telle combinaison est mon projet Oni-Extended, un fork du portage du jeu Oni ​​(Bungie, 2001) pour Apple Silicon. Les sources du jeu sont écrites en C et existent depuis plus de vingt ans ; ils n’ont jamais fait l’objet de tests et la taille des fichiers est mesurée en dizaines de milliers de lignes. Cependant, de nouvelles fonctionnalités ont été ajoutées au projet via Claude Code de DeepSeek : sauvegarde et chargement rapides via F5/F9, un bloc de maintien de clé et un indicateur de lancement -nodamage qui désactive les dommages.

    C’est une bonne illustration de ce qui a été dit ci-dessus. Toutes les tâches concernent un travail de routine dans un grand référentiel : l’agent examine le code d’autres personnes, trouve des connexions entre les modules et teste des hypothèses, plutôt que de concevoir une architecture à partir de zéro. Le coût de telles sessions sur DeepSeek s’avère sensiblement inférieur à celui sur les modèles Anthropic, malgré le fait que le résultat est vérifié par la propre infrastructure du projet : assemblage, level run stand et tests hors ligne.

    Liens

    https://platform.deepseek.com/api_keys
    https://api-docs.deepseek.com
    https://docs.anthropic.com/en/docs/claude-code
    https://github.com/anthropics/claude-code
    https://github.com/musistudio/claude-code-router
    https://ccrdesk.top/en/guides/cli/
    https://github.com/zefir1990/Oni-Extended

    Sources

    https://api-docs.deepseek.com/guides/anthropic_api
    https://api-docs.deepseek.com/quick_start/agent_integrations/claude_code
    https://ccrdesk.top/en/routing/
    https://code.claude.com/docs/en/vs-code

  • Donki Hills est officiellement sur Steam depuis plus d’un an !

    Donki Hills est sur Steam depuis plus d’un an maintenant !

    Il y a exactement un an, le projet est apparu sur la page Steam, et depuis lors, le jeu a parcouru un long chemin. Pendant ce temps, il y a eu de nombreuses expériences, changements et recherches sur la direction même dans laquelle Donki Hills devrait se développer.

    Le travail sur le gameplay se poursuit, et désormais le projet acquiert progressivement son vrai visage. Donki Hills commence à devenir ce qu’il était censé être : une comédie à la première personne, un roguelike, une parodie de survie et d’horreur.

    Une aventure étrange où l’horreur rencontre l’humour, l’exploration et les situations inattendues. Vous devez vous rendre en ville, chercher des objets, résoudre des énigmes et découvrir progressivement le secret qui vous mènera à Maria.

    Vous trouverez ci-dessous de nouvelles captures d’écran du prochain test de jeu du prototype. Ce n’est pas encore la version finale du jeu, mais vous pouvez déjà ressentir l’atmosphère de la ville et la direction dans laquelle évolue le projet.

    Très intéressé d’entendre votre réaction! 👀
    Comment aimez-vous la nouvelle direction ? Quelles sont vos impressions sur l’ambiance et les idées du jeu ?

    Merci à tous ceux qui ont ajouté Donki Hills à leur liste de souhaits, suivent le développement et soutiennent le projet ❤️

    Il y a encore de nombreuses expériences, de nouvelles mécaniques et d’étranges aventures à venir.

    https://store.steampowered.com/app/3476390/Donki_Hills/

  • Contourner la limitation sur les processeurs des ordinateurs portables de jeu

    Les fabricants d’ordinateurs portables de jeu modernes configurent souvent les systèmes de manière à ce que le processeur chauffe jusqu’à 90 degrés et atteigne même 100 degrés Celsius sous charge. Ce problème est particulièrement aigu en été lors de l’exécution de jeux exigeants ou de tâches lourdes.

    En raison d’un échauffement extrême, le throttling est activé (réinitialisation des fréquences du processeur pour éviter tout dommage physique), ce qui entraîne une forte perte de performances, des blocages et une baisse des FPS. Il existe de nombreuses façons de lutter contre la surchauffe (de l’utilisation de coussinets de refroidissement à la sous-tension), mais dans cet article, je décrirai la méthode la plus simple et la plus rapide pertinente pour Windows 11 et les versions antérieures du système d’exploitation.

    La méthode consiste à limiter l’état maximum du processeur via les paramètres d’alimentation :

    1. Ouvrez les Options d’alimentation via la recherche Windows ou le Panneau de configuration.
    2. Dans le plan d’alimentation actif, accédez à la section permettant de modifier des paramètres supplémentaires.
    3. Recherchez la branche Gestion de l’alimentation du processeur.
    4. Développez l’option État maximal du processeur.
    5. Pour Plugged In, modifiez la valeur de 100 % à 80 % ou moins.

    Après avoir appliqué ces paramètres, le processeur n’overclockera plus automatiquement à des fréquences extrêmes générant une chaleur excessive. Même si les performances maximales diminuent d’environ 20 %, le processeur ne surchauffera plus. Un fonctionnement stable à une fréquence réduite sans limitation est BEAUCOUP meilleur et plus confortable pour le système que des sauts de performances constants et brusques dus à une surchauffe à des températures inférieures à 100 degrés.

    Chaque ordinateur portable est unique, je recommande donc aux utilisateurs d’expérimenter et de trouver l’équilibre optimal (pourcentage) qui fournira les performances souhaitées sans surchauffe.

  • Portage du Surreal Engine C++ vers WebAssembly

    Dans cet article, je décrirai comment j’ai porté le moteur de jeu Surreal Engine vers WebAssembly.
    https://demensdeum.com/demos/SurrealEngine/”
    Moteur surréaliste – un moteur de jeu qui implémente la plupart des fonctionnalités de l’Unreal Engine 1, des jeux célèbres sur ce moteur – Unreal Tournament 99, Unreal, Deus Ex, Undying. Il fait référence aux moteurs classiques qui fonctionnaient principalement dans un environnement d’exécution monothread.
    Au départ, j’ai eu l’idée de me lancer dans un projet que je ne pouvais pas réaliser dans un délai raisonnable, montrant ainsi à mes abonnés Twitch qu’il y a des projets que même moi je ne peux pas réaliser. Lors de mon premier stream, j’ai soudainement réalisé que la tâche de porter Surreal Engine C++ vers WebAssembly à l’aide d’Emscripten était réalisable.

    Un mois plus tard, je peux faire une démonstration de mon ensemble fourche et moteur sur WebAssembly :
    https://demensdeum.com/demos/SurrealEngine/
    Le contrôle, comme dans l’original, s’effectue à l’aide des flèches du clavier. Ensuite, je prévois de l’adapter au contrôle mobile (tachi), en ajoutant un éclairage correct et d’autres fonctionnalités graphiques du rendu Unreal Tournament 99.

    Par où commencer ?

    La première chose que je veux dire est que n’importe quel projet peut être porté de C++ vers WebAssembly en utilisant Emscripten, la seule question est de savoir dans quelle mesure la fonctionnalité sera complète. Choisissez un projet dont les ports de bibliothèque sont déjà disponibles pour Emscripten ; dans le cas de Surreal Engine, vous avez beaucoup de chance, car le moteur utilise SDL 2, OpenAL – bibliothèques. ils sont tous deux portés sur Emscripten. Cependant, Vulkan est utilisé comme API graphique, qui n’est actuellement pas disponible pour HTML5, des travaux sont en cours pour implémenter WebGPU, mais il est également au stade de projet, et on ne sait pas non plus à quel point le port ultérieur de Vulkan vers WebGPU sera simple, une fois entièrement standardisé. Par conséquent, j’ai dû écrire mon propre moteur de rendu OpenGL-ES/WebGL de base pour Surreal Engine.

    Construire le projet

    Système de construction dans Surreal Engine – CMake, qui simplifie également le portage, car Emscripten fournit à ses constructeurs natifs – emcmake, emmake.
    Le portage de Surreal Engine était basé sur le code de mon dernier jeu en WebGL/OpenGL ES et C++ appelé Death-Mask, de ce fait le développement était beaucoup plus simple, j’avais tous les indicateurs de build nécessaires avec moi et des exemples de code.
    L’un des points les plus importants de CMakeLists.txt concerne les indicateurs de construction pour Emscripten. Vous trouverez ci-dessous un exemple tiré du fichier de projet :

    set(CMAKE_CXX_FLAGS "-s MIN_WEBGL_VERSION=2 
    -s MAX_WEBGL_VERSION=2 
    -s EXCEPTION_DEBUG 
    -fexceptions 
    --preload-file UnrealTournament/ 
    --preload-file SurrealEngine.pk3 
    --bind 
    --use-preload-plugins 
    -Wall 
    -Wextra 
    -Werror=return-type 
    -s USE_SDL=2 
    -s ASSERTIONS=1 
    -w 
    -g4 
    -s DISABLE_EXCEPTION_CATCHING=0 
    -O3 
    --no-heap-copy 
    -s ALLOW_MEMORY_GROWTH=1 
    -s EXIT_RUNTIME=1")
    

    Le script de build lui-même :

    clear
    emmake make -j 16
    cp SurrealEngine.data /srv/http/SurrealEngine/SurrealEngine.data
    cp SurrealEngine.js /srv/http/SurrealEngine/SurrealEngine.js
    cp SurrealEngine.wasm /srv/http/SurrealEngine/SurrealEngine.wasm
    cp ../buildScripts/Emscripten/index.html /srv/http/SurrealEngine/index.html
    

    Ensuite, préparons index.html, qui inclut le préchargeur du système de fichiers du projet. Pour télécharger sur le Web, j’ai utilisé Unreal Tournament Demo version 338. Comme vous pouvez le voir sur le fichier CMake, le dossier du jeu décompressé a été ajouté au répertoire de construction et lié en tant que fichier de préchargement pour Emscripten.

    Modifications du code principal

    Ensuite, nous avons dû changer la boucle de jeu du jeu, vous ne pouvez pas exécuter une boucle sans fin, cela conduit au blocage du navigateur, vous devez plutôt utiliser emscripten_set_main_loop, j’ai écrit à propos de cette fonctionnalité dans ma note de 2017 “Portage de jeux SDL C++ vers HTML5 (Emscripten)”
    Nous modifions le code pour quitter la boucle while en if, puis nous affichons la classe principale du moteur de jeu, qui contient la boucle de jeu, dans la portée globale, et écrivons une fonction globale qui appellera l’étape de boucle de jeu à partir de l’objet global :

    #if __EMSCRIPTEN__
    #include <emscripten.h>
    Engine *EMSCRIPTEN_GLOBAL_GAME_ENGINE = nullptr;
    void emscripten_game_loop_step() {
    	EMSCRIPTEN_GLOBAL_GAME_ENGINE->Run();
    }
    #endif
    

    Après cela, vous devez vous assurer qu’il n’y a pas de threads en arrière-plan dans l’application ; s’il y en a, préparez-vous à les réécrire pour une exécution monothread, ou utilisez la bibliothèque phtread dans Emscripten.
    Le fil d’arrière-plan de Surreal Engine est utilisé pour lire de la musique, les données proviennent du fil du moteur principal concernant la piste en cours, la nécessité de jouer de la musique ou son absence, puis le fil d’arrière-plan reçoit un nouvel état via un mutex et commence à jouer une nouvelle musique, ou fait une pause. Le fil d’arrière-plan est également utilisé pour mettre la musique en mémoire tampon pendant la lecture.
    Mes tentatives de création de Surreal Engine pour Emscripten avec pthread ont échoué, car les ports SDL2 et OpenAL ont été construits sans le support de pthread, et je ne voulais pas les reconstruire pour le plaisir de la musique. Par conséquent, j’ai transféré la fonctionnalité du flux de musique de fond vers une exécution monothread à l’aide d’une boucle. En supprimant les appels pthread du code C++, j’ai déplacé la mise en mémoire tampon et la lecture de musique vers le thread principal, afin qu’il n’y ait pas de retard, j’ai augmenté la mémoire tampon de quelques secondes.
    Ensuite, je décrirai des implémentations spécifiques des graphiques et du son.

    Vulkan n’est pas pris en charge !

    Oui, Vulkan n’est pas pris en charge en HTML5, bien que toutes les brochures marketing présentent le support multiplateforme et large plate-forme comme le principal avantage de Vulkan. Pour cette raison, j’ai dû écrire mon propre moteur de rendu graphique de base pour un type OpenGL simplifié – – ES, il est utilisé sur les appareils mobiles, parfois il ne contient pas les fonctionnalités à la mode de l’OpenGL moderne, mais il se porte très bien sur WebGL, ce qui est exactement ce qu’Emscripten implémente. L’écriture du rendu de tuiles de base, du rendu bsp, pour l’affichage GUI le plus simple et du rendu des modèles + cartes a été achevée en deux semaines. C’était peut-être la partie la plus difficile du projet. Il reste encore beaucoup de travail à faire pour implémenter toutes les fonctionnalités du rendu Surreal Engine, donc toute aide des lecteurs est la bienvenue sous forme de code et de demandes d’extraction.

    OpenAL pris en charge !

    La grande chance est que Surreal Engine utilise OpenAL pour la sortie audio. Après avoir écrit un simple hello world dans OpenAL et l’avoir assemblé dans WebAssembly à l’aide d’Emscripten, il m’est devenu clair à quel point tout était simple et j’ai commencé à porter le son.
    Après plusieurs heures de débogage, il est devenu évident que l’implémentation OpenAL d’Emscripten avait plusieurs bugs, par exemple, lors de l’initialisation de la lecture du nombre de canaux mono, la méthode a renvoyé un nombre infini, et après avoir essayé d’initialiser un vecteur de taille infinie, C++ plante avec l’exception vector::length_error.
    Nous avons réussi à contourner ce problème en codant en dur le nombre de canaux mono à 2048 :

    		alcGetIntegerv(alDevice, ALC_MONO_SOURCES, 1, &monoSources);
    		alcGetIntegerv(alDevice, ALC_STEREO_SOURCES, 1, &stereoSources);
    
    #if __EMSCRIPTEN__
    		monoSources = 2048; // for some reason Emscripten's OpenAL gives infinite monoSources count, bug?
    #endif
    
    

    Y a-t-il un réseau ?

    Surreal Engine ne prend actuellement pas en charge le jeu en ligne, le jeu avec des robots est pris en charge, mais nous avons besoin de quelqu’un pour écrire l’IA pour ces robots. Théoriquement, vous pouvez implémenter un jeu en réseau sur WebAssembly/Emscripten à l’aide de Websockets.

    Conclusion

    En conclusion, je voudrais dire que le portage de Surreal Engine s’est avéré assez fluide grâce à l’utilisation de bibliothèques pour lesquelles il existe des ports Emscripten, ainsi qu’à mon expérience passée dans l’implémentation d’un jeu en C++ pour WebAssembly sur Emscripten. Vous trouverez ci-dessous des liens vers des sources de connaissances et des référentiels sur le sujet.
    M-M-M-MONSTER KILL !
    Aussi, si vous souhaitez aider le projet, de préférence avec le code de rendu WebGL/OpenGL ES, alors écrivez-moi dans Telegram :
    https://t.me/demenscave

    Liens

    https://demensdeum.com/demos/SurrealEngine/

    https://github.com/demensdeum/SurrealEngine-Emscripten

    https://github.com/dpjudas/SurrealEngine

  • Redirection de port entre clients via Chisel : un tunnel épuré sans L3

    Lorsque deux appareils sont derrière un NAT ou un pare-feu strict et ne peuvent pas se « voir » directement, un VPN semble être la solution standard. Mais un tunnel L3 à part entière (comme WireGuard ou OpenVPN) est souvent redondant : il nécessite des droits root, la configuration d’interfaces virtuelles et peut entrer en conflit avec les routes existantes.

    Dans de tels cas, il est pratique d’utiliser Chisel – un tunnel TCP/UDP qui s’exécute sur HTTP et utilise WebSockets pour le transfert de données. Dans cette note, je vais montrer comment « transférer » un port d’un client à un autre via un serveur intermédiaire.

    Comment ça marche ?

    Imaginez la situation : vous disposez d’un Client A (par exemple, votre serveur domestique), d’un Client B (votre ordinateur portable de travail) et d’un VPS avec une adresse IP publique. Les clients A et B peuvent accéder au VPS, mais pas l’un à l’autre.

    Le schéma de transfert ressemblera à ceci :
    1. Le Client A se connecte au VPS et ouvre un port « inverse » sur le serveur. Désormais, tout ce qui arrive au port X du serveur va au port Y du client A.
    2. Le Client B se connecte au VPS et transfère le port Z de sa machine locale vers le port X du serveur.
    3. En conséquence, le client B accède à localhost:Z et se retrouve sur le client A:Y.

    Cette approche est l’une des solutions dans les cas où la communication avec un VPS n’implémente pas de couche L3 ou où il n’y a pas de possibilité de configurer le routage entre les clients. Nous travaillons exclusivement au niveau applicatif et portuaire.

    Étape 1 : Démarrez le serveur

    Sur votre VPS, exécutez simplement Chisel en mode serveur. L’indicateur --reverse est requis pour permettre aux clients d’ouvrir des ports côté serveur.

    chisel server --port 8080 --reverse
    

    Étape 2 : Connexion du client A (source)

    Disons que le client A souhaite ouvrir l’accès à son serveur Web local sur le port 3000. Il se connecte au VPS et dit : « réservez le port 2000 sur le serveur et transmettez-le-moi au 3000 ».

    chisel client vps-ip:8080 R:2000:127.0.0.1:3000
    

    Désormais, le port 2000 sur le VPS (sur l’interface de bouclage) mène au client A.

    Étape 3 : Connexion du client B (consommateur)

    Le client B souhaite désormais accéder à cette ressource. Il se connecte au même VPS et redirige son port local 8080 vers le port 2000 du serveur.

    chisel client vps-ip:8080 8080:127.0.0.1:2000
    

    Prêt! Désormais, lorsque vous ouvrez http://localhost:8080 sur le client B, vous verrez le service s’exécuter sur le client A.

    Sécurité et nuances

    Chisel prend en charge l’authentification via l’indicateur --auth, qui est fortement recommandé lorsque vous travaillez via des serveurs publics. Vous pouvez également utiliser des certificats TLS pour chiffrer le trafic.

    Le principal avantage de cette approche est qu’elle ne nécessite pas de périphériques TUN/TAP ni de tables de routage complexes. Il s’agit d’un tunnel simplifié qui fait exactement une chose : lier les ports via une connexion WebSocket. Cela fonctionne même via des proxys d’entreprise si vous configurez Chisel pour qu’il fonctionne via le port 443.

    Sortie

    Chisel est un utilitaire pour des tâches réseau spécifiques. Lorsque vous devez transférer des ports entre des nœuds isolés sans configurer un VPN à part entière, une combinaison de tunnels aller et retour via un serveur relais s’avère être une solution tout à fait viable.

    Liens

    https://github.com/jpillora/chisel

  • Pourquoi ne puis-je pas corriger le bug ?

    Vous passez des heures à travailler sur le code, à examiner des hypothèses, à ajuster les conditions, mais le bug est toujours reproduit. Cela vous semble familier ? Cet état de frustration est souvent appelé « chasse aux fantômes ». Le programme semble vivre sa propre vie, ignorant vos corrections.

    L’une des raisons les plus courantes – et la plus ennuyeuse – de cette situation est la recherche d’une erreur au mauvais endroit dans l’application.

    Le piège des « faux symptômes »

    Lorsque nous constatons une erreur, notre attention est attirée sur l’endroit où elle a « tiré ». Mais dans les systèmes complexes, l’apparition d’un bug (plantage ou valeur incorrecte) n’est que la fin d’une longue chaîne d’événements. Lorsque vous essayez de réparer la fin, vous combattez les symptômes, pas la maladie.

    C’est là qu’intervient le concept d’organigramme.

    Comment ça marche en réalité

    Bien sûr, il n’est pas nécessaire de dessiner (dessiner) directement un organigramme sur papier à chaque fois, mais il est important de l’avoir en tête ou à portée de main comme guide architectural. Un organigramme vous permet de visualiser le fonctionnement d’une application sous forme d’arbre de résultats.

    Sans comprendre cette structure, le développeur tâtonne souvent dans le noir. Imaginez la situation : vous modifiez la logique dans une branche de condition, tandis que l’application (en raison d’un certain ensemble de paramètres) va dans une branche complètement différente à laquelle vous n’avez même pas pensé.


    Résultat : vous passez des heures sur une correction de code « parfaite » dans une partie de l’algorithme, ce qui, bien sûr, ne fait rien pour résoudre le problème dans une autre partie de l’algorithme où il échoue réellement.

    Algorithme pour vaincre un bug

    Pour arrêter de frapper à porte fermée, vous devez changer votre approche du diagnostic :

    • Recherchez l’état dans l’arborescence des résultats :Avant d’écrire du code, vous devez déterminer exactement le chemin emprunté par l’application. À quel moment la logique a-t-elle pris une mauvaise tournure ? Quel État spécifique (État) est à l’origine du problème ?
    • La reproduction représente 80 % de réussite : elle est généralement effectuée par des testeurs et des tests automatisés. Si le bug est « flottant », le développement est impliqué dans le processus de recherche conjointe des conditions.
    • Utilisez autant d’informations que possible : les journaux, la version du système d’exploitation, les paramètres de l’appareil, le type de connexion (Wi-Fi/5G) et même un opérateur de télécommunications spécifique sont importants pour la localisation.

    « Photographie » du moment de l’erreur

    Idéalement, pour résoudre ce problème, vous devez obtenir l’état complet de l’application au moment où le bug a été reproduit. Les journaux d’interaction sont également d’une importance cruciale : ils montrent non seulement le point final, mais également l’intégralité du parcours utilisateur (quelles actions ont précédé l’échec). Cela aide à comprendre comment recréer à nouveau un état similaire.

    Conseil futur : si vous rencontrez un cas complexe, ajoutez des informations de journalisation de débogage étendues à cette section de code au cas où la situation se reproduirait.

    Le problème des États « insaisissables » à l’ère de l’IA

    Dans les systèmes modernes utilisant le LLM (Large Language Models), le déterminisme classique (« une entrée, une sortie ») est souvent violé. Vous pouvez transmettre exactement les mêmes données d’entrée, mais obtenir un résultat différent.

    Cela se produit en raison du non-déterminisme des systèmes de production modernes :

    • Parallélisme GPU : les opérations en virgule flottante GPU ne sont pas toujours associatives. En raison de l’exécution parallèle des threads, l’ordre dans lequel les nombres sont ajoutés peut légèrement changer, ce qui peut affecter le résultat.
    • Température et limitation du GPU : la vitesse d’exécution et la répartition de la charge peuvent dépendre de l’état physique du matériel. Dans les modèles volumineux, ces différences microscopiques s’accumulent et peuvent conduire à la sélection d’un jeton différent en sortie.
    • Lot dynamique : dans le cloud, votre demande est combinée avec d’autres. Différentes tailles de lots modifient les mathématiques des calculs dans les noyaux.

    Dans de telles conditions, il devient presque impossible de reproduire « ce même état ». Seule une approche statistique des tests peut vous sauver la vie.

    En cas d’échec de la logique : problèmes de mémoire

    Si vous travaillez avec des langages « non sécurisés » (C ou C++), le bug peut survenir en raison d’une corruption de la mémoire.

    Ce sont les cas les plus graves : une erreur dans un module peut « écraser » les données dans un autre. Cela conduit à des pannes totalement inexplicables et isolées qui ne peuvent pas être retracées à l’aide de la logique d’application normale.

    Comment se protéger au niveau architectural ?

    Pour éviter de tels bugs « mystiques », vous devez utiliser des approches modernes :

    • Modèles de programmation multithread : une synchronisation claire élimine les conditions de concurrence.
    • Langages thread-safe : outils garantissant la sécurité de la mémoire au moment de la compilation :
      • Rust : le système de propriété élimine les erreurs de mémoire.
      • Concurrency Swift 6 :Contrôles rigoureux de l’isolation des données.
      • Erlang : Isolation complète des processus grâce au modèle d’acteur.

    Résumé

    Corriger un bug ne consiste pas à écrire du nouveau code, mais à comprendre comment fonctionne l’ancien. N’oubliez pas : vous pourriez perdre du temps à éditer une branche à laquelle la direction ne touche même pas. Enregistrez l’état du système, tenez compte du facteur de non-déterminisme de l’IA et choisissez des outils sûrs.

  • Pourquoi la documentation est votre meilleure amie

    (et comment créer des solutions qui continuent de fonctionner après les mises à jour)

    “Les applications ne peuvent utiliser que des API publiques et doivent s’exécuter sur le système d’exploitation actuellement disponible.” Directives d’examen des applications Apple

    Si vous avez déjà commencé à travailler avec un nouveau framework et que vous vous êtes dit : « Maintenant, je vais tout comprendre moi-même, lire la documentation est trop long », vous n’êtes certainement pas seul. Beaucoup d’entre nous ont un instinct naturel d’investigation : essayez d’abord, et ensuite seulement regardez les instructions. Et c’est tout à fait normal.

    Cependant, à ce stade, il peut être facile de se laisser emporter et de se retrouver dans une situation où le code fonctionne très bien, mais repose peut-être sur des fonctionnalités non évidentes du système.

    Pourquoi ne suffit-il parfois pas simplement de « le découvrir par soi-même » ?

    Les frameworks, en particulier ceux fermés, sont des systèmes complexes et multicouches. Ils cachent souvent une logique interne et des optimisations qui :

    * ne sont pas décrits dans la documentation publique ;
    * ne garantissent pas que le comportement sera maintenu à l’avenir ;
    * peut changer avec la sortie de nouvelles versions ;
    * peut contenir des fonctionnalités connues des développeurs qui n’ont pas encore été corrigées.

    Lorsque nous agissons intuitivement, nous risquons de construire une architecture sur des observations aléatoires plutôt que sur des règles documentées. Cela peut rendre le code plus sensible aux mises à jour.

    La documentation n’est pas une limitation, mais un support fiable

    Les développeurs de framework créent des manuels pour nous aider. En agissant dans la documentation, nous obtenons :

    * stabilité ;
    * soutien;
    * comportement prévisible du système.

    En dépassant ces limites, on prend des risques supplémentaires, et la maintenance d’un tel code devient plus difficile.

    Des expériences ? Certainement. Mais avec une compréhension des limites.
    La curiosité est une grande qualité à avoir chez un développeur. Explorer et essayer de nouvelles choses est absolument essentiel. Mais voici un petit souhait :

    La manière la plus confortable d’expérimenter est de s’appuyer sur les meilleures pratiques.

    La documentation est une carte qui montre quels chemins sont les plus sécurisés et pris en charge par les créateurs.

    Un point de vue extérieur : conseils d’experts

    Nous apprenons souvent de collègues expérimentés :

    * ils dispensent des cours utiles,
    * prendre la parole lors de conférences,
    * écrire de merveilleux livres et blogs,
    *partager leur vision unique.

    Beaucoup d’entre eux partagent des expériences vraiment précieuses. Mais il convient de le rappeler : si les approches de l’auteur contredisent la documentation officielle, elles peuvent s’avérer fragiles.

    De tels « modèles empiriques » :

    * travailler uniquement sur une version spécifique du framework ;
    * sensible aux mises à jour ;
    * peut se comporter de manière imprévisible dans des situations inhabituelles.

    Apprendre de la communauté est formidable et enrichissant. Mais tout conseil, même le plus fiable, doit toujours être soigneusement vérifié avec les manuels officiels.

    Un peu de SOLID

    Trois idées issues des principes SOLID complètent parfaitement cette approche :

    * Principe ouvert/fermé : essayez d’étendre le comportement via des API publiques et, si possible, ne dépendez pas d’une implémentation cachée.
    * Principe de substitution de Liskov : comptez sur le contrat et non sur la mise en œuvre spécifique. Sinon, des changements sous le capot peuvent entraîner des difficultés inattendues.
    * Inversion des dépendances : créez des dépendances sur des abstractions, pas sur des détails.

    En pratique, cela signifie que le fait d’être lié à des détails internes non documentés du cadre rend le système fragile.
    Sur la base des interfaces et des contrats publics, nous obtenons :

    * une meilleure isolation du code des modifications apportées au framework ;
    * facilité de test ;
    * prévisibilité et fiabilité de l’architecture.

    Et s’il y a un bug ?

    Il arrive aussi que tout soit fait selon les règles, mais que le résultat ne soit pas à la hauteur des attentes. Les cadres évoluent et ne sont pas toujours parfaits. Dans de tels cas :

    * Construisez un exemple minimal qui reproduit le problème.
    * Assurez-vous que seules les API documentées sont utilisées.
    * Envoyez un rapport de bug – l’équipe de développement appréciera certainement votre travail et essaiera de vous aider.

    Si l’exemple repose sur des solutions de contournement, il sera beaucoup plus difficile pour les développeurs de fournir une assistance.

    Comment tirer le meilleur parti du framework

    *Se référer à la documentation.
    * Suivez les guides et recommandations des auteurs.
    * Expérimentez dans le cadre de la fonctionnalité décrite.
    * Vérifiez les conseils d’Internet auprès de sources officielles.
    * Localiser les bugs en respectant les contrats-cadres.

    Conclusion

    Les frameworks sont des outils puissants avec leurs propres règles du jeu. En les oubliant, nous risquons de rendre notre code trop vulnérable. Mais nous voulons tous que les produits créés durent longtemps et ne nécessitent pas de corrections urgentes après chaque mise à jour mineure.

    Les manuels et la documentation constituent un excellent support qui permet de créer des solutions véritablement fiables.

    Sources

    https://developer.apple.com/app-store/review/guidelines/
    https://en.wikipedia.org/wiki/SOLID
    https://en.wikipedia.org/wiki/API
    https://en.wikipedia.org/wiki/RTFM

  • Création d’une application C++ SDL pour iOS sous Linux

    Dans cette note, je décrirai la procédure pour créer une application C++ SDL pour iOS sous Linux, signer une archive ipa sans abonnement Apple Developer payant et l’installer sur un appareil propre (iPad) utilisant macOS sans Jailbreak.

    Tout d’abord, installons la chaîne d’outils de build pour Linux :
    https://github.com/tpoechtrager/cctools-port

    La chaîne d’outils doit être téléchargée depuis le référentiel, puis suivez les instructions sur le site Web Godot Engine pour terminer l’installation :
    https://docs.godotengine.org/ru/latest/development/compiling/cross-compiling_for_ios_on_linux.html

    Pour le moment, vous devez télécharger Xcode dmg et copier le SDK à partir de là pour créer le port cctools. Cette étape est plus facile à réaliser sur macOS ; copiez simplement les fichiers SDK nécessaires à partir du Xcode installé. Après un assemblage réussi, le terminal contiendra le chemin d’accès à la chaîne d’outils du compilateur croisé.
    Ensuite, vous pouvez commencer à créer l’application SDL pour iOS. Ouvrons cmake et ajoutons les modifications nécessaires pour construire le code C++ :

    SET(CMAKE_SYSTEM_NAME Darwin)
    SET(CMAKE_C_COMPILER arm-apple-darwin11-clang)
    SET(CMAKE_CXX_COMPILER arm-apple-darwin11-clang++)
    SET(CMAKE_LINKER arm-apple-darwin11-ld)
    
    

    Vous pouvez maintenant compiler en utilisant cmake et make, mais n’oubliez pas d’ajouter $PATH à la chaîne d’outils du compilateur croisé :

    
    PATH=$PATH:~/Sources/cctools-port/usage_examples/ios_toolchain/target/bin
    
    

    Pour un lien correct avec les frameworks et SDL, nous les écrivons dans cmake, dépendances du jeu Space Jaguar par exemple :

    
    target_link_libraries(
    ${FSEGT_PROJECT_NAME}
    ${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/libclang_rt.ios.a
    ${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/libSDL2.a
    ${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/libSDL2_mixer.a
    ${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/libSDL2_image.a
    "${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/CoreServices.framework"
    "${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/ImageIO.framework"
    "${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/Metal.framework"
    "${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/AVFoundation.framework"
    "${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/GameController.framework"
    "${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/CoreMotion.framework"
    "${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/CoreGraphics.framework"
    "${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/AudioToolbox.framework"
    "${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/CoreAudio.framework"
    "${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/QuartzCore.framework"
    "${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/OpenGLES.framework"
    "${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/UIKit.framework"
    "${FLAME_STEEL_PROJECT_ROOT_DIRECTORY}/scripts/buildScripts/ios/resources/libs/Foundation.framework"
    )
    
    

    Dans mon cas, les bibliothèques SDL, SDL_Image, SDL_mixer sont compilées à l’avance dans Xcode sur macOS pour les liaisons statiques ; Frameworks copiés depuis Xcode. La bibliothèque libclang_rt.ios.a a également été ajoutée, qui inclut des appels d’exécution spécifiques à iOS, par exemple isOSVersionAtLeast. Inclus une macro pour travailler avec OpenGL ES, désactivant les fonctions non prises en charge dans la version mobile, similaire à Android.
    Après avoir résolu tous les problèmes de construction, vous devriez obtenir le binaire assemblé pour arm. Ensuite, envisageons d’exécuter le binaire assemblé sur un appareil sans Jailbreak.
    Sur macOS, installez Xcode, inscrivez-vous sur le portail Apple, sans payer pour le programme développeur. Ajouter un compte dans Xcode -> Préférences -> Comptes, créez une application vierge et construisez sur un appareil réel. Lors de l’assemblage, l’appareil sera ajouté à votre compte développeur gratuit. Après l’assemblage et le lancement, vous devez créer l’archive ; pour ce faire, sélectionnez Appareil et produit iOS génériques -> Archive. Une fois l’archive créée, extrayez-en les fichiersembedded.mobileprovision et PkgInfo. Depuis le journal de build vers l’appareil, recherchez la ligne de codedesign avec la clé de signature correcte, le chemin d’accès au fichier de droits avec l’extension app.xcent, copiez-le.
    Copiez le dossier .app de l’archive, remplacez le binaire dans l’archive par un autre compilé par un compilateur croisé sous Linux (par exemple, SpaceJaguar.app/SpaceJaguar), puis ajoutez les ressources nécessaires au .app, vérifiez l’intégrité des fichiers PkgInfo et Embedded.mobileprovision dans le .app à partir de l’archive, copiez à nouveau si nécessaire. Nous re-signons le .app à l’aide de la commande codesign – le codedesign nécessite une clé d’entrée pour la signature, le chemin d’accès au fichier de droits (peut être renommé avec une extension .plist)
    Après la re-signature, créez un dossier Payload, déplacez-y le dossier avec l’extension .app, créez une archive zip avec Payload à la racine, renommez l’archive avec l’extension .ipa. Après cela, dans Xcode, ouvrez la liste des appareils et faites glisser le nouvel ipa vers la liste des applications de l’appareil ; L’installation via Apple Configurator 2 ne fonctionne pas pour cette méthode. Si la re-signature est effectuée correctement, alors l’application avec le nouveau binaire sera installée sur un appareil iOS (par exemple, iPad) avec un certificat de 7 jours, cela suffit pour la période de test.

    Sources

    https://github.com/tpoechtrager/cctools-port

    https://docs.godotengine.org/ru/latest/development/compiling/cross-compiling_for_ios_on_linux.html

    https://jonnyzzz.com/blog/2018/06/13/link-error-3/

    https://stackoverflow.com/questions/6896029/re-sign-ipa-iphone

    https://developer.apple.com/library/archive/documentation/Security/Conceptual/CodeSigningGuide/Procedures/Procedures.html

  • Construire pour Windows sous Ubuntu MinGW CMake

    Dans cet article, je décrirai le processus de création de bibliothèques et d’applications pour Windows à l’aide de la chaîne d’outils MinGW32 sur Ubuntu.
    Installez wine, mingw :

    sudo apt-get install wine mingw-w64
    

    Après cela, vous pouvez déjà créer des applications C/C++ pour Windows :

    # C
    i686-w64-mingw32-gcc helloWorld.c -o helloWorld32.exe      # 32-bit
    x86_64-w64-mingw32-gcc helloWorld.c -o helloWorld64.exe    # 64-bit
     
    # C++
    i686-w64-mingw32-g++ helloWorld.cc -o helloWorld32.exe     # 32-bit
    x86_64-w64-mingw32-g++ helloWorld.cc -o helloWorld64.exe   # 64-bit
    

    L’exe collecté peut être vérifié à l’aide de wine.
    Examinons ensuite les modifications apportées à la build CMake, le fichier CMakeLists.txt, en ajoutant des éléments spécifiques à MinGW au fichier de build :

    if (MINGW32)
    set(CMAKE_SYSTEM_NAME Windows)
    SET(CMAKE_C_COMPILER i686-w64-mingw32-gcc)
    SET(CMAKE_CXX_COMPILER i686-w64-mingw32-g++)
    SET(CMAKE_RC_COMPILER i686-w64-mingw32-windres)
    set(CMAKE_RANLIB i686-w64-mingw32-ranlib)
    endif()
    
    // для сборки shared dll
    elseif (MINGW32)
    add_library(FlameSteelEngineGameToolkit.dll SHARED ${SOURCE_FILES})
    else()
    
    // обязательно линкуем со всеми зависимостями
    if (MINGW32)
    target_link_libraries(
                            FlameSteelEngineGameToolkit.dll 
                            -static-libgcc
                            -static-libstdc++
                            SDL2 
                            SDL2_mixer 
                            /home/demensdeum/Sources/cube-art-project-bootstrap/FlameSteelFramework/FlameSteelCore/FlameSteelCore.dll
                            /home/demensdeum/Sources/cube-art-project-bootstrap/FlameSteelFramework/FlameSteelBattleHorn/FlameSteelBattleHorn.dll
                            /home/demensdeum/Sources/cube-art-project-bootstrap/FlameSteelFramework/FlameSteelCommonTraits/FlameSteelCommonTraits.dll)
    
    set_target_properties(FlameSteelEngineGameToolkit.dll PROPERTIES
            PREFIX ""
            SUFFIX ""
            LINK_FLAGS "-Wl,--add-stdcall-alias"
            POSITION_INDEPENDENT_CODE 0 # this is to avoid MinGW warning; 
            # MinGW generates position-independent-code for DLL by default
    )
    else()
    

    Nous collectons :

    cmake -DMINGW32=1 .
    make
    

    La sortie sera une DLL ou un exe, selon ce que vous collectez. Pour un exemple fonctionnel, vous pouvez consulter le référentiel du nouveau Cube-Art-Project et ses bibliothèques :
    https://gitlab.com/demensdeum/cube-art-project

    https://gitlab.com/demensdeum/FlameSteelEngineGameToolkitFSGL

    https://gitlab.com/demensdeum/cube-art-project-bootstrap

    Sources
    https://arrayfire.com/cross-compile-to-windows-from-linux/

  • Création d’applications macOS pour Ubuntu OSXCross CMake

    Dans cet article, je décrirai la création d’applications C++ multiplateformes pour macOS sur une machine de build Ubuntu à l’aide de CMake et osxcross.
    Tout d’abord, installez la chaîne d’outils osxcross :
    https://github.com/tpoechtrager/osxcross
    L’installation se déroule en 3 étapes, téléchargement des dépendances :

    cd tools
    ./get_dependencies.sh
    

    Téléchargez XCode.xip depuis le site officiel d’Apple, puis téléchargez le SDK depuis XCode :

    ./gen_sdk_package_pbzx.sh /media/demensdeum/2CE62A79E62A4404/LinuxSupportStorage/xcode111.xip
    

    J’espère que vous avez lu le contrat de licence XCode lors de la dernière étape ? Ensuite, créez la chaîne d’outils avec le préfixe requis :

    INSTALLPREFIX=/home/demensdeum/Apps/osxcross ./build.sh 
    

    Vous pouvez maintenant utiliser osxcross à partir du répertoire de préfixes de l’étape précédente. Ajoutons une nouvelle macro de build pour CMake et écrivons tout ce qui est nécessaire :

    if (OSXCROSS)
    SET(CMAKE_SYSTEM_NAME Darwin)
    SET(CMAKE_C_COMPILER o64-clang)
    SET(CMAKE_CXX_COMPILER o64-clang++)
    SET(CMAKE_C_COMPILER_AR x86_64-apple-darwin19-ar)
    SET(CMAKE_CXX_COMPILER_AR x86_64-apple-darwin19-ar)
    SET(CMAKE_LINKER x86_64-apple-darwin19-ld)
    SET(ENV{OSXCROSS_MP_INC} 1)
    endif()
    

    Les liens dynamiques n’ont pas réussi pour moi, nous exportons donc les bibliothèques de manière statique :

    if (OSXCROSS)
    add_library(FlameSteelCore STATIC ${SOURCE_FILES})
    else()
    

    Ensuite, vous serez peut-être confronté au fait que vous ne disposez pas des bibliothèques nécessaires pour osxcross, j’ai rencontré cela lors de l’utilisation de SDL2. osxcross prend en charge les packages de bibliothèques prêts à l’emploi – macports. Par exemple, en installant SDL2-mixer :

    osxcross-macports -v install libsdl2_mixer
    

    Après cela, vous pouvez commencer à créer des bibliothèques/applications comme d’habitude dans le lien cmake-make, n’oubliez pas de spécifier des liens statiques de bibliothèques si nécessaire.

    Assemblage manuel des bibliothèques

    Actuellement, j’ai rencontré le problème d’un archivage incorrect des bibliothèques lors de la liaison statique ; lors de la construction de l’application finale, je reçois l’erreur :

    file was built for archive which is not the architecture being linked (x86_64)
    

    Très similaire à ce ticket, nous avons réussi à implémenter une solution de contournement permettant à la construction de se terminer correctement. Décompressons la bibliothèque statique et recréons-la à l’aide de l’archiveur osxcross :

    ar x ../libFlameSteelCore.a
    rm ../libFlameSteelCore.a
    x86_64-apple-darwin19-ar rcs ../libFlameSteelCore.a *.o
    

    De plus, l’un des problèmes que je considère personnellement est le manque de possibilité d’exécuter des applications macOS directement sur Ubuntu (au moins avec une partie des fonctionnalités). Bien sûr, il existe un projet darling, mais le support laisse encore beaucoup à désirer.

    Sources

    https://github.com/tpoechtrager/osxcross

  • Génération d’images locales : modèle ComfyUI et FLUX

    De nos jours, vous n’avez plus besoin de recourir aux services cloud : vous pouvez générer des images de haute qualité entièrement sur votre propre matériel. Dans cet article, je vais décrire comment exécuter le modèle FLUX moderne localement sur votre ordinateur à l’aide de ComfyUI.

    ComfyUI utilise une architecture basée sur les nœuds. Cela vous permet de :
    – Contrôlez totalement chaque étape de la génération.
    – Partagez facilement des « workflows » prêts à l’emploi

    FLUX est un grand modèle, la configuration matérielle requise est donc supérieure à celle de SD 1.5 ou SDXL :
    – Carte vidéo (GPU) : Nvidia RTX avec 12 Go de VRAM ou plus (pour un travail confortable). Si vous disposez de 8 Go ou moins, vous devrez utiliser les versions quantifiées (GGUF ou NF4).
    – Mémoire vive (RAM) : minimum 16 Go (de préférence 32 Go et plus).
    – Espace disque : environ 20 à 50 Go pour les modèles et les composants.

    Le moyen le plus simple de démarrer FLUX est d’utiliser un modèle prêt à l’emploi. Recherchez simplement le texte de flux à image dans la fenêtre des flux de travail et installez-le.

    Écrivez une invite en anglais dans le nœud « Text to Image (Flux.1 Dev) », sélectionnez la résolution (FLUX fonctionne bien avec 1024 x 1024 et même plus) et appuyez sur RUN.

    La première génération peut prendre du temps car les modèles seront chargés dans la mémoire de la carte vidéo.

    https://github.com/comfyanonymous/ComfyUI

  • Codage Vibe local : LM Studio, VS Code et Continuer

    Si vous souhaitiez utiliser des réseaux de neurones pour vous aider à écrire du code (appelé codage Vibe) et que vous disposez d’un ordinateur assez puissant, par exemple avec une carte vidéo Nvidia RTX, alors vous pouvez déployer l’ensemble de l’environnement absolument gratuitement sur votre machine. Cela résout les problèmes liés aux abonnements payants et vous permet de travailler en toute sécurité avec des projets sous NDA, puisque votre code n’est envoyé nulle part. Dans cet article, je vais décrire comment assembler un bundle local de LM Studio, VS Code et l’extension Continue.

    Outils pour le codage Vibe local

    Pour un travail confortable, nous avons besoin de trois composants principaux :
    – LM Studio : une application pratique pour télécharger et exécuter des LLM locaux. Il prend en charge toute la complexité du travail avec les modèles GGUF et met en place un serveur local compatible avec l’API OpenAI.
    – VS Code : un éditeur de code populaire et familier.
    – Continuer : extension pour VS Code qui intègre les réseaux de neurones directement dans l’environnement de travail. Vous permet de discuter, de mettre en évidence le code pour la refactorisation et de prendre en charge la saisie semi-automatique.

    Exigences matérielles

    Les modèles de langage local sont gourmands en mémoire :
    – Carte vidéo (GPU) : Nvidia avec 8 Go de VRAM ou plus (pour un travail confortable avec des modèles avec 7 à 8 milliards de paramètres). Les modèles plus lourds nécessiteront 16 Go de VRAM.
    – Espace disque : environ 500 Go pour stocker les différents modèles téléchargés.

    Configurer le lien

    Le processus de configuration est assez simple et ne nécessite pas de manipulations complexes dans le terminal :
    1. Téléchargez et installez LM Studio. Utilisez la recherche intégrée pour trouver un modèle léger tel que Qwen Coder ou gemma3:12b.
    2. Dans LM Studio, accédez à l’onglet Serveur local et cliquez sur Démarrer le serveur. Par défaut, il démarrera sur `http://localhost:1234/v1`.
    3. Ouvrez VS Code et installez l’extension Continuer à partir du magasin de plugins.
    4. Ouvrez le fichier de configuration Continue et ajoutez un nouveau modèle, en spécifiant le fournisseur `openai` et l’adresse de votre serveur local depuis LM Studio.

    Vous pouvez ensuite communiquer avec votre LLM local directement dans la barre latérale Continuer, poser des questions sur votre code et générer de nouveaux composants.

    Pourquoi ça marche ?

    Comme je l’ai écrit plus tôt, les LLM réussissent mieux avec une structure plate et du code WET (Write Everything Twice). Les modèles de paramètres locaux peuvent être inférieurs aux géants comme GPT-4 lorsqu’il s’agit de concevoir des architectures complexes, mais ils sont plus que capables de générer du code passe-partout, de refactoriser des fonctions simples et de réaliser un prototypage rapide.

    De plus, grâce au codage Vibe local, votre code ne quitte jamais la machine. Cela rend cette combinaison idéale pour le développement d’entreprise et le travail avec des données sensibles.

    Sortie

    Les réseaux de neurones locaux ne sont pas capables de remplacer complètement un programmeur ou de concevoir un système complexe. Cependant, la combinaison de LM Studio + VS Code + Continue offre une indépendance par rapport aux services cloud et préserve la confidentialité. Il s’agit d’un outil auxiliaire entièrement fonctionnel pour les tâches de routine, si vous êtes prêt à supporter les limitations des petits modèles et à contrôler indépendamment l’architecture du projet.

    Liens

    https://code.visualstudio.com/
    https://lmstudio.ai/
    https://continue.dev/

    Sources

    https://youtu.be/IqqCwhG46jY
    https://www.youtube.com/watch?v=7AImkA96mE8

  • Génération vidéo locale : ComfyUI et LTX-2.3

    Auparavant, créer des vidéos à l’aide de réseaux de neurones était l’apanage des services cloud comme Runway ou Luma. Aujourd’hui, si vous disposez d’une carte graphique Nvidia moderne, vous pouvez générer des vidéos de haute qualité directement sur votre ordinateur. Dans cet article, je vais vous expliquer comment configurer la génération vidéo locale à l’aide de ComfyUI et du modèle efficace LTX-2.3.

    Outils de génération de vidéos

    Pour le travail, nous aurons besoin de :
    – ComfyUI : une interface puissante avec une architecture basée sur des nœuds qui vous permet de personnaliser de manière flexible le processus de génération.
    – LTX-2.3 : Un modèle moderne de Lightricks, optimisé pour créer des vidéos fluides et détaillées avec des besoins en mémoire vidéo relativement modérés.

    Exigences matérielles

    Générer une vidéo est un processus beaucoup plus gourmand en ressources que travailler avec des images :
    – Carte vidéo (GPU) : Nvidia RTX avec 8 Go de VRAM est le minimum requis pour une résolution de 768 x 512. Pour un fonctionnement confortable et des résolutions plus élevées, il est hautement souhaitable de disposer de 16 à 24 Go de VRAM.
    – Mémoire vive (RAM) : minimum 32 Go. Les modèles vidéo et les VAE prennent beaucoup de place lors du téléchargement.
    – Espace disque : environ 500 Go pour le modèle lui-même et les composants associés.

    Configuration et lancement

    Le processus de lancement de LTX-2.3 dans ComfyUI est le suivant :
    1. Mettre à jour ComfyUI : Le modèle est relativement nouveau, alors assurez-vous d’avoir installé la dernière version de l’interface.
    2. Installer le workflow : Le moyen le plus simple consiste à trouver un modèle JSON prêt à l’emploi pour LTX Video. Le modèle nécessite des nœuds spécifiques pour fonctionner avec l’espace latent vidéo.
    3. Invite et paramètres : Saisissez une description de la scène en anglais. Notez que le LTX-2.3 comprend bien le mouvement (par exemple « la caméra tourne autour », « mouvement rapide »).

    Pourquoi choisir LTX-2.3 ?

    LTX-2.3 est remarquable car il fournit des résultats comparables aux services cloud propriétaires, mais s’exécute localement. Cela vous donne :
    – Confidentialité totale : vos invites et vidéos générées ne sont pas transmises aux serveurs d’autres personnes.
    – Contrôle : vous pouvez expérimenter la fréquence d’images (FPS), la résolution et la force de l’invite sans avoir à payer pour chaque tentative.

    La génération vidéo locale est toujours en développement actif et LTX-2.3 constitue une excellente entrée dans le monde du « home Hollywood ».

    Liens

    https://github.com/comfyanonymous/ComfyUI
    https://huggingface.co/Lightricks/LTX-Video

  • Génération de musique locale : modèle ComfyUI et ACE-Step-1.5

    De nos jours, vous n’avez plus besoin de recourir aux services cloud pour créer du contenu : vous pouvez générer de la musique de haute qualité entièrement sur votre propre matériel. Dans cet article, je vais décrire comment exécuter le modèle ACE-Step-1.5 moderne localement sur votre ordinateur à l’aide de ComfyUI.

    ComfyUI utilise une architecture basée sur les nœuds. Cela vous permet de :
    – Contrôlez totalement chaque étape de la génération audio.
    – Partagez facilement des « workflows » prêts à l’emploi.

    ACE-Step-1.5 est un modèle avancé de génération de musique qui nécessite des ressources informatiques importantes. Les exigences matérielles sont supérieures à celles de nombreux synthétiseurs simples :
    – Carte vidéo (GPU) : Nvidia RTX avec 8 Go de VRAM ou plus (12 Go+ recommandés) pour un travail confortable et de haute qualité.
    – Mémoire vive (RAM) : minimum 16 Go (de préférence 32 Go et plus).
    – Processeur (CPU) : Processeur multicœur moderne avec une bonne prise en charge de l’informatique AVX/CUDA.
    – Espace disque : environ 20 à 50 Go pour les modèles et les composants.

    Le moyen le plus simple d’exécuter ACE-Step-1.5 consiste à utiliser un modèle de génération audio prêt à l’emploi. Recherchez simplement le texte musical en audio dans la fenêtre des flux de travail et installez-le.

    Écrivez une invite décrivant le genre et l’ambiance (par exemple, « piste synthwave inspirante avec des basses lourdes ») dans le nœud « Saisie d’invite ». Précisez la durée souhaitée et appuyez sur RUN.
    La première génération peut prendre du temps, car les modèles seront chargés dans la mémoire de la carte vidéo et traiteront des modèles acoustiques complexes.

    https://github.com/comfyanonymous/ComfyUI
    https://www.youtube.com/watch?v=UAlLD5fS7-c

  • Réseaux de neurones locaux utilisant ollama

    Si vous souhaitez lancer quelque chose comme ChatGPT et que vous disposez d’un ordinateur assez puissant, par exemple avec une carte vidéo Nvidia RTX, vous pouvez alors exécuter le projet ollama, qui vous permettra d’utiliser l’un des modèles LLM prêts à l’emploi sur votre machine locale, absolument gratuitement. ollama offre la possibilité de communiquer avec les modèles LLM, à la manière de ChatGPT ; également dans la dernière version, la possibilité de lire des images et de formater les données de sortie au format json a été annoncée.

    J’ai également exécuté le projet lui-même sur un MacBook équipé d’un processeur Apple M2 et je sais que les derniers modèles de cartes vidéo d’AMD sont pris en charge.

    Pour installer sur macOS, rendez-vous sur le site ollama :
    https://ollama.com/download/mac

    Cliquez sur “Télécharger pour macOS”, vous téléchargerez une archive du formulaire ollama-darwin.zip, à l’intérieur de l’archive il y aura Ollama.app qui doit être copié dans “Applications”. Après cela, lancez Ollama.app, le processus d’installation se produira probablement au premier lancement. Après cela, dans le plateau, vous avez vu l’icône ollama, le plateau se trouve en haut à droite à côté de l’horloge.

    Après cela, lancez un terminal macOS standard et tapez la commande pour télécharger, installer et exécuter n’importe quel modèle ollama. Une liste des modèles disponibles, leurs descriptions et leurs caractéristiques sont disponibles sur le site ollama :
    https://ollama.com/search

    Choisissez le modèle avec le moins de paramètres s’il ne rentre pas dans votre carte vidéo au lancement.

    Par exemple, la commande pour lancer le lama3.1:latest model :

    ollama run llama3.1:latest
    

    L’installation pour Windows et Linux est généralement similaire, dans un cas, il y aura un programme d’installation ollama et travaillerez ensuite avec lui via Powershell.
    Pour Linux, l’installation se fait à l’aide d’un script, mais je recommande d’utiliser la version de votre gestionnaire de packages spécifique. Sous Linux, ollama peut également être lancé via un terminal bash classique.

    Sources
    https://www.youtube.com/watch?v=Wjrdr0NU4Sk
    https://ollama.com

  • Stabilisation vidéo à l’aide de ffmpeg

    Si vous souhaitez stabiliser les vidéos et supprimer le bougé de l’appareil photo, l’outil « ffmpeg » offre une solution puissante. Grâce aux filtres intégrés « vidstabdetect » et « vidstabtransform », vous pouvez obtenir des résultats professionnels sans utiliser d’éditeurs vidéo complexes.

    Préparer le travail

    Avant de commencer, assurez-vous que votre `ffmpeg` prend en charge la bibliothèque `vidstab`. Sous Linux, vous pouvez vérifier cela avec la commande :

    bash  
    ffmpeg -filters | grep vidstab  
    

    Si la bibliothèque n’est pas installée, vous pouvez l’ajouter :

    sudo apt install ffmpeg libvidstab-dev  
    

    Installation pour macOS via Brew :

    brew install libvidstab
    brew install ffmpeg
    

    Passons maintenant au processus.

    Étape 1 : Analyse du mouvement

    Vous devez d’abord analyser le mouvement de la vidéo et créer un fichier avec les paramètres de stabilisation.

    ffmpeg -i input.mp4 -vf vidstabdetect=shakiness=10:accuracy=15 transfile=transforms.trf -f null -  
    

    Paramètres :

    tremblement : niveau de tremblement de la vidéo (par défaut 5, peut être augmenté à 10 pour les cas plus complexes).
    précision : précision de l’analyse (par défaut 15).
    transfile : Nom du fichier pour enregistrer les paramètres de mouvement.

    Étape 2 : Appliquer la stabilisation

    Vous pouvez maintenant appliquer la stabilisation à l’aide du fichier de transformation :

    ffmpeg -i input.mp4 -vf vidstabtransform=input=transforms.trf:zoom=5 output.mp4
    

    Paramètres :

    input : pointe vers le fichier avec les paramètres de transformation (créé lors de la première étape).
    zoom : facteur de zoom pour supprimer les bords noirs (par exemple 5 – zoom automatique jusqu’à ce que les artefacts soient supprimés).

  • Machines informatiques de Turing

    Je présente à votre attention une traduction des premières pages de l’article d’Alan Turing « SUR LES NUMÉROS COMPUTABLES AVEC UNE APPLICATION AU PROBLÈME DE RÉSOLUTION » de 1936. Les premiers chapitres contiennent une description des ordinateurs, qui sont devenus plus tard la base de l’informatique moderne.

    La traduction complète de l’article et l’explication peuvent être lues dans le livre du vulgarisateur américain Charles Petzold, intitulé « Reading Turing : A Journey through Turing’s Historical Article on Computability and Turing Machines » (ISBN 978-5-97060-231-7, 978-0-470-22905-7).

    Article original :
    https://www.astro.puc.cl/~rparra/tools/PAPERS/turing_1936.pdf

    SUR LES NOMBRES CALCULABLES AVEC APPLICATION AU PROBLEME DE RESOLUTION

    A. M. TURING

    [Reçu le 28 mai 1936 – Lu le 12 novembre 1936]

    Les nombres « calculables » peuvent être brièvement décrits comme des nombres réels dont les expressions sous forme de fractions décimales sont calculables d’un nombre fini de façons. Bien qu’à première vue cet article traite les nombres comme calculables, il est presque aussi simple de définir et d’explorer les fonctions calculables d’une variable entière, d’une variable réelle, d’une variable calculable, de prédicats calculables, etc. Cependant, les problèmes fondamentaux associés à ces objets calculables sont les mêmes dans chaque cas. Pour une considération détaillée, j’ai choisi les nombres calculables comme objet calculable car la méthode pour les considérer est la moins lourde. J’espère décrire bientôt la relation entre les nombres calculables et les fonctions calculables, etc. Parallèlement, des recherches seront menées dans le domaine de la théorie des fonctions d’une variable réelle exprimée en termes de nombres calculables. Selon ma définition, un nombre réel est calculable si sa représentation décimale peut être écrite par une machine.

    Aux paragraphes 9 et 10, je donne quelques arguments pour montrer que les nombres calculables incluent tous les nombres qui sont naturellement considérés comme calculables. En particulier, je montre que certaines grandes classes de nombres sont calculables. Ils comprennent, par exemple, les parties réelles de tous les nombres algébriques, les parties réelles des zéros des fonctions de Bessel, les nombres π, e et autres. Cependant, les nombres calculables n’incluent pas tous les nombres définissables, comme en témoigne l’exemple suivant d’un nombre définissable qui n’est pas calculable.

    Bien que la classe des nombres calculables soit très vaste et similaire à bien des égards à la classe des nombres réels, elle reste néanmoins dénombrable. Au §8, je considère certains arguments qui semblent soutenir le contraire. Lorsqu’un de ces arguments est correctement appliqué, on en tire des conclusions qui, à première vue, sont similaires à celles de Gödel*. Ces résultats ont des applications extrêmement importantes. En particulier, comme indiqué ci-dessous (§11), le problème de résolution ne peut pas avoir de solution.

    Dans un article récent, Alonzo Church a introduit l’idée de « calculabilité efficace », qui est équivalente à mon idée de « calculabilité » mais a une définition complètement différente. Church arrive également à des conclusions similaires concernant le problème de la résolution. La preuve de l’équivalence de « calculabilité » et « effectivement calculable » est présentée en annexe de cet article.

    1. Ordinateurs

    Nous avons déjà dit que les nombres calculables sont les nombres dont les décimales sont dénombrables par des moyens finis. Une définition plus claire est nécessaire ici. Cet article ne tentera pas réellement de justifier les définitions données ici avant d’arriver au §9. Pour l’instant, je noterai simplement que la justification (logique) (de cela) est que la mémoire humaine est, par nécessité, limitée.

    Comparons une personne en train de calculer un nombre réel avec une machine capable de remplir seulement un nombre fini de conditions q1, q2, …, qR ; Appelons ces conditions « m-configurations ». Cette machine (c’est-à-dire ainsi définie) est équipée d’un « ruban » (analogue au papier). Cette courroie traversant la machine est divisée en tronçons. Appelons-les « carrés ». Chacun de ces carrés peut contenir une sorte de « symbole ». À tout moment, il n’existe qu’un seul carré de ce type, disons le ième, contenant le symbole qui se trouve « dans cette machine ». Appelons un tel carré un « symbole numérisé ». Un “caractère scanné” est le seul caractère dont la machine est, pour ainsi dire, “directement consciente”. Cependant, en modifiant sa configuration m, la machine peut effectivement mémoriser certains des caractères qu’elle a “vus” (numérisés) précédemment. Le comportement possible de la machine à tout moment est déterminé par la configuration m qn et le symbole scanné***. Appelons cette paire de symboles qn, « configuration ». La configuration ainsi désignée détermine le comportement possible d’une machine donnée. Dans certaines de ces configurations dans lesquelles le carré scanné est vide (c’est-à-dire ne contient pas de caractère), la machine écrit un nouveau caractère sur le carré scanné, et dans d’autres de ces configurations, elle efface le caractère scanné. Cette machine est également capable de se déplacer pour scanner une autre case, mais de cette manière elle ne peut se déplacer que vers la case adjacente à droite ou à gauche. En plus de chacune de ces opérations, la configuration m de la machine peut être modifiée. Dans ce cas, certains des caractères écrits formeront une séquence de chiffres, qui constitue la partie décimale du nombre réel calculé. Le reste ne sera que des notes inexactes destinées à « aider la mémoire ». Dans ce cas, seules les marques inexactes mentionnées ci-dessus pourront être effacées.

    J’affirme que les opérations considérées ici incluent toutes les opérations utilisées dans le calcul. La justification de cette affirmation est plus facile à comprendre pour le lecteur qui a une compréhension de la théorie des machines. Par conséquent, dans la section suivante, je continuerai à développer la théorie en question, basée sur une compréhension de la signification des termes « machine », « bande », « scanné », etc.

    *Gödel « Sur les phrases formellement indécidables des Principia Mathematics (publié par Whitehead et Russell en 1910, 1912 et 1913) et des systèmes associés, partie I », Journal of Mathematics. Physique, bulletin mensuel en allemand n° 38 (pour 1931, pp. 173-198.
    ** Alonzo Church, « Un problème indécidable dans la théorie élémentaire des nombres », American J. of Math., n° 58 (1936), pp. 345-363.
    *** Alonzo Church, « Une note sur le problème de la résolution », J. of Symbolic Logic, n° 1 (1936), pp. 40-41

DemensDeum
Privacy Overview

This website uses cookies so that we can provide you with the best user experience possible. Cookie information is stored in your browser and performs functions such as recognising you when you return to our website and helping our team to understand which sections of the website you find most interesting and useful.