
Show Notes
SQLite is embedded everywhere - phones, browsers, IoT devices. It's reliable, battle-tested, and feature-rich. But what if you want concurrent writes? Or CDC for streaming changes? Or vector indexes for AI workloads? The SQLite codebase isn't accepting new contributors, and the test suite that makes it so reliable is proprietary. So how do you evolve an embedded database that's effectively frozen?
Glauber Costa spent a decade contributing to the Linux kernel at Red Hat, then helped build Scylla, a high-performance rewrite of Cassandra. Now he's applying those lessons to SQLite. After initially forking SQLite (which produced a working business but failed to attract contributors), his team is taking the bolder path: a complete rewrite in Rust called Turso. The project already has features SQLite lacks - vector search, CDC, browser-native async operation - and is using deterministic simulation testing (inspired by TigerBeetle) to match SQLite's legendary reliability without access to its test suite.
The conversation covers why rewrites attract contributors where forks don't, how the Linux kernel maintains quality with thousands of contributors, why Pekka's "pet project" jumped from 32 to 64 contributors in a month, and what it takes to build concurrent writes into an embedded database from scratch.
--
Support Developer Voices on Patreon: https://patreon.com/DeveloperVoices
Support Developer Voices on YouTube: https://www.youtube.com/@DeveloperVoices/join
Turso: https://turso.tech/
Turso GitHub: https://github.com/tursodatabase/turso
libSQL (SQLite fork): https://github.com/tursodatabase/libsql
SQLite: https://www.sqlite.org/
Rust: https://rust-lang.org/
ScyllaDB (Cassandra rewrite): https://www.scylladb.com/
Apache Cassandra: https://cassandra.apache.org/
DuckDB (analytical embedded database): https://duckdb.org/
MotherDuck (DuckDB cloud): https://motherduck.com/
dqlite (Canonical distributed SQLite): https://canonical.com/dqlite
TigerBeetle (deterministic simulation testing): https://tigerbeetle.com/
Redpanda (Kafka alternative): https://www.redpanda.com/
Linux Kernel: https://kernel.org/
Datadog: https://www.datadoghq.com/
Glauber Costa on X: https://x.com/glcst
Glauber Costa on GitHub: https://github.com/glommer
Kris on Bluesky: https://bsky.app/profile/krisajenkins.bsky.social
Kris on Mastodon: http://mastodon.social/@krisajenkins
Kris on LinkedIn: https://www.linkedin.com/in/krisjenkins/
--
0:00 Intro
3:16 Ten Years Contributing to the Linux Kernel
15:17 From Linux to Startups: OSv and Scylla
26:23 Lessons from Scylla: The Power of Ecosystem Compatibility
33:00 Why SQLite Needs More
37:41 Open Source But Not Open Contribution
48:04 Why a Rewrite Attracted Contributors When a Fork Didn't
57:22 How Deterministic Simulation Testing Works
1:06:17 70% of SQLite in Six Months
1:12:12 Features Beyond SQLite: Vector Search, CDC, and Browser Support
1:19:15 The Challenge of Adding Concurrent Writes
1:25:05 Building a Self-Sustaining Open Source Community
1:30:09 Where Does Turso Fit Against DuckDB?
1:41:00 Could Turso Compete with Postgres?
1:46:21 How Do You Avoid a Toxic Community Culture?
1:50:32 Outro
More from Developer Voices
How would you manage 30 million lines of PHP? You can't rewrite it - you'd be fired long before you delivered. That was the problem facing Facebook around 2011, and their answer was to add a type system, giving birth to the Hack language. But adding types to PHP turned out to be the easy part. The hard part was building a type checker that developers used to "edit, save, refresh" would actually tolerate. So how do you type-check tens of millions of lines of code fast enough that nobody notices?
Building something people actually want is supposed to be the happy ending. But it arrives with a bill attached: feature requests you didn't ask for, pull requests you'd rather not maintain forever, users demanding the one thing you swore you'd never build, and — if you're unlucky — a company where the sales team quietly starts deciding what engineering works on. DuckDB has spent the last two and a half years working through that list. So how do you stay a database engineering team when success keeps trying to turn you into something else?
My guest this week is James Brown, an engineering lead at Schroders, and that's a useful vantage point — asset managers carry all the regulation and organisational weight of a bank, mixed with the first-to-market pressure of a startup. James starts with his own "Claude mania": months of agents running around the clock, and the wave of anxiety that hit him one morning walking to the shop without one running at home. From there, Clair — the plugin he's building to give coding agents proximal awareness of each other, using git orphan branches as a zero-infrastructure message bus; why AI behaves like oxygen in a room full of tiny fires; what "going well" actually measures inside a regulated firm; and why he thinks team sizes won't change, even when the number of teams does.
There's a problem that's bugged the database industry since the 1980s: you run an expensive query over millions of rows, cache the result, and then a single new row arrives. Logically that's one small update, but most engines throw the cached answer away and recompute everything from scratch. Some will handle changes incrementally, but only for "simple" queries - and the rules for what counts as simple are arbitrary and brittle. So can you incrementally maintain *any* SQL query, no matter how complex? For decades the answer was no. Then an award-winning paper called DBSP proved that the answer is yes - all queries are simple enough.
AI is changing the way we all build software — that much seems clear. But the landscape is moving so fast that even the people paid to keep up are struggling. MCP or skills? Fine-tune or just prompt? LangChain or let a thousand agents loose? With almost 70 competing technologies and a shelf life of maybe six months on any advice, how do you figure out what's actually worth your time?