# Key Differences Between Turso and libSQL: Architecture and Features Explained

> Explore the key differences between Turso and libSQL. Discover Turso's modern Rust architecture with async I/O and vector search versus libSQL's SQLite fork.

- Repository: [Turso Database/turso](https://github.com/tursodatabase/turso)
- Tags: deep-dive
- Published: 2026-06-22

---

**Turso represents a ground-up Rust rewrite of SQLite featuring native async I/O, MVCC concurrency, and integrated vector search, whereas libSQL remains a C/C++ fork preserving SQLite's original synchronous architecture.**

While both projects aim to evolve SQLite beyond its traditional constraints, the `tursodatabase/turso` repository reveals fundamentally different implementation strategies. Turso abandons the C codebase entirely in favor of Rust's memory safety and modern async capabilities, while libSQL maintains compatibility through incremental C-based modifications. These architectural divergences impact everything from concurrency models to extension mechanisms.

## Core Architectural Philosophy

### Ground-Up Rust Rewrite vs. C Code Preservation

**Turso** implements a complete Rust rewrite of SQLite, abandoning the original C code base to enable safe memory handling and easier extensibility. The core bytecode interpreter resides in [[`core/vdbe/execute.rs`](https://github.com/tursodatabase/turso/blob/main/core/vdbe/execute.rs)](https://github.com/tursodatabase/turso/blob/main/core/vdbe/execute.rs), while the SQL parser lives in [[`parser/src/parser.rs`](https://github.com/tursodatabase/turso/blob/main/parser/src/parser.rs)](https://github.com/tursodatabase/turso/blob/main/parser/src/parser.rs), both written in idiomatic Rust.

**libSQL** functions as a **C/C++ fork** of the original SQLite source, preserving the traditional `src/` directory structure and C implementation patterns. This approach maintains full compatibility with the SQLite C API but inherits the limitations of C's memory management and synchronous design patterns.

### Memory Safety and Extensibility

Turso leverages Rust's ownership model to eliminate entire classes of memory safety vulnerabilities present in C-based implementations. The extension system in [`extensions/core/`](https://github.com/tursodatabase/turso/blob/main/extensions/core/) enables native Rust extensions—such as the vector search implementation in [[`extensions/vector/src/lib.rs`](https://github.com/tursodatabase/turso/blob/main/extensions/vector/src/lib.rs)](https://github.com/tursodatabase/turso/blob/main/extensions/vector/src/lib.rs)—compiled directly into the database engine.

libSQL extensions follow SQLite's traditional loadable C module pattern, requiring separate compilation and manual memory management.

## I/O and Concurrency Models

### Native Async I/O with io_uring

Turso implements **true asynchronous file operations** using **io_uring** on Linux, encapsulated in [[`sync/engine/src/io_operations.rs`](https://github.com/tursodatabase/turso/blob/main/sync/engine/src/io_operations.rs)](https://github.com/tursodatabase/turso/blob/main/sync/engine/src/io_operations.rs). This enables non-blocking database operations that integrate seamlessly with modern async runtimes.

libSQL relies on SQLite's **synchronous blocking I/O** model. While external language bindings can wrap libSQL in async interfaces, the underlying file operations remain blocking—creating potential bottlenecks for high-concurrency applications.

### MVCC and BEGIN CONCURRENT Support

Turso implements a custom **Multi-Version Concurrency Control (MVCC)** engine enabling the **`BEGIN CONCURRENT`** transaction mode. The MVCC implementation spans [`sync/engine/`](https://github.com/tursodatabase/turso/blob/main/sync/engine/) and [`sync/sdk-kit/`](https://github.com/tursodatabase/turso/blob/main/sync/sdk-kit/), handling concurrent writes via versioned pages as seen in [`database_sync_lazy_storage.rs`](https://github.com/tursodatabase/turso/blob/main/database_sync_lazy_storage.rs) and WAL session management in [[`sync/engine/src/wal_session.rs`](https://github.com/tursodatabase/turso/blob/main/sync/engine/src/wal_session.rs)](https://github.com/tursodatabase/turso/blob/main/sync/engine/src/wal_session.rs).

libSQL utilizes SQLite's traditional **locking and journal model**, requiring writers to obtain exclusive locks on database pages. This creates serialization points that Turso's MVCC architecture avoids.

## Feature Set and Extensions

### Integrated Vector Search and Full-Text Search

Turso provides **first-class vector search** (approximate nearest-neighbor) and **tantivy-based full-text search** as built-in extensions. The vector extension in [[`extensions/vector/src/lib.rs`](https://github.com/tursodatabase/turso/blob/main/extensions/vector/src/lib.rs)](https://github.com/tursodatabase/turso/blob/main/extensions/vector/src/lib.rs) demonstrates native integration with the Rust core.

libSQL offers full-text search through separate extension modules and lacks native vector search capabilities in the core distribution.

### Experimental Capabilities

According to the repository's [[`README.md`](https://github.com/tursodatabase/turso/blob/main/README.md)](https://github.com/tursodatabase/turso/blob/main/README.md), Turso actively develops **encryption-at-rest**, incremental computation (DBSP), change data capture (CDC), and multi-process WAL coordination. These features leverage Rust's ecosystem for cryptographic libraries and async coordination primitives.

## API Compatibility and Language Bindings

### C API Coverage

Turso implements a **partial SQLite C API** (e.g., `sqlite3_open`, `sqlite3_prepare_v2`, `sqlite3_step`), with specific compatibility details tracked in [[`COMPAT.md`](https://github.com/tursodatabase/turso/blob/main/COMPAT.md)](https://github.com/tursodatabase/turso/blob/main/COMPAT.md). This deliberate subset enables modernization while breaking legacy compatibility where necessary.

libSQL maintains **full SQLite C API compatibility** by default, acting as a drop-in replacement for existing SQLite deployments.

### Multi-Language Support

Turso provides **multi-language bindings** (Rust, Go, JavaScript, Java, .NET, Python, WASM) built on a common Rust core, ensuring consistent API behavior across languages. libSQL bindings generate from the C code base and often lag behind core changes, with varying API surfaces across different language implementations.

## Practical Implementation Comparison

### Rust Examples

**Turso (Rust)** – Async connection with native query handling:

```rust
let db = Builder::new_local("example.db").build().await?;
let conn = db.connect()?;
let rows = conn.query("SELECT id, name FROM users", ()).await?;

```

**libSQL (Rust)** – Synchronous C-based API:

```rust
let conn = libsql::open("example.db")?;
let mut stmt = conn.prepare("SELECT id, name FROM users")?;
let rows = stmt.query_map([], |row| {
    Ok((row.get::<usize, i64>(0)?, row.get::<usize, String>(1)?))
})?;

```

### JavaScript Examples

**Turso (JavaScript)** – Modern async API:

```javascript
import { connect } from '@tursodatabase/database';
const db = await connect('example.db');
const stmt = db.prepare('SELECT * FROM users');
const users = stmt.all();

```

**libSQL (JavaScript)** – Standard client interface:

```javascript
import { Database } from '@libsql/client';
const db = new Database('example.db');
const rows = await db.execute('SELECT * FROM users');

```

## Critical Source Files Illustrating the Differences

- **[[`core/vdbe/execute.rs`](https://github.com/tursodatabase/turso/blob/main/core/vdbe/execute.rs)](https://github.com/tursodatabase/turso/blob/main/core/vdbe/execute.rs)** – Rust bytecode interpreter replacing SQLite's C virtual machine.
- **[[`parser/src/parser.rs`](https://github.com/tursodatabase/turso/blob/main/parser/src/parser.rs)](https://github.com/tursodatabase/turso/blob/main/parser/src/parser.rs)** – SQL parser implementation in Rust.
- **[[`sync/engine/src/wal_session.rs`](https://github.com/tursodatabase/turso/blob/main/sync/engine/src/wal_session.rs)](https://github.com/tursodatabase/turso/blob/main/sync/engine/src/wal_session.rs)** – MVCC-aware write-ahead logging enabling concurrent transactions.
- **[[`extensions/vector/src/lib.rs`](https://github.com/tursodatabase/turso/blob/main/extensions/vector/src/lib.rs)](https://github.com/tursodatabase/turso/blob/main/extensions/vector/src/lib.rs)** – Native vector search demonstrating Turso's extension model.
- **[[`COMPAT.md`](https://github.com/tursodatabase/turso/blob/main/COMPAT.md)](https://github.com/tursodatabase/turso/blob/main/COMPAT.md)** – Detailed SQLite compatibility matrix highlighting API divergences.

## Summary

- **Turso** is a complete Rust rewrite offering async I/O, MVCC concurrency, and native vector search, while **libSQL** preserves C-based SQLite architecture with incremental improvements.
- Turso implements **io_uring-based async operations** compared to libSQL's synchronous blocking I/O.
- The **`BEGIN CONCURRENT`** MVCC model in Turso enables higher write throughput than libSQL's traditional locking mechanisms.
- Turso provides **built-in extensions** for vector search and FTS, whereas libSQL relies on external C modules.
- **API compatibility** differs significantly: Turso implements a partial C API subset tracked in [`COMPAT.md`](https://github.com/tursodatabase/turso/blob/main/COMPAT.md), while libSQL maintains full SQLite compatibility.

## Frequently Asked Questions

### Is Turso a drop-in replacement for libSQL?

No. While Turso maintains partial SQLite C API compatibility as documented in [[`COMPAT.md`](https://github.com/tursodatabase/turso/blob/main/COMPAT.md)](https://github.com/tursodatabase/turso/blob/main/COMPAT.md), it does not implement the complete API surface that libSQL preserves. Applications relying on specific SQLite C extensions or legacy APIs may require modification when migrating from libSQL to Turso.

### Which offers better performance for high-concurrency workloads?

Turso generally provides superior write concurrency due to its **MVCC engine** and **`BEGIN CONCURRENT`** support, allowing multiple writers to proceed simultaneously without blocking. libSQL inherits SQLite's single-writer lock model, serializing write operations regardless of hardware capabilities.

### Can I migrate existing SQLite databases to Turso?

Yes. Turso supports standard SQLite database file formats for import, and the `Builder::new_local()` API accepts existing `.db` files. However, applications using specific C extensions or pragma statements must verify compatibility against the [[`COMPAT.md`](https://github.com/tursodatabase/turso/blob/main/COMPAT.md)](https://github.com/tursodatabase/turso/blob/main/COMPAT.md) matrix, as certain SQLite features remain unimplemented in the Rust rewrite.

### Does libSQL support async operations like Turso?

No. libSQL relies on synchronous blocking I/O inherited from SQLite. While language-specific wrappers (such as async Rust crates or Node.js promisified wrappers) can provide async interfaces, the underlying database operations in libSQL block the calling thread, unlike Turso's native **io_uring** integration.