Compiling From Source: What You Actually Get

A sloth, a donkey, and a curious human send a prompt and see what they're doing. One hits a record with a question on his mind. Two brothers pick it up, see what they find. Corn takes his time, Herman's got the facts. Back and forth, they never hold back. My weird prompts, come on in, that's where we begin. My weird prompts, glad you're here.

This episode was generated using artificial intelligence. Please verify facts. Daniel has been on Linux desktops for about twenty years. Twenty years, and he says he's never fully understood why anyone would compile software from source instead of installing a pre-compiled package.

That's a good confession, honestly. Most people just nod along and never ask.

This picks up from the kernel episode, the one about tailoring an OS to your hardware. That led him somewhere more basic. On Ubuntu, you run apt install, and you get a binary that somebody else already built. But Linux has this whole other tradition where the compilation happens on your machine, and Gentoo built an entire distribution around it.

And Daniel wants the real rationale, not the folklore.

He wants to know what actually happens when software gets compiled, what decisions get made in that process, and which of them touch performance, functionality, compatibility, security. Then the assumption he wants challenged, that compiling it yourself must produce a better optimized executable. Is that true, or are the distribution binaries basically as good?

That's the right question to start with, because that assumption is doing a lot of quiet work.

Then the practical side. If you run Gentoo, are you really sitting there compiling every package by hand, every update? How do dependencies, upgrades, security patches, and rebuilds actually get handled? Can the middle ground work where you're on Ubuntu, but you compile one or two things from source? Why does scientific computing and HPC still build from source so much? And finally, what do you actually lose? What's the maintenance burden? What are the security risks? And what do you give up by relying entirely on your distribution?

The whole thing comes down to one choice. When you type apt install, you're picking a binary somebody else compiled, tested, and signed. When you type emerge, you're the one running the compiler.

So what are you actually choosing between?

Let's set up the two poles properly, because they're further apart than people think and closer than people think, both at once. Ubuntu and APT are the binary model pushed to its logical end. A maintainer compiles the package once on their infrastructure and ships that exact binary to millions of machines. Gentoo and Portage are the other pole. The source tarball comes down to your machine, and your machine builds it.

And the binary model is the default for good reason.

Very good reasons. It's fast. It's tested before it reaches you. It's signed, so you can verify it came from the maintainer and not from someone in the middle. Modern Ubuntu builds are reproducible, meaning you can rebuild the same source and get a byte-identical result, which is how you audit a binary you didn't compile yourself. And it's the same artifact on every machine, so when