Turso is an open-source rewrite of SQLite built in Rust, designed to be a fully backwards-compatible drop-in replacement that fixes SQLite's biggest pain points: no concurrent writes, blocking I/O, and zero native support for AI vector embeddings. In other words, it wants to be everything SQLite is — embedded, serverless, and blindingly fast — while also being everything SQLite isn't. That's either a brilliant idea or a catastrophically dumb one, and the jury is still deliberating.
Why Is SQLite Used on Every Device on Earth?
To understand why rewriting SQLite is such a massive bet, you have to understand just how dominant SQLite actually is. We're not talking billions of databases in the world — we're talking trillions. There is at least one SQLite database on every iPhone, every Android phone, every Mac, every Windows machine, every modern browser, and yes, every Mars rover currently rolling around on another planet.
0:45
The scale of SQLite: trillions of databases across every major platform including Mars rovers
Watch at 0:45 →
SQLite is the most deployed piece of software in human history, and the reason is almost embarrassingly simple: it has no server. There's no process to spin up, no port to configure, no credential to rotate, no overzealous web admin to manage. The entire database engine is a single C library that reads and writes to one file on disk. You drop it into your app, and it just works. That simplicity is its superpower — and also, eventually, its ceiling.
Who Created SQLite and Why Did He Build It?
The origin story of SQLite is genuinely one of the best in software. It's the year 2000. A developer named D. Richard Hipp is building damage control software for US Navy guided missile destroyers. His app relies on a SQL database, and every time the database server goes down, the whole app goes down with it. On a warship. During damage control. That's a problem.
1:15
D. Richard Hipp's origin story: building damage control software for Navy destroyers
Watch at 1:15 →
So Hipp asked a very reasonable question: why can't the database just live inside the application itself? Why does it need its own server, its own process, its own configuration? He couldn't find a good answer, so he built the solution himself. He named it SQLite, and then spent the next 25 years of his life maintaining it with a team of exactly three people. No outside contributions. No pull requests. Just three humans and an iron grip on quality. That's a huge part of why it's so trusted — and also why some people want to fork the entire thing and start over.
What Are the Biggest Limitations of SQLite?
SQLite's biggest limitations aren't bugs — they're design decisions that made perfect sense in 2000 and are starting to show their age in 2025. There are three that matter most:
- Single-writer concurrency: Only one writer can touch the database at a time. If two parts of your app try to write simultaneously, one of them waits. For many use cases this is fine. For high-throughput applications, it's a bottleneck.
- Blocking I/O: Every time SQLite touches the disk, it blocks the thread. Your entire application just... pauses. In the async-first world of modern development, that's increasingly painful to work around.
- No vector support: Every AI application needs somewhere to store and query embeddings. SQLite has no native vector types or indexing, which means you're duct-taping a separate vector database like Pinecone onto your stack and now managing two databases instead of one.
And because SQLite is maintained by just three people who don't accept outside contributions, if you have strong opinions about any of this, your options are limited. You can complain on the internet, or you can rewrite the whole thing yourself. Two engineers chose the latter.
What Is Turso and How Is It Different from SQLite?
Turso is what happens when two very serious engineers get tired of waiting. One of them wrote a book on latency. The other was personally ranked by Linus Torvalds as a top-five contributor to the Linux kernel. These are not people who write things on a whim.
2:30
Turso's three core improvements over SQLite: concurrent writes, async I/O, and native vector search
Watch at 2:30 →
Their core complaint wasn't that SQLite is bad software — it clearly isn't. The issue is that SQLite isn't truly open-source in the traditional sense. The source is available and permissively licensed, but the project is controlled by three people who don't accept external contributions. If you think it should do something differently, that's your problem, not theirs.
So they built Turso, a full rewrite of SQLite in Rust, and they addressed all three of the major limitations head-on:
- Concurrent writes: Multiple writers can work on different parts of the database simultaneously. They only conflict if they're actually touching the same rows — not the same table, not the same page, the same rows. SQLite has had something like this on a branch for nearly a decade but has never shipped it.
- Async I/O: Instead of blocking the thread every time it hits the disk, Turso hands control back to the caller. Your app can keep running while it waits. This is table stakes for modern development and Turso delivers it natively.
- Native vector search: This is the big one. Turso ships with native vector types and indexing built directly into the database engine. Your AI embeddings live in the same file as the rest of your data, and you query them with plain SQL you already know.
Does Turso Support Vector Search for AI Apps?
Yes, and it's arguably the most forward-looking feature in the whole project. The pattern Hipp used to build SQLite — take something that normally needs its own server and cram it into a library small enough to run anywhere — is exactly what Turso is doing with vector search.
Right now, if you're building an AI app, you store your embeddings in something like Pinecone or Weaviate. That's a separate service, a separate bill, a separate failure point, and a separate set of APIs to learn. Turso's pitch is: why not just keep them in the same database as everything else? Native vector indexing means you can run semantic similarity queries right alongside your relational queries, without leaving SQL and without spinning up another service. It's the embedded database philosophy applied to the AI era.
How Does Turso Test for Data Safety?
The hardest part of replacing SQLite isn't adding features — it's earning 25 years of trust in a much shorter time. SQLite is famous for never losing data. Turso has to match that reputation before anyone serious will switch.
Their answer is a technique called deterministic simulation testing. Instead of just running the database and hoping for the best, Turso runs the entire engine inside a simulated environment where the developers control time, the network, and the disk. They then inject specific failures: a power loss mid-write, a corrupted database page, a disk that lies about whether it actually saved your data. Then they replay the exact same scenario from the same random seed, over and over, until they find and fix every bug.
It's the kind of testing that would be overkill for most software. For a database that's trying to earn the trust of trillions of deployments, it's the minimum viable approach.
Is Rewriting SQLite in Rust Actually a Good Idea?
Honestly? Probably not, in the statistical sense. Most rewrites fail. Most ambitious open-source projects stall. And SQLite is not some forgotten legacy codebase — it's actively maintained by people who are very good at what they do.
But Turso isn't trying to replace SQLite everywhere overnight. It's trying to be a better SQLite for the use cases where SQLite's limitations actually hurt: high-concurrency applications, async runtimes, and AI-native apps that need vector search without the extra infrastructure. That's a real and growing market.
The team has the credentials, the testing discipline, and the open-source community that SQLite deliberately avoids. They're already fully backwards compatible, which means the switching cost is close to zero for anyone who wants to try it. You're only viewed as an idiot until it works — and Turso is starting to work.
