I Built Linux from Scratch

I did LFS back when I was a pre-teen/teen. So late 90s, early 00s. And while I agree to an extent that it doesn't give you much day-to-day stuff, it really makes you more comfortable with operating systems and linux especially.

Nowadays, I am a devops/infrastructure engineer, and I can say LFS is a core foundational experience that has let me be better at my job. I know deeper inner workings of a Linux distro and that strong foundation helps. Yes there is so much more to learn but having LFS in your back pocket of lifetime experiences is great.

I also think its a 1 and done kind of thing. I don't see a huge benefit of doing it again. Maybe for fun, in a VM while waiting for other things to finish. It is also much faster nowadays. Back when I did it, I had a 1ghz, 256gb ram machine, it took me days. I could probably go through it in a day casually with modern computing, and especially since I have a threadripper machine, sending 64 threads at the make commands im sure will get my 1 BU to be a very small number.

If you have a child that is interested in computers, tech, programming, etc. I highly encourage this activity. Could be a fun bonding activity too.

I built LFS like back in 2005 or something. I remember it took forever. I wonder if it's faster or slower now. My computer is definitely faster, but I also have a creeping suspicion the code has gotten a lot bigger. Then at some point I switched to gentoo. I remember I vacillated between gentoo and slackware. The important thing was that I had an onion on my belt, which was the style at the time.

I wrote this a few years ago, when LFS made the front page:

I had a lot of fun doing this. You really get a feel for the evolution of build systems -- from older software that uses automake/make to newer programs that use meson/ninja/cmake etc. It was also cool to learn how to bootstrap a bespoke set of development tools tuned for your hardware.

It took me a solid weekend to get everything built. I was able to get a basic LFS system built on a Saturday, and on Sunday I did the "Beyond Linux From Scratch" edition. At one point I got stuck trying to debug a weird interaction between systemd and PAM that took me a while to unravel. That was humbling, I thought I knew just about everything about Linux, but turns out there are large areas where I just don't have a clue.

The docs are well written and maintained, so there wasn't a lot of frustration there. Even if you're not an old hand at Linux you can likely get pretty far by just diligently following the instructions.

I struggled a lot more trying to make a decent desktop environment than I did getting the OS setup. I spent so much time trying to get a nice-looking toolbar (polybar) and basic stuff (like how patched fonts work) took me an embarrasingly long time to sort out. I also didn't know what a compositor was, or why you might want one. I enjoyed figuring out the basics of compton, which allowed me to get cool transparent backgrounds on windows[0], although I never did quite figure out how to get rounded corners.

[0]: https://muppetlabs.com/~mikeh/spudlyo.png

For something that's more of a prepackaged build-your-own-Linux kit, there's also KISS Linux[0]. It's kind of a microdistro with minimal abstraction over the raw guts, and "packages" are just pre-downloaded source code repos that you compile yourself.

The "package manager" is just a shell script. The installation process[1] is entirely manual, so you control every step as you bootstrap up to building your own kernel and installing each subsystem, all the way up to compiling and running Firefox. It's pretty neat.

[0] https://kisslinux.org/

[1] https://kisslinux.org/install

If you need something more practical, but still challenging, try Slackware.

Use the advanced install feature and only select the packages you need. Build the other software yourself. You can choose your own difficulty this way. You can also follow the distro's way of packaging up software (build scripts), or build it the software developer's way. The main advantages of building software yourself are:

1. You are a developer who wants to customize the software.

2. You want to practice.

3. You want to contribute to a project.

4. You want to have a better understanding of what the code does.

Slackware 15 is a modern platform to build upon.

I highly recommend building an LFS. It was one of my first big personal endeavors with computers. In the article, the author says they didn't learn stuff that'll _necessarily help them in their day-to-day_, which I can echo, but I definitely learned a lot about different commands, the file structure of linux, `hier`, changing root, cross-compiling, toolchain building... it's really an awesome and fun process, and is especially satisfying when you manage to boot into it for the first time. I will say I'm much less fearful of the GRUB CLI than I used to be ;)

I deployed ipcop[0] routers a few times.

Ipcop was a pretty good router. It could be booted off a 1.44MB floppy disk. It was built using LFS, so it took a while to install on a home-grade machine (like, a day!). This was ages ago; apparently they're still going.

