Astral: How a side project changed Python tooling

I first heard about Charlie Marsh in 2022 through Ben Quazzo, another Accel partner. Ben's introduction was simple and memorable: he called Charlie "his smartest friend." That's the kind of thing people say. In this case, he really meant it. 

Charlie was living in New York, tinkering on side projects, and drawn toward developer tooling. We grabbed coffee and talked about devtools. He was clearly sharp and very likeable, but not sure yet if he wanted to start a company.

Then a few months later, I came across a project called ruff on GitHub while skimming for new tools being built in Rust. I had a hunch this was my chance to work with Charlie, and I booked a flight to New York.

Rust-Pilled

When I sat down with Charlie again, he was deep in a new obsession. He had become what you might call "Rust-pilled," convinced that Rust was the right language for a generation of developer tooling the industry had largely overlooked. The origin story was practical, almost mundane: at his previous company, working on a large Python codebase, static tooling had eaten up an absurd amount of his team's time. He figured he could fix that.

ruff is a linter — and yes, it's not glaringly obvious how a linter translates into something commercially big.

But here's what changed my mind: developers who used ruff would run it, and it would finish so fast — 10 to 100x faster than anything they'd used before — that they thought something was broken. So they'd intentionally introduce errors just to confirm the linter was actually working.

That's what I call a magic moment. When something is so noticeably, viscerally better that users can't quite believe it's real. When I heard that story, I stopped thinking about what ruff was and started thinking about what Charlie was going to build next.

We closed the seed round shortly after.

Toolchain, etc

There's been a broader movement to rewrite developer tooling in Rust, and Astral is the perfect example. The VoidZero team have also been doing a lot of this work with oxc and their toolchain for JavaScript. The pattern makes sense: Rust gives you systems-level performance while letting users keep the language they already know.

For Astral, ruff was where that hypothesis first showed its promise, and it kept growing. When Charlie added a formatter alongside the linter, it was a real inflection point. ruff had quietly reimplemented rules from dozens of existing tools, flake8, pylint, isort, pyupgrade, and more, all in a single binary. Developers loved it and it started to tell a much bigger story about what Astral could become. Shortly after, we led the Series A and joined the board. 

By this point, the team was working on uv, a packaging tool for Python that aimed to replace much of the existing stack, pip, virtualenv, pip-tools, and parts of poetry, in a single, dramatically faster workflow. It was a big bet that was a little outside of the toolchain, and we didn’t know how developers would react.

As it turned out, developers cared a lot about uv. For people who had spent careers wrestling with Python's packaging quirks, uv felt like relief. For newer developers, it just worked. Same magic, new surface area.

One thing Charlie was consistent about from day one: it had to be about Python. He insisted the tools be backwards compatible with existing standards and that nothing would break what developers already relied on. This — and the blinding green tiles on Charlie and the team’s GitHub profiles — were big reasons the community trusted Astral so quickly.

Small teams can do big things

What still blows my mind: the team building all of this was never large. The scale of adoption relative to team size is genuinely unusual. That's what led to ty, a next-generation type checker the community had been loudly asking for, and another piece of the toolchain snapping into place.

The next chapter

Building tools that people love — not just use but actually love — because it makes their work meaningfully better, is rare. Today, OpenAI has announced that it will acquire Astral to bring these powerful tools to Codex. 

Astral has built a foundation for the Python ecosystem that a lot of that future can be built on top of. There is still so much to build in a world where code is increasingly written by AI and needs to be analyzed and validated at scales we're only beginning to understand. 

To Charlie and the whole Astral team: thank you for letting us be part of this. We're proud of what you've built, and genuinely excited to see what comes next at OpenAI. To the next magic moment!  

‍