Vous saviez que Claude d’Anthropic avait lancé sa fonction Computer Use et OpenAI son Operator ? Eh bien, pendant que ces géants se livrent une bataille sans merci, un projet open source du nom de ByteBot propose de faire tourner un agent IA autonome sur votre machine. Le tout, avec une approche qui devrait rassurer les plus paranoïaques d’entre nous puisque tout se déroule dans Docker.

Le concept c’est qu’au lieu d’accorder un accès direct à votre système à une IA (ce qui pourrait rapidement virer au cauchemar), ByteBot fait tourner un Ubuntu 22.04 complet avec environnement graphique XFCE dans un conteneur. Ainsi, l’IA peut interagir avec cet environnement isolé via VNC et WebSockets, capturer des images d’écran, cliquer, taper du texte… En somme, elle peut faire tout ce que vous feriez, mais dans sa petite bulle sécurisée.

Je vous ai fait une vidéo tuto dessus ! Et c’est grâce aux Patreons qui me soutiennent, alors merci à eux !

Il faut donc lui donner vos instructions en langage naturel… par exemple, vous pouvez lui demander de créer un nouveau repository GitHub ou de rechercher des informations spécifiques sur le web. ByteBot analyse alors votre demande, la décompose en étapes et se met au boulot. Il peut même naviguer sur le web, remplir des formulaires, gérer des mots de passe (stockés de manière sécurisée), et bien sûr exécuter des scripts bash ou Python.

Le truc cool, c’est également le mode “takeover”. Si jamais ByteBot galère sur une tâche ou que vous voulez reprendre la main, vous pouvez directement prendre le contrôle du desktop virtuel. C’est comme faire du pair programming avec une IA, sauf que c’est vous qui corrigez ses bêtises au lieu de l’inverse. Et une fois que vous avez montré comment faire, ByteBot apprend et peut reproduire la tâche plus tard.

Pour l’installer, plusieurs options s’offrent à vous. La plus simple reste Docker Compose. Vous clonez le repo, vous créez un fichier .env avec votre clé API (Anthropic, OpenAI ou Google Gemini au choix), et vous lancez le tout avec un docker-compose up. ByteBot se charge de builder les images, de configurer le réseau bridge pour l’isolation, et de monter les volumes persistants pour garder vos données entre les sessions.

git clone https://github.com/bytebot-ai/bytebot.git
cd bytebot
# Ajoutez votre clé de fournisseur d'IA (choisissez-en une)
echo "ANTHROPIC_API_KEY=sk-ant-..." > docker/.env
# Ou : echo "OPENAI_API_KEY=sk-..." > docker/.env
# Ou : echo "GEMINI_API_KEY=..." > docker/.env
docker-compose -f docker/docker-compose.yml up -d
# Ouvrez http://localhost:9992

Pour les amateurs de Kubernetes, des charts Helm sont également disponibles. Et si vous voulez tester sans vous prendre la tête, Railway propose aussi un déploiement en un clic. Mais franchement, pour un usage perso, Docker Compose fera parfaitement le job.

L’architecture technique est d’ailleus plutôt bien foutue puisque le backend Python gère la communication avec les LLMs et l’orchestration des tâches. Et le frontend React vous donne une interface web pour interagir avec ByteBot et voir ce qu’il fabrique en temps réel. Le tout communique via WebSockets pour une latence minimale. Et le conteneur desktop tourne avec un serveur VNC modifié qui permet à ByteBot de capturer l’écran et d’envoyer des événements souris/clavier.

Ce qui distingue vraiment ByteBot des solutions cloud comme Claude Computer Use, c’est surtout le côté self-hosted et privacy-first. Vos données restent chez vous, l’IA ne peut pas fouiner dans vos vrais fichiers système, et vous gardez un contrôle total sur ce qui se passe. En plus, comme c’est open source, vous pouvez auditer le code, contribuer des améliorations, ou même forker le projet si l’envie vous prend.

