Cloud Parts

Turso

A from-scratch Rust rewrite of SQLite with concurrent writes, plus libSQL (an open-contribution SQLite fork) and Turso Cloud, which hosts many small databases on S3.

What it is
Relational databases
Type
Open source
Made by
Turso (acquisition by Supabase announced October 2026)
License
MIT (Turso Database and libSQL); Turso Cloud is a proprietary hosted service
Facts checked
6 October 2026
Website Source code

What it is

Turso is three things from one company. libSQL (2022) is an MIT-licensed fork of SQLite that accepts outside contributions, which SQLite itself doesn’t, and adds a server for remote access and “embedded replicas”. Turso Database, announced in December 2024 under the codename Limbo, is a new implementation of SQLite in Rust: an in-process library, like SQLite, that reads and writes the same file format, speaks the same SQL dialect and offers the same C API, so existing SQLite files open as they are. Turso Cloud is the hosted service. The company now develops the Rust engine and keeps libSQL maintained, but recommends the rewrite for new projects.

The main thing the rewrite changes is writing. SQLite lets one writer commit at a time per file; a second writer gets database is locked. In Turso’s MVCC journal mode, BEGIN CONCURRENT transactions each read a snapshot and write new versions of rows, tracked in an in-memory index, instead of taking a lock. At commit Turso checks for conflicts row by row: transactions that touched different rows all commit, and one that changed a row another transaction changed first fails with SQLITE_BUSY and must be retried. In the company’s own benchmark for version 0.8 (September 2026), 64 connections committed about 9,500 transactions per second, against about 1,370 for SQLite. The engine also uses asynchronous I/O (io_uring on Linux), runs in browsers through WebAssembly, and has an experimental Postgres front end that speaks the Postgres dialect and wire protocol.

Turso Cloud gives each user unlimited databases, queried over HTTP or synced into an application. Each database is split into 128 kB segments stored durably in S3; the server’s local disk is only a cache. A write is acknowledged once the newest write-ahead log has reached S3 Express, which takes single-digit milliseconds. Embedded replicas keep a local copy of a cloud database: reads come from the local file in microseconds, while writes go to the cloud primary and are synced back. The newer Turso Sync, built on the Rust engine, adds local-first writes with explicit push() and pull().

Why teams pick it

  • Drop-in for SQLite at the file and SQL level, still embedded in the process with no server to run
  • Concurrent writers with row-level conflict detection, past SQLite’s one-writer-per-file limit
  • MIT licence and an open contribution model, tested with deterministic simulation and Antithesis
  • Cheap per-tenant or per-agent databases in the cloud, durable on S3, with local replicas for microsecond reads

Watch out for

  • Pre-1.0 and still moving: compatibility isn’t 100% yet (the project tracks gaps in COMPAT.md), several features are experimental, and the manual still marks the MVCC journal mode as not production-ready in one place while calling it supported in another
  • Concurrent transactions that change the same row fail at commit, so applications need retry logic; multi-process access to one file is still experimental
  • The product has changed course often: edge replicas ended for new users in 2025, the original libSQL SDKs gave way to Turso-native ones, and the company announced its sale to Supabase in October 2026
  • libSQL keeps SQLite’s single-writer model, and the published speed-ups of the rewrite are the vendor’s own benchmarks on one desktop machine

Alternatives

What all relational databases have in common →
Alibaba Cloud PolarDBCommercialAlibaba Cloud’s cloud-native relational databases: MySQL- and PostgreSQL-compatible clusters whose compute nodes share one copy of the data on distributed storage, plus PolarDB-X, a distributed MySQL-compatible edition.CedarDBCommercialA PostgreSQL-compatible database rebuilt from scratch at TU Munich, running transactions and analytics on one copy of the data on a single server.Cloudflare D1CommercialCloudflare’s serverless SQL database that speaks SQLite, runs each database inside a Durable Object, and bills by rows read and written rather than by the hour.CloudNativePGOpen sourceA Kubernetes operator that runs highly available PostgreSQL with no Patroni and no StatefulSets: the Kubernetes API itself holds the cluster’s state.CockroachDBCommercialA distributed SQL database that speaks the PostgreSQL wire protocol, replicates every slice of data with Raft and keeps transactions serializable across nodes and regions.MySQLOpen sourceThe long-standing open-source SQL database behind much of the web, built on the InnoDB engine.NeonCommercialServerless Postgres that keeps data in a shared storage layer, so compute can scale to zero and a branch of the database is a pointer, not a copy.PatroniOpen sourceA Python agent beside each Postgres server that elects one primary through etcd, Consul, ZooKeeper or Kubernetes, and fails over when it dies.Percona OperatorsOpen sourceFour free Kubernetes operators from Percona that run its builds of MySQL, PostgreSQL and MongoDB, each using the engine’s own replication and backup tools.PGO (Crunchy Postgres for Kubernetes)Open sourceCrunchy Data’s Postgres operator: Patroni in every pod for failover, pgBackRest for backups, and a declarative `PostgresCluster` resource on top.PlanetScaleCommercialManaged MySQL on Vitess and managed Postgres, with schema changes shipped through branches and deploy requests.PostgreSQLOpen sourceThe open-source relational database that most new projects start on, extensible enough to grow into many niches.ScramDBCommercialA brand-new, closed-source database that speaks the PostgreSQL protocol and promises transactions, analytics and vector search on one copy of the data; first builds shipped in summer 2026.SQLiteOpen sourceA complete SQL database in a library and a single file, with no server to run.VitessOpen sourceA proxy layer, born at YouTube, that shards MySQL across many servers while the app still sees one database.

