Open Source — MIT-Lizenz

Ein Befehl. Jedes Paket. Jede Distro.

Zero Layer ist ein universeller Linux-Paketmanager. Er installiert Software aus 13 verschiedenen Ökosystemen auf jeder Distribution, indem er Binärdateien bei der Installation übersetzt — nicht zur Laufzeit.

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

Eine Binärdatei. Kein Runtime, kein Daemon, keine Abhängigkeiten.

Holt Pakete aus
  • pacman
  • AUR
  • apt
  • dnf
  • zypper
  • apk
  • xbps
  • portage
  • nix
  • flatpak
  • snap
  • AppImage
  • GitHub
Paketquellen
13
Laufzeit-Overhead
0ms
Tests, CI grün
357
Hintergrunddienste
0

Das Problem

Linux-Paketierung ist von Grund auf zersplittert

Jede Distribution bringt ihr eigenes Format, ihre eigenen Repositories und ihre eigene Vorstellung davon mit, wo Dateien hingehören. Die Software, die du willst, ist oft schon paketiert — nur nicht für dein System.

Das Paket existiert, aber nicht für dich

Ein Werkzeug liegt im AUR, oder nur als .deb, oder nur als GitHub-Release. Deine Distro hat es vor zwei Jahren paketiert — oder nie. Am Ende kompilierst du selbst oder verzichtest.

Die Behelfslösungen kosten Leistung

Container, virtuelle Maschinen und Kompatibilitätsschichten lösen das, indem sie eine Schicht hinzufügen. Die bezahlst du dauerhaft: Startverzögerung, Arbeitsspeicher, Plattenplatz und ein Runtime, das laufen muss.

Manuelle Installationen verrotten still

Ein Tarball nach /opt zu entpacken funktioniert, bis eine Bibliothek umzieht. Nichts verfolgt die Dateien, nichts kennt die Abhängigkeiten, und nichts kann es sauber rückgängig machen.

Die Idee

Einmal übersetzen, bei der Installation

Eine Linux-Binärdatei ist nicht an eine Distribution gebunden, sondern an wenige konkrete Fakten: welcher dynamische Linker sie lädt und wo ihre gemeinsamen Bibliotheken liegen. Beides steht in der ELF-Datei, und beides lässt sich umschreiben.

Zero Layer liest diese Felder mit goblin und schreibt sie mit elb so um, dass sie auf den echten Linker und die echten Bibliothekspfade deines Systems zeigen. Genau einmal, während der Installation.

Danach ist die Binärdatei schlicht eine native Binärdatei auf deinem Rechner. Kein Shim, kein Wrapper-Skript, keine Sandbox, kein überwachender Prozess. Daher der Name: die Schicht ist null.

  • Kein Container-Runtime, das installiert oder am Laufen gehalten werden muss
  • Keine Leistungseinbuße — es ist derselbe Maschinencode
  • Dateien landen in normalen, einsehbaren Verzeichnissen
  • Alles wird verfolgt, und jede Installation lässt sich zurückrollen
/usr/bin/rgELF 64-bit LSB · x86-64

gebaut für Arch

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

angepasst an diese Maschine

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

Derselbe Maschinencode. Er weiß jetzt nur, wo er wohnt.

Philosophie

Sechs Prinzipien hinter jeder Entscheidung

Zero Layer bezieht Position. Das sind die Regeln, an denen sich der Code messen lassen muss.

Null Overhead nach der Installation

Die gesamte Übersetzungsarbeit passiert genau einmal, während der Installation. Danach steht nichts mehr zwischen deinem Programm und dem Kernel.

Erkennen, niemals annehmen

Architektur, dynamischer Linker, libc, Bibliotheksverzeichnisse und Dateisystemaufbau werden vom laufenden System ermittelt statt fest einprogrammiert.

Atomar oder gar nicht

Jede Installation läuft in einer Transaktion, die festhält, was sie angefasst hat. Ein Fehler an beliebiger Stelle macht den gesamten Vorgang rückgängig.

Eine Binärdatei, keine Systembibliotheken

redb statt SQLite, elb statt patchelf, rustls statt OpenSSL. In Rust geschrieben; die wenigen nativen Teile (Kompression, Kryptografie) sind einkompiliert, daneben muss also nichts installiert werden.

Die Quelle wählst du

Existiert ein Paket in mehreren Ökosystemen, zeigt Zero Layer alle an und lässt dich wählen. Es entscheidet nie stillschweigend für dich.

Standardmäßig umkehrbar

Verlauf, Rollback, Waisen-Erkennung und Trockenlauf sind Kernfunktionen, keine Nachgedanken. Du kannst immer sehen, was passiert ist, und es zurücknehmen.

So funktioniert's

Was passiert, wenn du install eingibst

