Document storage,
built for engineers.
A Rust-powered document database designed for backend applications, practical operations, and transparent performance engineering. Official SDK support currently covers JavaScript and TypeScript.
Self-hostable · V2 pre-alpha · APIs and deployment details live in the maintained docs
$ docker run -d --name liorandb -p 27018:27018 -p 27019:27019 -p 27201:27201 -v ldb-data:/var/lib/liorandb/data liorandb/liorandb:pre-alpha
$
$ npm install @liorandb/driver
$ node index.tsMeasured, with context
A benchmark preview you can interrogate.
Peak raw writes
300K
docs/sec · observed local peak
10M completion
36s
end-to-end insertion time
Read throughput
35K
reads/sec · query shape unrecorded
Memory observed
3.5 GiB
LioranDB only; not a comparison
user-reported development measurement; raw artifacts for the matched comparison are pending publication. These numbers describe one local development workload and should not be read as universal production performance.
Engine surface
A practical storage layer for backend work.
LioranDB keeps the developer path close to the engine: a familiar document API, a Rust storage core, and deployment choices that are explicit about what is ready today.
Document API
Collections, familiar query operators, updates, pagination, and aggregation for application data.
Storage engine
A Rust-based engine with WAL and checkpoint paths exposed as part of the V2 architecture direction.
Search and indexing
Secondary and text indexing are available in documented V2 test paths; workload-specific behavior matters.
Operations
Run locally with Docker, connect through the dashboard, or review managed deployment options.
Transport
The official docs describe JavaScript and TypeScript SDK, gRPC, and REST access paths. Verify endpoint details against the docs for your version.
Recovery
WAL replay and recovery are part of the documented V2 test surface; durability semantics depend on the configured path.
Developer path
Start local. Keep the escape hatch.
The first step is a local Docker instance and a documented driver. Managed infrastructure, Studio, and the source repositories are separate paths you can evaluate when the workload earns it.
import { LioranDBClient } from "@liorandb/driver";
const client = await LioranDBClient.connect(
process.env.LIORANDB_URI ??
"liorandb://admin:password@127.0.0.1:27018/default",
);
try {
const users = client.db("default").collection("users");
await users.insertOne({ email: "ada@example.com", active: true, age: 31 });
const user = await users.findOne({ email: "ada@example.com" });
console.log(user);
} finally {
await client.close();
}Architecture
Know where the request goes.
Follow the path from client request to persistent state. Implementation status and caveats are called out on the architecture page.
Explore the architectureClient request
JavaScript / TypeScript SDK, REST, or gRPC
Document API
Collections, filters, updates, and query execution
Storage paths
Primary storage plus configured secondary/text indexes
Durability
WAL and checkpoint lifecycle
Persistent state
Local or managed deployment storage
Choose managed
Compare shared and dedicated offerings without confusing them with local benchmarks.
Review cloud