Pre-v0 Rust database engine

One core. Four product surfaces.

ffs is a native engine for graph, vector, columnar, and typed data, with server, control, studio, and flow surfaces growing in one monorepo.

Read the code See the surfaces

ffs.db native core

ffs core engine ffsd server mode ffs-control plane ffs-studio workspace ffs-flow pipelines + AI

Shape: core + server
Surfaces: control · studio · flow
Status: pre-v0, tested

Native engine storage, execution, graph, vector, WAL, and catalog in one core

Server mode ffsd owns the database file when teams need a database process

Product layer control plane, studio, pipelines, vector, features, models, agents

Why

Some workloads should not need five systems before they prove themselves.

Graph traversal, vector search, columnar scans, feature pipelines, model output, and provenance often start in separate products. That can be the right answer later, but it adds glue and duplicate indexes before the workload earns that complexity.

ffs starts with one durable engine and builds the product surface around it. The same database core can run embedded for direct calls or behind ffsd when the database needs to be operated as a service.

Product surface

One monorepo while the boundaries harden.

The product is split into clear surfaces inside one repo: engine, server, control plane, studio, and flow. We split repos later only when deployment, security, release cadence, or team ownership demands it.

core

ffs + ffsd

Storage, WAL, execution, graph/vector indexes, and server ownership.

control

ffs-control

Projects, branches, deployments, endpoints, backups, restores.

studio

ffs-studio

Query editor, catalog explorer, lineage, dashboards, history.

flow

ffs-flow

Pipelines, sync, vector retrieval, features, models, agents.

Architecture shape

Built around four separable pillars.

The useful Databricks lesson is separation: transactional storage, native execution, catalog/provenance, and serving. ffs maps those pillars onto one durable Rust core.

storepages, columns, WAL

engineoperators, morsels, vector

catalogschema, lineage, models

serveembedded + ffsd

surfacecontrol, studio, flow

One-to-one map

Delta-like store

FFS Store: pages, chunks, catalog root, WAL, recovery, indexes.

Photon-like engine

FFS Native: batch operators, planner, SIMD distance, graph expansion.

Unity-like catalog

FFS Catalog: schema now; indexes, models, lineage, governance next.

Lakebase-like serve

FFS Serve: ffsd now; client protocol and operational endpoints next.

Studio-like UI

FFS Studio: query, catalog, lineage, dashboards, history.

Mosaic-like flow

FFS Flow: pipelines, vector, features, models, and agent loops.

Measured paths

Benchmarks for selected hot paths.

The eval harness compares engine paths and integrated workloads. The point is not a final scorecard; it is a way to keep storage, execution, server, and product decisions measurable.

Comparator	Path	Result
FFS integrated	filter, traverse, write-back, reopen	tested
sled	KV lookup	1.8x faster
instant-distance	HNSW query	2.6x faster
petgraph	1-hop traversal	9x faster
pgvector	HNSW query	3.01x faster

Rust first

Open a graph. Traverse it. Keep the data path native.

use ffs::cypher::{compile_query, parse};
use ffs::exec::collect_column;
use ffs::planner::{compile, CompileCtx};
use ffs::storage::RelTable;

let mut knows = RelTable::new(0, "KNOWS", 4, 4);
knows.add_edge(0, 0, 1, 1);
knows.add_edge(0, 0, 2, 2);

let q = parse("MATCH (a:Person)-[:KNOWS]->(b:Person) RETURN b")?;
let plan = compile_query(&q, |_| vec![0, 1, 2, 3]);
let ctx = CompileCtx::empty().with_rel_table("KNOWS", &knows);
let mut op = compile(plan, &ctx)?;
let neighbours = collect_column(&mut *op, 0);

Status

Pre-v0, with the spine already in tree.

ffs is early. The core engine, ffsd server scaffold, control plane surface, studio surface, flow surface, evals, and docs are all in the monorepo now.

Now harden storage, ffsd ownership, and product-surface boundaries
Next query protocol, catalog/index metadata, Studio query/catalog UI
Later 10GB and 100GB evals, backups, branch/restore, flow workloads