How it fits with other technologies

Concurrent writers on a SQLite-format file, in the `tursodb app.db` shell · sql

PRAGMA journal_mode = mvcc;   -- switch from WAL to multi-version concurrency

CREATE TABLE events (id INTEGER PRIMARY KEY, kind TEXT NOT NULL);

-- run on several connections at once: none of them waits for a lock
BEGIN CONCURRENT;
INSERT INTO events (kind) VALUES ('signup');
COMMIT;   -- SQLITE_BUSY only if another transaction changed the same row: retry

See it in a real stack

No architecture uses Turso yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2022–2026

SQLite is public domain, but it is open source without being open contribution: to keep it in the public domain and free of proprietary code, the project doesn’t accept patches from “random people on the internet”. In 2022 Glauber Costa and his cofounder Pekka Enberg forked it as libSQL, under the MIT licence, and invited the community to build it with them. To fund the work they launched a cloud service, announced in January 2023 as ChiselStrike Turso, which promised to bring “a SQLite-compatible embedded database to the edge”. Embedded replicas, local copies of a cloud database inside the application, followed that September.

libSQL gathered more than 13,000 GitHub stars, but by the founders’ own account few people used it as a SQLite replacement; most came for SQLite over the network, and deep contributions to the core were rare. Meanwhile Enberg had quietly started rewriting SQLite in Rust in his personal GitHub account. Turso announced the experiment as Limbo in December 2024, it passed 8,000 stars within a week, and in January 2025 the company went “all-in”: it renamed the rewrite Turso, stopped offering edge replicas (geographic copies) to new users because 70% of users had never created one, and began moving its cloud to AWS.

The rewrite reached its first alpha in July 2025 and a beta in October 2025, which added browser support, sync, encryption, concurrent writes and live materialized views. In 2026 the company pitched it for AI agents that each need their own small database, opened concurrent writes on Turso Cloud as an early preview in August, and released version 0.8 in September. On October 2, 2026 it announced that Supabase is acquiring it, saying the platform keeps running and Turso Database stays open source.

Why it’s built this way

Fork first, rewrite later
A fork was the fastest way to ship features such as replication and vector search on SQLite’s proven code. But invasive changes, such as the vector-search syntax they wanted or asynchronous I/O, were hard to make in a fork that tracks SQLite, which is what pushed the team to try a clean rewrite.
Rust plus deterministic simulation testing
SQLite’s reputation rests on its reliability, so a rewrite had to match it. Rust brings memory safety, and building deterministic simulation into the engine from the start, plus Antithesis’s deterministic hypervisor, is meant to catch even the most obscure edge cases.
Row-level MVCC instead of SQLite’s page-level approach
SQLite’s experimental BEGIN CONCURRENT branch, never merged, detects conflicts per page, so writers updating unrelated rows on the same B-tree page still collide. Turso kept the syntax but tracks row versions, so only true row conflicts abort.
Keep cloud data in S3, with local disk as a cache
Splitting each database into segments in object storage, and fetching only what is hot, lets one server host huge numbers of small databases cheaply, which is what per-user and per-agent databases need.

Timeline

  1. 2022

    libSQL, an open-contribution fork of SQLite, created under the MIT licence

  2. 2023

    ChiselStrike Turso announced in January; public beta in April; embedded replicas in September

  3. 2024

    Limbo, a rewrite of SQLite in Rust, announced December 10

  4. 2025

    Rewrite renamed Turso in January; edge replicas end for new users; alpha in July, beta in October

  5. 2026

    Concurrent writes preview on Turso Cloud (Aug); version 0.8 (Sep); Supabase acquisition announced (Oct)

Sources14 · facts checked 6 October 2026

Improve this page on GitHub