December 14, 2025 Categories Reading time: 6 minutes

I’m currently trying to get a little deeper into Linux and understand more what actually makes the OS tick under the hood. I’ve been using Linux for almost 20 years at this point, but how the Kernel works and how everything is put together so that a functioning operating system comes out of it is still somewhat of a mystery to me.

There is a project called "Linux From Scratch", which is essentially a tutorial that does a great job describing the process of compiling a working Linux system, well, from scratch. I’m currently working through it, but it’s pretty extensive and it takes a while to get through if you’re really trying to understand what you’re doing and aren’t just blindly copying commands.

Thanks to a recent YouTube video by Action Retro I found the perfect project to get into this sort of thing: Floppinux, a tutorial to create a working Linux distro of sorts that can boot from a single floppy disk and can run on hardware as low spec as a 33 MHz 486 CPU.

The tutorial does a great job guiding you through all the steps necessary to build a bootable Linux installation from scratch that is so tiny that it fits on a 1.44MB floppy disk.

You start by downloading the kernel sources and configuring the kernel with a bare minimum config that is just enough to make the system work, but as a result it’s also super lightweight with the compiled kernel only taking up around 830KB of space.

Booting just the kernel is kind of useless though, so some utilities are needed to turn this into a working system (utilities like ls, rm, echo, vi, cat and so on). For this, Busybox is used which is a collection of lightweight utilities compiled into a single binary. Busybox is primarily meant to be used in embedded devices where there’s a limited amount of storage and memory available and as such is perfect for this project. You also need a cross compiler to build Busybox for the target architecture (32 bit 486) on your modern 64 bit system.

After compiling the kernel and the Busybox utilities you create a floppy disk image, install a filesystem and bootloader (syslinux, another very lightweight tool) inside this image, copy the kernel and the Busybox utilities into the image, configure a few things and then you’re done. You just created a minimal Linux system that fits on a single floppy disk.

This image can then be tested inside an emulator like qemu or 86Box, or written to a floppy disk and be booted on real hardware. And so that’s what I did. I happen to have a USB floppy drive lying around that I bought on Ebay years ago, along with a few floppy disks, and so I dumped the image to a floppy disk, connected it to my Eee PC, set it to boot from the floppy drive, and... nothing.

The image booted fine in qemu and 86Box, but it didn’t get past the syslinux boot prompt on real hardware. I tried it on a different PC,wrote the floppy again, but the same thing happened every time. Maybe booting from a USB floppy drive doesn’t work the same as booting from an internally connected floppy drive? I don’t have a PC with an internal floppy drive anymore, so I thought I was out of luck here, until I decided to try a different floppy disk, and then it worked! Turns out 30 year old floppy disks can go bad. Who could have known.

And there is, a netbook booted from a floppy disk and running a Linux distro I created myself (following a tutorial of course). I have to say, that feels pretty satisfying! There’s still an error mounting the floppy disk itself, probably because it’s connected via USB and doesn’t show up under /dev/fd0 as expected. I’d probably have to compile the kernel with USB or SATA support enabled, but then I think I would run out of space pretty quickly, so I didn’t bother.

Is it useful? Probably not... you’d need a bit more software to make this into a system that can actually do anything, at least drivers for some external storage and maybe network access, but there’s only so much space on a single floppy disk. Booting from floppy is also insanely slow. I had forgotten how slow floppy disks are, but let me remind you: they’re very slow! Booting a system that’s just a bit over a megabyte in size takes almost a minute. When it’s booted however it’s perfectly responsive because it runs from ram and never needs to access the floppy again.

So even if the usefulness is pretty limited, at least if you stick to the utilities that are mentioned in the tutorial, it’s still a great learning exercise and a great demonstration of how much (or how little) is really needed to get a functioning Linux system. And of course it’s a good starting point if you want to flesh it out and install some actually useful software in there. You might be better off booting from a USB drive then, obviously. If you’re looking to understand Linux a bit better, I highly recommend having a look at Floppinux.

I have to mention though that I came across a few errors in the tutorial, which causes the system to be mostly functional, but a few things aren’t working right that have to do with mounting the proc and sys filesystems of the Kernel. I spent a bit of time figuring out why it wasn’t working and wrote a bug report on the project’s Github page. I’m also going to reproduce what I wrote here. Hopefully this will be included in the tutorial in the future.

So if you want to follow the tutorial and build the system yourself, make the following changes:

• The git clone call for the kernel contains an error

• Wrong: git clone --depth=1 --branch v6.14.y https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git

• Right: git clone --depth=1 --branch v6.14.11 https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git

• The init rc script expects ln and mkdir to be present, so these need to be included in busybox (add them via the busybox menu config)

• The first two setup paths for the cross compiler setup are missing a / after "${BASE}":

• Wrong: sed -i "s|.*CONFIG_CROSS_COMPILER_PREFIX.*|CONFIG_CROSS_COMPILER_PREFIX="\"${BASE}"i486-linux-musl-cross/bin/i486-linux-musl-\"|" .config

• Right: sed -i "s|.*CONFIG_CROSS_COMPILER_PREFIX.*|CONFIG_CROSS_COMPILER_PREFIX="\"${BASE}"/i486-linux-musl-cross/bin/i486-linux-musl-\"|" .config

• Wrong: sed -i "s|.*CONFIG_SYSROOT.*|CONFIG_SYSROOT=\""${BASE}"i486-linux-musl-cross\"|" .config

• Right: sed -i "s|.*CONFIG_SYSROOT.*|CONFIG_SYSROOT=\""${BASE}"/i486-linux-musl-cross\"|" .config

I also added /proc file system support in the kernel menuconfig under File systems -> Pseudo file systems. Not sure if this is really necessary though.

Want to get in touch?

• [Send me an E-Mail](mailto:andreas@82mhz.netDELETEME?subject=Post %22Building and running Linux off a Floppy Disk with Floppinux%22 “email me”)
• Reply on Mastodon