Josh Thomas

I'm not sure of the origin of the phrase, but a quick search suggests this post from 2011 by François Zaninotto as one possible origin.

When people say "open source is a gift," they usually mean the final product: a library or application given freely to society, with no expectation of reciprocity.

I agree with this take on the phrase. One of the downsides of releasing software under an open source license is the expectations it can set up for some subset of end users: since they got it for free, they assume that support, bug fixes, and feature requests are also owed to them for free. So I like the phrase as a way to push back on those expectations.

However, I want to talk about a slightly different interpretation of the phrase.

The Gift of Development in the Open

Astral is a venture-capital backed company that has written a handful of tools for the Python ecosystem: ruff for extremely fast formatting and linting, uv for packaging and dependency management, ty for type checking, and most recently a package manager, pyx.

All of these (except pyx) are MIT licensed and developed completely in the open.

Astral's tools have generally been well received. In my experience, this comes down to taste in API design. Their tools just feel good to use. Still, people have (understandably) raised concerns about the Python ecosystem coalescing around tooling from a VC-backed company, given the general likelihood of enshittification that VC money tends to lead to.

I'm not here to talk about that entirely valid concern. Instead, I want to talk about what a gift it is that the development of these well-designed, well-engineered tools is happening entirely in public. Seriously: go look at the pull requests in any of their repos and you will see extremely smart programmers tackling thorny issues in real time. The fact that anyone can learn from that is itself a gift.

The Gift of Learning in Public

For about a year now, I've been working on a language server for Django as a side project. I chose to write it in Rust, despite never having used a low-level, statically typed systems language before.

From one perspective, this was a mistake. If I were being paid to deliver it for a company, I'd agree. The cross-language barrier adds real friction (even with tools like maturin and PyO3 smoothing the way). A well-supported language server library already exists in Python, and there's even a Django language server written in Python that is far more full-featured than mine. Had I chosen Python, I'd no doubt be further along and closer to matching those features.

But I'm not getting paid for this. This is a personal project.

So I chose Rust for entirely personal reasons: I wanted to learn it in a meaningful, non-toy context. Rust offers performance essentially for free, and its type system and borrow checker, while painful at first, force you to think differently about correctness and memory safety. After years of wrestling with type checking in Python projects using mypy and pyright, working in a language with actual types has been refreshing.

And honestly: it was fun.

This is where the "gift" of open source really hit me. Astral's codebases and PRs have become my textbook. Their discussions around error handling, incremental parsing, cross-platform quirks, performance trade-offs - all of it has been incredibly useful while I've been learning Rust.

And beyond reading, I borrowed ideas and techniques directly. The architecture of my Django language server is heavily influenced by techniques I first saw in their repos: using salsa for incremental cached computations, structuring a Rust project into multiple crates within a workspace, and even approaches for integrating cleanly with Python. Astral, in turn, built on ideas from other open projects like rust-analyzer and Cargo itself.

That chain of influence is what makes open source special.

The Gift Passed Along

So yeah, the original meaning of "open source is a gift" holds up. But I think there's more to it than the code you uv add or pip install or cargo add. There's the act of doing the work in the open. Bug triages, design debates in GitHub threads, pull requests anyone can read through - it's all basically a free, ongoing seminar in how good software gets made.

Astral, of course, isn't the only one building in the open - they're just the most relevant to my journey this past year. Countless others, from CPython to Django to projects maintained entirely by volunteers, are out there too, all ready for anyone to study.

The software you install is the obvious gift. But I think there's something just as valuable in the process being open too. It gives you permission to watch how good software gets made, borrow what works, and eventually put your own stuff out there for someone else to learn from.