Ask past questions. Get live answers. Same syntax.
A single, consistent query language works identically whether you're looking at historical data or watching live events. No context switching. No learning multiple systems.
Turn any query into a live stream instantly.
Append .listen() to any query and you'll get a complete historical snapshot followed by a continuous stream of matching records as they arrive.
Transform data on the fly without writing code.
Chain together filters, transformations, aggregations, and sorting steps to process data as it flows through. Each step is a simple building block.
Watch a stream live from your terminal or API.
Stream records directly to your screen as they arrive. Perfect for debugging, monitoring, or building real-time dashboards.
Store vector embeddings directly alongside your data.
Liven stores embeddings natively alongside your data, keeping your data and its semantic representations together.
Search by meaning, not just keywords.
Find records that are conceptually similar to your query. Perfect for recommendation engines, fraud detection, and intelligent search.
Fast vector transmission without overhead.
Vector data moves efficiently between client and server with no unnecessary serialization, keeping similarity searches snappy.
Run inside your application with zero network latency.
Integrate the database directly into your application as a library. No network hops, no external dependencies — just fast, local data access.
Deploy as a network database with connection pooling.
Run Liven as a dedicated server, handling thousands of concurrent connections with built-in connection management.
Visual dashboard and JSON API out of the box.
A fully-featured web dashboard provides a query console, data visualization, and REST APIs for any programming language.
Query, monitor, and debug without writing code.
A rich terminal interface with syntax highlighting, real-time tail views, and full authentication support.
Existing data is never overwritten — crash-safe by design.
All writes go to the end of the log. Your existing data stays untouched. If a crash happens, recovery is automatic and complete.
Durable by default. Fast by design. No tradeoffs.
Writes are grouped together and safely stored on disk before you get a response. You never have to choose between safety and speed.
Corruption detected immediately, not silently.
Every piece of data is verified when written and when read. If something's wrong, you'll know right away — no silent corruption.
Reclaim space automatically without manual intervention.
A background process consolidates data and reclaims space from deleted records. Set it and forget it.
Express complex data flows in a single line.
from("events") | filter(amount > 100) | group(status, count()) | sort(timestamp) | limit(50) — everything in one clear expression.
Aggregate and detect patterns over time.
Time-windowed aggregations, stream joins within time boundaries, and pattern detection for sequences of related events.
Join, enrich, and chain data across different streams.
Pull in data from other streams, correlate events across time, or follow chains of relationships — all within a single query.
Find records by key instantly — no full scans.
Point lookups and key-based filters resolve directly to the right record on disk, no matter how much data you have.
Time-range queries are fast, even on huge datasets.
Filter by timestamp ranges using a specialized index. You get results quickly without scanning everything.
Simple, secure access control.
Authenticate with symmetric keys that can be generated, assigned roles, and revoked at any time — no server restart required.
Production-grade encrypted connections.
Two-way certificate authentication ensures only trusted clients can connect. Ideal for zero-trust network architectures.
Read, write, and admin permissions per key.
Assign specific capabilities to each authentication key. Some keys can only read. Others can write. Only admins can drop streams or trigger maintenance.
Prevent overload during traffic spikes.
Liven gracefully queues new connections when busy instead of crashing. Your service stays responsive under load.
Thousands of simultaneous queries without slowdown.
Read operations don't block each other. Many queries can run at the same time without waiting in line.
Consistent performance with no unexpected pauses.
Critical paths reuse memory instead of constantly allocating new space. No garbage collection, no unexpected pauses.
Writes never block reads, reads never block writes.
The write path runs independently, so heavy write loads don't impact query performance. Both happen simultaneously.
LIMIT stops early, not after scanning everything.
When you only need the first N results, Liven stops reading as soon as it has them. No wasted I/O.
Know your resource consumption instantly.
See memory usage, disk space, segment counts, and per-stream statistics at a glance. Spot growing streams before they cause problems.
See how your query will run before you execute it.
Get a complete execution plan showing which indexes will be used, how many records will be scanned, and where potential bottlenecks might appear.
Debug slow queries in production.
Detailed operation logs with query type, stream name, and duration — perfect for identifying bottlenecks.
Spot growing streams before they cause problems.
See record counts and storage size per stream at a glance. Identify which streams are growing unexpectedly and where to focus optimization efforts.
Reach Liven from anywhere, in any language.
Native TCP protocol for high-performance applications. WebSocket gateway for browser-based apps. REST API for simple JSON integration.
Use Liven from any programming language.
The wire protocol and REST API work with any language that speaks TCP or HTTP. No special client libraries required.
Configure programmatically with sensible defaults.
When embedding Liven, configuration is handled in code with safe defaults. No configuration files to manage.
Download and run. Nothing to install.
A single executable file with no runtime dependencies. Install via command line, package managers, or Docker. It just works.
Environment variables for modern deployments.
Configure everything through environment variables. Perfect for containers, orchestration platforms, and twelve-factor apps.
Everything from your terminal.
Start, stop, query, tail, import, export, and more — all from the command line. A full terminal interface for advanced users.
Secrets never accidentally committed to version control.
Master keys live in a separate secure file, not in configuration. Set an environment variable in production and the key file is never created.
Every stage is a composable building block. Chain them together to build complex data flows from simple parts.