AetheriusDB · high-performance data engine
One engine serves SQL, vector search, graph traversal, and time-travel over the same tables — and runs your logic inside the database, so one call returns the final answer.
The one idea everything follows from
The engine’s storage design removes whole categories of database work instead of optimizing them. That single choice buys three things most databases build elaborate machinery for.
Heavy write traffic never slows your queries. Reads and writes don’t compete, so dashboards stay fast while millions of rows land.
Lose power mid-write and restart in milliseconds. Committed data is always intact — there is no repair step and nothing to replay.
Query any table AS OF an earlier moment, or replay history to debug a running application — built in, not bolted on.
Interactive prototypes
Each prototype is a faithful browser simulation of one core mechanic, in the order data experiences them: it arrives, gets placed, gets joined, becomes history, and finally meets your code. These are simulations of the mechanics — not the engine itself. They run on their own; the window in instrument 2, the timeline in 4, and the tabs in 5 also respond to you directly.
A million rows land, the block seals, and the power gets cut — sometimes mid-write, sometimes after the seal. Committed data is always intact, and there is never a log to replay.
EMPTY
The block is ready. Rows land directly in place — no staging, no copies.
Drag the query window and compare layouts: AetheriusDB keeps nearby rows together, so the scan touches a handful of blocks and the rest is never read at all.
Drag the window, or focus the canvas and use arrow keys.
Storage order · 16 blocks × 16 rows
The same join, two ways: build and probe a hash table, or follow the relationship straight to the answer. Same result — different physics.
32 orders joining 24 customers, racing on a loop.
Scrub the timeline and the query re-answers as of that moment — inserts appear, updates change, deletes vanish. History is simply part of the data.
| id | name | price |
|---|
The real SQL from the user guide, end to end — a typed table with a native vector column through to logic deployed into the database, so one call returns the final ranked result.
One engine, several front doors
You don’t choose between a SQL database, a vector store, and a graph store — they are different views over the same data, reachable over the native protocol, PostgreSQL pgwire, and Arrow Flight SQL at once.
Strictly typed tables and a broad ANSI SQL surface. Schema is enforced at ingest — no permissive blob fallback.
/define-data/ansi-sql →Native fixed-dimension tensor columns with HNSW and IVFFLAT indexes for k-nearest-neighbour queries in SQL.
/vectors-ai/vector-search →Follow relationships directly — no join tables rebuilt per query.
/graph-temporal/overview →Query any table as of an earlier point in time, and replay history to debug.
/graph-temporal/temporal-tables →From the user guide
Sixteen sections of task-oriented documentation. A few landmarks:
Your SQL compiles to native code — one opt-in flag, no hints, no tuning pass.
/query-data/performanceEnable parallel execution and one query can use the whole machine — no per-query tuning.
/query-data/parallelismHNSW for recall, IVFFLAT for throughput — native similarity search as plain SQL.
/vectors-ai/vector-searchDeploy your logic next to the data; one call returns the final answer instead of a million rows.
/compute/overviewGraph-relational duality: the same rows queried as nodes and edges, traversed natively.
/graph-temporal/knowledge-graphHot data in RAM, warm on NVMe, cold in cloud archive — all queryable. Pin tables that must never leave memory.
/storage/multi-tier-residencyFine-grained access control down to the row, enforced inside the engine on every path.
/security/rbac-rlsBranchable schemas and data — database-as-code, with deterministic simulation for tests.
/files-branching/database-branchingNative protocol, PostgreSQL pgwire, and Arrow Flight SQL — the same engine behind every door.
/security/wire-protocolsFrom zero to first query
One signed installer — or a plain cargo build — starts a daemon that exposes all three wire endpoints at once. The bundled REPL gets you to a first query in the same sitting.
# macOS / Linux — signed pre-built binary $ curl -fsSL https://aetherius.dev/install.sh | bash # smoke-test with the bundled REPL $ aether-term aether> CREATE TABLE hello (id BIGINT, msg TEXT); -- OK
Prefer a pre-built tarball? Grab the database server and client tools for Linux, macOS, and Windows from the downloads page →
Building from source instead? cargo build --release -p aetheriusd -p aether-term — full steps, platforms, and start-up flags in /get-started/install →
aether-term ships with the daemon — typed tables and your first query with nothing else installed.
/get-started/install →psql, Tableau, JDBC, and SQLAlchemy connect unchanged over the PostgreSQL wire protocol on port 5678.
/get-started/connect-clients →pip install aetherius for the lowest-overhead client, or Arrow Flight SQL for pyarrow, Polars, and dbt.
/get-started/connect-clients →Ask us anything
No. Vectors are a native column type — TENSOR(n) — with HNSW and IVFFLAT indexes, queried in plain SQL alongside your relational data. /vectors-ai/vector-search →
Sometimes — but that isn’t the pitch. It speaks the Postgres wire protocol, so many psql, Tableau, and JDBC workflows run unchanged; exotic extensions and catalog quirks may not. Most teams run it as the engine for analytics, vector, and graph workloads beside their OLTP database. /security/wire-protocols →
Committed data is always intact, and there is no repair step and nothing to replay — restart and query. Instrument 1 above simulates exactly this, both mid-write and after a block seals. /storage/crash-recovery →
Typed tables, SQL, vector indexes, and time-travel reads are on out of the box. HTAP (enable_htap), the fast bulk path (BULK_PULSE_V2), compiled execution, and parallel scans are implemented but opt-in — every feature page carries its label. /reference/configuration →
macOS on Apple Silicon and Linux on x86_64 / aarch64 are Tier 1; Windows runs via WSL2. The Linux builds carry the fastest bulk-ingest path. /get-started/install →
Not a document database. Every column is rigidly typed at ingest — there is no schemaless JSON-blob mode. You can store JSON text in a TEXT column; you just don’t get typed, vectorized speed over it.
Not a drop-in PostgreSQL replacement. The pgwire endpoint covers a large ANSI surface and many psql / Tableau / JDBC workflows run unchanged — but exotic extensions and catalog quirks may not behave identically.