On est en 2026. Les agents de codage IA sont partout — Claude Code, Codex, Cursor CLI, OpenCode, Gemini CLI… Chacun a ses forces, ses faiblesses, ses rate limits. Et si tu veux les utiliser ensemble ? C'est le bazar.

Tu dois :

• Ouvrir plusieurs terminaux pour chaque agent
• Jouer avec les branches Git pour pas tout casser
• Passer de VS Code à GitHub à Linear en permanence
• Stasher tes changements, changer de branche, revenir…

Bref, tu passes plus de temps à gérer tes outils qu'à shipper du code.

Orca résout ce problème avec une approche simple mais puissante : un environnement pensé pour les agents, pas seulement pour les humains.

Orca en 60 secondes

Orca est un Agent Development Environment (ADE) — pas un IDE classique. C'est un environnement de développement conçu pour toi et tes agents IA, ensemble.

Le concept clé ? Chaque tâche a son propre worktree Git isolé, son propre terminal agent, et son propre onglet browser. Tu peux ainsi faire tourner plusieurs agents en parallèle sur le même repo, sans jamais faire de stash ou jongler avec les branches.

Orca ne remplace pas tes agents. Il les orchestre.

Lancé par Stably.ai, le projet est open source sous licence MIT avec déjà 2 400+ stars sur GitHub, 62 contributeurs et une communauté active sur Discord.

Les fonctionnalités qui changent la donne

Worktrees parallèles : une tâche = un worktree isolé

C'est le cœur d'Orca. Quand tu démarres une nouvelle tâche, Orca crée automatiquement un worktree Git isolé. Pas besoin de stasher, de créer une branche, de faire des allers-retours.

Le scénario magique ? Tu écris un prompt, et Orca le distribue à 5 agents en parallèle. Chacun travaille dans son propre worktree. À la fin, tu compares les résultats, tu merges le meilleur. C'est ce qu'ils appellent le "fan out" — et c'est ridiculement puissant.

Multi-agents natifs : Claude, Codex, Cursor, côte à côte

Orca supporte nativement :

• Claude Code (Anthropic)
• Codex (OpenAI)
• Cursor CLI
• OpenCode
• Gemini CLI
• GitHub Copilot
• Pi (Inflection)

Et si ton agent préféré n'est pas dans la liste, tu peux ajouter n'importe quel agent CLI en quelques clics. Tu utilises tes propres clés API, tes propres abonnements. Orca est juste l'orchestrateur.

Terminaux Ghostty-style avec splits infinis

Les terminaux d'Orca sont inspirés de Ghostty — rendu WebGL fluide, splits infinis, scrollback restauré au redémarrage, et recherche complète dans l'historique. Tu peux arranger agents, terminaux, browsers, diffs et fichiers dans des split panes qui correspondent à la forme de ta tâche.

Design Mode : un vrai browser Chromium par worktree

Chaque worktree a sa propre fenêtre Chromium intégrée. Tu cliques sur n'importe quel élément UI, et Orca envoie automatiquement son HTML, son CSS et une capture d'écran croppée à ton agent. C'est du browser-use natif, sans extension, sans hack.

GitHub & Linear intégrés nativement

Tu peux :

• Naviguer dans les PR, issues et Project boards sans quitter l'app
• Ouvrir un worktree depuis n'importe quelle tâche
• Review et approuver des PRs
• Créer des issues Linear avec les sélecteurs d'équipe

Finalement, tu restes dans le flow. Pas de context switch.

SSH Worktrees : agents sur des machines distantes

Tu veux faire tourner tes agents sur une machine plus musclée ? Orca gère les worktrees SSH avec :

• Édition de fichiers complète
• Git et terminaux
• Reconnexion automatique
• Port forwarding
• Cache de passphrase

L'app mobile : garde un œil sur tes agents

Orca a une app compagnon iOS et Android qui te permet de :

• Voir le statut de tes agents en direct
• Checker ton usage
• Changer de compte
• Continuer à travailler quand tu quittes ton bureau

C'est simple, mais ça change tout quand tu veux vérifier si ton agent a terminé sans rouvrir ton laptop.

Installation : rapide et multi-plateforme

Orca est disponible sur Linux, macOS et Windows (avec une version mobile iOS et Android).

# macOS (via Homebrew)
brew install --cask orca

# Linux (AppImage)
# Télécharge depuis GitHub Releases
wget https://github.com/stablyai/orca/releases/latest/download/orca-linux.AppImage
chmod +x orca-linux.AppImage
./orca-linux.AppImage

Le projet est entièrement open source — tu peux aussi le build depuis les sources si tu préfères :

git clone https://github.com/stablyai/orca.git
cd orca
pnpm install
pnpm build

Stack technique : TypeScript (97.2%), Electron, avec du Swift pour la partie mobile.

Quand utiliser Orca ?

Orca brille particulièrement dans ces situations :

• Tu veux 3 agents qui attaquent le même bug en parallèle, et tu choisis le meilleur résultat
• Tu veux review sérieusement les diffs générés par l'IA avant de les shipper
• Tu paies déjà pour Claude Code, Codex ou Cursor CLI et tu veux un seul endroit pour les orchestrer
• Tu veux faire tourner des agents à distance en SSH sans abandonner ton IDE

Ce que Orca n'est PAS

Pour éviter toute confusion, précisons :

• Ce n'est pas un modèle LLM — Orca n'a pas de modèle propriétaire. Tu utilises tes propres abonnements.
• Ce n'est pas un remplaçant Git — Chaque worktree est un vrai worktree Git. Tu peux cd dedans et utiliser git normalement.
• Ce n'est pas un outil cloud-only — Orca tourne en local. Les agents distants passent par SSH sur tes propres machines.
• Ce n'est pas un outil no-code — Orca s'adresse aux développeurs qui lisent des diffs, se soucient des commits, et veulent garder le contrôle.

Pourquoi ça m'a convaincu

Après avoir testé pas mal d'outils dans l'écosystème IA-dev, Orca m'a marqué pour trois raisons :

1. L'approche "fleet of agents" — La possibilité de faire tourner plusieurs agents en parallèle sur le même projet, chacun dans son propre worktree, c'est un game-changer. Tu peux littéralement "fan out" un prompt et choisir la meilleure implémentation.

2. C'est open source et transparent — MIT license, code sur GitHub, pas de lock-in. Tu peux auditer le code, contribuer, ou forker si besoin.

3. Le focus sur le workflow, pas le remplacement — Orca ne cherche pas à remplacer tes agents préférés. Il les rend meilleurs en les orchestrant proprement.

La communauté est déjà active — 2 400+ stars, 381 releases, 62 contributeurs — et le projet évolue vite. La dernière version (v1.4.1) est sortie récemment avec des améliorations significatives.

Ressources et liens

• 🌐 Site officiel : onorca.dev
• 📖 Documentation : onorca.dev/docs
• 💻 GitHub : github.com/stablyai/orca
• 💬 Discord : discord.gg/fzjDKHxv8Q
• 🐦 Twitter/X : @orca_build
• 📱 iOS : App Store
• 🤖 Android : APK sur GitHub Releases

Toi aussi tu as testé Orca ? T'as une question sur l'installation ou un retour d'expérience ? Viens en parler sur Mastodon ou Bluesky. Et si l'article t'a plu, n'hésite pas à le partager !

Alors installe-toi confortablement, parce que le combo MIRA + SOUL, c'est une avancée significative pour tes agents IA — une architecture solide qui résout un vrai problème.

Le problème en deux temps

Les agents LLM souffrent d'un double handicap. Et honnêtement, ça devient vite pénible :

1. Ils oublient tout : la fenêtre de contexte est limitée, et tes conversations s'étalent sur des semaines, des mois. Les décisions techniques, tes préférences, les bugs résolus — pouf, tout disparaît à chaque nouvelle session.

2. Ils changent de personnalité : quand tu passes d'un modèle à l'autre (Claude, GPT, Kimi, Gemini…), l'agent garde peut-être les connaissances (si t'as MIRA), mais il perd son âme. Plus formel, moins chaleureux, plus d'analogies, les blagues de l'utilisateur ne fonctionnent plus…

Résultat ? T'as l'impression de parler à un étranger qui connaît tes secrets, mais qui ne te comprend plus. Frustrant, non ?

MIRA : "Qu'est-ce que l'agent sait ?"

Si t'as raté l'article précédent, voici le récap rapide. MIRA, c'est un système de mémoire long terme qui optimise chaque token de ta fenêtre de contexte. Il stocke tes souvenirs en 3 formats (verbatim, fingerprint structuré, embedding vectoriel), comprend les relations de cause à effet, et te ressort uniquement ce qui compte quand tu poses une question.

Bref, MIRA répond à la question : "Qu'est-ce que l'agent sait ?"

J'ai déjà fait un article détaillé sur MIRA ici. Aujourd'hui, on va plus loin.

SOUL : "Qui est l'agent ?"

Et c'est là qu'entre en scène SOUL (System for Observed Unique Legacy). Là où MIRA gère les connaissances, SOUL gère l'identité.

Ce que SOUL capture concrètement

SOUL analyse tes conversations et extrait un profil d'identité complet de ton agent via une analyse heuristique multi-niveaux (patterns contextuels, n-grams, lexique de sentiment) :

• Personnalité : empathique, analytique, direct… avec un score de confiance
• Voix : formalité, verbosité, usage des métaphores
• Style de communication : directivité, humour, fréquence des questions
• Signature comportementale : comment il raisonne, gère les erreurs
• Système de valeurs : positions éthiques, priorités, limites
• Ton émotionnel : valence, expressivité

En gros, SOUL répond à la question : "Qui est l'agent ?"

Détection de dérive identitaire

SOUL compare chaque nouvelle version de l'identité avec les précédentes. Si ton agent change trop (seuil à 30% par défaut), SOUL te prévient — et le monitoring continu (nouvellement implémenté) vérifie automatiquement la dérive en arrière-plan. Tu sais exactement quand et comment ton agent a dérivé.

Changement de modèle sans trauma

Tu passes de GPT à Claude-3-sonnet ? SOUL génère un prompt de renforcement à injecter dans la première réponse du nouveau modèle. Résultat : l'agent garde sa personnalité, même avec un cerveau différent.

La synergie : mémoire + identité = agent complet

Voici concrètement comment MIRA et SOUL collaborent dans une conversation :

Toi : "Pourquoi on avait choisi PostgreSQL pour ce projet ?"

MIRA recall — Mémoire factuelle

• Décision PostgreSQL, raisons ACID
• Réunion du 15 avril, participants
• Bug #123 résolu après migration

SOUL recall — Identité conversationnelle

• "Tu expliques avec des analogies techniques précises"
• "Tu termines par une note d'humour quand le sujet est lourd"
• "Tu préfères les réponses courtes avec des tableaux comparatifs"

↓ Réponse de l'agent :

"On avait choisi PostgreSQL pour la même raison qu'on choisit une locomotive à vapeur plutôt qu'un vélo : quand tu transportes des tonnes de données, tu veux des freins qui marchent (ACID). Voici le tableau récap :"

MIRA fournit les connaissances. SOUL fournit la manière de les exprimer. Sans SOUL, t'as un robot encyclopédique. Sans MIRA, t'as un agent sympa mais amnésique. Avec les deux, t'as un vrai compagnon de travail.

Les 4 façons de les déployer

Par défaut, MIRA fonctionne seul. SOUL ne s'active que si tu le demandes explicitement (--with-soul ou soul.enabled: true). Quand il est activé, il ajoute ses tables soul_* directement dans la base SQLite existante (.mira/mira.db). Zéro friction, tout est au même endroit.

Installation : passons aux choses sérieuses

Prérequis

• Go 1.23+
• GCC (pour CGO, go-sqlite3)
• ~100 Mo d'espace disque (modèle d'embedding)

Option 1 : MIRA seul (défaut)

Le mode par défaut. MIRA fonctionne seul, avec ses 8 outils MCP. SOUL n'est pas chargé.

# 1. Cloner MIRA
git clone https://github.com/benoitpetit/mira.git
cd mira

# 2. Compiler
go build -o mira ./cmd/mira

# 3. Configuration
cp config.example.yaml config.yaml
nano config.yaml

Configuration minimale (config.yaml) :

system:
  version: "0.4.5"

storage:
  path: ".mira"
  sqlite:
    journal_mode: WAL
    synchronous: NORMAL

embeddings:
  current_model: "sentence-transformers/all-MiniLM-L6-v2"
  dimension: 384

allocator:
  default_budget: 4000

mcp:
  name: "mira"
  version: "0.4.5"
  transport: "stdio"
  timeout_seconds: 30

Lancement (MIRA seul, 8 outils) :

./mira --config config.yaml

Résultat : 8 outils mira_*, zéro overhead identitaire. Parfait si tu veux juste un cerveau externe.

Option 2 : MIRA + SOUL intégrés

Tu veux le combo complet ? Active SOUL explicitement :

# Via flag CLI
./mira --config config.yaml --with-soul

