Diff — The Distro Landscape

{{infobox

| title = The Distro Landscape

| chapter = Linux Handbook, chapter 28 — the families, the philosophies, the map

| core | A distro = kernel + package manager + installer + philosophy

| families | Debian · Red Hat · Arch · Slackware · Gentoo · independent

| skills | choosing wisely · the release models · the family tree

| next | Automation & the dev environment — living in the system

}}

**A Linux distribution is a curated world** — the same kernel and userland, packaged a hundred different ways. The differences aren't skin-deep: each family chooses a package manager, a release model, an init system, and a *philosophy* — stability vs freshness, handholding vs transparency, binary vs source. This chapter maps the families, the release models, and the choice that actually matters.

## The family tree — five root stocks

Almost every distro descends from one of a handful of roots:

- **Debian** → Ubuntu → Mint, Pop!_OS, elementary, Kali, Raspberry Pi OS, MX... — the largest lineage on Earth. `apt`, `.deb`, legendary stability, massive repos.

- **Red Hat** → Fedora → RHEL → CentOS/Rocky/Alma — the enterprise path. `dnf`, `.rpm`, systemd-native, SELinux.

- **Arch** → Manjaro, EndeavourOS — rolling release, minimal base, AUR's vast user repo. `pacman`.

- **Slackware** → Slint, Salix — 1993's survivor, BSD-style init, `pkgtools`, nothing hidden — this handbook's reference.

- **Gentoo** → source-built everything — USE flags as configuration — the LFS-adjacent lineage.

- **Independents** — Void (runit+musl/glibc, `xbps`), Alpine (musl+BusyBox, the container base), NixOS (declarative), openSUSE (`zypper`, `rpm`), Solus, Clear.

## The release models — the real fork

| Model | Examples | The trade |

| --- | --- | --- |

| **Fixed/regular** | Ubuntu LTS, Debian stable, Fedora | Tested snapshots — stability, slower freshness |

| **Rolling** | Arch, Gentoo, Void, Tumbleweed | Always-current — freshness, more breakage |

| **LTS** | Ubuntu LTS, Debian, RHEL | Years of security fixes, old software |

| **Immutable/atomic** | Silverblue, NixOS-ish | The rootfs as read-only image — rebasing not upgrading |

The choice is temperament: want it to *work for years* → Debian stable/Ubuntu LTS. Want it *new* → Arch/Fedora. Want to *see it all* → Slackware/Gentoo/LFS.

## The family differences that actually matter

