One Person Rewrote All of Postgres in Rust. Should the Database World Care?

For the past few years, one phrase has run through software like a live wire: memory safety. Piece by piece, decades of C code has been reborn in Rust. But the latest target is not some dusty command-line utility. It’s the king of open-source databases, Postgres. Someone rewrote the whole thing in Rust and declared “100% of the regression tests pass.” That’s a big claim, and it deserves a hard look.

What Actually Happened

The project is called Pgrust — Postgres, ported to Rust, exactly as the name suggests. It slipped onto Hacker News as a quiet Show HN in late June, then detonated when it hit the front page again on July 9. It pulled in 478 points and a staggering 447 comments.

The core pitch is simple and deliberately provocative: Pgrust passes 100% of the regression tests that Postgres runs against itself. If you’re not familiar, a regression test suite is the automated battery that checks whether a database still does what it’s supposed to do. Passing all of them means that, at least on the surface, this thing behaves like real Postgres.

Then there’s the twist that caught everyone’s eye: the license. Pgrust ships under AGPL. The original Postgres uses the famously permissive PostgreSQL License. AGPL is the opposite end of the spectrum — a strong copyleft that triggers source-disclosure obligations even if you only offer the software as a network service. That’s why the top-of-thread reaction was less “amazing” and more “AGPL? Now that’s interesting.”

Why the Community Is Skeptical

This was not a standing ovation. If anything, doubt outweighed applause, and the sharpest comment cut straight to the point:

We now need to clearly distinguish between something a human rewrote and something an AI rewrote.

Here’s the subtext. “I rewrote X in another language” projects are flooding the ecosystem right now, and a large share of them are the output of an AI told to transpile a codebase. The commenter’s real jab was that these projects all lean on the same single piece of evidence — the tests pass — and nothing more. As one user put it, they’re seeing too many rewrite projects that claim “it works” on the strength of a green test run alone.

That critique stings because it’s correct. Passing tests only guarantees the things the tests check. No matter how dense a regression suite is, a huge fraction of what actually breaks in production lives outside the test harness. For a database, that gap is enormous.

Passing the Tests Is the Easy Part

A veteran commenter named the real gate: running Postgres at scale in production is genuinely dangerous, and a fresh rewrite makes it more so.

Think about it. If a database’s job were merely “take a query, return the right answer,” life would be easy. But real Postgres is the distilled product of decades of hard-won operational knowledge.

Staying up when thousands of connections hit it at once. Not corrupting your data when the server dies mid-write. A query planner that stays fast on a table with hundreds of gigabytes. The subtle handling of locks and transaction isolation. None of that is proven by a single clean regression run. It’s the trust that gets forged over years, as countless companies get beaten up by edge cases in the field.

That’s the mountain Pgrust has to climb. Behaving identically at the syntax level and surviving a 3 a.m. outage without losing a byte are two completely different achievements.

Why the Attempt Still Matters

Skepticism isn’t the same as worthlessness. In this case, it’s closer to the opposite.

The heart of Postgres is written in C. C is powerful, but it hands memory management to the programmer — and in a database, a memory bug doesn’t stay small. It becomes data corruption or a security vulnerability. Rust’s whole pitch is to shut that door at compile time, before the bug can ever ship.

If Pgrust actually matures to production grade, it stops being a mere port. It becomes a proof of concept for a much bigger claim: that even the most critical infrastructure software on earth can be rewritten in a memory-safe language. The Rust-rewrite wave that started in browser engines and OS kernels would have finally reached the last line of defense — the layer that guards your data itself.

The Takeaway

Let me be straight, though: the conversation around this is still thin. Over the past month, the meaningful discussions you can point to are few. Hacker News caught fire once, but real-world reports and benchmarks are still scarce. Right now the buzz is out ahead of the verification, and that’s the honest read.

So here’s where it lands. Pgrust is a fascinating challenge, but calling it a “Postgres replacement” is far too early. The real exam doesn’t start with the regression suite — it starts the day someone puts this in front of live traffic. The question worth sitting with: would you have the nerve to swap your company’s core database for a newborn Rust edition of Postgres?