FluxDB — The Time-Series Database Developers Actually Love

Core Capabilities

Everything you need, nothing you don't

Built with zero external database dependencies. Every subsystem hand-crafted for time-series workloads.

⚡

LSM-Inspired Storage

Write-Ahead Log → MemTable → immutable Segment files. Atomic flushes via rename. CRC32 integrity on every segment.

🗜️

Multi-Layer Compression

Delta+zigzag+varint for timestamps. Gorilla XOR bit-packing for floats. RLE for repeated values. Auto-selects best codec per column.

🔍

FluxQL Query Language

SQL-like syntax: SELECT, FROM, WHERE, GROUP BY, EVERY, ORDER BY, LIMIT, OFFSET. 9 aggregate functions including percentile(n).

🔒

Thread-Safe Engine

Arc<Engine> + parking_lot RwLock. Concurrent reads never block writes. Lock-free hot paths via atomic counters.

🌐

HTTP API + Prometheus

axum 0.7 server with JSON write, FluxQL query, series listing, health checks, and Prometheus /metrics exposition.

🐍

Python Bindings

PyO3-based extension module with abi3-py38 stable ABI. Works with Python 3.8 through 3.14+. Full type annotations.

⏱️

Retention Policies

Multi-tier downsampling with background expiry worker. Configurable raw duration, resolution buckets, and total retention windows.

💾

Crash Recovery

WAL replay on startup. Generation-based rotation with fsync. Binary format with length-prefix framing and CRC32 checksums.

📦

Zero External DB Deps

No InfluxDB. No RocksDB. No PostgreSQL. Pure Rust storage engine with hand-crafted segment files and sparse index.

Architecture

Built for modern hardware

Every layer of the stack is designed to minimize allocations and maximize cache locality.

Client Layer

HTTP API
axum 0.7

CLI
clap 4

Python
PyO3

Rust Embed
DB::write()

↓

Query Engine

Lexer
FluxQL tokens

Parser
SelectStatement AST

Planner
QueryPlan

Executor
Aggregates

↓

Storage Engine

WAL
CRC32 + fsync

MemTable
BTreeMap + RwLock

Segment Index
Sparse index

Segment Files
FLUXDB01 format

↓

Compression

Delta+Zigzag
timestamps

Gorilla XOR
float values

RLE
repeated vals

Raw f64
fallback

Quick Start

Up and running in 60 seconds

# Pull and run
docker pull ghcr.io/vignesh2027/fluxdb:latest
docker run -p 8086:8086 -v fluxdb-data:/var/lib/fluxdb ghcr.io/vignesh2027/fluxdb

# Write a data point
curl -X POST http://localhost:8086/write \
  -H 'Content-Type: application/json' \
  -d '{"measurement":"cpu","tags":{"host":"web01"},"fields":{"usage":72.4}}'

# Query it back
curl -X POST http://localhost:8086/query \
  -H 'Content-Type: application/json' \
  -d '{"q":"SELECT avg(usage) FROM cpu WHERE host = '\''web01'\''"}'

# Install CLI
cargo install --git https://github.com/vignesh2027/-FLUXDB fluxdb-cli

# Start server
cargo run --release -p fluxdb-server

# In another terminal
fluxdb write cpu --tag host=web01 --field usage=72.4
fluxdb query "SELECT avg(usage) FROM cpu"
fluxdb bench --count 100000
fluxdb series

# Cargo.toml
[dependencies]
fluxdb-core = { git = "https://github.com/vignesh2027/-FLUXDB" }

# main.rs
use fluxdb_core::db::DB;
use fluxdb_core::query::executor::Executor;
use fluxdb_core::types::{SeriesKey, WriteEntry, ts};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let db = DB::open("./data")?;

    db.write(
        WriteEntry::new(SeriesKey::new("cpu"), ts::now())
            .with_field("usage", 72.4)
    )?;

    let exec = Executor::new(&db);
    let result = exec.execute("SELECT avg(usage) FROM cpu")?;
    println!("{:?}", result);
    Ok(())
}

# Install (requires maturin)
pip install maturin
maturin develop --manifest-path crates/fluxdb-python/Cargo.toml

# Usage
import fluxdb

db = fluxdb.PyDB("./data")

db.write(
    "cpu",
    fields={"usage": 72.4, "temp": 65.0},
    tags={"host": "web01"},
)

result = db.query("SELECT avg(usage) FROM cpu WHERE host = 'web01'")
for series in result.results:
    print(f"{series.measurement}: {series.rows[0].fields}")

print(f"Total: {result.total_rows()} rows")

Benchmarks

Performance that speaks for itself

Measured on Apple M3 Pro, 16GB RAM, NVMe SSD.

Write Throughput

FluxDB (single)

880K w/s

FluxDB (batch 1K)

2.1M w/s

InfluxDB OSS

450K w/s

TimescaleDB

280K w/s

Compression Ratio

Data Type Codec Ratio

1s-interval timestamps Delta+Varint 6.3×

Slowly drifting floats Gorilla XOR 8.1×

Constant values RLE 64×

Random floats Raw f64 1×

Query Latency (p99)

Scan 100 rows <0.1ms

Scan 10K rows 0.3ms

Aggregate 100K rows 1.2ms

Windowed avg (EVERY 5m) 0.8ms

Multi-series scan 2.1ms

FluxQL

A query language that feels right

Basic scan

SELECT value FROM cpu
WHERE time > now() - 1h
ORDER BY time DESC
LIMIT 100

Aggregation with windowing

SELECT avg(usage), max(usage)
FROM cpu
WHERE time > now() - 24h
GROUP BY host
EVERY 5m

Tag filtering

SELECT sum(bytes)
FROM network
WHERE host = 'web01'
  AND interface != 'lo'
  AND time > now() - 1h

All aggregate functions

SELECT
  avg(v), mean(v),
  sum(v), count(v),
  min(v), max(v),
  first(v), last(v),
  stddev(v),
  percentile(v)  -- defaults p99
FROM sensors

HTTP API

Simple REST interface

MethodEndpointDescription

POST /write Write JSON data point(s)

POST /write/line Write InfluxDB line protocol

POST /query Execute FluxQL query

GET /series List all series

GET /health Liveness + readiness probe

GET /metrics Prometheus exposition format

Comparison

Why FluxDB?

Feature	FluxDB	InfluxDB OSS	Prometheus	TimescaleDB
Embeddable library	✅	❌	❌	❌
Pure Rust (no CGO)	✅	✅ (Go)	✅ (Go)	❌ (C)
Custom storage engine	✅	✅	✅	❌ (uses PG)
Python bindings	✅	via HTTP only	client lib	via psycopg2
Single binary	✅	✅	✅	❌ (PG plugin)
Gorilla compression	✅	✅	✅	✅
Retention policies	✅	✅	✅	✅
Prometheus /metrics	✅	✅	native	✅

V

Vigneshwar L

Designed, architected, and built FluxDB entirely from scratch — every byte of the storage engine, compression stack, query language, HTTP server, CLI, and Python bindings. No templates. No wrappers. Pure engineering.

GitHub FluxDB Repository