Skip to content
ocx
install

Why binary distribution is broken

Why installing one tool on every laptop and CI runner is still harder than it should be, and what a registry can do about it.

Duration ·

Transcript

How many machines did you put the same tool on this year?

I stopped counting.

A Mac, a Windows laptop, a Linux runner: three ways to install one tool.

And nobody blinks.

Never.

It's just the tax.

This is the OCX Podcast for engineers who install tools on laptops and in pipelines. I'm Vera.

And I'm Max.

And I'd push back on that word, Vera.

Nobody's charging you.

Everyone's paying, though.

That's episode zero, why it's still true, and where the fix has been sitting all along.

Monday morning, new hire, new Mac.

The setup doc was written years ago for Windows.

Step one is a Windows installer.

That step doesn't exist on a Mac, so they follow the tool's own docs instead.

A package manager, whatever version it ships today.

Fine, same tool.

Same name, different version, different place on disk.

Half the doc's commands and configs land somewhere else.

I've done that.

Rewrote the doc for my machine. Next hire got a Linux laptop.

Then CI.

The runner takes it from the distribution's packages.

Two years behind, the release freezes versions.

That's not broken.

That's the distribution doing its job.

It is.

One tool, three machines, three versions.

Everyone did what their platform said.

Nobody did anything wrong.

So why does one tool need three ways in?

The honest answer isn't a bug report.

Getting one tool onto every machine that needs it isn't a hard problem.

It ate somebody's first day.

And it comes back with every version bump, every machine, every platform again.

So people stop bumping, and if you're the platform team, you can't easily move the version everyone else's projects require.

Every team pays that separately and pays again for the next tool.

Where does it actually get paid then? Installing a tool is one line in a doc.

One line per platform.

Every operating system on the team has its own idea of where a binary lives and how it lands on your path.

On Windows, the terminal you already had open never hears about the path change.

Neither does your editor.

You restart both, and by then, it looks like the install failed.

Linux, at least, is one platform.

Linux is where one build stops being one build.

Two C libraries are in common use, glibc and musl, and a binary linked against one won't start under the other.

Two builds then for one operating system.

At least two.

Call it the libc tax.

A team that's been at this a while doesn't live like that, though.

They pin it.

In their own packages with the version baked in, installed the way the distribution installs everything else.

That sounds like the grown-up answer.

It works for whoever then owns it.

Every distribution the runners use needs its own packaging.

None of it reaches the laptops, and installing it needs root.

And it holds one version per machine.

So moving between two projects means reinstalling the other version and hoping nothing else leaned on the one you removed.

That's where dev containers come in, a whole environment per project.

Which helps where teams adopt them.

Plenty haven't, so the laptop still needs the tool.

And a team that pins nothing just takes whatever the CI runner ships.

Until the runner changes.

In early two thousand twenty-five, a hosted CI provider moved its default Linux runner to the next release of the distribution.

The new image shipped fewer pre-installed tools.

So a tool you never installed because it was always just there is gone.

Nobody edited a workflow.

The meaning of latest changed.

For some projects, that runner is also where the release gets built.

Then the libc tax follows.

The release is built against the runner's GLC, so the runner decides the oldest Linux it runs on.

And less than two years later, that default moved again.

A laptop does the same thing, just without a red pipeline to tell you.

Its package manager keeps its own copy of a language interpreter, and the tools you install through it share that copy.

Until something upgrades it.

Because something else wanted a newer one.

Tools you haven't touched in months break.

Here's the other half.

People love that package manager because its versions are current.

Oh, that's the same property.

Current and unpinned are one thing.

You find out which one you wanted after the upgrade.

Then pinning through the system's packages is too stiff, and not pinning moves under you.

The project has to pin its own tools.

For a small team, at one version, that means four places, the CI runners, a couple of laptops, and the image the service gets built into.

Each with its own mechanism, a package list, a formula, an archive per platform.

And an image pinned to something slightly different.

None of the four knows the other three exist.

Most teams end up with the honest incumbent, one install script, and all four pointed at it.

Which is a table, really.

Platforms and download links edited by hand at every version bump.

A column for the operating system, a column for the architecture.

And nothing for the C library.

Not which one and not how old.

On an older Linux host, the script says everything's installed, exits clean, and leaves a tool that fails on its first run.

Why is anyone still handwriting that table? There are whole categories of tools for installing things.

Each one's good at its own job, and none of those jobs is this one.

The distributions packages manage an operating system.

A language package manager serves one ecosystem.

And the releases page doesn't install anything.

It's file hosting.

Build systems have the same problem.

One that needs a tool at a specific version carries its own downloader for every platform it runs on.

What about the version managers that fetch the release file for you?

The ones that pick it by filename break when a project renames its files.

And a publisher that ships through many channels finds each one works for some users and none for all.

So everyone's maintaining the same table.

Back to Monday then.

Why does one tool need three ways in?

It doesn't.

Add up what we've been asking for, every platform the team uses, the right build for each host, versions that stay put.

And no new service to run.

That's the one that narrows it.

Your team runs a system that stores multi-platform artifacts, authenticated, access controlled over TLS. It's the container registry.

Which sorts by platform too.

One name, a different image for each operating system and architecture.

The industry standardized the box and the port, and the tools inside still travel the old way.

That's not us running our tools in containers.

Different job.

It's transport.

You already have the infrastructure.

The registry your team already runs is what OCX is built on.

It's a package manager that moves tools through that registry.

Where does the pin live?

In your repository.

A file committed next to the code says which tools this project needs.

You clone it, pull, and the tools are on your path in that project.

The new hire from Monday opens the repo instead of the setup doc.

And gets the version the project chose, built for their machine.

CI reads the same file and the same lock, the same toolchain on the laptop and in CI.

A version bump is one change, reviewed like any other.

And the libc tax?

Not all of it.

Which family, glibc or musl, each host now picks for itself from one index per tool.

How old a glibc the build needs is still set where it's built.

We didn't answer how, though.

A registry was built to hand images to container runtimes, not a command line tool to a Mac, a Windows laptop, and a Linux runner.

That's episode one.

Your registry is already a package backend.

Everything's at ocx.sh.

Same toolchain on every laptop.

And in CI.

See you next episode.