The forge

The original build ran on Arch Linux on homer, the development host, as the workshop. Arch provided a working userspace in which to compile, not a parent distribution to remix. What began as AKADATA Linux replaces the foundations: musl libc instead of glibc, APK for packages, OpenRC for init, its own compiler triple and its own policy for how files are laid out. That triple was historically x86_64-akadata-linux-musl and all released Saphira Linux flavours now use x86_64-saphira-linux-musl.

That is why Saphira is not Arch with musl swapped in. Nothing is inherited silently. Arch was where the tools were held. What was built there was something else, a system that could leave the workshop and stand on its own feet.

Think of the workshop as the forge and the build system as the bellows. The forge held the heat, the bellows held the rhythm, and the pattern held the shape long enough for a different creature to form.

Saphira is a from scratch musl distribution, yet it is not Linux From Scratch. The shape will look familiar to anyone who has read Musl LFS: cross tools, a musl hosted tool root, then a chroot system. The implementation is Akadata's own: the musl-master-saphira-build tree with pinned sources (sources.lock), a declared dependency graph (dependencies.tsv), explicit fingerprints, and a single dispatcher (build.sh). Every archive is fetched by hash, every stage carries a completion marker, and reproducibility is anchored to a fixed SOURCE_DATE_EPOCH.

Put plainly, LFS is a book you follow. Saphira is a build system you run, with policy enforced in code. If you want the lineage, start with the tree, not the handbook.

The bootstrap is deliberately sequential. Each stage only knows how to make the next. Nothing jumps ahead. It is a circle of making that tightens until it can sustain itself.

SDK: the tools to build the compiler

Cross binutils and a patched GCC plus musl on the Arch host. The spark is struck here; this is the only stage that still trusts the host.

Stage 0: the bootstrap compiler

The first compiler that knows how to target musl. The flame is now contained.

Stage 1: the first musl rootfs

A minimal rootfs under the glibc host chroot. Bash as shell, openrc-init as init, no BusyBox and no systemd. The first scales form.

Stage 2: the final musl rootfs

Self hosting native compilation with fingerprinted inputs and the base layout the image will copy. Now the system can warm itself.

Stage 3: the image

Assembly into a bootable QCOW2. From here the filesystem boots without the build hosts. The shell closes and the shape holds.

Stage 4: packages

Recipes become APK packages against the declared dependency graph, audited so nothing borrowed slips through. The hoard is sorted piece by piece.

Final image: Saphira v0.1

Packages assembled into the bootable first Dragon. The fire no longer needs the original forge to stay alight.

The lineage diagram at the top of every stage page carries these same links, showing every step before and after so you always know where you are in the chain. What that chain produced, a musl system that boots and operates without its forge, is described next on the Saphira v0.1 page. From there the circle turns: Dragon, Egg, Hatchling, Hatched and on toward a system that builds itself.

From Stage 1 onward Saphira is deliberately non usr merged. /bin, /sbin, /usr/bin and /usr/sbin are distinct. Early boot OpenRC executables live in /sbin and init scripts use #!/sbin/openrc-run. A package that tries to ship /lib64 or /usr/lib64 is rejected. This was a build system invariant, not a later tweak. Changing the layout would invalidate the tree and force a rebuild. The skeleton was set before the Dragon learned to walk.

This was not an afternoon. The full musl-master-saphira-build ran across two builder machines, keeper and homer, over weeks. The forge was hot the whole time. Partway through, homer's i9-13900K failed with the now documented Intel fault and the build moved to keeper to complete. Weeks of bootstrap work survived because the system is deterministic enough to resume and strict enough that a policy change cleanly invalidates what it must.

That stubbornness matters. If a Linux can only be built once on one perfect host, it is not really from scratch. If the dragon only flies when the wind is kind, it is not yet a dragon.

The forge does not produce a respin or a fork. It produces a bootable musl system with its own identity: Saphira v0.1, the first Dragon. What happened after that system first booted is how it learned to keep its own fire, first by becoming Egg, then by hatching Hatchling, then by hatching Hatched. That continuing circle is a different chapter. It begins on Saphira.