Open source — licence MIT

Une seule commande. N'importe quel paquet. N'importe quelle distro.

Zero Layer est un gestionnaire de paquets universel pour Linux. Il installe des logiciels issus de 13 écosystèmes sur n'importe quelle distribution en traduisant les binaires à l'installation — et non à l'exécution.

curl -Lo zl https://github.com/polpo21/zero_layer/releases/latest/download/zl-x86_64-unknown-linux-gnu

Un seul binaire. Sans runtime, sans démon, sans dépendances.

Récupère les paquets depuis
  • pacman
  • AUR
  • apt
  • dnf
  • zypper
  • apk
  • xbps
  • portage
  • nix
  • flatpak
  • snap
  • AppImage
  • GitHub
sources de paquets
13
surcoût à l'exécution
0ms
tests, CI au vert
357
démons en arrière-plan
0

Le problème

L'empaquetage Linux est fragmenté par nature

Chaque distribution a son format, ses dépôts et sa propre idée de l'endroit où doivent aller les fichiers. Le logiciel que vous cherchez est souvent déjà empaqueté — mais pas pour votre système.

Le paquet existe, mais pas pour vous

Un outil est dans l'AUR, ou seulement en .deb, ou seulement en release GitHub. Votre distro l'a empaqueté il y a deux ans, ou jamais. Vous finissez par compiler à la main ou par vous en passer.

Les contournements coûtent en performances

Conteneurs, machines virtuelles et couches de compatibilité résolvent le problème en ajoutant une couche. Vous la payez indéfiniment : latence au démarrage, mémoire, disque, et un runtime qui doit rester actif.

Les installations manuelles pourrissent en silence

Déposer une archive dans /opt fonctionne jusqu'à ce qu'une bibliothèque bouge. Rien ne suit les fichiers, rien ne connaît les dépendances, et rien ne permet de revenir en arrière proprement.

L'idée

Traduire une fois, à l'installation

Un binaire Linux n'est pas lié à une distribution : il est lié à quelques faits concrets, à savoir quel éditeur de liens dynamique le charge et où se trouvent ses bibliothèques partagées. Les deux sont inscrits dans le fichier ELF, et les deux peuvent être réécrits.

Zero Layer lit ces champs avec goblin, puis les réécrit avec elb pour qu'ils pointent vers l'éditeur de liens et les chemins réels de votre système. Une seule fois, pendant l'installation.

Ensuite, le binaire est simplement un binaire natif sur votre machine. Pas de shim, pas de script d'enrobage, pas de bac à sable et pas de processus superviseur. D'où le nom : la couche est nulle.

  • Aucun runtime de conteneur à installer ni à maintenir actif
  • Aucune pénalité de performance — c'est le même code machine
  • Les fichiers arrivent dans des répertoires normaux, inspectables
  • Tout est suivi, et chaque installation est annulable
/usr/bin/rgELF 64-bit LSB · x86-64

compilé pour Arch

PT_INTERP
/usr/lib/ld-linux-x86-64.so.2
RUNPATH
—
NEEDED
libpcre2-8.so.0 · libc.so.6

adapté à cette machine

PT_INTERP
/lib64/ld-linux-x86-64.so.2
RUNPATH
$ORIGIN/../lib:~/.local/share/zl/lib
NEEDED
libpcre2-8.so.0 · libc.so.6

Le même code machine. Il sait simplement où il vit désormais.

Philosophie

Six principes derrière chaque décision

Zero Layer assume ses partis pris. Voici les règles auxquelles le code est tenu.

Zéro surcoût après l'installation

Tout le travail de traduction a lieu une seule fois, pendant l'installation. Ensuite, plus rien ne s'interpose entre votre programme et le noyau.

Détecter, jamais supposer

Architecture, éditeur de liens dynamique, libc, répertoires de bibliothèques et organisation du système de fichiers sont sondés depuis le système en cours, jamais codés en dur.

Atomique ou rien

