I have been playing with Turso lately, and it hits a sweet spot I did not know I wanted: the simplicity of SQLite with the convenience of a cloud database.

What is Turso?

Turso started life as libSQL, an open-contribution fork of SQLite. The project has since evolved into what they call “the next evolution of SQLite” — a ground-up rewrite in Rust that stays fully backwards compatible with SQLite while adding things the original never had:

  • Native vector search for AI and RAG applications
  • Async design built on modern primitives like Linux’s io_uring
  • Concurrent writes without locking conflicts
  • An open contribution model — unlike SQLite itself, which is open source but famously closed to outside contributions

There are two sides to the product:

  1. Turso Database — the embedded engine you run in your app, on-device, or even in the browser
  2. Turso Cloud — the managed platform with branching, backups, and analytics

Embedded replicas

This is the killer feature for me. An embedded replica keeps a local copy of your cloud database right next to your application:

  • Reads hit the local file and return in microseconds
  • Writes go to the cloud primary and are reflected back to the replica
  • You get read-your-writes semantics — after a successful write, your replica immediately sees the new data, no explicit sync() needed

Setup is essentially two parameters: a local url for the file and a syncUrl pointing at the remote database. You can sync periodically with syncInterval or call sync() manually on startup or in a background job.

It is the database equivalent of a CDN: your data lives at the edge, right inside your process, but there is still a single source of truth in the cloud.

Offline writes

By default writes require connectivity since they go to the primary. But you can flip on offline mode (offline: true) and write locally instead, syncing back to the cloud later. For mobile apps or anything that needs to work on flaky networks, this is exactly the local-first pattern everyone has been reinventing on top of SQLite by hand.

Caveats

  • Do not open the local database file with another process while it is actively syncing — you risk corruption.
  • Embedded replicas need a real filesystem, so they will not work in serverless environments without one.

Conclusion

SQLite has always been my favorite “just works” database, and Turso keeps that feel while quietly solving the two problems that always pushed me to Postgres: replication and backups. SDKs exist for TypeScript, Go, Rust, PHP, and more, so it slots into most stacks easily.

If you have ever thought “I wish I could just ship SQLite but with sync,” this is worth an afternoon of your time.