Zeta-Lite: A Concurrent, Branchable In-Browser SQL Database for Agentic Memory
cs.DB · cs.AI
Quick verdict
Claims first-ever single-thread SI transactions and DB branching in a 2.87 MB wasm engine; coherent and honest, but closed-source with single-run benchmarks.
Summary
The paper presents Zeta-lite, a WebAssembly build of the Zeta SQL database engine (2.87 MB gzipped) that runs entirely in the browser without workers, SharedArrayBuffer, or cross-origin-isolation headers. Its log-centric MVCC core yields two claimed firsts among in-browser SQL engines: overlapping snapshot-isolated transactions on a single thread (multiple transactions hold distinct read/commit timestamps, interleave between statements, and get write-write conflict detection) and copy-on-write whole-database branching (fork/merge/rebase) derived directly from the version log. The system exposes a PostgreSQL-style surface — joins, CTEs, window functions, JSONB with GIN, full-text search, HNSW vector search, SQL/PGQ graph queries — and persists via whole-database snapshots to OPFS. On one workstation across Chrome 152, Firefox 154, and a native bun reference, it sustains 268k-315k point reads/s, stays within ~5-15% of native throughput, and passes a rate-limited 1,500 ops/s soak (900k ops, ~4.8 MB OPFS round-trips under 200 ms, thousands of branch cycles) with flat read-only memory. Main limitations, largely self-declared: transaction-lifetime overlap only (no sub-statement concurrency), snapshot-granularity durability, snapshots that cannot yet capture branches, closed engine source (NDA), single-run benchmarks without variance, no head-to-head comparison against PGlite or SQLite-wasm, and the motivating agentic-memory workload is argued, not measured.
Review complete
Assessment at a glance
5
risk flags identified
● high 1
● medium 3
● low 1
5 strengths · 5 weaknesses · 5 author questions
AI text signal = Binoculars zero-shot detector score over 20 sampled passages (Fast-DetectGPT co-reported) — absence does not prove human authorship, and a flag does not imply misconduct.
Levels reflect verification complexity — not a quality score. Evolve never rates your paper.
Key claims under review
- Zeta-lite is the only in-browser SQL engine supporting overlapping snapshot-isolated transactions on a single thread, obtained from a log-centric MVCC design without threads or SharedArrayBuffer (§3.2, §7.1).
- Whole-database copy-on-write branching (fork/merge/rebase) is absent from every other in-browser SQL engine and falls out of the MVCC version log at near-zero cost (§3.6).
- The engine compiles to a 2.87 MB gzipped artifact — the same size class as PGlite — while carrying a strictly larger feature surface including HNSW vector search and SQL/PGQ graph queries (§7.4).
- In-browser throughput is within ~5-15% of a native build, sustaining 267,953-315,345 point reads/s across Chrome 152 and Firefox 154 (Table 3).
- Snapshot-to-OPFS durability removes the need for workers, SharedArrayBuffer, and COOP/COEP headers, at the accepted cost of snapshot-granularity rather than per-commit durability (§5, §8).
Strengths
Two headline capabilities from one mechanism
§3.2/§3.6 show transaction overlap and whole-DB branching are both timestamps over one append-only MVCC log — an architectural argument, not bolt-on features. §7.1 demonstrates both halves: 8 disjoint transactions, 40,000 commits, zero conflicts, and Table 2's 5,000/5,000 write-write aborts replicated identically across Chrome, Firefox, and bun.
Explicitly bounded claims
§8 refuses overclaim: overlap is transaction-lifetime only, not sub-statement; per-op latency is native-only because the ~1 ms performance.now clamp on non-COI pages makes browser timings meaningless; §7.3 reports unflattering insert-phase memory growth (131→195 MB) alongside the favorable +0 MB settle figure.
Unusually complete reproducibility apparatus
Precise competitive and platform positioning
Soak methodology measures stability, not just peaks
Weaknesses
Closed engine core
No head-to-head engine baselines
Thin statistical reporting
MERGE BRANCH semantics unspecified
Title use case argued, not evaluated
Full Review Report
$1.99 · one-timeUnlock the complete preliminary analysis Evolve produced for this paper.
Report preview
Scope & Claims
Zeta-lite (arXiv 2609.01818, v0.1 preview) is the WebAssembly form factor of the Zeta SQL engine, compiled from one Rust codebase to a 2.87 MB gzipped artifact (§3.1). The central claims: (1) overlapping snapshot-isolated (SI) transactions on a single wasm thread without SharedArrayBuffer — asserted as unique among in-browser SQL engines (§3.2, §7.1); (2) whole-database copy-on-write branching (fork/merge/rebase) derived from the same append-only version log (§3.6); (3) a 'feature-complete' PostgreSQL surface (JSONB+GIN, full-text, HNSW vectors, SQL/PGQ) at PGlite's size (§7.4); (4) snapshot-to-OPFS durability needing no worker or COOP/COEP headers (§5); (5) in-browser throughput within ~5-15% of native (§7.2). The title's target use case — agentic memory — is argued (§6), not evaluated.
The remaining sections cover Methodology Assessment, Statistical Evidence, Results & Reproducibility, Limitations & Risks, and Verdict & Recommendations.
- All 5 strengths & 5 weaknesses, analyzed in detail
- 5 risk flags with severity, section & reviewer questions
- Methods & statistical evidence assessment
- 5 questions a peer reviewer would ask
- Full six-dimension evaluation report & recommendations
One-time purchase · this paper only
One-time purchase, this paper only. AI-generated preliminary analysis — not peer review.
Frequently asked questions
What is Zeta-lite?
A SQL database engine compiled to WebAssembly (2.87 MB gzipped) that runs entirely inside the browser. It offers PostgreSQL-style SQL (joins, CTEs, JSONB with GIN indexes, full-text search, HNSW vector search, SQL/PGQ graph queries), lets several snapshot-isolated transactions overlap on a single thread, supports whole-database branching (fork/merge/rebase), and persists via snapshots to the browser's OPFS storage — without workers, SharedArrayBuffer, or special HTTP headers.
How is Zeta-lite different from PGlite?
PGlite compiles PostgreSQL to WebAssembly but runs it in single-user mode: one connection executes one statement at a time, so two transactions can never be open at once. Zeta-lite instead keeps multiple snapshot-isolated transactions open simultaneously on one thread and adds whole-database branching, HNSW vector search, and SQL/PGQ graph queries, at a comparable download size (2.87 MB versus PGlite's 'under 3 MB' gzipped).
Is Zeta-lite open source?
No. The compiled engine is published on npm, free for any use including commercial, and the SQL playground, documentation, and the full benchmark/evaluation harness are public on GitHub. However, the engine's source code itself is closed and available only under NDA.
What happens to my data if the browser tab crashes?
You keep everything up to the last snapshot your application wrote to OPFS. Durability is per-snapshot, not per-commit, so transactions committed after the last checkpoint are lost on crash, reload, or tab close. Additionally, in v0.1 snapshots cannot capture branches — a database must merge or drop all branches before it can be persisted.
About this review
This is an AI-generated preliminary review by Evolve.Pub, produced from the openly available text of the paper. It is not peer review and does not represent the authors' views. The canonical record of the paper is at the publisher link above.
- The metadata abstract cuts off mid-word ('multi-dat'), but the complete abstract is present in the body text; no material truncation detected — conclusion §9 and references [1]-[11] are intact, and Tables 1-3 plus Figure 1's content are all present in the extraction.
Go deeper on this paper
Wrote a paper? Stress-test it before reviewers do.
Upload your manuscript for the same structured scrutiny — reasoning, statistics, evidence, figures, and reproducibility.