Zwischen deinem Befehl und einer lauffähigen Binärdatei liegen acht Stufen. Jede ist mit -v beobachtbar, und jeder Fehler rollt alles zurück.

  1. Auflösen

    Findet das Paket und durchläuft rekursiv seinen Abhängigkeitsbaum, inklusive Zyklenerkennung. Fehlt eine Abhängigkeit in der Hauptquelle, werden alle anderen aktiven Quellen abgefragt und du wählst.

    quellenübergreifend

  2. Konflikte prüfen

    Fünf Kategorien werden geprüft, bevor irgendetwas geschrieben wird: Dateibesitz, Binärnamen, Bibliotheks-Sonames, deklarierte Konflikte und Versionsbedingungen.

    5 Konfliktarten

  3. Herunterladen

    Pakete werden direkt aus ihren nativen Repositories über vier parallele Threads geholt, mit Fortschrittsbalken und automatischer Wiederholung mit Backoff.

    4 Threads · Retry

  4. Prüfen

    SHA256-Prüfsummen werden erzwungen, GPG-Signaturen geprüft, sofern die Quelle sie liefert. Eine nicht überprüfbare Signatur wird anders gemeldet als eine falsche.

    SHA256 + GPG

  5. Entpacken

    Das Archivformat wird erkannt und entpackt — deb, rpm, tar, zst, xz, nar, squashfs, zip oder AppImage — und anschließend auf ein Standard-FHS-Layout normalisiert.

    9 Archivformate

  6. Patchen

    Jede ELF-Binärdatei wird analysiert, dann werden Interpreter und RUNPATH passend zu deinem System umgeschrieben. Pakete mit mehreren Binärdateien werden parallel gepatcht; statische bleiben korrekterweise unangetastet.

    goblin + elb

  7. Installieren

    Dateien werden atomar innerhalb einer Transaktion abgelegt, die jede erzeugte Datei, jedes Verzeichnis, jeden Symlink und jeden Datenbankeintrag festhält. Jeder Fehler nimmt alles zurück.

    atomar · Rollback

  8. Erfassen

    Dateien, Abhängigkeiten, Besitz und der Vorgang selbst werden in eine eingebettete Datenbank geschrieben — genau das macht why, size, doctor und rollback später möglich.

    redb + Graph

Funktionsumfang

Ein vollwertiger Paketmanager, keine Demo

Alles, was du von den Werkzeugen deiner Distribution erwartest — und das, was sie nie hatten.

Native Binärübersetzung

ELF-Binärdateien werden mit goblin analysiert und bei der Installation mit elb gepatcht. Dynamischer Linker und RUNPATH werden für dein System umgeschrieben, sodass Pakete danach mit voller nativer Geschwindigkeit laufen.

  • goblin
  • elb
  • PT_INTERP
  • RUNPATH

13 Quellen parallel

Alle aktiven Quellen werden gleichzeitig abgefragt, Ergebnisse nach Relevanz bewertet und AUR-Binärvarianten automatisch gefunden.

Atomare Transaktionen

Eine Installation gelingt vollständig oder hinterlässt keine Spur. Niemals ein halb geschriebener Zustand.

Diagnose eingebaut

doctor, audit, why, size, diff und history beantworten die Fragen, bei denen Paketmanager dich sonst raten lassen.

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

Mehrere Versionen & Umgebungen

Installiere Versionen nebeneinander und wechsle zwischen ihnen, oder starte eine flüchtige Umgebung, die beim Verlassen der Shell verschwindet.

Sicherheitsbewusst

Prüfsummen und Signaturen beim Hereinkommen, CVE-Abfragen über OSV.dev beim Hinausgehen, dazu Pinning, um alles einzufrieren, was sich nicht bewegen soll.

Quellen

Dreizehn Ökosysteme, eine Oberfläche

Jede Quelle ist ein Plugin, das denselben Trait implementiert. Aktiviere pro Rechner, was du brauchst, oder filtere pro Befehl mit --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
  • Plugin-Status ansehen

Ob eine Quelle nutzbar ist, hängt von der Erreichbarkeit des Upstreams ab. Das Repository verfolgt den tatsächlichen Zustand jedes Plugins.

Befehle

Die Oberfläche, von A bis Z

Eine Binärdatei, fünfundzwanzig Befehle, Shell-Vervollständigung für bash, zsh und 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

Unter der Haube

Gebaut, um an den richtigen Stellen langweilig zu sein

Vorhersehbare Ablage auf der Platte, eine Rust-Codebasis mit so wenig nativem Code wie möglich und eine Testsuite, die bei jedem Push läuft.

Wo alles landet

Alles liegt unter einem Verzeichnis, das dir gehört. Nimm bin in den PATH auf — sonst wird nichts am System angefasst.

Entwurfsvorgaben

  • Eine Binärdatei, keine Systembibliotheken nötig
  • RUNPATH statt RPATH, damit LD_LIBRARY_PATH weiterhin greift
  • Threads statt einer asynchronen Laufzeitumgebung
  • Alles wird vom laufenden System erkannt
  • Rollback ist ein erstklassiger Pfad, kein Fehlerfall
  • Null Clippy-Warnungen, formatiert, durch CI abgesichert
~/.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

Der Stack

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

Vergleich

Was es von den Alternativen unterscheidet

