Vous avez déjà essayé de dessiner une TUI (Interface utilisateur pour le Terminal) à la main dans votre IDE ?

Genre, calculer les paddings d'une Box ANSI à la mano et compter les caractères Unicode pour aligner trois colonnes ? Pffff quelle galère !! Hé bien cette mauvaise expérience, Javier Alonso Gómez, Staff Design Technologist chez Docker, vient de la transformer en simple drag-and-drop avec son outil TUIStudio .

En gros, c'est comme Figma mais pour vos applis terminal.

Vous lancez l'éditeur, vous balancez des composants sur un canvas, et un aperçu ANSI temps réel vous montre ce que ça donnera dans un vrai terminal. Il y a 21 composants prêts à l'emploi (Box, Button, TextInput, Table, Tree, Modal, Tabs, Spinner...), avec un moteur de layout qui supporte Absolute, Flexbox et Grid.

C'est du CSS pour le terminal si vous préférez et le truc cool, c'est que ça reste fidèle au rendu final, donc fini les tableaux qui débordent sans raison !

J'suis pas encore super doué !

Côté thèmes, vous avez également le droit à 8 palettes intégrées (Dracula, Nord, Solarized, Monokai, Gruvbox, Tokyo Night, Nightfox et Sonokai), et le canvas se met à jour live quand vous changez. Sympa, hein !

Niveau export, TUIStudio cible les frameworks Ink (TypeScript), BubbleTea (Go), Blessed (JavaScript), Textual (Python), OpenTUI (TypeScript) et Tview (Go) mais d'après ce que j'ai lu sur le site officiel, la fonction d'export vers tout ça n'est pas encore opérationnelle. Mais ça m'étonne car lors de mes tests, j'ai quand même pu voir que ça fonctionnait... Donc j'sais pas, peut-être que le site web n'a pas été mis à jour et que l'export est bien opérationnel ?

L'export

Ça tourne sur macOS Apple Silicon, Windows et Linux (.deb) et le code est sous licence MIT sur le repo GitHub .

Amusez-vous bien !

Justin Poehnelt, Senior Developer Relations Engineer chez Google, vient de balancer sur Github un outil en ligne de commande (CLI), codé en Rust qui permet de faire un truc trop pratique, à savoir piloter entièrement Workspace depuis le terminal. Ce logiciel nommé GWS est donc capable de gérer Gmail, Drive, Calendar, Sheets et sept autres services Google d'un coup. Et en plus, comme il a été conçu pour les agents IA, donc c'est pas juste pour vous et votre terminal !

Une fois installé via npm, cargo, brew ou un binaire pré-compilé, vous tapez gws auth login pour vous authentifier via OAuth et vous pouvez ensuite attaquer onze services depuis votre shell : Drive, Gmail, Calendar, Sheets, Docs, Chat, Admin, Apps Script, Tasks, Workspace Events et Model Armor.

Niveau archi, au lieu de hard-coder chaque commande dans le binaire, gws interroge tout simplement le Discovery Service de Google au démarrage et reconstruit son arbre de commandes à la volée. Du coup quand Google ajoute un endpoint à l'API Sheets, le CLI le voit apparaître tout seul. C'est trop bien parce que ça évite de devoir attendre une release pour utiliser un éventuel nouveau service de Google. Et pour un agent IA qui re-fetch le schéma à chaque run, c'est plutôt une bonne idée.

Donc en plus de démarrer en moins d'une seconde, GWS crache des sorties en JSON structurées, y'a un mode --dry-run qui montre la requête sans l'envoyer, et de l'auto-pagination via --page-all. Et côté commandes utilitaires, vous avez aussi les + qui sont des helpers cousus main tels que gws gmail +send, gws drive +upload, gws calendar +agenda, gws sheets +append, gws gmail +triage et un gws gmail +standup-report qui résume vos mails de la semaine en quelques lignes.

Le repo embarque aussi 40+ skills d'agent prêts à l'emploi du type "résume mes mails non lus" ou "génère mon rapport", une extension Gemini CLI qui s'installe avec gemini extensions install https://github.com/googleworkspace/cli, et le helper +sanitize-response qui fait passer la sortie par Model Armor (le filtre anti-prompt-injection de Google Cloud) pour éviter les réponses bizarres.

En gros, c'est un outil pensé pour faire piloter votre Workspace par Claude, Gemini ou n'importe quel agent. Comme ça vous allez pouvoir écrire un workflow qui lit vos mails non lus, en fait un résumé, le poste dans un Chat et classe tout ça proprement dans Drive... sans avoir à toucher à la souris ni avoir à utiliser votre cerveau léthargique. Elle est pas belle la vie ?

Sauf que. Le projet porte le disclaimer "This is not an officially supported Google product", et un employé Google a confirmé sur le thread Hacker News (presque 1000 points, quand même) que c'est un projet DevRel. Comprendre : pas de SLA, pas de roadmap garantie, pas d'équipe SRE qui veille au grain. Vous savez comment ça finit chez Google avec ce genre de statut !

Bref si vous êtes chaud pour tester, le binaire est dispo ici . Maintenant reste à voir si Google lui donnera un statut officiel ou si GWS s'éteindra discrètement comme tant d'autres projets internes oubliés...

Deux fois plus rapide que LZ4 en décompression ?? Ah bon c'est possible ? Évidemment, quand Bertrand Lebonnois a publié zxc sur GitHub , et m'a envoyé un email pour me prévenir, j'ai été jeter un œil, surtout aux benchmarks.

Eh bien après analyse, c'est bien réel !

La philosophie de zxc est assez tranchée vous allez voir. Il s'agit d'une lib WORM (Write-Once, Read-Many) qui permet de compresser une fois lentement, à la compilation ou en CI, et ensuite de décompresser comme vous voulez des millions de fois sur les appareils de vos utilisateurs à la vitesse de l'éclair. Avec zxc, on accepte que la compression soit lente et complexe (pour trouver le bitstream parfait), afin que la décompression soit méga rapide et simple pour le processeur. C'est aussi simple que ça.

Le revers de la médaille, c'est que si vous voulez de la compression à la volée ou du streaming temps réel, ce n'est clairement pas adapté. Par contre, si vous produisez des assets une fois et qu'ensuite, vous les servez des milliers de fois, alors vous êtes exactement dans la cible.

En pratique, sur macOS M2 avec un corpus de test standard, zxc dépasse les ~12 000 Mo/s en décompression, contre ~5 600 Mo/s pour LZ4 --fast dans le même test. L'écart reste également hyper solide ailleurs : 1,8× sur ARM serveur (Google Axion) et 2× sur x86_64 (AMD).

