Postgres rewritten in Rust, now passing 100% of the Postgres regression tests
In this article
> **Bottom line:** A community-driven project has announced that its Rust rewrite of PostgreSQL, internally dubbed "FerrousDB," now passes 100% of the official Postgres regression test suite as of early July 2026.
This milestone, widely discussed on Hacker News, signals a significant shift towards memory-safe, high-performance database foundations.
While not yet production-ready, early benchmarks from contributors suggest up to a 25% reduction in p99 latency for read-heavy OLTP workloads and a 15% improvement in write throughput on specific indexing operations, primarily due to Rust's zero-cost abstractions and robust concurrency model.
This development challenges traditional database architecture and sets the stage for a new era of secure, performant data persistence.
I’ve spent the better part of two decades staring at systems logs, debugging memory leaks in C, and generally trying to make computers do what they’re told without setting themselves on fire.
So when I saw the news trending about a complete rewrite of Postgres in Rust, now passing *all* its regression tests, my first thought wasn't "hallelujah!" It was, "Alright, show me the numbers.
And tell me what unholy mess you've probably created along the way."
Turns out, the unholy mess might just be a blueprint for the next generation of data infrastructure.
Three Engineers. One Audacious Goal.
This isn't just some academic exercise. This is a project that three engineers I’ve spoken with in the past month all said represents a monumental shift.
"We were tired of the same old classes of bugs," explained Dr.
Anya Sharma, a principal database architect who previously worked on high-scale financial systems and now contributes to the FerrousDB project.
She recounted a specific incident in late 2024 where a subtle memory corruption bug in a custom Postgres extension led to weeks of intermittent data integrity issues.
"It was the kind of bug that makes you question your career choices," she deadpanned during a recent video call.
"That’s when the idea of a ground-up rewrite, with memory safety as a fundamental primitive, stopped being a pipe dream and started looking like a survival strategy."
The goal was audacious: replicate Postgres’s vast feature set, including its complex transaction management, MVCC, extensibility model, and rich data types, all within Rust's strict type and borrow checker system.
This isn't a new database inspired by Postgres; it's a byte-for-byte, feature-for-feature reimplementation of the Postgres wire protocol, query planner, and storage engine.
The project’s core team, which includes former contributors to other database systems, has been chipping away at this for nearly four years.
Their focus wasn't just on "making it work," but on ensuring semantic equivalence down to the most obscure edge cases.
The Regression Test Gauntlet
Hitting 100% parity on the Postgres regression test suite is not a trivial achievement.
The Postgres test suite is notoriously comprehensive, covering everything from basic SQL operations to complex window functions, concurrency scenarios, replication edge cases, and crash recovery.
It's a brutal gauntlet designed to expose even the most subtle deviations in behavior.
For FerrousDB to pass every single one of these tests means that, from an external perspective, it behaves indistinguishably from a C-based Postgres instance.
"We knew the regression tests were the ultimate arbiter," shared Liam O'Connell, a lead developer on FerrousDB, in a recent online forum post. "There’s no faking it.
If you deviate even slightly in how you handle a `NULL` in a `LEFT JOIN` under specific isolation levels, the tests will catch it.
We spent months just on the type system, ensuring Rust’s strong typing mapped perfectly to Postgres’s dynamic runtime." This meticulous approach is what separates a true rewrite from a mere "inspired by" project.
They aren't just building a database; they're building *Postgres*, but in Rust.
The Elephant in the Room: Performance and Production Readiness
Of course, the immediate question from any seasoned engineer is: "Does it go faster?" And "Can I run my production workload on it tomorrow?" The answers, as always, are nuanced.
Early, unofficial benchmarks are indeed promising.
Across a series of internal tests simulating a typical e-commerce OLTP workload (heavy reads, moderate writes, standard joins), FerrousDB consistently demonstrated a **12-18% reduction in average query latency** compared to an identically configured Postgres 16 instance.
More impressively, p99 latencies for complex read operations saw reductions of up to **25%**.
On the write side, particularly for operations involving B-tree indexing on SSDs, a **15% improvement in throughput** was observed.
"We attribute much of the gains to Rust’s memory management and thread safety," explains Dr. Sharma.
"The C version of Postgres, while incredibly optimized, still requires significant runtime checks and careful manual memory handling.
Rust, by guaranteeing memory safety at compile time, allows for more aggressive optimizations and reduces the overhead of defensive programming." She pointed out that specific areas like `JSONB` parsing and geometric operations, which are often CPU-bound, showed significant speedups due to Rust’s efficient string and data structure handling.
However, O'Connell was quick to temper expectations regarding production readiness. "Passing regression tests is a huge step, but it’s not the finish line.
We’re still in the early stages of hardening the storage engine, optimizing for extreme concurrency, and building out the entire ecosystem of tools that Postgres users rely on." This includes robust replication, backup/restore utilities, and integration with existing monitoring solutions.
A timeline for a stable 1.0 release is still "at least 18 months out," putting it in early 2028.
The Complication: Migration and Ecosystem Lock-in
The biggest hurdle for widespread adoption isn't just performance or feature parity, but the sheer inertia of the existing Postgres ecosystem.
"Rewriting a database is one thing; getting thousands of companies to trust it with their most critical data is another," commented Mark Jensen, a principal engineer at a large FinTech firm, who I spoke with last week.
"We’ve got decades of tooling, operational expertise, and tribal knowledge built around C-based Postgres.
The mental model, the debugging tools, the community forums – it’s all mature. What does FerrousDB offer that justifies that massive migration cost?"
Jensen’s point is valid. Database migrations are notoriously risky and expensive.
Even if FerrousDB offers a 20% performance boost and eliminates an entire class of bugs, the perceived risk of moving off a battle-tested foundation might outweigh the benefits for many organizations, especially those with stringent regulatory requirements.
He highlighted the extensive ecosystem of extensions, from PostGIS to TimescaleDB, which would all need to be re-evaluated or rewritten to integrate seamlessly with a Rust-based core.
"It's not just the database; it's the entire universe around it," he concluded.
This isn't a simple drop-in replacement, at least not yet.
While the wire protocol compatibility is a huge win, allowing existing drivers to connect, the internal extension API will likely require significant adaptation.
This means that custom functions, triggers, and data types implemented as C extensions would need to be re-engineered in Rust, or perhaps through a FFI layer, adding complexity.
What This Means for Developers and the Future of Data
Despite the challenges, the implications of FerrousDB passing its regression tests are profound for anyone building or operating data-intensive systems.
First, **enhanced security and reliability**. Memory safety bugs are a persistent source of vulnerabilities and crashes in C/C++ codebases.
By eliminating these at compile time, FerrousDB promises a more robust and secure database foundation.
This is critical for industries like finance, healthcare, and government, where data integrity and uptime are paramount.
Imagine a world where entire classes of critical database exploits simply cease to exist.
Second, **a new paradigm for database development**. The project demonstrates that complex, high-performance systems can be built with modern, safe languages without sacrificing control or efficiency.
This could inspire similar rewrites or new database projects in Rust, Go, or even other emerging languages, pushing the boundaries of what's considered "enterprise-grade." It also makes database development more accessible to a new generation of engineers fluent in Rust, potentially accelerating innovation.
Third, **potential for specialized deployments**. While general-purpose adoption will take time, FerrousDB could quickly find a niche in specific use cases.
Edge computing, for example, where resource constraints and security are critical, could greatly benefit from a lightweight, memory-safe Postgres.
Embedded systems requiring robust data persistence without the overhead of a full OS could also be prime candidates.
Cloud providers might also see an opportunity to offer a "Rust-powered Postgres" with stronger isolation guarantees and potentially lower operational costs due to fewer runtime errors.
The Long Road Ahead
Dr. Sharma concluded our conversation by reiterating the long-term vision. "We're not trying to replace Postgres overnight.
We're trying to build a future where the database, the most critical component of most applications, is fundamentally more resilient and performant.
This 100% test parity is just the first major signal that it's not only possible, but it's happening."
It’s a future I’m cautiously optimistic about. The shift from C to Rust in core infrastructure projects isn't just a trend; it's a pragmatic response to persistent, expensive problems.
FerrousDB is leading the charge for databases. Now, if only we could get people to write their AI prompts in Rust too, we might actually get some reliable output.
Have you ever considered the underlying language of your primary database, or has "it just works" always been enough?
Let's talk in the comments about whether memory safety truly justifies a ground-up rewrite.
---
**James Torres** — Systems programmer and AI skeptic. Writes about Rust, low-level computing, and ChatGPT.
