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.
users.find({ age: 18 })$ users.find({ age: 18 })[ { name: "Aarav", age: 18, plan: "pro" }]Product status
V2 is live and ready.
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-alphaBuild 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
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 successfullyClient ready to useLioranDB 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.
Architecture direction
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
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
π Write Performance Logs
23K-25K writes/sec with stable WAL group commit
π Read Performance Logs
Low millisecond latency with high parallel throughput
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 logsDeveloped 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
Keep product data close to the app runtime.
AI applications
Collections
runs, vectors_meta, prompts
Log structured model activity without extra services.
CRM systems
Collections
contacts, notes, pipelines
Iterate on schema as workflows evolve.
Internal developer tools
Collections
jobs, tokens, audit
Stay self-hosted for sensitive ops tooling.
APIs and backend services
Collections
sessions, webhooks, caches
Ship lightweight persistence directly in Node.js.
Local-first applications
Collections
drafts, sync_queue, profiles
Keep data available close to the user.
Prototypes growing into real products
Collections
leads, events, config
Start simple without throwing away the model later.
Data-intensive startup workloads
Collections
orders, metrics, jobs
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",});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.
Direct visibility into storage and performance
Inspect directories, snapshots, query paths and benchmark intent without vendor lock-in or hidden service behavior.
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
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.β
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.
GitHub activity panel
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