Chaque installation s'exécute dans une transaction qui enregistre ce qu'elle a touché. Une erreur, où qu'elle survienne, annule toute l'opération.

Un binaire, aucune bibliothèque système

redb plutôt que SQLite, elb plutôt que patchelf, rustls plutôt qu'OpenSSL. Écrit en Rust ; les rares parties natives (compression, cryptographie) sont intégrées au binaire, il n'y a donc rien d'autre à installer.

C'est vous qui choisissez la source

Quand un paquet existe dans plusieurs écosystèmes, Zero Layer les affiche tous et vous laisse choisir. Il ne décide jamais en silence à votre place.

Réversible par défaut

Historique, retour arrière, détection des orphelins et simulation sont des fonctions centrales, pas des ajouts tardifs. Vous pouvez toujours voir ce qui s'est passé et l'annuler.

Fonctionnement

Ce qui se passe quand vous tapez install

Huit étapes séparent votre commande d'un binaire fonctionnel. Chacune est observable avec -v, et la moindre erreur ramène tout en arrière.

  1. Résolution

    Trouve le paquet et parcourt récursivement son arbre de dépendances en détectant les cycles. Si une dépendance manque dans la source principale, toutes les autres sources actives sont interrogées et vous choisissez.

    résolution inter-sources
  2. Vérification des conflits

    Cinq catégories sont contrôlées avant toute écriture : propriété des fichiers, noms de binaires, sonames de bibliothèques, conflits déclarés et contraintes de version.

    5 types de conflits
  3. Téléchargement

    Les paquets sont récupérés directement depuis leurs dépôts natifs sur quatre threads parallèles, avec barres de progression et nouvelles tentatives automatiques.

    4 threads · reprise
  4. Vérification

    Les sommes SHA256 sont imposées et les signatures GPG contrôlées lorsque la source les fournit. Une signature invérifiable est signalée différemment d'une signature erronée.

    SHA256 + GPG
  5. Extraction

    Le format d'archive est détecté et décompressé — deb, rpm, tar, zst, xz, nar, squashfs, zip ou AppImage — puis normalisé vers une arborescence FHS standard.

    9 formats d'archive
  6. Patch

    Chaque binaire ELF est analysé, puis son interpréteur et son RUNPATH sont réécrits pour votre système. Les paquets multi-binaires sont traités en parallèle ; les binaires statiques sont laissés intacts, à raison.

    goblin + elb
  7. Installation

    Les fichiers sont placés de façon atomique dans une transaction qui consigne chaque fichier, répertoire, lien et ligne de base de données créés. La moindre erreur annule l'ensemble.

    atomique · retour arrière
  8. Suivi

    Fichiers, dépendances, propriété et l'opération elle-même sont écrits dans une base embarquée : c'est ce qui rend possibles ensuite why, size, doctor et rollback.

    redb + graphe

Fonctionnalités

Un gestionnaire de paquets complet, pas une démo

Tout ce que vous attendez des outils de votre distribution, plus ce qu'ils n'ont jamais eu.

Traduction native des binaires

Les binaires ELF sont analysés avec goblin et modifiés avec elb à l'installation. L'éditeur de liens dynamique et le RUNPATH sont réécrits pour votre système : les paquets tournent ensuite à pleine vitesse native.

  • goblin
  • elb
  • PT_INTERP
  • RUNPATH

13 sources en parallèle

Toutes les sources actives sont interrogées simultanément, les résultats classés par pertinence, et les variantes binaires de l'AUR détectées automatiquement.

Transactions atomiques

Une installation aboutit ou ne laisse aucune trace. Jamais d'état écrit à moitié.

Diagnostics intégrés

doctor, audit, why, size, diff et history répondent aux questions que les gestionnaires de paquets laissent d'ordinaire sans réponse.

  • zl doctor
  • zl why
  • zl size
  • zl audit
  • zl diff

Multi-version et environnements

Installez plusieurs versions côte à côte et basculez entre elles, ou créez un environnement éphémère qui disparaît à la sortie du shell.

