SQLite Driver Benchmark: Comparing better-sqlite3, node:sqlite, libSQL, Turso

Choosing the right SQLite driver for Node.js can impact your application’s performance.

We ran performance tests comparing better-sqlite3, node:sqlite, libSQL, and Turso across common database operations. Here’s what we found.

This library has been tested in production for years, offering excellent performance through a synchronous API. The synchronous API makes it very performant and easy to use, and is perfect for fast queries.

→ GitHub better-sqlite3

Node.js 22+ includes a built-in SQLite module (still experimental). It provides zero-dependency SQLite access with a synchronous API similar to better-sqlite3, and also an asynchronous API.

→ Node.js SQlite Documentation

An open-source fork of SQLite created by the Turso team. It provides an async API and supports both local database files and remote libSQL/Turso servers. Fully compatible with the original SQLite (file format, API)

→ libSQL TypeScript

Turso is a SQLite compatible database written in Rust. Currently still in beta.

→ Turso for Javascript

We tested all four drivers with identical queries. A simple scenario with a user and posts table.

• 10,000 users and 500,000 posts (50 per user)
• Optimized pragma settings (WAL mode, 64MB cache, memory-mapped I/O)
• Various query patterns: simple selects, indexed lookups, JOINs, aggregates, inserts, updates

Note: better-sqlite3 and node:sqlite use synchronous APIs, while libSQL and Turso use async/await.

All databases used these optimized settings:

PRAGMA journal_mode = WAL;       -- Write-Ahead Logging
PRAGMA synchronous = NORMAL;      -- Balance safety/speed
PRAGMA cache_size = -64000;       -- 64MB cache
PRAGMA temp_store = MEMORY;       -- Temp tables in memory
PRAGMA mmap_size = 268435456;     -- 256MB memory-mapped I/O

• better-sqlite3 is the fastest for most operations, with node:sqlite second
• Turso has a surprisingly slow query for countPostsByUser (better-sqlite3 is almost 100x faster here). I did not investigate why this is, it might be that the Turso database like many others (eg Postgresql) needs to scan the full table in order to count the number of rows and has no fast handling for this special case.

The benchmark is implemented using SQG, a SQL to code generator.

One advantage of using a code generator like SQG is that you can switch between SQLite drivers without rewriting your queries. SQG generates type-safe code for all four drivers from the same SQL file:

# sqg.yaml - generate code for multiple drivers
sql:
  - files:
      - queries.sql
    gen:
      - generator: typescript/sqlite/better-sqlite3
        output: ./src/db-better-sqlite3.ts
      - generator: typescript/sqlite/node
        output: ./src/db-node-sqlite.ts
      - generator: typescript/sqlite/libsql
        output: ./src/db-libsql.ts
      - generator: typescript/sqlite/turso
        output: ./src/db-turso.ts

This makes it easy to benchmark with your actual queries and switch drivers by changing imports.

The benchmark code is available in our examples repository:

git clone https://github.com/sqg-dev/sqg
cd sqg/examples/typescript-sqlite-benchmark
pnpm install
pnpm generate
pnpm bench

This will generate an HTML report with the results table shown above.

I think for most applications, better-sqlite3 remains the best choice.

Benchmarks generated using SQG. Have questions? Open an issue on GitHub.