On traditional Linux, "just install it" is one command and one mutable filesystem. On Fedora Atomic the command still exists — dnf install ansible, apt-get install nginx — but it cannot run on the host, because the host is an image. So it runs somewhere else: inside a small, mutable, heavily-integrated container that shares your home directory and pretends, convincingly, to be your machine. This is the container the previous article in this series called the "development environment" slot in the Atomic three-way split, and there are two tools that build it: Toolbx, which ships with Fedora, and Distrobox, which does not. They solve the same problem, in nearly the same way, with nearly the same commands — and yet the question "which one?" has generated years of mailing-list heat, a formal request to delete one of them, and a maintainer essay on why most of the requested features will never arrive. That argument is worth understanding, because it is not really about two shell wrappers. It is about what happens to the package manager when the operating system stops being a place where packages get installed.

A note on scope: this is a researched comparison grounded in the Toolbx project documentation and the containers/toolbox issue tracker (especially issue #1272, where the maintainer lays out the design philosophy), the Distrobox documentation and repository, a published September 2026 benchmark suite from ComputingForGeeks (Fedora 44 lab, Distrobox 1.8.2.5 vs. Toolbx 0.3), and Fedora community discussion threads. It is not hands-on: the numbers cited are third-party measurements, attributed as such, not results I produced. Version context: Fedora 45 is the current release, Toolbx is at the 0.3 line, and Distrobox is mid-transition from its shell-based v1 to a Go rewrite (v2). Both projects change quickly — verify against upstream documentation before relying on specifics.


Why Fedora Atomic Needs These Tools At All

The atomic model removes the package manager from the host and hands software to three mechanisms: Flatpak for applications, containers for development environments, and rpm-ostree layering as a last resort. That leaves a gap. A developer does not want "an application"; they want gcc, make, gdb, podman, ansible, tldr, a specific Python, a specific Node — a whole userland of unglamorous CLI tools, SDKs, and troubleshooting utilities, changed constantly and without ceremony. Layering all of that into the base image would poison the update path: every layered package is re-applied on every update, blocks rebases when dependencies drift, and reintroduces exactly the fragility the atomic model exists to remove. Flatpak is the wrong shape for a compiler.

So the tools move into a container instead. Both Toolbx and Distrobox do the same fundamental thing: they wrap rootless Podman to create an OCI container that is tightly integrated with the host — your home directory, the Wayland and X11 sockets, networking (including Avahi and CA certificates), USB devices, the systemd journal, the SSH agent, D-Bus, /dev, the udev database — and then drop you into a shell where dnf, apt, or pacman works like it always did. Inside the container you are root-equivalent and free; the host image stays untouched; the container is disposable. The host filesystem is visible at /run/host (Toolbx) or through mounted paths, so troubleshooting the actual machine from inside the box is a first-class use case.

The concept is genuinely shared. Distrobox's own README credits Toolbx bluntly: it implements the same concepts introduced by containers/toolbox, and gives Toolbx the credit for the original idea. One Toolbx maintainer notes that Distrobox descends from the original shell-era Toolbox codebase, before Toolbx itself was rewritten in Go. These are sibling projects with a common ancestor. Which makes the differences — and the argument — more interesting.


Toolbx: The Fedora-Native Answer

Toolbx began in 2018 as Fedora Toolbox, born with Fedora Silverblue: a brand-new desktop whose selling point was that you couldn't install anything on it needed an official answer for "how do I install anything?" It was renamed to Toolbox, then to Toolbx in 2022 (the canonical spelling drops the "o"; confusingly, the binary and the RPM are still called toolbox). It lives in the same containers GitHub organization as Podman, which is not a coincidence — the maintainers describe working on Toolbx as owning the Podman stack, driving Podman features and tracking container-level regressions down to the kernel.

The design philosophy is conservative in a specific, deliberate way: Toolbx containers are built from images that were prepared for Toolbx, and are then left alone. The maintainer's reasoning, in substance: installing packages at container create or start time made containers fail for non-obvious reasons, and made behavior depend on whatever repositories and packages happened to be in some random image. Starting from an image and not changing it at creation and start time produces outcomes that are far more predictable and testable. The project runs close to 300 tests across CentOS Stream, Fedora, and Ubuntu hosts. Predictability is the product.

That philosophy shows up everywhere:

  • Images. On Fedora you get the fedora-toolbox image; it ships everything toolbox init-container needs. Creation writes about 1 MB of container layer — the user account, a sudoers drop-in, host path links — and downloads nothing after the pull.
  • Distro coverage is curated, not maximal. toolbox create --distro <name> --release <ver> officially supports exactly four distributions: arch, fedora, rhel, and ubuntu. Anything else is refused before an image is pulled (Distribution debian is unsupported). The bar for adding a distro is high: a dedicated maintainer from that distro, and ideally CI running on real hosts of it. Community images for more distros (Debian, openSUSE, Rocky, AlmaLinux, Alpine...) exist in the satellite toolbx-images project, and toolbox create --image <ref> accepts any OCI image — but those are explicitly not "supported," merely possible.
  • Integration is seamless and invisible. Home directory mounted at the same path, the hostname inside reads toolbx, sudo works interactively without a prompt, /run/host exposes the host. There is no setup phase to see; the container is simply there.
  • Non-goals are stated as such. Docker support? No — that would mean owning a second container stack with no user-visible benefit. Exporting .desktop entries to the host? No — the project considers Flatpak the solution for graphical client-side applications, and sees Toolbx as a complement to Flatpak rather than a replacement for it. Instead the project invests in things like making IDEs shipped as Flatpaks (VS Code, GNOME Prompt) work well against Toolbx containers.

Toolbx is the boring option in the best sense: it is already installed on your Fedora Atomic desktop, it does one thing, and its behavior does not depend on the state of the internet at the moment you press Enter.


Distrobox: The Anything-Goes Answer

Distrobox arrived in 2021, written by Luca Di Maio (89luca89), and its pitch is the mirror image of Toolbx's: any distro userland on any other distro. It is GPL-3.0, has accumulated close to 13,000 GitHub stars, and wraps Podman, Docker, or lilipod — your choice of container manager, not a project policy. Host support is broad (Fedora Atomic desktops, ChromeOS, SteamOS/Steam Deck, openSUSE Aeon, VanillaOS, ordinary distros), and the container side accepts essentially any OCI image: Debian, openSUSE, Alpine, Kali, Oracle Linux, Void, Gentoo, Wolfi, whatever your workflow needs. The compatibility list is enormous and that is the point.

The cost of that flexibility is visible on first use. Because Distrobox will take any image, it cannot assume the image contains what its host integration needs — so on the first enter, its init script inspects the container and builds the integration: installing packages (sudo, openssh-client, mesa, locale data, and dozens more), configuring mounts and sockets, setting up the user. In the September 2026 benchmark, that first enter took 24 to 84 seconds and added 142 MB to over 1 GB to the container layer, depending on the base image — versus under 0.4 seconds and about 1 MB for Toolbx. This is not a performance bug; it is the design paying its bills. The same mechanism that makes docker.io/library/debian:stable work is the mechanism that runs apt-get install before your first prompt. (The upstream docs acknowledge the mirror-image trade: images prepared for Toolbx work beautifully as Distrobox containers too, and distrobox create --clone or a custom image with packages baked in is the recommended fix for the re-creation case.)

Where Distrobox pulls decisively ahead is the feature surface — the layer that turns "a container" into "my environment":

  • distrobox-export writes host-side wrappers and .desktop entries, so an app installed in an Arch container appears in your Fedora application launcher, and a CLI tool runs from your Fedora shell as if native.
  • distrobox assemble declares a whole set of boxes in an INI manifest and creates them in batch — reproducible team environments from a file in the repository. Toolbx has no equivalent.
  • distrobox upgrade --all upgrades every box with that box's native package manager in one command.
  • Separate home directories (--home): the container shares your files but keeps its dotfiles out of yours. In community threads this is the single most-requested Toolbx gap.
  • --init runs systemd as PID 1 (a Debian box that reports systemctl is-system-running as running — a real test rig for unit files), --root runs rootful, --unshare-netns gives the box its own network namespace, distrobox ephemeral makes throwaway boxes, distrobox-host-exec runs host commands from inside.
  • Runtime choice (Podman/Docker/lilipod) and configuration files (distrobox.conf) for defaults.

Distrobox v1 is shell-based (a single POSIX shell toolchain); the v2 "Distrobox Next" rewrite — a static Go binary with shell kept only for in-container helpers — is in release candidate as of this writing, with distrobox enter benchmarked by its author at roughly 400 ms. The project's stated aim is blunt: enter the container as fast as possible, because for many people it is their terminal.


The Measured Differences

The clearest public numbers come from a single-lab benchmark published by ComputingForGeeks in September 2026 (Fedora 44 VM, 2 vCPU, 4 GB RAM, rootless Podman, Toolbx 0.3 and Distrobox 1.8.2.5 from the Fedora repos). Seven containers across Fedora, Ubuntu 24.04, and Arch:

Container Create First enter Warm run (median) Disk added
Toolbx, Fedora (fedora-toolbox:44) 1.28 s 0.35 s 185 ms 1 MB
Distrobox, Fedora (same image) 2.21 s 24.4 s 216 ms 142 MB
Toolbx, Ubuntu (ubuntu-toolbox:24.04) 1.24 s 0.37 s 225 ms 1 MB
Distrobox, Ubuntu (Toolbx image) 1.99 s 62.4 s 222 ms 606 MB
Distrobox, Ubuntu (Docker Hub ubuntu) 0.98 s 83.8 s 213 ms 659 MB
Toolbx, Arch (arch-toolbox:latest) 2.38 s 0.39 s 194 ms 1 MB
Distrobox, Arch (Docker Hub archlinux) 1.80 s 38.7 s 212 ms 1,011 MB

Three conclusions held across every distro:

First use is the entire speed story. Toolbx is interactive in under half a second; Distrobox spends 24–84 seconds downloading and configuring before the first prompt, and the worst cases are network-bound (apt against Ubuntu mirrors). Once the container exists, the two are within milliseconds: 185–225 ms warm for Toolbx, 212–222 ms for Distrobox — overlapping ranges. A shell in either feels identical. Idle memory is a wash too: under 3 MB either way.

Disk is a shuffle between image and container. Toolbx keeps the container layer at 1 MB by making the image fat (the Arch Toolbx image unpacks to 2.2 GB vs. 413 MB for Docker Hub's archlinux); Distrobox keeps the image thin by doing the work in the container layer. For one container, Toolbx is smaller on Fedora and Ubuntu and larger on Arch. For many containers from one image, Toolbx wins bigger, because the image is stored once and only the thin layers repeat: five Ubuntu boxes cost ~588 MB under Toolbx vs. ~3.4 GB under Distrobox with the Docker Hub image.

The host integration is nearly identical under the hood. Reading podman inspect back from both tools' Fedora containers shows the same posture: net=host pid=host ipc=host privileged=true with SELinux labeling disabled (Distrobox adds a no-op AppArmor opt-out). Small behavioral differences matter for scripts, though: Toolbx's sudo works interactively but sudo -n fails (empty password field), while Distrobox writes an explicit NOPASSWD rule and supports both; Distrobox honors the host's hostname inside the box where Toolbx always says toolbx.

One caveat worth keeping: this is one lab's numbers, on one host shape, one set of images. They match the design logic of both projects well, which is why they are quoted here — but treat them as an illustration of the architectural difference, not as gospel.


The Features People Actually Fight About

Read the Fedora Discussion threads and the containers/toolbox#1272 saga (the formal "just merge with Distrobox" request, opened in early 2023, closed after a long exchange) and the same four complaints recur:

  1. Separate home directory. Distrobox's --home keeps container dotfiles out of your real ones. Toolbx's answer: not a priority; the shared home is the seamless experience.
  2. Exporting apps and binaries. Distrobox's distrobox-export --app/--bin puts container GUI apps in your launcher and container CLI tools on your PATH. Toolbx's answer, stated more than once by the maintainer: GUI apps are Flatpak's job, Toolbx is meant to complement Flatpak rather than replace it, and a binary export is replicable with a shell alias — alias mycmd='toolbox run mycmd' guarded by [ -f /run/.containerenv ]. Users counter that aliases don't cover fish-vs-bash config drift, don't produce desktop entries with icons and MIME types, and that Flatpak genuinely does not fit IDEs with plugin package managers (RStudio, QGIS, Qt version matrices — the "Flatpak is 80% done" complaint).
  3. Declarative boxes. distrobox assemble makes a team's environments a config file. Toolbx has no equivalent; its counter-concern is that every feature means code kept backward-compatible across ~300 tests.
  4. Bulk upgrades. distrobox upgrade --all visits each box and runs its native upgrade command. On Toolbx, boxes are recreated rather than upgraded (Fedora containers can't use dnf system-upgrade in place anyway).

Underneath the four complaints sit two genuinely different answers to "what is this container for?" Toolbx treats the box as a predictable, tested, disposable toolshed — if you need more, the sanctioned path is a custom image at build time or a feature request that must survive the test matrix. Distrobox treats the box as a second computer — home dir, init system, root mode, exported apps, network namespace, the works. Neither position is dishonest; they are simply optimizing for different things.


Security: Neither One Is a Sandbox

Both tools make the same promise, and it is the same non-promise: the container is not a security boundary. Distrobox's documentation says isolation is explicitly not an aim — the container gets complete access to your home directory, removable drives, and so on — and Toolbx's README says it makes no promise about security beyond what's already available in the usual command line environment on the host. Both run privileged with host network, PID, and IPC namespaces. Rootless Podman does bound the blast radius to what your user can do (a process inside cannot exceed the host user's privileges), but everything you own, the box can read and write.

Two sharp edges deserve mention. Distrobox's rootful mode (--root, or Docker) genuinely runs root against the system — useful for virtualization or systemd experiments, risky as a habit, and Distrobox at least requires setting a password for the container user rather than leaving a passwordless gate. And if you want an actual sandbox, the answer is not a fancier toolbox: it is Flatpak (for apps) or a VM/Qube (for workloads), with projects like Litterbox exploring sandboxed variants of the same idea. Use these boxes the way you would use a shell you own — because that is what they are.


Running Both Side by Side

They coexist without conflict — both packages install from the Fedora repositories, both talk to the same rootless Podman store — but there are two quirks worth knowing before you keep one box of each kind:

  • The listings overlap. distrobox list shows only Distrobox's containers, but toolbox list also shows any Distrobox container built from a Toolbx-family image, because those images carry the com.github.containers.toolbox label. Cosmetic, but confusing when you're auditing what's on the machine.
  • Toolbx won't enter a Distrobox box. toolbox run -c <distrobox-container> fails with "container ... is too old and no longer supported," because Distrobox creates containers with its own entrypoint rather than toolbox init-container. Nothing is broken — enter it with distrobox enter — but the fix that works is naming discipline: prefix your containers (tbx-, dbx-) and let each tool manage its own.

On Fedora Atomic specifically, Toolbx is present out of the box while Distrobox is an rpm-ostree install distrobox (layered, reboot-required) away — or, in the Universal Blue family, already baked into the image: Bluefin and Bazzite ship Distrobox alongside Toolbx precisely because their users want both. That is the quiet verdict of the ecosystem that runs these tools at scale.


The Debate, and Where It Actually Settled

The timeline is short. Early 2023: a user files "Replace Toolbox with Distrobox" against the Silverblue tracker and around the same time files "Anything standing against merging with Distrobox?" against containers/toolbox. Both close without a merge. The Silverblue team redirects to the Toolbx project; the Toolbx maintainer closes #1272 with a design statement instead of a roadmap: Docker support is a non-goal (Toolbx owns the Podman stack), desktop-entry export is a non-goal (Flatpak's job), distro support requires a maintainer per distro and CI on real hosts, and installing packages at container start is why projects like Distrobox get bugs where a container didn't start for non-obvious reasons. Fedora keeps shipping Toolbx — and also keeps shipping a perfectly good Distrobox RPM, since Fedora contributors do the heavy lifting on Toolbx while Distrobox gets that work for free.

Community sentiment never fully lined up with either side. The recurring asks (separate home, exports, assemble) are exactly the features Toolbx has declined on principle; meanwhile every Fedora thread about the topic collects users who simply install Distrobox and move on, and commenters who argue the debate itself is misaimed — the container should not need a bespoke CLI wrapper at all.

That last position has a name behind it: Jorge Castro (Universal Blue) argues that the Distrobox-vs-Toolbox question doesn't really matter — both are duct tape over a missing desktop API, and the real fix is the terminal talking to the container runtime directly, with the UI deciding what to expose. There is a spec discussion (ublue-os #156) to make it happen, early Terminal/Boxes integration work exists, and GNOME Prompt already offers graphical Toolbx container selection. If that future arrives, the wrapper debate dissolves — the way these things usually end is not with one project winning, but with the abstraction layer underneath both changing.


Head-to-Head

  Toolbx Distrobox
Origin Fedora/Red Hat, 2018 (containers org, with Podman) Community (89luca89), 2021
Implementation Go binary (rewritten from shell) POSIX shell v1; Go rewrite (v2) in RC
License Apache-style upstream, Fedora/RHEL packaged GPL-3.0
Container runtime Podman only Podman, Docker, lilipod
Images Curated *-toolbox images; 4 official distros (--distro); --image for anything Any OCI image; huge compatibility list
First enter ~0.35 s, ~1 MB written 24–84 s, 142 MB–1 GB written (setup runs once)
Warm command latency 185–225 ms 212–222 ms
Host integration home, sockets, journal, D-Bus, /run/host, sudo same, plus --home, --unshare-netns, --root, --init
Export apps/CLI to host no (non-goal; Flatpak + shell aliases) distrobox-export --app / --bin
Declarative environments no (per-image build instead) distrobox assemble (INI manifests)
Bulk upgrade recreate containers distrobox upgrade --all
Sandbox no (rootless-bounded) no (explicit non-goal; rootful mode optional)
Preinstalled on Fedora Atomic yes no (layer or use Universal Blue images)

Which One Fits You

Stay with Toolbx if: you are on Fedora and want zero setup; your boxes are toolsheds — compilers, Ansible, tcpdump, a specific SDK — not second homes; you value that the container behaves identically every time; GUI apps are Flatpaks and you're at peace with that; and the 0.4-second, 1-megabyte economics matter because you create and destroy boxes often.

Add Distrobox if: you need a distro Toolbx doesn't officially cover (Debian, openSUSE, Alpine, Kali...); you want exported desktop apps or CLI tools; you want a separate home directory for the box; you want systemd inside the container, rootful mode, or its own network namespace; you want your team's environments declared in a config file; or you simply clicked with the workflow — the install is one layer command away.

Use both if: that sentence describes half of each column. This is the most common real-world answer. Toolbx for the daily shell (already there, instant, predictable), Distrobox for the specialized boxes (the Arch bleeding-edge userland, the Debian test rig, the RStudio that Flatpak won't carry). They share one Podman store and coexist; just namespace the container names.

Choose neither if: what you actually want is an application — that is Flatpak's job and always was — or a long-running service (Podman Quadlet is the better fit), or a real security boundary (that is a VM). A toolbox with your dotfiles mounted in it is a convenience, not a perimeter.

The honest summary is the one the benchmark drew and the maintainers' own comments confirm: once the container is up, these tools are the same tool. The choice is a philosophy of what a container is for — a predictable, tested toolshed (Toolbx), or a faithful second computer (Distrobox) — and an economics question of where you want to pay the setup cost: 1 GB of curated image once per distro, or 24–84 seconds per box. On Fedora Atomic, where dnf install has to live somewhere, both answers are legitimate; the argument between them is mostly a disagreement about which kind of mess you prefer.


Further reading:

Researched November 2026 from the sources above. Benchmark figures are third-party measurements on a Fedora 44 lab host (Toolbx 0.3, Distrobox 1.8.2.5), not hands-on results; Distrobox v2 and the terminal↔container-runtime work are in progress, so specifics will drift. Fedora 45 is the current release at time of writing; verify versions and feature status against upstream documentation before relying on them.