Attentif à la sécurité

Sommes de contrôle et signatures à l'entrée, recherche de CVE via OSV.dev à la sortie, et épinglage pour figer ce que vous ne voulez pas voir bouger.

Sources

Treize écosystèmes, une seule interface

Chaque source est un greffon implémentant le même trait. Activez celles que vous voulez par machine, ou filtrez par commande avec --from.

  • pacmanArch Linux
  • aurArch User Repository
  • aptDebian · Ubuntu
  • dnfFedora · RHEL
  • zypperopenSUSE · SLES
  • apkAlpine Linux
  • xbpsVoid Linux
  • portageGentoo binhost
  • nixnixpkgs
  • flatpakFlathub
  • snapSnapcraft Store
  • appimageAppImageHub
  • githubGitHub Releases
  • Voir l'état des greffons

La disponibilité d'une source dépend de l'accessibilité de l'amont. Le dépôt suit l'état réel de chaque greffon.

Commandes

L'interface, de bout en bout

Un binaire, vingt-cinq commandes, complétions pour bash, zsh et fish.

$ zl install firefox                 # pick from every source
$ zl install firefox --from pacman   # force one source
$ zl install sharkdp/bat --from github
$ zl install python --version 3.12  # side by side
$ zl remove firefox --cascade       # drop orphaned deps
$ zl --dry-run install firefox     # preview only
$ zl run neofetch                   # run without installing

Sous le capot

Conçu pour être ennuyeux là où il faut

Une organisation prévisible sur disque, une base de code Rust avec le strict minimum de code natif et une suite de tests exécutée à chaque push.

Où atterrissent les fichiers

Tout vit sous un seul répertoire qui vous appartient. Ajoutez bin au PATH et rien d'autre sur le système n'est touché.

Contraintes de conception

  • Binaire unique, aucune bibliothèque système à installer
  • RUNPATH plutôt que RPATH, pour que LD_LIBRARY_PATH fonctionne encore
  • Des threads plutôt qu'un runtime asynchrone
  • Tout est détecté depuis le système en cours d'exécution
  • Le retour arrière est un chemin de premier plan, pas un cas d'erreur
  • Zéro avertissement clippy, formaté, verrouillé par la CI
~/.local/share/zl/
├── bin/        symlinks — add to PATH
├── lib/        shared libraries
├── share/      data files
├── etc/        configuration
├── packages/   one dir per name-version
├── cache/      downloads
├── envs/       ephemeral environments
└── zl.redb     package database

La stack

  • Rust 2024
  • goblin
  • elb
  • redb
  • petgraph
  • clap
  • reqwest + rustls
  • indicatif
  • quick-xml
  • sha2
  • zstd
  • tar
  • cpio

Comparaison

Ce qui le distingue des alternatives

Conteneurs et formats universels résolvent le même problème en isolant le logiciel. Zero Layer le résout en l'adaptant.

Tool Approche Coût à l'exécution Coût disque Démon requis
Zero Layer Patch des binaires à l'installation Aucun Bibliothèques partagées, dédupliquées Non
Docker / Podman Image système complète par application Surcoût de processus et d'espaces de noms Couches d'image par application Oui
Flatpak Runtimes embarqués Bac à sable et indirection des portails Un runtime par famille d'applications Oui
Snap Squashfs et confinement Couche de montage et de confinement Image compressée par application Oui
Archive manuelle Décompresser et espérer Aucun Ce que vous avez copié Non

L'installation manuelle égale Zero Layer sur le surcoût — et perd sur tout le reste : rien n'est suivi, rien ne résout les dépendances, et rien ne peut l'annuler.

Démarrer

Opérationnel en moins d'une minute

Un téléchargement, une ligne dans votre profil shell. Pas besoin d'un gestionnaire de paquets pour installer le gestionnaire de paquets.

