text stringlengths 0 2.68k |
|---|
**Jerod Santo:** Good stuff, Andrew. Thanks for coming on the show again. |
**Andrew Nesbitt:** Yeah, thanks so much for having me. |
• Glauber Costa and his team are rewriting SQLite in Rust with new twists and ideas, called Limbo |
• SQLite is considered the most widely-deployed database in the world, and is public domain, but not open source in the classical sense |
• The maintainers of SQLite do not take contributions from the public, and it's not designed for community-driven development |
• LibSQL was a previous effort to create a modified version of SQLite that addressed some of its limitations, but ultimately decided to fork it instead of rewriting it |
• The team decided to rewrite SQLite in Rust as Limbo, instead of continuing with the fork, after reconsidering the options |
• The unique public domain-ness and closed contribution policy of SQLite |
• Challenges of working with SQLite, particularly with large-scale changes |
• The decision to fork SQLite and create a new database, Limbo |
• Glauber Costa's clarification that the decision to fork was not a criticism of SQLite, but rather a choice to create a different project |
• The goal of replacing SQLite with Limbo |
• The history of LibSQL and its failure to replace SQLite, but its success as a business |
• The decision to rewrite Limbo and create a new, more modern database |
• The reaction to the new Limbo and the realization that it may not be enough to replace SQLite |
• The original SQLite fork, LibSQL, failed to gain traction and differentiate itself from the original SQLite. |
• The Limbo project, a new rewrite of SQLite, was announced and received an overwhelming positive response from the community, with 8,000 GitHub stars in a week. |
• The rewrite allowed the team to start with a clean slate and implement new ideas and features, whereas a fork would have been limited by the original codebase. |
• Deterministic simulation testing, a technique used by the TigerBeetle database, was adopted by the Limbo project to improve testing and debugging. |
• The combination of deterministic simulation testing and partnering with Antithesis to simulate complex system interactions has greatly improved the testing and debugging capabilities of the Limbo project. |
• The goal of the Limbo project is to eventually replace SQLite as the go-to database solution. |
• Deterministic simulation testing (DST) is a complex and time-consuming process that requires rewriting code to ensure determinism |
• Antithesis is a tool used in conjunction with DST to provide integration testing capabilities |
• DST is not easily boltable upon existing codebases and requires a significant rewrite |
• Limbo's goal is to be compatible with SQLite, with a focus on language, API, and file format compatibility |
• Limbo aims to provide fully asynchronous IO, which requires a different approach than SQLite |
• The simulator is used to generate random queries and test the system's behavior in a deterministic way |
• The team is testing bytecode compatibility with SQLite to ensure that the query plan is the same |
• The process of rewriting SQLite with DST is likened to unit testing, with the goal of gaining trust and confidence in the new system |
• SQLite limitations for complex queries and serverless environments |
• Limbo's async design and its benefits for complex queries and serverless environments |
• Turso Cloud and its features, including serverless SQLite on the cloud, partial storage, and browser support |
• The original intention to rewrite SQLite and the project's technical decisions |
• The unexpected success of the project and its implications for the company's strategy |
• Discussion of Limbo's unexpected success and subsequent decision to go all-in on the project |
• Reasons behind the contributions of two key engineers, including their desire for a more ambitious project and a seat at the table |
• Plans to replace the client-side part of LibSQL with Limbo and eventually rename Limbo to Turso |
• Ongoing development work, including replication, schema changes, write throughput, and analytical workloads |
• Timeline for completing these tasks, with a rough estimate of 9 months to a year |
• SQLite fork project timeline: 9-12 months |
• Project goals: make a stable and production-ready SQLite fork, called Limbo |
• Turso business changes: simplifying the platform, discontinuing certain features, and focusing on Limbo |
• Turso Cloud will remain a separate entity, offering serverless managed SQLite databases and other features |
• Consolidation of Turso and LibSQL brands into a single Turso brand |
• Limbo will replace SQLite as the default database in Turso Cloud and other products |
• Renaming client offering to Turso, with no change in open source strategy |
• Managing relationships between Turso, Turso Cloud, and third-party contributors |
• Separating server code from client code to maintain independence and avoid conflicts of interest |
• Open-sourcing client-side library and Turso, while keeping server-side code closed-source |
• Defining success metrics, including reaching 1 billion databases |
• Current state of the project, with some read functionality available |
• Future plans, including a new server implementation with deterministic simulation testing, and a focus on scalability and multi-tenancy |
• Turso Cloud to remain closed-source, with LibSQL as an open-source alternative for running databases |
• Open-sourcing Turso, the embedded database, to encourage community contribution and adoption |
• Implementing a database hosting model |
• Company's financial runway (15-20 months without additional funding) |
• Plans for future growth and scalability |
• Schedule for a follow-up conversation (January 22nd, 2026) |
**Jerod Santo:** So what would happen if you took SQLite, the most widely-deployed database in the entire world, and you rewrote it in Rust, with some new twists and new ideas? We are all going to find out because Glauber Costa and his team at Turso are working on it. It's called Limbo. Glauber, welcome to the Changelo... |
**Glauber Costa:** Thank you. It's great to be here. |
**Jerod Santo:** It's great to have Adam here, despite flu season hitting hard in the Stacoviak house... |
**Adam Stacoviak:** Oh, man... |
**Glauber Costa:** It sounds great, though. Adam, you sound great. |
**Adam Stacoviak:** Thank you! |
**Glauber Costa:** You'd mentioned you're on the tail end of the flu, but you don't sound like it. |
**Adam Stacoviak:** I've been trying so hard to sound better... So thank you. |
**Jerod Santo:** Where should we start? I think the story goes back quite a ways. I remember LibSQL, which was a couple of years ago now, your guys' effort to create a different open source SQLite. I thought SQLite was open source and public domain. Can you tell that story? |
**Glauber Costa:** Oh, happy to do that. And the story - in a sense, it's still the same story, so I think you hit the nail on the head there. It's just really how it started. I don't feel this is a completely different thing, what we're doing now. The story there is that we were using SQLite in our company. Pekka is m... |
SQLite is a public domain software, which is technically a difference that doesn't matter. I think only a lawyer would be concerned with what is the difference between public domain and open source. For all intents and purposes, it's the same difference between like the BSD license and the MIT license. It's minor. Nobo... |
So when people think of an open source project, there are two things that come to your mind. The first one is the code is open. And SQLite is that. But you also think about -- instinctively, "Well, the code is going to be on GitHub somehow, and then if I find an issue, I can go contribute to this project... And I have ... |
\[07:57\] And yes, I mean, I think it happened in the past that people managed to contribute to SQLite in very special occasions, but it's not a project that is designed to take contributions from other people. So that is how SQLite is. |
We started running into a couple of, hurdles with SQLite. Part of that is that we wanted to deploy our SQLite databases to the edge. We wanted to deploy it in a way that was replicated, we wanted to do things like read replicas, and we wanted to put it to run on call for workers, and all things like that. And we consid... |
Pekka is my co-founder. We've been working together for 15 years now. We met each other when we were both working on the Linux Kernel. Pekka was one of the maintainers. Each one of us worked in Linux for almost 10 years, the first five without knowing each other; I think we knew off each other, but we never met. And in... |
And we saw at the time a lot of people dancing around the subject. That's what we saw. So there were some projects like LightFS that were super-interesting projects. Dqlite... We saw lots of people trying to get SQLite to work as a distributed system. The problem that we saw with all of those projects is that they were... |
And I think the last piece of the puzzle, or maybe the two last pieces of the puzzle - number one is that we were very concerned with who's going to want to run our SQLite plus patches, because SQLite is a very trusted project... So you make random modifications to SQLite, and everybody starts distrusting what you're d... |
And the last piece of the puzzle is that at the time, we were actually discussing "How do we do this?" And one of the options was maybe we should just rewrite SQLite. And we had a lot of experience in our previous company, Scylla... Scylla was a re-implementation of Apache Cassandra and C++, fully compatible. And maybe... |
So at the time, our decision, after much deliberation was "We're not going to rewrite SQLite. We are going to fork it instead." The main advantage is that you have something tomorrow, because you start from a codebase that is already working. And then we're going to start making changes to that. |
\[11:59\] So that was LibSQL. LibSQL was essentially at the time -- and the story of Limbo, if I had to tell the sanitized version in which the fork never existed, it would be the same up until this point, because all of those things, all of that, it's still valid. It's just that at the time, a year and a half ago, we ... |
**Adam Stacoviak:** I think the public domain-ness of SQLite is unique. I think the not open to contribution is also quite unique. Very valid in the "open source world." And even, they say on this public domain page they have, where they say "Warranty of title." So if you are a company that needed something where you n... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.