Philosophy

UNIX and the tooling that grew on top of it are remarkable. Its designers were uncommonly disciplined about subtraction: the question wasn't "what should we add?" but "what can we take away?". The result was a set of narrow waists (everything is a file, programs read and write streams of text, small tools compose into bigger ones) that are still load-bearing fifty years later. Plan 9 sharpened those ideas further, Linux adopted many of them, and the userspace tooling has been refined for decades. It works. We are not trying to displace it.

Rust is unusual. It has a famously steep learning curve, but the curve is the point: the same constraints that make the language hard to pick up make it safe to experiment in. The compiler enforces enough invariants that you can rewrite a piece six times and trust each version not to fall over in surprising ways. For us, that makes Rust the most inviting language to play in.

Rebuilding classic tools in Rust is how we learn the corners of the systems they touch. Along the way, we get something the original sources rarely offer: clean, readable code with a real test suite, and library crates that other projects can build on. Much of the original tooling grew out of monolithic C codebases with no clear separation between reusable logic and the CLI wrapped around it; we try to keep that split to allow others to easily build on our work.

We default to permissive licenses (usually MIT and Apache-2.0) so others can build on what we publish. Some pieces of the ecosystem we touch are more restrictively licensed (GPL), and where a fully clean-room rewrite would cost more than the project is worth, we accept that. In those cases we still try to keep the library crates permissive; the restriction stays in the binary.