La v0.3.1 est publiée, avec des binaires précompilés pour x86_64 et aarch64, glibc et musl. Tout ce qui est décrit sur cette page y figure — aucun compilateur nécessaire. Notes de version →

  1. Installer le binaire

    Récupérez la dernière version pour votre architecture. Utilisez la seconde forme si vous préférez éviter sudo.

    $ curl -Lo zl https://github.com/polpo21/zero_layer/releases/latest/download/zl-x86_64-unknown-linux-gnu
    $ chmod +x zl && sudo mv zl /usr/local/bin/
    
    # or, without sudo:
    $ mkdir -p ~/.local/bin && mv zl ~/.local/bin/
    
    # other builds: zl-x86_64-unknown-linux-musl,
    # zl-aarch64-unknown-linux-gnu, zl-aarch64-unknown-linux-musl
  2. L'ajouter au PATH

    Zero Layer place des liens vers les exécutables qu'il installe dans son propre répertoire bin.

    # bash (~/.bashrc) or zsh (~/.zshrc)
    export PATH="$HOME/.local/share/zl/bin:$PATH"
    
    # fish
    fish_add_path ~/.local/share/zl/bin
  3. Installer quelque chose

    Omettez --from et Zero Layer cherchera dans toutes les sources actives en vous laissant choisir.

    $ zl install ripgrep
    $ zl install sharkdp/bat --from github
    $ zl doctor                # confirm everything is healthy

Vous préférez le compiler ? Rust 1.90 ou plus récent est requis. cargo build --release →

FAQ

Questions légitimes

Cela remplace-t-il le gestionnaire de paquets de ma distribution ?
Non, et ce n'est pas son but. Zero Layer installe dans votre dossier personnel et ne touche jamais aux chemins système : pacman, apt ou dnf continuent de gérer le système de base exactement comme avant. Utilisez-le pour les logiciels que votre distribution n'empaquette pas.
Faut-il être root ?
Non. L'installation par défaut réside entièrement sous ~/.local/share/zl. Root n'intervient que si vous choisissez de placer le binaire zl dans /usr/local/bin, et c'est facultatif.
Est-ce vraiment sans surcoût ?
Oui, car après l'installation il ne reste rien en cours d'exécution. Le binaire modifié est du code machine ordinaire exécuté directement par le noyau — sans bac à sable, sans superviseur, sans traduction à l'exécution. Le travail a lieu une fois, à l'installation.
Et si un paquet a besoin d'une bibliothèque que je n'ai pas ?
Les dépendances sont résolues récursivement avant tout téléchargement et, si l'une manque dans la source principale, toutes les autres sources actives sont explorées. Après l'installation, une vérification signale toute bibliothèque partagée encore introuvable.
Que se passe-t-il si une installation échoue en cours de route ?
Rien ne subsiste. Chaque installation s'exécute dans une transaction qui consigne les fichiers, répertoires, liens et entrées de base de données créés, et la moindre erreur les annule tous. Vous pouvez aussi prévisualiser toute opération avec --dry-run.
Quelles distributions sont prises en charge ?
Toutes, en principe. Plutôt que de tenir une liste, Zero Layer détecte à l'exécution l'architecture, l'éditeur de liens dynamique, la libc, les répertoires de bibliothèques et l'organisation du système de fichiers — y compris merged-usr, NixOS, Guix, GoboLinux et Termux.
Est-ce prêt pour la production ?
C'est un logiciel jeune, en développement actif, et il l'assume : le dépôt indique précisément quels greffons sont vérifiés face à leurs amonts réels et lesquels sont encore en réparation. Le chemin d'installation principal est couvert par 357 tests qui verrouillent chaque commit.
Comment le désinstaller ?
Supprimez le répertoire. Tout ce que Zero Layer installe — paquets, base de données, cache, liens — se trouve dans un seul dossier : le supprimer efface toute trace.

Installez n'importe quoi, sur n'importe quoi

Gratuit et open source sous licence MIT. Sans compte, sans télémétrie, sans démon.