Les cas d’usage sont très nombreux : Automatisation de tâches répétitives, tests d’interfaces web, scraping de données complexes, ou même apprentissage par démonstration pour créer vos propres workflows automatisés. J’imagine déjà les possibilités pour automatiser des installations de logiciels, des configurations système, des processus de CI/CD un peu tordus ou juste faire ma compta.. ^^

Niveau limitations, ByteBot reste dépendant de la qualité du modèle IA que vous utilisez. Claude 4 Sonnet semble donner les meilleurs résultats pour l’instant, mais GPT-4 et Gemini Pro fonctionnent aussi. Les tâches nécessitant beaucoup de contexte visuel ou de manipulation précise peuvent encore poser problème. Et évidemment, faire tourner un desktop complet dans Docker consomme pas mal de ressources.

Si vous voulez pousser plus loin, ByteBot expose aussi une API REST complète. Vous pouvez donc créer des tâches programmatiquement, récupérer les logs, gérer les sessions, et même étendre les capacités avec des plugins custom. La doc est bien fournie avec des exemples en Python, JavaScript et même cURL pour les puristes.

from bytebot import ByteBotClient

client = ByteBotClient(api_key="your-key")
task = client.create_task("Effectue une recherche web")
result = client.wait_for_completion(task.id)
print(result.output)

Et pour la sécurité, ByteBot implémente plusieurs garde-fous . Les conteneurs sont isolés du réseau host par défaut, les capabilities Docker sont limitées au strict minimum, et un système de permissions permet de restreindre ce que l’agent peut faire. Vous pouvez même configurer des règles pour bloquer l’accès à certains sites ou empêcher l’exécution de commandes spécifiques.

Un aspect que j’apprécie particulièrement, c’est la gestion des erreurs. Quand ByteBot se plante (et ça arrive !), il génère des rapports détaillés avec captures d’écran, logs des actions tentées, et suggestions pour résoudre le problème. C’est super pratique pour debugger et améliorer vos prompts.

Une bonne petite communauté commence à se former autour du projet. Un Discord actif, des contributions régulières sur GitHub, et même quelques extensions communautaires qui ajoutent le support pour d’autres LLMs ou des intégrations avec des outils comme Zapier ou n8n. Bref, c’est un projet qui évolue vite, avec des releases toutes les deux semaines environ.

Comparé à ses concurrents, ByteBot se positionne vraiment sur le créneau open source et self-hosted là où OpenAI et Anthropic proposent des solutions cloud propriétaire. C’est, si vous préférez, le Nextcloud des agents IA autonomes.

Après pour ceux qui s’inquiètent des implications éthiques et de sécurité de laisser une IA contrôler un ordinateur, ByteBot apporte à cela des réponses pragmatiques. L’isolation Docker, le mode takeover pour reprendre la main, et la possibilité d’auditer chaque action effectuée permettent de garder un œil sur ce que fait l’agent. C’est bien sûr loin d’être parfait, mais c’est un bon compromis entre automatisation et contrôle.

Donc si vous êtes du genre à automatiser tout ce qui peut l’être, ByteBot mérite vraiment le coup d’oeil. C’est encore un peu but sur les bords, mais le potentiel est énorme. Pour aller plus loin, je vous invite à consulter la documentation complète ici , et le code source sur GitHub .

Bon, si vous me lisez depuis loooongtemps, vous connaissez forcément le risque que représentent les métadonnées contenues dans les images que vous partagez en ligne. Oui, je parle bien des fameux EXIFs qui contiennent aussi bien le modèle d’appareil photo utilisé, l’heure précise à la seconde près où vous avez pris le cliché, les réglages de l’objectif, parfois même l’altitude, et surtout les coordonnées GPS exactes de l’endroit où vous étiez.

Et toutes ces données, si vous mettez vos photos en ligne par exemple, chez Google ou Apple, et bien eux les récupèrent et les utilisent. C’est dommage, surtout que ce sont des données qui sont quand même utiles pour peu qu’on garde ça en local sur sa machine.

Alors que faire ?

Hé bien, il existe un logiciel open source sous licence MIT qui s’appelle ChronoFrame . C’est une galerie photo que vous pouvez héberger vous-même, qui va parser automatiquement toutes les données exif de vos clichés, extraire la géolocalisation, faire du reverse géocoding pour identifier le lieu exact et afficher tout ça sur une espèce de carte interactive sur laquelle vous pouvez naviguer pour revoir vos souvenirs de voyage.

