That’s the rallying cry from Michael Stapelberg, the Debian developer who’s fed up with version black holes in software. Picture this: your build fails, mysteriously. You chase logs, poke configs, but what’s the version of that pesky compiler? Or the linker? Gone. Vanished into the ether of unversioned binaries. Stapelberg argues — no, demands — that all programs must report their version. Easily. Reliably. Via a simple stamp subcommand.
It’s not just whining. In the trenches of open-source maintenance, version opacity kills hours. Days, even. And here’s the thing: we’ve had tools like --version forever, but they’re flaky. Half the time, they’re missing. Or they lie. Or they spit out garbage.
“I propose ‘stamp’, a new subcommand for all programs: ‘progname stamp’ prints version, VCS revision, build date, build host — machine-readable, stable format. Every program. No exceptions.”
Stapelberg lays it out in his April 2025 post (dated cheekily to 2026, because why not?). He wants JSON output. Structured. Parseable. So scripts can grab it without regex hell.
Why Don’t Programs Just Tell Us Their Damn Versions?
Blame history. Unix traditions birthed --version and --help, but no one enforced them. Tools evolved in silos — GCC here, Rustc there, each with quirks. Some use -V. Others --about. A few? Nothing. Developers assume you’ll strings | grep version, a hack that breaks on stripped binaries.
Look, it’s architectural laziness. Programs aren’t built with introspection in mind. Binaries ship as black boxes, optimized for speed, not debuggability. Stapelberg flips that: embed metadata at compile time. Link in a tiny handler for stamp. Boom — instant visibility.
But wait. Isn’t this cargo culting? We’ve seen standards fizzle — remember POSIX promises? Nah. This one’s different. It’s opt-out impossible in practice. Distro packagers could enforce it. Nix, Guix, already version-pin everything; they’d love parseable stamps.
One paragraph. Punch.
How Does ‘Stamp It’ Actually Work?
Simple: add a stamp case to main(). Route to a function dumping JSON:
{
"name": "progname",
"version": "1.2.3",
"vcs_revision": "abc1234",
"build_date": "2025-04-05",
"build_host": "builder.example.com"
}
No flags needed beyond stamp. Predictable. Stapelberg provides C code — 20 lines — embeddable anywhere. Rust crate? Coming. Go? Ditto.
Here’s my unique angle: this echoes the web’s evolution. Think HTTP headers — User-Agent, Server. Once optional, now mandatory for debugging. Browsers crashed? Check UA string. Servers misbehave? Server header. ‘Stamp It’ is the CLI’s User-Agent. Predict it’ll spawn ecosystems: stamp-aware package managers, auto-debuggers. Five years out, CI/CD pipelines stamp everything, chaining versions like blockchain provenance.
Skeptical? Fair. Enforcement’s the rub. Who mandates? LSB died; freedesktop.org might step up. Or distros: Debian’s Mr. Stapelberg could lint it in. Corporate spin? None here — this is pure engineer rage, not VC hype.
And yeah, edge cases. Static binaries? Embed at build. Containers? Image manifests already do versions; extend ‘em. Embedded? Minimal footprint — under 1KB added.
What Breaks Without Version Stamps?
Reproducibility nightmares. You fix a bug on your machine — works. Deploy? Fails. Why? Upstream bumped a dep silently. No version? Blind rebuilds.
Debugging war stories abound. Stapelberg recounts chasing a systemd issue — hours lost to version guesswork. Multiply by 10^6 maintainers. Open source bleeds time.
Corporate angle: DevOps teams hoard version matrices in wikis. Error-prone. Stamps? Query at runtime. docker run img stamp — instant audit.
But — em-dash alert — what about security? Versions leak info. Attackers fingerprint? Already do via behavior. Stamps standardize defense: known versions get patches prioritized.
Short one.
Long exploration: Imagine NixOS adopting this. Flakes pin versions; stamps verify. Or Homebrew: brew info gets turbocharged. Cross-distro? Flatpak, Snap could mandate. The shift? From opaque artifacts to provenance-first. It’s not just convenience — it’s auditing the supply chain. SolarWinds taught us: invisible builds invite sabotage. Stamps? Transparent trail.
Critique time. Stapelberg’s JSON rigid? Yeah, but extensible fields fix it. PR spin? Zero — guy’s not selling licenses.
Why This Fixes More Than You Think
Productivity multiplier. Scripts like for prog in $(path); do $prog stamp; done — toolchain census in seconds.
Prediction: 2030, it’s POSIX. Or de facto via AI agents parsing stamps for root-cause.
Wander a bit: Reminds me of Git’s plumbing commands — porcelain for humans, plumbing for machines. Stamp’s plumbing.
🧬 Related Insights
- Read more: finprim: The TypeScript Library That Stops Teams From Rebuilding IBAN Validators for the Tenth Time
- Read more: The Docker Captain Making Six Figures While Teaching Everyone Else: How Sunny Built a Tech Career Beyond Code
Frequently Asked Questions
What is the Stamp It proposal?
Michael Stapelberg’s idea that every program implements a stamp subcommand to output structured version info in JSON.
Why should all programs report their versions?
Version opacity wastes developer time on debugging and reproducibility; stamps make it machine-readable and universal.
Will Stamp It become a standard?
Likely via distro enforcement (Debian, Nix) and language ecosystems — low cost, high reward.