I didn't learn anything from installing it, except that it's possible, as a user, to build the whole toolchain, the OS, and the application, starting from assembly language. And that using LFS, you can make a really tiny Linux. Making a router was a good application of LFS; I'm surprised the search engines have forgotten it.

[0] http://www.ipcop.org/

It's important that we can always do that.

I did this back in highschool (so 1ate 90s). It was a really fun experience but I don't think I learned as much as I had hoped. I learned a lot about bootstrapping a system but not how to maintain it. It turns out package managers are really important for that.

I ended up using the system for a few months until it collected enough cruft that I started over with some other distro.

Flamebait, but:

> Slackware and LFS are the Haskells of the Linux distribution world. People jump to the extreme end of the spectrum, and either get burnt or remain unproductive for life, when they should have just used OCaml or F# instead.

https://blog.nawaz.org/posts/2023/May/20-years-of-gentoo/

I've done both LFS and Gentoo. While LFS is certainly fun, in practice I don't think you really learn that much more than with Gentoo. The benefit of the latter is it's easy to stick to for life.

I built an LFS system during one weekend my first semester of freshman year of college. I had too much free time I guess...

At the time I made it a 32-bit system since LFS didn't (doesn't?) support multilib and I knew I would need some 32-bit libraries.

I used that as my main system for quite a long time, upgrading software or installing based on BLFS or my own intuition as necessary. It worked pretty well! It was an invaluable experience in the development of my Linux expertise.

After about 5 years I got frustrated with the 32-bit system so I did an in-place upgrade to 64-bit. It was thrilling to come out the other end of that, to say the least (seriously). The training wheels were definitely off, but LFS had educated me enough to be confident in doing it. Also I kept around all the 32-bit stuff of course, so I could incrementally upgrade things.

After a few more years (maybe 2018ish?) I grew weary and changed to Arch (now I use void) :)

All that being said, I highly recommend LFS!

Some 20 years ago I went and built "Linux From Scratch". I think this (among other similar exercises I did) enables me to find my way pretty quickly around any new or old tech thrown my way.

I highly recommend this to anyone interested in 'computers'.

After I finish the whole process, can I slap pacman on top my freshly build LTS and effectively transform it into Arch and daily drive it? Or is it only meant "for the journey" of building it, but can't realistically be used as a daily?

I spent about two weeks in the early 90s with an unholy collection of DOS, 386BSD and Minix futzing together a bootable linux system on a 386/25 with 1M of memory. A couple months later someone told me about this thing called "SLS." I am definitely a fan of a decent distro.

But yes... building Linux from scratch can be very educational. It's probably a right of passage for jedi geeks: LFS, designing and spinning your own SBC, using wireshark/ethereal to debug a borked Cisco router. Sadly, I still remember much more about LILO than I ever learned about Grub.

Recently I was making an embedded linux image for enclaves where a shell and shell utilities did not make sense and high security and auditability was needed.

I learned a bit of rust and wrote a minimal init system perfect for my use case: https://github.com/distrust-foundation/EnclaveOS/blob/master...

The init system is statically compiled into the kernel as a CPIO.

This is about as bare bones as you can get with linux, and may help others understand the essentials.

I was only able to do this because of years of running gentoo and building linux for various embedded projects. It pays off!

You could swap out my init binary for busybox init and have built a full interactive linux distro from scratch in under an hour.

I did it in 2001 and it was one of the most educational things I've ever done. I think there should be a college course which gives you a box of computer parts at the beginning of the semester and at the end you get the grade displayed on a web page hosted on that computer built entirely from source.

I have some precedent for that kind of thing, back in 1987 I made a deal with a prof that as an independent study course a friend and I were going to build a pair of voice synthesizers on IBM PC Prototype boards using the synth chips available at Radio Shack and he'd give us the grade my computer verbally asked him for at the end of the semester. I had no backup plan and it was a crazy risk, but we got A's and the teacher regretted not having us make one for him as well.

I almost did it but it really didn't like that I was using NixOS as my host so I built a package manager instead https://git.sr.ht/~nektro/wifilylinux

Linux from Scratch is educational but fundamentally impractical to use.

I recommend using embedded Linux instead, e.g. with Buildroot. You get an understanding of the fundamentals of the hardware, kernel, and build toolchain. And you can create small hardware systems that do fun things.

