Skip to content

🦊 Alopex DB

Silent. Adaptive. Unbreakable.

The unified database engine that scales from a single embedded file to a globally distributed cluster.

Native SQL, Vector Search, and HNSW indexing in one Rust-based engine.

Get Started View on GitHub


💻 CLI Defaults

On a TTY, the CLI launches the TUI by default; use --batch or --output to force batch output. In the results TUI, press a to open the admin console when available. The status bar emphasizes Connection/Focus/Action and Ops so you can see the current target and primary actions at a glance. The admin console uses a rainfrog-style layout (left resource tree, right detail input, right-bottom status/preview) with h/l focus switching.

🚀 Current Status

v0.7.6 Released — Cluster-Aware + gRPC Cluster Administration (July 2026)

Alopex DB v0.7.6 is out! The v0.6/v0.7 series delivered SQL JOIN & subqueries on a new Nim FFI SQL parser, the alopex-cluster crate, a mode-parity verification suite, and gRPC cluster administration. Every release ships prebuilt CLI binaries (Linux / macOS / Windows) and Python wheels.

# Rust
cargo add alopex-embedded alopex-sql alopex-server alopex-cluster

# Python
pip install alopex

alopex-embedded alopex-sql alopex-server alopex-cluster alopex-chirps CLI Binaries


🤔 The Problem

Modern AI applications require multiple database technologies—creating complexity, inconsistency, and operational overhead.

  • Traditional Approach


    • SQLite for local storage
    • Vector DB for embeddings
    • Graph DB for relationships
    • Distributed SQL for scale

    ❌ 4+ systems to manage, sync, and maintain

  • 🦊 The Alopex Way


    • One unified engine
    • Seamless topology migration
    • Single API everywhere
    • Native multi-model support

    ✅ One engine that adapts to your scale


⭐ Key Features

  • 🎯 Native Vector + HNSW


    VECTOR(N) is a first-class data type with ACID transactions. HNSW indexing for high-performance similarity search with hybrid SQL queries.

  • ⚡ SQL Frontend


    Full SQL support with DDL/DML, JOIN & subqueries, vector_similarity() function, and Top-K optimization. Published on crates.io.

  • 📊 Columnar Storage


    Optimized columnar segments with compression, statistics, and predicate pushdown for analytical workloads.

  • 🦀 Pure Rust Engine


    Memory-safe, high-performance, and portable. Custom LSM-Tree storage optimized for vector workloads.

  • 🔒 ACID Transactions


    Full transactional guarantees across SQL, vector, and KV operations. MVCC with Snapshot Isolation for concurrent access.

  • 📡 Chirps Mesh Network


    QUIC-based cluster communication with SWIM protocol for membership. Raft-ready transport with priority streams.


📦 Any Scale, One Engine

Start small, scale infinitely—without changing your data model or application code.

Mode Use Case Architecture
🌐 WASM Viewer Browser Data Exploration Read-only viewer with IndexedDB caching
📦 Embedded Mobile Apps, Local RAG, Edge Devices Single Binary / Library (like SQLite)
🖥 Single-Node Microservices, Dev/Test Environments Standalone Server (HTTP/gRPC)
🔄 Replicated High Availability, Read-heavy Workloads Primary-Replica with automatic failover
🌎 Distributed Large-Scale Production Multi-Raft Cluster (Range Sharding)

Learn more about deployment modes


💻 SQL + Vector in Action

-- Create a table with vector column
CREATE TABLE knowledge_chunks (
    id INTEGER PRIMARY KEY,
    content TEXT,
    embedding VECTOR(1536)
);

-- Hybrid Search: SQL Filter + Vector Similarity
SELECT id, content,
       vector_similarity(embedding, ?) AS score
FROM knowledge_chunks
ORDER BY score DESC
LIMIT 5;
-- Create HNSW index for fast similarity search
CREATE INDEX idx_embedding ON knowledge_chunks
USING HNSW (embedding)
WITH (m = 16, ef_construction = 200);

-- Search with HNSW acceleration
SELECT id, content
FROM knowledge_chunks
ORDER BY vector_similarity(embedding, ?) DESC
LIMIT 10;
use alopex_embedded::Database;