Et l'API proposée par zxc ne s'arrête pas à un compresseur basique. En effet, un mode "seekable" permet d'accéder à n'importe quelle position d'une archive sans scanner le fichier depuis le début. Par exemple, vous packagez vos assets de jeux vidéo dans une seule archive zxc, et quand le joueur charge une texture précise, vous lisez directement le bon bloc, et pas tout le fichier.

Côté installation, c'est simple : brew install zxc sur macOS, apt install zxc sous Debian ou Ubuntu, pip install zxc-compress, npm install zxc, cargo add zxc-compress ou vcpkg install zxc sous Windows.

Des bindings officiels existent aussi pour Rust, Python, Node.js, Go et WASM et la communauté a aussi ajouté Nim et Free Pascal de son côté. Et comme c'est codé en C, y'a aucune dépendance lourde.

Sache que pour assoir la crédibilité du projet, zxc a été intégré dans lzbench et TurboBench, les deux outils de référence permettant de comparer les algos de compression. Et le paquet est déjà dispo dans les versions testing et unstable de Debian, ce qui veut dire que les mainteneurs ont validé le truc !

Bref, si vous gérez de la compression d'assets ou de firmwares dans votre pipeline, ça vaut le coup d'y jeter un oeil.

Merci à Bertrand pour l'info et chapeau pour le boulot !

Si vous utilisez Claude Code au quotidien, vous connaissez ce goût de sang qui vous monte dans la bouche lorsque, sans prévenir, cette putain de limite de quota imposée par Anthropic vous explose à la gueule ! Et le pire c'est que vous n'avez pas l'impression d'avoir fait grand chose.

En réalité, la vraie raison c'est surtout le "bruit" de toutes vos sorties shell. Un git log, un cargo test, un npm build... votre agent IA ingère tout ça comme du petit lait alors qu'il n'a besoin que d'une fraction pour comprendre ce qui se passe.

Breeef, c'est pas ouf quoi.

Heureusement pour vous RTK (Rust Token Killer) vient régler en partie ce problème. RTK c'est développé par un Français et c'est un proxy CLI en Rust qui s'intercale entre votre shell et votre agent IA, intercepte les commandes courantes et compresse leur sortie avant qu'elle n'atterrisse dans le contexte de votre agent.

Comme ça plutôt que de massacrer vos prompts ou de changer vos habitudes (et dieu sait que vous avez horreur de changer d'habitudes..lol), il attaque le bruit à la source grâce à 4 stratégies de compression : un filtrage du boilerplate, un regroupement des lignes similaires, une troncature intelligente et de la déduplication des répétitions.

Et tout ça s'intègre merveilleusement bien via un hook pour Claude Code, GitHub Copilot, Cursor, Gemini CLI, Windsurf, Cline, Codex... soit une bonne dizaine d'outils supportés !

Ainsi, votre git status devient rtk git status sans changer quoi que ce soit à vos habitudes... RTK fait tout le filtrage dans votre dos, ce qui est parfait ! C'est un outil qu'on installe et qu'on oublie.

Par exemple un git diff passe de 12 000 tokens à 960, soit 92% d'économie, un npm test tombe de 6 000 à 600 tokens et une session de refactoring sur 12 fichiers passe de 74 700 à 6 960 tokens d'après les benchmarks. En pratique, les utilisateurs constatent des économies autour de 70% sur l'ensemble d'une journée de boulot, ce qui représente plusieurs millions de tokens par semaine pour ceux qui bossent avec des agents IA à plein régime.

Moi ça fait plusieurs mois que je le teste et voici mes stats. Ça donne quand même 81,5 % d'économie de tokens !!

L'installation se fait en une commande : brew install rtk sur macOS, ou un script curl pour les autres plateformes, ou cargo install --git https://github.com/rtk-ai/rtk si vous préférez compiler ça vous-même.

Avec la commande rtk gain vous verrez un tableau comme ci-dessus avec les statistiques par commande, et rtk gain --history donnera l'historique détaillé. Y'a plus de 100 commandes couvertes, de git aux runners de tests en passant par AWS CLI, kubectl et docker. Par contre, ça marche pas super bien si vos sorties de commandes sont déjà très courtes. Ça ne fera pas de miracle mais pour des diffs volumineux ou de suites de tests qui crachent 3 000 lignes à chaque fois, c'est tip top !

Si vous utilisez des agents en mode autonome où une boucle tourne sans intervention, c'est même encore plus pertinent car chaque itération accumule du bruit de façon cumulative, et du coup le contexte se remplit de trucs inutiles à vitesse grand V. Moins de bruit grâce à RTK, c'est donc une économie de tokens mais c'est également un meilleur signal pour votre agent.

RTK est dispo en open source sur GitHub sous licence Apache 2.0.

Flash à sa grande époque c'était quand même tout un truc, mais est-ce que vous vous souvenez de Shockwave ? Le grand frère de Flash (techniquement c'était une autre techno bâtie sur Director mais bref...), qui était capable de faire tourner des trucs bien plus complexes que les vieux .swf ?

Et ben l'équipe derrière DirPlayer s'est tapé tout le reverse-engineering du moteur Director from scratch pour le ressusciter grâce à Rust et le rendre à nouveau fonctionnel dans nos navigateurs modernes !

Faut savoir qu'Adobe a débranché Shockwave Player en avril 2019 et Flash un peu plus tard, et avec eux c'est un pan entier du web rétro qui s'est retrouvé inaccessible du jour au lendemain. Du genre tous ces jeux qui tournaient sur Shockwave.com ou les vieux portails de mini-jeux des années 2000, paf, d'un coup plus moyen d'y rejouer.

Alors heureusement, pour Flash, y'a déjà Ruffle qui fait tourner les bons vieux .swf. Hé bien ici c'est le même principe avec DirPlayer pour les .dcr Shockwave.

L'outil se décline sous 3 formes. D'abord une extension Chrome qui détecte automatiquement les balises Shockwave qui traînent encore sur les vieux sites web, ce qui peut être sympa pour redécouvrir des sites des années 2000.

Y'a aussi une version standalone construite avec Electron qui embarque carrément un debugger Lingo (le langage de scripting de Director, super pratique si vous voulez bidouiller du contenu existant). Et enfin un polyfill JS auto-contenu qui réécrit les et directement sur votre site web.

Perso, pour vous faire une idée, je vous invite surtout à jeter un oeil à la démo web pour tester rapidement parce qu'il n'y a rien à installer. Mais dès que vous voudrez analyser ou debugger un vieux jeu en profondeur, faudra plutôt opter pour la version standalone.

Notez que DirPlayer utilise Ruffle en submodule Git donc les 2 projets sont liés et bonus côté sécurité, le tout tourne en WebAssembly avec le sandboxing du navigateur, donc y'aura plus toutes ces failles qu'on pouvait retrouver à l'époque sur l'ancien plugin Shockwave Player.

