Releases & roadmap

Embedded library ✓ Shipped

libengine + engine.h + @twilldb/bun + LocalFileStorage

The engine as an in-process library bound into Bun via bun:ffi, backed by LocalFileStorage (a plain file:// database, no network). SQL → MVCC snapshot isolation → crash-safe WAL durability with deterministic replay. The C ABI is frozen here and reused unchanged by everything built since.

Gate: basic SQL correctness + MVCC snapshot isolation; durable-after-ack with torn-frame recovery. Implementation map → · Engine Core spec

Object-storage backend ✓ Shipped

ObjectStorage (LSM page store + S3-CAS commit log)

A second Storage impl makes the database disaggregated and scale-to-zero — while staying embedded. Flip the connection string from file:// to s3:///r2:///gs:// and the same binary durably bottoms out on object storage, with the local cache keeping S3 latency off the read hot path.

Gate: commit-latency floor, group-commit throughput, and crash-safety (every acked commit survives kill -9). Implementation map → · Object-Storage spec

Server mode + pgwire ✓ Shipped

engine-server (Postgres-wire subset)

The same engine wrapped in a Postgres-wire listener. Ordinary Postgres clients — psql, Bun.sql, pgbench, PostgREST — connect with no bespoke driver. The server links the engine's Rust API unchanged and adds exactly one thing: the listener.

Gate: serves Bun.sql and pgbench over the wire; contention behaviour reproduces in server mode. Implementation map → · Server Mode spec

Branching & lifecycle ✓ Shipped

BranchStorage + durable single-writer lease + twill-controller

Copy-on-write branching as a storage-seam concern (a parent read-through below the fork LSN plus a private write overlay), a durable single-writer lease fenced by a monotonic CAS epoch, and a scale-to-zero lifecycle controller (cold-start, idle reaper, lease heartbeat, thundering-herd admission). All additive: STORAGE_TRAIT_VERSION and ENGINE_ABI_VERSION bumped to 2.

Gate: scale-to-zero + cold-start with the fence re-acquired by exactly one writer; O(1) branch creation with write isolation. Implementation map → · Lifecycle spec

Vector search (in-core) ✓ Shipped

in-core vector(N) type + HNSW + distance operators + KNN · composition

Vector search built into the engine: a vector(N) type, an HNSW access method (CREATE INDEX … USING hnsw), the distance operators <-> / <=> / <#>, and top-k nearest-neighbour answered by the index. Because the index rides the same WAL/replay path as the rows, it branches and scales-to-zero with the database — an agent can fork its memory. Interface/service capabilities (better-auth, PostgREST, DuckDB) are composed around the core, never welded in. Additive: ENGINE_ABI_VERSION → 3, STORAGE_TRAIT_VERSION stays 2.

Gate: HNSW top-k matches brute force; WHERE-filtered + MVCC-correct KNN; the index branches and rebuilds from the WAL on restart. Implementation map → · Capabilities spec

SQL surface completeness ✓ Shipped

richer SQL frontend (6A–6E) — parser + executor only; the storage seam never moved

The hand-written SQL frontend (sql.rs → exec.rs) grown to cover the common, OLTP-shaped majority of the PostgreSQL and SQLite surface, in five additive stages: 6A expression & single-table (CASE, CAST/::, IN/BETWEEN, ||, RETURNING, upsert, INSERT … SELECT); 6B multi-table (joins, GROUP BY/HAVING, subqueries, set ops, views & CTEs); 6C the scalar function library (string / math / date-time / uuid / JSON); 6D constraints, schema evolution & savepoints (CHECK/DEFAULT/UNIQUE, ALTER TABLE, SAVEPOINT); 6E dialect shims (placeholders, quoting, LIKE/ILIKE, SET/SHOW/PRAGMA). Pure frontend growth — STORAGE_TRAIT_VERSION and ENGINE_ABI_VERSION never moved; anything still unsupported returns a clean ENGINE_ERR_SQL.

Gate: per-stage test binaries (expr_6a, relational_6b, functions_6c, constraints_6d, dialect_6e) all green; the C1–C8 conformance suite, branching, and scale-to-zero untouched. Implementation map → · SQL Compatibility spec

Row-Level Security ✓ Shipped

in-core per-row enforcement (Phase 7) · JWT identity composed around

Supabase-style RLS built into the engine and enforced over the same MVCC snapshot every query already uses. CREATE/DROP POLICY and ALTER TABLE … ENABLE ROW LEVEL SECURITY persist as additive WAL catalog facts; a per-connection session context (role + JWT claims via SET ROLE / SET twill.jwt.claims) is read by auth.uid() / auth.role() / auth.claim(). Enforcement is default-deny — USING on reads, WITH CHECK on writes, RLS-filtered RETURNING, and an explicit off-by-default bypass — reflected through pg_policies. JWT verification stays composed around the engine, so PostgREST-style identity layers on without entering the core. Additive: ENGINE_ABI_VERSION and STORAGE_TRAIT_VERSION both unchanged, so policies branch / scale-to-zero / PITR-restore for free.

Gate: default-deny read/write enforcement on the single-table and relational paths; bypass off unless explicitly set; policies survive branch + replay. Row-Level Security spec

CLI tooling & multi-runtime clients ✓ Shipped

twilldb scaffolder + management CLI (spec 19) · @twilldb/node + PHP clients (spec 20)

A dependency-free twilldb scaffolder (new/init, with a --vector HNSW template) and a full database-management CLI — sql, shell, tables, migrate, gen types, seed, stats, branch, db reset, schema dump, serve — over both embedded (file:///s3://) and over-the-wire (postgres://) transports. Alongside them, @twilldb/node (koffi FFI) and twilldb/twilldb (PHP FFI) join the Bun client with the same surface.

Gate: management tests behind the manage feature green while the default scaffolder build stays lean; Node + PHP embedded e2e suites pass. CLI Tooling · Management CLI · Client Runtimes

Vector hardening ✓ Shipped

deferred items from the vector-search scope boundaries — landed in v0.5.0

• DonePage-laid-out vector index improvements for cold reads, on top of the WAL-derived index that branches and rebuilds on open.
• DoneDelete-churn maintenance so tombstoned deletes no longer degrade the graph over time.
• DoneRecall tuning via ef_search — the HNSW recall/latency trade-off is now surfaced and documented.

Detail in Capabilities: Build-in vs Compose and the vector-search implementation map; delivered under epic #89.