Turso and libSQL: What They Add to SQLite, and Embedded Replicas vs Turso Sync
"Edge database" used to mean something specific at Turso: copies of your SQLite database running in dozens of regions, close to wherever your serverless function woke up. That's not the product any more. The edge replicas page now says the feature "is now deprecated for all new users", with existing users allowed to keep their Edge Replicas on Fly. What replaced it is more interesting: the replica moves into your app process, as a local file.
And the company itself changed hands. On 2 October 2026 Turso announced it is being acquired by Supabase. The post says Turso Cloud "keeps running", existing databases and APIs continue as they are, and "Turso Database remains open source and actively developed." It gives no pricing changes and no migration deadline. That's all we know as of November 2026, so I'd treat it as a reason to keep an eye on the changelog, not a reason to migrate.
This post sorts out the three things people mean by "Turso" today, what each adds over plain SQLite, and how the two sync models actually move your data. If you haven't decided whether SQLite fits your app in the first place, start with our SQLite in production post, which covers WAL, write concurrency and Litestream.
Three names, three things
| Name | What it is | Status as of November 2026 |
|---|---|---|
| libSQL | MIT-licensed fork of SQLite, plus a server (sqld) and client SDKs such as @libsql/client | "actively maintained, but new features are being developed in Turso" (README) |
| Turso Database | A rewrite of SQLite in Rust, in-process, SQLite-compatible | Latest stable release v0.8.3 (12 October 2026), with v0.9.0 pre-releases out; the README says it "replaces libSQL as our intended direction" and hasn't reached 1.0 (repo) |
| Turso Cloud | The hosted service that runs either engine | Being acquired by Supabase; edge replicas deprecated for new users |
Turso's libSQL docs page gives its own rule of thumb: Turso Database for new projects, libSQL "for mission-critical workloads that need a battle-tested foundation today." The two READMEs don't quite agree on how mature the rewrite is (the libSQL README still calls it "currently in beta"), so I'd read "production-ready" generously and test your own workload.
What libSQL adds over SQLite
libSQL exists because, in Turso's words, SQLite is "open-source but not open-contribution." The fork keeps the file format and API and adds things SQLite's maintainers wouldn't take. The ones you'll actually use:
- Embedded replicas, covered below.
- A network server, so a SQLite-compatible database can be reached over HTTP or WebSockets like Postgres.
- ALTER TABLE ... ALTER COLUMN, for changing a column's type and constraints in place.
- RANDOM ROWID tables.
- Native vector search, with no extension to load.
I ran these against a local file with @libsql/client 0.18.0 (the bundled engine reports sqlite_version() as 3.45.1). The same statements fail with a syntax error in the stock sqlite3 3.51.0 CLI, which is the point:
import { createClient } from "@libsql/client";
const db = createClient({ url: "file:local.db", intMode: "bigint" });
await db.execute("create table notes (id integer primary key, title text, score text)");
await db.execute("alter table notes alter column score to score integer not null default 0");
// schema is now: score integer not null default 0
await db.execute("create table events (msg text) random rowid");
await db.execute("insert into events values ('a'), ('b')");
const { rows } = await db.execute("select rowid, msg from events");
// rowids like 3056322426787310566 and 4049068015358889792
Note the intMode: "bigint". Without it, that last query threw Received integer which cannot be safely represented as a JavaScript number. Random rowids are 64-bit, and the client's default "number" mode can't hold anything past 2^53 - 1, as its own type definitions warn. If you use random rowids from JavaScript, set intMode to "bigint" or "string" from day one.
Vector search is the other headline feature. The AI and embeddings docs describe vector column types such as F32_BLOB(n), conversion functions like vector32(), cosine and L2 distance functions, and an approximate index based on DiskANN:
create table docs (id integer primary key, body text, embedding F32_BLOB(3));
insert into docs (body, embedding) values
('cat', vector32('[0.1, 0.9, 0.0]')),
('car', vector32('[0.9, 0.1, 0.2]'));
create index docs_idx on docs (libsql_vector_idx(embedding));
select d.body
from vector_top_k('docs_idx', vector32('[0.15, 0.85, 0.0]'), 1) as v
join docs d on d.rowid = v.id;
-- cat
That ran as shown. The docs warn the index "may return slightly suboptimal neighbors" on large tables, which is the normal trade for approximate search, and that it needs a rowid table or a single-column primary key. Keeping vectors next to your app data at all is a bigger question; our vector database guide covers when a dedicated store earns its place.
Embedded replicas vs Turso Sync
This is the part that replaced "edge." Both models put a SQLite file next to your code so reads never leave the process. They differ in where writes go.
Embedded replicas (libSQL)
You point url at a local file and syncUrl at the cloud database (docs):
import { createClient } from "@libsql/client";
const db = createClient({
url: "file:replica.db",
syncUrl: process.env.TURSO_DATABASE_URL,
authToken: process.env.TURSO_AUTH_TOKEN,
syncInterval: 60, // seconds, per the client's type definitions
});
await db.sync(); // pull now, e.g. at startup
Reads hit the file. Writes go to the remote primary by default, and the replica that wrote sees its own write immediately; other replicas see it after their next sync. You can opt into local writes with offline: true.
The docs list three gotchas you should read before deploying this:
- "Do not open the local database while the embedded replica is syncing. This can lead to data corruption." So no second process poking at
replica.dbwith thesqlite3CLI. - Serverless platforms without a writable filesystem can't use embedded replicas at all.
- Sync works in 4 kB frames, so a one-byte write still costs a 4 kB frame, and things like page splits can make a sync move more data than you'd expect.
One small trap of my own finding: the client's type definition says syncInterval is in seconds, but the @libsql/client README quickstart passes syncInterval: 60000 with a comment saying it syncs every minute. Going by the type definition, that would be every 16 hours or so. Trust the types, and check your sync actually runs.
Turso Sync (Turso Database)
The embedded replicas page now says, "For new projects that need sync, we recommend" Turso Sync. It's built on the Rust engine and flips the model: reads and writes happen locally, and you decide when to exchange changes (usage docs):
import { connect } from "@tursodatabase/sync";
const db = await connect({
path: "./app.db",
url: process.env.TURSO_DATABASE_URL,
authToken: process.env.TURSO_AUTH_TOKEN,
});
// ...local reads and writes...
await db.push(); // send local changes
const changed = await db.pull(); // true if anything new arrived
The docs describe push() as sending local changes as logical statements, with conflicts resolved as "last push wins." That's fine for a single user's notes app and wrong for an inventory count, so be clear which one you're building. Two more details from the same page: on first run the database bootstraps from the remote, so the cloud must be reachable during that first connect, and checkpoint() compacts the local WAL when it grows.
Which driver for which runtime
There's a third JavaScript package worth knowing. The @libsql/client README now points serverless users to @tursodatabase/serverless, "the lightest option with zero native dependencies", which it says "will be the driver to later support concurrent writes", while recommending @libsql/client "if you need a battle-tested driver today with ORM integration."
| Situation | What I'd use |
|---|---|
| Long-running server with a disk, read-heavy | @libsql/client with an embedded replica |
| Serverless or edge function, no filesystem | @tursodatabase/serverless or @libsql/client over HTTP, no local file |
| Desktop, mobile or offline-first app | @tursodatabase/sync with push and pull |
| Prisma or Drizzle today | @libsql/client, since that's where ORM adapters exist (Prisma vs Drizzle) |
If "edge" in your architecture means edge functions, our edge functions post is a useful sanity check: a database call from an edge function to a single-region primary can be slower than doing the work in one region next to the data.
Pricing, briefly
From the pricing page as of November 2026: the Free plan includes 100 databases, 5 GB of storage, 500 million rows read and 10 million rows written a month, plus 3 GB of sync bandwidth. The Developer plan is listed at $4.99 a month. The page also says idle databases only cost storage, which is what makes the "one database per user or per agent" design affordable. Prices may change after the Supabase deal closes, so check before you commit.
Before you pick it
- Do you need writes from more than one place? Embedded replicas still send them to one primary. Turso Sync makes them local but resolves conflicts with last push wins.
- Can your runtime keep a file on disk between requests? If not, embedded replicas are off the table.
- Do you read integers from random rowids or 64-bit IDs in JavaScript? Set
intMode. - Are you relying on a feature the Rust engine marks experimental (its README lists Postgres compatibility, encryption at rest and full-text search that way)? Treat it as a preview.
- Want an assistant to manage it? The Turso MCP server works with Turso Cloud only, not local libSQL files, and consent happens on the Turso dashboard, where you scope its token to an organisation or group.
Written by AIDToolStack Editorial
Researched from official documentation, specifications and vendor pages, listed under Sources below. Last checked November 2026.
Sources
- docs.turso.tech/features/data-edge
- turso.tech/blog/turso-is-joining-supabase
- github.com/tursodatabase/libsql
- github.com/tursodatabase/turso
- github.com/tursodatabase/turso/releases
- docs.turso.tech/libsql
- docs.turso.tech/features/ai-and-embeddings
- docs.turso.tech/features/embedded-replicas/introduction
- docs.turso.tech/sync/usage
- www.npmjs.com/package/@libsql/client
- turso.tech/pricing
- github.com/tursodatabase/turso-mcp
Related Posts
Explore on AIDToolStack
Discover tools and servers featured in our directory.
AI Tools
MCP Servers
Sponsor Our Newsletter
Reach thousands of developers who are actively evaluating AI tools, MCP servers, and dev infrastructure. Our weekly newsletter goes to engaged technical decision-makers.
All sponsored content is clearly labeled per our editorial policy.