# How Turso's MVCC Improves Write Throughput for Concurrent Transactions > Discover how Turso's MVCC boosts write throughput for concurrent transactions by replacing WAL locks with a lock-free, row-level versioning engine. - Repository: [Turso Database/turso](https://github.com/tursodatabase/turso) - Tags: performance - Published: 2026-06-22 --- **Turso's experimental MVCC (Multi-Version Concurrency Control) replaces the traditional Write-Ahead Log (WAL) lock-based write path with a lock-free, row-level versioning engine that enables multiple writers to execute transactions simultaneously without blocking.** Turso's MVCC implementation fundamentally restructures how SQLite handles concurrent writes by moving from a single-writer page-locking model to a multi-writer row-versioning architecture. Unlike the traditional WAL mode that serializes writers through exclusive locks, MVCC allows connections to begin concurrent transactions immediately, dramatically improving throughput under heavy write loads. This experimental feature in the `tursodatabase/turso` repository operates through a combination of lock-free data structures and deferred checkpointing. ## Eliminating the Single-Writer Bottleneck Traditional WAL mode requires writers to acquire an exclusive lock on entire database pages before committing changes. This creates a significant bottleneck where only one transaction can write at any given time, forcing other connections to wait or retry. Turso's MVCC eliminates this contention by implementing **row-level versioning** instead of page-level locking. When using `PRAGMA journal_mode = 'mvcc'`, the database engine stores modified rows in an in-memory `MvStore` defined in [`core/mvcc/database/mod.rs`](https://github.com/tursodatabase/turso/blob/main/core/mvcc/database/mod.rs) rather than flushing whole pages to disk immediately. This architectural shift allows multiple transactions to create independent versions of the same row without blocking each other. ## Lock-Free Data Structures and Snapshot Isolation The MVCC engine relies on `crossbeam_skiplist` to manage concurrent access without traditional mutexes. In [`core/mvcc/mod.rs`](https://github.com/tursodatabase/turso/blob/main/core/mvcc/mod.rs), the storage layer constructs the `MvStore` using these lock-free skip-lists (lines 54-55), enabling concurrent insertion and lookup operations without thread contention. Each transaction receives **snapshot isolation** based on a begin timestamp taken at `BEGIN CONCURRENT`. Writers verify only that rows they modify haven't changed since their transaction started, using a lightweight hash-lookup in the version list rather than acquiring global locks. This validation happens entirely in memory until the transaction commits. ## The Checkpoint State Machine While writes remain in memory, durability is maintained through a background checkpoint process. The [`core/mvcc/database/checkpoint_state_machine.rs`](https://github.com/tursodatabase/turso/blob/main/core/mvcc/database/checkpoint_state_machine.rs) file implements a state machine that periodically flushes accumulated row-versions to the B-tree. During checkpointing, the system acquires only a brief pager lock to write the logical log (`.db-log` file), then releases it immediately. Because checkpoints run infrequently compared to individual write operations, the average latency for transaction commits remains significantly lower than WAL mode, where each commit may trigger synchronous page flushes. ## Enabling MVCC and Running Concurrent Transactions To activate the MVCC engine, set the journal mode and begin transactions with the concurrent pragma: ```sql -- Enable MVCC mode for the database PRAGMA journal_mode = 'mvcc'; ``` Once enabled, use `BEGIN CONCURRENT` to start transactions that can run simultaneously with other writers: ```sql -- Multiple connections can execute this simultaneously without blocking BEGIN CONCURRENT; INSERT INTO users (id, name) VALUES (1, 'Alice'); INSERT INTO users (id, name) VALUES (2, 'Bob'); COMMIT; ``` When using Turso's embedded API, the same pattern applies: ```rust use turso::Connection; fn concurrent_write(conn: &Connection, id: i64, name: &str) { conn.execute("BEGIN CONCURRENT").unwrap(); conn.execute(&format!("INSERT INTO users (id, name) VALUES ({}, '{}')", id, name)) .unwrap(); conn.execute("COMMIT").unwrap(); } ``` The transaction orchestration in [`core/vdbe/execute.rs`](https://github.com/tursodatabase/turso/blob/main/core/vdbe/execute.rs) handles the `BEGIN CONCURRENT` logic, ensuring that each connection manages its own version timeline without interfering with other active writers. ## Key Performance Optimizations Turso's MVCC improves write throughput through five specific mechanisms: 1. **No exclusive write lock** – Writers never wait for a global lock; CPU keeps multiple threads busy processing inserts and updates concurrently. 2. **Row-level granularity** – Costs are proportional to rows touched, not page sizes. The `MvStore` tracks only modified rows rather than rewriting entire pages. 3. **Lock-free data structures** – The `crossbeam_skiplist` in [`core/mvcc/mod.rs`](https://github.com/tursodatabase/turso/blob/main/core/mvcc/mod.rs) eliminates mutex contention between writer threads. 4. **Deferred checkpointing** – Writes accumulate in memory while a background checkpoint state machine periodically flushes them to the B-tree, reducing the frequency of disk synchronization. 5. **Efficient conflict detection** – Write-write conflicts are detected through timestamp comparisons in the version list, avoiding expensive serialization overhead. ## Summary - Turso's MVCC replaces the WAL's single-writer page-locking model with a multi-writer, row-level versioning system. - The implementation uses lock-free `crossbeam_skiplist` structures in [`core/mvcc/mod.rs`](https://github.com/tursodatabase/turso/blob/main/core/mvcc/mod.rs) to eliminate thread contention. - Transactions use `BEGIN CONCURRENT` to achieve snapshot isolation without blocking, with versions stored in the `MvStore` defined in [`core/mvcc/database/mod.rs`](https://github.com/tursodatabase/turso/blob/main/core/mvcc/database/mod.rs). - A background checkpoint state machine in [`core/mvcc/database/checkpoint_state_machine.rs`](https://github.com/tursodatabase/turso/blob/main/core/mvcc/database/checkpoint_state_machine.rs) periodically flushes the `.db-log` to the B-tree while holding locks only briefly. - The shift from page-level to row-level granularity significantly reduces write latency and increases throughput for concurrent workloads. ## Frequently Asked Questions ### How do I enable MVCC in Turso? Enable MVCC by executing `PRAGMA journal_mode = 'mvcc'` on your database connection. This switches the storage engine from the default WAL mode to the experimental MVCC engine, allowing subsequent transactions to use `BEGIN CONCURRENT` for lock-free writes. ### What happens when two concurrent transactions modify the same row? MVCC detects write-write conflicts by comparing timestamps. If two transactions modify the same row, the second commit will fail with a conflict error because the row was modified after the transaction's begin timestamp. This maintains snapshot isolation without requiring readers to block writers. ### How does MVCC affect read performance? Read performance remains efficient because MVCC provides snapshot isolation at the row level. Readers access a consistent view of the database as of their transaction start time without acquiring locks, while the `crossbeam_skiplist` structure in [`core/mvcc/mod.rs`](https://github.com/tursodatabase/turso/blob/main/core/mvcc/mod.rs) enables fast version lookups. ### Is MVCC suitable for all workloads? MVCC excels in high-concurrency write scenarios where multiple connections need to commit simultaneously. However, workloads with very large transactions that touch many rows may increase memory pressure in the `MvStore` before checkpointing occurs, as implemented in [`core/mvcc/database/checkpoint_state_machine.rs`](https://github.com/tursodatabase/turso/blob/main/core/mvcc/database/checkpoint_state_machine.rs).