Turso - SQLite-Compatible In-Process SQL Database

Turso Database is a rewrite of SQLite in Rust. The project’s own description is more ambitious than that sounds: “An in-process SQL database, compatible with SQLite, and now with a Postgres frontend too.” It is MIT licensed, and the stated architectural goal is to be “The LLVM of databases” — one storage engine, concurrency layer, compiler and VM, with multiple SQL dialects in front of it.

The strategic sentence to notice

Turso previously shipped libSQL, a fork of SQLite. The README now states that this Rust rewrite “replaces libSQL as our intended direction.”

That is the most consequential line in the repository, and it is easy to skim past. If you adopted libSQL, you are on the path the vendor has said is no longer where it is going — both are described as running in production, with libSQL “battle-tested for longer,” but only one is the future. Plan accordingly rather than discovering it later.

How compatible is “SQLite compatible”?

Specifically rather than vaguely, which is the only useful way to ask.

The project targets compatibility at three levels — SQL dialect, file format and C API — and tracks a named version: SQLite 3.50.4, documented in COMPAT.md. Existing SQLite files are reported to work as-is.

Then the honest qualifier, from the FAQ: “We are not at 100% yet, so some differences are still expected.”

That is the sentence to plan around. A rewrite that is 99% compatible is wonderful until your application depends on the other 1%, and you cannot know which pragma or edge case that is without testing your own queries. Reaching full SQLite compatibility is a stated requirement for 1.0, which also tells you it is not done.

What works today, and what does not

Shipped: SQLite compatibility, BEGIN CONCURRENT via MVCC, change data capture, async I/O on Linux through io_uring, bindings for Go, JavaScript, Java, .NET, Python, Rust and WebAssembly, cross-platform support including browsers, exact vector search, and improved schema management.

Explicitly experimental: Postgres compatibility (both dialect and wire protocol), encryption at rest, incremental computation via DBSP, full-text search via tantivy, and multi-process WAL coordination through a .tshm sidecar.

The split is informative. The parts that make it a better SQLite — concurrency, async I/O, CDC — are done. The parts that make it a different product are not. If the Postgres frontend is why you are interested, you are looking at an experiment.

Trying it

curl --proto '=https' --tlsv1.2 -LsSf \
  https://github.com/tursodatabase/turso/releases/latest/download/turso_cli-installer.sh | sh
tursodb

Language bindings are one command each — cargo add turso, npm i @tursodatabase/database, uv pip install pyturso, go get turso.tech/database/tursogo — and tursodb your_database.db --mcp exposes it as an MCP server, which is a neat touch for letting an agent query a local database directly.

If you use it from TypeScript, note that Drizzle ORM lists Turso among its supported backends, so the typed-query layer is already there.

The line in the FAQ that sets expectations

The project says Turso “powers production applications today at multiple organizations,” has “not yet reached 1.0,” and recommends that you “keep independent backups” until it does.

Read those three together. This is not pre-release software nobody runs; it is software whose authors are telling you to keep a second copy of your data. For a cache, a local-first app store or an embedded analytics file, that is an easy risk. For the only copy of something you cannot regenerate, take the advice literally.

Worth watching, and worth testing

The engineering case is genuinely interesting: SQLite’s design with modern concurrency and async I/O, in a memory-safe language, with the file format preserved so migration is a non-event. The BEGIN CONCURRENT support alone solves a real pain for anyone who has hit SQLite’s single-writer limit.

The honest recommendation is to test it against your own schema rather than trusting the compatibility claim, keep the backups the project asks for, and treat the Postgres frontend as a preview. If you are shopping for an embedded database today and want settled, PocketBase wraps plain SQLite with less to think about; if you want where this is heading, it is here.