Open Source · MIT Licensed · Single Binary
A document database where every node is a full read-write copy. No leader election. No primary. Branch your data like code. Merge it back deterministically. Deploy one binary — on your servers, at the edge, or air-gapped.
KineDB is an open-source document database built on content-addressed Prolly trees. Zero-cost data branching, deterministic three-way merging, leaderless clustering via SWIM gossip, per-document multi-tenant ACLs, and familiar SQL queries. Single binary, zero external dependencies, MIT licensed. 2.8x faster than PostgreSQL and 14x faster than MongoDB on mixed workloads.
These aren't configuration issues. They're architectural limitations baked into engines designed decades ago.
PostgreSQL
Every UPDATE creates dead tuples. Autovacuum runs constantly. Miss it, and XID wraparound can freeze your entire database — Sentry and Mailchimp both learned this the hard way. KineDB's Prolly trees are append-only and content-addressed. No dead tuples. No vacuum. No wraparound.
PostgreSQL
Patroni + etcd + PgBouncer — three separate systems just to keep your database available. Split-brain risk during failover. Replication lag that silently falls hours behind. KineDB nodes are leaderless. No election. No split-brain. Every node accepts writes.
MongoDB
OSI rejected it. Debian and Red Hat dropped MongoDB from their repos. The license lets MongoDB change terms at any time. Redis already did an SSPL rug-pull, then reversed course. KineDB is MIT licensed. No asterisks. No "source-available" doublespeak.
MongoDB
Atlas starts at $200/month and quietly becomes $15,000. M10 to M30 is a 6-8x jump, not 3x. Multi-region doubles costs per region. Data egress adds $900-1,200/month at scale. KineDB is self-hosted. Your hardware, your costs, your data.
Both
PostgreSQL RLS evaluates per-row, can't handle complex RBAC without degrading queries from milliseconds to hours. MongoDB's shared-collection model has no document-level RBAC at all. KineDB has per-document ACLs hardcoded into the query engine — every query is automatically filtered by the user's permissions.
Both
Bad UPDATE? Restore from backup. Want to test a migration on production data? Clone the whole database, wait an hour, pay for double the storage. KineDB branches your dataset in O(1) — one hash pointer — and merges it back deterministically.
Not a wrapper around PostgreSQL. Not a fork of MongoDB. A database built from scratch on Prolly trees — the same content-addressed data structure used by Dolt, Bluesky's AT Protocol, and the IPLD ecosystem.
Traditional databases address data by disk location. KineDB addresses data by content hash. Same data always produces the same tree. This one change unlocks four capabilities B-tree databases can't offer.
O(1) — copy one hash pointer
Branch your entire dataset by copying a single reference. No data cloned. No storage cost. Branch for testing, migrations, or tenant isolation. Nearly 60% of releases require database changes — branch and test them on real data, not mocked data.
O(changes) — skip identical subtrees
1M documents with 10 changes? ~30-40 blocks compared, not 33,000. Unchanged subtrees share the same hash — skip them entirely. Sync proportional to divergence, not data size.
Deterministic — merge(A,B) = merge(B,A)
Three-way merge with field-level conflict resolution via hybrid logical clocks. Two nodes editing the same document at different fields? Both changes survive. The result is identical regardless of merge order — no manual conflict resolution.
Automatic — same content = same hash
Branches that share most of their data share most of their blocks on disk. Storage grows proportional to unique content, not total branches. Run hundreds of branches without multiplying storage.
faster than PostgreSQL
75K ops/sec · Mixed workload · 3-node cluster
faster than MongoDB
Write latency 79µs vs 1.48ms · 3-node cluster
SELECT, INSERT, UPDATE, DELETE with WHERE, aggregation, nested document paths. Not an aggregation pipeline. Not MapReduce. SQL that teams already know. Hand-rolled recursive descent parser — no external dependencies.
CREATE BRANCH, MERGE BRANCH, DROP BRANCH. Test migrations against production data. Run experiments in isolation. O(1) cost to branch, O(changes) to merge. The workflow Neon and PlanetScale bolt onto PostgreSQL — native in KineDB's storage engine.
Every document carries READ, WRITE, DELETE permissions per user and role. Hardcoded into the engine with bitmap index evaluation — not a policy layer you configure and hope you got right. Queries automatically return only rows the user can see. No RLS. No middleware.
Subscribe to data changes with query filters: SUBSCRIBE WHERE collection='orders' AND status='paid'. Notifications are ACL-filtered per subscriber. Like CouchDB's _changes feed, but with SQL filter expressions and access control built in.
No Raft. No Paxos. No leader election. Nodes discover each other via SWIM gossip, sync via Prolly tree diffs, and auto-merge with field-level HLC resolution. Any node accepts writes. Sub-second sync convergence for active writers. No Patroni. No etcd. No split-brain.
BEGIN creates a Prolly tree branch. Writes accumulate in snapshot isolation. COMMIT three-way merges back. ROLLBACK drops the branch at zero cost. Concurrent field-level edits are preserved automatically. Not eventually consistent — actually ACID.
Different databases make different trade-offs. PostgreSQL has full SQL. MongoDB has a mature ecosystem. Here's where KineDB is genuinely different.
| Capability | KineDB | PostgreSQL | MongoDB | CouchDB | Dolt |
|---|---|---|---|---|---|
| Storage engine | Prolly trees (content-addressed) | B-trees (disk-addressed) | WiredTiger B-trees | B-trees (append-only) | Prolly trees |
| Data branching | Zero-cost O(1) | No (dump/restore) | No | No | Zero-cost O(1) |
| Deterministic merge | 3-way, field-level HLC | No | No | Conflict detection only | 3-way merge |
| Clustering model | Leaderless (gossip + tree diff) | Leader-based (Patroni+etcd) | Primary required | Leaderless | No clustering |
| Per-document ACLs | Hardcoded in engine | RLS (manual, per-row eval) | DIY middleware | No | No |
| Query language | SQL subset | Full SQL | Aggregation pipeline | MapReduce / Mango | Full SQL (MySQL) |
| ACID transactions | Branch-based | Full ACID | With limitations | No | Yes |
| Vacuum / maintenance | None needed | Constant (MVCC bloat) | Compaction | Compaction required | None needed |
| Offline / disconnected | Full read-write, sync on reconnect | Needs leader | Needs primary | Yes (via replication) | Single node only |
| Single binary | Yes, zero deps | Multiple processes | Requires ops | Yes (Erlang) | Yes (Go) |
| License | MIT | PostgreSQL (permissive) | SSPL (not OSI-approved) | Apache 2.0 | Apache 2.0 |
KineDB's architecture — leaderless, single binary, deterministic merge — makes it a natural fit for use cases that traditional databases struggle with.
$12.6B sovereign cloud market (2026), tripling by 2027
US-headquartered database vendors are subject to the CLOUD Act — data can be compelled regardless of where it's stored. Microsoft's Chief Legal Officer admitted this in France in 2025. KineDB is MIT licensed and fully self-hosted. No US cloud dependency. No phone-home. No license server. Deploy in your EU data center and the data stays under your jurisdiction.
$1.82B edge data sync market, 28% CAGR
Every edge database today — Turso, Cloudflare D1, LiteFS — requires a single primary writer. KineDB doesn't. Every edge node is a full read-write database. Work offline for days. When connectivity returns, Prolly tree diffs sync only the changes. Deterministic merge means no conflicts. The sync CouchDB users love, with the SQL and ACLs they've been asking for.
DDIL: DoD's toughest operational challenge
Denied, Degraded, Intermittent, Limited — environments where the network disappears. KineDB gives every tactical node a fully operational database. No leader required. No cloud required. When the network comes back, SWIM gossip rediscovers peers and Prolly tree diffs reconcile all changes deterministically. Single binary deploys on any device. MIT license means no license server in an air-gapped environment.
PostgreSQL RLS: "queries go from milliseconds to hours"
PostgreSQL RLS evaluates policies per-row, doesn't apply to superusers, and can accidentally authorize wrong requests when threads are reused. MongoDB has no document-level RBAC at all — shared-collection multi-tenancy requires tenantID in every query. KineDB's per-document ACLs are hardcoded into the engine with bitmap index evaluation. O(1) permission checks. Users automatically see only their rows.
$13.75B industrial IoT gateway market
Hundreds of factory nodes or vehicles operating independently, collecting data offline. When connectivity returns, KineDB merges everything deterministically. No conflicts. No data loss. Single binary on every gateway. No JVM, no runtime, no infrastructure team at the edge. Storage grows proportional to unique data, not total nodes.
$5.27B game backend-as-a-service market
Turn-based, strategy, and asynchronous multiplayer games where players make moves offline and sync later. Persistent world state with branching — save game states, experiment, merge back. Deterministic merge means game state conflicts resolve automatically. Not for sub-millisecond MMO ticks (SpacetimeDB wins there), but for everything that doesn't need frame-rate latency.
KineDB is an open-source, MIT-licensed, single-binary document database built on content-addressed Prolly trees. It provides version control for your data — branch, diff, and merge your entire dataset like Git handles code. It features leaderless distributed clustering via SWIM gossip, per-document multi-tenant ACLs hardcoded into the engine, real-time change streaming, ACID transactions, and familiar SQL queries. It runs as a single binary with only three external dependencies (tokio, serde, blake3).
PostgreSQL uses MVCC with B-trees, creating dead tuple bloat that requires constant vacuum maintenance and risks transaction ID wraparound outages (Sentry and Mailchimp both experienced this). KineDB uses content-addressed Prolly trees — no vacuum, no bloat, no XID wraparound. PostgreSQL HA requires Patroni + etcd + PgBouncer with leader election and split-brain risk. KineDB is leaderless — every node accepts reads and writes. PostgreSQL RLS evaluates per-row and degrades performance on complex RBAC. KineDB has per-document ACLs with O(1) bitmap checks. KineDB delivers 2.8x PostgreSQL throughput on mixed workloads with 24x lower write latency.
MongoDB uses SSPL licensing (not recognized as open source by OSI, Debian, or Red Hat) and Atlas pricing typically escalates from $200/month to $15,000/month. KineDB is MIT licensed and self-hosted. MongoDB requires a primary node and uses a complex aggregation pipeline. KineDB is leaderless and uses SQL. MongoDB multi-tenancy requires DIY middleware. KineDB has per-document ACLs built in. Both are document databases, but KineDB's Prolly tree storage enables zero-cost data branching and leaderless replication that MongoDB's WiredTiger B-trees can't offer. KineDB delivers 14x MongoDB throughput on mixed workloads.
Both use Prolly trees for version-controlled data. But Dolt is MySQL-compatible relational only, has no clustering or horizontal scaling, and can't embed outside Go. KineDB is a document database with leaderless clustering, per-document ACLs, and change streaming. Dolt validated that developers want version control for data — KineDB adds the distributed, multi-tenant, and offline-capable features that production applications need.
Yes. Every node operates as a fully independent database. Work offline for hours, days, or weeks. When connectivity returns, SWIM gossip discovers peers and Prolly tree diffs sync only the changes — not the full dataset. Field-level HLC resolution preserves concurrent edits to different fields automatically. This makes KineDB suitable for edge deployments, IoT gateways, military DDIL environments, and local-first applications where current solutions like Turso, D1, and LiteFS all require a primary writer.
Yes. KineDB is MIT licensed and fully self-hosted. It runs in your EU data center with zero dependency on US cloud vendors subject to the CLOUD Act. No license server, no phone-home, no managed service. This directly addresses Schrems II transfer restrictions, GDPR data residency requirements, and EU Data Act portability mandates. European sovereign cloud spending reached $12.6B in 2026 and is expected to triple by 2027 — KineDB is built for this market.
A Prolly (probabilistic) tree is a content-addressed Merkle tree where every node is identified by its blake3 hash. The same sorted data always produces the same tree structure, regardless of insertion order. This enables zero-cost branching (copy one pointer), O(changes) diffing (skip unchanged subtrees), and deterministic merging. Prolly trees were invented by Aaron Boodman for the Noms database and are also used by Dolt, Bluesky's AT Protocol, and the IPLD/IPFS ecosystem. Multiple independent projects converging on this data structure is "a textbook example of multiple discovery" (DoltHub, 2025).
One binary. Every node sovereign. MIT licensed forever.