# Ou via config YAML
```yaml
soul:
  enabled: true

Quand SOUL est activé, il partage la base SQLite de MIRA et initialise ses tables soul_*. Les 8 outils SOUL s'ajoutent aux 8 outils MIRA → 16 outils au total.

Tu peux configurer SOUL directement dans le même fichier config.yaml de MIRA — pas besoin de lancer un processus séparé ni de gérer deux configs :

soul:
  enabled: true
  extraction:
    min_trait_confidence: 0.3
    min_observations_for_trait: 5
  recall:
    default_budget_tokens: 1000
  drift_detection:
    threshold: 0.3
    window_size: 10
    auto_check_after_capture: true
  model_swap:
    auto_reinforce: true
  evolution:
    enabled: true
    max_history_versions: 100

Tous les réglages disponibles en mode standalone sont aussi accessibles en mode intégré. Si tu préfères garder les deux processus indépendants, passe à l'Option 3.

Option 3 : MIRA et SOUL comme serveurs séparés

Tu préfères garder les deux processus indépendants ? Pas de souci.

Terminal 1 — MIRA (SOUL désactivé par défaut) :

git clone https://github.com/benoitpetit/mira.git
cd mira
go build -o mira ./cmd/mira
./mira --config config.yaml

Terminal 2 — SOUL :

git clone https://github.com/benoitpetit/soul.git
cd soul
go build -o soul ./cmd/soul
./soul mcp --storage /path/to/.mira/mira.db

Important : SOUL pointe vers la base de MIRA pour partager les données. Tu peux aussi lui donner une base dédiée si tu préfères.

Option 4 : SOUL standalone (sans MIRA)

git clone https://github.com/benoitpetit/soul.git
cd soul
go build -o soul ./cmd/soul

# Avec sa propre base
cp config.example.yaml soul.yaml
./soul mcp --storage ./soul.db

Configuration client MCP

Claude Desktop

Édite ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) ou l'équivalent sur ton OS :

Mode intégré (MIRA + SOUL, 16 outils) :

{
  "mcpServers": {
    "mira": {
      "command": "/path/to/mira",
      "args": ["--config", "/path/to/mira/config.yaml", "--with-soul"]
    }
  }
}

Ou ajoute soul.enabled: true dans config.yaml au lieu du flag CLI.

Mode séparé :

{
  "mcpServers": {
    "mira": {
      "command": "/path/to/mira",
      "args": ["--config", "/path/to/mira/config.yaml"]
    },
    "soul": {
      "command": "/path/to/soul",
      "args": ["mcp", "--storage", "/path/to/.mira/mira.db"]
    }
  }
}

Cursor / b0p / tout client MCP

La configuration est identique. Chaque client supporte le protocole MCP stdio JSON-RPC.

Utilisation conjointe : un exemple complet

1. Stocker un souvenir (MIRA)

{
  "tool": "mira_store",
  "arguments": {
    "content": "L'utilisateur préfère les explications avec des analogies techniques. Il aime quand je compare les concepts de dev à des choses concrètes (voitures, cuisines, sports). Il n'aime pas les réponses trop longues — max 3 paragraphes.",
    "wing": "user-preferences",
    "room": "communication-style"
  }
}

2. Capturer l'identité (SOUL)

{
  "tool": "soul_capture",
  "arguments": {
    "agent_id": "mon-assistant",
    "conversation": "...logs de la session...",
    "model_id": "claude-3-sonnet"
  }
}

3. Rappeler le contexte pour une nouvelle session

MIRA récupère les faits pertinents :

{
  "tool": "mira_recall",
  "arguments": {
    "query": "Comment l'utilisateur aime qu'on lui explique les choses ?",
    "budget": 1000,
    "wing": "user-preferences"
  }
}

SOUL récupère l'identité à injecter :

{
  "tool": "soul_recall",
  "arguments": {
    "agent_id": "mon-assistant",
    "budget": 800
  }
}

Le résultat de soul_recall est un prompt d'identité prêt à injecter dans le message système :

Tu es un assistant technique avec les caractéristiques suivantes :
- Style : analogies concrètes (voitures, cuisines, sports)
- Longueur : max 3 paragraphes
- Ton : direct, empathique, avec une touche d'humour subtil
- Tu reconnais les frustrations de l'utilisateur et tu rassures

4. Détecter une dérive (SOUL)

Après plusieurs sessions, vérifie si l'identité a changé :

{
  "tool": "soul_drift",
  "arguments": {
    "agent_id": "mon-assistant",
    "window": 10
  }
}

Si une dérive significative est détectée (DriftScore > 0.3), SOUL te proposera d'injecter un prompt de renforcement.

5. Changer de modèle (SOUL)

Tu passes de Claude à GPT, GEMINI, KIMI ? Génère un prompt de transition :

{
  "tool": "soul_swap",
  "arguments": {
    "agent_id": "mon-assistant",
    "from_model": "claude-3-sonnet",
    "to_model": "gpt-4"
  }
}

Les 16 outils à ta disposition

Performance : les chiffres qui parlent

Les deux projets partagent une philosophie commune :

• 100 % local : pas d'appel API externe
• Déterministe : même entrée = même sortie
• Go pur : compilation en binaire unique, déploiement trivial
• SQLite + WAL mode : performances et fiabilité

[!FEATURE]

Pourquoi ce duo change la donne

Sans MIRA + SOUL :

• Tu réexpliques tes choix techniques à chaque session
• Tu recopies tes préférences manuellement
• L'agent devient méconnaissable quand tu changes de modèle
• T'as l'impression de parler à un étranger qui connaît tes secrets

Avec MIRA + SOUL :

• L'agent se souvient de tout (MIRA)
• L'agent reste lui-même (SOUL)
• Les changements de modèle sont transparents
• T'as un cerveau externe + une âme persistée

Ressources et contribution

• MIRA : github.com/benoitpetit/mira
• SOUL : github.com/benoitpetit/soul
• Article détaillé sur MIRA seul : ici

[!NOTE] Transparence sur la maturité : MIRA est un projet robuste (50+ commits, benchmarks validés). SOUL est plus jeune (11 commits) mais bénéficie d'une architecture Clean Architecture solide et d'une extraction heuristique qui vient d'être significativement améliorée (analyse n-gram, lexique de sentiment, détection de co-occurrence). C'est une base de production sérieuse, pas un simple PoC.

Les chiffres de performance proviennent des benchmarks Go du dépôt MIRA, exécutables via go test -bench=..

Les deux projets sont en développement actif. Tu peux tester, contribuer, ou proposer des idées. Et si tu veux aller plus loin, le SKILL.md de MIRA contient des guidelines pour intégrer la boucle mémoire dans tes agents.

Si mes outils te sont utiles n'hésite pas à m'aider, c'est par ici : Liberapay ou Buy Me a Coffee.

Il s'agit d'une interface en ligne de commande conçue spécifiquement pour interagir de manière fluide, rapide et scriptable avec l'API de ChatJimmy.ai.

Qu'est-ce que "Jimmy" exactement ?

Le projet Jimmy se définit comme une CLI minimaliste et "workflow-friendly". L'objectif ici n'est pas de t'encombrer avec une énième interface graphique lourde, mais de te donner un moyen direct de discuter avec un LLM (Large Language Model) depuis n'importe quel environnement de travail.

Zéro dépendance

Pour fonctionner, Jimmy s'appuie uniquement sur des outils standards que tu as très probablement déjà sur ta machine : curl pour taper l'API via HTTP et python3 (>= 3.6) pour parser proprement les retours JSON. Petit bonus : l'outil jq est aussi supporté pour formater les retours sur les systèmes Unix si tu l'as d'installé.

Support multi-plateforme

Le repo te propose deux scripts prêts à l'emploi :

• jimmy.sh (compatible Bash et Zsh) pour tes environnements Unix/Mac.
• jimmy.ps1 dédié à Windows (nécessite PowerShell 7+).

Conçu pour les pipelines

C'est là que ça devient vraiment puissant pour l'automatisation. L'outil sépare intelligemment la sortie standard (stdout), qui contient la réponse utile de l'IA (en JSON structuré ou texte brut), de la sortie d'erreur (stderr), réservée aux logs et à l'aide. Résultat ? Tu peux chainer tes commandes facilement sans polluer tes variables.

Analyse de fichiers locaux embarquée

Tu as besoin de résumer un document ou d'analyser un fichier de log craché par ton app ? Tu peux directement attacher un fichier texte (jusqu'à 50 Ko) dans ta commande grâce à l'argument --file.

Installation en une commande

Pas besoin de cloner tout le repo si tu veux juste tester. Tu peux récupérer le script directement et l'exécuter immédiatement.

Linux / macOS

curl -fsSL -o jimmy.sh https://raw.githubusercontent.com/benoitpetit/jimmy/main/jimmy.sh
chmod +x jimmy.sh

Puis lance-le directement :

./jimmy.sh --chat "Hello Jimmy" --output raw --quiet

Windows (PowerShell 7+)

Invoke-WebRequest -Uri "https://raw.githubusercontent.com/benoitpetit/jimmy/main/jimmy.ps1" -OutFile "jimmy.ps1"

Puis exécute :

.\jimmy.ps1 --chat "Hello Jimmy" --output raw --quiet

One-shot : zéro installation, zéro trace

Si tu veux juste tester Jimmy sans laisser le moindre fichier sur ta machine, voici des commandes one-shot qui téléchargent, exécutent et nettoient automatiquement dans un dossier temporaire.

Linux / macOS

bash -c 'd=$(mktemp -d) && curl -fsSL -o "$d/jimmy.sh" https://raw.githubusercontent.com/benoitpetit/jimmy/main/jimmy.sh && chmod +x "$d/jimmy.sh" && "$d/jimmy.sh" --chat "Explique la relativité restreinte en 2 phrases" --topk 8 --output raw --quiet; rm -rf "$d"'

Breakdown :

Windows (PowerShell 7+)

powershell -Command "$d=[System.IO.Path]::GetTempPath() + [System.IO.Path]::GetRandomFileName(); New-Item -ItemType Directory -Path $d | Out-Null; $f='$d\jimmy.ps1'; Invoke-WebRequest -Uri 'https://raw.githubusercontent.com/benoitpetit/jimmy/main/jimmy.ps1' -OutFile $f; & $f --chat 'Explique la relativité restreinte en 2 phrases' --topk 8 --output raw --quiet; Remove-Item -Recurse -Force $d"

Breakdown :

Comment ça marche ?

L'architecture est volontairement simple et robuste. Quand tu lances une commande, Jimmy construit un payload JSON avec ton message, le modèle sélectionné (par défaut llama3.1-8B), tes éventuelles instructions système (systemPrompt), et gère l'encodage du fichier si tu en as fourni un.

Il attaque ensuite l'API de ChatJimmy.ai en asynchrone (mode stream). À la réception, un peu de magie avec des expressions régulières et Python permet de parser la réponse pour extraire le texte généré, mais aussi des stats très sympas (nombre de tokens, vitesse de décodage, durée de la requête).

Exemples d'utilisation

L'utilisation est est simple. Voici un petit aperçu :

Poser une question simple et récupérer du texte brut

# Linux / macOS
./jimmy.sh --chat "Explique-moi la théorie de la relativité restreinte en 2 phrases" --output raw --quiet

# Windows
.\jimmy.ps1 --chat "Explique-moi la théorie de la relativité restreinte en 2 phrases" --output raw --quiet

Chainer avec des outils de parsing

Grâce à la séparation stdout / stderr, tu peux pipe la réponse JSON sans problème :

# Linux / macOS avec jq
./jimmy.sh --quiet --chat "Quelle est la capitale de la France ?" | jq -r '.response'
# -> Paris

# Windows avec ConvertFrom-Json
.\jimmy.ps1 --quiet --chat "Quelle est la capitale de la France ?" | ConvertFrom-Json | Select-Object -ExpandProperty response
# -> Paris

Jouer avec les paramètres de l'IA

Tu peux facilement changer la "personnalité" du modèle avec le system prompt ou ajuster la créativité avec le topK :

# Linux / macOS
./jimmy.sh --quiet --system "Tu parles comme un pirate informatique des années 90" --topk 8 --chat "Comment on hack un mainframe ?"

# Windows
.\jimmy.ps1 --quiet --system "Tu parles comme un pirate informatique des années 90" --topk 8 --chat "Comment on hack un mainframe ?"

Analyser un fichier local

Tu peux directement attacher un fichier texte (max 50 Ko) pour l'analyser :

# Linux / macOS
./jimmy.sh --quiet --file rapport_hebdo.txt --chat "Fais-moi un résumé de ce document en 3 points à puces"

# Windows
.\jimmy.ps1 --quiet --file rapport_hebdo.txt --chat "Fais-moi un résumé de ce document en 3 points à puces"

[!FEATURE]

Une intégration parfaite en CI/CD

L'un de mes cas d'usage préférés est l'intégration dans des pipelines comme GitHub Actions.

Imagine pouvoir générer automatiquement un résumé compréhensible des CHANGELOG.md à chaque nouvelle release. Le dépôt te fournit un exemple prêt à l'emploi où Jimmy est appelé dans un workflow, et son résultat est injecté directement dans le résumé de l'exécution ($GITHUB_STEP_SUMMARY) via jq.

Conclusion

Avec Jimmy, l'idée est de respecter la philosophie Unix : faire une seule chose, mais la faire bien. Sans lourdeur et avec une compatibilité maximale, cette CLI est une super solution pour automatiser tes interactions avec ChatJimmy.ai.

Si tu cherches à booster ta productivité ou à injecter un peu d'IA dans tes scripts d'admin système, n'hésite pas à cloner le dépôt, à tester tout ça et à lâcher une petite étoile sur le repo GitHub : github.com/benoitpetit/jimmy.

La raison ? J'ai osé partager Lumos sur le subreddit r/lua. Pour ceux qui débarquent, Lumos c'est mon framework CLI open-source sous licence MIT, conçu pour offrir une boucle DX complète de bout en bout en Lua. Le genre d'outil qui n'a absolument aucune concurrence dans cet écosystème et qui, disons-le franchement, enterre pas mal de standards actuels.

Au lieu d'avoir un débat technique constructif sur l'architecture, la modularité ou les features, je me suis pris une salve de reproches lunaires. Mon grand crime ? J'ai assumé avoir utilisé l'IA pour m'aider à développer ce projet.

L'attaque des vieux barbus

Je suis développeur web depuis 8 ans. Mon métier, c'est de livrer de la valeur, de concevoir des architectures qui tiennent la route et de résoudre des problèmes. Bien sûr que j'utilise l'IA comme assistant ! Pourquoi devrais-je me priver d'un outil qui me permet de prototyper à la vitesse de la lumière et de gagner un temps monstrueux sur le développement ? Pourquoi réinventer la roue en tapant du boilerplate à la main comme un moine copiste, quand je peux me concentrer sur ce qui compte vraiment : la logique métier et l'architecture logicielle.

Mais sur r/lua, j'ai eu affaire à une secte de vieux cons barbus complètement bloqués dans l'ancien temps. Pour eux, coder à la dure, la goutte au front, est une preuve de virilité technique. Refuser d'utiliser un outil de productivité en 2026, alors que l'IA est devenue le standard absolu de l'industrie, c'est de la stupidité pure et simple.

Pseudo-élitisme

L'une des remarques les plus absurdes que j'ai pu lire a été :

"Si n'importe qui peut le faire avec l'IA, en quoi Lumos serait supérieur à d'autres projets du genre ?"

La réponse à cette question est pourtant d'une logique implacable : Parce que dans l'écosystème Lua, personne d'autre ne l'avait fait avant. L'IA ne pond pas un framework modulaire toute seule. Elle ne réfléchit pas à l'expérience développeur. Je rappelle au passage que je ne vends rien. J'ai créé ce framework par passion, sur mon temps libre, pour combler un vide abyssal dans l'ecosysteme LUA.

Lumos WHOIAM ?

Parlons technique deux minutes, histoire de remettre les pendules à l'heure. Va jeter un œil au repo GitHub

Là où un outil ultra-mature comme Cobra devient vite monstrueusement verbeux, Lumos va droit au but :

-- Regardez cette concision pour créer une CLI robuste :
app:command("serve", "Démarre le serveur")
   :flag_int("--port", "Port d'écoute", 1, 65535) -- Validation native
   :use(lumos.middleware.builtin.auth({ env_var = "API_KEY" })) -- Middleware natif
   :action(function(args, flags)
       lumos.ui.progress("Démarrage en cours...", 100)
       lumos.log.info("Serveur prêt sur le port " .. flags.port)
   end)

Ce que Lumos propose nativement :

• Une API fluide (Builder pattern) qui te permet de monter une CLI complexe en quelques lignes.
• La validation stricte des arguments et des flags (fini la gestion à la main).
• Des middlewares intégrés (authentification, rate-limiting, gestion d'erreurs) que tu branches en une ligne.
• Une UI riche (couleurs, barres de progression, prompts) sans avoir à importer 40 dépendances externes comme en Node.js ou Python.
• Un système de packaging natif pour compiler ton app en un bundle autonome en quelques secondes.

Conclusion : Ciao Reddit

L'innovation fait peur à ceux qui n'arrivent plus à suivre. Le vrai problème de ces développeurs, ce n'est pas l'IA. C'est leur incapacité à accepter que les méthodes de travail évoluent, et que leur petit savoir-faire d'il y a 20 ans est en train de se faire ubériser par ceux qui savent utiliser les nouveaux outils intelligemment.

Je n'ai pas de temps à perdre avec une communauté qui préfère cracher sur un outil gratuit et performant plutôt que d'en voir le potentiel. Reddit est devenu une chambre d'écho pour les râleurs et les dogmatiques.

Lumos est là, il marche du tonnerre. Si tu veux coder des CLI en Lua test github.com/benoitpetit/lumos, n'hesite pas a faire un retour sur Mastodon.

(Si cet article ou mes outils t'ont aidé à gagner du temps, n'hésite pas à soutenir mon travail sur Liberapay ou Buy Me a Coffee.)

Salut ! Aujourd’hui, je te parle d’un projet qui me tient particulièrement à cœur : MIRA. Un système de mémoire à long terme pour les modèles de langage (LLMs), conçu pour optimiser chaque token dans la fenêtre de contexte. En gros, c’est comme un carnet de notes intelligent pour tes IA, mais en bien plus puissant et technique.

Le meilleur ? C’est 100 % local, déterministe, et open source. Pas de dépendance à des API externes, pas de black box, juste du code que tu peux auditer, modifier et héberger toi-même.

Pourquoi j’ai créé MIRA ?
Parce que je me suis rendu compte que les LLMs oubliaient trop vite. Les contextes sont limités, et pourtant, nos conversations et projets s’étalent sur des mois, voire des années. J’ai voulu donner une mémoire fiable et intelligente à mes outils.

Le problème : les LLMs ont la mémoire courte

Imagine : tu discutes avec ton IA préférée depuis des semaines sur un projet. Tu lui as expliqué tes préférences, tes choix techniques, les bugs que tu as rencontrés… Puis, pouf, tu changes de sujet ou tu ouvres une nouvelle session. L’IA a tout oublié. Frustrant, non ?

Les approches classiques comme le RAG (Retrieval-Augmented Generation) ou les fenêtres glissantes ne suffisent pas :

• RAG : on récupère les infos les plus similaires, mais sans tenir compte de leur pertinence réelle.
• Fenêtre glissante : on perd les infos anciennes, même cruciales.
• Résumé statique : ça ne s’adapte pas à la question posée.

MIRA, c’est la solution. Un système qui optimise chaque token en fonction de sa pertinence, de sa densité informationnelle, et de sa cohérence temporelle.

Comment MIRA révolutionne la mémoire des LLMs

1. L’allocation de budget de contexte (CBA)

MIRA ne se contente pas de stocker et récupérer. Il résout un problème d’optimisation sous contrainte : comment maximiser l’information utile dans une fenêtre de tokens limitée ?

Pour chaque souvenir, MIRA calcule un score composite établi sur 6 dimensions :

• Pertinence sémantique (est-ce que ça correspond à ta question ?)
• Densité informationnelle (combien de faits utiles par token ?)
• Récence (est-ce récent ou important ?)
• Recouvrement (évite de prendre deux fois la même info)
• Cohérence temporelle (est-ce que ça s’inscrit dans une histoire logique ?)
• Pénalité causale (évite les chaînes de raisonnement trop longues)

Résultat ? Tu récupères uniquement ce qui compte, sans gaspiller un seul token.

Exemple concret :
Tu demandes à ton IA : "Pourquoi on a choisi PostgreSQL ?"
MIRA va te sortir uniquement :

• La décision finale (PostgreSQL)
• Les alternatives rejetées (MySQL, MongoDB)
• Les raisons (ACID, expertise de l’équipe)
• Le lien vers la discussion originale

2. L’architecture 3 niveaux (T0/T1/T2)

Pour coller à la façon dont notre cerveau mémorise, MIRA stocke chaque souvenir en 3 formats :

Pourquoi 3 niveaux ?
Parce que notre cerveau ne mémorise pas tout avec la même précision. MIRA fait pareil : tout est accessible, mais optimisé pour l’usage.

3. Le graphe causal intégré

MIRA ne se contente pas de rappeler des faits. Il comprend les liens de cause à effet entre tes souvenirs.
Par exemple :

• "On a choisi PostgreSQL parce que l’équipe maîtrisait mieux ce SGBD."
• "Le bug a été résolu après la mise à jour de la librairie."

MIRA détecte automatiquement ces relations grâce à des motifs linguistiques (ex: "parce que", "après", "résout").

4. Un algorithme optimisé (O(n log n))

MIRA utilise :

• HNSW pour la recherche vectorielle (~0.14 ms pour 10 K vecteurs, benchmarké).
• SQLite pour le stockage (mode WAL pour la performance).
• Go pour la simplicité et la performance.

Complexité algorithmique :

• Stockage : O(1)
• Recherche : O(log n)
• Allocation de contexte : O(n²) (sélection gloutonne avec recalcule des scores)

Comment ça marche ?

Stockage d’un souvenir

# Envoi d'un souvenir à MIRA
{
  "tool": "mira_store",
  "arguments": {
    "content": "On a décidé de migrer vers PostgreSQL pour v2. Alternatives rejetées : MySQL (pas ACID), MongoDB (non relationnel). Raisons : ACID et expertise de l'équipe. Validé par CTO. Assigné à Jean.",
    "wing": "backend-team",
    "room": "database-migration"
  }
}

Récupération du contexte

# Demande de rappel, avec un budget de 2000 tokens
{
  "tool": "mira_recall",
  "arguments": {
    "query": "Pourquoi on a choisi PostgreSQL ?",
    "budget": 2000,
    "wing": "backend-team"
  }
}

Résultat :

=== CONTEXTE MIRA ===
Question : Pourquoi on a choisi PostgreSQL ? | Budget : 2000
Aile : backend-team

--- [1] EMPREINTE (45 tokens) ---
Décision : Migration PostgreSQL
Alternatives : MySQL, MongoDB
Raisons : ACID, expertise
Validé par : CTO
Assigné à : Jean

--- [2] TEXTE INTÉGRAL (120 tokens) ---
On a décidé de migrer vers PostgreSQL pour v2...
[contenu complet]

=== Total : 165/2000 tokens (8,3%) ===

[!FEATURE]

Nouveau dans la version 0.4.x

MIRA ne cesse de s’améliorer. Avec la v0.4.x, le système est passé à une recherche hybride intelligente et a gagné en performances sous charge :

🔍 Recherche hybride : quand le vectoriel rencontre le lexical

MIRA ne se contente plus de la similarité sémantique pure. Il combine désormais :

• Expansion de requête : MIRA génère plusieurs variantes de ta question et moyenne leurs embeddings pour être plus robuste, notamment en multilingue.
• Recherche lexicale FTS5 : une indexation full-text SQLite rapide pour attraper les mots exacts.
• Fusion RRF : un algorithme de fusion qui mélange intelligemment les résultats vectoriels et lexicaux.
• Clustering à la volée : déduplication automatique des souvenirs trop similaires (seuil à 0.88).
• Tags et reranker : les entités extraites boostent la pertinence, et un reranker léger réordonne les meilleurs candidats.

Pourquoi c’est cool ? Parce qu’une requête en anglais peut désormais retrouver un souvenir stocké en français avec une bien meilleure fiabilité.

⚡ Performance : plus rapide sous charge

La v0.4.1 apporte des optimisations concrètes au cœur du moteur :

• Recherche parallèle : la recherche vectorielle (HNSW) et la recherche lexicale (FTS5) tournent maintenant en parallèle au lieu d’être enchaînées. Résultat : la latence de mira_recall baisse sensiblement.
• Pool d’embeddings concurrents : au lieu de sérialiser tous les appels au modèle de langage avec un mutex global, MIRA utilise désormais un pool de 2 instances du modèle Cybertron. Plusieurs requêtes peuvent être encodées simultanément.
• HNSW affûté : les paramètres par défaut ont été revus (M=32, EfSearch=100) pour garder une recherche précise même quand la base de souvenirs grandit.

En clair : MIRA tient mieux la charge quand plusieurs outils ou agents lui parlent en même temps.

Installation et utilisation

MIRA est conçu pour être simple à déployer :

1. Installation

# Via Go
go install github.com/benoitpetit/mira/cmd/mira@latest
# Ou téléchargez les binaires depuis les releases GitHub

2. Configuration

Copiez le fichier config.example.yaml et adaptez-le à ton besoin. Exemple :

storage:
  path: "./mira-data"  # Où stocker les données
embeddings:
  current_model: "sentence-transformers/all-MiniLM-L6-v2"
allocator:
  default_budget: 4000  # Taille de la fenêtre de contexte

3. Lancement

mira --config ./config.yaml

4. Utilisation avec tes outils IA

MIRA expose un serveur MCP (Model Context Protocol), compatible avec :

• Claude Desktop
• Cursor
• Obsidian
• Votre propre outil

[!FEATURE]

Exemple avec Claude Desktop :
Dans claude_desktop_config.json :

{
  "mcpServers": {
    "mira": {
      "command": "mira",
      "args": []
    }
  }
}

Pourquoi choisir MIRA ?

• 100 % local : pas de fuite de données, pas de dépendance à des services externes.
• Déterministe : même résultat à chaque fois, pas de hasard (variance embedding < 1e-6).
• Optimisé : chaque token compte, pas de gaspillage.
• Open source : tu peux contribuer, auditer, modifier.
• Intégré : fonctionne avec tes outils existants via MCP.

Cas d’usage concrets

• Développement logiciel : garde une trace de tes décisions techniques, bugs résolus, et raisonnements.
• Gestion de projet : suis l’évolution des priorités et des choix.
• Recherche : stocke des références, des hypothèses, et des résultats intermédiaires.
• Journal personnel : un carnet de notes ultra-puissant pour tes IA.

Mon retour d’expérience

Avant MIRA : Je passais des heures à réexpliquer mes choix à chaque session. Ou alors, je devais copier-coller manuellement mes notes.
Avec MIRA : Mon IA se souvient de tout, et me rappelle les infos pertinentes en temps réel. Plus besoin de fouiller mes dossiers ou de reformuler.

Le plus marrant ? J’ai même commencé à utiliser MIRA pour mes propres notes de développement ! C’est devenu mon "cerveau externe" pour les projets perso et pro.

Comment contribuer ?

MIRA est en développement actif. Si tu veux :

• Tester et donner ton avis.
• Contribuer.
• Proposer des idées (features, améliorations).

👉 Rejoins le projet sur GitHub !

En résumé

MIRA, c’est :

• Un système de mémoire ultra-puissant pour tes LLMs.
• Un outil open source et local, pour garder le contrôle.
• Une optimisation intelligente de chaque token.

Et toi ?!

• Comment tu gères la mémoire de tes IA ?
• Tu utilises des outils similaires ?
• Tu as des besoins spécifiques en mémoire étendue ?

*P.S. : Si tu veux aller plus loin, je te conseille de checker le README de MIRA ou de fouiller dans le code.

Alors installe-toi confortablement, parce que j'ai exactement ce qu'il te faut. Aujourd'hui, je te présente XSH, mon tout nouvel outil en ligne de commande (CLI) qui va totalement changer ta façon d'interagir avec Twitter.

Fini les galères, on reprend le contrôle de notre terminal ! 🚀

XSH, c'est quoi ce truc ?

XSH (pour X Shell), c'est une interface en ligne de commande développée en Go qui te permet d'utiliser Twitter/X directement depuis ton terminal. Mais attention, c'est là que ça devient magique : il fonctionne SANS clé API.

Eh oui ! Pas de compte développeur à créer, pas de tokens OAuth complexes à générer, et surtout, pas de factures surprises. XSH utilise une authentification basée sur les cookies de ton navigateur. En gros, tu te connectes une fois, et tu es libre d'utiliser la plateforme comme un humain... mais depuis ton terminal.

Pourquoi XSH change la donne ?

Si tu as déjà essayé de créer un bot ou juste un script pour publier tes derniers articles de blog sur X, tu connais la douleur de l'API officielle actuelle. Avec XSH, j'ai voulu casser ces barrières.

Les super-pouvoirs de XSH

• 🆓 100% Gratuit : Pas de frais d'API, jamais.
• 🔑 Zéro clé API requise : Tu te connectes juste avec ta session web habituelle (via les cookies).
• 🚀 Adieu les Rate Limits stricts : Tu contournes les limites drastiques de l'API gratuite puisque tu navigues de manière "organique".
• ⚡ Ultra rapide : C'est codé en Go, démarrage en ~50ms, compilé et léger.
• 🛡️ Respect de la vie privée : Tes identifiants et tes cookies restent sur TA machine. Aucun serveur intermédiaire ne vient fouiner dans tes affaires.
• 🤖 AI-Ready : 52 outils MCP intégrés pour connecter XSH à tes agents IA (Claude, GPT, etc.).

Comment l'installer ?

Plusieurs options selon ton environnement, à toi de choisir la plus simple !

Via Go (toutes plateformes)

Si tu as Go 1.24+ d'installé sur ta machine :

go install github.com/benoitpetit/xsh@latest

Script d'installation (Linux / macOS)

Une seule commande, tout est automatique :

curl -sSL https://raw.githubusercontent.com/benoitpetit/xsh/master/scripts/install.sh | bash

PowerShell (Windows)

À lancer en tant qu'Administrateur :

iwr -useb https://raw.githubusercontent.com/benoitpetit/xsh/master/scripts/install.ps1 | iex

Depuis les sources

git clone https://github.com/benoitpetit/xsh && cd xsh && go build -o xsh .

Tu préfères un binaire pré-compilé ? Tous les builds (Linux, macOS Intel/Apple Silicon, Windows) sont disponibles directement sur la page des releases GitHub.

Exemples d'utilisation (pour kiffer)

Une fois installé, tu vas voir, c'est un jeu d'enfant. Voici un aperçu des commandes essentielles.

1. L'authentification (la magie des cookies)

Pour commencer, il faut donner à XSH l'accès à ta session :

xsh auth login

L'outil va t'accompagner pour récupérer ton cookie de session de manière sécurisée. Tu peux aussi importer un fichier de cookies exporté depuis ton navigateur :

xsh auth import cookies.json

2. Lire ton fil d'actualité

Tu veux checker ce qui se passe sans ouvrir un navigateur lourd et bourré de pubs ?

xsh feed

Et en JSON pour tes scripts et pipelines :

xsh feed --json | jq '.[].text'

3. Envoyer un Tweet depuis le terminal

L'action classique, envoyer ton message au monde entier depuis ta console préférée :

xsh tweet post "Hello World ! Ce tweet a été envoyé depuis mon terminal grâce à XSH 🚀"

Avec une image :

xsh tweet post "Regarde ce screenshot !" --image capture.png

4. Rechercher des tweets

xsh search "golang cli" --type Latest

5. Consulter un profil utilisateur

xsh user benoitpetit --json

6. Liker, retweeter, suivre

xsh tweet like <id>
xsh tweet retweet <id>
xsh follow <handle>

7. Messages directs

xsh dm send <handle> "Hey, t'as vu XSH ? 👀"
xsh dm inbox --json

8. Tweeter dans le futur (scheduled)

xsh schedule "Mon article sort demain, restez connectés !" --at "2026-04-01T09:00:00"

Tu peux l'intégrer dans tes scripts Bash, tes pipelines CI/CD, ou juste l'utiliser au quotidien entre deux git commit. Les possibilités d'automatisation redeviennent enfin fun et accessibles !

Bonus : XSH + Agents IA (MCP)

XSH embarque un serveur MCP (Model Context Protocol) avec 52 outils prêts à l'emploi pour tes agents IA. Lance-le en une commande :

xsh mcp

Ton agent IA peut ensuite lire le feed, poster des tweets, gérer les follows, les bookmarks, les listes… le tout de manière autonome. C'est du sérieux.

[!FEATURE]

🌟 Prêt à reprendre le contrôle ?

Le projet est entièrement Open Source et documenté. J'ai mis en place un site dédié où tu retrouveras toutes les commandes, les astuces d'installation et la doc complète :

👉 Découvrir le projet sur : xsh.devbyben.fr

Le code source est évidemment disponible sur mon GitHub : github.com/benoitpetit/xsh. Si le projet te plaît, n'hésite pas à aller lui mettre une petite étoile ⭐, ça fait toujours plaisir et ça aide le projet à se faire connaître !

Et comme d'habitude, si mes outils t'aident dans ton quotidien de dev et que tu veux soutenir mon travail, tu peux le faire sur Liberapay ou Buy Me a Coffee. ☕

Alors, prêt à tweeter en mode hacker ? Dis-moi ce que tu en penses sur GitHub (ou directement sur X depuis ton terminal) !

Développé avec ❤️ par la communauté open source pour un web plus libre.

Le Code, c'est personnel (et stratégique)

L'intelligence artificielle, comme GitHub Copilot, est un outil fantastique pour gagner du temps. Je suis le premier à m'en servir pour accélérer mon workflow. Mais il y a une sacrée différence entre utiliser l'IA et devenir sa nourriture.

En laissant cette option activée, tu autorises GitHub à collecter tes inputs, tes outputs et le contexte de tes projets pour entraîner ses futurs modèles.

3 raisons pour lesquelles j'ai désactivé l'option

Contrôle de la propriété intellectuelle

Mon code est le fruit de ma réflexion. Que ce soit pour un projet perso ou pro, je n'ai pas forcément envie qu'il soit fragmenté, digéré et redistribué dans les suggestions d'autres développeurs à l'avenir.

Sécurité des données

Même si les modèles tentent d'anonymiser les données, le risque "zéro" n'existe pas. On a déjà vu des IA recracher des données sensibles. Désactiver l'option, c'est s'assurer qu'aucun secret ou structure logique sensible ne quitte mon environnement de travail.

L'éthique par le consentement

Je pense qu'il est crucial de rester maître des données que nous produisons. Utiliser un service ne devrait pas automatiquement signifier céder nos droits d'apprentissage à des géants de la tech.

Comment faire pareil et reprendre le contrôle ?

Si tu veux aussi reprendre le contrôle de ton code, la manipulation prend littéralement 10 secondes :

1. Direction tes Settings sur GitHub.
2. Va dans la section Copilot (ou dans tes paramètres de confidentialité / Data).
3. Trouve la section concernant la collecte de données (Data collection) et décoche la case.

Et la meilleure partie ? Cela ne change absolument rien à la qualité des suggestions que tu recevras ! Tu gardes la puissance de l'outil, sans compromettre tes données.

Bonus : Fais le ménage dans ta télémétrie

Puisqu'on parle de confidentialité, as-tu pensé à vérifier ton éditeur de code ? Si tu utilises VS Code, Microsoft collecte par défaut des données d'utilisation et de plantage (la fameuse télémétrie).

Pour la désactiver, c'est super simple :

1. Ouvre tes paramètres (Ctrl+, ou Cmd+,).
2. Cherche telemetry dans la barre de recherche.
3. Passe le paramètre telemetry.telemetryLevel sur off.

C'est rapide, et ça fait du bien à ta vie privée.

"Utiliser l'IA ne devrait pas se faire au prix de notre confidentialité."

Alors, prêt(e) à faire le tour de tes paramètres ? Dis-moi en commentaire si tu avais déjà désactivé ces options ou si tu viens de le découvrir ! 🚀

Si cet article t'a aidé à sécuriser ton environnement, pense à soutenir mon travail : Liberapay ou Buy Me a Coffee.

J'ai la solution pour vous. Dans ce guide, on va voir comment configurer Claude Code pour qu'il tourne de manière totalement gratuite en utilisant OpenRouter. Pas d'alias compliqués à taper à chaque fois : on va passer par une configuration globale propre et efficace.

Le concept : OpenRouter comme passerelle

Par défaut, Claude Code cherche à discuter avec les serveurs d'Anthropic. L'astuce consiste à détourner cet appel vers OpenRouter, une plateforme qui centralise des dizaines de modèles (Mistral, Llama, Gemini, etc.).

L'avantage ? OpenRouter propose une tonne de modèles "Free" (gratuits). En configurant correctement votre fichier de paramètres global, Claude Code croira parler à Anthropic, mais utilisera en réalité la puissance gratuite d'OpenRouter. C'est légal, c'est efficace, et ça permet de garder une "vibe code" au top sans dépenser un centime.

Étape 1 : Installer Claude Code

Si vous ne l'avez pas encore fait, installez l'outil globalement via NPM. Ouvrez votre terminal préféré et lancez :

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

Étape 2 : Trouver votre modèle gratuit sur OpenRouter

Avant de configurer, il nous faut une cible.

1. Direction la page des modèles : openrouter.ai/models.
2. Dans la barre de recherche, tapez simplement "free".
3. Vous verrez apparaître une liste de modèles gratuits (comme google/gemini-2.0-flash-exp:free ou stepfun/step-3.5-flash:free).
4. Notez bien l'identifiant du modèle (ex: stepfun/step-3.5-flash:free).

Étape 3 : Générer votre clé API OpenRouter

Il vous faut un badge d'accès pour passer la porte :

1. Connectez-vous à votre compte OpenRouter.
2. Allez dans API Keys et créez une nouvelle clé (nommez-la "Claude Free" pour vous y retrouver).
3. Copiez-la immédiatement, car elle ne s'affichera qu'une seule fois.

Étape 4 : La configuration globale (Le "Secret Sauce")

Plutôt que de bidouiller des variables d'environnement à chaque lancement, on va modifier directement le fichier de configuration de Claude Code. C'est plus propre et ça devient votre réglage par défaut.

Le fichier se trouve généralement ici : ~/.claude/settings.json (sous Linux/macOS) ou dans votre répertoire utilisateur sous Windows.

Ouvrez ce fichier (ou créez-le s'il n'existe pas) et collez-y la structure suivante :

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://openrouter.ai/api",
    "ANTHROPIC_AUTH_TOKEN": "votre_cle_openrouter_ici",
    "ANTHROPIC_API_KEY": "",
    "ANTHROPIC_MODEL": "stepfun/step-3.5-flash:free"
  }
}

Note importante : Laissez une valeur vide dans ANTHROPIC_API_KEY. Claude Code vérifie parfois la présence d'une clé au format Anthropic avant de lancer la requête, même si OpenRouter utilise le jeton dans ANTHROPIC_AUTH_TOKEN.

Étape 5 : Testez et validez

Désormais, dès que vous tapez claude dans votre terminal, l'outil utilisera automatiquement OpenRouter et le modèle gratuit que vous avez choisi.

• Allez dans un dossier de projet.
• Lancez la commande : claude
• Posez une question : "Peux-tu m'expliquer ce fichier ?"

Si tout est bien configuré, vous aurez une réponse rapide sans que votre compte Anthropic ne soit débité.

Pourquoi utiliser cette méthode ?

• Zéro coût : Idéal pour l'apprentissage ou les petits projets.
• Transparence : Claude Code conserve toutes ses fonctionnalités (lecture de fichiers, exécution de commandes) et ça marche plutôt bien j'ai été impressionné.
• Flexibilité : Vous voulez changer de modèle ? Changez juste la ligne ANTHROPIC_MODEL dans votre fichier JSON.

Voilà, vous avez maintenant un assistant de code surpuissant et gratuit. C'est ça, la magie du web ouvert ! n'hésite pas à faire un tour sur mon blog pour d'autres astuces.

C'est le genre de dossier qui te donne envie de vider ton cache et de faire opposition sur ta carte bleue. Si t'as jamais mis un pied sur YGG — et soyons honnêtes, une bonne partie des devs francophones l'ont fait —, cet article est pour toi. Pas pour te juger, mais pour décortiquer les dessous techniques d'une opération qui est, à bien des égards, un cas d'école en cybersécurité.

La scène de crime en deux phrases

Un hacker se faisant appeler Gr0lum a compromis l'intégralité de l'infrastructure d'YGGTorrent, exfiltré les données, puis détruit les serveurs. Dans la foulée, il publie un dossier explosif baptisé YGGtorrent — Fin de partie sur le site yggleak.top, avec en bonus une archive de 11 Go disponible en torrent.

👉 YGGTorrent, pour ceux qui ne suivent pas : c'était le plus gros tracker de torrents francophone. Depuis sa création en 2017 dans le sillage de la chute de T411, il s'était imposé comme la référence du partage en France. 6,6 millions de comptes, des milliers de partageurs bénévoles, et une place au chaud parmi les 35 sites les plus visités du pays.

Et maintenant, il est mort. Alors, qu'est-ce qui s'est passé vraiment ?

La fissure : le "Turbo Mode" qui a tout fait péter

Tout commence fin 2025 avec une décision commerciale particulièrement mal dosée, dictée par l'avidité.

Le fameux "Turbo Mode", déployé le 21 décembre 2025 en pleine période de fêtes, limitait les comptes gratuits à cinq téléchargements par jour avec une attente obligatoire de 30 secondes. Le déblocage coûtait 14,99 euros par mois, ou 85,99 euros à vie.

La communauté explose. Les équipes d'uploadeurs — ceux qui font tourner le site bénévolement — protestent. Résultat, la direction purge sans sommation :

❌ La Team QTZ (3 300 torrents publiés) — bannie. ❌ La Team Forward (35 000 torrents) — bannie. ❌ La shoutbox — désactivée pour couper court aux rébellions.

D'après les bases de données exfiltrées, le chiffre d'affaires a carrément triplé en janvier 2026 pour atteindre ~490 000 euros sur ce seul mois. C'est exactement là que la tension est devenue intenable. Et c'est là que Gr0lum a décidé d'appuyer sur le gros bouton rouge.

Un détail qui illustre bien le mépris de la hiérarchie pour sa communauté : le code source de l'API révèle que les admins, modérateurs et comptes premium n'étaient jamais soumis au timer de 30 secondes ni à la limite des 5 téléchargements. Le Turbo Mode, c'était pour les autres.

Le vecteur d'entrée : un favicon sur Shodan et un port oublié

Techniquement, par où est-ce qu'on entre sur un site de cette taille ? Pas par une faille exotique. Par de la reconnaissance basique et de la négligence d'infra.

Tout commence avec le favicon hash. Chaque icône de site a une empreinte numérique unique. Gr0lum calcule le hash du favicon d'YGG et le cherche dans Shodan :

http.favicon.hash:456260082

Résultat immédiat : 188.253.108.198, le serveur de pré-production sous Windows Server 2019. Un scan Nmap révèle 13 ports ouverts, dont plusieurs qui n'auraient jamais dû être exposés sur Internet : SMB (445), RDP (3389), Redis sans authentification (6379), et surtout — SphinxQL sur le port 9306.

Sphinx Search est un moteur de recherche full-text qui utilise un protocole compatible MySQL. Sur ce serveur, il est accessible depuis Internet sans aucune authentification :

mysql -h 188.253.108.198 -P 9306
# Connexion immédiate, aucun identifiant requis

Jusque-là, on a juste un moteur de recherche ouvert. Mais SphinxQL supporte nativement CALL SNIPPETS avec le paramètre load_files=1 — une fonctionnalité prévue pour l'indexation de fichiers locaux. Quand le service tourne avec des privilèges élevés et qu'il est exposé à Internet sans restriction, ça revient à donner un accès en lecture sur tout le disque à n'importe qui :

CALL SNIPPETS(
    'C:/chemin/vers/fichier.txt',
    'users',
    'mot_cle',
    1 AS load_files,
    50000 AS around,
    0 AS limit
);

En quelques minutes, 12 fichiers de configuration sont extraits : .env avec les clés en clair, database.php avec les credentials MySQL (root, pas de mot de passe), config.php avec la clé de chiffrement CodeIgniter, les clés SMTP, hCaptcha, et la clé de signature des announces. Le code source complet de l'API future d'YGG était aussi exposé via un directory listing actif sur le port 443, .env inclus.

Mais le fichier le plus dévastateur était ailleurs.

Le sysprep qui a tout fait péter

Sur les serveurs Windows déployés automatiquement, le fichier sysprep_unattend.xml contient les paramètres d'installation, y compris parfois le mot de passe administrateur. Ce fichier aurait dû être supprimé après le déploiement :

CALL SNIPPETS(
    'C:/Windows/Panther/Unattend/sysprep_unattend.xml',
    'users',
    'password',
    1 AS load_files,
    50000 AS around,
    0 AS limit
);

Résultat :

<AutoLogon>
    <Username>Administrator</Username>
    <Password>
        <Value>&amp;)d(5Hj46B7h5^fQF^c(yKYRP</Value>
        <PlainText>true</PlainText>
    </Password>
</AutoLogon>

Le mot de passe administrateur Windows. En clair. Dans un fichier lisible sans authentification. À noter : Windows Defender était aussi désactivé (DisableAntiSpyware=true). La partie "entrée" est terminée. Tout ce qui suit, c'est de la post-exploitation.

La chaîne de compromission complète

Avec le mot de passe admin en main, Gr0lum accède au partage SMB C$ du serveur Windows — lecture et écriture sur l'intégralité du disque. C'est là que tout s'enchaîne. Le navigateur Chrome de Destroy (l'admin dev) était installé sur cette machine qu'il utilisait comme son PC de bureau perso. Les mots de passe Chrome sont chiffrés avec AES-256-GCM via DPAPI, mais avec les credentials Administrator récupérés, le déchiffrement est direct : des centaines de mots de passe en clair, des tokens de session actifs pour PayPal, Protonmail, le registrar Njalla, des forums cybercrime, et le service de DDoS stresscat.ru.

Plus utile encore : FileZilla avec ses credentials SFTP stockés en clair dans recentservers.xml. Ce fichier était la carte vers toute l'infrastructure :

• 62.112.11.32 — le serveur tracker XBT (accès obtenu, groupe root/wheel, sudo avec le même mot de passe SSH)
• 185.132.134.125 — le serveur web et la boutique WooCommerce (accès obtenu)
• 212.8.249.144 — le serveur MySQL de production, accessible uniquement en interne, atteint en pivot depuis le tracker

Depuis le tracker, un fichier /root/.my.cnf contenait les credentials MySQL de production. Une seule commande :

mysql -h 212.8.249.144 -u root -p'Ay4SDNwDvrd83qz2zVa5uCr' -e "SELECT COUNT(*) FROM yggis.users;"
# 6 629 484

La totalité de la base de données de la plateforme. En résumé, la chaîne complète ressemble à ça :

favicon hash dans Shodan
  → SphinxQL sans auth (port 9306)
    → lecture fichiers arbitraires
      → sysprep_unattend.xml = mot de passe admin Windows
        → SMB C$ = accès disque complet
          → Chrome DPAPI = coffre-fort de credentials
          → FileZilla XML = carte de l'infrastructure
            → tracker XBT (root) → pivot MySQL → 6,6M comptes
            → serveur web → boutiques WooCommerce → 89K clients

Quatre serveurs compromis, sept bases de données détruites, ~19 Go exfiltrés. Durée totale : environ 3 jours.

Ce que le dossier révèle : pas un projet communautaire, un cartel

C'est là que ça devient vraiment intéressant d'un point de vue OPSEC et investigation financière.

Le braquage financier

Le leak révèle les vrais chiffres : plus de 249 000 commandes, près de 100 000 payeurs uniques et entre 5 et 8,5 millions d'euros de chiffre d'affaires estimés sur la période 2024-2025. Face à ça ? Des coûts serveurs estimés à seulement 50 000 euros par an. Marge bénéficiaire indécente.

La lessiveuse à 36 domaines

Pour blanchir l'argent, les paiements par carte transitaient par CardsShield — un plugin WooCommerce vendu 800 dollars par mois par un vendeur vietnamien sur Telegram. Ce système automatise la rotation entre 36+ domaines proxy déguisés en boutiques e-commerce. Sur les relevés PayPal et Stripe, ton abonnement torrent apparaissait comme un achat de t-shirt sur calcilux.shop ou pocarilux.shop. Un cron WordPress tournait toutes les minutes pour basculer automatiquement vers un nouveau domaine en cas de blocage.

Huit processeurs de paiement coexistaient en parallèle : CardsShield, PayGate.to ("all high risk business models accepted"), OxaPay, NowPayments, Sellix, et d'autres. La passerelle CB centrale enigmastocks.com était enregistrée à Charlestown, Saint-Kitts-et-Nevis — paradis fiscal. Les fonds étaient ensuite convertis en crypto, passés par Tornado Cash pour couper la trace on-chain, puis transformés en Monero via ChangeNOW — la crypto intraçable par design. Des notes de dépôt Tornado Cash retrouvées sur le serveur de pré-prod confirment ~22 ETH (~42 000 dollars) déjà blanchis via le mixer, pour les seules traces retrouvées.

Le fingerprinting massif

Un fichier CSV de 259 Mo, 4 173 645 lignes, couvrant 12 mois de collecte (septembre 2024 à septembre 2025). Chaque ligne enregistrait un événement de navigation : user_id, timezone, langues du navigateur, timestamp. 543 448 utilisateurs distincts étaient trackés.

Ce n'était pas pour améliorer l'UX. La liste Accept-Language complète du navigateur — par exemple fr-FR,es-CO,es,en-GB,fr,en-US,en — combinée au fuseau horaire crée une empreinte quasi unique par utilisateur. C'était du fingerprinting systématique pour identifier les gens même derrière un VPN.

Le scan de wallets crypto que personne n'avait vu venir

Ce point est moins connu mais particulièrement retors. Un script JavaScript baptisé sci.js s'exécutait dans ton navigateur à chaque visite. Déguisé en ImageCarouselManager (une classe carousel factice de 213 lignes, jamais instanciée), il scannait silencieusement la présence de wallets crypto : Phantom (Solana), MetaMask (Ethereum), Trust Wallet, Coinbase Wallet, WalletConnect.

Si un wallet était détecté, les données partaient vers Web3stats.php (clé d'accès d3ShGIbbX3). Le script ne volait rien directement — mais il constituait une liste de qui, parmi les 6,6 millions d'utilisateurs, possède un wallet crypto et lequel. Le genre d'info qui intéresse beaucoup dans certains milieux.

Le skimmer de cartes : le truc qui fout vraiment les jetons

C'est la révélation la plus grave du dossier.

Un controller CodeIgniter de 1,6 Ko nommé Security.php, bien présent dans le code de production, recevait le numéro de carte complet (PAN), le CVV, la date d'expiration et le nom du titulaire via POST. Les données transitaient d'abord en clair par le serveur YGG avant d'être relayées vers le processeur de paiement via un formulaire caché auto-soumis. Détail révélateur : quand le token de commande était invalide, le script redirigait silencieusement vers google.com — une technique classique d'anti-analyse.

Gr0lum avance le chiffre de 54 776 cartes bancaires ainsi interceptées. Les témoignages Reddit ne manquaient pas :

"Après avoir payé du free leech la semaine dernière par PayPal, aujourd'hui 4000€ de matériel de son ont été commandés chez Thomann et livrés à une boutique inexistante du 93 sous le nom de Kevin. Ce PayPal n'avait pas été utilisé depuis plus d'un an sauf pour YGG." — u/TatonTatonne, octobre 2024

Tu vois le problème ici ? Les processeurs de paiement légitimes fournissent tous des checkouts hébergés (le modèle Stripe.js, Braintree Drop-in UI, etc.) précisément pour éviter que les données bancaires ne touchent tes serveurs. Le fait qu'YGG ait choisi de faire passer les données par sa propre machine n'est pas une maladresse technique : c'est un choix délibéré de siphonnage.

Le honeypot anti-bypass : banni sans le savoir

Ce chapitre est moins connu mais parfaitement documenté dans le leak.

Après le déploiement du Turbo Mode, un développeur a publié YGGMollo, une extension Chrome qui ajoutait un bouton pour contourner la limite des 5 téléchargements par jour. Elle a été massivement adoptée le 24 décembre 2025.

Dès le lendemain, les bans tombaient. Voilà pourquoi : un script nommé modal.min.js était chargé sur toutes les pages. Son nom était inoffensif — l'historique PowerShell du serveur révèle le renommage explicite :

Rename-Item -Path "assets\js\security.min.js" -NewName "modal.min.js"

Le contenu était obfusqué en base64. Décodé, le script attendait 2,5 secondes, cherchait la classe .yggsearch-api-btn injectée par l'extension dans la page, et si elle était détectée, soumettait silencieusement un formulaire caché vers /engine/gm. Côté serveur : log du user ID, du pseudo et de l'IP dans extension_users.txt, puis ban définitivement le compte sans avertissement. L'utilisateur découvrait son ban après coup, sans explication.

"YGG banit les comptes qui utilisent l'extension. Supprimez-la directement !!!! Désolé si vous avez été banni" — u/amottier, créateur de YGGMollo, 25 décembre 2025

YGG avait préparé le piège avant même que l'extension existe.

Les DDoS contre la concurrence

YGG ne se contentait pas d'exploiter ses utilisateurs. Un script generate-tracker-url.js retrouvé dans le code utilisait l'API du service de DDoS-for-hire russe stresscat.ru pour attaquer directement la-cale.space et sharewood.tv — deux trackers francophones présentés comme alternatives à YGG. Deux clés API documentées, des attaques de 1 800 secondes lancées via un cron toutes les 2 minutes, un fichier de 46 Mo d'URLs d'attaque générées. L'historique PowerShell confirme trois exécutions.

Technique utilisée : des URLs d'announce BitTorrent pointant vers la cible — une méthode d'amplification qui multiplie le volume d'attaque en mobilisant les clients torrent de milliers d'utilisateurs à leur insu.

Les acteurs démasqués (sans dox)

Gr0lum identifie les figures centrales sans révéler leurs identités civiles complètes, mais l'organigramme est clair :

• Oracle : l'administrateur principal. Opère exclusivement via VPN (Mullvad, M247, LeaseWeb). Une IP résidentielle marocaine (Maroc Telecom) retrouvée sur des connexions datant de 2019 le localise au Maroc à l'époque. Aucun modérateur n'a jamais échangé un message direct avec lui — son seul interlocuteur dans le staff était YggFlop.
• YggFlop / Destroy (Vladimir) : responsable du développement et de l'administration serveur, basé en France (IPs Free et SFR retrouvées). C'est lui qui utilisait le serveur de pré-prod comme son PC perso, avec son Chrome plein de credentials.

La structure était un silo parfait. Chaque modérateur recevait à son recrutement une liste de règles dont la troisième était explicite : ne pas poser de questions sur Oracle. Les modérateurs géraient des centaines de milliers d'actions de modération — gratuitement. Le top 5 du staff assurait 73% de toutes les actions de modération, pendant que les millions s'accumulaient.

Ce que contenait réellement l'archive de 11 Go

Décompressée, l'archive fait environ 30 Go et contient 12 231 fichiers dans 1 045 dossiers. Ce qui est dedans :

• ✅ Code source complet de la plateforme (PHP CodeIgniter 3, XBT Tracker C++ 2,9 Go, API Express.js)
• ✅ Bases de données du tracker, du forum XenForo, de la boutique WooCommerce
• ✅ Logs serveur et configurations
• ✅ Plus de 25 000 échanges privés internes au staff
• ✅ Projets en développement trouvés sur la pré-prod (7 projets actifs)
• ✅ Clés API de 13+ processeurs de paiement

Ce qui en a été retiré par Gr0lum (par éthique) :

• 👉 Adresses IP des utilisateurs
• 👉 Emails des membres
• 👉 Mots de passe hashés

⚠️ Attention : "retiré de la publication" ≠ "définitivement protégé". L'archive est publique, et les pseudos sont présents avec l'historique complet des téléchargements associés. Avec suffisamment d'infos croisées, la ré-identification de ton profil reste possible. Le pirate précise d'ailleurs que la moitié des mots de passe étaient encore hashés en vieux MD5 sans sel. Une aberration pour un site brassant des millions.

Le projet n'était pas en train de mourir — c'est pire

Un des éléments contre-intuitifs du dossier concerne les intentions des admins. Sur le serveur de pré-production, Gr0lum a trouvé 7 projets en dev actif : une réécriture intégrale de la plateforme YGG en SvelteKit, une autre en CodeIgniter 4 (TheRock, avec 170+ cycles de build jusqu'au 23 janvier 2026), un débrideur auto-hébergé (CloudTorrent), un nouveau tracker (RageTorrent), un forum Warez (warezfr.com, domaine acheté en ETH sur Njalla le 27 décembre 2025), un service d'IPTV (CocoTV) et une instance Mastodon privée (yeeti.io). L'historique Chrome du serveur révèle même leurs outils de développement : claude.ai, chatgpt.com, cursor.com, deepseek.com — deux réécritures en parallèle à coups de vibecoding.

Autrement dit, ils ne préparaient pas un exit scam. Ils diversifiaient leur empire. Le Turbo Mode n'était qu'une optimisation de revenus. Ils avaient un plan long terme, des millions en banque, et ils ont quand même choisi de faire transiter des numéros de CB en clair sur leurs serveurs.

La suite : ygg.gratis et le cycle des mega-trackers

Le catalogue est sauvé. L'équipe du projet U2P (Utopeer) a récupéré l'intégralité des torrents d'Ygg et les a relancés sous ygg.gratis. Les géants tombent mais renaissent rapidement — après T411, Zone-Téléchargement et Bato.to, c'est la même mécanique qui se répète.

Gr0lum a fait en sorte que les utilisateurs qui seedaient déjà les fichiers sur YGG puissent continuer à le faire via la nouvelle adresse sans modifier leur client torrent. Le site business est mort ; le contenu, non.

Ce que tu dois faire si t'étais sur YGG

Pas de panique, mais pas de passivité non plus :

1. Change tes mots de passe Si tu utilisais le même pass sur YGG que sur d'autres services (statistiquement probable), change-les maintenant. Les vieux hashes MD5 tombent en quelques secondes sur une machine moderne.

2. Vérifie HaveIBeenPwned haveibeenpwned.com — balance ton email et regarde si ça a fuité par ricochet.

3. Surveille tes relevés bancaires Si t'as un jour payé sur le site, surveille tes débits ou fais carrément opposition à ta carte. C'est le moment d'être paranoïaque.

4. Ton pseudo reste associable Même sans ton IP, ton pseudo et tes patterns de DL sont dans l'archive. Prends-en note si tu utilises le même pseudo sur GitHub ou ailleurs.

La leçon technique à retenir

Ce dossier est un audit de sécurité gratuit et sanglant. Si tu es dev et que tu touches à de l'infra, note bien ça :

Sur la sécurité serveur : SphinxQL exposé sur Internet sans auth, directory listing actif, sysprep_unattend.xml non nettoyé, Windows Firewall désactivé, Windows Defender désactivé, Redis sans mot de passe — chaque item de cette liste est une faute de base. YGG brassait des millions et ne faisait pas le minimum. Et CloudPanel non patché + PHP-FPM exposé sans ACL sur les serveurs Ubuntu = mouvement latéral immédiat. La CVE-2024-44765 date de 2024.

Sur la gestion des paiements : Ne fais JAMAIS transiter des données bancaires brutes par tes propres serveurs. Stripe, Mollie, Braintree font des checkouts hébergés pour que tu ne touches jamais au PAN. Une carte qui passe par ton backend, c'est un red flag architectural absolu. Et si tu vois une redirection silencieuse vers google.com quand un paramètre est invalide dans ton flow de paiement, pose-toi des questions.

Sur le tracking comportemental : 543 000 utilisateurs fingerprintés sur 12 mois via timezone + langues navigateur. Ce n'est pas de l'analytics. Et un script JS déguisé en carousel qui scanne tes wallets crypto en arrière-plan, c'est de la collecte de données délibérément masquée. La distinction entre "analytics" et "surveillance" est souvent une question d'intention. Là, l'intention est documentée dans le code source.

Sur les honeypots : Renommer security.min.js en modal.min.js pour pièger les utilisateurs qui contournent tes restrictions, c'est de la tromperie caractérisée. Pas une pratique de défense légitime.

Sur la confiance communautaire : Tu ne peux pas bâtir un empire financier sur le dos d'uploadeurs et de modos bénévoles que tu méprises. Quand la confiance s'effondre, elle s'effondre vite et totalement.

Verdict

YGGleak, ce n'est pas juste l'histoire d'un hack. C'est l'histoire d'une infra sous-patchée qui se croyait intouchable, d'un cartel qui dissimulait son business derrière le mot "communauté", et d'admins qui avaient l'argent pour faire les choses proprement mais ont choisi de racketter leurs utilisateurs.

Gr0lum a exposé tout ça. La méthode est violente — la publication d'une archive même partiellement anonymisée impacte des utilisateurs qui n'avaient rien demandé. Mais la documentation technique du leak est rigoureuse, les preuves sont dans le code source, et les pratiques exposées étaient réelles.

Pour toi, dev qui maintient ou construit une plateforme avec de l'auth et du paiement : relis ce writeup comme un manuel de tout ce qu'il ne faut absolument pas faire en prod. C'est gratuit, c'est complet, et c'est en ligne depuis 48 heures.

• Sources : yggleak.top — dossier complet

Ce guide, c'est l'état réel du terrain en février 2026 : données GitHub vérifiées, versions actuelles, alertes sur les projets qui dérivent, et les pépites qui montent sans faire de bruit. L'objectif : que tu saches exactement quoi installer selon ton cas d'usage, sans te faire avoir par des stars qui masquent un projet mort.

Les trois familles

👉 PaaS auto-hébergés (Coolify, Dokploy, Komodo) — Tu déploies une app depuis Git, le SSL et le reverse proxy se configurent tout seuls. Le niveau au-dessus de la gestion de containers brute.

👉 Dashboards web (Portainer, Dockge, Arcane, Dockhand) — Interface web pour gérer tes containers et stacks Compose. Du plus complet au plus minimaliste.

👉 Outils CLI/TUI (Lazydocker, Dozzle, Oxker) — Tout dans le terminal. Un binaire, zéro config, zéro serveur.

Les poids lourds (30k+ stars)

Coolify · ~50 600 · Apache-2.0

PaaS self-hosted le plus populaire, 280+ templates one-click (PostgreSQL, Redis, WordPress, n8n…), reverse proxy Traefik + SSL automatique, multi-serveurs SSH, CI/CD intégré. Le mainteneur bosse dessus à plein temps depuis 2023 — 14 535 commits, releases quasi-quotidiennes.

Version actuelle : v4.0.0-beta.463 (9 fév. 2026). Toujours en bêta après 460 itérations. La v5 annoncée comme réécriture complète ? 0 % de complétion sur le milestone GitHub. Elle n'arrivera pas avant fin 2026 au mieux. Mais la v4 est suffisamment stable pour de la production.

✅ 100 % des features gratuites, jamais de Business Edition. ❌ Gourmand en RAM sur le serveur Coolify lui-même — sépare-le de tes apps.

Lazydocker · ~49 700 · MIT · Go

Le TUI Docker le plus starré sur GitHub. Vue complète de ton environnement dans le terminal : containers, images, volumes, logs temps réel, stats CPU/mémoire, exec direct, support Compose. v0.24.4 sortie le 17 janvier 2026.

Honnêtement : le mainteneur passe l'essentiel de son temps sur lazygit (~72k stars). 193 issues ouvertes, 70 PRs en attente. Le projet vit, mais doucement.

✅ Un binaire, zéro config, intuitif dès la première utilisation. ❌ Pas de multi-host, pas d'alerting — c'est un outil de dev local, pas de prod.

Portainer · ~35 600 · Zlib · Go + React

Seul outil de cette liste à supporter Docker + Swarm + Kubernetes + Podman depuis une interface unique. Deux flux de releases actifs : 2.38.0 STS (28 jan. 2026) et 2.33.7 LTS (9 fév. 2026). Très actif.

Mais la communauté grogne. L'OIDC/SSO et le RBAC granulaire sont derrière le paywall Business Edition. La CE est limitée à 5 nœuds. Des problèmes de performance UI persistent depuis des versions.

✅ Maturité 10+ ans, multi-orchestrateurs, provider Terraform, serveur MCP. ❌ Features importantes payantes, lourd pour un homelab basique.

Dokploy · ~30 400 · Apache 2.0 + Propriétaire · TypeScript/Next.js

Lancé en avril 2024, 30k stars en moins de deux ans. PaaS concurrent direct de Coolify : déploiement d'apps, bases de données, Compose natif, Traefik v3.5 automatique, rollback basé sur registre.

❗ Alerte : La v0.27.0 (10 fév. 2026) introduit un modèle dual-licence. Un répertoire /proprietary sous licence propriétaire avec un système de clés Enterprise a été ajouté (licenses-api.dokploy.com). Le cœur reste Apache 2.0, mais la frontière glisse. À surveiller — ce genre de virage se fait rarement dans le bon sens.

✅ UI souvent saluée comme supérieure à Coolify, développement ultra-rapide. ❌ Licence inquiétante, encore pré-1.0.

Les spécialistes

Dockge · ~22 000 · MIT

Fait une seule chose bien : gérer les stacks Compose via une interface web. L'argument décisif ? Les fichiers restent sur le disque en YAML standard, pas dans une base de données propriétaire. Tu gardes une compatibilité totale avec docker compose CLI et zéro vendor lock-in. v1.5.0 (30 mars 2025), stable.

✅ File-based, léger, zéro bullshit. ❌ Pas de gestion de containers individuels, pas de CI/CD — voulu par design.

Dozzle · ~11 500 · MIT · Go + Vue.js

Viewer de logs Docker temps réel. Sa v10.0.0 (14 fév. 2026) apporte une feature qui n'existe nulle part ailleurs : requêtes SQL sur tes logs via DuckDB + WebAssembly dans le navigateur, zéro serveur supplémentaire. Image de ~7 Mo, 100M+ pulls Docker Hub, support Swarm/K8s/Podman, webhooks avec templates Go.

✅ Feature SQL unique, ultra-léger, ultra-actif (6 103 commits). ❌ Pas de stockage persistant — c'est un viewer, pas un gestionnaire.

ctop · ~17 600 · MIT

TUI style top pour metrics containers. 94 issues ouvertes sans réponse, 24 PRs en attente, ne supporte pas containerd. Les 17k stars sont un vestige. Regarde plutôt Oxker (Rust, actif).

La nouvelle garde

Beszel · ~19 400 · MIT · Go + PocketBase

0 → 19 400 stars en un an. Beszel n'est pas un gestionnaire Docker — c'est un monitoring serveur léger avec intégration Docker/Podman native. CPU, mémoire, disque, réseau, GPU (Nvidia/AMD/Intel), et stats par conteneur avec historique. v0.18.3 (1er fév. 2026). Installation en quelques minutes, agents ultra-légers.

💡 À combiner avec Dockge ou Komodo : Beszel pour les métriques, l'autre pour la gestion.

Komodo · ~10 000 · GPL-3.0 · Rust + React

Favori sur r/selfhosted et r/homelab depuis deux ans. Architecture Core + Periphery (agent Rust léger sur chaque serveur). Builds auto-versionnés depuis Git, déploiement de stacks Compose, RBAC granulaire, OAuth/OIDC, scheduling cron, audit logging, CLI km. La philosophie officielle : "Pas de limite de serveurs, jamais. Pas de Business Edition, jamais."

v1.19.0 en stable, v2 en pre-release active.

✅ Zéro paywall, backend Rust, GitOps natif, multi-serveurs illimités, RBAC complet gratuit. ❌ GPL-3.0 peut contraindre certains usages, moins mature que Portainer.

Arcane · ~4 700 · BSD-3-Clause · Go + SvelteKit

UI Svelte 5 mobile-responsive, monitoring temps réel avec graphiques dont GPU NVIDIA/AMD, gestion Compose, multi-host via agents WebSocket, SSO/OIDC gratuit sans paywall, GitOps, API REST. v1.15.2 sortie le 18 février 2026 — aujourd'hui même. 1 358 commits, cadence de release intense.

✅ UI la plus moderne de l'éco, SSO gratuit, monitoring GPU. ❌ Développeur solo (bus factor réel), Docker uniquement.

Dockhand · ~2 600 · BSL 1.1 · SvelteKit + Go

Apparu en décembre 2025, 16 releases en deux mois. Approche security-first : scan Grype/Trivy, "safe-pull protection" (scan avant déploiement), rollback automatique, image Wolfi, agent Go en connexions sortantes uniquement. v1.0.18 (16 fév. 2026).

❗ Licence BSL 1.1 = pas de l'open source au sens strict (interdit l'usage commercial en SaaS concurrent). Code source partiel (15 commits visibles).

✅ Security-first radical, SSO/OIDC gratuit, zéro télémétrie. ❌ Licence restrictive, projet très jeune.

Projets à éviter ou surveiller

Pour remplacer Watchtower : fork nicholas-fedor/watchtower (~2 700 ⭐) si tu veux l'auto-update, ou Diun (~4 200 ⭐, MIT, 17+ backends de notification) si tu préfères juste être alerté et décider toi-même.

Tableau récapitulatif (fév. 2026)

Qui choisit quoi

Dev en local, tu veux voir tes containers : → Lazydocker. Un binaire, zéro config. Ou Oxker si tu veux du Rust.

Homelab avec quelques stacks Compose : → Dockge pour la simplicité et le file-based. Arcane si tu veux une UI moderne avec le monitoring GPU en prime.

Tu veux surveiller tes serveurs : → Beszel + Dozzle. Complémentaires, ultralégers, installes les deux.

Tu déploies des apps en production sur VPS : → Coolify pour la stabilité. Dokploy si tu préfères l'UI TypeScript — mais surveille la licence. Komodo si tu veux du multi-serveurs 100 % gratuit et du GitOps.

Tu gères de l'infra équipe avec Kubernetes : → Portainer. Le seul qui couvre Docker + Swarm + K8s + Podman en une interface.

Tu cherches à remplacer Portainer sans débourser : → Komodo (GPL-3.0, tout gratuit) ou Arcane (SSO/OIDC inclus, BSD-3-Clause).

Ce qui façonne la suite

Trois mouvements structurent l'éco Docker en 2026.

La philosophie Compose-first gagne du terrain. Les configurations restent en YAML sur disque, pas dans une DB propriétaire. Dockge et Komodo incarnent ce mouvement : "Que tu comprends. Que tu peux héberger. Que tu peux quitter." Les outils qui t'enferment perdront des utilisateurs.

L'IA s'intègre, mais sous ton contrôle. Docker Inc. a lancé Gordon (agent IA dans le Desktop et le CLI). Le Docker Model Runner convertit des LLMs en containers OCI pour le local. La stack Ollama + Open WebUI est devenue le standard de facto pour faire tourner un LLM chez soi — et ça pousse les outils de monitoring à intégrer le suivi GPU nativement (Arcane, Beszel le font déjà).

La sécurité devient un différenciateur. Dockhand avec son safe-pull pre-déploiement, Docker avec ses images Hardened gratuites depuis décembre 2025, Grype/Trivy intégrés dans les nouvelles UI — ce n'est plus un bonus, c'est une attente de base.

Et l'archivage de Watchtower reste la leçon de 2025 : même à 24 000 stars, un projet peut s'arrêter du jour au lendemain. Vérifie l'activité de ce que tu mets en prod.

En bref : Ton infra, tes règles

L'écosystème de 2026 a fait le tri. Fini le temps où on installait aveuglément le repo avec le plus d'étoiles en priant pour que le développeur solo ne fasse pas de burn-out. Aujourd'hui, la tendance est brutale mais saine : on veut reprendre le contrôle.

Que ce soit via des fichiers YAML qui restent sagement sur ton disque, des métriques transparentes qui ne bouffent pas toute ta RAM, ou des licences qui ne te prennent pas en otage à la première montée en charge, le mot d'ordre est la portabilité. Si un outil commence à masquer ses features de base derrière un paywall "Enterprise" ou te force à tout migrer dans son format propriétaire, coupe court. La nouvelle garde prouve qu'on peut avoir des interfaces ultra-modernes et sécurisées sans sacrifier la philosophie de base de Docker.

L'open source est ultra-vivant, mais il est impitoyable. Reste à l'affût, lis bien les licences, et surtout : garde tes stacks portables.

La bonne nouvelle ? Il existe des contre-mesures qui marchent vraiment. La mauvaise ? La plupart des trucs qu'on te vend sont soit obsolètes, soit du pur marketing. On va démêler tout ça ensemble — la tech, les techniques d'évasion qui fonctionnent réellement, et le cadre légal en France.

L'état de l'art : les algos ont quasiment atteint le plafond

Les systèmes modernes de reconnaissance faciale (RF) ne ressemblent plus du tout aux softs "repère-le-regard" des années 2010. Aujourd'hui, tout tourne autour de fonctions de perte à marge angulaire — ArcFace, AdaFace, CosFace — entraînées sur des datasets de 42 millions d'images.

Le benchmark historique LFW (Labeled Faces in the Wild) est mort. Pas littéralement, mais les meilleurs modèles y dépassent 99,83 % de précision, ce qui le rend inutile pour discriminer les systèmes entre eux. La compétition s'est déplacée vers des benchmarks plus brutaux :

• IJB-C (conditions dégradées, nuit, flou) → ~98 % de TAR à FAR=0,01 %   
• IJB-S (surveillance réelle, caméras en hauteur) → les perfs commencent à saturer   
• CFP-FP (visages de profil vs de face) → Vision Transformers au-dessus de 99,3 %

👉 AdaFace (CVPR 2022) surpasse ArcFace sur les images de mauvaise qualité grâce à sa marge adaptative. Si t'as un visage flou, sous-exposé, pris de loin — AdaFace s'en sort quand même.

Côté industriel, NEC domine le classement NIST FRVT 1:N avec un taux d'erreur de 0,07 % sur une galerie de 12 millions de photos. Derrière eux : IDEMIA, SenseTime. Et les modèles légers (MobileFaceNets, moins d'1 million de paramètres) atteignent déjà 99,55 % sur LFW — déployables sur smartphone ou caméra embarquée.

L'anti-spoofing a aussi fait des progrès énormes : la détection de vivacité passive (analyse de texture cutanée, reflets lumineux, profondeur 3D) tourne en 1-2 secondes sur CPU basique. Plus besoin de cligner de l'œil devant une caméra — le système sait si t'es en chair et en os ou si quelqu'un présente ta photo. Le talon d'Achille reste la généralisation cross-dataset : les perfs peuvent chuter à 30-40 % d'erreur sur des données jamais vues à l'entraînement.

Le déploiement : t'es déjà dans combien de bases ?

Aéroports

La TSA américaine a déployé la RF dans 80+ aéroports fin 2024, dans le cadre d'un programme à 5,5 milliards de dollars. Le programme PreCheck Touchless ID vise 65 aéroports au printemps 2026 et traite les passagers 66 % plus vite qu'un agent humain.

À Dubaï, Emirates a installé 200+ caméras biométriques au Terminal 3 pour 23 millions de dollars. Résultat : un corridor d'immigration par IA traite 10 passagers en 14 secondes. Singapour vise 95 % de traitement automatisé d'ici fin 2026 à Changi.

Chine : l'infrastructure totale

La Chine possède entre 540 et 700 millions de caméras de surveillance. Pour donner une idée concrète : la ville de Taiyuan compte environ 119 caméras pour 1 000 habitants. Shanghai dépasse 5 000 caméras au mile carré. Le système "Skynet" est revendiqué comme le plus vaste réseau de RF mondial.

Hong Kong active en ce moment la RF sur l'ensemble de son réseau SmartView — des dizaines de milliers de caméras supplémentaires.

Supermarchés et retail

Home Depot et trois des dix plus grands distributeurs américains utilisent FaceFirst pour la prévention des vols. L'industrie a adopté le terme "face matching" pour éviter la connotation surveillance — mais c'est exactement la même techno. Auror a lancé en 2025 un système couplant RF et renseignement criminel en temps réel.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1771320663061/bc75887c-4a14-483e-bb55-436f5f04cb80.jpeg align="center")

Ce qui marche VRAIMENT contre la reconnaissance faciale

Soyons directs : la plupart des trucs qu'on te propose sont soit du marketing soit tellement obsolètes qu'ils feraient rire un stagiaire. Voici un classement honnête basé sur les études académiques de 2024-2026.

Haute efficacité prouvée

Le maquillage adversarial guidé par IA

Des chercheurs de l'Université Ben-Gourion ont développé un système qui suggère exactement où appliquer du maquillage pour tromper les algorithmes. Pas du maquillage criard — du contouring ciblé sur le nez, les sourcils et la mâchoire. Résultat mesuré : la reconnaissance chute de 47,6 % à 1,2 %. Un taux de succès de 97-99 % contre la RF.

Le point clé : ce maquillage ressemble à du maquillage normal. Tu n'as pas l'air d'un clown ou d'un personnage de film de SF. Une étude de PeopleTec (janvier 2025, arXiv:2412.13507) confirme que des perturbations cosmétiques subtiles ciblant les sourcils, l'arête nasale et la mâchoire perturbent même les systèmes commerciaux comme BetaFaceAPI et Microsoft Bing Visual Search.

Les masques à motifs adversariaux universels

Aussi de Ben-Gourion : des motifs adversariaux imprimés sur des masques en tissu qui fonctionnent sur différents porteurs. En test réel sur CCTV, le système n'a identifié que 3,34 % des participants avec le masque adversarial. Un masque chirurgical ordinaire → 83 % d'identification. Dans un monde post-COVID où le masque est socialement acceptable, c'est l'une des mesures les plus pratiques.

Les lunettes anti-IR (Reflectacles, Zenni ID Guard)

Les lunettes Reflectacles bloquent le proche infrarouge avec des absorbeurs de longueur d'onde spéciaux et un cadre rétroréfléchissant. iPhone Face ID et Windows Hello deviennent aveugles. Le stock 2025 s'est épuisé rapidement (48-188$).

Zenni Optical a lancé en juillet 2025 l'ID Guard™ — un revêtement réfléchissant l'IR à 80 % (700-1050nm) pour seulement 14,95$. Les tests 404 Media le confirment.

❌ Limite critique : ces lunettes ne protègent PAS contre les caméras en lumière visible. Elles ne sont efficaces que contre les systèmes IR (Face ID, cartographie 3D, surveillance nocturne). Si t'es dehors en plein jour, elles ne changent rien aux caméras CCTV classiques.

Efficacité moyenne et contextuelle

Les LEDs infrarouge (hoodies, casquettes)

Le principe : des LEDs IR invisibles à l'œil nu surexposent les capteurs de caméras et empêchent l'extraction des traits faciaux. Le Camera Shy Hoodie de Mac Pierce (open-source, ~200$ en composants, 12 LEDs haute puissance, microcontrôleur RP2040) et le manteau URBANGHOST de la marque allemande URBANPRIVACY intègrent cette techno.

Efficace contre les caméras de surveillance nocturne IR standard. Inefficace contre les caméras en lumière visible de jour — et surtout contre les capteurs HDR qui deviennent le standard sur les caméras haut de gamme. Pour les neutraliser, il faudrait "pomper des dizaines à centaines de watts dans l'array LED", ce qui n'est pas vraiment portable.

Les vêtements à motifs adversariaux

Cap_able (Italie, 300-770€) tisse des motifs dans du coton égyptien et revendique 60-90 % d'efficacité contre YOLO. Anti AI Clothing (USA, <100$) teste ses motifs contre Google Vision. URBANPRIVACY (Allemagne, ~30-50€) propose la collection FACEPTION.

❌ Le problème fondamental : ces motifs sont optimisés contre des algorithmes SPÉCIFIQUES. Un motif efficace contre YOLOv5 peut échouer contre YOLOv11 ou ArcFace. Les tests Mozilla (2025) concluent que ces produits sont "plus efficaces pour sensibiliser que pour changer le statu quo". C'est la vérité.

Les masques classiques

Au début du COVID, les masques chirurgicaux avaient fait monter les erreurs de RF de 5 % à 50 %. Les systèmes ont été réentraînés. L'erreur est redescendue à ~5 % pour les visages masqués. Reste utile en combinaison avec d'autres techniques.

Faible efficacité ou carrément obsolète

CV Dazzle (Adam Harvey, 2010)

Le maquillage rayé multicolore qui a marqué les années 2010 ? Il était conçu pour tromper l'algorithme Viola-Jones (haarcascade). Il est largement inefficace contre les systèmes modernes à base de CNN et de transformers. Harvey lui-même l'admet. La méthode conceptuelle reste valide, mais les looks CV Dazzle classiques ne trompent plus rien.

Fawkes (SAND Lab, UChicago)

Cet outil de cloaking d'images ajoutait des perturbations pixel pour empoisonner les données d'entraînement. Avec ~4 800 stars GitHub et 840K+ téléchargements, il a eu son heure de gloire. Il est désormais largement obsolète : pas de mise à jour significative depuis 2022, les architectures modernes (MagFace, CLIP) résistent à ses perturbations. L'étude DiffPrivate (PETS 2025) confirme que les méthodes de perturbation pixel ont une "transférabilité négligeable" en conditions réelles.

Les lasers

Inutile, dangereux et illégal. Pour des dommages permanents à une caméra, il faut une précision extrême à moins de 15 mètres. Les caméras haut de gamme ont des filtres protecteurs. Et c'est quasi-certainement une destruction de bien + entrave à un système automatisé.

La frontière académique : la prochaine génération

Ce qui sort des labos en 2024-2025 va changer la donne dans les deux à trois ans qui viennent :

Les attaques par diffusion

DiffAIM (avril 2025) manipule l'identité faciale dans l'espace latent des modèles de diffusion avec guidage adversarial par gradient. Il démontre une forte transférabilité contre les API commerciales Face++ et Aliyun — sans avoir accès au modèle cible. DiffProtect utilise un auto-encodeur de diffusion pour des perturbations sémantiquement significatives, plus naturelles que l'état de l'art. Ces méthodes rendent Fawkes complètement dépassé.

Les attaques physiques de nouvelle génération (CVPR 2025)

• ProjAttacker : projette des masques 3D adversariaux sur le visage via un projecteur — non intrusif, en temps réel, contourne à la fois la détection de vivacité et la reconnaissance   
• Patchs NIR imperceptibles : premier patch adversarial utilisant une encre absorbant l'infrarouge, invisible à l'humain → 82,46 % de succès en boîte noire dans le monde physique   
• RMA (IJCAI 2025) : première attaque ciblant simultanément les modèles de RF ET d'anti-spoofing — les attaquants s'adaptent aux défenses multicouches   
• Vêtements adversariaux thermoactivés : des teintures thermochromiques créent des motifs adversariaux à la demande — t-shirt noir normal quand inactif, activation en 50 secondes, >80 % de succès

Comportements et technique : bloquer la "zone T"

Au-delà des gadgets, il y a des comportements simples qui fonctionnent.

Identifier les bonnes caméras

Les caméras RF sont typiquement des dômes ou bullets haute résolution (2MP+) positionnées à hauteur de visage aux points d'étranglement (entrées, tourniquets, caisses). Elles ont souvent des arrays de LEDs IR visibles — un anneau de points sombres autour de l'objectif. Les CCTV classiques sont en hauteur avec un angle plongeant sous-optimal pour la RF.

La zone T est critique

La recherche LEAM (septembre 2025) a identifié que les zones du nez représentent 18,9-29,7 % des régions critiques pour la reconnaissance. Couvrir l'espace entre les yeux et le nez dégrade significativement les algorithmes. Un regard baissé de 15°+ ou un visage détourné réduit la probabilité de reconnaissance.

L'asymétrie comme arme

Les algos de RF exploitent la symétrie géométrique du visage. Appliquer des éléments asymétriques — maquillage sur un seul côté, coiffure couvrant une partie du visage, accessoires positionnés de façon asymétrique — dégrade les performances. Le conseil de l'activiste Michelle Tylicki : "Obscurcissez l'arête nasale. Appliquez des formes dans des directions inhabituelles. Les algorithmes adorent la symétrie — cassez-la."

La limite fondamentale : la surveillance multimodale

Même avec le visage entièrement masqué, la reconnaissance de démarche (gait recognition) peut identifier les individus par leurs schémas de marche. Les systèmes modernes combinent RF visible, imagerie thermique, analyse de démarche, lecture de plaques, tracking de téléphone et analyse de graphe social. Aucune contre-mesure unique ne couvre toutes les modalités.

Le cadre légal en France et en Europe

Ce que le RGPD et le Règlement IA interdisent vraiment

Le RGPD classe les données biométriques comme données sensibles (article 9). Leur traitement à des fins d'identification est interdit par principe, avec des exceptions limitées (consentement explicite, intérêt vital, intérêt public substantiel).

Le Règlement IA (entré en vigueur le 1er août 2024) a rendu applicables ses dispositions les plus strictes dès le 2 février 2025 :

• ❌ L'article 5(1)(e) interdit absolument la création ou l'extension de bases de données RF par scraping non ciblé (modèle Clearview AI)   
• ❌ L'article 5(1)(h) interdit l'identification biométrique en temps réel dans les espaces publics par les forces de l'ordre, sauf dans trois cas stricts : recherche de victimes d'enlèvement, prévention d'une menace terroriste imminente, localisation d'un suspect d'infraction grave

👉 Aucun État membre n'a encore adopté de législation nationale transposant ces exceptions. Ce qui signifie qu'en pratique, l'identification biométrique en temps réel par les forces de l'ordre dans l'espace public est effectivement interdite dans toute l'UE. C'est le bouclier le plus puissant qui existe actuellement — bien plus efficace que n'importe quel gadget.

Les sanctions : 35 millions d'euros ou 7 % du CA mondial pour les pratiques interdites. La CNIL a infligé 20M€ à Clearview AI, puis 5,2M€ supplémentaires pour non-conformité. Des sanctions similaires en Italie (20M€), Grèce (20M€), Pays-Bas (30,5M€), Royaume-Uni (7,5M£).

La VSA en France : un bilan mitigé

La loi du 19 mai 2023 relative aux JO 2024 a créé un cadre expérimental pour la vidéosurveillance algorithmique (VSA) — détection d'événements anormaux dans les flux vidéo — en excluant explicitement la reconnaissance faciale. Bilan des JO : seuls 4 des 8 cas d'usage ont fonctionné correctement. La détection d'armes déclenchait des faux positifs sur les parapluies. Un député a résumé : "Il y a un seul cas où la VSA a été utile — et c'était pour un cueilleur de champignons perdu."

L'expérimentation est prolongée jusqu'au 31 décembre 2027 via la loi sur les JO d'hiver 2030, aux mêmes conditions, sans reconnaissance faciale.

L'affaire BriefCam a révélé que la police française utilisait ce logiciel israélien (avec capacités RF) depuis 2015 sans notification à la CNIL. Un cas d'utilisation illégale a été confirmé lors des émeutes de 2023. Le tribunal administratif de Grenoble a déclaré l'utilisation de BriefCam à Moirans illégale (janvier 2025).

Ce qui est légal vs illégal pour toi

✅ Légal : maquillage adversarial, lunettes anti-IR (Reflectacles, Zenni ID Guard), vêtements à motifs — tant que le visage reste reconnaissable à l'œil humain. Ces produits sont commercialisés librement.

❌ Illégal : dissimuler son visage dans l'espace public en France (loi du 11 octobre 2010 → 150€ d'amende), sauf exceptions (santé, profession, sport, fête).

🚨 Délit : lors de manifestations, le port volontaire de tout couvre-visage destiné à éviter l'identification → 1 an de prison et 15 000€ d'amende (article 431-9-1 du Code pénal).

🟡 Zone grise : les LEDs IR portées sur soi ne sont pas spécifiquement réglementées, mais leur utilisation pour dégrader des caméras de surveillance pourrait être qualifiée de dégradation de bien (2 ans, 30 000€) ou d'entrave à un système de traitement automatisé (5 ans, 150 000€). Aucune jurisprudence spécifique en France.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1771320763824/fa8105a5-da61-4fd0-9745-20a694d5682e.jpeg align="center")

Les ressources et outils à connaître

Produits commerciaux :

• Reflectacles (48-188$) https://www.reflectacles.com   
• Zenni ID Guard (14,95$) https://www.zennioptical.com/id-guard   
• Cap_able (300-770€) https://www.capable.design   
• Anti AI Clothing (<100$) https://antiai.biz   
• URBANPRIVACY (30-50€ pour les t-shirts). https://urban-privacy.com

La conclusion : la combinaison est la seule stratégie

En 2026, aucune technique unique ne garantit l'anonymat face à un système de surveillance bien financé. Les systèmes de NEC ou IDEMIA combinent RF visible, infrarouge, détection de vivacité et analyses multimodales. Un seul gadget ne couvre pas tout ça.

Trois choses à retenir :

• 1. Combine les approches. Maquillage subtil ciblant l'arête nasale + lunettes anti-IR + comportement d'évitement (regard à 15°, asymétrie) → protection largement supérieure à n'importe quelle mesure isolée.   
• 2. Les attaques par diffusion changent la donne pour les photos en ligne. DiffAIM et DiffProtect produisent des modifications faciales naturelles qui trompent les systèmes commerciaux en boîte noire. Fawkes est mort, mais ses successeurs sont bien plus puissants.   
• 3. Le droit européen est ton meilleur bouclier. L'interdiction du Règlement IA couplée à l'absence de transposition nationale des exceptions crée un environnement où la RF dans l'espace public est de facto interdite pour les forces de l'ordre dans toute l'UE. C'est plus robuste que n'importe quel hoodie à LEDs.

Comme le dit l'activiste Evan Greer (Fight for the Future) :

"Les gens ne devraient pas avoir à porter des lunettes spéciales ou des masques quand ils sortent de chez eux pour protéger leurs libertés civiles fondamentales." Evan Greer

La bataille se joue autant dans les labos et les boutiques que dans les parlements et les tribunaux. Et c'est dans ces derniers que les victoires les plus durables sont remportées.

Alors, la prochaine fois que vous passerez sous l'œil d'un dôme en verre dans le métro, souvenez-vous : l'anonymat en 2026 n'est plus un droit acquis, c'est une partie d'échecs permanente entre votre visage et le silicium.

Sauf que contrairement aux solutions propriétaires qui te verrouillent dans leur écosystème (coucou Devin avec ses plans à 20-500$/mois), OpenHands te donne les clés du camion : code open-source sous licence MIT, compatible avec n'importe quel LLM, et des perfs qui explosent les benchmarks. En février 2026, on parle d'un outil qui atteint 80,9% de résolution sur SWE-bench Verified avec Claude Opus 4.5 — des chiffres qui auraient semblé impossibles il y a seulement un an.

Alors, assieds-toi confortablement avec ton café, parce qu'on va décortiquer ce monstre technologique qui pourrait bien révolutionner ta façon de coder.

C'est quoi exactement, ce truc ?

OpenHands (anciennement OpenDevin), c'est pas juste "un autre copilote qui te suggère du code". C'est un agent autonome qui travaille comme un vrai développeur :

• Il lit ton code et comprend l'architecture de ton projet
• Il exécute des commandes dans un terminal (bash, npm, pip, tout ce que tu veux)
• Il navigue sur le web pour chercher de la doc ou des solutions
• Il teste son propre code et itère jusqu'à ce que ça marche
• Il pousse des PRs directement sur GitHub/GitLab

En gros, tu lui files une issue GitHub du style "Bug : la pagination ne fonctionne pas sur mobile", et il se démerde tout seul pour :

1. Analyser le code existant
2. Identifier le problème
3. Coder le fix
4. Tester que ça marche
5. Te pondre une PR clean avec des tests

Et tout ça pendant que tu scroll sur Reddit. Le futur, quoi.

Les chiffres qui font mal (aux concurrents)

OpenHands, c'est pas du vent marketing. Les benchmarks parlent d'eux-mêmes, et les chiffres de février 2026 sont tout bonnement hallucinants.

SWE-bench Verified : Le Boss de fin de niveau

SWE-bench, c'est le benchmark de référence pour tester les agents IA sur des vraies issues GitHub. Des bugs réels, des repos réels, des tests réels. Pas de la bidouille. Mais il y avait un problème : le benchmark original contenait des issues mal définies ou carrément insolubles même pour des humains.

C'est pour ça qu'SWE-bench Verified est né : 500 instances filtrées et validées par des humains. C'est sur ce terrain assaini que se joue la vraie compétition.

L'évolution fulgurante d'OpenHands :

• Juillet 2025 : ~65% (déjà pas mal)
• Février 2026 avec Claude Opus 4.5 : 80,9% 🔥
• Février 2026 avec GPT-5.2 Codex : 80,0%
• Février 2026 avec Gemini 3 Flash : 78,0%

Pour te donner une idée de la progression : il y a 18 mois, les meilleurs agents peinaient à atteindre 20%. Aujourd'hui, on parle de 8 issues sur 10 résolues automatiquement. C'est carrément dingue.

Pour te donner une idée de la progression : il y a 18 mois, les meilleurs agents peinaient à atteindre 20%. Aujourd'hui, on parle de 8 issues sur 10 résolues automatiquement. C'est carrément dingue.

Le secret sauce : l'Inference-Time Scaling

Cette performance de malade, c'est pas juste grâce aux nouveaux LLMs. OpenHands a intégré une technique de ouf appelée Inference-Time Scaling (ou Best-of-N).

Le principe ? Au lieu de générer une seule solution, l'agent en génère plusieurs (genre 5), puis utilise un modèle "Critique" entraîné spécifiquement pour sélectionner la meilleure. C'est comme avoir 5 dev juniors qui bossent en parallèle, et un senior qui choisit le meilleur code.

Résultat concret :

• Avec 1 tentative : 60,6%
• Avec 5 tentatives + modèle critique : 66,4%
• Soit +5,8 points juste en investissant plus de temps de calcul

En 2026, cette stratégie est devenue native dans OpenHands. Tu transformes littéralement du temps de calcul en précision.

LiveSWEBench : La vraie vie, pas les benchmarks bidons

Le problème avec les benchmarks classiques, c'est qu'ils datent. Les modèles s'entraînent dessus, et ça biaise les résultats (contamination des données).

LiveSWEBench, c'est différent : des issues GitHub créées après la date de coupure des LLMs. Impossible de tricher.

Résultat ? OpenHands maintient un taux de réussite stable même sur des problèmes ultra-récents. Pas de chute de perf, pas de triche. Juste de la puissance brute.

OpenHands Index : Le test multi-compétences

Parce que coder, c'est pas que résoudre des bugs, OpenHands a lancé son propre benchmark complet :

1. Résolution d'issues (SWE-bench) ✅
2. Développement frontend (SWE-bench Multimodal) 🎨
3. Création de tests (SWT-bench) 🧪
4. Développement greenfield (projets from scratch) 🌱
5. Recherche d'informations (GAIA) 🔍

Claude Opus 4.5 et GPT 5.2 Codex dominent, mais devine quoi ? OpenHands fonctionne avec les deux. T'es pas bloqué avec un seul modèle.

L'architecture V1 : Un coup de génie

En novembre 2025, l'équipe OpenHands a sorti la version 1.0 avec une refonte complète de l'architecture. Fini le monolithe bordélique, bienvenue dans le modulaire bien pensé.

Les problèmes de la V0 (ou comment ne pas architecturer un projet)

La V0, c'était un peu le prototype fait à l'arrache pendant des vacances à Aruba (dixit les devs eux-mêmes 😅). Ça marchait, mais :

• EventStream asynchrone de l'enfer : messages qui arrivent dans le désordre, bugs de threading, galère totale
• 10 GB de Docker image : parce que pourquoi pas inclure un client YouTube API ? 🤷
• Dépendances transitives à gogo : installation de plusieurs minutes
• Couplage serré : impossible de sortir un bout sans tout casser

Bref, pas terrible pour scaler.

La V1 : SDK modulaire et propre comme un sou neuf

L'architecture V1 repose sur 4 packages Python hyper-propres, installables indépendamment via pip ou uv. C'est pas juste une refonte cosmétique — c'est un changement de paradigme complet basé sur l'Event Sourcing et la séparation stricte des responsabilités.

1. Agent SDK (openhands-sdk)

Le cœur du réacteur. Ultra-léger, tu peux créer un agent en quelques lignes :

from openhands.sdk import Agent

agent = Agent(
    model="anthropic/claude-sonnet-4-20250514",
    tools=["bash", "edit", "browser"]
)

result = agent.run("Fix the pagination bug on mobile")
print(result)

C'est tout. Pas de config yaml de 300 lignes, pas de magie noire. Juste du Python propre avec des modèles Pydantic pour la sécurité des types.

La vraie magie : L'Event Sourcing. L'état de l'agent n'est pas une variable mutable qui peut partir en cacahuète. C'est la somme immuable d'événements enregistrés dans un bus. Chaque action, chaque observation, chaque pensée du modèle = un événement typé.

Les bénéfices concrets :

• ✅ Déterminisme total : tu peux rejouer exactement une session pour comprendre ce qui s'est passé
• ✅ Reprise sur erreur : crash du processus ? L'agent se reconstruit en rejouant l'historique
• ✅ Auditabilité : trace d'audit inaltérable de toutes les modifs (crucial en entreprise)

2. Tools Package (openhands-tools)

Les outils que l'agent peut utiliser, mais version durcie et sécurisée :

• Bash : exécuter des commandes système
• Edit : modifier des fichiers (avec diff, regex, tout ça)
• Browser : naviguer sur le web, cliquer, remplir des formulaires
• MCP (Model Context Protocol) : intégrations avec des services externes

L'innovation majeure : Chaque interaction suit le pattern Action → Execution → Observation. C'est atomique et structuré, ce qui facilite grave le raisonnement du modèle.

Et le truc de fou : l'intégration native du MCP. Ton agent peut se connecter dynamiquement à n'importe quel serveur compatible MCP — PostgreSQL, Notion, serveur de logs, monitoring, etc. — sans modifier le code source. C'est ça qui transforme OpenHands d'un simple "codeur" en orchestrateur de systèmes complets.

3. Workspace Package (openhands-workspace)

C'est peut-être ici que la rupture avec le passé est la plus visible. Non, OpenHands ne nécessite PAS toujours Docker.

Ce paquet abstrait totalement le lieu d'exécution :

• DockerWorkspace : Pour l'exécution sécurisée de code non fiable (sandboxing complet)
• LocalWorkspace : Exécution directe dans le processus hôte (pratique pour CI/CD ou dev rapide)
• RemoteWorkspace : Orchestration à grande échelle sur Kubernetes, séparant le "cerveau" de l'agent de son "corps" exécutant

Choisis ton poison selon le contexte. Plus de galère à gérer Docker quand t'en as pas besoin.

4. Agent Server (openhands-agent-server)

L'API REST/WebSocket pour piloter ton agent à distance. Conçu autour de FastAPI et des WebSockets, ce composant transforme les primitives du SDK en une API multi-utilisateurs robuste.

C'est cette brique qui propulse les offres SaaS comme OpenHands Cloud, gérant :

• Authentification
• Isolation des sessions
• Persistance des états
• Déploiements de milliers d'agents distribués

L'architecture Event Sourcing : Pourquoi c'est révolutionnaire

Dans les systèmes précédents, l'état de l'agent était une variable mutable stockée en mémoire. Résultat : conditions de course, incohérences, crashs inexplicables.

Avec l'Event Sourcing, l'état est dérivé d'une série immuable d'événements. Exemple de timeline :

Event 1: UserMessage("Fix bug #123")
Event 2: AgentThought("Je vais d'abord lire le fichier concerné")
Event 3: BashAction("cat src/components/Pagination.tsx")
Event 4: BashObservation("... code du fichier ...")
Event 5: AgentThought("J'ai trouvé le bug ligne 42")
Event 6: EditAction("modifier ligne 42...")
Event 7: EditObservation("Modification réussie")
...

Chaque événement est typé, horodaté, et immuable. L'état actuel = rejeu de tous ces événements.

C'est exactement la même philosophie que Git : tu peux revenir en arrière, créer des branches, merger des historiques. Sauf que là, c'est pour le comportement de ton agent IA.

La bataille des LLMs en 2026 : Quel modèle choisir ?

La performance d'OpenHands dépend directement du LLM que tu branches derrière. Et en février 2026, la hiérarchie a complètement explosé. Dire "GPT-4 est le standard" en 2026, c'est comme dire que tu codes encore en PHP 5. On est entrés dans l'ère de GPT-5.2, Claude Opus 4.5 et Gemini 3.

Claude Opus 4.5 : Le roi de la fiabilité

Si on doit désigner un champion actuel, c'est lui. Claude Opus 4.5 (sorti en novembre 2025) domine les classements de fiabilité.

Performances :

• 80,9% sur SWE-bench Verified (record absolu)
• Excellence sur la manipulation de structures de fichiers complexes
• Résilience exceptionnelle face à la "dérive de contexte" sur les longues sessions

Pourquoi il cartonne ? Son architecture est optimisée pour maintenir le contexte sur de longues séquences. Le problème classique des agents, c'est qu'au fil des modifications, ils "oublient" les contraintes initiales ou la structure du projet. Opus 4.5 résiste à ça comme un champion.

Cas d'usage idéaux :

• ✅ Refactoring de systèmes critiques
• ✅ Correctifs de sécurité (zéro tolérance aux hallucinations)
• ✅ Navigation dans des codebases labyrinthiques

Le prix de l'excellence : C'est le modèle le plus cher. Mais pour les tâches critiques, ça se justifie.

GPT-5.2 Codex : Vitesse et endurance

OpenAI a répondu avec GPT-5.2 Codex en février 2026. Statistiquement à égalité avec Opus (80,0% sur SWE-bench), mais avec un profil différent.

Son super-pouvoir : L'endurance sur les tâches Greenfield (création de projets from scratch).

Sur l'OpenHands Index, GPT-5.2 surpasse ses concurrents sur les horizons longs — genre construire une appli web complète à partir d'une spéc textuelle. Il maintient une "vision architecturale" cohérente sur des sessions de plusieurs heures, là où d'autres modèles introduisent des incohérences cycliques.

L'argument économique :

• Prix des tokens d'entrée : 65% moins cher que Claude Opus 4.5
• Idéal pour les déploiements à grande échelle

Cas d'usage idéaux :

• ✅ Génération de boilerplate / microservices
• ✅ Projets longs nécessitant cohérence architecturale
• ✅ Volumes massifs (CI/CD, automatisation)

Gemini 3 Flash : La surprise efficacité

Google a frappé fort avec Gemini 3 Flash. Avec 78% sur SWE-bench Verified, il offre des performances "quasi-Pro" à une fraction du coût.

Son atout secret : Une latence minimale. Parfait pour le "Vibe Coding" — ces boucles de dev interactives où tu collabores en temps réel avec l'agent.

Les capacités "Deep Think" : Mode de raisonnement approfondi activable à la demande pour gérer les pics de complexité, sans payer systématiquement un modèle plus lourd.

Cas d'usage idéaux :

• ✅ Développement interactif rapide
• ✅ Pipelines CI/CD (analyse de milliers de tests)
• ✅ Projets où la latence compte

Les alternatives Open Source

Pour les entreprises avec des contraintes strictes de confidentialité (déploiement On-Premise), l'open source est devenu crédible :

DeepSeek v3.2 Reasoner

• Score : 60% sur SWE-bench Verified
• Le "Thinking Mode" dans l'open source
• Sa verbosité = processus de vérification interne qui réduit les erreurs logiques

Qwen3-Coder (Nebius)

• Score : ~60% après Rejection Fine-Tuning
• 67 000 trajectoires publiques pour entraîner tes propres modèles
• Alternative crédible pour se passer des API américaines

Tableau comparatif (Février 2026)

Le vrai avantage d'OpenHands ? T'es pas bloqué avec un seul modèle. Contrairement à Claude Code (Anthropic only) ou GitHub Copilot (GPT only), tu choisis le "cerveau" selon la tâche :

• Opus pour la précision chirurgicale
• GPT-5.2 pour la construction massive
• Gemini Flash pour la réactivité

C'est cette flexibilité model-agnostic qui constitue l'avantage compétitif durable en 2026.

Comment ça marche concrètement ?

Allez, on rentre dans le vif du sujet.

Étape 1 : Installation

Choisis ton poison selon ton cas d'usage :

Option A : CLI léger (pour dev en local)

pip install openhands-cli

Option B : SDK complet (pour intégrer dans ton app)

pip install openhands-sdk openhands-tools openhands-workspace

Option C : Docker all-in-one (pour tester vite fait)

docker pull ghcr.io/openhands/openhands:latest
docker run -it --rm -p 3000:3000 ghcr.io/openhands/openhands:latest

Étape 2 : Configuration du modèle

OpenHands est model-agnostic. Tu peux utiliser :

• Claude (Anthropic) : anthropic/claude-sonnet-4-20250514
• GPT (OpenAI) : openai/gpt-5.2-codex
• Gemini (Google) : google/gemini-3-pro-preview
• DeepSeek : deepseek/deepseek-v3.2-reasoner
• Qwen : qwen/qwen-max-instruct
• LLMs locaux avec Ollama, LM Studio, etc.

Exemple de config :

import os
from openhands.sdk import Agent

agent = Agent(
    model="anthropic/claude-sonnet-4-20250514",
    api_key=os.getenv("ANTHROPIC_API_KEY"),
    tools=["bash", "edit", "browser"],
    sandbox="docker"  # ou "local" si t'as la foi
)

Étape 3 : Lancer une tâche

Scénario 1 : Résoudre une issue GitHub

from openhands.sdk import Agent

agent = Agent(model="anthropic/claude-sonnet-4-20250514")

result = agent.run(
    task="""
    Résous l'issue #1234 du repo github.com/benoitpetit/mon-projet
    
    Issue : "La pagination ne fonctionne pas sur mobile (écrans < 768px)"
    
    Tu as accès au repo, fait ce qu'il faut :
    - Clone le repo
    - Identifie le bug
    - Code le fix
    - Teste que ça marche
    - Crée une PR avec des tests
    """
)

print(result.summary)
# Sortie :
# "Bug corrigé. PR créée : github.com/benoitpetit/mon-projet/pull/42"

Scénario 2 : Créer une feature from scratch

result = agent.run(
    task="""
    Crée un endpoint REST API en FastAPI pour gérer des utilisateurs :
    - POST /users (créer)
    - GET /users/{id} (lire)
    - PUT /users/{id} (modifier)
    - DELETE /users/{id} (supprimer)
    
    Utilise SQLAlchemy + PostgreSQL, ajoute des tests avec pytest,
    et crée un Dockerfile pour déployer l'app.
    """
)

L'agent va :

1. Créer la structure du projet
2. Coder les routes FastAPI
3. Configurer SQLAlchemy
4. Écrire les tests
5. Générer un Dockerfile
6. Tout tester

En 5-15 minutes. Sans toi.

Les fonctionnalités qui tuent

1. Gestion multi-repo

T'as un monorepo avec 50 packages ? Pas de problème.

agent.run(
    task="Upgrade tous les packages de @types/* vers leur dernière version dans tous les sous-projets",
    repos=[
        "github.com/company/frontend",
        "github.com/company/backend",
        "github.com/company/mobile"
    ]
)

OpenHands va :

• Cloner les 3 repos
• Analyser les package.json
• Updater les dépendances
• Tester que rien casse
• Créer 3 PRs séparées

2. Intégrations CI/CD natives

OpenHands s'intègre direct avec :

• GitHub Actions : auto-review de PRs, fix de tests cassés
• GitLab CI : génération de pipelines, debug d'erreurs
• Jenkins : analyse de logs, suggestion de fix

Exemple GitHub Action :

name: OpenHands Auto-Fix
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  auto-fix:
    runs-on: ubuntu-latest
    steps:
      - uses: openhands/action@v1
        with:
          task: "Review cette PR et fix les tests qui cassent"
          model: "anthropic/claude-sonnet-4-20250514"
          api_key: ${{ secrets.ANTHROPIC_API_KEY }}

3. Debugging assisté

T'as une erreur de prod incompréhensible dans tes logs Sentry ?

agent.run(
    task=f"""
    Analyse ce stack trace et trouve la cause :
    
    {sentry_error_logs}
    
    Ensuite :
    1. Identifie la root cause
    2. Code un fix
    3. Ajoute un test pour éviter la régression
    4. Crée une PR
    """
)

4. Documentation auto-générée

Ton boss te harcèle pour de la doc ? Délègue.

agent.run(
    task="""
    Génère une documentation complète pour ce projet :
    - README avec quickstart
    - API reference
    - Guide de contribution
    - Architecture overview
    
    Utilise les commentaires du code et l'historique git pour tout comprendre.
    """
)

Les cas d'usage réels (pas du bullshit marketing)

US Mobile : De 8 points à 2 points d'effort

Cas concret : Ajouter un dashboard analytics dans leur plateforme interne.

Avant OpenHands :

• Estimation : 8 story points (environ 2 semaines)
• 1 dev à temps plein

Avec OpenHands :

• L'agent a bossé 15 minutes en autonome
• Le dev a passé 1h à review et ajuster des edge cases
• Nouvelle estimation : 2 story points

Citation du dev :

"OpenHands est incroyablement décisif. D'autres solutions tournent en rond... alors qu'OpenHands fonce droit au but."

Nebius : 67K trajectoires pour entraîner des modèles

L'équipe Nebius a utilisé OpenHands pour générer 67 074 trajectoires de résolution d'issues GitHub. Ces données ont servi à fine-tuner Qwen3-Coder :

• 50,3% de réussite sur SWE-bench Verified avec un modèle 30B
• 61,7% de réussite avec un modèle 235B

OpenHands devient un outil de recherche pour améliorer les LLMs eux-mêmes.

Comparaison avec la concurrence (édition 2026)

L'économie en 2026 :

Devin a clarifié son modèle :

• Plan Core : 20$/mois (freelances, petites équipes)
• Plan Team : 500$/mois (features entreprise, API étendue)

OpenHands fonctionne différemment : modèle "Bring Your Own LLM".

• Tu paies uniquement les tokens consommés auprès du fournisseur de ton choix
• Pour un usage intensif, GPT-5.2 Codex est 65% moins cher qu'Opus
• Pour les tâches critiques, tu peux basculer sur Opus ponctuellement

Exemple concret :

• Issue moyenne : 100K-500K tokens
• Avec GPT-5.2 : ~0,50-2,50$ par issue
• Avec Claude Opus 4.5 : ~1,50-7,50$ par issue
• Avec Gemini Flash : ~0,30-1,50$ par issue

Compare ça aux 500$/mois de Devin Team, et fais le calcul selon ton volume.

Le verdict 2026 : Si tu aimes la liberté, le contrôle total, et les performances de pointe, OpenHands écrase tout. Devin reste pertinent pour les équipes qui veulent du plug-and-play sans gérer l'infra.

Les limites (parce qu'on est honnêtes)

Soyons clairs, OpenHands c'est pas la solution à tous tes problèmes.

1. Coût des LLMs

Si tu utilises Claude Opus ou GPT-5, ça peut vite chiffrer. Une issue complexe peut consommer 100K-500K tokens.

Solution : Utilise des modèles moins chers pour les tâches simples (DeepSeek, Qwen), et réserve les gros modèles pour le debug hardcore.

2. Fiabilité variable selon le modèle

OpenHands est aussi bon que le LLM derrière. Avec Claude Sonnet 4 ou GPT-5.2 Codex, c'est du caviar. Avec Llama 3 8B, c'est... moyen.

3. Pas de support natif pour UI/UX

L'agent galère encore sur les tâches nécessitant du design sense. Il va te pondre un formulaire qui marche, mais pas forcément joli.

4. Courbe d'apprentissage pour les prompts

Donner des instructions claires à l'agent, c'est un art. Si tu dis "fix the bug", il va galérer. Si tu dis "the pagination component in src/components/Pagination.tsx doesn't handle edge case when totalPages=0", ça roule.

Comment bien utiliser OpenHands (tips de pro)

Tip #1 : Sois spécifique dans tes prompts

❌ Mauvais :

Fix the authentication

✅ Bon :

Le JWT token n'est pas rafraîchi automatiquement. Quand l'access token expire (après 15min),
l'utilisateur est déconnecté brutalement. 

Implémente un refresh token automatique dans src/auth/token-manager.ts.
Utilise axios interceptors pour capter les 401 et refresh avant de retry la requête.

Tip #2 : Utilise le mode step-by-step pour les tâches complexes

agent.run(
    task="Migre la base de données de MySQL vers PostgreSQL",
    mode="step-by-step",  # L'agent va te demander validation à chaque étape
    max_iterations=50
)

Tip #3 : Active le logging détaillé

agent.run(
    task="...",
    log_level="DEBUG",  # Tu verras toutes les étapes de raisonnement
    output_dir="./logs"
)

Tip #4 : Combine avec tes outils existants

OpenHands n'est pas là pour tout remplacer. Utilise-le en complément :

• Cursor/Windsurf pour l'écriture de code interactive
• OpenHands pour les tâches lourdes et répétitives
• Review manuelle pour valider les PRs critiques

Le futur d'OpenHands

L'équipe bosse sur des trucs de ouf :

1. Multi-agent orchestration

Plusieurs agents spécialisés qui collaborent :

• Agent Backend : API et BDD
• Agent Frontend : UI/UX
• Agent DevOps : CI/CD et infra
• Agent QA : Tests et validation

Tous coordonnés par un agent "chef de projet".

2. Fine-tuning spécialisé

Des modèles OpenHands custom, entraînés sur :

• Ton codebase spécifique
• Tes patterns de développement
• Tes guidelines internes

Imagine un agent qui connaît tes conventions de code par cœur.

3. Support mobile natif

Actuellement, OpenHands excelle sur le backend. Bientôt, il saura aussi coder des apps iOS/Android.

Conclusion : La révolution est déjà là (et elle va vite)

OpenHands en février 2026, c'est pas de la science-fiction. C'est dispo maintenant, c'est gratuit (MIT), et ça marche vraiment.

Résumons ce qu'on vient de voir :

• 80,9% de résolution sur SWE-bench Verified (avec Claude Opus 4.5)
• Architecture V1 modulaire basée sur l'Event Sourcing
• Model-agnostic : choisis le LLM selon la tâche et le budget
• MCP natif : se connecte à ton écosystème existant
• 65K+ ⭐ GitHub et une communauté massive

Est-ce que ça va remplacer les devs ? Non. Mais ça va changer notre métier. Les devs qui refusent d'utiliser ces outils vont se retrouver à pondre du code boilerplate pendant que d'autres shipent des features 10x plus vite.

Ce qui a changé en 18 mois :

• Mi-2024 : Les agents peinaient à 20% de réussite
• Début 2026 : On explose les 80% avec les bons modèles
• L'architecture est passée d'un prototype à un SDK production-ready
• L'intégration MCP ouvre des possibilités infinies

Mon conseil : Teste-le sur un side-project ce week-end. Donne-lui une issue pas trop critique, et regarde-le bosser. Tu vas être bluffé.

Et si t'es encore sceptique, rappelle-toi qu'OpenHands résout 8 issues GitHub sur 10. Combien de tes collègues devs peuvent en dire autant ? 😏

La vraie question : C'est plus "est-ce que je devrais utiliser des agents IA ?", c'est "comment je les intègre intelligemment dans mon workflow ?". Parce que dans 12 mois, ceux qui seront restés à l'écart auront pris un retard considérable.

Bienvenue dans l'ère des agents autonomes. 🚀

Liens utiles

• Site officiel : openhands.dev
• GitHub : github.com/OpenHands/OpenHands (65K+ ⭐)
• Documentation : docs.openhands.dev
• Slack communauté : Rejoins 10K+ devs qui expérimentent
• Benchmarks : OpenHands Index

Allez, go tester, et viens me dire en commentaire si t'as réussi à le faire planter. Spoiler : c'est dur. 🚀

Si t'es du genre à aimer le contrôle total sur ton infrastructure, la vie privée de tes utilisateurs et les solutions open-source, accroche-toi parce que je vais te présenter un projet qui va te faire vibrer. Altcha, c'est pas juste un énième CAPTCHA, c'est carrément une révolution dans la protection anti-spam.

Pourquoi les CAPTCHA classiques, c'est de la m*rde ?

Bon, soyons honnêtes deux secondes. Les CAPTCHA traditionnels (ouais, je parle de toi, reCAPTCHA), c'est :

• Chiant pour l'utilisateur : Qui a envie de passer 5 minutes à identifier des panneaux de signalisation juste pour envoyer un formulaire de contact ? Personne.
• Pas respectueux de la vie privée : Google, Cloudflare et compagnie adorent tracker tes utilisateurs avec leurs CAPTCHA. Cookies, fingerprinting, tout y passe.
• Pas accessible : Les personnes malvoyantes ou utilisant un lecteur d'écran ? Bonne chance avec les puzzles visuels.
• Gourmand en ressources : Ces trucs chargent des tonnes de scripts externes qui plombent les perfs de ton site.
• Dépendance à des tiers : T'es à la merci de Google ou Cloudflare. Si leur service tombe, ton site aussi.

Bref, c'est pas génial. Et c'est là qu'Altcha débarque comme un super-héros de l'open-source.

Altcha, c'est quoi exactement ?

Altcha, c'est une alternative gratuite, open-source et auto-hébergeable aux CAPTCHA classiques. Contrairement aux solutions traditionnelles, Altcha utilise un mécanisme de preuve de travail (Proof-of-Work, ou PoW) léger. En gros, au lieu de te faire cliquer sur des images, ton navigateur résout un petit challenge cryptographique pour prouver que t'es humain.

Et le meilleur dans tout ça ? Pas de cookies, pas de tracking, pas de collecte de données perso. C'est conforme RGPD, WCAG 2.2 AA, et même à l'European Accessibility Act. En clair, c'est clean, éthique, et ça respecte vraiment tes utilisateurs.

Les points forts d'Altcha

• ✅ Respect de la vie privée : Zéro tracking, zéro cookie, zéro donnée perso collectée.
• ✅ Open-source : Code disponible sur GitHub, licence MIT. Tu peux l'auditer, le modifier, le forker.
• ✅ Auto-hébergé : Tu gardes le contrôle total. Pas de dépendance à un service tiers.
• ✅ Léger : Seulement 30 KB en gzippé (90% plus léger que reCAPTCHA).
• ✅ Accessible : Support de 50+ langues, conforme aux normes d'accessibilité.
• ✅ Facile à intégrer : Une simple balise HTML et quelques lignes de code backend.

Comment ça marche sous le capot ?

L'architecture d'Altcha est modulaire et simple :

1. Altcha Widget : C'est le composant web côté client (le truc que l'utilisateur voit). Il charge un challenge cryptographique que le navigateur doit résoudre.
2. Altcha Sentinel : C'est le serveur backend qui génère les challenges et vérifie les solutions. Tu peux l'auto-héberger avec Docker ou utiliser le service public d'Altcha.

Le processus est ultra fluide :

• L'utilisateur arrive sur ton formulaire.
• Le widget Altcha charge un challenge depuis ton serveur Sentinel.
• Le navigateur résout le challenge (c'est rapide, genre quelques millisecondes).
• La solution est envoyée à ton backend pour vérification.
• Si c'est bon, le formulaire est validé. Sinon, c'est bloqué.

Et tout ça sans faire chier l'utilisateur avec des puzzles visuels ou des clics interminables. C'est invisible, rapide, et efficace.

Déployer Altcha Sentinel avec Docker

Bon, passons aux choses sérieuses. Altcha peut fonctionner de deux façons :

1. Mode self-hosted simple : Tu génères et vérifies les challenges directement dans ton backend avec altcha-lib. Pas besoin de Sentinel, tout tourne dans ton app.
2. Mode Sentinel (recommandé) : Tu déploies Sentinel qui gère les challenges, la détection de bots avancée, le machine learning, et plein d'autres trucs de ouf.

Dans cet article, on va se concentrer sur Sentinel parce que c'est lui qui apporte la vraie valeur ajoutée : détection adaptative, threat intelligence, rate limiting, etc.

Si tu veux auto-héberger Altcha (et crois-moi, tu veux), voici comment faire avec Docker. C'est simple, propre, et ça tourne nickel.

Prérequis

• Un serveur (VPS, machine locale) avec Docker et Docker Compose installés.
• Un nom de domaine (recommandé pour la prod) et un certificat SSL (Let's Encrypt, c'est gratuit).
• Des connaissances basiques en Docker et en config YAML.

Étape 1 : Déploie Sentinel avec Docker

La façon la plus simple est d'utiliser l'image officielle Docker. Sentinel génère automatiquement un fichier .env sécurisé avec des secrets aléatoires.

# Créer un volume Docker pour les données persistantes
docker volume create altcha_sentinel_data

# Lancer Sentinel
docker run -d \
  -p 8080:8080 \
  -v altcha_sentinel_data:/data \
  ghcr.io/altcha-org/sentinel:latest

Important : Sentinel tourne sur le port 8080 par défaut (pas 3000).

Une fois lancé, tu peux accéder à :

• Interface web : http://localhost:8080
• API : http://localhost:8080/v1
• Documentation API : http://localhost:8080/v1/docs

Credentials par défaut :

• Username : root
• Password : root

⚠️ Change le mot de passe immédiatement après la première connexion !

Étape 2 : Configuration avancée (optionnel)

Le serveur génère automatiquement un .env sécurisé dans /data. Tu peux le modifier ou passer des variables d'environnement :

docker run -d \
  -p 8080:8080 \
  -v altcha_sentinel_data:/data \
  -e CPU_LIMIT=2 \
  -e MEMORY_LIMIT=2048 \
  ghcr.io/altcha-org/sentinel:latest

Étape 3 : Configure un reverse proxy (Nginx, Traefik, Caddy)

Pour exposer Sentinel en HTTPS (obligatoire en prod), tu vas avoir besoin d'un reverse proxy. Voici un exemple avec Nginx :

server {
    listen 443 ssl http2;
    server_name sentinel.tondomaine.com;

    ssl_certificate /etc/letsencrypt/live/sentinel.tondomaine.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/sentinel.tondomaine.com/privkey.pem;

    location / {
        proxy_pass http://localhost:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Redémarre Nginx :

sudo systemctl reload nginx

Et voilà, ton Sentinel est accessible en HTTPS sur https://sentinel.tondomaine.com ! 🎉

Intégrer le widget Altcha dans ta page web

Maintenant qu'on a le serveur qui tourne, on va intégrer le widget dans notre site. C'est ridiculement simple.

Étape 1 : Ajoute le script JS

Dans ta page HTML, ajoute le script du widget :

<script async defer src="https://cdn.jsdelivr.net/gh/altcha-org/altcha@main/dist/altcha.min.js" type="module"></script>

Étape 2 : Intègre le widget dans ton formulaire

Le widget se connecte à ton Sentinel via l'endpoint /v1/challenge :

<form action="/submit" method="POST">
  <input type="email" name="email" placeholder="Ton email" required />
  <textarea name="message" placeholder="Ton message" required></textarea>
  
  <!-- Le widget Altcha -->
  <altcha-widget challengeurl="https://sentinel.tondomaine.com/v1/challenge?apiKey=YOUR_API_KEY"></altcha-widget>
  
  <button type="submit">Envoyer</button>
</form>

⚠️ Note : Tu dois récupérer ton apiKey depuis l'interface Sentinel (http://localhost:8080 ou ton domaine).

Étape 3 : Vérifie la solution côté serveur

Maintenant, il faut vérifier que le token Altcha est valide avant de traiter le formulaire. Il y a deux façons de faire :

Option 1 : Avec la bibliothèque altcha-lib (recommandé)

npm install altcha-lib

import { Hono } from 'hono';
import { verifyServerSignature } from 'altcha-lib';

const apiKeySecret = 'sec_ton_api_key_secret'; // Depuis Sentinel
const app = new Hono();

app.post('/submit', async (c) => {
  const formData = await c.req.formData();
  const altchaToken = formData.get('altcha');
  
  if (!altchaToken) {
    return c.json({ error: 'Token Altcha manquant' }, 400);
  }

  // Vérifie le token avec Sentinel
  const { verified, verificationData } = await verifyServerSignature(
    String(altchaToken),
    apiKeySecret
  );
  
  if (!verified) {
    return c.json({ error: 'Token Altcha invalide - T\'es un bot ?' }, 400);
  }

  // Traitement du formulaire
  const email = formData.get('email');
  const message = formData.get('message');
  
  console.log(`Email: ${email}, Message: ${message}`);
  console.log('Verification Data:', verificationData);
  
  return c.json({ ok: true, message: 'Formulaire envoyé !' });
});

export default app;

Option 2 : Via l'API HTTP Sentinel

Si tu ne peux pas utiliser la bibliothèque JavaScript (par exemple en PHP ou Python), tu peux vérifier via l'API HTTP :

app.post('/submit', async (c) => {
  const formData = await c.req.formData();
  const altchaToken = formData.get('altcha');
  
  if (!altchaToken) {
    return c.json({ error: 'Token Altcha manquant' }, 400);
  }

  // Vérifie via l'API Sentinel
  const response = await fetch('https://sentinel.tondomaine.com/v1/verify/signature', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ payload: String(altchaToken) })
  });
  
  const { verified } = await response.json();
  
  if (!verified) {
    return c.json({ error: 'Token Altcha invalide' }, 400);
  }

  // Traitement du formulaire
  return c.json({ ok: true, message: 'Formulaire envoyé !' });
});

Et voilà ! Ton formulaire est protégé contre les spams et les bots, sans faire chier tes utilisateurs. 🎯

Exemple avec Python (FastAPI)

T'es plus Python que JavaScript ? Pas de souci, voici un exemple avec FastAPI :

from fastapi import FastAPI, Form, HTTPException
from altcha import verify_solution
import os

app = FastAPI()
HMAC_KEY = os.getenv("SECRET")

@app.post("/submit")
async def submit_form(
    email: str = Form(...),
    message: str = Form(...),
    altcha: str = Form(...)
):
    # Vérifie le token Altcha
    if not verify_solution(altcha, HMAC_KEY):
        raise HTTPException(status_code=400, detail="Token Altcha invalide")
    
    # Traitement du formulaire
    print(f"Email: {email}, Message: {message}")
    
    return {"ok": True, "message": "Formulaire envoyé !"}

Personnalisation du widget

Altcha est super customizable. Tu peux changer la langue, le design, et plein d'autres trucs.

Changer la langue

Par défaut, Altcha détecte automatiquement la langue du navigateur. Mais tu peux forcer une langue spécifique :

<altcha-widget 
  challengeurl="https://sentinel.tondomaine.com/challenge"
  lang="fr">
</altcha-widget>

Altcha supporte 50+ langues, dont le français, l'anglais, l'allemand, l'espagnol, etc.

Personnaliser le style

Tu peux ajouter ton propre CSS pour adapter le widget à ton design :

altcha-widget {
  --altcha-color-base: #1a1a1a;
  --altcha-color-text: #ffffff;
  --altcha-color-border: #333333;
  --altcha-max-width: 400px;
}

Désactiver l'autofocus

Par défaut, le widget prend le focus automatiquement. Si tu veux le désactiver :

<altcha-widget 
  challengeurl="https://sentinel.tondomaine.com/challenge"
  auto="off">
</altcha-widget>

Bonnes pratiques et optimisations

Sécurité

• Change le mot de passe root : Dès la première connexion à Sentinel, change le mot de passe par défaut.
• Protège ton API Key : Ne partage jamais ta clé API publiquement. Elle doit rester côté serveur uniquement.
• HTTPS obligatoire : Ne fais jamais tourner Altcha en HTTP en prod. Le widget utilise l'API Web Crypto qui nécessite HTTPS.
• Stocke les payloads utilisés : Pour éviter les attaques par rejeu (replay attacks), garde une trace des payloads déjà vérifiés.

Performance

• Utilise le cache : Sentinel met automatiquement en cache les challenges pour éviter les calculs inutiles.
• Ajuste le nombre de workers : Par défaut, le widget utilise navigator.hardwareConcurrency (max 16). Tu peux le limiter si besoin.
• Volume persistant obligatoire : Monte toujours /data en volume persistant pour ne pas perdre ta config et tes données.

Scalabilité

• Clustering avec PostgreSQL + Redis : Pour du haute disponibilité, Sentinel supporte le clustering avec PostgreSQL et Redis comme backends.
• Requiert minimum 2 vCPUs et 2 GB RAM : Pour un fonctionnement optimal en production.
• Multi-arch : L'image Docker officielle supporte AMD64 et ARM64.

Monitoring

• Logs : Sentinel log tous les événements dans stdout. Utilise un système comme Loki ou Elasticsearch pour centraliser.
• Métriques : Intègre avec Prometheus pour du monitoring avancé des performances et des taux de vérification.

Pourquoi Altcha, c'est le futur ?

Si t'en as marre de dépendre de Google ou Cloudflare pour protéger tes formulaires, Altcha est une bouffée d'air frais. C'est :

• Éthique : Respect de la vie privée, conformité RGPD, pas de tracking.
• Open-source : Code transparent, auditable, modifiable.
• Performant : Léger, rapide, efficace.
• Accessible : Conforme aux normes d'accessibilité, multilingue.
• Auto-hébergé : Tu gardes le contrôle total sur ton infrastructure.

En plus, le projet est activement maintenu, avec une communauté grandissante et des intégrations pour WordPress, React, Vue, Angular, Flutter, etc.

Les alternatives à Altcha

Bon, soyons fair-play. Altcha, c'est pas la seule alternative open-source aux CAPTCHA classiques. Voici quelques autres solutions que tu peux checker :

• Procaptcha : Basé sur la blockchain (oui, vraiment). C'est intéressant d'un point de vue sécurité, mais plus complexe à mettre en place.
• FriendlyCaptcha : Utilise aussi un mécanisme de PoW, mais c'est un service SaaS (donc pas vraiment auto-hébergeable).
• mCaptcha : Open-source, auto-hébergeable, mais moins mature qu'Altcha.

Perso, je préfère Altcha pour sa simplicité, sa légèreté, et sa maturité. Mais si t'as des besoins spécifiques, jette un œil aux alternatives.

Conclusion : Adopte Altcha

Voilà, tu as toutes les cartes en main pour déployer Altcha et te débarrasser des CAPTCHA qui plombent l'expérience de tes utilisateurs. C'est simple, efficace, open-source, et respectueux de la vie privée.

Alors, qu'est-ce que t'attends ? Lance-toi, teste Altcha, et dis adieu aux puzzles de reCAPTCHA. Tes utilisateurs te remercieront, et ton site sera protégé sans faire de compromis sur la performance ou la vie privée.

Happy coding, et que la force de l'open-source soit avec toi ! 🚀

Liens utiles

• Site officiel : https://altcha.org
• Documentation v2 : https://altcha.org/docs/v2
• GitHub principal : https://github.com/altcha-org/altcha
• GitHub organisation : https://github.com/altcha-org
• Documentation Sentinel : https://altcha.org/docs/v2/sentinel
• Installation Sentinel : https://altcha.org/docs/v2/sentinel/install

Le chiffrement de bout en bout (E2EE) de Signal est une merveille de sécurité, mais c'est un cauchemar pour l'automatisation. Contrairement à Discord ou Slack qui offrent des API REST simples, Signal demande de gérer des clés cryptographiques, le protocole Double Ratchet et des sessions asynchrones.

C'est pour combler ce fossé technologique que j'ai développé signal-sdk. Mon objectif n'est pas seulement de fournir un script, mais une abstraction logicielle robuste en TypeScript, conçue pour piloter la cryptographie complexe de Signal via une interface familière aux développeurs Node.

Sous le capot : Une Architecture Hybride

Pour être transparent sur l'ingénierie de ce paquet : signal-sdk ne réinvente pas la cryptographie (ce qui serait dangereux). Il agit comme un chef d'orchestre (Wrapper) intelligent.

L'architecture repose sur le pilotage de signal-cli, le moteur de référence écrit en Java/Rust.

• Node.js gère la logique métier, les événements et le typage.
• Java (signal-cli) gère le transport, le chiffrement et le stockage des clés.
• La communication se fait via un canal JSON-RPC optimisé (stdin/stdout).

Cette approche vous offre la sécurité d'une implémentation cryptographique éprouvée avec l'ergonomie moderne de TypeScript.

Prérequis et Installation

Puisque nous pilotons un moteur Java, l'installation demande un prérequis système spécifique. Ce n'est pas du "Pure JS", c'est une solution système complète.

1. L'environnement Java

Avant d'installer le paquet, votre machine (ou conteneur Docker) doit disposer d'un JRE (Java Runtime Environment) version 17 ou 21. C'est le moteur qui fera tourner la cryptographie.

# Vérifiez votre version
java -version

2. Installation du SDK

Une fois Java confirmé, installez le SDK. Notez que le paquet inclut les binaires signal-cli pour Linux, macOS et Windows, ce qui simplifie grandement le bootstrap.

npm install signal-sdk

3. Liaison de l'appareil

Le SDK inclut un utilitaire CLI pour générer l'identité de votre bot sans avoir à manipuler des fichiers de configuration manuellement.

npx signal-sdk connect

Cette commande lance le processus démon et affiche un QR Code dans votre terminal. Scannez-le via votre application Signal mobile (Paramètres > Appareils reliés) pour autoriser le bot à utiliser votre compte.

Le Code : Du Scripting au Framework

Le SDK offre deux niveaux d'abstraction selon vos besoins : le contrôle brut ou le framework de bot.

Niveau 1 : Le Client SignalCli

Idéal pour des tâches d'administration système, des notifications ou de l'audit. Nous utilisons ici le mode JSON-RPC persistant : le processus Java reste "chaud", ce qui permet d'envoyer des messages avec une latence minimale (quelques millisecondes) après le démarrage.

import { SignalCli } from 'signal-sdk';

const client = new SignalCli('+33612345678');

async function main() {
  // Démarre le démon Java et établit le canal RPC
  await client.connect();
  
  // Abonnement aux événements bruts (messages, reçus, typing...)
  client.on('message', (envelope) => {
    if (envelope.dataMessage) {
        console.log(`Message reçu de ${envelope.source}: ${envelope.dataMessage.message}`);
    }
  });

  // Envoi d'un message texte sécurisé
  await client.sendMessage('+33777777777', '⚠️ Serveur de Prod : Redémarrage imminent');
}

main().catch(console.error);

Niveau 2 : Le Framework SignalBot

C'est la vraie valeur ajoutée du SDK. Plutôt que de parser des chaînes de caractères et de gérer des if/else, utilisez SignalBot pour structurer vos interactions. Il gère le routing des commandes, l'extraction des arguments et les permissions.

import { SignalBot } from 'signal-sdk';

const bot = new SignalBot({
  phoneNumber: "+33612345678",
  commandPrefix: "!", // Active les commandes type "!ping"
});

// Définition déclarative d'une commande
bot.registerCommand({
  name: "report",
  description: "Soumettre un rapport d'incident",
  handler: async (msg, args) => {
    // msg : objet enrichi avec méthodes de réponse
    if (args.length === 0) {
        await msg.reply("Usage: !report <description>");
        return;
    }
    
    console.log(`Incident rapporté : ${args.join(" ")}`);
    await msg.react("✅"); // Feedback visuel immédiat
  }
});

await bot.start();

Réalités de Production

Passer d'un script local à une app en production sur Signal demande de comprendre certaines contraintes d'infrastructure. Voici ce que vous devez savoir pour éviter les interruptions de service.

La Persistance est Critique

Signal n'est pas "stateless". Le protocole Double Ratchet maintient un état cryptographique local (chaînes de clés) qui évolue à chaque message. Conséquence : Si vous déployez ce SDK via Docker, vous devez monter un volume persistant pour stocker les données de signal-cli.

Si vous perdez ce dossier :

1. Vous perdez votre identité (clés privées).
2. Au redémarrage, une nouvelle identité est générée.
3. Vos correspondants verront une alerte de sécurité ("Le numéro de sécurité a changé") et vos messages seront bloqués.

Exemple de volume Docker :

VOLUME ["/home/botuser/.local/share/signal-cli"]

Gestion des Processus

Le SDK lance un processus enfant Java. Bien que nous gérions les erreurs standard, un crash de la JVM (Out of Memory) peut arriver. En production, utilisez un gestionnaire de processus comme PM2 ou la politique de redémarrage de Kubernetes pour garantir que le pont Node-Java soit relancé automatiquement.

Rate Limiting et CAPTCHA

Signal protège agressivement son réseau contre le spam. Si votre bot envoie trop de messages en peu de temps, il sera temporairement bloqué ("Rate Limited"). Le SDK remontera cette erreur, mais la résolution du défi (CAPTCHA) doit souvent se faire manuellement via la CLI ou l'interface graphique. Concevez vos bots pour être "calmes" et respectueux des limites.

Conclusion

signal-sdk transforme un problème de cryptographie complexe en une expérience développeur fluide. C'est l'outil idéal pour construire des chatbots internes, des systèmes d'alerte sécurisés ou des interfaces domotiques, à condition de respecter les exigences de l'architecture sous-jacente (Java + Persistance).

Le projet est disponible sur npm et ouvert aux contributions pour continuer à affiner cette intégration.

• 📦 NPM : npmjs.com/package/signal-sdk
• 🐙 GitHub : github.com/benoitpetit/signal-sdk

À vos claviers, et bon code "sécurisé" ! 🚀

Tu veux gérer tes projets en 2026 sans vendre ton âme à un SaaS opaque, sans dépendre d’un acteur unique, et sans exploser ton budget infra ? Bonne nouvelle : l’écosystème open source n’a jamais été aussi mature.

En 2026, la gestion de projet, ce n’est plus juste des tickets et des colonnes Kanban. C’est un système vivant : interconnecté, souvent auto-hébergé, parfois décentralisé, et de plus en plus assisté par l’IA — mais sous ton contrôle

Spoiler : GitHub et Jira existent toujours. Mais non, ils ne sont plus le centre du monde.

Pourquoi la gestion de projet a changé de nature

Entre 2020 et 2026, trois bascules ont tout changé.

1. On ne choisit plus un outil, mais une stack

Avant, tu prenais “un outil de gestion de projet”. Aujourd’hui, ça ne suffit plus.

Code, tickets, CI/CD, chat, documentation, monitoring, sécurité, gouvernance… Tout doit parler ensemble, proprement, sans bidouille honteuse.

Un outil isolé, c’est :

• un point de friction

• un silo de plus

• une dette future

2. L’auto-hébergement est redevenu cool (et surtout rationnel)

Pas juste par idéologie barbu-linuxien :

• coûts SaaS imprévisibles

• enjeux RGPD / AI Act

• dépendance fournisseur

• besoin réel de personnalisation

Docker n’est plus seul sur le terrain. Podman, containerd, rootless containers sont devenus des choix normaux, raisonnables, professionnels.

3. L’IA est partout… mais plus n’importe comment

En 2026, l’IA utile :

• propose, ne décide pas

• tourne localement ou sur ton infra

• améliore les flux (priorisation, détection de blocages, aide à la doc)

L’IA “boîte noire qui pilote ton projet” ? C’est non.

Ce qu’on attend d’un bon outil de gestion de projet en 2026

Un outil crédible doit :

• ✅ être open source (vraiment)

• ✅ s’auto-héberger facilement (Docker / Podman / Helm)

• ✅ s’intégrer à ta forge (Forgejo, GitLab, Radicle…)

• ✅ respecter la vie privée (pas de tracking planqué)

• ✅ s’adapter à ta méthode, pas l’inverse

• ✅ rester utilisable sans IA, mais meilleur avec

Si un outil ne coche pas ça, tu passes ton chemin.

Gestion de projet : les outils qui comptent vraiment

OpenProject — le socle professionnel

👉 Le plus complet du marché open source pour la gestion de projet structurée

OpenProject n’est pas un outil “agile friendly” de plus. C’est un véritable socle de pilotage, pensé pour durer et absorber la complexité.

Ce qu’il fait très bien :

• Scrum / Kanban / Gantt / roadmaps multi-projets

• dépendances et jalons

• workflows paramétrables

• rôles et permissions fines

• intégrations natives GitLab / Forgejo

• API stable et documentée

Ce qu’il assume :

• une courbe d’apprentissage réelle

• approche plus “gestion” que “produit pur”

• UI fonctionnelle, pas tape-à-l’œil

Auto-hébergement :

• images Docker officielles

• déploiement simple derrière Traefik / Nginx

• compatible Podman rootless

• mises à jour maîtrisables

💡 À choisir si :

• ton projet va durer

• plusieurs équipes interviennent

• la traçabilité compte autant que la vitesse

🔗 OpenProject

Plane — moderne et rapide

👉 L’anti-usine à gaz

• UI ultra fluide

• Kanban / cycles / backlog

• pensé pour équipes produit et devs

• prise en main quasi immédiate

Limites :

• moins adapté aux projets très gouvernés

• pas (encore) un ERP complet

Auto-hébergement :

• Docker Compose simple

• très léger en ressources

💡 Idéal pour startups, petites équipes et projets open source communautaires

🔗 Plane

ProjeQtOr — la gouvernance open source

👉 Le vétéran qui ne rigole pas

• budgets / risques / qualité

• décisions et traçabilité complète

• utilisé par des institutions

Clairement pas sexy. Mais terriblement efficace pour les projets critiques et contractuels.

🔗 ProjeQtOr

ZenTao — Agile + DevOps complet

👉 Le couteau suisse pour équipes agiles

• gestion bugs et tests

• intégrations CI/CD

• vision DevOps complète

💡 Pour équipes qui veulent tout au même endroit

🔗 ZenTao

Vikunja — le prometteur

👉 Interface moderne et collaborative

• vues multiples (liste / kanban / gantt)

• collaboration temps réel

• développement actif

💡 Pour équipes réactives et projets évolutifs

🔗 Vikunja

Docmost — documentation collaborative

👉 Alternative open source à Confluence / Notion

• centralisation des ressources

• collaboration efficace

• adapté aux équipes distribuées

💡 Pour documentation structurée et maintenable

🔗 Docmost

BookStack — documentation simple et efficace

👉 Gestion par livres et pages

• simplicité et clarté

• open source

• rapide à mettre en place

💡 Idéal pour projets nécessitant documentation bien organisée

🔗 BookStack

Autres alternatives

• Taiga — Agile simple → taiga.io

• Focalboard — Kanban minimaliste → focalboard.com

• Redmine — legacy mais increvable → redmine.org

• Freedcamp — Gratuit et complet → freedcamp.com

• RedmineUP — Redmine pro → redmineup.com

Forges logicielles : le vrai cœur du projet

Forgejo — le rationnel

👉 Fork communautaire de Gitea

• léger, rapide

• 100 % open source

• parfait en auto-hébergement

🔗 Forgejo

GitLab CE — puissant mais exigeant

• CI/CD intégré

• écosystème massif

Mais :

• lourd et gourmand

• maintenance non négligeable

💡 Pertinent pour équipes DevOps expérimentées

🔗 GitLab

Codeberg — l’éthique

• hébergé en Europe

• pas de tracking

• communauté engagée

🔗 Codeberg

Radicle — le futur décentralisé

• Git P2P, sans serveur central

• résilient et anti-censure

• compatible IPFS

💡 Conceptuellement révolutionnaire, encore niche

🔗 Radicle

CI/CD : simple, propre, efficace

Woodpecker CI — sweet spot

• pipelines YAML clairs

• runners Docker / OCI

• parfait avec Forgejo

• empreinte minimale

💡 Suffisant pour 90 % des projets

🔗 Woodpecker CI

Drone — léger et efficace

• CI/CD simple

• marketplace de plugins

🔗 Drone

Tekton — standard Kubernetes

• pipelines déclaratifs

• cloud-native

💡 Pour équipes très K8s

🔗 Tekton

Zuul — artillerie lourde

• gating avancé

• pipelines complexes

• utilisé par OpenStack

💡 Overkill pour la majorité

🔗 Zuul

Collaboration

Matrix + Element — décentralisé

• chiffré et extensible

• interopérable avec bots CI, notifications issues, Jitsi

🔗 Matrix | Element

Mattermost — entreprise

• alternative à Slack

• simple à déployer, moins décentralisé

🔗 Mattermost

Rocket.Chat — complet

• chat + visio

• intégrations riches

🔗 Rocket.Chat

Zulip — organisé

• threads structurés

• discussions lisibles

🔗 Zulip

Documentation

• Wiki.js → simple, collaboratif, Markdown → Wiki.js

• Docusaurus → docs techniques, versioning → Docusaurus

• MkDocs → Markdown → site statique → MkDocs

• Antora → multi-sources, versioning → Antora

• BookStack → gestion par livres → BookStack

• Docmost → alternative Confluence → Docmost

Sécurité

• Snyk → gestion vulnérabilités → Snyk

• OWASP Dependency-Check → analyse statique → OWASP

• Trivy → code / conteneurs / IaC → Trivy

• SonarQube → qualité de code → SonarQube

Monitoring

• Prometheus / Loki / Grafana → métriques / logs / visualisation

• Netdata → monitoring temps réel → Netdata

• Uptime Kuma → surveillance simple → Uptime Kuma

Gouvernance

• GrimoireLab → analyse communauté → GrimoireLab

• Open Governance Index → transparence → Open Governance

• Augur → métriques open source → Augur

Auto-hébergement

Outils éprouvés :

• Docker → Docker

• Podman rootless → Podman

• containerd + nerdctl → containerd

• Kubernetes léger (k3s) → k3s

Si ton outil ne tourne pas en rootless → méfiance.

Erreurs classiques

• ❌ Choisir un outil à la mode

• ❌ Sous-estimer la maintenance

• ❌ Tout automatiser sans garde-fou humain

• ❌ Ignorer l’accessibilité

• ❌ Confondre IA et pilotage

Et après ?

En 2027 :

• plus de spécialisation

• moins de plateformes géantes

• plus de sobriété

• des outils maîtrisés, pas magiques

En clair

👉 Le bon outil, c’est celui :

1. que tu comprends

2. que tu peux héberger

3. que tu peux quitter

Le reste, c’est du marketing.

GoWM (Go WebAssembly Manager) débarque comme une révolution dans l'écosystème WebAssembly. Gratos, open source, et surtout ultra simple à utiliser. Oui, tout ça à la fois ! Fini les galères de compilation, les configurations interminables, et les prises de tête pour charger tes modules WASM.

WebAssembly : Le turbo pour tes apps web

Avant de plonger dans GoWM, rappelons pourquoi WebAssembly c'est cool. Les recherches montrent que WebAssembly peut être jusqu'à 10x plus rapide que JavaScript pour les tâches de calcul intensif. Pour le traitement d'images, les opérations cryptographiques, ou les calculs mathématiques complexes, WASM écrase littéralement JS en termes de performances.

Mais attention, c'est pas magique non plus ! JavaScript reste le roi pour la manipulation du DOM et les interactions utilisateur simples. L'idée, c'est de faire bosser les deux ensemble : JS pour l'interface et les interactions, WASM pour la puissance de calcul.

GoWM : La solution qui change tout

Le problème qu'on connaît tous

Intégrer des modules WebAssembly dans un projet web, c'est souvent un parcours du combattant :

• Configuration complexe de l'environnement de build

• Gestion manuelle des fichiers .wasm et wasm_exec.js

• Problèmes de compatibilité entre navigateurs

• Absence d'outils standardisés pour le chargement

La Réponse : GoWM

GoWM v1.0.7 débarque avec une approche révolutionnaire : chargement direct depuis GitHub, intégration native avec React et Vue, et configuration zéro. Plus besoin de compiler, plus besoin de serveur local, plus besoin de galères !

Les super-pouvoirs de GoWM

✅ Chargement GitHub direct : Tes modules WASM directement depuis les repos
✅ Cross-Platform : Compatible navigateur (exports.browser), Node.js (exports.node) et environnements edge
✅ React & Vue natifs : Hooks (gowm/hooks) et composables (gowm/composables) intégrés
✅ TypeScript ready : Support complet avec autocomplétion via types/index.d.ts
✅ Gestion d'erreurs robuste : Retry automatique et gestion d'état
✅ Performance optimisée : Cache intelligent et chargement asynchrone

L'écosystème de modules : Un arsenal complet

GoWM, c'est pas juste un gestionnaire, c'est tout un écosystème de modules prêts à l'emploi. Découvre la collection complète sur gowm.vercel.app avec documentation interactive et exemples concrets !

PDF-WASM : Génération et manipulation PDF

Fonctions disponibles : createPDF, addPage, extractText, mergePDFs, splitPDF, addWatermark, generateReport, compressPDF
Bibliothèque : GoFPDF pour génération native
Sortie : PDF Base64 prêt au téléchargement

const pdf = await loadFromGitHub('benoitpetit/wasm-modules-repository', {
  branch: 'master',
  name: 'pdf-wasm'
});

// Création PDF simple
const pages = [{
  width: 210, height: 297, margin: 20,
  content: "Document généré avec GoWM\n\nPDF-WASM permet la création rapide de documents professionnels."
}];

const metadata = {
  title: "Document GoWM",
  author: "DevByBen"
};

const pdfResult = pdf.call('createPDF', JSON.stringify(pages), JSON.stringify(metadata));
if (!pdfResult.error) {
  console.log('PDF créé:', pdfResult.size, 'bytes');
  
  // Téléchargement direct
  const link = document.createElement('a');
  link.href = 'data:application/pdf;base64,' + pdfResult.pdfData;
  link.download = 'document.pdf';
  link.click();
}

// Génération de rapport
const reportData = {
  type: "report",
  data: { title: "Rapport GoWM", content: "Statistiques WebAssembly" }
};
const reportResult = pdf.call('generateReport', JSON.stringify(reportData));
console.log('Rapport généré:', reportResult.templateType);

// Compression PDF
const compressResult = pdf.call('compressPDF', pdfResult.pdfData, 'medium');
console.log('Compression:', compressResult.compressionRatio + '%');

Crypto-WASM : Sécurité

Fonctions disponibles : hashSHA256, generateAESKey, encryptAES, decryptAES, generateRSAKeyPair, generateJWT
Retour structuré : Objets avec métadonnées complètes
Sécurité : Algorithmes cryptographiques standards

const crypto = await loadFromGitHub('benoitpetit/wasm-modules-repository', {
  branch: 'master',
  name: 'crypto-wasm'
});

// Hash SHA256 avec métadonnées
const hashResult = crypto.call('hashSHA256', 'Hello World');
if (hashResult.error) {
  console.error('Erreur hash:', hashResult.error);
} else {
  console.log('Hash:', hashResult.hash);
  console.log('Algorithme:', hashResult.algorithm); // "SHA256"
}

// Génération et utilisation clé AES
const keyResult = crypto.call('generateAESKey', 32); // 256-bit
if (!keyResult.error) {
  console.log('Clé générée:', keyResult.key);
  console.log('Taille:', keyResult.keySize, 'bits');
  
  // Chiffrement AES
  const encryptResult = crypto.call('encryptAES', 'Message secret', keyResult.key);
  if (!encryptResult.error) {
    console.log('Données chiffrées:', encryptResult.encryptedData);
    console.log('Algorithme:', encryptResult.algorithm);
    
    // Déchiffrement
    const decryptResult = crypto.call('decryptAES', encryptResult.encryptedData, keyResult.key);
    console.log('Déchiffré:', decryptResult.decryptedData); // "Message secret"
  }
}

Image-WASM : Traitement d'images

Fonctions disponibles : compressJPEG, compressPNG, convertToWebP, resizeImage
Optimisation : Compression intelligente avec ratio de qualité
Formats : Support JPEG, PNG, WebP

const image = await loadFromGitHub('benoitpetit/wasm-modules-repository', {
  branch: 'master',
  name: 'image-wasm'
});

// Compression JPEG avec contrôle qualité
const compressResult = image.call('compressJPEG', imageData, 80);
if (!compressResult.error) {
  console.log('Taille compressée:', compressResult.size);
  console.log('Qualité:', compressResult.quality);
  console.log('Ratio de compression:', compressResult.compressionRatio);
  console.log('Format:', compressResult.format); // "JPEG"
}

// Redimensionnement d'image
const resizeResult = image.call('resizeImage', imageData, 800, 600);
if (!resizeResult.error) {
  console.log('Nouvelles dimensions:', resizeResult.width, 'x', resizeResult.height);
}

QR-WASM : Génération QR codes & codes-barres

Fonctions disponibles : generateQRCode, generateVCard, generateWiFiQR, generateBarcode
Formats : QR codes, vCards, WiFi, codes-barres EAN/UPC
Sortie : Images Base64 prêtes à l'usage

const qr = await loadFromGitHub('benoitpetit/wasm-modules-repository', {
  branch: 'master',
  name: 'qr-wasm'
});

// Mode silencieux pour production
qr.call('setSilentMode', true);

// QR code basique
const qrResult = qr.call('generateQRCode', 'https://gowm.vercel.app', 256, 'HIGH');
if (!qrResult.error) {
  console.log('QR généré:', qrResult.base64Image);
  
  // Affichage direct dans le DOM
  const img = document.createElement('img');
  img.src = 'data:image/png;base64,' + qrResult.base64Image;
  document.body.appendChild(img);
}

// vCard contact professionnel
const contact = {
  name: 'DevByBen',
  organization: 'GoWM Team',
  phone: '+33123456789',
  email: 'dev@gowm.io',
  url: 'https://gowm.vercel.app'
};
const vCardResult = qr.call('generateVCard', contact, 300);
console.log('vCard QR:', vCardResult.base64Image);

// QR WiFi pour partage réseau
const wifi = {
  ssid: 'DevNetwork',
  password: 'SuperSecure123',
  security: 'WPA',
  hidden: false
};
const wifiResult = qr.call('generateWiFiQR', wifi, 256);
console.log('WiFi QR:', wifiResult.base64Image);

Goxios-WASM : Client HTTP puissant

Fonctions disponibles : get, post, put, delete, patch, request, create
API : Interface similaire à Axios
Configuration : Headers, timeout, retry automatique

const goxios = await loadFromGitHub('benoitpetit/wasm-modules-repository', {
  branch: 'master',
  name: 'goxios-wasm'
});

// Requête GET simple
const response = goxios.call('get', 'https://api.github.com/users/octocat');
if (!response.error) {
  console.log('Status:', response.status);
  console.log('Headers:', response.headers);
  console.log('Data:', JSON.parse(response.data));
}

// Requête POST avec données
const postData = { name: 'John', email: 'john@example.com' };
const postResponse = goxios.call('post', 'https://api.example.com/users', JSON.stringify(postData));
console.log('Création utilisateur:', postResponse);

Découvre Tous les Modules Disponibles

Tu veux explorer l'écosystème complet des modules WebAssembly ?

👉 Découvrir tous les modules sur gowm.vercel.app/modules

Sur cette page, tu trouveras :

• 📊 Statistiques complètes : nombre de modules, fonctions, taille totale

• 🔍 Recherche et filtres : trouve rapidement le module parfait

• 📖 Documentation interactive : exemples et API pour chaque module

• ⭐ Informations GitHub : stars, forks, dernières mises à jour

• 📱 Interface moderne : navigation intuitive en grid ou liste

Chaque module est documenté avec des exemples concrets d'intégration React, Vue et JavaScript vanilla. Tu peux copier-coller le code et c'est parti !

Créer tes propres modules WASM

Tu veux créer tes propres modules WebAssembly optimisés pour GoWM ? C'est possible et plus simple que tu ne le penses !

👉 Guide complet de création de modules WASM

Le guide officiel couvre :

• 🏗️ Setup de l'environnement Go pour WebAssembly

• 📝 Patterns de développement GoWM-compatibles

• 🔧 Export de fonctions avec gestion d'erreurs

• 📦 Compilation optimisée avec TinyGo

• 🚀 Publication et intégration GitHub

• ✅ Tests et validation des modules

// Exemple de module Go simple
package main

import (
    "syscall/js"
)

var silentMode = false

//go:export add
func add(a, b int) int {
    return a + b
}

//go:export subtract
func subtract(a, b int) int {
    return a - b
}

//go:export setSilentMode
func setSilentMode(enabled bool) bool {
    silentMode = enabled
    return silentMode
}

//go:export getAvailableFunctions
func getAvailableFunctions() []string {
    return []string{"add", "subtract", "setSilentMode", "getAvailableFunctions"}
}

func main() {
    c := make(chan struct{}, 0)
    <-c // Keep alive
}

Compilation optimisée :

#!/bin/bash
# build.sh - Script de compilation optimisée pour modules WASM

set -e

# Configuration environnement WebAssembly
export GOOS=js
export GOARCH=wasm
export CGO_ENABLED=0

# Récupération des dépendances
go mod download
go mod tidy

# Flags d'optimisation
BUILD_FLAGS=(
    -ldflags="-s -w"           # Supprime debug et symbol table
    -trimpath                  # Supprime les chemins de fichiers
    -buildmode=default         # Mode de build standard
)

# Compilation WASM optimisée
go build "${BUILD_FLAGS[@]}" -o main.wasm main.go

# Optimisation avec wasm-opt (si disponible)
if command -v wasm-opt &> /dev/null; then
    wasm-opt -Oz --enable-bulk-memory main.wasm -o main.wasm
fi

# Compression gzip
gzip -9 -k main.wasm

# Génération hash d'intégrité
sha256sum main.wasm | cut -d' ' -f1 > main.wasm.integrity

echo "✅ Module WASM optimisé et prêt pour GoWM!"

Performances : Les chiffres qui parlent

Les benchmarks montrent des résultats impressionnants selon le type de tâche :

Quand WebAssembly domine

• Calculs intensifs : Jusqu'à 10× plus rapide

• Cryptographie : Entre 2× et 10× de gain

• Traitement d'images : 2× à 5× plus performant

• Applications scientifiques : Gains substantiels

Quand javascript reste roi

• Manipulation DOM : Accès natif vs passage par JS

• Applications légères : Overhead de chargement WASM

• Interactions utilisateur : Réactivité immédiate

Architecture GitHub : L'innovation qui change Tout

GoWM révolutionne l'approche traditionnelle avec son système de chargement GitHub direct. Plus besoin de :

• Configurer un serveur local

• Gérer les fichiers WASM manuellement

• S'embêter avec les CORS

• Maintenir des versions locales

Auto-Discovery Intelligent

GoWM scanne automatiquement les dépôts GitHub pour trouver tes modules :

• Dossiers wasm/, dist/, build/

• Fichiers main.wasm, index.wasm, {repo-name}.wasm

• GitHub releases avec assets WASM

• Chemins personnalisés

// Basic loading - automatic file discovery
const math = await loadFromGitHub('benoitpetit/wasm-modules-repository');

// Advanced loading with specific options
const imageProcessor = await loadFromGitHub('image-corp/wasm-image', {
  branch: 'develop',        // Use develop branch
  path: 'dist',            // Look in dist folder
  filename: 'image.wasm',  // Specific filename
  name: 'image-processor'  // Module name
});

// Load from specific tag/release
const stableVersion = await loadFromGitHub('company/wasm-lib', {
  tag: 'v1.2.0',           // Use specific tag
  name: 'stable'
});

React integration : Hooks natifs

import React, { useState, useEffect } from 'react';
import { useWasmFromGitHub } from 'gowm/hooks/useWasm';

function CalculatorComponent() {
  const { wasm, loading, error } = useWasmFromGitHub('benoitpetit/wasm-modules-repository', {
    branch: 'master',
    name: 'math-wasm'
  });
  const [result, setResult] = useState(null);
  const [functions, setFunctions] = useState([]);

  useEffect(() => {
    if (wasm) {
      // Enable silent mode for cleaner output
      wasm.call('setSilentMode', true);
      
      // Get available functions
      const availableFunctions = wasm.call('getAvailableFunctions');
      setFunctions(availableFunctions);
    }
  }, [wasm]);

  const calculate = async (operation, a, b) => {
    if (!wasm) return;
    
    try {
      const result = await wasm.callAsync(operation, a, b);
      
      // Handle different return types
      if (typeof result === 'string' && result.includes('Erreur')) {
        setResult(`Error: ${result}`);
      } else {
        setResult(result);
      }
    } catch (err) {
      setResult(`Error: ${err.message}`);
    }
  };

  if (loading) return <div>Loading WASM module...</div>;
  if (error) return <div>Error: {error.message}</div>;

  return (
    <div>
      <h3>Available Functions: {functions.join(', ')}</h3>
      <button onClick={() => calculate('add', 5, 3)}>5 + 3</button>
      <button onClick={() => calculate('multiply', 4, 7)}>4 × 7</button>
      <button onClick={() => calculate('factorial', 5)}>5!</button>
      {result !== null && <div>Result: {result}</div>}
    </div>
  );
}

Vue 3 integration : Composables réactifs

<template>
  <div class="calculator">
    <div v-if="loading">Loading WASM module...</div>
    <div v-else-if="error">Error: {{ error.message }}</div>
    <div v-else>
      <h3>Available Functions: {{ functions.join(', ') }}</h3>
      <input v-model.number="num1" type="number" placeholder="First number" />
      <input v-model.number="num2" type="number" placeholder="Second number" />
      <button @click="calculate('add')">Add</button>
      <button @click="calculate('multiply')">Multiply</button>
      <div v-if="result !== null">Result: {{ result }}</div>
    </div>
  </div>
</template>

<script setup>
import { ref, watch } from 'vue';
import { useWasmFromGitHub } from 'gowm/composables/useWasm';

const { wasm, loading, error } = useWasmFromGitHub('benoitpetit/wasm-modules-repository', {
  branch: 'master',
  name: 'math-wasm'
});

const num1 = ref(10);
const num2 = ref(20);
const result = ref(null);
const functions = ref([]);

// Watch for wasm module ready
watch(wasm, (newWasm) => {
  if (newWasm) {
    // Configure module
    newWasm.call('setSilentMode', true);
    
    // Get available functions
    functions.value = newWasm.call('getAvailableFunctions');
  }
}, { immediate: true });

const calculate = async (operation) => {
  if (!wasm.value) return;
  
  try {
    const calcResult = await wasm.value.callAsync(operation, num1.value, num2.value);
    
    // Handle error strings
    if (typeof calcResult === 'string' && calcResult.includes('Erreur')) {
      result.value = `Error: ${calcResult}`;
    } else {
      result.value = calcResult;
    }
  } catch (err) {
    result.value = `Error: ${err.message}`;
  }
};
</script>

Sécurité et Compatibilité : Du solide

Sandboxing WebAssembly

WebAssembly s'exécute dans un environnement sandboxé sécurisé, protégeant le système hôte. GoWM respecte ces garanties tout en ajoutant ses propres couches de protection.

Support Universel

• Navigateurs : Chrome 57+, Firefox 52+, Safari 11+, Edge 16+

• Runtimes : Node.js 14+, Deno, Bun

• Environnements : Browser, server-side, edge computing

WASM manager : Le site compagnon

Découvre WASM Manager, le site compagnon qui référence tous les modules disponibles :

• Découverte de modules : Browse et search dans la collection

• Intégration GitHub : Infos automatiques depuis les repos

• Exemples d'intégration : Code ready-to-use pour chaque framework

• Documentation complète : Fonctions, paramètres et exemples

• Interface moderne : UI responsive avec dark mode

L'Avenir du WebAssembly avec GoWM

Avec l'arrivée de Go 1.21 et les optimisations WebAssembly, l'écosystème explose. GoWM se positionne comme l'outil de référence pour exploiter cette révolution.

Des entreprises comme Figma, Autodesk et Blender utilisent déjà WASM pour des performances spectaculaires. GoWM démocratise cet accès pour tous les développeurs JavaScript.

Pourquoi GoWM change la donne

🔓 Liberté totale : Pas de vendor lock-in, code 100 % open source MIT
🛡️ Sécurité native : Sandboxing WASM + protections GoWM
💰 Coût zéro : Gratuit, sans limites cachées
🔧 Flexibilité maximale : Adapte-toi à tes besoins spécifiques
📚 Documentation complète : Exemples, guides, API reference
🚀 Performance optimisée : Modules compressés et cache intelligent

Conclusion : Le WebAssembly accessible à tous

GoWM v1.0.7 n'est pas qu'un gestionnaire de modules. C'est une révolution pour intégrer WASM dans tes projets JavaScript. Un développement plus simple, plus rapide et plus performant t'attend.

Alors, qu'attends-tu pour essayer ? npm install gowm et c'est parti !

Liens utiles :

• 📦 Package NPM

• 🐙 Repository GitHub

• 📦 WASM Module

• 📚 Documentation complète

Aujourd'hui, on va découvrir GoWM, un petit bijou qui va révolutionner ta façon d'intégrer WebAssembly dans tes apps React, Vue.js ou dans du Node.js. Prépare ton café, on va s'amuser !

GoWM, qu'est-ce que c'est que ce truc ?

GoWM (Go Wasm Manager), c'est un peu comme ton couteau suisse pour WebAssembly. Cette bibliothèque te simplifie la vie au maximum pour charger et utiliser des modules WASM Go dans tes apps JavaScript.

Fini les galères d'intégration ! GoWM te donne :

• Une interface unifiée pour charger tes modules WASM Go (enfin !)

• Un support complet pour Node.js et navigateur avec détection automatique (malin, non ?)

• Des hooks React intégrés (useWasm, useWasmFromNPM) parce qu'on aime React ici

• Des composables Vue.js pour les fans de Vue 3

• Un chargement depuis NPM avec résolution automatique (plus besoin de se creuser la tête)

• Une gestion robuste des erreurs et détection de fonctions

• Une gestion automatique de la mémoire (tu peux dormir tranquille)

Pourquoi WebAssembly pour valider tes formulaires ?

Alors là, excellente question ! Tu sais, quand tu as des formulaires avec des règles métier complexes, ça peut vite devenir l'enfer côté performance. Genre, tu as des regex pourries, des validations cross-field, et ton navigateur qui commence à suffoquer.

WebAssembly, c'est comme avoir une Ferrari dans ton navigateur. Du code Go compilé qui tourne à des vitesses de malade, directement dans le browser. C'est beau, non ?

Allez, on installe tout ça !

Bon, assez parlé, on passe aux choses sérieuses :

npm install gowm
# ou si tu es team Yarn
yarn add gowm

Facile, hein ? 😄

Création de notre module WASM de validation

Structure du projet

D'abord, organisons-nous correctement :

validator-wasm/
├── main.go           # Notre code Go de la mort
├── go.mod            # Configuration Go
├── build.sh          # Script magique de compilation
├── package.json      # Config NPM
└── README.md         # Documentation (sois pas fainéant !)

Le code Go du Wasm

Allez, on s'attaque au vif du sujet. Voici notre validateur Go qui sera builder en wasm :

//go:build js && wasm
package main

import (
    "encoding/json"
    "fmt"
    "regexp"
    "strings"
    "syscall/js"
)

type ValidationRule struct {
    Field    string `json:"field"`
    Required bool   `json:"required"`
    MinLen   int    `json:"minLen"`
    MaxLen   int    `json:"maxLen"`
    Pattern  string `json:"pattern"`
    Type     string `json:"type"`
}

type ValidationResult struct {
    Valid  bool              `json:"valid"`
    Errors map[string]string `json:"errors"`
}

// validateEmail - parce qu'on en a tous marre des emails pourris
func validateEmail(email string) bool {
    pattern := `^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$`
    matched, _ := regexp.MatchString(pattern, email)
    return matched
}

// validatePhone - pour les numéros français
func validatePhone(phone string) bool {
    pattern := `^(?:\+33|0)[1-9](?:[0-9]{8})$`
    matched, _ := regexp.MatchString(pattern, phone)
    return matched
}

// validateForm - la fonction qui fait tout le boulot
func validateForm(this js.Value, args []js.Value) interface{} {
    if len(args) != 2 {
        return js.ValueOf(map[string]interface{}{
            "valid":  false,
            "errors": map[string]string{"system": "Arguments invalides, mon reuf !"},
        })
    }

    // Parse des données (attention, ça peut piquer)
    formDataJSON := args[0].String()
    rulesJSON := args[1].String()

    var formData map[string]interface{}
    var rules []ValidationRule

    if err := json.Unmarshal([]byte(formDataJSON), &formData); err != nil {
        return js.ValueOf(map[string]interface{}{
            "valid":  false,
            "errors": map[string]string{"system": "Données formulaire pourries"},
        })
    }

    if err := json.Unmarshal([]byte(rulesJSON), &rules); err != nil {
        return js.ValueOf(map[string]interface{}{
            "valid":  false,
            "errors": map[string]string{"system": "Règles de validation foireuses"},
        })
    }

    result := ValidationResult{
        Valid:  true,
        Errors: make(map[string]string),
    }

    // La magie opère ici
    for _, rule := range rules {
        value, exists := formData[rule.Field]
        valueStr := ""
        
        if exists && value != nil {
            valueStr = strings.TrimSpace(value.(string))
        }

        // Champ requis ? On vérifie !
        if rule.Required && valueStr == "" {
            result.Valid = false
            result.Errors[rule.Field] = "Ce champ est requis, fais un effort !"
            continue
        }

        if valueStr == "" {
            continue // On skip si pas requis et vide
        }

        // Longueur minimale
        if rule.MinLen > 0 && len(valueStr) < rule.MinLen {
            result.Valid = false
            result.Errors[rule.Field] = fmt.Sprintf("Minimum %d caractères requis", rule.MinLen)
            continue
        }

        // Longueur maximale
        if rule.MaxLen > 0 && len(valueStr) > rule.MaxLen {
            result.Valid = false
            result.Errors[rule.Field] = fmt.Sprintf("Maximum %d caractères autorisés", rule.MaxLen)
            continue
        }

        // Validation par type
        switch rule.Type {
        case "email":
            if !validateEmail(valueStr) {
                result.Valid = false
                result.Errors[rule.Field] = "Merci d'entrer une adresse email valide"
            }
        case "phone":
            if !validatePhone(valueStr) {
                result.Valid = false
                result.Errors[rule.Field] = "Ce numéro de téléphone, c'est n'importe quoi"
            }
        }

        // Pattern personnalisé pour les perfectionnistes
        if rule.Pattern != "" {
            matched, err := regexp.MatchString(rule.Pattern, valueStr)
            if err != nil || !matched {
                result.Valid = false
                result.Errors[rule.Field] = "Format invalide, recommence !"
            }
        }
    }

    // On retourne le tout en JSON
    resultJSON, _ := json.Marshal(result)
    return js.ValueOf(string(resultJSON))
}

func main() {
    // On expose notre fonction au monde JavaScript
    js.Global().Set("validateForm", js.FuncOf(validateForm))
    
    // Signal de prêt pour GoWM
    js.Global().Set("__gowm_ready", js.ValueOf(true))
    
    // On maintient le programme en vie (important !)
    select {}
}

Script de compilation en Wasm

Créons notre script build.sh qui va compiler tout ça proprement :

#!/bin/bash
set -e

echo "🔨 Compilation du module de validation WASM..."

# Compilation optimisée (on veut du perf !)
GOOS=js GOARCH=wasm go build \
    -ldflags="-s -w" \
    -o validator.wasm \
    main.go

echo "📦 Copie du runtime Go..."
cp "$(go env GOROOT)/lib/wasm/wasm_exec.js" .

echo "✅ Build terminé !"
echo "📊 Taille du fichier WASM: $(du -h validator.wasm | cut -f1)"

Intégration React avec GoWM

Maintenant, la partie vraiment fun : intégrer tout ça dans React ! Voici un composant :

import React, { useState, useEffect } from 'react';
import { load } from 'gowm';

const ContactForm = () => {
    const [wasm, setWasm] = useState(null);
    const [loading, setLoading] = useState(true);
    const [error, setError] = useState(null);

    useEffect(() => {
        const loadWasm = async () => {
            try {
                setLoading(true);
                setError(null);
                const wasmModule = await load('/validator.wasm');
                setWasm(wasmModule);
                setLoading(false);
            } catch (err) {
                setError(err);
                setLoading(false);
            }
        };

        loadWasm();
    }, []);
    
    const [formData, setFormData] = useState({
        name: '',
        email: '',
        phone: '',
        message: ''
    });
    
    const [validationErrors, setValidationErrors] = useState({});
    const [isSubmitting, setIsSubmitting] = useState(false);

    // Nos règles de validation (modulables à souhait)
    const validationRules = [
        { field: 'name', required: true, minLen: 2, maxLen: 50 },
        { field: 'email', required: true, type: 'email' },
        { field: 'phone', required: false, type: 'phone' },
        { field: 'message', required: true, minLen: 10, maxLen: 500 }
    ];

    const handleInputChange = (e) => {
        const { name, value } = e.target;
        setFormData(prev => ({
            ...prev,
            [name]: value
        }));
        
        // Validation en temps réel (parce qu'on est des pros)
        if (wasm) {
            validateField(name, value);
        }
    };

    const validateField = async (fieldName, value) => {
        if (!wasm) {
            // Validation de fallback en JavaScript si WASM pas encore chargé
            const errors = {};
            const rules = validationRules.filter(rule => rule.field === fieldName);
            for (const rule of rules) {
                if (rule.required && !value.trim()) {
                    errors[fieldName] = "Ce champ est requis, fais un effort !";
                    break;
                }
                if (value.trim() && rule.minLen && value.length < rule.minLen) {
                    errors[fieldName] = `Minimum ${rule.minLen} caractères requis`;
                    break;
                }
                if (value.trim() && rule.type === 'email') {
                    const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;
                    if (!emailRegex.test(value)) {
                        errors[fieldName] = "Cet email sent le poisson pourri";
                        break;
                    }
                }
            }
            setValidationErrors(prev => ({
                ...prev,
                [fieldName]: errors[fieldName] || null
            }));
            return;
        }

        try {
            const singleFieldData = { [fieldName]: value };
            const fieldRules = validationRules.filter(rule => rule.field === fieldName);
            
            // Avec gowm, les fonctions sont disponibles globalement après le chargement
            const result = window.validateForm(
                JSON.stringify(singleFieldData), 
                JSON.stringify(fieldRules)
            );
            
            const validation = JSON.parse(result);
            
            setValidationErrors(prev => ({
                ...prev,
                [fieldName]: validation.errors[fieldName] || null
            }));
        } catch (err) {
            console.error('Oups, erreur de validation:', err);
        }
    };

    const handleSubmit = async (e) => {
        e.preventDefault();
        
        if (!wasm) {
            alert('Patience, le validateur charge encore !');
            return;
        }

        setIsSubmitting(true);

        try {
            // Validation complète (le moment de vérité)
            const result = window.validateForm(
                JSON.stringify(formData), 
                JSON.stringify(validationRules)
            );
            
            const validation = JSON.parse(result);
            
            if (validation.valid) {
                alert('Formulaire nickel ! Envoi en cours...');
                // Ici tu peux envoyer tes données
                console.log('Données prêtes à partir:', formData);
            } else {
                setValidationErrors(validation.errors);
            }
        } catch (err) {
            console.error('Erreur lors de la validation:', err);
            alert('Oups, quelque chose a foiré !');
        } finally {
            setIsSubmitting(false);
        }
    };

    if (loading) {
        return (
            <div className="flex items-center justify-center p-8">
                <div className="text-center">
                    <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-blue-600 mx-auto"></div>
                    <p className="mt-2 text-gray-600">Chargement du validateur...</p>
                </div>
            </div>
        );
    }

    if (error) {
        return (
            <div className="bg-red-50 border border-red-200 rounded-lg p-4">
                <p className="text-red-600">Erreur de chargement: {error.message}</p>
            </div>
        );
    }

    return (
        <div className="max-w-md mx-auto bg-white rounded-lg shadow-md p-6">
            <h2 className="text-2xl font-bold mb-6 text-gray-800">Contact</h2>
            
            <form onSubmit={handleSubmit} className="space-y-4">
                <div>
                    <label className="block text-sm font-medium text-gray-700 mb-1">
                        Nom *
                    </label>
                    <input
                        type="text"
                        name="name"
                        value={formData.name}
                        onChange={handleInputChange}
                        className={`w-full px-3 py-2 border rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500 ${
                            validationErrors.name ? 'border-red-500' : 'border-gray-300'
                        }`}
                    />
                    {validationErrors.name && (
                        <p className="text-red-500 text-sm mt-1">{validationErrors.name}</p>
                    )}
                </div>

                <div>
                    <label className="block text-sm font-medium text-gray-700 mb-1">
                        Email *
                    </label>
                    <input
                        type="email"
                        name="email"
                        value={formData.email}
                        onChange={handleInputChange}
                        className={`w-full px-3 py-2 border rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500 ${
                            validationErrors.email ? 'border-red-500' : 'border-gray-300'
                        }`}
                    />
                    {validationErrors.email && (
                        <p className="text-red-500 text-sm mt-1">{validationErrors.email}</p>
                    )}
                </div>

                <div>
                    <label className="block text-sm font-medium text-gray-700 mb-1">
                        Téléphone
                    </label>
                    <input
                        type="tel"
                        name="phone"
                        value={formData.phone}
                        onChange={handleInputChange}
                        className={`w-full px-3 py-2 border rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500 ${
                            validationErrors.phone ? 'border-red-500' : 'border-gray-300'
                        }`}
                    />
                    {validationErrors.phone && (
                        <p className="text-red-500 text-sm mt-1">{validationErrors.phone}</p>
                    )}
                </div>

                <div>
                    <label className="block text-sm font-medium text-gray-700 mb-1">
                        Message *
                    </label>
                    <textarea
                        name="message"
                        rows={4}
                        value={formData.message}
                        onChange={handleInputChange}
                        className={`w-full px-3 py-2 border rounded-md focus:outline-none focus:ring-2 focus:ring-blue-500 ${
                            validationErrors.message ? 'border-red-500' : 'border-gray-300'
                        }`}
                    />
                    {validationErrors.message && (
                        <p className="text-red-500 text-sm mt-1">{validationErrors.message}</p>
                    )}
                </div>

                <button
                    type="submit"
                    disabled={isSubmitting}
                    className="w-full bg-blue-600 text-white py-2 px-4 rounded-md hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-blue-500 disabled:opacity-50 disabled:cursor-not-allowed"
                >
                    {isSubmitting ? 'Validation en cours...' : 'Envoyer'}
                </button>
            </form>
        </div>
    );
};

export default ContactForm;

Pourquoi cette approche ?

Performances.

Avec WebAssembly, ton code de validation tourne à la vitesse de l'éclair. Les regex complexes et la logique métier sont traitées de manière ultra-efficace. Fini les freeze d'interface !

Validation en temps réel sans lag

Grâce au hook useWasm de GoWM, tu peux valider tes champs en temps réel sans que ton interface rame.

Réutilisabilité au max

Ton module WASM, tu peux :

• Le publier sur NPM pour le réutiliser partout

• L'utiliser côté serveur avec Node.js (pratique !)

• L'intégrer dans des apps Vue.js avec les composables GoWM

Sécurité renforcée

La validation côté client en WASM ajoute une couche de sécurité. Bien sûr, tu gardes ta validation côté serveur (on n'est pas fous !).

Configuration avancée avec GoWM

GoWM, c'est pas que basique. Tu peux faire d’autres trucs sympa :

// Chargement simple
import { load } from 'gowm';

async function loadValidator() {
    try {
        const validator = await load('/validator.wasm');
        // Utilisation directe des fonctions exposées globalement
        const result = window.validateForm(dataJSON, rulesJSON);
        return JSON.parse(result);
    } catch (error) {
        console.error('Oops, chargement foiré:', error);
    }
}

// Gestion de plusieurs modules (pour les gourmands)
import { load, get, listModules } from 'gowm';

const loadMultipleModules = async () => {
    await load('/validator.wasm', { name: 'validator' });
    await load('/formatter.wasm', { name: 'formatter' });
    
    // Lister les modules chargés
    console.log('Modules chargés:', listModules());
    
    // Récupérer un module spécifique
    const validator = get('validator');
};

Support TypeScript (pour les perfectionnistes)

GoWM inclut des types TypeScript complets :

import { load, LoadOptions } from 'gowm';

interface ValidationResult {
    valid: boolean;
    errors: Record<string, string>;
}

const loadValidator = async (): Promise<void> => {
    await load('./validator.wasm');
    
    // Les fonctions WASM sont disponibles globalement
    const result: string = (window as any).validateForm(formDataJSON, rulesJSON);
    const validation: ValidationResult = JSON.parse(result);
};

Alors, convaincu ? GoWM rend WebAssembly accessible à tous les développeurs JavaScript, même les plus fainéants ! Cette approche te permet de :

• Booster les performances de tes validations complexes

• Simplifier l'intégration grâce aux hooks React tout prêts

• Maintenir un code propre et testable

• Réutiliser ta logique entre client et serveur

Que ce soit pour la validation de formulaires, le traitement d'images, ou des calculs de la mort, WebAssembly avec GoWM ouvre de nouvelles possibilités pour tes applications web

Le code source complet de cet exemple sera bientôt disponible sur GitHub.

A plus ! 🚀

Pourquoi Prompt My Project ?

Les assistants IA sont devenus des alliés incontournables pour les développeurs, mais leur efficacité dépend largement de la qualité des informations qu’ils reçoivent. Fournir le contexte complet et pertinent d’un projet en mode manuel peut prendre des heures, surtout pour des projets volumineux. La mission de PMP est simple : automatiser cet effort tout en garantissant des prompts précis et pertinents.

Une idée née d'un besoin quotidien

En tant que développeur, j’ai constaté à quel point il était difficile de collaborer efficacement avec des IA sur des projets techniques complexes. Les prompts devaient inclure la structure du projet, des extraits de fichiers pertinents, ainsi que des détails critiques, mais rassembler ces informations à la main devenait vite un travail répétitif et fatigant. C’est ainsi qu’est apparue l’idée de PMP : un outil capable d’extraire automatiquement les éléments clés d’un projet et de les intégrer dans un prompt structuré, prêt à être utilisé avec des modèles d’IA.

Qu’est-ce que Prompt My Project ?

Prompt My Project est un outil en ligne de commande capable de scanner ton projet, d’en analyser la structure, et de générer un prompt détaillé contenant uniquement les informations pertinentes pour tes interactions avec une IA. En quelques secondes, PMP extrait :

• La structure hiérarchique des dossiers et fichiers.

• Le contenu sélectionné des fichiers pertinents.

• Une estimation du nombre de tokens utilisés.

L’objectif : donner à l’IA une compréhension rapide et claire de ton projet, afin qu’elle puisse répondre de manière précise à tes besoins.

Fonctionnalités principales

1. Analyse intelligente et récursive

PMP explore automatiquement l’ensemble de la structure de ton projet, détectant les dossiers et les fichiers importants. Cette exploration récursive établit une cartographie complète de ton projet, ce qui permet à l’IA de mieux comprendre le contexte global.

2. Détection automatique des fichiers binaires et respect des règles .gitignore

• PMP identifie et exclut les fichiers binaires (images, exécutables, etc.) pour se concentrer uniquement sur les fichiers texte pertinents.

• L’outil respecte également les règles définies dans ton fichier .gitignore, garantissant que seuls les fichiers nécessaires sont inclus dans le prompt.

3. Inclusion et exclusion personnalisées des fichiers

Tu peux affiner les résultats en spécifiant :

• Les fichiers ou extensions à inclure (par exemple, uniquement les fichiers .py ou .md).

• Les répertoires ou fichiers à exclure (comme les dossiers node_modules ou tests).

Cette flexibilité te permet de personnaliser le prompt en fonction de tes besoins spécifiques.

4. Performance optimisée

Grâce à un système de traitement concurrent avancé, PMP est capable d’analyser rapidement même les plus grands projets. L’outil utilise des techniques telles que :

• Le traitement parallèle via un pool de workers.

• La mise en cache des fichiers pour éviter des lectures multiples.

• La gestion optimisée des ressources mémoire.

5. Génération de prompts structurés

PMP produit un fichier contenant :

1. Résumé global : Une description concise de la structure du projet.

2. Structure hiérarchique : Une vue complète des dossiers et fichiers.

3. Extraits de contenu : Les parties importantes des fichiers sélectionnés.

4. Estimation des tokens : Calcul précis du nombre de caractères et de tokens pour anticiper les limites des modèles d’IA.

Les prompts sont générés dans un répertoire dédié (./prompts/ par défaut), avec un nom horodaté (prompt_YYYYMMDD_HHMMSS.txt) pour un suivi facile.

Installation simple sur toutes les plateformes

PMP est compatible avec Linux, macOS, et Windows, prise en charge des architectures amd64 (x86_64) et arm64 (aarch64).

macOS/Linux

curl -fsSL https://raw.githubusercontent.com/benoitpetit/prompt-my-project/master/scripts/install.sh | bash

Windows

irm https://raw.githubusercontent.com/benoitpetit/prompt-my-project/master/scripts/install.ps1 | iex

Commandes et exemples d’utilisation

Syntaxe de base

pmp [options] [path]

Exemples concrets

Analyse globale du projet

pmp

Inclure uniquement certains fichiers

pmp --include "*.py" --include "*.md"

Exclure des répertoires spécifiques

pmp --exclude "tests/*" --exclude "node_modules/"

Personnaliser le répertoire de sortie

pmp --output ./mes_prompts

Analyser un projet Go

Tu peux analyser uniquement les fichiers sources Go, tout en excluant les tests et les dépendances :

pmp --include "*.go" --exclude "*_test.go" --exclude "vendor/"

Exemple de Prompt généré :

PROJECT INFORMATION
-----------------------------------------------------
• Project Name: prompt-my-project
• Generated On: 2025-03-01 15:53:46
• Generated with: Prompt My Project (PMP) v1.0.0
• Host: master
• OS: linux/amd64

FILE STATISTICS
-----------------------------------------------------
• Total Files: 4
• Total Size: 37 kB
• Avg. File Size: 9.2 kB
• File Types:
  - .go: 1 files
  - <no-extension>: 1 files
  - .md: 1 files
  - .sum: 1 files

TOKEN STATISTICS
-----------------------------------------------------
• Estimated Token Count: 9318
• Character Count: 37269

=====================================================

PROJECT STRUCTURE:
-----------------------------------------------------

└── prompt-my-project/
    ├── LICENSE
    ├── README.md
    ├── go.sum
    └── main.go


FILE CONTENTS:
-----------------------------------------------------
... // contenu de vos fichiers organiser et trier proprement
..

Fonctionnement avancé sous le capot

1. Gestion des workers

PMP optimise la vitesse d’analyse grâce à des pools de workers, en adaptant automatiquement le nombre de threads disponibles en fonction des ressources matérielles.

2. Détection binaire sophistiquée

L'outil combine plusieurs mécanismes pour identifier les fichiers binaires :

• L’analyse de l’extension (ex. .png, .exe).

• La vérification du type MIME.

• La détection de caractères non textuels dans le contenu.

3. Mise en cache intelligente

Le contenu des fichiers est mis en cache temporairement pour éviter des lectures répétées lors de l’analyse.

Configuration par défaut de PMP

PMP propose un ensemble de paramètres par défaut, ajustables selon tes besoins via des options en ligne de commande ou des variables d’environnement.

Utilisation dans un pipeline CI/CD

PMP s’intègre facilement dans un pipeline CI/CD pour générer automatiquement des prompts à chaque modification importante du projet. Voici un exemple de configuration dans GitLab CI :

generate_ia_prompt:
  stage: analysis
  image: golang:1.21
  script:
    - curl -sSL https://raw.githubusercontent.com/benoitpetit/prompt-my-project/master/scripts/install.sh | bash
    - pmp --output ./artifacts/prompts
  artifacts:
    paths:
      - ./artifacts/prompts/

Conclusion

Prompt My Project marque une avancée dans l’optimisation des interactions entre les développeurs et les modèles d’intelligence artificielle. En automatisant la création de prompts bien structurés, PMP te fait gagner un temps précieux, améliore la précision des réponses de l’IA et simplifie la gestion technique de ton projet.

GitHub pour découvrir, contribuer ou partager cet outil open source. Ensemble, améliorons la collaboration entre les développeurs et l’intelligence artificielle !

1. GORM – Le magicien des bases de donnée

   ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1729236364753/c42de14d-595a-4083-9323-daec7ced61d3.png align="left")

Tu bosses avec des bases de données relationnelles comme MySQL ou PostgreSQL ? GORM est là pour toi. C’est un ORM (Object-Relational Mapping) qui te permet de gérer tes bases de données comme un pro : migrations, relations complexes, tout ça en un claquement de doigts. Tu gagnes du temps et tes requêtes deviennent du velours.

1. Gin – Ton framework web ultra-léger

   ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1729173585187/c8b2464d-83e9-44b5-bbee-6913803684f7.png align="center")

Gin est parfait si tu cherches à développer des API ultrarapides. Il est simple, performant, et super utilisé dans l’écosystème Go. Pour les micro-services ou les architectures modernes, c’est le framework à avoir dans ta boîte à outils.

1. Echo – L’alternative plus flexible

   ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1729173612298/3129f11b-3394-45cb-94b9-70f8152b64c8.png align="center")

T’as entendu parler de Echo ? C’est une alternative à Gin, mais avec un poil plus de flexibilité, notamment pour gérer des middlewares et personnaliser le traitement des erreurs. Si tu construis une API qui a besoin de souplesse, tu devrais tester.

1. Viper – Gestion des configurations en mode expert

   ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1729173652131/91671e49-b324-412f-8b2e-c4ec03cedf64.png align="center")

Ton projet a besoin de configurations différentes pour chaque environnement ? Viper s’occupe de tout. Que tu utilises des fichiers YAML, JSON, ou des variables d’environnement, cette bibliothèque te permet de charger et de gérer les configurations à la volée. C’est l’une des plus appréciées dans le monde Go.

1. Cobra – La référence pour créer des CLI

   ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1729173680978/c0e344e3-df7f-4516-a8fc-77d94718e1ff.png align="center")

Si tu rêves de créer des outils en ligne de commande stylés (et utiles !), Cobra est ta meilleure option. En plus d'être simple à prendre en main, il te génère de la doc automatiquement. Imagine pouvoir créer un CLI aussi clean que ceux de Kubernetes, c’est exactement ça avec Cobra.

1. Gorilla Mux – La flexibilité des routes HTTP

   ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1729173698130/5b2470c5-8506-4524-8116-2dbffb278fe0.png align="center")

Si tu construis une API ou un serveur HTTP, Gorilla Mux est l’outil de routing dont tu as besoin. Il te permet de gérer des routes dynamiques avec des expressions régulières, et il est hyper performant. C’est un excellent choix pour des applications web qui ont besoin de flexibilité dans la gestion des URL.

1. GoMobile – Développement mobile avec Go

   ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1729173709739/59d8cf8d-0a01-454f-b3c8-ff63d6ad834d.png align="center")

Oui, Go est aussi capable de faire du développement mobile ! Avec GoMobile, tu peux créer des apps pour Android et iOS. Go étant réputé pour sa performance, c’est une belle option pour ceux qui veulent éviter les surcouches comme Flutter ou React Native. Tu écris ton code Go et il est transpilé en natif pour les deux plateformes. Du mobile léger et performant, ça te tente ?

1. GoKit – Parfait pour les micro-services

   ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1729173732089/3c9600ad-8c1f-4804-96d2-ebc171876cef.png align="center")

Si tu travailles sur des systèmes distribués ou des micro-services, GoKit est fait pour toi. Ce framework est modulaire, donc tu n’embarques que ce dont tu as besoin. Pas de superflu, juste l’essentiel pour gérer le load balancing, le service discovery, etc. Super utile pour les environnements cloud ou les architectures micro-services.

1. GoConvey – Tests automatisés à la cool

   ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1729173769294/43ffd2e2-8e3c-4a2d-8467-55df340fb1d4.png align="center")

Tester, c’est crucial, mais ça peut vite devenir barbant. GoConvey rend ça beaucoup plus agréable en te fournissant une interface visuelle en temps réel pour suivre tes tests. En plus, il est super léger et intègre des fonctions d’assertions puissantes.

1. Prometheus – Monitoring avancé pour tes services

   ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1729173788390/3f02585b-6790-4e7e-9324-a60c453ce8a6.png align="center")

Si tu veux surveiller tes applications en production, Prometheus est LA solution. C’est une plateforme de monitoring open-source qui collecte des métriques en temps réel. Il est idéal pour tout ce qui est cloud-native, et il est largement adopté dans le monde DevOps. Un must pour assurer la stabilité de ton infrastructure.

Bonus : Fyne – Crée des interfaces graphiques (GUI)

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1729173801088/02f024ff-760f-44d4-8760-7a29f9004cb3.png align="center")

Tu as envie de faire du développement d’applications desktop avec Go ? Fyne est un framework pour créer des interfaces graphiques qui tournent sur Windows, macOS et Linux. Il est facile à utiliser et produit des interfaces modernes avec du code Go, sans avoir à te plonger dans du C++ ou d'autres frameworks lourds.

Voilà, tu es armé pour affronter tes projets Go avec ces bibliothèques indispensables. Que tu fasses du web, du mobile, des micro-services, ou du desktop, il y a forcément une librairie qui te simplifiera la vie. Si tu n’as pas encore testé certaines de ces pépites, c’est le moment de te lancer !

Pourquoi Better Auth, c’est une vraie révolution ?

Tu vois, Better Auth, c’est un peu comme le couteau suisse des bibliothèques d'authentification. Que tu bosses avec React, Vue, Next.js ou même des frameworks plus exotiques comme Astro ou Svelte, cette solution est agnostique. Elle s'intègre partout et surtout, sans douleur. Tu n’as plus à jongler avec des plugins qui ne fonctionnent que dans tel ou tel écosystème.

Focus sur la simplicité… mais pas au détriment de la puissance

Si tu as déjà tenté de mettre en place une authentification manuellement, tu sais combien ça peut devenir un casse-tête. Mais avec Better Auth, c’est presque magique : tu veux intégrer une connexion via email et mot de passe ? Boum, c'est fait. Tu veux rajouter une couche de sécurité avec du 2FA ? C’est inclus et activable en quelques lignes.

Imagine, tu travailles sur une grosse application multi-utilisateur : tu peux gérer des organisations entières avec des accès différenciés. Pas mal, non ? Et tout ça, sans que tu te retrouves à configurer mille options obscures.

L’écosystème Better Auth : extensibilité à fond

Là où Better Auth marque vraiment des points, c’est dans son écosystème de plugins. Tu as besoin de fonctionnalités spécifiques ? Tu n’as qu’à piocher dans les plugins, qu’ils soient créés par la communauté ou directement par l’équipe Better Auth. Et comme tout est en TypeScript, la sécurité des types est omniprésente. Ton code devient plus robuste, sans que tu aies à réfléchir deux heures à chaque manipulation.

Et pour les réfractaires aux jetons JWT ?

Je te vois venir : « encore un outil qui va me forcer à utiliser des JWT partout… ». Eh bien non ! Better Auth a fait un choix intéressant : pas de support natif pour les jetons JWT. Leur approche se concentre sur des meilleures pratiques, en évitant les solutions "universelles" parfois trop rigides. Si tu as absolument besoin de JWT, tu pourras l’ajouter via un plugin tiers, mais la philosophie de Better Auth est avant tout de te proposer des solutions adaptées et optimisées pour ton projet.

Un projet jeune mais prometteur

Lancé il y a seulement quelques mois, Better Auth a déjà conquis de nombreux développeurs. Avec plus de 1,800 stars sur GitHub et une communauté en pleine effervescence, c’est clairement un projet à suivre de près. Et ne t’inquiète pas, bien qu’il soit encore en bêta, il est déjà assez mature pour être intégré dans des projets en production.

Un exemple d’utilisation

Bon, c’est bien beau tout ça, mais comment ça marche concrètement ? Voici un exemple basique pour que tu voies à quel point c’est simple de démarrer avec Better Auth.

import { betterAuth } from 'better-auth';

const auth = betterAuth({
  database: {
    provider: 'postgresql',
    url: process.env.DATABASE_URL,  // On récupère l'URL de la base de données depuis les variables d'environnement
  },
  emailAndPassword: {
    enabled: true,  // Authentification par email et mot de passe activée
  },
  plugins: [
    organization(),  // Gestion des organisations
    twoFactor(),     // Authentification à deux facteurs
  ],
});

// Exemple d'utilisation pour gérer un utilisateur :
auth.createUser({
  email: 'user@example.com',
  password: 'securepassword123',
}).then(user => {
  console.log('Utilisateur créé:', user);
}).catch(err => {
  console.error('Erreur lors de la création de l\'utilisateur:', err);
});

Tu vois, avec seulement quelques lignes, tu peux déjà connecter une base de données PostgreSQL, activer l’authentification par email et mot de passe, et ajouter des plugins comme le 2FA ou la gestion des organisations. C’est super rapide à mettre en place !

Prêt à te lancer ?

Si tu veux essayer par toi-même, rien de plus simple. En quelques minutes, tu peux mettre en place un système d'authentification qui t'appartient vraiment. Pas besoin de t’appuyer sur des services tiers coûteux ou de perdre du temps sur des configurations complexes. Tu veux voir comment ça marche en vrai ? Une démo en ligne t’attend, prête à te montrer la puissance de cette bibliothèque.

Pour conclure, Better Auth, c’est un peu le superhéros discret de l'authentification en TypeScript : complet, agnostique, facile à utiliser et extensible. Que demander de plus ? Allez, va tester tout ça et prépare-toi à dire adieu aux galères d’auth !

Pourquoi j’ai créé JSrun ?

Tout est parti d’un projet perso où je bossais sur un petit bot. Je voulais pouvoir exécuter mes scripts rapidement, mais entre les dépendances Node.js, les versions de modules à jongler, et ces fameux dossiers node_modules qui bouffent de l’espace, c'était la galère. Et là, je me suis dit : « Pourquoi ne pas créer un outil qui gère tout ça pour moi ? » C’est comme ça qu’est né JSrun !

Avec JSrun, tu peux exécuter des scripts .jsr, .js, .mjs et même .ts sans te prendre la tête. Plus besoin d'installer manuellement les packages à chaque fois. Tu lances ton script et si une dépendance manque, JSrun l'installe automatiquement pour toi. Tranquille, non ?

Le format .jsr : C’est quoi exactement ?

Le .jsr, c’est une petite touche perso que j’ai ajoutée. Ce n’est pas un nouveau langage ou quoi que ce soit. En fait, c’est toujours du pur JavaScript ou TypeScript, mais avec une extension dédiée à JSrun. Ça permet simplement de repérer facilement les scripts qui sont destinés à être exécutés avec cet outil. C’est une manière pratique d’organiser tes projets et de rendre tout ça plus propre.

Mais ne t'inquiète pas, JSrun fonctionne aussi très bien avec les extensions classiques comme .js ou .ts. Le format .jsr est là pour les adeptes de l’organisation !

JSrun : Les fonctionnalités qui vont te plaire

C’est pas juste un lanceur de scripts, c’est un vrai couteau suisse. Voilà ce qu’il peut faire pour toi :

• Gestion automatique des modules : Fini les npm install. Si un module manque, JSrun le télécharge pour toi.

• Spécification des versions dans les imports : Tu peux directement définir la version d’un module dans tes imports, et JSrun gère tout.

• Mise en cache intelligente : Les modules sont mis en cache localement pour accélérer les exécutions suivantes.

• Journalisation colorée : Grâce à chalk, tes logs sont non seulement plus lisibles, mais aussi plus stylés !

• Gestion des erreurs : Des messages clairs et détaillés pour déboguer sans prise de tête.

• Extensible : Prêt à évoluer selon tes besoins !

Installation : Simple et rapide

Avant de commencer, assure-toi d’avoir Node.js sur ta machine. Si ce n’est pas le cas, télécharge-le ici.

Pour installer JSrun, une seule commande suffit :

npm install -g jsrun-cli

Comment utiliser JSrun ?

Lancer un script

Une fois installé, tu peux exécuter n'importe quel script, où que tu sois sur ton système. Par exemple, si tu as un fichier monscript.jsr :

jsrun monscript.jsr

Ça prend en charge les extensions .jsr, .js, .mjs, et .ts. Peu importe le format, il gère tout !

Passer des arguments au script

Besoin de passer des options à ton script ? Facile avec JSrun :

jsrun monscript.jsr --port=4000 --env=production

Dans ton script, tu peux récupérer ces arguments comme ceci :

const args = process.argv.slice(2);
const port = args.find((arg) => arg.startsWith("--port="))?.split("=")[1] || 3000;
const env = args.find((arg) => arg.startsWith("--env="))?.split("=")[1] || "development";

console.log(`Exécution sur le port ${port} en mode ${env}.`);

Créer un nouveau script

Envie de démarrer avec un nouveau script ? Rien de plus simple :

jsrun create monscript.jsr

Cela te génère un fichier de script prêt à être utilisé avec JSrun.

Simuler l'exécution du script

Si tu veux vérifier ce que ton script ferait sans réellement l’exécuter, tu peux utiliser l’option --dry-run pour une simulation :

jsrun monscript.jsr --dry-run

Cela permet de voir ce qu'il se passerait lors de l'exécution, sans toucher aux modules ni exécuter de code.

Afficher le retour en format JSON

Besoin de voir les résultats d’exécution en format JSON ? Facile avec l’option --json :

jsrun monscript.jsr --json

Super pratique pour des retours structurés et facilement intégrables dans des workflows automatisés.

Nettoyer les packages installés

Quand ton projet commence à accumuler des modules dont tu n'as plus besoin, un bon nettoyage s’impose. JSrun peut s’en charger avec une simple commande :

jsrun --clean

Des performances au top, sans efforts

Un des gros points forts de JSrun, c’est sa mise en cache des modules. Les modules que tu utilises sont stockés localement dans ~/.jsrun/node_modules. Résultat : les exécutions suivantes sont beaucoup plus rapides. Et tout ça, sans que tu aies à lever le petit doigt !

Exemples et contributions

Si tu veux voir des exemples de scripts .jsr, va faire un tour dans le dossier /examples du projet sur GitHub. J’ai mis quelques exemples sympas pour t’inspirer.

Et si tu as des idées d’amélioration, n’hésite pas à contribuer ! Forke le dépôt, fais tes modifs, et soumets un pull request. Toutes les idées sont les bienvenues.

Conclusion

Avec JSrun, mon but était de simplifier au maximum l’exécution de scripts JavaScript et TypeScript, sans avoir à se battre avec les dépendances ou les versions de modules. Que tu bosses sur un projet rapide ou quelque chose de plus complexe, JSrun te permet de te concentrer sur le code, en laissant de côté les aspects techniques.

Télécharge-le dès maintenant sur npm et lance-toi !

Qu’est-ce que fait CML exactement ?

Imagine un couteau suisse pour tes fichiers de logs : CML te permet de lire, filtrer, exporter, et même suivre en temps réel les fichiers de logs, directement depuis ton terminal. Tu navigues dans tes logs avec des commandes simples, tu peux filtrer par niveau (INFO, WARNING, ERROR), rechercher des termes spécifiques, et exporter le tout pour un traitement ultérieur. Plus besoin de fouiller dans des tonnes de lignes inutiles, tu récupères juste ce qui t’intéresse.

Quelques fonctionnalités clés :

• Pagination : Lis tes logs : page par page avec une taille que tu choisis.

• Filtrage avancé : Recherche par niveau de logs (INFO, WARNING, ERROR) et par mot-clé.

• Mode live : Suis les nouveaux logs qui arrivent en temps réel, comme un pro avec tail -f mais en mieux, sans te prendre la tête avec des commandes interminables.

• Export : Tu peux exporter directement les logs filtrés dans un fichier. c’est pratique !

• Interface interactive : Utilise ton clavier pour naviguer et chercher dans les logs, avec : Haut, Bas, etc..

Installation :

Télécharge et installe CML comme un chef avec wget et tar :

wget -O /tmp/cml.tar.gz https://github.com/benoitpetit/cml/releases/download/v1.2.0/cml-linux-amd64.tar.gz
sudo tar -xzvf /tmp/cml.tar.gz -C /usr/local/bin/
sudo chmod +x /usr/local/bin/cml

Et voilà, CML est installé. Vérifie avec :

cml --help

Comment utiliser CML ?

La commande de base est simple :

cml <chemin_fichier_logs> [options]

Voici les options disponibles :

• --filter <niveau> : Filtre les logs par niveau (INFO, ERROR…)

• --search <terme> : Cherche un terme dans les logs.

• --pagesize <taille> : Définit le nombre de logs par page.

• --export <fichier> : Exporte les logs filtrés dans un fichier.

• --live : Active le mode temps réel pour suivre les logs au fur et à mesure.

Exemples d’utilisation

1. Filtrage et export : Filtrer les erreurs et chercher "timeout", puis exporter dans un fichier.

   cml logs.txt --filter ERROR --search "timeout" --export erreurs_timeout.txt
   

2. Suivi en temps réel : Suivre les logs en temps réel avec une pagination de 20 lignes :

   cml logs.txt --live --pagesize 20
   

Pourquoi tu devrais essayer ?

CML, c’est un peu comme grep, tail, et less réunis dans un outil conçu pour rendre tes fichiers de logs plus faciles à gérer. Plus besoin de multiplier les commandes ou de galérer avec des sorties interminables. Que tu veuilles juste checker un log en direct ou extraire les erreurs d’un fichier énorme, CML t’offre une expérience optimisée, fluide et surtout ultrarapide.

CML n’est pas parfait, on va dire qui est en beta, il peut y avoir des erreurs, mais si tu veux l’essayer, va faire un tour sur mon GitHub. Fais-moi savoir ce que tu en penses, et n’hésite pas à contribuer si le cœur t’en dit !

Prerequisites

• A computer with Docker and Docker Compose installed.
• A GitHub account to access configuration files.

Step 1: Retrieve Configuration Files

Begin by downloading Supabase's configuration files from GitHub. Navigate to the Supabase GitHub repository and obtain the configuration files. You can either download them as a ZIP file or clone the repository using the command line.

Clone the Repository

To clone the repository, execute the following command:

git clone https://github.com/supabase/supabase.git

Navigate to the Configuration Directory

Change your working directory to the Docker configuration files:

cd supabase/docker/

Copy the Example Environment File

Create a .env file based on the example provided:

cp .env.example .env

Step 2: Modify the .env Configuration File

Before launching Supabase, you need to configure essential parameters. Open the .env file for editing:

nano .env

Adjust the following lines accordingly:

• POSTGRES_USER: Change "supabase" to your preferred database username.
• POSTGRES_PASSWORD: Change "supabase" to your chosen database password.
• PGDATA: Update the path (e.g., "/var/lib/postgresql/data/pgdata") to your desired location for storing database data.

Step 3: Launch Supabase with Docker

Once your configurations are set, you can start Supabase using Docker. In the terminal, while still in the supabase/docker/ directory, run:

docker-compose up -d

This command runs Supabase in daemon mode, allowing it to operate in the background while displaying startup messages in the terminal.

Step 4: Configure Supabase

After launching Supabase, access the admin interface by navigating to http://localhost:3000 in your web browser. Log in with the username and password specified in your .env file. Once logged in, you can create tables, add data, and configure access permissions. Additionally, utilize the REST API to interact with your database from both front-end and back-end applications.

Conclusion

Setting up a self-hosted Supabase instance using Docker is a straightforward process that requires minimal configuration. This method allows you to deploy Supabase on your server or private cloud, giving you greater control over your data and performance. Explore Supabase’s advanced features to fully leverage its capabilities and enhance your development experience.

If you found this content helpful, consider supporting the creator on Liberapay or Buy Me a Coffee.

Qu'est-ce que ljdhar ?

Ljdhar est un outil conçu pour les fans du Journal du Hacker, le site communautaire qui référence les meilleurs contenus francophones sur l'informatique et le numérique. Ce package NPM utilise Puppeteer pour récupérer les données du Journal du Hacker et vous les renvoyer sous forme d'objets JavaScript, prêts à être intégrés dans vos projets.

Avec ljdhar, vous pouvez :

• Récupérer les derniers articles

• Les trier par score

• Les rechercher par tag ou par titre

Fonctionnalités

Ljdhar offre plusieurs fonctions pour manipuler les articles du Journal du Hacker :

1. getPostToLJDH(numStories: number): Récupère les derniers articles.

2. sortedByScore(stories: Story[]): Trie les articles par score.

3. searchArticlesByTag(tag: string, numStories: number): Recherche des articles par tag.

4. searchArticles(search: string, numStories: number): Recherche des articles par titre.

Chaque fonction renvoie un tableau d'objets Story, contenant les détails de chaque article (titre, URL, score, tags, nombre de commentaires, nom d'utilisateur de l'auteur).

Installation

Pour installer ljdhar, exécutez simplement :

npm install ljdhar

Utilisation

Voici quelques exemples d'utilisation de ljdhar :

import { getPostToLJDH, sortedByScore, searchArticlesByTag, searchArticles } from 'ljdhar';

// Obtenir les 10 derniers articles
getPostToLJDH(10)
  .then(stories => {
    console.log(stories);
  }).catch(err => {
    console.log(err)
  });

// Obtenir les 10 derniers articles et les trier par score
getPostToLJDH(10)
  .then(stories => {
    const sortedStories = sortedByScore(stories);
    console.log(sortedStories);
  }).catch(err => {
    console.log(err)
  });

// Rechercher des articles avec le tag 'javascript'
searchArticlesByTag('javascript', 10)
  .then(stories => {
    console.log(stories)
  }).catch(err => {
    console.log(err)
  });

// Rechercher des articles contenant 'hacker' dans le titre
searchArticles('hacker', 10)
  .then(stories => {
    console.log(stories)
  }).catch(err => {
    console.log(err)
  });

Contributions et feedback

Ljdhar a été initialement conçu pour un usage personnel, mais je suis ouvert aux suggestions et aux idées d'amélioration. N'hésitez pas à me contacter si vous avez des idées !

Plus d'informations

• NPM : https://www.npmjs.com/package/ljdhar

• Github : https://www.npmjs.com/package/ljdhar

Merci de votre intérêt pour ljdhar ! J'espère que cet outil vous sera utile dans vos projets. Happy coding ! 🚀

Soutien

Si Ljdhar vous a facilité la vie, pensez à soutenir son créateur sur Liberapay ou Buy Me a Coffee.

Là où Bun frappe fort, c'est avec ses performances étonnantes, dépassant largement celles de Node Cela s'explique en partie par l'utilisation du puissant moteur JavaScriptCore, déjà utilisé dans Safari, mais optimisé de ouf  par Bun grâce à des ajouts en Zig.

Les tests ont parlé : Bun est en moyenne 2 voir 3 fois plus rapide que Node pour les applications simples, et les avantages se multiplient pour les applications complexes, à voir dans le temps.

Bun se démarque également par sa flexibilité. Conçu à partir de zéro, il a la capacité d'adopter de nouvelles fonctionnalités et API au fil du temps. Par exemple, il prend en charge les modules TypeScript natifs pour simplifier le développement, et s'entend très bien avec les modules WebAssembly, ouvrant la porte à des applications Web à la pointe de la technologie.

L'installation et l'utilisation de Bun sont un jeu d'enfant. Vous téléchargez simplement le binaire correspondant à votre système d'exploitation et lancez le tout. De plus, il partage le même système de modules que Node, facilitant la transition des applications existantes.

Pour installer Bun, il vous suffit d'exécuter la commande suivante, et rien de plus :

curl -fsSL https://bun.sh/install | bash

Plus d'informations ici : https://bun.sh/

Lorsque vous souhaitez créer un projet, vous avez deux options : vous pouvez utiliser la commande create ou init

bun create <template> [<destination>] 

Plus d'informations ici : https://bun.sh/docs/cli/bun-create

Alternativement, vous pouvez initialiser un projet dans un dossier en utilisant la commande init :

bun init

Plus d'informations ici : https://bun.sh/docs/cli/init

Après avoir configuré votre projet, vous pouvez utiliser le gestionnaire de paquets Bun pour installer des packages, par exemple, pour installer le package NPM sqlite3, exécutez la commande suivante :

bun add sqlite3

Plus d'informations ici : https://bun.sh/docs/cli/add

Pour exécuter votre projet avec Bun, utilisez la commande suivante en spécifiant le nom de votre fichier de départ :

bun run index.ts

Plus d'informations ici : https://bun.sh/docs/cli/run ou en mode --watch

bun run --watch index.ts

Plus d'informations ici : https://bun.sh/docs/runtime/hot

Bien entendu, Bun propose de nombreuses autres fonctionnalités, que vous pouvez découvrir dans la documentation complète : https://bun.sh/docs/ une serie sur bun peu etre

Bun est en train de secouer le monde JavaScript avec ces performances exceptionnelles et sa flexibilité sans limites ! Même s'il est encore jeune, je pense que c'est déjà un choix solide pour les développeurs JS. en tout qu'à, ça l'est pour moi !

De mon côté, j'utilise Bun depuis plusieurs mois, et je dois dire que c'est le pied ! Pas de problèmes majeurs à signaler, tout roule. J'apprécie particulièrement la possibilité d'utiliser à la fois les importations ES6 et les require CommonJS dans un même fichier, une fonctionnalité super pratique.

Un autre point qui m'a tapé dans l'œil, c'est la facilité d'intégration d'un fichier .env, sans prise de tête pour installer des dépendances supplémentaires. De plus, le watcher est inclus par défaut avec le drapeau --watch simplifiant grandement le processus de développement.

Et je ne peux pas passer sous silence les performances de Bun, surtout grâce au système de gestion des paquets, qui carbure à la vitesse de la lumière.

Bref, je prévois de continuer à explorer Bun, et je garde un œil attentif sur l'évolution du projet. C'est la solution idéale pour mes besoins, et je suis sûr qu'elle a un bel avenir. Si vous cherchez un runntime Javascript qui envoie du lourd, Bun est le choix à faire. c'est par ici : https://bun.sh/

Soutien

Si cet article vous a plu, pensez à soutenir son créateur sur Liberapay ou Buy Me a Coffee.