LioranDB V2 pre-alpha launched on 16 August 2026. Alpha coming 23 October 2026

India's developer-first document database.

High-performance document database developed in Rust.

LioranDB V2 is a developer-first document database with Rust performance, Docker deployment, and APIs designed for startups, SaaS platforms, APIs and data-intensive applications. Pre-alpha is live now.

View source on GitHub
Developed in IndiaSelf-hostableDeveloper-firstMongoDB-style APIRust-powered V21 year old
V2
Queryusers collection
users.find({ age: 18 })
Terminal
$ users.find({ age: 18 })
[
{
name: "Aarav",
age: 18,
plan: "pro"
}
]

Product status

V2 is live and ready.

V2 Pre-alphaLaunched
Engine
Rust
Released
16 August 2026
Alpha Launch
23 October 2026
Read the docs

Get Started

Solo Docker Quickstart

Spin up a single local LioranDB instance running directly from Docker. Everything you need to start building.

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

Build Path

Step 1

Start Docker container

Step 2

Install CLI

Step 3

Login as admin

Step 4

Install driver

Step 5

Write your first query

Step 6

Deploy to production

First database
import { LioranDBClient } from "@liorandb/driver";
type User = {
_id?: string;
email: string;
active: boolean;
age: number;
};
const password = encodeURIComponent("Q7m!Z2x@L9p#R4vK");
const uri = `liorandb://admin:${password}@127.0.0.1:27018/default`;
const client = await LioranDBClient.connect(uri);
try {
const db = client.db("default");
const users = db.collection<User>("users");
const insertResult = await users.insertOne({
email: "ada@example.com",
active: true,
age: 31,
});
const user = await users.findOne({email: "ada@example.com"});
const activeUsers = await users.find({active: true}).limit(10).toArray();
console.log({
insertedId: insertResult.insertedId,
user,
activeCount: activeUsers.length,
});
} finally {
await client.close();
}
{
"insertedId": "01K2EXAMPLE",
"user": {
"_id": "01K2EXAMPLE",
"email": "ada@example.com",
"active": true,
"age": 31
},
"activeCount": 1
}

Developer API

Build with the TypeScript driver.

Connect, query, index, and aggregate with familiar MongoDB-style operations. gRPC and REST APIs are also available.

Operations

MongoDB-style workflow

Connect

import { LioranDBClient } from "@liorandb/driver";
const client = await LioranDBClient.connect(
"liorandb://admin:password@127.0.0.1:27018/default"
);

Result

// Connected successfully
Client ready to use
Pre-alpha Launched

LioranDB V2 is built in Rust. Now you can code it.

V2 is a high-performance storage engine designed for larger datasets, predictable latency, transactional workloads and production-focused observability. Docker deployment is ready. Alpha launch coming on 23 October 2026.

Rust enginePre-alpha β€’ 16 August 2026Not production-ready
Join the pre-alpha community

Architecture direction

ApplicationsClient requests
LioranDB Query LayerDocument API
Transactions + MVCCSnapshot isolation
Primary B+ TreePrimary pages
WAL + CheckpointsDurability layer
Page CacheHot reads
Persistent StorageOn-disk state
Secondary Index LSM
Text Inverted Index
Compaction
Recovery
Metrics
Encryption

V2 focus

Rust storage engine

V2 focus

MVCC transactions

V2 focus

WAL and recovery

V2 focus

B+ tree primary storage

V2 focus

LSM secondary indexes

V2 focus

Inverted text search

Internal Benchmarking

Built under pressure, not inside a toy demo.

Development testing has reached datasets approaching 100 million documents, with sustained write throughput of 23-25K writes per second and 35K combined operations per second in mixed workloads.

Representative development workload

Internal development benchmarks

Visual demo

Writes/sec

25,140

Reads/sec

34,987

p50 latency

4.3ms

p99 latency

31.7ms

Dataset size

100M docs

Index health

98.4%

Hardware

  • Intel Core Ultra 7 (14th Generation)
  • 16 Physical Cores
  • 24 GB DDR5 @ 5600 MT/s
  • NVMe PCIe SSD

Configuration

  • Nodes: 4
  • Partitions: 8
  • Threads: 32
  • Batch: 256

Write Performance

23K to 25K writes/sec

Sustained write throughput across millions of documents with stable WAL group commit behavior.

Recovery & Durability

Crash Recovery

WAL replay, metadata consistency, and duplicate prevention validated through repeated crash cycles.

Features Tested

Secondary Indexes
Full-Text Search
Write-Ahead Log (WAL)
MVCC
Parallel Read & Write Execution

πŸ“Š Write Performance Logs

23K-25K writes/sec with stable WAL group commit

πŸ“– Read Performance Logs

Low millisecond latency with high parallel throughput

πŸ”„ Mixed Workload (Soak Test)

~10K writes/sec + ~25K reads/sec = ~35K ops/sec

soak_10m.txt

πŸ›‘οΈ Crash Recovery Test

