Why DocLite?

Stop configuring.
Start building.

No server to install. No schema to define. No migration to run.
Just drop it in and go.

�

Query Like You Already Know

If you know SQL, you know DocLite. SELECT, INSERT, JOINs, GROUP BY, HAVING, subqueries, UNION, CASE WHEN — the syntax you're used to, with no learning curve.

🔒

Your Data Is Safe

Crash mid-write? No problem. The Write-Ahead Log recovers automatically. Every byte is CRC32 integrity-checked. ACID-compliant.

⚡

Fast Without Effort

Persistent B+ Tree indexes give you O(log n) lookups out of the box. The query planner picks the right strategy — you just write SQL.

🔗

Combine Your Data

INNER, LEFT, RIGHT JOINs with automatic strategy: Hash Join O(n+m), Index Lookup O(n·log m), or Nested Loop fallback. DocLite picks the fastest path.

📦

No Schema? No Problem.

Store nested documents, dynamic fields, mixed types, arrays. Use dot-notation for deep access: user.address.city. Native JSON insert support.

🔄

Safe Transactions

BEGIN / COMMIT / ROLLBACK with undo log. Single-writer isolation, multi-reader concurrency. Either everything succeeds, or nothing changes.

🧠

Understand What Happens

EXPLAIN shows cardinality, selectivity, and cost estimation. Need more control? Use Oracle-style hints like /*+ INDEX_LOOKUP */ to tune manually.

🖥️

Built-in Admin Panel

Lumen (Vue 3 + Tailwind) gives you a SQL editor, collection browser, schema viewer, LRU cache stats, and full SQL export — no extra tools needed.

🌍

Works With Your Stack

C shared library (cgo) with native wrappers: Python (ctypes), Node.js (ffi-napi), Java (JNA). One line to connect, one line to query.

Developer Experience

Up and running in 3 lines

Pick your language. Open a file. Start querying. It really is that simple.

              
              main.go
            
db, _ := api.Open("app.dlite")
defer db.Close()

// Insert documents
db.Exec(`INSERT INTO users VALUES (name="Alice", age=30)`)
db.Exec(`INSERT INTO users VALUES (name="Bob", age=25)`)

// Query with JOIN
res, _ := db.Exec(`SELECT u.name, o.total
  FROM users u
  JOIN orders o ON u.name = o.user
  WHERE o.total > 50
  ORDER BY o.total DESC`)

// Transactions
tx, _ := db.Begin()
tx.Exec(`UPDATE accounts SET balance = balance - 100 WHERE id = 1`)
tx.Exec(`UPDATE accounts SET balance = balance + 100 WHERE id = 2`)
tx.Commit()

              
              app.py
            
from doclite import DocLite

with DocLite("app.dlite") as db:
    # Insert and query
    db.exec('INSERT INTO users VALUES (name="Alice", age=30)')
    result = db.exec("SELECT * FROM users WHERE age > 25")

    for doc in result["docs"]:
        print(doc["name"], doc["age"])

    # Native JSON insert
    db.insert_json("users", '{"name": "Bob", "tags": ["vip"]}')

    # Aggregations
    result = db.exec("SELECT COUNT(*), AVG(age) FROM users")
    print(result["docs"])

              
              app.js
            
const { DocLite } = require('./doclite');

const db = new DocLite('app.dlite');

// Insert and query
db.exec('INSERT INTO users VALUES (name="Alice", age=30)');
const result = db.exec('SELECT * FROM users');
console.log(result.docs);

// JSON insert
db.insertJSON('users', '{"name": "Bob", "age": 25}');

// Collections list
console.log(db.collections());

db.close();

              
              App.java
            
try (DocLite db = new DocLite("app.dlite")) {
    // Execute SQL
    String result = db.exec("SELECT * FROM users");
    System.out.println(result);

    // Insert JSON
    long id = db.insertJSON("users",
        "{\"name\": \"Alice\", \"age\": 30}");

    // List collections
    System.out.println(db.collections());
}

              
              terminal
            
$ ./doclite mydata.dlite

doclite> INSERT INTO users VALUES (name="Alice", age=30)
  OK — 1 row(s) affected, last ID: 1

doclite> SELECT * FROM users
  [#1] name="Alice", age=30
  --- 1 document(s)

doclite> .schema
  users (1 document(s))
    ├─ name    string (1/1 = 100%)
    ├─ age     int64  (1/1 = 100%)

doclite> .tables
  users

Your language, your rules

Works everywhere you do

One library. Four languages. Same simple API. Connect in one line.

🐹

Go

Native. No wrapper needed.

api.Open("db.dlite")

🐍

Python

Zero dependencies. Just import.

from doclite import DocLite

🟢

Node.js

npm install and go.

const db = new DocLite()

☕

Java

AutoCloseable. Try-with-resources.

new DocLite("db.dlite")

┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐
│    Go    │  │  Python  │  │  Node.js │  │   Java   │
│ (native) │  │ (ctypes) │  │(ffi-napi)│  │  (JNA)   │
└────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘
     │             │              │              │
     └─────────────┴──────┬───────┴──────────────┘
                          │
                 ┌────────▼────────┐
                 │  doclite.dll    │
                 │  (C shared lib) │
                 └────────┬────────┘
                          │
                 ┌────────▼────────┐
                 │  DocLite Core   │
                 │   (Go engine)   │
                 └─────────────────┘

Your data deserves better
than a config nightmare

Stop configuring.
Start building.

Query Like You Already Know

Your Data Is Safe

Fast Without Effort

Combine Your Data

No Schema? No Problem.

Safe Transactions

Understand What Happens

Built-in Admin Panel

Works With Your Stack

Up and running in 3 lines

Works everywhere you do

Go

Python

Node.js

Java

Free to start. Grow when you're ready.

Ready to simplify your data layer?

Your data deserves betterthan a config nightmare

Stop configuring.Start building.

Query Like You Already Know

Your Data Is Safe

Fast Without Effort

Combine Your Data

No Schema? No Problem.

Safe Transactions

Understand What Happens

Built-in Admin Panel

Works With Your Stack

Up and running in 3 lines

Works everywhere you do

Go

Python

Node.js

Java

Free to start. Grow when you're ready.

Ready to simplify your data layer?

Your data deserves better
than a config nightmare

Stop configuring.
Start building.