- **Package manager** — apt/dnf/pacman/xbps/pkgtools — the daily interface (chapter 20's table)

- **Init** — systemd (most) vs SysVinit (Slackware) vs runit (Void) vs OpenRC (Gentoo/Alpine) — the boot personality

- **libc** — glibc (standard) vs musl (Alpine/Void-musl) — the ABI difference that disqualifies musl hosts from LFS

- **Release cadence + support length** — Debian ~5yr, Ubuntu LTS 5-10yr, RHEL 10+, Arch forever-until-broken

- **Philosophy** — Ubuntu's polish vs Arch's minimalism vs Slackware's transparency vs Gentoo's build-it-yourself

## The family detail — each root's character

**Debian** — the community pillar: `apt`+`.deb`, ~5-year support cycles, three branches (stable/testing/unstable), the constitution + social contract, DFSG purity. `apt` is the world's most-used package manager; Debian stable runs half the internet's servers. Ubuntu, Mint, Kali, Raspberry Pi OS descend from it.

**Red Hat** — the enterprise lineage: Fedora (community, leading-edge) → RHEL (commercial, 10-year support) → CentOS Stream → Alma/Rocky (the RHEL clones). `dnf`+`.rpm`, SELinux by default, systemd's home turf. The paid Linux ecosystem's center.

**Arch** — the rolling minimal: `pacman`+AUR, no defaults chosen for you, the Arch Wiki (the best documentation in the landscape — usable by any distro), KISS philosophy. The distro you configure, not the one that configures itself.

**Slackware** — 1993's survivor: the oldest living distro, BSD-style init scripts, `pkgtools` leaving everything visible in `/var/log/packages`, no dependency-resolution automation — you choose. This handbook's reference because it *hides nothing*. Slint is its accessible fork.

**Gentoo** — source-as-distro: `portage`/`emerge`, USE flags configure what compiles, every package built on *your* machine. The LFS-adjacent middle ground — automated compilation, your decisions.

**The independents** — Void (runit init, `xbps`, both musl and glibc), Alpine (musl+BusyBox — every Docker image's base), NixOS (declarative functional — `/etc/nixos/configuration.nix` is the whole system), openSUSE (YaST, `zypper`), Clear Linux (Intel's optimized), Bedrock (the meta-distro combining others).

## The package-manager signatures

| Manager | Format | Distros | The syntax |

| --- | --- | --- | --- |

| apt | .deb | Debian/Ubuntu/Mint | `apt install x` |

| dnf | .rpm | Fedora/RHEL/Alma | `dnf install x` |

| yum | .rpm | legacy RHEL | `yum install x` |

| zypper | .rpm | openSUSE | `zypper in x` |

| pacman | .pkg.tar.zst | Arch/Manjaro | `pacman -S x` |

| xbps | .xbps | Void | `xbps-install -S x` |

| apk | .apk | Alpine | `apk add x` |

| emerge/portage | ebuild | Gentoo | `emerge x` |

| nix | .nar | NixOS | `nix-env -iA x` |

| pkgtools/slackpkg | .tgz/.txz | Slackware/Slint | `installpkg x.txz` |

| slackware's sbopkg | SlackBuilds | Slackware | source-builds |

## The specialist distros — the ecosystem's branches

- **Live/rescue** — SystemRescue, Knoppix, Slackware install media

- **Security** — Kali, Parrot — pentest toolkits

- **Containers/minimal** — Alpine (musl+BusyBox — why it's in every Docker image), Distroless

- **Accessible** — Slint, Vinux, Sonar, Accessible-Coconut, TalkingArch

- **Router/embedded** — OpenWrt, Buildroot, Yocto

- **Privacy** — Tails, Qubes, Whonix

- **Old hardware** — antiX, Puppy, Tiny Core (~20MB)

- **Enterprise** — RHEL, SLES, Ubuntu LTS

- **DIY** — LFS itself — the terminal point of the lineage

## The release-model detail — what each cadence means

| Model | Cadence | Support | The feel |

| --- | --- | --- | --- |

| Debian stable | ~2yr releases | ~5yr LTS | Ancient but never breaks |

| Ubuntu LTS | 2yr LTS + 6mo regular | 5-10yr | Polished LTS |

| Fedora | 6mo | ~13mo | Fresh, leading-edge, clean |

| RHEL/Alma/Rocky | 3yr | 10yr | The enterprise standard |

| Arch | Rolling | forever-until-broken | Always-newest |

| Gentoo | Rolling source | forever | Compile your own world |

| Slackware | years between | long | Stable, unchanging |

| Void | Rolling | forever | Lean + runit |

| Alpine | Rolling/6mo | — | musl+BusyBox minimal |

| openSUSE Tumbleweed | Rolling | — | Rolling tested |

| openSUSE Leap | aligned SLE | long | The stable branch |

| NixOS | 6mo channels + rolling | — | Declarative — reproducible |

| Kali | rolling | — | The pentest toolkit |

## The init-system map

| Init | Distros | Character |

| --- | --- | --- |

| systemd | Fedora, RHEL, Debian, Ubuntu, Arch, openSUSE | The standard — unit graphs, journald |

| SysVinit | Slackware/Slint, Devuan, antiX | rc scripts — readable shell |

| OpenRC | Gentoo, Alpine | Dependency-aware scripts — Gentoo's own |

| runit | Void, artix | The minimal supervision suite |

| s6 | some embedded | Modern supervision |

| busybox-init | initramfs + tiny embedded | The minimal one — Alpine's userland is busybox but its init is OpenRC |

The Devuan fork exists specifically because Debian adopted systemd — the init wars' living fossil.

## The libc map — the ABI fork that matters

- **glibc** — the standard — almost every distro — the only LFS-compatible host libc

- **musl** — Alpine, Void-musl, some embedded — tiny, clean, *not* glibc-compatible — can't host LFS

- **uclibc-ng** — embedded

- **bionic** — Android's libc — different universe

The libc choice is invisible until it isn't — musl systems produce binaries glibc can't run and vice versa. For LFS: glibc only.

## Choosing — the honest guide

| You want... | Choose |

| --- | --- |

| To learn Linux deeply | Slackware or Arch |

| It to just work | Mint, Fedora, Ubuntu LTS |

| A server | Debian stable, Alma/Rocky, Ubuntu LTS |

| The newest everything | Arch, Fedora, Tumbleweed |

| To build it all yourself | Gentoo, then LFS |

| Old hardware | antiX, Puppy, Debian + LXQt |

| Eyes-free | Slint, Vinux |

| Containers/Alpine-style minimalism | Alpine, Void |

## Why Slackware — the handbook's argument

Slackware (1993 — the oldest living distro) is the choice because it hides *nothing*: the installer makes you partition, the init is readable scripts, the package tools leave artifacts visible in `/var/log/packages`. It's the LFS philosophy with a package manager — the perfect staging ground for chapter 2. **Slint** adds the accessibility layer that makes it the eyes-free path too.

## The LFS endpoint

LFS isn't a distro — it's the *source* of the distro idea: a system you built yourself, no upstream. The landscape exists because someone else does the curation work — LFS shows you what that work actually is.

## Exercises

1. Place three distros you've used on the family tree — which root?

2. Compare `apt`, `dnf`, `pacman`, `xbps` on the same task — the syntax grammar.

3. Identify a musl vs glibc distro — and the consequence for LFS.

4. Map a specialist distro to its niche — why that choice?

5. Argue for a distro for a specific real use — which family and why?

## Timeline

| | |

| --- | --- |

| 1993 | Slackware — the oldest living |

| 1993 | Debian — the community pillar |

| 1996 | Red Hat's RPM era |

| 2000 | Gentoo — source as distro |

| 2002 | Arch — the rolling model |

| 2004 | Ubuntu — the mass-market move |

| 2008+ | Alpine/void/NixOS — the independents |

| 2020 | immutable/atomic era begins |

## See also

- [[Getting Linux]] · [[Package Management]] · [[Linux]] · [[Eyes-Free Linux]]

[[Category:Linux]]

[[Category:Handbook]]

[[Category:Distributions]]