We're building Postgres in Rust. Using the LLVM of databasesRegister now for early access to concurrent writes in the Turso Cloud. Join the waitlist
Jul 16, 2026
We're building Postgres in Rust. Using the LLVM of databases<br>We are writing a modern, from-scratch version of Postgres in Rust, on top of Turso. Here is the architecture, what works today, and where we are headed.<br>Glauber Costa
Pekka Enberg
Today we are announcing the beginning of a new and exciting journey: we will write a modern version of Postgres, in Turso (which is itself written in Rust). Some of you reading this phrase will think it makes absolutely no sense: what does it even mean to write Postgres in Turso? Are you drunk? (the answer in the case of Pekka is likely yes, but that is irrelevant). This will make sense soon.
Not to bury the lede, here’s the short version: Turso is becoming the LLVM of databases. One modern, reliable core; many database frontends compiled down onto it. SQLite was the first frontend. Postgres is next. Others will follow.
But the end game is clear: we want a new database, compatible with Postgres, written from the ground up with a modern architecture (not using processes for connections, able to be run embedded in the browser, as a file, with self-updating materialized views, etc). And we want you to build this with us, in the best possible spirit of Open Source. We have done this successfully many times, and we are confident we can do it again.
What we are announcing today is the first step. That step already goes quite far. In this post we will explain the architecture, what works today, the current limitations, and what we believe the future will look like.
#What is was Turso ?
Some of you may be familiar with Turso: Turso is, or was until recently, exclusively a full rewrite of SQLite in Rust using a modern architecture. It is file-compatible with SQLite, meaning it can open and generate SQLite files. But it has a couple of very interesting features: It supports concurrent writes using MVCC (like Postgres), it has a rich type system (like Postgres), it has support for Materialized Views (unlike Postgres, those views actually auto-update!), it is fully asynchronous, meaning it runs natively very well on browsers and other challenging environments, and the list goes on.
Let’s pause on that materialized views one, because we said it too casually. It works now, and it showcases exactly how we aim to be much more than just a 1:1 translation of Postgres to Rust. If you have ever babysat a REFRESH MATERIALIZED VIEW cron job, or faked live views with a pile of triggers, read that sentence again: our views update themselves, live. This is the feature Postgres users have quietly wanted for twenty years.
Turso is also written with extreme reliability in mind: it is tested using a Deterministic Simulation Testing suite, Antithesis testing, Oracle testing, Fuzzying, and Formal methods. One of the features of SQLite that we love the most is how rock solid it is, and we wouldn’t be able to do it justice if we didn’t replicate that one feature! Yes, reliability is a feature.
More importantly, Turso is an Open Contribution project: we have over 260 contributors today, with an extremely healthy Open Source community. AI hasn’t changed our stance on Open Source a bit. In fact we have doubled down: we welcome AI contributions, as long as they are *good* contributions. We, the creators of Turso, spent the first 10 years of our careers working in the Linux Kernel. And we have then spent the rest of our time trying to replicate that same environment elsewhere: a place where code speaks, the bar is high, and you can - through grit and work - have a seat at the table, and help shape the *direction* of the project (not just fix things here and there). Turso is already such a place, with a large body of work coming from total strangers (which often become good friends!), albeit at a smaller scale than Linux (at least for now)
#The truth about SQLite
SQLite is, very deservedly, a piece of technology that users love to love. I fell in love with it over 20 years ago, and I am proud to have built so much on it. But there are lots of things about SQLite that, in our experience, people just don’t know. For example: SQLite doesn’t accept external contributions, and its legendary test suite is proprietary.
Another thing many don’t know is that in a sense, if you squint, SQLite is not really a database: SQLite is a Virtual Machine. Yes, you have heard this right: SQLite (and we also adopted this design in Turso), has a very unique design: it compiles SQL (in the SQLite dialect) to its own bytecode language, called the VDBE. That is not a general purpose language, like you would get from the JVM, .NET or WASM: it is a database-specific language with higher level operations like “find something in a B-tree”, but it is a bytecode language nevertheless.
It works more or less like this:
This is really an implementation detail, and...