Pour les sites qui hébergent encore des applis ou des jeux Shockwave (genre archive.org, avec des musées interactifs ou des jeux des années 2000), c'est une nouvelle corde à leur arc. Et si vous avez de vieux .dcr planqués sur un disque dur, la démo web devrait pouvoir les avaler aussi (faudra tester quoi...).

Bref, grâce à Ruffle pour Flash et DirPlayer pour Shockwave, le web des années 90-2000 n'est pas encore tout à fait mort ! Un peu comme moi finalement ^^

Ouais, je sais, on est le 1er mai, et je suis pas censé bosser mais que voulez-vous on ne se refait pas ^^. Et si j'ai ouvert l'ordi ce matin, c'est pour vous parler de KULA !

KULA est un binaire tout simple qui permet de monitorer très facilement votre serveur Linux en temps réel, sans aucune dépendance. c0m4r , le dev derrière le projet, l'a codé en Go avec une obsession claire : Que ça marche partout sans rien installer à côté !

C'est vrai que les outils de monitoring temps réel sur Linux ont tendance à grossir avec le temps. Netdata est passé par exemple d'un script léger à une plateforme SaaS.

KULA veut faire exactement l'inverse ! Parce que si vous avez un VPS à 5 balles, un Raspberry Pi ou trois homelabs qui ronronnent dans le placard, c'est pas la peine de sortir un bazooka quand il y a ce petit binaire qui fait tout aussi bien.

Vous le posez sur la machine, vous lancez ./kula, et c'est plié ! Il y a même un installeur guidé en une commande (nia nia nia lisez le contenu du .sh avant de le lancer, nia nia nia, je me répète, je sais):

bash -c "$(curl -fsSL https://raw.githubusercontent.com/c0m4r/kula/refs/heads/main/addons/install.sh)"

Côté technique, le projet va chercher ses infos directement dans /proc et /sys toutes les secondes. Comme ça y'a pas besoin d'un programme "agent" séparé à installer, ni besoin de vous lancer dans du scraping HTTP. C'est juste KULA qui tourne en daemon et qui lit ce qui se passe au niveau du kernel.

Les données passent ensuite dans un moteur de stockage maison : un ring-buffer avec trois niveaux (1 seconde brut, 1 minute agrégé, 5 minutes agrégé), chacun ayant une taille max fixe (250 Mo, 150 Mo, 50 Mo par défaut). Et quand la limite est atteinte, les nouvelles données écrasent les vieilles. Comme ça l'usage disque est maîtrisé, et y'a pas besoin de faire de ménage.

Niveau métriques, c'est plutôt complet je trouve... CPU, GPU (VRAM, charge, conso), mémoire, swap, load average, processus par état, températures CPU/GPU/disque, batteries, entropie système, sync horloge. Le réseau remonte les débits par interface, les paquets par seconde, les erreurs, les drops, les retransmissions TCP, les connexions établies...etc.

Et côté disque c'est par composant : IOPS, lectures/écritures par seconde, octets/s, plus l'usage des systèmes de fichiers. Et bien sûr tout ce qui est containers Docker, podman, et même ces cgroups bruts dont vous êtes si fiers ^^, pour ceux qui font tourner des trucs sans Docker.

Et le truc auquel je ne m'attendais pas mais que j'aurais pu anticiper parce que c'est à la modeuuuuh, c'est l'assistant IA via Ollama. Vous configurez une instance Ollama locale, et le dashboard vous laisse causer à un modèle de votre choix qui peut analyser les courbes en cours, exporter du CSV par graphique, et même faire appel à une fonction get_metrics pour interroger les données en mode agent.

Tout ça en local bien sûr. C'est plutôt sympa pour debugger par exemple un pic de CPU récurrent à 3h du matin sans devoir vous taper des heures de graphes !

Le déploiement Docker c'est comme ça :

docker run -d --name kula --pid host --network host
 -v /proc:/proc:ro -v kula_data:/app/data c0m4r/kula:latest

Notez le paramètre --pid host et /proc:/proc:ro : car KULA a besoin de voir l'hôte et pas le container.

Bah ouais, c'est logique, sinon il va monitorer juste son propre container, ce qui n'a aucun intérêt, hein...

Notez que si vous êtes sur un VPS LXC mutualisé bas de gamme, certains hébergeurs restreignent l'accès à /proc du host... et là, malheureusement, KULA ne pourra remonter que ce qu'il voit ce qui est souvent pas grand-chose... sniiif.

Pour les puristes, y'a aussi des paquets .deb, .rpm, AUR pour Arch, et du multi-arch (amd64, ARM, RISC-V). Ça couvre à peu près tout ce qui se croise sur un homelab !

Et côté auth, c'est désactivé par défaut (le port par défaut est le 27960, pas le 80), mais quand vous l'activerez vous tomberez sur de l'Argon2id avec des jetons de session hashés en base.

Par contre, même si y'a quelques alertes internes (clock sync, low entropy, overload), vous n'aurez pas de notifications natives (pas de mail, ni Slack, ni webhook...etc). Et pas de support multi-node non plus puisque KULA monitore une machine à la fois.

Donc si vous avez 30 serveurs, faudra vous farcir 30 instances et 30 dashboards séparés. Pas glop ! Et bien sûr, c'est Linux only parce que tout repose sur /proc et /sys.

C'est encore un projet un peu jeune, donc à voir comment ça vieillit mais pour votre petit VPS perso d'amour ou une machine dans un setup d'auto-hébergement , c'est top pour esquiver à la fois htop qui est trop minimaliste et Grafana qui est trop usine à gaz.

Si vous voulez voir la démo, y'en a une ici : demo.kula.ovh !

Source

Monter un serveur HTTPS local pour bosser sur du Next.js ou du Vite, ça reste étrangement chiant. Faut mkcert pour générer les certifs, faut éditer le /etc/hosts à la mimine, installer caddy ou nginx en reverse proxy par-dessus... bref, vous voyez le diiiiliiiire ! Heureusement, Kamran Ahmed , le mec derrière roadmap.sh, vient de balancer Slim , un binaire Go standalone qui fait tout ça d'un coup.

Et tant qu'à faire, il rajoute aussi des tunnels publics à la ngrok au cas où vous voudriez présenter votre travail de dev payé au lance pierre, à un client pressé.

L'idée c'est donc de taper : slim start myapp --port 3000 et hop, votre app tourne OKLM en local sur le port 3000 et devient accessible via https://myapp.test avec un certif totalement valide reconnu à 100% par votre navigateur.

Ça permet d'esquiver tout config manuelle, puisque le binaire crée une autorité de certification locale (CA) dès le premier lancement, signe ensuite les certifs par domaine, et met à jour /etc/hosts tout seul, sans oublier de rediriger les ports 80/443 sur 10080/10443 sans même avoir besoin de root.

