SQLRite is a from-scratch SQLite alternative — a single-file embedded database in Rust with a real B-tree, write-ahead log, transactions, JOINs, aggregates, HNSW vector search, BM25 full-text search, and bindings for six languages. Built to teach what databases actually do.
No mocks, no shortcuts. SQLRite implements the parts of SQLite that matter — a paged file format, a B-tree, a WAL, locks, JOINs, aggregates — and extends them with the parts AI workloads need: vector search, full-text search, hybrid retrieval, and an MCP adapter.
One .sqlrite file per database. 4 KiB pages. Magic header, format version, schema-root pointer. Currently file format v5.
Real cell-based pages with a slot directory. Interior + leaf nodes. Overflow chains for oversized rows.
32-byte header, 4112-byte frames, rolling-sum checksums. Torn-write recovery and atomic commits.
BEGIN / COMMIT / ROLLBACK with snapshot isolation. Auto-rollback if the commit's disk write fails.
BEGIN CONCURRENT for multi-writer apps. Snapshot-isolated reads, row-level conflict detection at commit, retryable Busy/BusySnapshot errors across every SDK.
Four JOIN flavors with explicit ON. GROUP BY + COUNT/SUM/AVG/MIN/MAX, DISTINCT, LIKE, IN, IS NULL.
? placeholders bind anywhere a literal is allowed — including vector arguments to k-NN. Per-connection LRU plan cache.
VECTOR(N) column type with cosine / dot / L2 distance. HNSW index per metric for sub-linear k-NN.
FTS5-style inverted index with BM25 scoring. fts_match() / bm25_score() functions, hybrid retrieval ready.
DROP TABLE / DROP INDEX / DROP COLUMN release pages onto a free-list. Auto-VACUUM compacts past 25%, tunable via PRAGMA.
Rust crate, Python (PyO3), Node.js (napi-rs), Go (database/sql), C FFI, and WASM for the browser. All five non-Rust SDKs mint sibling connection handles for multi-writer workloads.
Cross-platform Svelte 5 + Tauri 2.0 client. sqlrite-mcp exposes the database as an MCP stdio server.
Every phase is shippable on its own and documented. The codebase is the textbook.
SQLRite mirrors SQLite’s classic two-half split: a front end that turns SQL into a plan, and a back end that turns that plan into bytes.
Every phase is independently usable and merges to main before the next starts. Eleven phases shipped through v0.10.0; the remaining list at the bottom is small, well-scoped follow-ups.
Rust 2024 edition, resolver 3, every dependency on current majors.
CREATE / INSERT / SELECT / UPDATE / DELETE with WHERE, ORDER BY, LIMIT.
Single-file .sqlrite format with a 4 KiB page layout and crash-safe header writes.
Cell-based pages, interior + leaf nodes, overflow chains, secondary indexes.
Cross-platform GUI in Svelte 5; engine extracted into a reusable library.
WAL, checkpointer, exclusive/shared locks, and real BEGIN/COMMIT/ROLLBACK.
Public Connection / Statement / Rows API plus Rust, Python, Node, Go, C FFI, and WASM bindings.
Lockstep versioning across eleven manifests; OIDC trusted publishing across PyPI, npm, crates.io.
Vector / embedding column type, HNSW ANN index, JSON column type, ask() (natural-language → SQL), MCP server.
FTS5-style inverted index, BM25 scoring, hybrid (lexical + semantic) retrieval. Bumps file format v4 → v5.
After v0.2.0 closed the file-format bump, the next nine sub-phases shipped the SQL surface that had been parked under "possible extras" — JOINs, aggregates, prepared statements, PRAGMA, and the storage hygiene around them.
Twelve-workload bench harness (SQLR-4 / SQLR-16) with a pluggable Driver trait. Pinned-host runs published.
BEGIN CONCURRENT for multi-writer apps. Hekaton-style optimistic MVCC, row-level conflict detection at commit, snapshot-isolated reads, and a typed retry surface across every SDK.
Smaller, well-scoped follow-ups that slot in where they make sense — see the canonical roadmap doc for the full list.
The same Rust core — wrapped, never reimplemented. SDKs ship as prebuilt binaries so there’s no toolchain to install just to use the database.
use sqlrite::Connection;
fn main() -> sqlrite::Result<()> {
let mut conn = Connection::open("app.sqlrite")?;
conn.execute(
"CREATE TABLE IF NOT EXISTS users \
(id INTEGER PRIMARY KEY, name TEXT NOT NULL)",
)?;
conn.execute("INSERT INTO users (name) VALUES ('alice')")?;
let rows = conn.query("SELECT id, name FROM users")?;
for row in rows {
let id: i64 = row.get(0)?;
let name: String = row.get(1)?;
println!("{id}: {name}");
}
Ok(())
}The supported SQL is real — every feature lands with type checks, UNIQUE enforcement, and a clean error path instead of a panic. JOINs, aggregates, and prepared statements all came in the v0.2.0 → v0.9.1 wave.
| Statement | Features |
|---|---|
| CREATE TABLE | PRIMARY KEYUNIQUENOT NULLDEFAULT <literal>INTEGERTEXTREALBOOLEANVECTOR(N)JSONauto-index |
| ALTER TABLE | RENAME TORENAME COLUMNADD COLUMN [+ DEFAULT backfill]DROP COLUMNIF EXISTS |
| DROP TABLE / DROP INDEX | IF EXISTSauto-indexes refusedfreelist reclaimauto-VACUUM |
| CREATE [UNIQUE] INDEX | IF NOT EXISTSB-tree (default)USING HNSW WITH (metric = …)USING FTSINTEGER + TEXT + VECTOR |
| INSERT INTO | explicit column listauto-ROWIDmulti-row VALUESUNIQUE enforcementJSON validationvector dim checkDEFAULT padding |
| SELECT | projectionWHEREORDER BY ASC|DESCLIMIT nDISTINCTGROUP BY= literal → index probevec_distance_* / k-NN (HNSW)fts_match / bm25_score |
| JOINs | INNER JOINLEFT OUTERRIGHT OUTERFULL OUTERON <expr>aliasesself-joinsmulti-join chains |
| Predicates | = <> < <= > >=IS NULL / IS NOT NULLLIKE / NOT LIKE / ILIKEIN (literal-list)AND / OR / NOTarithmetic + || |
| Aggregates | COUNT(*)COUNT(DISTINCT col)SUMAVGMINMAXGROUP BY <col>HAVING |
| UPDATE | multi-column SETWHEREarithmetic in SETUNIQUE + type checksFTS / HNSW index maintenance |
| DELETE | WHEREfull-tablefreelist reclaim |
| BEGIN / COMMIT / ROLLBACK | snapshot transactionsWAL-backed commitauto-rollback on disk error |
| VACUUM | manual compactionauto-VACUUM (25% freelist)tunable thresholdSQL via PRAGMA |
| PRAGMA | auto_vacuum (read/write)extensible dispatchertyped errors on bad values |
| Prepared statements | ? placeholdersexecute_with_paramsquery_with_paramsper-conn LRU plan cacheValue::Vector binding |
| Functions | json_extract / json_typejson_array_length / json_object_keysvec_distance_l2 / cosine / dotfts_matchbm25_score |
Twelve workloads pitch SQLRite, the embedded Rust database, against SQLite (WAL+NORMAL) and DuckDB on a pinned-host run. The point isn’t to win — SQLite has 25 years of optimization behind it — it’s to baseline future engine work, prove the differentiator workloads (HNSW vector search, BM25 full-text) deliver, and ground the roadmap with evidence.
Cosine distance, 10k × 384-dim corpus. Same engine, same data — only the index probe changes. Lower is better.
After SQLR-23 (prepared statements + ? bindings) closed the parser tax, SQLRite tracks SQLite within ~2× on hot read paths. Lower is better.
1k-doc tech-blurb corpus. SQLite FTS5 is the lexical comparator; the hybrid query (BM25 + cosine) is SQLRite-only. Lower is better.
Columnar engines win on big aggregations. We publish the gap honestly — SQLRite isn't competing on this axis, but the suite proves the differentiator workloads still deliver. Lower is better.
The suite ships with the gap measured + the workaround documented + the task linked. Each is “investigation, not a release gate.”
Cross-platform, dark by default, written in Svelte 5 + Tauri 2.0. The header has New… / Open… / Save As… buttons; the editor has live line numbers, ⌘/ comment toggle, and selection-aware Run.
| name | age |
|---|---|
| alice | 31 |
| cara | 29 |
| dan | 27 |
SQLRite is a learning project as much as a database. Each phase is paired with a long-form post on the design choices behind it.
SQLRite v0.10.0 lifts the single-writer ceiling. The release ships an in-memory version index, BEGIN CONCURRENT with row-level conflict detection at commit, snapshot-isolated reads, durable WAL log-records, and sibling connection handles across every SDK — Rust, Python, Node, Go, C FFI, and a REPL demo.
read post →May 6, 2026The distribution story behind SQLRite — one engine, six surfaces. How a Rust crate becomes a Svelte/Tauri desktop app, a Model Context Protocol stdio server, and language SDKs for Python, Node, Go, C, and the browser.
read post →April 29, 2026How SQLRite's benchmark harness compares an in-development Rust embedded database against rusqlite-bundled SQLite — the workloads, what's already close, and where the gap is wide.
read post →April 22, 2026How SQLRite added a VECTOR(N) column type and an HNSW index to an embedded SQL engine — distance functions, the executor shortcut, and the design tradeoffs of putting an ANN graph next to a B-tree.
read post →The short answers. The long ones live in the docs and the repository.
SQLRite is an embedded SQL + vector database written from scratch in Rust. Like SQLite, it stores a whole database in a single file and runs inside your process — no server. On top of the classic engine (B-tree storage, WAL, transactions, JOINs, aggregates) it adds the parts AI workloads need: HNSW vector search, BM25 full-text search, JSON columns, and a built-in MCP server.
SQLite is a battle-tested C library; SQLRite is an independent Rust engine with a SQLite-style design, built to be read and extended. SQLRite ships vector search (VECTOR columns + HNSW indexes), BM25 full-text search, MVCC concurrent writes via BEGIN CONCURRENT, natural-language-to-SQL, and an MCP server as first-class features instead of extensions. SQLite remains the right default for maximum maturity; SQLRite targets embedded AI / retrieval workloads and learning how databases work.
Yes. Declare a VECTOR(N) column, build an HNSW index with CREATE INDEX … USING HNSW, and query with vec_distance_cosine / dot / L2 in an ORDER BY … LIMIT k. The optimizer recognizes the k-NN pattern and probes the HNSW index for sub-linear search, and you can combine the distance with bm25_score() for hybrid retrieval.
Yes. CREATE INDEX … USING FTS builds an FTS5-style inverted index; fts_match() filters and bm25_score() ranks with BM25. The index persists in the same single .sqlrite file as your tables.
Six surfaces wrap the same engine: a native Rust crate (sqlrite-engine), Python (PyO3), Node.js (napi-rs), Go (database/sql driver), a C FFI with a generated sqlrite.h header, and a WebAssembly build for the browser. There's also a CLI REPL and a Tauri desktop GUI.
Yes — the engine compiles to a ~500 KB-gzipped WebAssembly module with web, bundler, and nodejs targets. The playground on this site runs the full engine in your tab, including HNSW vector search, with OPFS persistence.
sqlrite-mcp exposes any .sqlrite database to AI agents over the Model Context Protocol (stdio). It ships eight tools — list_tables, describe_table, query, execute, schema_dump, vector_search, bm25_search, and ask — and a --read-only mode that opens the file under a shared lock and hides execute.
SQLRite is a young, well-tested engine built in public — honest about what it is. It has WAL crash safety, typed errors, snapshot-isolated transactions, and a benchmark suite against SQLite and DuckDB, but it hasn't had SQLite's decades of hardening. Use it for embedded AI prototypes, tools, and learning; reach for SQLite when you need maximum maturity.
SQLRite is open source under MIT. Pull requests, issues, and database trivia all welcome.