Código abierto — licencia MIT
Zero Layer es un gestor de paquetes universal para Linux. Instala software de 13 ecosistemas distintos en cualquier distribución traduciendo los binarios al instalar, no al ejecutar.
curl -Lo zl https://github.com/polpo21/zero_layer/releases/latest/download/zl-x86_64-unknown-linux-gnu
Un único binario. Sin runtime, sin demonio, sin dependencias.
El problema
Cada distribución trae su propio formato, sus repositorios y su idea de dónde deben ir los archivos. El software que quieres suele estar empaquetado, pero no para tu sistema.
Una herramienta está en el AUR, o solo como .deb, o solo como release de GitHub. Tu distro la empaquetó hace dos años, o nunca. Acabas compilando a mano o quedándote sin ella.
Contenedores, máquinas virtuales y capas de compatibilidad resuelven esto añadiendo una capa. Y la pagas para siempre: latencia de arranque, memoria, disco y un runtime que debe seguir ejecutándose.
Soltar un tarball en /opt funciona hasta que una biblioteca se mueve. Nada registra los archivos, nada conoce las dependencias y nada puede deshacerlo limpiamente.
La idea
Un binario de Linux no está atado a una distribución: está atado a unos pocos hechos concretos, es decir, qué enlazador dinámico lo carga y dónde viven sus bibliotecas compartidas. Ambos están escritos dentro del archivo ELF y ambos se pueden reescribir.
Zero Layer lee esos campos con goblin y los reescribe con elb para que apunten al enlazador y a las rutas reales de tu sistema. Lo hace una sola vez, durante la instalación.
A partir de ahí el binario es sencillamente un binario nativo en tu máquina. Sin shim, sin script envoltorio, sin sandbox y sin proceso supervisor. De ahí el nombre: la capa es cero.
compilado para Arch
adaptado a esta máquina
El mismo código máquina. Solo sabe dónde vive ahora.
Filosofía
Zero Layer tiene criterio propio. Estas son las reglas a las que se somete el código.
Todo el trabajo de traducción ocurre una sola vez, durante la instalación. Después no queda nada entre tu programa y el kernel.
Arquitectura, enlazador dinámico, libc, directorios de bibliotecas y estructura del sistema de archivos se sondean del sistema en ejecución en lugar de fijarse en el código.
Cada instalación se ejecuta dentro de una transacción que registra lo que tocó. Un fallo en cualquier punto revierte la operación entera.
redb en lugar de SQLite, elb en lugar de patchelf, rustls en lugar de OpenSSL. Escrito en Rust; las pocas piezas nativas (compresión, criptografía) van compiladas dentro, así que no hay nada más que instalar.
Cuando un paquete existe en varios ecosistemas, Zero Layer los muestra todos y te deja elegir. Nunca decide por ti en silencio.
Historial, reversión, detección de huérfanos y simulación son funciones centrales, no añadidos. Siempre puedes ver qué pasó y deshacerlo.
Cómo funciona
Entre tu comando y un binario funcionando hay ocho etapas. Cada una es observable con -v y cualquier fallo lo revierte todo.
Encuentra el paquete y recorre recursivamente su árbol de dependencias detectando ciclos. Si falta una dependencia en la fuente principal, se consultan todas las demás activas y eliges tú.
resolución entre fuentesSe revisan cinco categorías antes de escribir nada: propiedad de archivos, nombres de binarios, sonames de bibliotecas, conflictos declarados y restricciones de versión.
5 tipos de conflictoLos paquetes se obtienen directamente de sus repositorios nativos en cuatro hilos paralelos, con barras de progreso y reintentos automáticos con espera creciente.
4 hilos · reintentosSe exigen sumas SHA256 y se comprueban las firmas GPG cuando la fuente las proporciona. Una firma no verificable se informa de forma distinta a una incorrecta.
SHA256 + GPGEl formato del archivo se detecta y se descomprime — deb, rpm, tar, zst, xz, nar, squashfs, zip o AppImage — y luego se normaliza a una estructura FHS estándar.
9 formatos de archivoCada binario ELF se analiza y después se reescriben su intérprete y su RUNPATH para tu sistema. Los paquetes con varios binarios se parchean en paralelo; los estáticos se dejan intactos, como corresponde.
goblin + elbLos archivos se colocan de forma atómica dentro de una transacción que anota cada archivo, directorio, enlace y fila de base de datos que crea. Cualquier error lo deshace todo.
atómico · reversiónArchivos, dependencias, propiedad y la propia operación se escriben en una base de datos embebida: es lo que después hace posibles why, size, doctor y rollback.
redb + grafoCapacidades
Todo lo que esperas de las herramientas de tu distro, más lo que nunca tuvieron.
Los binarios ELF se analizan con goblin y se parchean con elb al instalar. El enlazador dinámico y el RUNPATH se reescriben para tu sistema, así que después los paquetes corren a plena velocidad nativa.
Todas las fuentes activas se consultan a la vez, los resultados se puntúan por relevancia y las variantes binarias del AUR se detectan automáticamente.
Una instalación se completa o no deja rastro. Nunca queda un estado a medio escribir.
doctor, audit, why, size, diff e history responden las preguntas que los gestores de paquetes suelen dejar en el aire.
Instala versiones en paralelo y cambia entre ellas, o levanta un entorno efímero que desaparece al salir del shell.
Sumas y firmas a la entrada, consulta de CVE en OSV.dev a la salida, y anclaje para congelar lo que no quieras que se mueva.
Fuentes
Cada fuente es un plugin que implementa el mismo trait. Activa las que quieras en cada máquina o filtra por comando con --from.
pacmanArch LinuxaurArch User RepositoryaptDebian · UbuntudnfFedora · RHELzypperopenSUSE · SLESapkAlpine LinuxxbpsVoid LinuxportageGentoo binhostnixnixpkgsflatpakFlathubsnapSnapcraft StoreappimageAppImageHubgithubGitHub ReleasesLa disponibilidad de una fuente depende de que el upstream sea accesible. El repositorio registra el estado real de cada plugin.
Comandos
Un binario, veinticinco comandos, autocompletado para bash, zsh y 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
Bajo el capó
Estructura predecible en disco, un código en Rust con el mínimo imprescindible de código nativo y una batería de pruebas que corre en cada push.
Todo vive bajo un único directorio que es tuyo. Añade bin al PATH y no se toca nada más del sistema.
~/.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
Comparación
Los contenedores y los formatos universales resuelven el mismo problema aislando el software. Zero Layer lo resuelve adaptándolo.
| Tool | Enfoque | Coste en ejecución | Coste en disco | Requiere demonio |
|---|---|---|---|---|
| Zero Layer | Parchea binarios al instalar | Ninguno | Bibliotecas compartidas, deduplicadas | No |
| Docker / Podman | Imagen completa del SO por app | Sobrecarga de proceso y espacios de nombres | Capas de imagen por app | Sí |
| Flatpak | Runtimes incluidos | Sandbox e indirección de portales | Un runtime por familia de apps | Sí |
| Snap | Squashfs y confinamiento | Capa de montaje y confinamiento | Imagen comprimida por app | Sí |
| Tarball manual | Descomprimir y confiar | Ninguno | Lo que hayas copiado | No |
La instalación manual empata con Zero Layer en sobrecarga y pierde en todo lo demás: nada queda registrado, nada resuelve dependencias y nada puede deshacerlo.
Primeros pasos
Una descarga y una línea en el perfil de tu shell. No hace falta un gestor de paquetes para instalar el gestor de paquetes.
La v0.3.1 ya está publicada, con binarios precompilados para x86_64 y aarch64, glibc y musl. Todo lo descrito en esta página va incluido: no hace falta compilar nada. Notas de la versión →
Descarga la última versión para tu arquitectura. Usa la segunda forma si prefieres no usar 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 enlaza los ejecutables que instala en su propio directorio bin.
# bash (~/.bashrc) or zsh (~/.zshrc) export PATH="$HOME/.local/share/zl/bin:$PATH" # fish fish_add_path ~/.local/share/zl/bin
Omite --from y Zero Layer buscará en todas las fuentes activas para que elijas.
$ zl install ripgrep $ zl install sharkdp/bat --from github $ zl doctor # confirm everything is healthy
¿Prefieres compilarlo tú? Necesitas Rust 1.90 o superior. cargo build --release →
FAQ
~/.local/share/zl. Root solo entra en juego si decides poner el binario zl en /usr/local/bin, y eso es opcional.--dry-run.Gratuito y de código abierto con licencia MIT. Sin cuenta, sin telemetría, sin demonio.