I ran Gentoo for a few years, and enjoyed it. Doing the install from stage1 gives you a similar understanding of how the pieces fit together and enables you to fix low level system problems, e.g. with disk failures. The community is also smart, as it self-selects for people who have skills and good attitude. Unfortunately Gentoo is too slow to install and quirky to deploy on servers.

I remember this being a phase I went through when I was in school.

Back then I ran into the same issue as everyone else, it basically felt like Slackware, or FreeBSD with the ports but sans all the handy patches.

I'd love it if their docs[1] actually mentioned how to install an existing package manager software on your LFS, that would basically make it a distro.

1. https://www.linuxfromscratch.org/lfs/view/stable/chapter08/p...

I'm reminded of this in the very early days on my blazing fast 486... where you would go to build the kernel and walk away for two days waiting for the next compile failure.

I did it few times. It's so much easier nowadays with https://buildroot.org/

For those who've been through LFS, would you say that it's a good first step for someone who wants to roll their own bistro at some point down the road?

There's the LFS Project[0] route and then there's building things on top of the latest Debian or Arch releases. All are good learning exercises. The only real hurdle is installing drivers for things like Printers, Wi-Fi adapters, graphics cards, etc. That can be a headache-and-a-half.

[0] https://www.linuxfromscratch.org/lfs/

I like LFS, and I think it's a good teaching tool, but probably most people on HN won't get much out of it. It's like building a car from a kit: You don't know why you're connecting the belt between generic oddly-shaped box A and generic oddly-shaped box B. I've thought about making an LFS where you use a bare kernel image and write a simple init process, with busybox as a backup.

I got to do an independent study project junior year of highschool where I build the LFS project and went on to write my own (super basic) source based package management system. Was hands down the most valuable learning experience I've ever had. I highly recommend going through the process once if you want a better understanding about Linux/operating systems/compilers/toolchains!

I did one based around LFS a year or two back, but I used the Heirloom pkgtools stuff to publish packages in SVR4 format just for a laugh. I even packaged up and built CDE for it, it was a real fun parody of Solaris and other SVR4 systems. I called it HeadRat Linux. It really did add a nice spicy SVR4 style coating over Linux which I thought was kind of hilarious.

It's a waste of time. There is a reason why this is all done automatically. This is one of the things I think about when people say that "Linux is only free if you don't value your time."

Even if you try and argue it is educational. Learning how to build programs does not require LFS. LFS is inefficient as a learning tool

I did it multiple times in past in a few companies where I worked on various Linux based network security appliances. Using standard Linux distros on them is problematic for various reasons.

So I developed my own build system, which probably looked somewhat like Nix for building the distribution and managing updates.

LFS was great place to start with

I started doing it back in 2019 after college, but at the same time I was doing job interviews with code challenges that would take 2 - 3 days, so I end up giving up halfway through.

It was a miss calculation on my part, I underestimate how long it would take me to complete the whole LFS thing. Still on my todo list though

I built LFS in the early 2000s and I must say that I felt pretty much the same way. Compile times were pretty high for some of the items and it was fun to bootstrap the entire system. I learned a lot but I don't intend to do it again. I don't really need the knowledge these days.

I tried this twice, first time failed in stage 1... second time I got it all built but didn't build the kernel or boot loader...

Its certainly a learning experience, but I'm happy with Gentoo thanks.

Wait, no log or anything besides the sharing with the world that he did it?

Is the LFS faster than a regular distro? If the compiler takes into account your specific CPU and applies the available optimizations, it should be, right?

Could someone here please let the linuxfromscratch.org admins know that you can't access their site from Starlink?

I did LFS long back and replaced its default terminal as nodejs terminal. It was fun and learned so much from it.

I developed professionally on top of a LFS system in the early/mid 2000s.

In retrospect it was insanity layered upon insanity.

This link contains no additional information over the headline. He says he installed LFS.

No need to click on the link.

I did LFS long back and replaced its default terminal as nodejs terminal.

Do the hashes match? Is it 'wrong' if they don't?

If you have children, a much better investment is to have them install LFS and forbid them from using Windows/Mac, compared to going to college. I did not learn a damn thing in college because I'd been using Linux since age 12.