Et cette CA est ajoutée au trousseau du système, donc votre Chrome, Safari ou Firefox (ze best !!) la considèrent immédiatement comme légitime, sans alerte de sécurité. Du tout-en-un comme je l'aime quoi !

L'install se fait en une ligne (pensez à regarder comme d'hab le contenu du fichier .sh avant de le lancer, je ne le répéterais jamais assez) :

curl -sL https://slim.sh/install.sh | sh

slim start myapp --port 3000 --route /api=8080 --route /ws=9000

Datadog Labs vient de sortir pup , un outil CLI codé en Rust qui donne à vos agents IA un accès complet à leur plateforme. L'idée c'est que pendant que Vercel et AWS galèrent de ouf à rendre leurs trucs « agent-friendly », Datadog, lui, dégaine un outil dédié qui expose +200 commandes sur plus de 33 de leurs produits, du monitoring aux SLOs en passant par la sécurité et les incidents.

Côté install c'est du classique, brew tap datadog-labs/pack && brew install pup, puis pup auth login pour le flow OAuth2 avec PKCE.

Plus besoin comme ça de balader vos clés API à vie dans des variables d'env, même si le fallback DD_API_KEY reste là quand même pour d'éventuels cas "headless". Une fois loggué, vous tapez alors par exemple :

pup monitors list

pup metrics query --query="avg:system.cpu.user{*}" --from="1h"

Vous avez déjà voulu créer une appli desktop qui tourne sur Linux, Mac et Windows en même temps ? En Rust, c'était un peu compliqué jusqu'ici. Heureusement, Slint , créé par la société allemande SixtyFPS GmbH, propose une solution sympa !

L'idée, c'est de décrire votre interface dans des petits fichiers .slint (un genre de mini HTML/CSS pour appli native), et de brancher ça à du Rust, du C++, du JavaScript ou du Python. Comme ça, vous codez le visuel d'un côté, la logique de l'autre.

Et ce qui est encore plus cool c'est que leur runtime tient dans 300 KiB de RAM. A titre de comparaison, une appli Electron type Discord en bouffe plusieurs centaines de mégaoctets. Slint tourne donc aussi bien sur un Raspberry Pi, un microcontrôleur STM32, ou directement dans un navigateur via WebAssembly.

Par exemple, SK Signet, un fabricant sud-coréen leader sur le marché américain des bornes de recharge électrique, anime ses écrans tactiles 15 à 32 pouces avec. OTIV fait tourner ses trains autonomes dessus. WesAudio l'utilise également pour son plugin audio pro.

Donc c'est du sérieux et si vous voulez tester sans rien installer, direction SlintPad . Vous tapez du code, et le rendu apparaît dans le navigateur. Ensuite pour débuter un projet Slint en local, faudra faire un cargo install slint-lsp puis utiliser le template slint-rust-template dispo sur GitHub. 2 minutes de compilation plus tard et hop, vous avez votre première fenêtre.

Côté tarif, Slint est gratuit pour les projets open source et gratuit aussi pour les applis desktop, mobile ou web même propriétaires. Seul l'embarqué propriétaire est payant. Donc pour la majorité des gens, c'est gratos.

Le revers de la médaille c'est qu'il faudra apprendre un nouveau langage de description, et la bibliothèque de boutons et menus prêts à l'emploi est moins fournie qu'un Qt qui a 30 ans d'avance derrière lui. Mais ça vaut le coup d'essayer puis vu que tout le monde vibe code de toute façon, ça ne devrait pas vous poser trop de soucis.

Voilà, si vous bricolez vos propres outils sur Raspberry Pi ou que vous voulez juste une appli desktop ultra-légère sans embarquer un navigateur entier avec, c'est à regarder.

Merci Chrltc pour le lien !

Source : github.com/slint-ui/slint

Le scraping web, c'est un combat permanent contre les sites qui changent leur HTML toutes les deux semaines. Vous vous emmerdez à coder vos sélecteurs CSS, ça marche pendant un mois, puis le site refait son design et hop, votre script s'éteint en silence. C'est pourquoi Karim Shoair (alias D4Vinci sur GitHub) a sorti Scrapling, un framework Python qui s'adapte tout seul quand le DOM bouge.

La clé c'est adaptive=True sur n'importe quel sélecteur. Vous lui dites "je cherchais .product", Scrapling sauvegarde alors la signature de l'élément (texte, attributs, position dans l'arbre), et la prochaine fois que le site a renommé sa classe, il retrouve l'élément via similarité.

Concrètement ça donne ça :

from scrapling.fetchers import StealthyFetcher
StealthyFetcher.adaptive = True
page = StealthyFetcher.fetch('https://example.com', headless=True)
product = page.css_first('.product', adaptive=True) # Retrouve l'élément même si la classe a changé

Le truc marche grâce à un algo de similarité maison qui compare la structure DOM autour de l'élément. L'auteur lui-même a écrit un long post Medium intitulé " Creating self-healing spiders with Scrapling in Python without AI ", et ça résume bien la philosophie : pas de modèle IA mais juste des heuristiques solides !

La doc précise que adaptive=True ne sauvegarde que le premier élément de la sélection. Du coup si vous récupérez 50 produits d'un coup avec .css('.product'), seul le premier sera adapté. Faudra donc soit utiliser css_first comme dans l'exemple, soit boucler manuellement et appeler adaptive sur chaque élément. C'est bon à savoir...

Y'a également 3 fetchers selon le besoin. Fetcher pour les requêtes HTTP rapides avec spoofing TLS, StealthyFetcher qui passe Cloudflare Turnstile via un navigateur furtif (Camoufox sous le capot), et DynamicFetcher qui lance un Chromium ou un Chrome via Playwright pour les sites lourds en JS. Du coup vous pouvez démarrer léger en HTTP et basculer vers un navigateur uniquement quand un site bloque, sans réécrire votre code.

Côté perfs, le README annonce du lourd : 2 ms pour extraire 5000 éléments contre 1584 ms pour BeautifulSoup avec lxml. Sauf que Parsel et Scrapy font aussi 2 ms. Donc le gain vient du moteur lxml utilisé en direct, ce qui veut dire que si vous étiez déjà sur Scrapy, vous ne gagnerez pas en vitesse brute. Mais si vous traînez encore du BS4 partout, le saut sera énorme !

Sur le terrain anti-bot, ça se compare bien à Botasaurus dont je vous avais parlé. La différence c'est que Scrapling embarque un ProxyRotator natif et propose un blocage d'ads/trackers (~3500 domaines) activable via block_ads=True ou automatique en mode MCP, ce qui simplifie la vie quand vous tournez sur un serveur (où les IPs des datacenter se font régulièrement filtrer). Botasaurus, lui, vous laisse gérer la rotation à la main.