WAL replay & durability validation

crash_test_1m_9c.txt

All raw benchmark logs are publicly available for inspection and validation. These results demonstrate current pre-alpha capabilities rather than production guarantees. Dedicated server hardware is expected to deliver significantly higher throughput than consumer laptop testing.

View all benchmark logs

Developed in India

Indian data deserves Indian infrastructure.

India’s software ecosystem should not depend entirely on infrastructure designed, owned and controlled elsewhere. LioranDB is one step toward a stronger domestic developer platform ecosystem.

Developed in India. Built for the world.

LioranDB is independently developed and is not presented as an official government product or initiative.

Data sovereignty

Give teams the option to keep application data on infrastructure they control, including infrastructure located in India.

Infrastructure independence

Reduce dependency on a small number of foreign database and cloud vendors.

Built for Indian developers

Simple deployment, transparent architecture, founder-led support and pricing designed with Indian startups in mind.

Use Cases

Designed for products that cannot afford database drama.

From internal tools to SaaS backends, the page maps real collection names, query shapes and operating benefits instead of generic market segments.

SaaS platforms

Collections

tenants, billing, feature_flags

{ tenantId: 'acme' }

Keep product data close to the app runtime.

AI applications

Collections

runs, vectors_meta, prompts

{ model: 'custom' }

Log structured model activity without extra services.

CRM systems

Collections

contacts, notes, pipelines

{ ownerId: 'sales-1' }

Iterate on schema as workflows evolve.

Internal developer tools

Collections

jobs, tokens, audit

{ status: 'queued' }

Stay self-hosted for sensitive ops tooling.

APIs and backend services

Collections

sessions, webhooks, caches

{ region: 'IN' }

Ship lightweight persistence directly in Node.js.

Local-first applications

Collections

drafts, sync_queue, profiles

{ device: 'laptop' }

Keep data available close to the user.

Prototypes growing into real products

Collections

leads, events, config

{ stage: 'seed' }

Start simple without throwing away the model later.

Data-intensive startup workloads

Collections

orders, metrics, jobs

{ qty: { $gte: 100 } }

Track the path toward larger Rust-powered workloads.

Developer Experience

Familiar enough to start. Deep enough to grow.

The experience starts with MongoDB-style syntax, stays self-hostable by default, and keeps storage plus performance visible to the engineers running it.

MongoDB-style syntax

const users = db.collection("users");
await users.insertOne({
email: "dev@startup.in",
plan: "pro",
});
const result = await users.find({
plan: "pro",
});
TypeScriptNode.jsJSONRust V2Self-hostedNo vendor lock-in

Self-hostable by default

Run the database inside your Node.js process, keep files under your project, and control deployment instead of handing everything to a managed black box.

TypeScriptNode.jsJSONRust V2Self-hostedNo vendor lock-in

Direct visibility into storage and performance

Inspect directories, snapshots, query paths and benchmark intent without vendor lock-in or hidden service behavior.

TypeScriptNode.jsJSONRust V2Self-hostedNo vendor lock-in

Roadmap

Shipping the database one hard problem at a time.

The roadmap separates what is live, what is being actively built, and what the August 16, 2026 pre-alpha is actually meant to validate.

V2 pre-alpha β€’ Launched

  • Rust storage engine
  • B+ tree and MVCC
  • LSM secondary indexes
  • Text inverted index
  • Crash recovery
  • Docker deployment

V2 Alpha β€’ 23 October 2026

  • Larger dataset testing
  • Driver ecosystem
  • gRPC and REST APIs
  • Managed deployment templates
  • Production hardening
  • Performance optimization

V2 Future

  • Replication and clustering
  • Sharding and partitioning
  • Advanced monitoring
  • Backup and restore
  • Enterprise features
  • Community contributions
Swaraj Puppalwar, Founder and CTO of Lioran Group
building

Founder

Swaraj Puppalwar

Founder & CTO, Lioran Group

Swaraj Puppalwar is an 18-year-old full-stack developer, database engineer and founder building developer infrastructure from India. He began programming at 11 and is leading the architecture and development of LioranDB.

β€œI don't want India to only consume developer infrastructure. I want us to build it.”
RustTypeScriptStorage enginesDatabasesDistributed systemsDeveloper infrastructure

swaraj@lioran:~/liorandb$ building_indias_infra

Open Development

Watch it being built. Break it before production does.

LioranDB is being developed in the open with feedback from backend engineers, founders and database enthusiasts.

FAQ

Straight answers for evaluating the product.

The page keeps the line between V1, V2, development targets and public availability explicit.

LioranDB V2 is a developer-first document database developed in India. It is a Rust-powered engine launched as pre-alpha on 16 August 2026.

Now you can code it. Pre-alpha is live.

Get started with the Docker Quickstart. Read the docs. Join the community helping shape the production release.

From India to the global developer community.

$ npm install @liorandb/driver
βœ“ package installed
$ liorandb start
βœ“ database ready