LAMINARDB: STREAMING DATA PLATFORM.

The open-source distributed SQL engine for millisecond-latency streaming and real-time state management.

$ cargo add laminar-db copy
$ pip install laminardb copy
4.24ns
Tumbling Window
235.9M/s
Window Throughput
Low
Hot-Path Overhead

Built for High-Performance Streaming

Evaluate window functions, temporal joins, and custom state aggregations continuously as event data streams in.

MILLISECOND STATEFUL PROCESSING

Execute window functions and session aggregations on a latency-focused, memory-accounted compute path.

DISTRIBUTED MPP SCALING

Scale bounded interval joins across clusters with canonical vnode partitioning and lease-fenced coordination.

ON-DEMAND LOOKUP SOURCES

Query slowly-changing reference tables (Postgres, CDC, Delta Lake, Iceberg) directly with in-memory caching (S3-FIFO eviction) and pushdown predicates.

STATEFUL STREAM JOINS

Correlate independent event pipelines using bounded interval joins.

EXACTLY-ONCE GUARANTEES

Achieve transactional safety and partition-tolerant stream alignment via Chandy-Lamport barrier checkpoints and two-phase commits.

LIVE MATERIALIZED VIEWS

Query active streaming state instantly with standard SQL, using automatically updated materialized views that act like regular tables.

Engineered for Low-Overhead Stream Processing

LaminarDB runs SQL queries over event streams. Aggregations, joins, and windows are evaluated continuously in a dedicated thread topology.

Latency-focused compute. Bounded batches, managed state accounting, and lock-free channels reduce hot-path overhead.

Connector-gated exactly-once delivery. Barrier checkpoints align source offsets, state, and coordinated sink publication. The current cluster candidate is Kafka input to direct S3/S3A append-mode Delta Lake.

Compute Thread Ring 0

Dedicated tokio runtime · Zero allocations on data path

StreamingCoordinator Operators In-Memory State DataFusion Exec
Crossfire MPSC Channels
I/O Runtime Ring 1

Main tokio runtime · Asynchronous boundary

Source Tasks Sink Tasks Checkpoint Coordinator Recovery
Bounded Channels
Control Plane Ring 2

No latency requirements · Cluster coordination

REST API WebSocket Console UI Cluster Coordination Metrics

Write Streaming SQL

Add the dependency to your project and execute continuous queries using standard SQL.

Unified Connectivity

Build end-to-end streaming architectures. All connectors are compiled conditionally via Cargo feature gates.

Apache Kafka Stable
Source + Sink
--features kafka
NATS Stable
Source + Sink (JetStream)
--features nats
PostgreSQL CDC Preview
Source (pgoutput)
--features postgres-cdc
PostgreSQL Sink Stable
Sink (COPY/UPSERT)
--features postgres-sink
MongoDB CDC Preview
Source + Sink
--features mongodb-cdc
Delta Lake Stable
Source + Sink
--features delta-lake
Apache Iceberg Stable
Source + Sink
--features iceberg
OpenTelemetry Stable
Source (OTLP/gRPC)
--features otel
WebSocket Stable
Source + Sink
--features websocket
File Loader Stable
Source + Sink (Parquet/JSON)
--features files

LaminarDB Web Console

Inspect and manage your streaming SQL nodes. Author queries, inspect schemas, and watch data flow through your pipeline in real time.

  • Interactive SQL Worksheet: Execute streaming DDL/DML with live tailing subscription panels.
  • Live Lineage DAGs: Introspect query topologies and watch throughput rates from sources to sinks.
  • Catalog Browser: Browse active streams, materialized views, schemas, and connector configurations.
  • Cluster Health Heatmaps: Monitor coordinator leader status, active node gossip, and partition leases.
Open Web Console
LaminarDB Console
Connected
-- Authoring continuous stream join
SELECT symbol, price, volume
FROM trades INNER JOIN quotes
ON trades.symbol = quotes.symbol AND quotes.ts BETWEEN trades.ts AND trades.ts + INTERVAL '5' SECOND
trades
Source
24.5k eps
vwap_sink
Sink
sentiment.sql