Détail sympa pour les bidouilleurs : y'a également un serveur MCP intégré (pip install "scrapling[ai]"). Du coup Claude ou Cursor peuvent piloter Scrapling directement pour extraire des données, en réduisant la consommation de tokens car l'IA ne voit pas tout le HTML brut, juste ce qui est extrait. Pour les agents qui scrappent en boucle, c'est cool.

Notez que les sponsors Platinum du projet sont tous des fournisseurs de proxies (DataImpulse, BirdProxies, Evomi, etc.). C'est logique vu l'usage du framework, mais gardez en tête que pour bypasser un Cloudflare sérieux à grande échelle, vous aurez besoin de proxies résidentiels payants, donc d'eux. L'outil est gratuit, mais le contournement industriel ne l'est pas.

Pour installer, c'est pip install "scrapling[fetchers]" puis scrapling install pour récupérer les binaires navigateur. Une image Docker existe aussi (pyd4vinci/scrapling) et y'a même un shell interactif (scrapling shell) pour debugger vos sélecteurs en live.

Bref, c'est carrément pas mal pour ceux qui scrapent régulièrement. Alors si BS4 vous fait pleurer, allez voir par ici .

Et merci à Letsar pour le lien !

Vous synchronisez 4 ou 5 dossiers vers plusieurs serveurs avec rsync ? Alors vous connaissez ce sketch quand un job mouline pendant que les autres font la queue, parce que rsync de base c'est mono-thread et ça avance en file indienne.

Hé bien y'a un petit utilitaire Python qui dégoupille tout ça, pondu par overflowy. Ça s'appelle parallel-rsync et le nom annonce la couleur !

L'idée c'est de pouvoir empiler plusieurs jobs rsync en parallèle, avec une config YAML pour piloter le tout. Vous décrivez vos sources et destinations dans sync.yml, vous lancez parallel-rsync -c sync.yml --workers 4 --max-per-host 2, et hop, ça parallélise.

Le bougre tourne sur un ThreadPoolExecutor Python 3 qui spawn N processus rsync système avec un cap global et un cap par hôte. Et pendant ce temps, des barres de progression vous affichent l'avancement de chaque transfert sans que la console parte en sucette.

La dernière fois, je vous parlais de rsyncy qui collait juste une barre de progression à un rsync solo mais là, on monte clairement d'un cran avec une orchestration multi-cibles.

--workers cap c'est donc le nombre total de processus rsync simultanés (4 par défaut). --max-per-host limite la concurrence par destination (2 par défaut, histoire de ne pas saturer un seul serveur, parce que oui, balancer 8 rsync sur la même machine c'est juste se tirer une balle dans le pied côté I/O).

--timeout met une laisse à chaque rsync, --dry-run ajoute le flag à toutes les commandes pour tester avant de tirer, et --no-progress débraye les barres si vous voulez juste les logs. Côté logging, --log-file et --log-level font également le job.

Par contre y'a pas de retry automatique donc si une session SSH coupe en plein transfert, faudra relancer à la main. C'est logique mais un peu dommage.

Sur un homelab, ce genre de config YAML permet de résoudre le problème des synchros récurrentes avec un seul fichier centralisé au lieu de 8 scripts shell.

Votre navigateur ne supporte pas la lecture de vidéos HTML5. Voici un
<a href="/parallel-rsync/parallel-rsync-1.mp4">lien vers la vidéo</a>.

Quarkdown vient de passer en v2.0.0, et c'est une mise à jour qui en jette ! Pour ceux qui auraient raté le projet de Giorgio Garofalo, c'est ce compilateur Markdown capable de cracher livres, slides, PDF académiques et wikis à partir du même projet.

J'en avais parlé il y a presque un an dans cet article , et le truc a bien grossi depuis.

