The problem

Linux packaging is fragmented by design

Every distribution ships its own format, its own repository and its own idea of where files belong. The software you want is often packaged — just not for your system.

✕

The package exists, but not for you

A tool is in the AUR, or only as a .deb, or only as a GitHub release. Your distro packaged it two years ago, or never.

⏱

The workarounds cost you performance

Containers, virtual machines and compatibility layers all solve this by adding a layer. You pay for it forever.

⚠

Manual installs rot silently

Dropping a tarball into /opt works until a library moves. Nothing tracks the files, and nothing can cleanly undo it.

The idea

Translate once, at install time

A Linux binary is not tied to a distribution — it is tied to a handful of concrete facts: which dynamic linker loads it, and where its shared libraries live.

Zero Layer reads those fields with goblin, then rewrites them with elb.

After that the binary is simply a native binary on your machine.

✓No container runtime to install or keep running
✓No performance penalty — it is the same machine code
✓Files land in normal directories you can inspect
✓Everything is tracked, and every install can be rolled back

# the ELF fields Zero Layer rewrites

── before ── (built for Arch)
PT_INTERP  /lib64/ld-linux-x86-64.so.2
RUNPATH    (none)
NEEDED     libpcre2-8.so.0, libc.so.6

── after ──  (patched for this host)
PT_INTERP  /lib/x86_64-linux-gnu/ld-linux-x86-64.so.2
RUNPATH    ~/.local/share/zl/lib
NEEDED     libpcre2-8.so.0, libc.so.6

# same machine code — it just knows
# where it lives now

Philosophy

Six principles behind every decision

Zero Layer is opinionated. These are the rules the codebase is held to.

◎

Zero overhead after install

All translation work happens once, during installation.

⌖

Detect, never assume

Architecture, linker, libc and layout are probed from the running system.

⇄

Atomic or nothing

Every install runs inside a transaction that records what it touched.

◆

One binary, no C

redb instead of SQLite, elb instead of patchelf, rustls instead of OpenSSL.

☰

The user picks the source

When a package exists in several ecosystems, you choose.

↩

Reversible by default

History, rollback, orphan detection and dry-run are core features.

How it works

What happens when you type install

Eight stages run between your command and a working binary. Each one is observable with -v, and any failure rolls the whole thing back.

Resolve

Finds the package and walks its dependency tree recursively.

cross-source resolution

Check conflicts

Five classes are checked before anything is written.

5 conflict types

Download

Packages are fetched over four parallel threads with automatic retry.

4 threads · retry

Verify

SHA256 checksums are enforced and GPG signatures checked.

SHA256 + GPG

Extract

The archive format is detected, unpacked and normalised to FHS.

9 archive formats

Patch

Interpreter and RUNPATH are rewritten to match your system.

goblin + elb

Install

Files are placed atomically inside a transaction.

atomic · rollback

Track

Files, dependencies and the operation are written to an embedded database.

redb + graph

Capabilities

A complete package manager, not a demo

Everything you would expect from your distro's tooling, plus the things it never had.

⚙

Native binary translation

ELF binaries are analysed with goblin and patched with elb at install time.

⚡

13 sources in parallel

Every enabled source is queried simultaneously and scored by relevance.

🔒

Atomic transactions

An install either completes or leaves no trace.

🛠

Diagnostics built in

doctor, audit, why, size, diff and history answer the questions package managers usually leave you guessing about.

⧉

Multi-version & environments

Install versions side by side, or spin up an ephemeral environment.

🛡

Security aware

Checksums and signatures in, CVE lookups against OSV.dev out.

Sources

Thirteen ecosystems, one interface

Each source is a plugin implementing the same trait. Enable the ones you want per machine, or filter per command with --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

Source availability depends on the upstream being reachable. See live plugin status

Commands

The interface, end to end

One binary, twenty-five commands, shell completions for bash, zsh and 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

Under the hood

Built to be boring in the right places

Predictable layout on disk, pure-Rust dependencies, and a test suite that runs on every push.

Where things land

Everything lives under one directory you own. Add bin to your PATH and nothing else on the system is touched.

Design constraints

▸Single binary with zero C dependencies
▸RUNPATH over RPATH, so LD_LIBRARY_PATH still works
▸Threads instead of an async runtime
▸Everything auto-detected from the running system
▸Rollback is a first-class path, not an error case
▸Zero clippy warnings, formatted, CI-gated

~/.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

# nothing outside this tree is modified
# removing the folder removes everything

The stack

Comparison

How it differs from the alternatives

Containers and universal package formats solve the same problem by isolating software. Zero Layer solves it by adapting software.

	Approach	Runtime cost	Disk cost	Needs a daemon
Zero Layer	Patch binaries at install	None	Shared libraries, deduplicated	No
Docker / Podman	Full OS image per app	Process + namespace overhead	Image layers per app	Yes
Flatpak	Bundled runtimes	Sandbox + portal indirection	Runtime per app family	Yes
Snap	Squashfs + confinement	Mount + confinement layer	Compressed image per app	Yes
Manual tarball	Unpack and hope	None	Whatever you copied	No

Manual installs match Zero Layer on overhead — and lose on everything else.

Get started

Running in under a minute

One download, one line in your shell profile. No package manager needed to install the package manager.

v0.3.0 is published, with prebuilt binaries for x86_64 and aarch64. Everything described on this page ships in it — no compiler needed. Release notes →

1Install the binary

Grab the latest release for your architecture. Use the second form if you would rather not use sudo.

$ curl -Lo zl https://github.com/supercosti21/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-musl

2Put it on your PATH

Zero Layer symlinks the executables it installs into its own bin directory.

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

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

3Install something

Leave off --from and Zero Layer will search every enabled source and let you pick.

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

Prefer to build it yourself? Requires Rust 1.85 or newer. cargo build --release →

FAQ

Reasonable questions

Does this replace my distro's package manager?

No, and it does not try to.

Do I need root?

No.

Is it really zero overhead?

Yes.

What if a package needs a library I do not have?

Dependencies are resolved recursively.

What happens when an install fails halfway?

Nothing is left behind.

Which distributions does it support?

Any of them, in principle.

Is it production ready?

It is early software under active development.

How do I get rid of it?

Delete the directory.

Install anything, on anything

Free and open source under the MIT licence. No account, no telemetry, no daemon.

Download latest release Star on GitHub

v0.3.0 is published, with prebuilt binaries for x86_64 and aarch64. Release notes →