let db = Database::open("./my_data")?;

// Execute SQL
let results = db.execute_sql(
    "SELECT * FROM docs WHERE vector_similarity(embedding, ?) > 0.8",
    &[query_vector]
)?;

// HNSW search
let similar = db.search_hnsw("docs", &query_vector, 10)?;

View SQL + Vector guide


🚧 Roadmap

gantt
    title Alopex DB Development Timeline
    dateFormat  YYYY-MM
    axisFormat  %Y-%m

    section Foundation
    v0.1-v0.2 Core          :done, 2025-01, 2025-10
    v0.3 SQL + HNSW         :done, 2025-10, 2025-12

    section Python & Server
    v0.3.3 Python Wrapper   :done, 2025-12, 2025-12
    v0.4 Server + DataFrame :done, 2026-01, 2026-01
    v0.5 GROUP BY + DataFrame P1 :done, 2026-01, 2026-01

    section Distributed
    v0.6 SQL JOIN + Nim Parser :done, 2026-07, 2026-07
    v0.7 Cluster-aware      :done, 2026-07, 2026-07
    v0.8 Metadata Raft      :2026-10, 2026-12
    v1.0 GA                 :milestone, 2027-03, 0d

What's Complete

Version Features Status
v0.1-v0.2 Embedded KV, WAL, MVCC, Vector (Flat), Columnar ✅ Complete
v0.3 SQL Frontend, HNSW Index, Embedded Integration ✅ crates.io Published
v0.3.3 Python Wrapper (alopex-py), CLI ✅ PyPI Published
v0.4.0 Server Mode, DataFrame API, Async/Stream ✅ crates.io Published
v0.5.0 GROUP BY/Aggregation, DataFrame P1 (JOIN/sort/null) ✅ crates.io Published
v0.6.0 SQL JOIN & Subqueries, Nim FFI SQL Parser ✅ crates.io Published
v0.7.x alopex-cluster, Mode-Parity Suite, gRPC Cluster Admin ✅ v0.7.6 Published
Chirps v0.5 Gossip, SWIM, Membership, Raft Consensus API ✅ Complete

What's Next

Version Features Target
v0.8 Metadata Raft, MultiRaftManager Integration Q4 2026
v0.9 Multi-Raft (Range Partitioning), CRDT Q1 2027
v1.0 General Availability 2027

View detailed roadmap


🐍 Python Support (Available Now)

import alopex

# Open database
db = alopex.Database.open("./my_data")

# Execute SQL
results = db.execute_sql(
    "SELECT * FROM docs WHERE category = ?",
    ["science"]
)

# Vector search
similar = db.search_hnsw("docs", query_embedding, k=10)
import alopex

# Polars-compatible DataFrame API
df = alopex.read_parquet("data.parquet")

result = (
    df.lazy()
    .filter(alopex.col("score") > 0.5)
    .select(["id", "content", "embedding"])
    .collect()
)

Python Guide


🔗 Chirps — Cluster Foundation

crates.io

Alopex Chirps is the control plane for distributed Alopex DB clusters.

  • 📡 SWIM Protocol


    Failure detection via ping/ack/ping-req with configurable timeouts. Scalable membership management.

  • ⚡ QUIC Transport


    TLS 1.3, 0-RTT resumption, multiplexed streams. Priority channels for Raft consensus.

  • ✉ Raft Consensus


    Raft-ready transport with StateMachine/RaftStorage traits. WAL-based persistent storage.

Learn about Chirps architecture


📈 Skulk — Time-Series Companion

crates.io

Alopex Skulk is the time-series member of the family — an embedded storage and ingest core for monitoring, IoT, and observability workloads. v0.3.0 replaced the storage engine with Arrow + Parquet columnar, in a 3.7 MB pure-Rust binary.

  • 📦 Columnar Compression


    Parquet with pure-Rust BROTLI — 7.1× smaller than the previous Gorilla format on repeated-value workloads. No C toolchain, no *-sys crate.

  • 📥 Three Ingest Protocols


    InfluxDB Line Protocol, Prometheus Remote Write, and JSON — point your existing agents at it without changing what they emit.

  • 🛡 Durable by Default


    Writes are acknowledged only after the WAL. Atomic file publication, torn-tail recovery, hourly partitions, and persisted retention policies.