Container und universelle Paketformate lösen dasselbe Problem, indem sie Software isolieren. Zero Layer löst es, indem es Software anpasst.

Ansatz Laufzeitkosten Plattenkosten Braucht Daemon
Zero Layer Binärdateien bei Installation patchen Keine Gemeinsame Bibliotheken, dedupliziert Nein
Docker / Podman Vollständiges OS-Image pro App Prozess- und Namespace-Overhead Image-Schichten pro App Ja
Flatpak Mitgelieferte Runtimes Sandbox und Portal-Umweg Ein Runtime je App-Familie Ja
Snap Squashfs und Confinement Mount- und Confinement-Schicht Komprimiertes Image pro App Ja
Manueller Tarball Entpacken und hoffen Keine Was immer du kopiert hast Nein

Die manuelle Installation zieht beim Overhead mit Zero Layer gleich — und verliert bei allem anderen: nichts wird erfasst, nichts löst Abhängigkeiten auf, und nichts kann es rückgängig machen.

Erste Schritte

In unter einer Minute einsatzbereit

Ein Download, eine Zeile im Shell-Profil. Man braucht keinen Paketmanager, um den Paketmanager zu installieren.

v0.3.1 ist veröffentlicht, mit vorgebauten Binärdateien für x86_64 und aarch64, glibc und musl. Alles auf dieser Seite Beschriebene ist enthalten — kein Compiler nötig. Release-Notes →

  1. Binärdatei installieren

    Hol dir das neueste Release für deine Architektur. Nimm die zweite Variante, wenn du auf sudo verzichten willst.

    $ 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. In den PATH aufnehmen

    Zero Layer verlinkt die installierten ausführbaren Dateien in sein eigenes bin-Verzeichnis.

    # bash (~/.bashrc) or zsh (~/.zshrc)
export PATH="$HOME/.local/share/zl/bin:$PATH"

# fish
fish_add_path ~/.local/share/zl/bin

  3. Etwas installieren

    Lass --from weg, und Zero Layer durchsucht alle aktiven Quellen und lässt dich wählen.

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

Lieber selbst bauen? Erfordert Rust 1.90 oder neuer. cargo build --release →

FAQ

Berechtigte Fragen

Ersetzt das den Paketmanager meiner Distribution?
Nein, und das ist auch nicht das Ziel. Zero Layer installiert in dein Home-Verzeichnis und fasst niemals Systempfade an, sodass pacman, apt oder dnf das Grundsystem weiterhin genau wie bisher verwalten. Nutze es für Software, die deine Distribution nicht paketiert.
Brauche ich root?
Nein. Die Standardinstallation liegt vollständig unter ~/.local/share/zl. Root ist nur relevant, wenn du die Binärdatei zl selbst nach /usr/local/bin legen willst — und auch das ist optional.
Ist es wirklich ohne Overhead?
Ja, denn nach der Installation läuft nichts mehr mit. Die gepatchte Binärdatei ist gewöhnlicher Maschinencode, den der Kernel direkt ausführt — keine Sandbox, kein Supervisor, keine Übersetzung zur Laufzeit. Die Arbeit passiert einmal, beim Installieren.
Was, wenn ein Paket eine Bibliothek braucht, die ich nicht habe?
Abhängigkeiten werden rekursiv aufgelöst, bevor irgendetwas heruntergeladen wird, und fehlt eine in der Hauptquelle, wird in allen anderen aktiven Quellen gesucht. Nach der Installation warnt eine Nachprüfung vor jeder gemeinsamen Bibliothek, die weiterhin nicht auffindbar ist.
Was passiert, wenn eine Installation auf halbem Weg scheitert?
Es bleibt nichts zurück. Jede Installation läuft in einer Transaktion, die erzeugte Dateien, Verzeichnisse, Symlinks und Datenbankeinträge festhält, und jeder Fehler nimmt sie alle zurück. Du kannst jeden Vorgang außerdem mit --dry-run vorab ansehen.
Welche Distributionen werden unterstützt?
Im Prinzip alle. Statt eine Liste zu pflegen, erkennt Zero Layer zur Laufzeit Architektur, dynamischen Linker, libc, Bibliotheksverzeichnisse und Dateisystemaufbau — einschließlich merged-usr, NixOS, Guix, GoboLinux und Termux.
Ist es produktionsreif?
Es ist junge Software in aktiver Entwicklung und sagt das offen: Das Repository hält fest, welche Quell-Plugins gegen ihre echten Upstreams verifiziert sind und welche noch repariert werden. Der zentrale Installationspfad ist durch 357 Tests abgedeckt, die jeden Commit absichern.
Wie werde ich es wieder los?
Lösche das Verzeichnis. Alles, was Zero Layer installiert — Pakete, Datenbank, Cache, Symlinks — liegt in einem einzigen Ordner; ihn zu entfernen beseitigt jede Spur.

Installiere alles, auf allem

Kostenlos und quelloffen unter der MIT-Lizenz. Kein Konto, keine Telemetrie, kein Daemon.

Neuestes Release herunterladen Auf GitHub mit Stern versehen