Have you ever compiled a custom Linux kernel?

It's been about 20 years, but when I was 13-14 I ran some small webservers out of my room. Pretty much just toy projects. I definitely compiled Gentoo and some other distros, mostly as a hobby and also because at the time it was more or less necessary depending on the functionality you wanted. It wasn't hard, just slow at the time :).

I started building my own kernel sometime in the late 2000s when I needed to get a mouse driver fully functional. Then I never stopped doing it. It's a great way to learn about all the new features that are being added and to trim off excess modules you know you'll never need (or to learn about why you actually DID need them. oops.)

It's been a while but it's actually pretty easy. The last time I checked it was just a matter of grabbing the sources, answering some detailed questions about your machine, and running make. The hardest part was getting the bootloader to use the new one safely without getting rid of the old kernel in case you messed up the configuration.

My early experiences with Linux were well before Ubuntu made it easy, so I took the time to understand the system from inside out. For a time I was running a scratch-built somewhat barebones Linux system. I tried to do Gentoo for a while but their tools that were supposed to simplify everything actually seemed to make things more complicated, so I don't remember if I ever managed to make it self-hosting.

With all that in mind, I had a lot more knowledge about the inner workings of a PC before I started, so while I say "it's easy", that's not accounting for the knowledge I had acquired beforehand. For most people it's going to be something of a research project.

Over the summer I bought a Libre Computer "Le Potato", essentially as a cheaper alternative to a Raspberry Pi. They do provide their own images, but my preferred distro (NixOS) doesn't have their kernel in the central repository, so I ended up writing a little recipe to build it. Fortunately, NixOS makes that sort of thing easy (once you've gotten past the hardest thing in Nix: the documentation).

Somewhat tangentially related, but I've used a DevOps pipeline process to automate the build of a custom Linux ISO image off of a virtual machine. It was a complicated process that required a lot of trial and error; calling chroot presented some challenges and introduced unexpected behaviors. But looking back, this project really established my love of working with Linux and becoming comfortable with the command line.

I run funtoo, a derivative of gentoo, and routinely compile my own kernels. The standard tool for this family of distros is genkernel, which makes everything super easy. I also use dracut to generate my initramfs, because it has some nice tools for handling encrypted partitions.

Without starting a flamewar, I was on Debian for a long time, had a looooot of issues with the switch to systemd, switched to gentoo cos it seemed the best supported non-systemd distro, and quickly jumped to funtoo cos it has some nicer utils. Kinda fell in love with how the whole os is designed and haven't looked back. While you don't need to compile your own kernel for Funtoo it's a very natural step to take

Been using Gentoo for many years. I don't even know or remember what it's like to just accept and use a stock kernel blob from a distro provider. If all you're doing is changing kernel config and compiling, that's actually pretty easy, assuming you know which config vars you want or need to change -- and there's a lot of documentation out there to help you find those out.

In a sense, what's actually harder in practice than rolling a custom kernel is getting it to load smoothly with a boot loader. I actually have had more UX friction dealing with LILO and GRUB than with the kernel. Not to mention BIOS, UEFI, dual booting, telling the computer which disk to boot from. Those are the trickier things.

I run Gentoo Linux on almost all my machines, I have compiled al he kernels myself. I also set them up myself. I don't use initramfs, I boot kernel straight up.

Every kernel is made for the concrete mchine it runs on, which means it has only the driver for that one ethernet device that is present in the computer, for that one hardware monitoring (temps, voltages, fan speeds), for that one wifi card...

It is part of Gentoo Linux and I do it since around 2010, so it is just kinda no-brainer for me.

I also setup my own GRUB config file, as the generazed one seems too convoluted for me. I have my boot parameters on literally four lines, two of those are name to show on boot screen and closing parentheses ( } ). The other two are just pointing on the partition with /boot and then calling out the specified kernel.

Compiling a kernel is easy, verging on trivial. Documentation is good, the build tools are very robust, and the process is well-tested (across multiple C compilers, even). The kernel very possibly accounts for a plurality of C compilation time since the 2000s or so, so you would expect it to be well hammered-out.

Configuring a kernel is a whole different story. I have never successfully configured a working kernel from scratch. There are a lot of obscure options that you have to get "right", that may depend on details of your hardware or desired kernel functionality that no one who's not a kernel developer has enough context for to know. I've compiled working kernels, but only by starting from a pre-existing configuration (typically a distro's).

Far too long ago, at the beginning of my time with Unix and Unix-like systems, I spent a fair amount of time recompiling the NetBSD kernel in the hopes of squeezing a little more performance out of a DEC Multia. (I'm aware OP asked specifically about the Linux kernel, but the question was about motivations, not OS choices.) While the idea sounded scary when suggested to me by more experienced geeks, the process turned out to be little more than editing a text file to comment out unused drivers, running a couple of prep commands, then firing off the compile. Oh yeah, and then waiting until the next morning, because if there was one thing you could say about Multias, it's that they were SLOOOOWWWWWW.

I haven’t, but it’s sort of on my bucket list to do so. I’ve had the Building Linux from Scratch guide in my bookmarks forever and someday I’ll see it through.

Yes, back when I started I had only a very old PC (Pentium II, I think) built with whatever other parts I could scrounge together.

Leaving out everything I didn‘t use made a small but noticeable performance difference and I had to customize things to get my graphics and sound card working.

It was kinda fun but these days I have better uses for my time. And money for supported hardware.

Technically, yes. I used to run custom kernels on my Android phones way back when that was more possible. A lot of them had to be compiled from scratch.

Yes, in 1999 when I was first learning Linux and had a very crappy PCI 56kbps winmodem that Linux just didn't like. I attempted to get it to work by so many various attempts at changing flags/etc and recompiling the kernel.

I ended up getting an ISA 33.6kbps modem that just worked with Linux and I never bothered with a winmodem again.

Sort of, while making a postmarketOS port to an old phone of mine (real linux for phones) i had to get a kernel for my device, so i speciefied the kernel (which is basically the android kernel) and the program to make a port automatically took care of compiling it, i just had to put some patch files to make the kernel compile.

I ran gentoo for a while maybe 12 to 13 years ago which my nature required me to compile my own kernel but I don't remember much about it.