Building a Minimal X86 Linux Distro with Buildroot

The manual ARM/QEMU build earlier in this track does every step by hand — cross-compiler, kernel config, BusyBox, hand-written init, on purpose, to see each piece. Buildroot automates that entire pipeline for a target of your choice, including the host's own x86_64 architecture, which also means no cross-compiler is needed at all. This repo has an actual working build under Simple_Distro/ — a real buildroot-2025.08.1 + busybox-1.36.1 + linux-6.17 checkout, with the resulting rootfs.ext2/x86.img images sitting right next to them as proof it boots.

What Buildroot Actually Automates

Buildroot generates, in one pass: the cross-compilation toolchain (or, for a native x86_64 target, just the right host toolchain flags), a correctly-configured Linux kernel, a root filesystem built around BusyBox plus whatever extra packages are selected, and — for a QEMU-style target — a ready-to-boot disk image. Everything that took a dozen manual steps in the ARM/QEMU walkthrough (cross-compiler setup, versatile_defconfig, manual BusyBox menuconfig, hand-rolled init, manual cpio/ext2 image creation) is one make invocation here.

tar xvf buildroot-2025.08.1.tar.gz
cd buildroot-2025.08.1

# a complete, working default config for a QEMU x86_64 target
make qemu_x86_64_defconfig

# optional: browse/change package selection, kernel config, etc.
make menuconfig

make   # downloads everything, builds the toolchain, kernel, and rootfs — takes a while, especially the first time

The output lands in output/images/: a kernel image, the root filesystem image, and (depending on the target defconfig) a ready start-qemu.sh script or an equivalent documented qemu-system-x86_64 invocation.

qemu-system-x86_64 \
    -kernel output/images/bzImage \
    -drive file=output/images/rootfs.ext2,if=virtio,format=raw \
    -append "root=/dev/vda console=ttyS0" \
    -nographic

Default login is root, no password — this is a from-scratch build, not a hardened distro image.

Why the Manual Approach Still Matters

Buildroot is what any real embedded project actually uses — nobody hand-assembles a production root filesystem with cpio — but it hides exactly the steps the manual ARM/QEMU lesson walks through by hand: what actually goes into an init script, why dracut/BusyBox exist, why a kernel needs specific driver config for the storage it's supposed to boot from. Doing it manually once is what makes Buildroot's make qemu_x86_64_defconfig legible instead of magic — every one of its generated artifacts (bzImage, rootfs.ext2, the init process) is the exact same kind of thing the manual build produced by hand, just generated and wired together automatically.

The Manual X86_64 Path, for Comparison

The same manual technique from the ARM lesson applies almost unchanged to a native x86_64 target — and notably, no cross-compiler is needed at all, since the build host and the target architecture match:

# a raw disk image, partitioned and formatted, standing in for a real drive
dd if=/dev/zero of=disk.img bs=1M count=128
sudo losetup -fP disk.img
sudo fdisk /dev/loopX          # n, p, 1, <enter>, <enter>, w
sudo losetup -d /dev/loopX && sudo losetup -fP disk.img   # refresh so the kernel sees the new partition
sudo mkfs.ext2 /dev/loopXp1

# no ARCH= or CROSS_COMPILE= needed — building for the host's own architecture
make O=./x86_build defconfig
make O=./x86_build menuconfig   # confirm: File systems ---> <*> Second extended fs support
time make -j$(nproc) O=./x86_build

BusyBox, device nodes (/dev/console, /dev/null), and a hand-written /sbin/init get assembled into the mounted partition exactly as in the ARM build — then:

qemu-system-x86_64 \
    -kernel linux-6.17/arch/x86/boot/bzImage \
    -drive file=disk.img,format=raw,if=virtio \
    -append "root=/dev/vda1 rw console=ttyS0" \
    -nographic

Ctrl+A then x exits QEMU. Between the two approaches: the manual build is the one worth doing once, to see every moving part; Buildroot is the one worth using for anything beyond a learning exercise, since it turns the same pipeline into a single reproducible make.