En gros c’est comme Google Photo sauf que c’est vous qui gérez vos données et vous contrôlez qui accède à quoi.

L’intérêt de ChronoFrame, c’est qu’il rend visible l’invisible. Vous uploadez une image, ChronoFrame lit les métadonnées, extrait les coordonnées GPS si elles existent, et lance un appel à l’API Mapbox ou MapLibre pour faire du reverse geocoding. Ça, ça veut dire transformer des coordonnées GPS (48.8584, 2.2945) en adresse lisible (“Tour Eiffel, Paris, France”).

Et surtout, ChronoFrame supporte les Live Photos d’Apple ET les Motion Photos de Google. La génération de miniatures, quand à elle, utilise ThumbHash , un algorithme de placeholder ultra-compact créé par Evan Wallace (cofondateur de Figma). Ainsi au lieu de générer plusieurs tailles de miniatures (100x100, 200x200, 400x400…etc), ThumbHash encode une version floue de l’image dans moins de 100 bytes et comme ça, les vignettes se chargent instantanément, et l’affichage est ensuite progressif (flou -> net) jusqu’à ce que l’image full résolution arrive.

L’interface est bien sûr responsive, supporte le touch et la navigation par gestes, et donne une expérience proche d’une app native. Pour la déployer, vous devez créer un fichier .env avec vos variables d’environnement (email admin, mot de passe, provider de stockage, token Mapbox…etc), vous lancez docker pull ghcr.io/hoshinosuzumi/chronoframe:latest, et hop, ça tourne direct.

Le guide de démarrage détaille tout le process et ça vous prendra 5 minutes chrono.

Voici un exemple de configuration minimale :

CFRAME_ADMIN_EMAIL=admin@chronoframe.com
CFRAME_ADMIN_PASSWORD=VotreMotDePasse
NUXT_PUBLIC_MAP_PROVIDER=maplibre
NUXT_PUBLIC_MAP_MAPLIBRE_TOKEN=votre_token_maptiler
NUXT_STORAGE_PROVIDER=local
NUXT_PROVIDER_LOCAL_PATH=/app/data/storage
NUXT_SESSION_PASSWORD=$(openssl rand -base64 32)

NUXT_STORAGE_PROVIDER=s3
NUXT_PROVIDER_S3_ENDPOINT=https://s3.amazonaws.com
NUXT_PROVIDER_S3_BUCKET=votre-bucket
NUXT_PROVIDER_S3_REGION=eu-west-1
NUXT_PROVIDER_S3_ACCESS_KEY_ID=votre_key
NUXT_PROVIDER_S3_SECRET_ACCESS_KEY=votre_secret

Il arrive que des gens publient un code sur GitHub avec un Dockerfile mais sans package. Le container est donc à construire soi-même, localement.

Ça peut se faire directement depuis un compose

services:
  applicationABC:
    build:
      context: https://github.com/user/applicationABC.git
      dockerfile: Dockerfile
    container_name: applicationABC
    restart: always
    ports:
      - 8080:8080

Mais dans ce cas la mise à jour automatisée via WatchTower ne fonctionne pas puisqu’il n’y a pas d’image à aller chercher.

    labels:
      - com.centurylinklabs.watchtower.enable=true

Du coup voici une solution de contournement, simple et surtout qui n’implique pas d’outil tiers ou de cloner un dépôt GitHub et faire/tenir à jour un package moi-même.