Du Kotlin sous le capot, et surtout une v2 qui ajoute le truc qu'on attendait pas : un vrai système de permissions ! En gros, vous pouvez maintenant brider ce qu'un document Quarkdown a le droit de faire pendant la compilation. Ça se contrôle avec des flags comme --deny network (pour bloquer l'accès réseau) ou --deny global-read (pour empêcher la lecture de fichiers en dehors du projet) à la compilation. C'est pratique quand vous compilez un document que quelqu'un vous a envoyé sans trop savoir ce qu'il y a dedans.

L'autre nouveauté qui change la vie, c'est l'output HTML qui peut maintenant tourner sans réseau. Plus besoin de pinger un CDN au moment du rendu puisque toutes les polices et les thèmes sont copiés dans le dossier de sortie. Par contre, maintenant les fichiers pèsent plus lourd mais c'est un bon compromis quand même puisque vous pouvez balancer le HTML sur une clé USB et ça tourne en quasi-autonomie (sauf si vous chargez des Google Fonts custom ou des polices cheloues, qui restent distantes).

Côté SEO, la fonction .htmloptions peut générer un sitemap.xml et des canonical links si vous lui passez un baseurl, ce qui le rend utilisable pour publier de vrais sites statiques.

Pour le reste, y'a plein de petits trucs sympas : les cross-références (figures, tables, équations) sont enfin cliquables, la fonction .keybinding affiche les raccourcis clavier avec ⌘ sur Mac et Ctrl ailleurs, et le rendu se parallélise sur les éléments frères. Ah, et un détail qui va surprendre ceux qui mettent à jour : le dossier de sortie passe de ./output à ./quarkdown-output, donc faudra adapter vos scripts CI !

Côté installation, ils ont aussi simplifié tout ça : Homebrew sur Mac (brew install quarkdown-labs/quarkdown/quarkdown), Scoop sur Windows, ou les habituels scripts shell. Attention quand même, faut se taper la syntaxe Quarkdown plutôt que du Markdown pur, ce qui est un nouveau dialecte à apprendre, mais c'est pas non plus la mer à boire, donc pas de stress.

Bref, si vous cherchez une alternative à LaTeX ou un complément à Pandoc pour votre workflow doc, c'est peut-être le bon moment de tester !

Source

Vous savez cette télécommande Apple TV de première génération qui traîne dans un tiroir et dont vous ne faites rien ?

Bah y'a enfin un truc à faire avec ! Jinsoo An, alias machinarii sur GitHub, vient de sortir Hypervibe , un outil macOS qui transforme la télécommande de l'Apple TV en walkie-talkie comme disent les québecois, pour Claude Code.

Push-to-talk, swipes pour les commandes slash, boutons remappables, le tout pour coder à une seule main pendant que vous mangez vos chips au vinaigre de hipsters de l'autre.

Le principe est simple : vous tenez la télécommande comme un talkie, vous appuyez sur le bouton Siri pour parler à Claude Code (dictation Claude doit être activée préalablement), puis Play/Pause envoie le prompt, Menu fait Échap, et TV envoie un Ctrl+C pour annuler.

Et les swipes du touchpad sont mappés sur les commandes slash de Claude : swipe up pour /usage, swipe down pour /compact, swipe left pour /model, swipe right pour basculer en mode plan/auto-accept. Et comme vous pouvez vous en douter, ous les mappings sont modifiables à la volée via la barre de menu, et sauvegardés dans UserDefaults.

Hypervibe est en V0.1 expérimental, et y'a pas de binaire pré-compilé, donc vous devrez le compiler depuis les sources.

Notez quand même (parce qu'il faut rendre à César ce qui appartient à César) que Hypervibe est un fork de Remotastic de Lauschue, qui a posé les fondations du HID Siri Remote et du menu bar. Hypervibe ajoute en plus le push-to-talk, les swipes mappables sur les commandes Claude Code, et pas mal de petites subtilités pour que ça fonctionne au poil !. Côté licence c'est MIT, donc vous pouvez forker à votre tour si vous voulez ajouter votre propre layout.

Et voilà comme une télécommande à 3 balles en vente sur LeBonCoin devient un périphérique d'entrée pour Claude Code avec voix et gestures intégrés, pendant que des startups de dropshipping nous vendent des claviers "AI-native" à 300 €.

La bidouille plus fort que la douille !!

Distribuer des paquets binaires en WebAssembly, c'est galère. Vous téléchargez le .tar.gz, vous le gunzippez, vous l'extrayez en mémoire... et ça rame sévèrement !! Mais youpi, Jeroen Ooms (qui contribue à webR et bosse chez ROpenSci) vient de publier tar-vfs-index , un petit npm package qui casse cette malédiction des enfers en sautant carrément l'étape extraction.

L'astuce est toute bête ! Au lieu d'extraire l'archive, on génère un fichier d'index qui liste la taille et l'offset de chaque fichier dans le tar. Du coup le navigateur n'a plus qu'à monter le blob du tar comme un système de fichiers virtuel, et chaque lecture devient alors un simple slice du blob à la bonne position. Pas d'extraction donc, mais juste du slicing à la demande !

Sous le capot, ça repose sur 3 propriétés alignées. 1/ le format tar est un layout plat : une suite de headers de 512 octets suivis des données du fichier, le tout contigu et adressable à l'octet près. 2/ Emscripten propose un backend filesystem appelé WORKERFS, prévu pour servir les lectures d'un Blob sans le copier dans le heap WASM. Et 3/ les navigateurs ont une API native, DecompressionStream , qui gunzippe efficacement pendant le téléchargement.

Concrètement, vous installez le truc avec npm install tar-vfs-index (y'a aucune dépendance externe) puis vous lancez npx tar-vfs-index archive.tar.gz. Et hop, le package vous sort un JSON dans ce genre :

{
 "files": [
 { "filename": "mypackage/DESCRIPTION", "start": 512, "end": 548 },
 { "filename": "mypackage/R/code.R", "start": 1536, "end": 1563 }
 ],
 "remote_package_size": 3072
}

const [metaRes, dataRes] = await Promise.all([
 fetch('archive.tar.gz.json'),
 fetch('archive.tar.gz'),
]);
const metadata = await metaRes.json();
const blob = await new Response(
 dataRes.body.pipeThrough(new DecompressionStream('gzip'))
).blob();
FS.mkdir('/pkg');
FS.mount(WORKERFS, { packages: [{ metadata, blob }] }, '/pkg');

Vous bossez sur un Dockerfile et vous avez besoin de la dernière version de nginx. Vous ouvrez GitHub, vous cliquez sur Releases, vous copiez-collez. Et 3 minutes plus tard, rebelote pour curl. Puis pour PHP. Sans parler du fait que dans votre script d'auto-update, vous avez hardcodé une "v3.2.1" qui dort là depuis 2023 parce que personne n'a pris le temps de mettre à jour le fichier.

Lastversion , c'est le petit CLI Python signé Danila Vershinin qui remplace cette corvée par une seule ligne. Vous tapez lastversion apache/incubator-pagespeed-ngx et vous récupérez le numéro de la dernière version.

Le truc marche sur GitHub, GitLab, BitBucket, PyPI, Wikipédia, les flux RSS, les plugins WordPress, Helm charts, Gitea, SourceForge... et même sur des sites qui publient leurs versions comme ils veulent, genre nginx.org.

La beauté du bazar, c'est qu'il comprend les humains, parce que, c'est vrai, les mainteneurs font un peu n'importe quoi avec leurs tags. Ils étiquettent release-1.2.3 au lieu de 1.2.3, ils marquent des release candidates en stable sans le faire exprès, ils changent de format entre v20150121 et v2.0.1 sans prévenir. lastversion détecte toutes ces incohérences et vous renvoie la véritable dernière stable, celle que vous vouliez dès le départ. C'est pénible à gérer à la main quand vous avez vingt dépendances à suivre. Maintenant c'est réglé tout seul avec ce petit bidule.

Et les sources exotiques, c'est tout un délire. lastversion windows vous crache le build Windows en cours, lastversion ios pour iOS, lastversion rocky vous renverra 8.4 et lastversion https://en.wikipedia.org/wiki/Rocky_Linux aussi, parce que le bidule va carrément parser la page Wikipédia pour vous.

Alors certains d'entre vous me diront que ce n'est pas utile au quotidien. Peut-être jusqu'au jour où vous devez scripter une vérif de version d'OS sans dépendre d'un outil système. Par contre, si vous enchaînez cinquante requêtes par heure sur un token GitHub anonyme, faudra pas s'étonner de manger un rate limit dans la tronche.

Côté one-liners qui tuent, y'a déjà de quoi faire.

wget $(lastversion --assets mautic/mautic) télécharge direct la dernière archive.

lastversion --pre Aircoookie/WLED --format assets --filter ESP32.bin -d ESP32.bin récupère le dernier firmware ESP32 WLED.

Pour Nginx, lastversion https://nginx.org --major stable renvoie 1.16.1 pendant que --major mainline renvoie 1.17.9.

Vous voyez l'idée, c'est du pipe-friendly pur jus.

Et le mode install, c'est un autre délire. Vous tapez lastversion install mailspring et hop, il récupère l'AppImage ou le RPM du dépôt, il l'installe, et c'est fini. Attention quand même, sur les dépôts un peu bordéliques il va parfois se vautrer sur le packaging et juste vous balancer le tarball brut. Bon, c'est pas la mort, vous dézippez à la main et vous passez à la suite...

Combiné avec cron, @daily /usr/bin/lastversion install mailspring -y et votre bureau sera toujours à jour sans passer par un store. Pour tous les outils qui ne sont ni dans apt, ni dans un snap, ni dans un flatpak, c'est l'alternative la plus propre à avoir sous la main.

L'install se fait via pip install lastversion sur à peu près tout, ou yum install lastversion après avoir ajouté le repo GetPageSpeed si vous êtes sur CentOS, RHEL, Rocky, Alma, Fedora ou Amazon Linux.

Le projet est publié sous licence BSD-2, codé en Python, et il y a aussi une API utilisable directement (from lastversion import latest) si vous préférez appeler ça dans vos scripts plutôt que de piper dans un subprocess.

Bref, un chouette outil à ranger entre vos redirections bash et votre gestionnaire SSH , catégorie petits trucs qui font gagner 10 minutes par semaine.

Ah, le presse-papiers et Claude Code... Quelle misère !!! Si vous utilisez l'assistant d'Anthropic dans le terminal, vous connaissez la douleur. Vous copiez 3 lignes pour les coller ailleurs et vous vous retrouvez avec des │ partout, des marges de deux espaces, et des sauts de ligne au milieu des phrases. Un vrai bordel !

Un développeur norvégien, Anders Myrmel, en avait déjà ras-le-bol lui aussi. Du coup il a pondu claude-copy , un script Hammerspoon qui intercepte votre Cmd+C quand vous êtes dans un terminal, laisse la copie native s'exécuter, puis nettoie le presse-papiers après coup.

Côté prérequis, il vous faut donc macOS avec Homebrew installé. L'installation ensuite c'est 3 commandes :

git clone https://github.com/andersmyrmel/claude-copy
cd claude-copy
./install.sh

Le script installe alors Hammerspoon via Homebrew si vous ne l'avez pas déjà et ajoute une ligne dans ~/.hammerspoon/init.lua. Au premier lancement, macOS demande ensuite l'accès Accessibility à Hammerspoon, donc donnez-le puis rechargez la config. C'est testé sur Ghostty, mais ça devrait également fonctionner avec iTerm2, Alacritty, kitty, WezTerm, Warp et une poignée d'autres terminaux.

Le truc cool, c'est comment ça décide quoi nettoyer. Le code Lua classe chaque copie en 3 niveaux de confiance :

• Haute confiance, avec une couverture de marge à 2 espaces qui dépasse 0,65 ou des │ partout ? Hop, strip des marges, box-drawing virées, lignes molles rejointes en paragraphes !
• Confiance moyenne, on nettoie sans rejoindre.
• Basse, on touche à rien. Les blocs de code indentés (+4 espaces) et les listes markdown sont préservés.

Alors pourquoi Anthropic a livré un TUI qui pourrit votre clipboard à la moindre copie structurée ? Hé bien on n'en sait rien mais c'est un vrai souci. Y'a d'ailleurs plusieurs issues ouvertes sur le sujets qui se référencent les unes les autres comme doublons (genre la #4686 et la #5097 ) donc qui s'annulent... Tu parles d'un bordel...

Après claude-copy n'est pas tout seul dans son coin. Y'a aussi Clean-Clode (dont claude-copy s'inspire d'ailleurs) qui fait pareil en version web, et un autre claude-copy signé clementrog pour Kitty et iTerm2.

C'est évidemment macOS only, parce que Hammerspoon est macOS only. Si vous êtes sous Linux ou Windows, ou que vous préférez éviter d'installer Hammerspoon, Clean-Clode fait le même boulot dans votre navigateur et rien ne quitte votre bécane.

Bref, si vous passez vos journées à copier-coller du Claude Code, ça vaut peut-être le coup. Donc en attendant qu'Anthropic se sorte les doigts et décide de nettoyer leur sortie à la source, je trouve ce genre de petit hack bien pratique !

Vous avez un super GPU de la mort qui tue et vous voulez faire tourner un modèle d'IA en local, mais entre la VRAM dispo, la quantification qui change tout et les 500 modèles existant... c'est tout simplement le bordel pour savoir lequel va passer crèèème sans faire ramer votre machine. On galère tous à tester des modèles au pif en voyant la RAM exploser, mais aujourd'hui on a une solution.

Car c'est exactement le problème que résout llmfit , un outil en Rust qui scanne votre hardware et vous classe les modèles compatibles par score. GPU NVIDIA, AMD, Intel Arc, Apple Silicon, sur macOS, Linux ou Windows, tout y passe ! Sur mon Mac, cette commande détecte instantanément la VRAM unified memory, les cœurs CPU et le type de GPU dans mon système, puis elle passe en revue sa base d'environ 500 modèles HuggingFace pour me dire lesquels tournent chez moi.

L'interface llmfit dans un terminal, sobre et efficace

Du coup, chaque modèle est évalué sur 4 axes : qualité, vitesse, occupation mémoire et capacité de contexte. En fait, le scoring s'adapte à votre usage, si vous voulez du chat rapide, la vitesse pèse plus lourd, et si c'est du raisonnement, c'est la qualité qui prime. À vrai dire, c'est plus malin que de comparer bêtement les paramètres sur la page HuggingFace. Et la quantification est choisie dynamiquement, de Q8_0 (la plus fidèle) jusqu'à Q2_K (la plus compressée), histoire de caser un max de trucs dans votre config.

L'interface par défaut c'est un TUI (une interface dans le terminal) avec navigation à la vim (j/k, /, tout ça) qui affiche un tableau avec les scores dans votre terminal. Pour le mode CLI, y'a llmfit --cli, et pour ceux qui veulent intégrer ça dans un pipeline, un petit llmfit serve et ça lance un serveur REST sur votre machine.

Le truc vraiment sympa je trouve c'est surtout la simulation hardware. Vous appuyez sur S dans le TUI et vous testez d'autres configs sans rien changer à votre machine. Genre "et si j'avais 24 Go de VRAM au lieu de 8 ?". Ça évite d'acheter une nouvelle carte graphique pour rien, quand on peut vérifier en deux secondes que la config actuelle suffit déjà amplement pour son usage quotidien de chat et de génération de petits scripts en local au fil de la semaine. Pas mal non ?

Y'a aussi le mode plan qui fait l'inverse, vous donnez un nom de modèle et l'outil vous dit de quel hardware vous avez besoin. D'ailleurs si vous êtes sur Mac et que l'IA en local vous branche, n'oubliez pas au passage que apfel vous permet de libérer le modèle caché dans macOS.

Côté installation, brew install llmfit sur Mac, scoop install llmfit sous Windows, ou un curl -fsSL https://llmfit.axjns.dev/install.sh | sh partout ailleurs. Une commande, c'est tout. Et ça tourne aussi en Docker !

Le support multi-GPU est également là avec agrégation de la VRAM, et l'outil tient compte des architectures MoE comme Mixtral dans son scoring (ces modèles ne chargent pas tous leurs experts d'un coup, du coup la VRAM nécessaire est plus faible qu'on pourrait croire). L'outil propose aussi 10 thèmes de couleurs, Dracula, Nord, Catppuccin... pour ceux qui ont des opinions sur les palettes de leur terminal.

Par contre y'a un hic, la base est figée à environ 500 modèles embarqués dans le binaire, donc si un nouveau modèle sort demain, faudra attendre la prochaine release. Et disons que les estimations de vitesse sont des ordres de grandeur, pas des valeurs exactes (difficile de faire mieux sans lancer vraiment l'inférence). Mais bon, pour les classiques comme Llama, Qwen, Mistral ou Gemma, c'est bien couvert. Et bien sûr, le projet est open source sous licence MIT, donc c'est chouette comme dirait le hibou (déso, pas déso ^^).

Si llamafile vous avait déjà simplifié le lancement de modèles, llmfit s'attaque au problème d'avant : choisir LEQUEL lancer.

Bref, ça vaut le coup de tester, dites-moi quel modèle ça vous recommande !

Bon, j'ai la crève et y'a du bricolage qui m'attend, du coup aujourd'hui y'aura pas des centaines d'article. Mais faut quand même que je vous parle de Hister , le nouveau projet d'Adam Tauber (le créateur de Searx ) qui indexe localement tout ce que vous visitez sur le web pour le retrouver en texte intégral.

Vous installez l'extension Chrome ou Firefox, vous lancez le binaire Go sur votre machine (ça tourne sous Linux, macOS et Windows), et hop, chaque page que vous visitez est indexée en full-text. Du coup, quand vous cherchez ce tuto que vous aviez lu y'a 3 semaines mais dont vous avez zappé l'URL, vous ouvrez l'interface web locale de Hister, vous tapez un mot qui était dans le contenu de la page et ça ressort ! Si vous aviez testé Deeper History à l'époque, c'est le même concept mais en beaucoup plus costaud.

L'interface de Hister - sobre mais efficace

Sous le capot, Hister utilise blevesearch, un moteur d'indexation en Go qui gère le fuzzy matching et les requêtes booléennes. En gros, vous tapez "configuration nginx reverse proxy" et ça vous ressort cette page de doc que vous aviez consultée y'a un mois, même si vous ne vous souvenez que de 2 mots. Efficace donc. Et l'outil capture les pages telles qu'elles étaient au moment de votre visite donc si un site modifie son contenu ou si un article disparaît, vous aurez toujours la version d'origine. Y'a même un mode aperçu hors-ligne pour consulter ces snapshots sans connexion !

Côté vie privée (forcément, quand ça vient du mec qui a pondu Searx déjà en 2013... le temps file les amis ^^), tout reste sur votre machine. Et pour les domaines sensibles comme votre banque ou votre mutuelle, une blacklist permet même d'exclure certains sites de l'indexation. Enfin pour ceux qui ont déjà des années de navigation derrière eux, la commande hister import aspirera votre historique Chrome ou Firefox existant, comme ça pas besoin de repartir de zéro.

Pour installer ça, téléchargez le binaire depuis les releases GitHub , puis lancez le serveur et installez l'extension ( Firefox ou Chrome) qui va bien. Y'a aussi un Docker Compose pour ceux qui préfèrent tout conteneuriser. Prévoyez aussi quelques Go sur le disque pour la base d'index car ça se rempli vite...

Tauber dit avoir réduit sa dépendance à Google de moitié en un mois et demi juste avec ça. Et je trouve ça logique parce que quand vous avez déjà visité la bonne page une fois, ça ne sert plus à rien de redemander à Google de vous la remonter entre 3 pubs et une réponse IA à côté de la plaque. Autant récupérer ce que vous aviez déjà !

Voilà, je suis sûr que ça va vous plaire... Et si vous voulez tester avant d'installer quoi que ce soit, une démo tourne en ligne.

Allez, je retourne bricoler...

Et si je vous disais qu'on pouvait faire tourner Firefox dans un terminal ? Et pas un navigateur en mode texte, hein. Non, le véritable Firefox, avec ses onglets, les images, la totale... Hé oui c'est possible et que ça fonctionne via SSH, donc depuis un serveur distant. Bienvenue dans le futur (ou le passé, j'sais plus trop) !

Term.everything c'est un compositeur Wayland construit from scratch en Go qui, au lieu de balancer l'image sur votre écran, la convertit en caractères ANSI et l'affiche dans le terminal. Du coup, n'importe quelle app GUI Linux peut tourner là-dedans. Firefox, un gestionnaire de fichiers, un lecteur vidéo... et même Doom (parce que si ça peut pas faire tourner Doom, ça compte pas). Le binaire fait une poignée de Mo, c'est sous licence AGPL-3.0, et y'a zéro dépendance externe.

L'outil propose 2 modes d'affichage. Le mode basique qui convertit les pixels en blocs Unicode, et dont la qualité dépend du nombre de lignes et colonnes de votre terminal. Plus vous zoomez out (Ctrl+- sur Alacritty), plus c'est net... mais plus ça rame. Donc si votre terminal supporte le protocole image, genre Kitty ou iTerm2, l'autre mode, c'est du rendu pleine résolution et là non seulement c'est pas dégeu mais en plus ça marche bien !

Le truc vraiment dingue, c'est surtout le SSH parce que si vous avez un serveur Linux distant, vous vous connectez dessus en SSH, vous lancez term-everything firefox et hop, Firefox s'affiche dans votre terminal local. Pas de X11 forwarding relou à mettre en place ni de VNC / RDP zarbi.

Pour les admins sys qui gèrent des serveurs headless, c'est quand même sympa ! D'ailleurs si vous aimez les outils SSH bien pensés , celui-ci aussi va vous plaire.

Par contre, on est encore en bêta et certaines apps vont planter ou refuser de se lancer. C'est normal, c'est un compositeur Wayland complet écrit par un seul gars (chapeau l'artiste !). Ce n'est donc pas le genre de truc qu'on met en prod, mais pour du dépannage sur un serveur Debian distant ou juste pour la beauté du geste, ça envoie du pâté.

Le créateur de term.everything est d'ailleurs le même qui avait codé Fontemon , un jeu vidéo caché dans une police de caractères. On est donc clairement dans la catégorie "parce qu'on peut le faire et que c'est marrant".

Bref, si vous voulez épater vos collègues en lançant KDE dans un terminal par-dessus SSH, ou juste jouer à Doom dans tmux, c'est par là que ça se passe.

Amusez-vous bien et merci à Lorenper pour l'info !