Native Inline AI Inference

Call machine learning and AI models directly within your continuous SQL statements.

Off the hot path. The streaming execution pipeline never blocks on model inference. The operator queries the internal state cache inline, routing misses to asynchronous background workers.

Dual inference backend. Configure models to point either to local, in-process ONNX Runtime encoders (highly efficient for classification and embeddings) or to remote LLMs via OpenAI-compatible endpoints.

Proven Performance

Criterion benchmark metrics recorded on single-node consumer-grade hardware. Dedicated server environments achieve higher rates.

4.24ns
Tumbling Window Assignment
235.9M/s
Window Assignment Throughput
383ns
Hot State Update Latency
2.65M/s
Sustained Aggregation Rate
451.1µs
Full State Recovery (1MB)
40.27ms
Checkpoint Save (1MB state)

Implementation Status

Current development milestone: 0.25.0 (pre-1.0 release).

Engine & SQL

  • Streaming operator graph evaluation (tumble, sliding, hopping, session windows).
  • Bounded interval joins; lookup and temporal joins in local mode.
  • Dynamic vnode partitioning and in-memory lookup indexes.
  • Chandy-Lamport barrier checkpointing (2-phase commit).
  • Multi-node coordination, gossip discovery, durable leader leases, and CAS-published assignments.

Operations & CLI

  • Conditionally-compiled source/sink connector plugins (including Kafka, CDC, Delta Lake, Iceberg, NATS).
  • Checkpoint snapshot archival to local FS, S3, Azure Blob, or GCS.
  • Standalone server binary with REST health check endpoints.
  • Dynamic pipeline hot-reloads of configuration parameters.
  • Console UI Vite application for DAG pipeline visualization.

Frequently Asked Questions

Common questions regarding LaminarDB features, internals, and operations.

What is LaminarDB?

LaminarDB is an open-source streaming SQL engine written in Rust. It runs continuous SQL queries over event streams using Apache Arrow and DataFusion. It can be embedded in Rust or Python applications or run as a standalone server.

How fast is LaminarDB?

LaminarDB targets sub-microsecond state lookups (under 500 nanoseconds) and processes over 500,000 events per core per second. Criterion benchmarks on an AMD Ryzen AI 7 350 laptop measured state lookups in 10 to 16 nanoseconds and throughput of 1.1 to 1.46 million events per second per core.

What connectors does LaminarDB support?

LaminarDB ships with sources and sinks for Apache Kafka, NATS, PostgreSQL CDC, MongoDB CDC, Delta Lake, Apache Iceberg, OpenTelemetry OTLP, WebSocket, and rolling file formats (CSV, JSON, Parquet). All connectors are feature-gated so you only compile what you use.

Is LaminarDB production-ready?

LaminarDB is pre-1.0. Distributed-state production certification is pending the full single-node and cluster ALO/EO soak matrix.

Can I use LaminarDB from Python?

Yes. Install the Python package with pip install laminardb. It exposes the same streaming SQL engine as the Rust crate, with a Python-native API for pushing events and subscribing to results.

What SQL features does LaminarDB support?

LaminarDB supports standard SQL through DataFusion plus streaming extensions: tumbling, sliding, hopping, and session windows; bounded interval, temporal, and lookup joins; EMIT clauses (ON WATERMARK, ON WINDOW CLOSE, PERIODICALLY, CHANGES, FINAL); watermarks with ALLOW LATENESS; and late data routing via LATE DATA TO.

How does LaminarDB handle exactly-once delivery?

Exactly-once is connector-gated. Barrier checkpoints align source offsets, operator state, and coordinated sink publication; the current cluster candidate is Kafka input to direct S3/S3A append-mode Delta Lake.

Does LaminarDB require a JVM?

No. LaminarDB is written in Rust and ships as a native binary. It has no JVM or other runtime dependencies beyond the operating system.

Is LaminarDB open source?

Yes. LaminarDB is licensed under Apache 2.0 and the source is hosted at github.com/laminardb/laminardb.

Contributing to LaminarDB

LaminarDB is Apache 2.0 licensed and welcomes community contributions. Check out our guides to get started with local compilation.