Ce bout de code va checker les commits d’un dépôt GitHub à intervalles réguliers et, au besoin, construire un container à jour localement et relancer le tout.
Avec notification Discord, parce que j’aime ça.

  applicationABC-autoupdate:
    image: alpine:latest
    container_name: applicationABC-autoupdate
    restart: always
    environment:
      GITHUB_REPO: https://github.com/user/applicationABC.git
      DISCORD_WEBHOOK: https://canary.discord.com/api/webhooks/xxx/xxx
      POLL_INTERVAL: 172800 # secondes
      SERVICE_NAME: applicationABC
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /tmp:/repo
    command: >
      sh -c "
        apk add --no-cache git bash curl docker-cli jq &&
        mkdir -p /repo &&
        cd /repo &&
        git clone --depth 1 \$GITHUB_REPO . || true &&
        REPO_NAME=\$(basename -s .git \$GITHUB_REPO) &&
        DEFAULT_BRANCH=\$(curl -s https://api.github.com/repos/\$(echo \$GITHUB_REPO | sed 's|.*/||;s|.git||') | jq -r .default_branch) &&
        git fetch origin \$DEFAULT_BRANCH &&
        git checkout \$DEFAULT_BRANCH &&
        LAST_COMMIT=\$(git rev-parse HEAD) &&
        while true; do
          git fetch origin \$DEFAULT_BRANCH &&
          NEW_COMMIT=\$(git rev-parse origin/\$DEFAULT_BRANCH) &&
          if [ \"\$NEW_COMMIT\" != \"\$LAST_COMMIT\" ]; then
            echo \"[$(date)] Nouveau commit détecté sur \$DEFAULT_BRANCH, rebuild...\"
            git reset --hard origin/\$DEFAULT_BRANCH &&
            docker compose -f /repo/docker-compose.yml build \$SERVICE_NAME &&
            docker compose -f /repo/docker-compose.yml up -d \$SERVICE_NAME &&
            REPO_LINK=\$GITHUB_REPO &&
            COMMIT_LINK=\"\$GITHUB_REPO/commit/\$NEW_COMMIT\" &&
            curl -H 'Content-Type: application/json' -X POST -d '{\"content\": \"\$REPO_NAME mis à jour automatiquement !\nBranche : \$DEFAULT_BRANCH\nCommit : \$NEW_COMMIT\nDépôt : <\$REPO_LINK|\$REPO_NAME>\nLien du commit : <\$COMMIT_LINK|voir commit>\"}' \$DISCORD_WEBHOOK &&
            LAST_COMMIT=\$NEW_COMMIT
          else
            echo \"[$(date)] Aucun changement sur \$DEFAULT_BRANCH.\"
          fi
          sleep \$POLL_INTERVAL
        done
      "

Le travail est effectué dans le dossier temporaire.

Il suffit d’éditer les variables voire le nom du container, histoire de faire propre

  applicationABC-autoupdate:
    image: alpine:latest
    container_name: applicationABC-autoupdate
    restart: always
    environment:
      GITHUB_REPO: https://github.com/user/applicationABC.git
      DISCORD_WEBHOOK: https://canary.discord.com/api/webhooks/xxx/xxx
      POLL_INTERVAL: 172800 # secondes
      SERVICE_NAME: applicationABC

Attention, la variable SERVICE_NAME doit être le nom exact du service à reconstruire/relancer

services:
  applicationABC:
    build:
      context: https://github.com/user/applicationABC.git
      dockerfile: Dockerfile
    container_name: applicationABC
    restart: always
    ports:
      - 8080:8080

Merci Holaf pour la découverte.

Je n’ai plus de Proxmox depuis des années à la maison, je le teste avec Docker : Ubuntu, Synology et UNRAiD.

Ça fait penser à Beszel mais en plus puissant et complet bien entendu.

Pulse s’utilise en toute logique avec un serveur et des agents. Le tout s’installe en Docker ou en dur.

C’est très musclé et sécurisé, ça permet la découverte de réseaux pour ajouter des nodes Proxmox notamment. Je l’utilise de manière très simple pour ce test :

services:
  pulse:
    image: rcourtman/pulse:latest
    container_name: pulse_serveur
    ports:
      - 7655:7655
    volumes:
      - /mnt/user/appdata/pulse:/data
    restart: always

On peut ensuite définir un compte d’accès

Je souhaite ajouter des clients Docker

Il faudra pour ça générer un token par client

Et tout est ensuite expliqué pour l’installer ou le retirer. C’est très bien fait.

Mais pour ma machine sous UNRAiD je préfère passer par un container Docker

docker run -d \
  --name pulse-docker-agent \
  -e PULSE_URL="http://192.168.0.195:7655" \
  -e PULSE_TOKEN="a297b11d70d16c15e4eb9241ace555a19bff4279c98ffaa92de5bd9d0bc9bab7" \
  -e PULSE_TARGETS="http://192.168.0.195:7655|a297b11d70d16c15e4eb9241ace555a19bff4279c98ffaa92de5bd9d0bc9bab7" \
  -v /var/run/docker.sock:/var/run/docker.sock \
  --restart always \
  ghcr.io/rcourtman/pulse-docker-agent:latest

Et je l’ai tout de suite dans ma liste de clients

Pour un NAS Synology je passe aussi par Docker. En revanche je suis leur recommandation pour ajouter un client sur la machine Ubuntu.

curl -fsSL http://192.168.0.195:7655/install-docker-agent.sh | bash -s -- --url http://192.168.0.195:7655 --token bc6f2c3e562d5c030a1b2b925a6f145050e214359542b3670a79a4a94a971c18

root@StreamBox:/home/aerya# curl -fsSL http://192.168.0.195:7655/install-docker-agent.sh | bash -s -- --url http://192.168.0.195:7655 --token bc6f2c3e562d5c030a1b2b925a6f145050e214359542b3670a79a4a94a971c18

== Pulse Docker Agent Installer ==
[INFO] Primary Pulse URL : http://192.168.0.195:7655
[INFO] Install path      : /usr/local/bin/pulse-docker-agent
[INFO] Log directory     : /var/log/pulse-docker-agent
[INFO] Reporting interval: 30s
[INFO] API token         : provided
[INFO] Docker host ID    : cf13d13b-a0e2-4bc6-b755-2535f80b4932
[INFO] Targets:
[INFO]   • http://192.168.0.195:7655

[INFO] Downloading agent binary
/usr/local/bin/pulse-docker-agent                                                          100%[=======================================================================================================================================================================================================================================>]   6.85M  --.-KB/s    in 0.03s   
[ OK ] Agent binary installed
[ OK ] Cleared any previous stop block for host

== Configuring systemd service ==
[ OK ] Wrote unit file: /etc/systemd/system/pulse-docker-agent.service
[INFO] Starting service
Created symlink /etc/systemd/system/multi-user.target.wants/pulse-docker-agent.service → /etc/systemd/system/pulse-docker-agent.service.

== Installation complete ==
[INFO] Agent service enabled and started
[INFO] Check status          : systemctl status pulse-docker-agent
[INFO] Follow logs           : journalctl -u pulse-docker-agent -f
[INFO] Host visible in Pulse : ~30 seconds

Et j’ai bien mes 3 clients

Pulse est un outil sécurisé, très simple, très beau, trés complet, très léger. J’adopte !

Les Linuxiens ont beau dire que Linux peut TOUT faire, ils gardent presque tous un dual-boot ou une VM Windows planquée quelque part pour lancer Photoshop ou remplir une page web administrative qui plante sous Firefox. C’est ça la définition du déni, les amis ^^.

Alors bien sûr, y’a Wine qui existe depuis plus de 20 ans, mais bon faut bidouiller des préfixes, installer des DLL manquantes, fouiller sur WineHQ et au final, c’est toujours du rafistolage à se taper.

Alors comme le fait Winapps , il y a aussi WinBoat , un outil capable de faire tourner un Windows dans un container Docker. Pas d’émulation, pas de traduction d’API, pas de prière à saint Wine pour que votre app se lance. Ça lance de vraies apps Windows !

Techniquement, WinBoat utilise donc Docker et KVM pour faire tourner Windows dans un container. Electron gère l’interface, FreeRDP se connecte à Windows via le protocole RemoteApp, et vos apps Windows apparaissent comme des fenêtres normales sur votre bureau Linux.

Vous cliquez sur une icône, hop, l’app se lance, et vous oubliez qu’il y a une VM qui tourne en arrière-plan.

L’installation de Windows est également automatisée. Vous lancez WinBoat, ça télécharge et configure tout, tout seul, et après c’est prêt. L’intégration filesystem permet d’accéder vos fichiers Linux depuis les apps Windows et le passthrough USB et smartcard fonctionne, ce qui règle le problème des signatures électroniques pour les démarches administratives dont je parle un peu plus haut.

Photoshop, Illustrator, InDesign, c’est clair que ces apps ne tourneront jamais correctement sous Wine parce qu’Adobe n’a jamais pensé son code pour être portable alors qu’avec WinBoat, elles tournent. Office 365 aussi, pour les boîtes qui imposent Teams et SharePoint. Ah et Affinity Photo pareil ça roule impecc aussi.

WinBoat assume quand même ses limites dès le départ car y’a pas de passthrough GPU pour le moment, donc les apps lourdes en 3D rameront. Pas de support non plus des jeux avec anti-cheat, mais le Steam Deck fait ça mieux de toute façon. Et notez qu’il vous faudra minimum 4 Go de RAM rien que pour WinBoat, parce qu’un Windows léger ça n’existe pas !

Le projet est open source sous licence MIT, gratuit, dispo en AppImage, .deb, .rpm, ou via AUR pour Arch. Docker CLI est obligatoire, mais pas Docker Desktop et FreeRDP 3.x.x avec le support son aussi. KVM aussi doit être activé sur votre système.

Bref, WinBoat c’est comme Winapps, très sympa à tester car ça marche très bien même si les perfs ne seront jamais celles d’un Windows natif. C’est dispo sur GitHub avec toute la doc si ça vous chauffe.

Merci à Lorenper pour le soft.

Si vous faites partie des anciens qui continuent à collectionner les liens sympa que vous trouvez sur le net, j’sais pas comment vous les gérez, mais j’ai peut-être un truc pour vous. Ça s’appelle Linkding (rien à voir avec le site rempli de teubés en costard qui parlent comme des IA nulles) et c’est un gestionnaire de bookmarks qu’on installe chez soi !

Hé oui, les champions de l’auto-hébergement, Linkding ne cherche pas à réinventer la roue… Il stocke juste vos liens, vos tags, vos notes en Markdown, et basta ! L’interface est sobre, lisible, et surtout elle ne vous balance pas des suggestions sponso à la con entre deux articles que vous vouliez lire plus tard.

Ce projet est open source sous licence MIT, et repose sur Django et SQLite. Donc c’est du solide ! SQLite pour la base de données, ça veut dire zéro configuration serveur et pas de grosse maintenance.

Vous installez le truc dans un container Docker, et ça tourne sur n’importe quoi. Ensuite, vous ajoutez un bookmark, et Linkding va automatiquement chercher le titre de la page, sa description, son icône, même une image de preview.

Autre truc cool prévu dans l’outil, c’est la possibilité de faire de l’archivage web car oui, Linkding peut créer des snapshots de chaque page que vous bookmarkez, soit en local sous forme de fichier HTML, soit via Internet Archive.

Parce que oui, il arrive parfois que les liens meurent dans d’atroces souffrances. Les sites ferment, les articles disparaissent, et dans 5 ans vous vous retrouvez avec une liste bourrée d’erreurs 404.

Alors que là, au moins, avec cet outil, vous avez une copie.

L’extension navigateur est aussi indispensable pour ajouter des bookmarks vite fait ! Elle est disponible pour Firefox et Chrome, et elle vous permet de les tagger à la volée, et même de chercher dans votre collection directement depuis la barre du navigateur. Ça ressemble un peu à ce qu’on avait avec Del.ici.ous à l’époque, en mieux.

Linkding gère aussi le multi-utilisateurs donc vous pouvez partager certains bookmarks avec d’autres personnes, ou les garder privés. C’est super pratique si vous l’installez pour toute la famille ou une petite équipe. Il y a même une API REST, donc si vous voulez automatiser des trucs ou créer vos propres outils autour, c’est possible !!

Y’a aussi une version PWA installable aussi donc vous pouvez l’ajouter à votre écran d’accueil sur mobile et l’utiliser comme une app native !

Une fois que vous y aurez goûté, difficile de revenir en arrière !

Pour tester, y’a une démo en ligne et l’installation prend moins de 10 minutes ! Ce serait dommage de s’en priver

Vous voulez regarder une vidéo YouTube avec des potes qui habitent à l’autre bout du monde sans que ça rame ? Ou vous devez faire une démo produit à un client sans avoir à lui envoyer 50 captures d’écran ? Ou mieux vous avez besoin d’un navigateur jetable qui ne laisse aucune trace après utilisation ?

Et bien pour tout ça et plus encore, voici Neko , un navigateur virtuel auto-hébergé qui tourne dans Docker et utilise WebRTC pour streamer l’écran à plusieurs utilisateurs en même temps. C’est un outil développé par m1k1o et ça permet de créer très facilement des sessions de navigation partagées avec une latence inférieure à 300 millisecondes.

Vous lancez donc Neko sur votre serveur Docker, vous accédez à l’interface web, et vous avez un navigateur complet qui tourne dans le cloud. Plusieurs personnes peuvent se connecter à la même session et voir exactement le même écran en temps réel. L’hôte de la session peut également donner ou retirer le contrôle aux participants. Un peu comme quand on partage son écran sur Zoom, mais en mieux parce que tout le monde voit le même flux avec une qualité parfaite.

D’ailleurs, la technologie derrière est plutôt intéressante puisque ça utilise du WebRTC. Ainsi, le flux média ne transite pas par un serveur centralisé mais directement en peer-to-peer entre les navigateurs. Les médias circulent via SRTP et les données via SCTP, du coup, vous avez un streaming ultra-fluide avec synchronisation audio et vidéo impeccable.

Neko affiche sur son site plusieurs cas d’usage assez pratiques. Vous pouvez par exemple organiser des watch party pour regarder des films ou séries ensemble. Vous pouvez aussi pourquoi pas faire des présentations interactives où tout le monde voit la même chose en direct. Vous pouvez l’utiliser pour du support technique à distance en montrant exactement sur quoi cliquer. Ou tout pour du debugging collaboratif quand vous galérez sur un bug avec un collègue.

Le projet supporte aussi l’automatisation avec Playwright ou Puppeteer, donc vous pouvez scripter des actions dans le navigateur virtuel. Pratique si vous devez faire des tests automatisés ou des interactions complexes sur des sites web.

Niveau sécurité et vie privée, Neko propose deux modes. Le mode persistent browser garde les sessions entre les connexions, donc vous pouvez retrouver vos onglets et votre historique. Et le mode throwaway browser qui crée une session isolée qui est détruite après utilisation, sans historique, cookies ou cache. Zéro trace !

Vous pouvez aussi l’utiliser comme jump host (hôte relais quoi…) pour accéder à des ressources internes de votre réseau sans exposer directement ces ressources. Ou pour protéger la propriété intellectuelle en permettant à des gens de consulter des documents sensibles sans pouvoir les télécharger ou les copier.

L’installation se fait via Docker avec plusieurs images disponibles puisque vous avez le choix entre Firefox, Chrome, Brave et d’autres navigateurs. Le projet est d’ailleurs assez complet avec des projets satellites comme Neko Rooms pour gérer plusieurs salles, Neko Apps pour créer un environnement virtuel complet dans le navigateur, et Neko VPN pour des connexions sécurisées. Vous pouvez même broadcaster sur Twitch, YouTube ou n’importe quel service compatible RTMP directement depuis Neko.

Notez que Neko ne se limite pas qu’aux navigateurs puisque vous pouvez faire tourner n’importe quelle application Linux dedans, comme VLC par exemple. C’est en réalité plutôt une machine virtuelle streamée qu’un simple navigateur.

Le projet est sous licence Apache 2.0, donc c’est complètement open source et il y a aussi un serveur Discord actif pour échanger avec la communauté.

Bref, si vous cherchez une alternative aux solutions propriétaires pour le partage d’écran ou les watch party, Neko fera le job. Et comme c’est auto-hébergeable et hyper flexible, vous gardez le contrôle sur vos données tout en ayant une grande liberté sur l’usage que vous en ferez ! A tester donc !

Merci à Lorenper pour le partage.