Query execution (PromQL, SQL-TS) arrives in v0.4; HTTP serving in v0.6.

Learn about Skulk · Quick start


📄 Trail — For Logs, Audit Trails, and Events

Write first. The schema binds when you read.

Application logs, audit trails, webhook payloads — the things your system emits when something happens. They arrive with fields nobody declared, sometimes without a usable timestamp, and occasionally with a field that was an integer last week and a string today.

Nobody updates a log line. Alopex DB is transactional — built for rows you change, and strict about types because of it. Skulk is append-only like Trail, but built for numeric series on a schedule. Logs are neither, and that gap is what Trail is for — the newest design in the family.

  • ➕ Columns Appear On Arrival


    A new attribute creates a column; earlier rows read back as null. No ALTER TABLE, no migration, no coordination.

  • 🔀 Type Changes Don't Stop Ingestion


    When status goes from 200 to "upstream_timeout", both are stored and reads coalesce them. Your pipeline does not fail at 3am.

  • 🏗 Proven Foundation


    Reuses the durability machinery already running in Skulk — WAL recovery, atomic publication, manifest rotation, single-writer locking.

Trail is being designed in the open. The API is not frozen, so what you need can still change it.

See the preview · Read the concept


🔭 Alopex OTel — Storage and Dashboards, One Product

OpenTelemetry from embedded to cluster.

Observing one application normally means deploying a Collector, Prometheus, Tempo, Loki, and Grafana — five systems, three storage engines, three query languages. Alopex OTel is one system: ingestion, storage, and the dashboard ship together, and that whole thing runs from a single embedded process to a distributed cluster.

  • The Dashboard Ships With It


    No second server to deploy, no data source to point at anything. It reads its own storage — so even an embedded deployment comes with a UI.

  • Same Screen at Every Size


    A dashboard built on your laptop works on a twenty-node cluster, and the reverse. The screen, API, and query language don't change with scale.

  • Time Series or Events


    Metrics arrive on a schedule, so they go to Skulk. Spans and logs arrive when something happens, so they go to Trail. Right storage per signal — presented as one database.

  • Not a Walled Garden


    Speaks the Prometheus query API, so Grafana's built-in data source connects with no plugin — and existing Prometheus dashboards just work.

Alopex OTel is a published design. The metrics path builds on what Skulk ships today; traces and logs follow Trail.

Read the concept


🎨 Alopex Data UI — One Interface for Data Apps

One interface, wherever the data moves. Alopex Data UI is the newest member of the family: a consistent UI model for data applications. Adapters translate schema, queries, filters, selections, and editable records into one DataSource contract, so forms, grids, charts, graphs, and maps evolve as one coherent system — whether data arrives from Alopex DB, DuckDB, an API, or a file.

Currently in early development — the concept and component model are published on the project site.

Visit Alopex Data UI View on GitHub


🏢 Alopex Enterprise — Beyond OSS

The Alopex platform is not OSS-only. Alopex Enterprise — commercial middleware built on the Alopex OSS foundation — is currently in design:

  • 🔒 Security Suite — physical & logical storage encryption (AES-GCM, XChaCha20), identity with JWT / OIDC / RBAC
  • 🔎 Unified Query Model — one engine for SQL / AQL / PromQL, with Enterprise Search (full-text, vector, aggregation)
  • 📈 Observe (SRE) — SLO engine, error budgets, and automated actions
  • ⚙ Infrastructure Packages — distributed config store (etcd/ZK compatible), service discovery + internal DNS

Design phase — no fixed delivery dates yet. Interested in early conversations? Get in touch.


🤝 Join the Pack

Alopex DB is open-source under the Apache 2.0 License.

We welcome contributions from engineers passionate about Rust, Distributed Systems, and Vector Search.

Contributing Guide GitHub Discussions