Open source — licenza MIT
Zero Layer è un gestore di pacchetti universale per Linux. Installa software proveniente da 13 ecosistemi diversi su qualunque distribuzione, traducendo i binari al momento dell'installazione — non durante l'esecuzione.
curl -Lo zl https://github.com/polpo21/zero_layer/releases/latest/download/zl-x86_64-unknown-linux-gnu
Un solo binario. Nessun runtime, nessun demone, nessuna dipendenza.
Il problema
Ogni distribuzione ha il proprio formato, i propri repository e la propria idea di dove vadano i file. Il software che ti serve è spesso già pacchettizzato — solo non per il tuo sistema.
Uno strumento è nell'AUR, o solo come .deb, o solo come release su GitHub. La tua distro l'ha pacchettizzato due anni fa, oppure mai. Finisci per compilarlo a mano o per rinunciarci.
Container, macchine virtuali e livelli di compatibilità risolvono il problema aggiungendo un livello. E lo paghi per sempre: latenza all'avvio, memoria, disco e un runtime che deve restare in esecuzione.
Scompattare un tarball in /opt funziona finché una libreria non si sposta. Nulla tiene traccia dei file, nulla conosce le dipendenze e nulla è in grado di annullare l'operazione.
L'idea
Un binario Linux non è legato a una distribuzione: è legato a pochi fatti concreti, ovvero quale linker dinamico lo carica e dove si trovano le sue librerie condivise. Entrambi sono scritti dentro il file ELF, ed entrambi si possono riscrivere.
Zero Layer legge quei campi con goblin e li riscrive con elb perché puntino al linker e ai percorsi reali del tuo sistema. Lo fa una volta sola, durante l'installazione.
Da quel momento il binario è semplicemente un binario nativo sulla tua macchina. Nessuno shim, nessuno script wrapper, nessuna sandbox e nessun processo di supervisione. Da qui il nome: il livello è zero.
compilato per Arch
adattato a questa macchina
Stesso codice macchina. Ora sa solo dove si trova.
Filosofia
Zero Layer ha una posizione precisa. Queste sono le regole a cui il codice deve rispondere.
Tutto il lavoro di traduzione avviene una volta sola, durante l'installazione. Dopo non resta nulla tra il tuo programma e il kernel.
Architettura, linker dinamico, libc, directory delle librerie e struttura del filesystem vengono rilevati dal sistema in esecuzione, non scritti a mano nel codice.
Ogni installazione avviene dentro una transazione che registra ciò che ha toccato. Un errore in qualsiasi punto annulla l'intera operazione.
redb al posto di SQLite, elb al posto di patchelf, rustls al posto di OpenSSL. Scritto in Rust; le poche parti native (compressione, crittografia) sono compilate dentro, quindi non c'è nient'altro da installare.
Quando un pacchetto esiste in più ecosistemi, Zero Layer li mostra tutti e ti lascia scegliere. Non decide mai al posto tuo in silenzio.
Cronologia, rollback, rilevamento degli orfani e dry-run sono funzioni centrali, non ripensamenti. Puoi sempre vedere cos'è successo e tornare indietro.
Come funziona
Tra il tuo comando e un binario funzionante ci sono otto fasi. Ognuna è osservabile con -v, e qualsiasi errore riporta tutto indietro.
Trova il pacchetto e percorre ricorsivamente l'albero delle dipendenze, rilevando i cicli. Se una dipendenza manca nella sorgente principale, vengono interrogate tutte le altre attive e scegli tu.
risoluzione cross-sorgenteCinque categorie vengono verificate prima di scrivere qualsiasi cosa: proprietà dei file, nomi dei binari, soname delle librerie, conflitti dichiarati e vincoli di versione.
5 tipi di conflittoI pacchetti sono scaricati direttamente dai repository nativi su quattro thread paralleli, con barre di avanzamento e ritentativi automatici con backoff.
4 thread · retryI checksum SHA256 sono obbligatori e le firme GPG vengono controllate quando la sorgente le fornisce. Una firma non verificabile viene segnalata diversamente da una errata.
SHA256 + GPGIl formato dell'archivio viene riconosciuto e scompattato — deb, rpm, tar, zst, xz, nar, squashfs, zip o AppImage — poi normalizzato in una struttura FHS standard.
9 formati di archivioOgni binario ELF viene analizzato, poi interprete e RUNPATH vengono riscritti per il tuo sistema. I pacchetti con più binari sono patchati in parallelo; quelli statici vengono giustamente lasciati intatti.
goblin + elbI file sono collocati in modo atomico dentro una transazione che registra ogni file, directory, symlink e riga di database creata. Qualsiasi errore annulla tutto.
atomico · rollbackFile, dipendenze, proprietà e l'operazione stessa vengono scritti in un database integrato: è ciò che rende possibili in seguito why, size, doctor e rollback.
redb + grafoFunzionalità
Tutto quello che ti aspetti dagli strumenti della tua distro, più ciò che non hanno mai avuto.
I binari ELF vengono analizzati con goblin e modificati con elb durante l'installazione. Linker dinamico e RUNPATH sono riscritti per il tuo sistema, così i pacchetti girano poi a piena velocità nativa.
Ogni sorgente attiva viene interrogata simultaneamente, i risultati sono ordinati per rilevanza e le varianti binarie AUR vengono trovate in automatico.
Un'installazione o si completa o non lascia traccia. Mai stati scritti a metà.
doctor, audit, why, size, diff e history rispondono alle domande su cui di solito i gestori di pacchetti ti lasciano a indovinare.
Installa più versioni affiancate e passa dall'una all'altra, oppure crea un ambiente effimero che sparisce quando esci dalla shell.
Checksum e firme in entrata, ricerca di CVE su OSV.dev in uscita, più il pinning per congelare ciò che non vuoi si muova.
Sorgenti
Ogni sorgente è un plugin che implementa lo stesso trait. Attiva quelle che vuoi per ogni macchina, o filtra per singolo comando con --from.
pacmanArch LinuxaurArch User RepositoryaptDebian · UbuntudnfFedora · RHELzypperopenSUSE · SLESapkAlpine LinuxxbpsVoid LinuxportageGentoo binhostnixnixpkgsflatpakFlathubsnapSnapcraft StoreappimageAppImageHubgithubGitHub ReleasesLa disponibilità di una sorgente dipende dalla raggiungibilità dell'upstream. Il repository tiene traccia dello stato reale di ogni plugin.
Comandi
Un binario, venticinque comandi, completamenti per bash, zsh e 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
$ zl search vim # all sources, in parallel $ zl search vim --exact # exact names only $ zl search vim --from pacman,apt # limit the sweep $ zl info ripgrep # full metadata $ zl list --explicit # what you asked for $ zl sources list # enabled / disabled $ zl sources only pacman aur github
$ zl doctor # full system health check $ zl why libpcre2 # which package pulled it in $ zl size --sort # disk usage, largest first $ zl diff firefox # what an update would change $ zl audit # known CVEs via OSV.dev $ zl cache dedup # hardlink duplicate libs
$ zl history list # every operation, timestamped $ zl history rollback # undo the last one $ zl history rollback 3 # undo the last three $ zl pin firefox # freeze this version $ zl export # write zl-lock.json $ zl import zl-lock.json # reproduce elsewhere
$ zl env shell # throwaway env, dies on exit $ zl env shell myproject # named, persists $ zl env list $ zl env delete myproject $ zl switch python 3.12 # activate another version $ zl completions zsh # bash · zsh · fish
Sotto il cofano
Struttura prevedibile su disco, un codice in Rust con il minimo indispensabile di codice nativo e una suite di test che gira a ogni push.
Tutto vive sotto un'unica directory che ti appartiene. Aggiungi bin al PATH e nient'altro nel sistema viene toccato.
~/.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
Confronto
Container e formati universali risolvono lo stesso problema isolando il software. Zero Layer lo risolve adattandolo.
| Tool | Approccio | Costo a runtime | Costo su disco | Richiede un demone |
|---|---|---|---|---|
| Zero Layer | Patch dei binari all'installazione | Nessuno | Librerie condivise, deduplicate | No |
| Docker / Podman | Immagine completa di OS per app | Overhead di processo e namespace | Livelli di immagine per app | Sì |
| Flatpak | Runtime inclusi | Sandbox e indirezione dei portal | Un runtime per famiglia di app | Sì |
| Snap | Squashfs e confinamento | Livello di mount e confinamento | Immagine compressa per app | Sì |
| Tarball manuale | Scompatta e spera | Nessuno | Quello che hai copiato | No |
L'installazione manuale pareggia Zero Layer sull'overhead — e perde su tutto il resto: nulla è tracciato, nulla risolve le dipendenze e nulla può annullare l'operazione.
Per iniziare
Un download, una riga nel profilo della shell. Non serve un gestore di pacchetti per installare il gestore di pacchetti.
La v0.3.1 è pubblicata, con binari precompilati per x86_64 e aarch64, glibc e musl. Tutto ciò che è descritto in questa pagina è incluso — non serve compilare nulla. Note di rilascio →
Scarica l'ultima release per la tua architettura. Usa la seconda forma se preferisci non usare 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
Zero Layer crea i symlink degli eseguibili che installa nella propria directory bin.
# bash (~/.bashrc) or zsh (~/.zshrc) export PATH="$HOME/.local/share/zl/bin:$PATH" # fish fish_add_path ~/.local/share/zl/bin
Ometti --from e Zero Layer cercherà in tutte le sorgenti attive lasciandoti scegliere.
$ zl install ripgrep $ zl install sharkdp/bat --from github $ zl doctor # confirm everything is healthy
Preferisci compilarlo da te? Serve Rust 1.90 o successivo. cargo build --release →
FAQ
~/.local/share/zl. Root entra in gioco solo se scegli di mettere il binario zl in /usr/local/bin, e anche quello è facoltativo.--dry-run.Gratuito e open source con licenza MIT. Nessun account, nessuna telemetria, nessun demone.