Skip to content
Engineering

Turso and libSQL: What They Add to SQLite, and Embedded Replicas vs Turso Sync

AIDToolStack EditorialNovember 7, 20267 min read
sqlitelibsqltursoedgedatabases
Share:Twitter

"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

NameWhat it isStatus as of November 2026
libSQLMIT-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 DatabaseA rewrite of SQLite in Rust, in-process, SQLite-compatibleLatest 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 CloudThe hosted service that runs either engineBeing 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 read from a local file and send writes to the Turso Cloud primary; Turso Sync reads and writes locally and pushes or pulls changes
Embedded replicas read from a local file and send writes to the Turso Cloud primary; Turso Sync reads and writes locally and pushes or pulls changes

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:

  1. "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.db with the sqlite3 CLI.
  2. Serverless platforms without a writable filesystem can't use embedded replicas at all.
  3. 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."

SituationWhat 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.
AE

Written by AIDToolStack Editorial

Researched from official documentation, specifications and vendor pages, listed under Sources below. Last checked November 2026.

Sources

  1. docs.turso.tech/features/data-edge
  2. turso.tech/blog/turso-is-joining-supabase
  3. github.com/tursodatabase/libsql
  4. github.com/tursodatabase/turso
  5. github.com/tursodatabase/turso/releases
  6. docs.turso.tech/libsql
  7. docs.turso.tech/features/ai-and-embeddings
  8. docs.turso.tech/features/embedded-replicas/introduction
  9. docs.turso.tech/sync/usage
  10. www.npmjs.com/package/@libsql/client
  11. turso.tech/pricing
  12. github.com/tursodatabase/turso-mcp

Related Posts

Explore on AIDToolStack

Discover tools and servers featured in our directory.

MCP Servers

Trigger.dev Jobs MCP ServerManage Trigger.dev background jobs from your AI coding assistant. Monitor job runs, trigger tasks manually, inspect execution logs, manage schedules, and debug failed runs. The server provides operational visibility into your background job infrastructure — see which tasks are running, queued, or failed, and take action. Your AI can help diagnose job failures from execution logs, retry failed tasks, and optimize concurrency configurations for better throughput.Tailscale Network MCP ServerManage your Tailscale mesh VPN network from your AI coding assistant. View connected devices, manage ACLs, configure exit nodes, check device status, and manage DNS settings. The server provides visibility into your Tailscale network — see which machines are online, troubleshoot connectivity issues, manage network access policies, and configure routes. Useful for developers managing distributed infrastructure where Tailscale provides secure networking between services.Portainer Docker MCP ServerManage Docker environments through Portainer's API from your AI coding assistant. Control containers, images, networks, and volumes across multiple Docker hosts and Kubernetes clusters. The server provides tools for container lifecycle management, image pulling and building, stack deployment, and resource monitoring. Portainer's multi-environment management makes this server particularly valuable for teams managing containers across development, staging, and production environments.

Reviews

Sign in to leave a review.

No reviews yet. Be the first!

Comments

Sign in to leave a comment.

No comments yet. Be the first!

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.

Growing subscriber baseHigh open rates

All sponsored content is clearly labeled per our editorial policy.