Local-first data engine

One durable truth for SQL, keyspace, lexical and vector search.

Hyphae is one Rust process, owning one data directory, that runs relational SQL, native data structures, lexical search and vector search over one shared transaction, WAL, MVCC and proof substrate — instead of four separate systems an application has to keep in sync itself.

Install How it works

one process · one data directory

SQL
Keyspace
Lexical
Vector

one commit sequence (CSN)

The problem

Four systems, four versions of reality.

An application today runs a relational database, a key-value cache, a search engine and a vector store. Each one holds its own copy of the same underlying facts, on its own schedule, with its own notion of what is current. Nothing outside application code knows that a row, a cached key, an index entry and an embedding all describe the same object.

So the application reconciles them by hand: dual writes, sagas, background re-indexing, cache invalidation, and the eventual-consistency bugs that come from doing transactional work across systems that were never designed to agree with each other.

How Hyphae changes the game

Hyphae puts SQL, native structures, lexical search and vector search inside one process, over one catalog, one WAL, one MVCC snapshot space, one commit sequence (CSN) and one recovery path. A transaction that touches SQL, structure and search is one commit, not a saga: it becomes visible at exactly one CSN in all engines, or in none.

Results come with proofs a third party can verify offline, without directory access or a network call. And every performance number on this site is a receipt bound to an exact commit and an exact host class — never a general claim.

What you get

One process. Four engines. One substrate.

SQL

An indexed, fail-closed relational core. Typed DDL, multi-row named-column INSERT, exact-primary-key UPDATE/DELETE, indexed SELECT shapes, total and primary-key-prefix grouped aggregates with HAVING and grouped ORDER BY, SELECT DISTINCT, OFFSET, BETWEEN, one admitted indexed INNER JOIN and one nonrecursive CTE form. No subqueries, no UNION, no outer joins, no expression arithmetic — unsupported shapes fail closed rather than scan.

Native structures

A native keyspace/data-structure engine: strings, counters, hashes, lists, sets, sorted sets, streams, TTL, scans and algebra, plus the Valkey-shaped conditional and range commands on wire minor 6. Structures share Hyphae's own transaction and TTL semantics — there is no RESP surface in the native product.

Lexical search

An integrated lexical/vector search engine: BM25 and BM25F field boosts, typed doc-values with bounded filters, facets and metric aggregations, relative-score fusion, autocut, and prefix, fuzzy and phrase matching under explicit budgets. Positions are not stored.

Vector and hybrid fusion

Exact vectors and a deterministic HNSW index for incremental ANN, with same-snapshot hybrid fusion across lexical and vector results — no external search engine or vector store.

Proofs and witnesses

Native checkpoints, HYNPRF02 result proofs and witnesses bound to an ExternalTrustedAnchor, backups, restores, vacuum generations and complete doctor reports. hyphae proof verify runs offline, on another machine, with no directory access and no network call.

Agent Memory

One shared, local Agent Memory for Claude Code, Codex, OpenCode and Pi, with project isolation, TTL, proactive recall, conservative capture, durable spool, PII/secret rejection, and offline-verifiable recall proofs.

Protocol and SDKs

One embedded Rust facade, a local UDS/named-pipe protocol, a CLI, optional loopback HTTP /v2, typed Python and TypeScript SDKs, and the bounded Agent Memory MCP profile.

Measured, with receipts

Every number below is a receipt.

2.2 µs

Embedded keyspace GET, p50

3.6× faster than Redis's 7.9 µs over its own UDS round trip at p50; Redis remains faster at p99 (16.3 vs 7.9–10.8 µs).

a443c52 receipt, §2

1.02 ms

Cross-engine delta transaction, p50

SQL + structure + search in one commit, down from 46.6 ms on the pre-delta materialized path.

a443c52 receipt, §4

23.2 ms

Lexical BM25 query at 1,000,000 documents, p50

Linear in document count: 3.7× the 250,000-document stage's latency for 4× the documents.

a443c52 receipt, §6

111 µs

BM25 top-10, 100,000 documents, p50

Tantivy measures 78.3 µs on the same workload (1.4×); durable ingest is 1.12 s per 1,000-document batch.

a443c52 receipt, §3

20.3 µs

SQL prepared point read, p50

Read checksums matched SQLite and DuckDB on the same 1,000,000-row workload; SQLite's own point read remains faster.

a443c52 receipt, §1

Crates published to crates.io

The complete dependency graph, one version (3.0.0), one commit, independently reverified.

3.0.0 publication receipt

Latency numbers: AWS i7i.metal-24xl, environment class 3 (dedicated hardware), one run per phase — deltas under 10% are not claimed. See the claims and non-claims page and the evidence index for every other measurement.

Who it is for

Built for local-first ownership.

Local-first applications

One process and one data directory own SQL, structure and search together — no cache to invalidate, no search index to reconcile, no separate vector store to keep current.

Coding agents needing durable memory

Agent Memory gives Claude Code, Codex, OpenCode and Pi one shared, local, project-isolated memory with proactive recall and offline-verifiable proofs — no cloud account required.

Teams that need auditable data

Every read can carry a proof a third party verifies offline against an independently held anchor, and every performance claim ships with the receipt that produced it.

Get started

Install the CLI and open a directory.

The complete 24-crate graph is published on crates.io for 3.0.0. Pin the exact version and lock the dependency graph.

cargo install hyphae-cli --version 3.0.0 --locked

Install guide GitHub ↗ Documentation