cloudparts

RethinkDBDormant

A clustered JSON document database whose queries can stay open as changefeeds, pushing every change to the client instead of the app polling for it.

Linux Foundation project
What it is
Document databases
Type
Open source
Made by
RethinkDB community (copyright held by the Linux Foundation)
Foundation
The Linux Foundation, joined February 2017. Bought from the defunct RethinkDB company by the CNCF and contributed to the Linux Foundation
License
Apache 2.0
Status
Dormant. Volunteer-maintained: the last feature release, 2.4, was in December 2019, and 2.4.5 (November 2025) only fixed builds on newer platforms.
Facts checked
28 October 2026
Website Source code

What it is

RethinkDB stores JSON documents in tables and is queried with ReQL, a query language built from method chains in the host language: r.table('game').orderBy({index: 'score'}).limit(3) in JavaScript, the same chain in Python, Ruby or Java. Add .changes() to most queries and the server keeps them open as a changefeed, sending the old and new value of every document that enters, leaves or changes the result. That is the feature it was built around: a leaderboard, chat room or dashboard subscribes to a query and gets updates pushed over the driver connection.

A table is range-sharded on its primary key across servers, and each shard has one primary replica and any number of secondaries, configured with reconfigure(shards=…, replicas=…) or from the built-in web console. Cluster configuration is kept with Raft, and when enough voting replicas remain a failed primary is replaced automatically. Writes are atomic per document only; by default they are acknowledged once a majority of replicas have them on disk, while reads come from the primary’s memory unless you ask for read_mode: 'majority', which makes single-document operations linearizable. Data lives in B-trees on a log-structured storage engine with its own cache, so tables can be much larger than RAM.

The company behind it shut down in October 2016. The CNCF bought the code and copyrights in February 2017, relicensed them from AGPLv3 to Apache 2.0 and gave the project to the Linux Foundation, where volunteers have kept it alive since. They shipped 2.4 in December 2019 with write hooks, then only fix and build releases; 2.4.5 in November 2025 changed nothing but packaging. Commits still land in 2026, mostly tests and CI, so it is maintained but not moving forward.

Why teams pick it

  • Changefeeds on ordinary queries, including filtered and ordered ones, so realtime updates need no separate pub/sub system
  • ReQL composes in your own language, with joins, aggregation and map/reduce running in parallel across shards
  • Sharding, replication and automatic failover are built in and can be changed live from the web console or the API
  • Apache 2.0 with copyright held by the Linux Foundation, so no single company can relicense it

Watch out for

  • Little development: no feature release since 2.4 in 2019, a small volunteer team, and official drivers for only JavaScript, Python, Ruby and Java
  • No multi-document transactions; a single query is not atomic across the documents it touches
  • The default read_mode of single can return writes a failover later loses; strong reads need majority and cost latency
  • Changefeeds are not a durable log: a client that disconnects misses changes and has to re-read, unlike a Kafka topic or a CDC stream

Specs

Compare with alternatives →
Data model
JSON documents in tables, each with a primary key
Query language
ReQL, chained methods in the client language, with .changes() for live queries
Client protocol
Its own JSON protocol over TCP, used by the drivers
Secondary indexes
Secondary, compound, multi and geospatial indexes
Transactions
Atomic per document; none across documents
Consistency
Majority write acks by default; reads from the primary’s memory unless read_mode: majority
How it scales
Range sharding on the primary key across servers
Replication
One primary and many secondaries per shard; automatic failover, configuration kept with Raft
Storage engine
Log-structured storage with B-trees and its own cache
Written in
C++
Ways to run it
Self-hosted; no managed service since the company closed

Alternatives

What all document databases have in common →Compare side by side →
MongoDBCommercialA document database that stores JSON-like records with a flexible schema, from one replica set to a sharded cluster.Apache CouchDBOpen sourceA JSON document database spoken to entirely over HTTP, built around replication: any two copies can sync in either direction and keep conflicting edits instead of losing them.SurrealDBCommercialA multi-model database in Rust that stores documents, graph edges, vectors and time series in one engine, queried with an SQL-like language, SurrealQL, and able to run embedded, as a server or as a cluster.SupabaseCommercialA backend built around one dedicated Postgres database per project, with a REST API generated from its schema, JWT auth, file storage, realtime updates and edge functions, all assembled from open-source parts you can also self-host.DocumentDBOpen sourceA MongoDB-compatible document database built as PostgreSQL extensions plus a gateway, so MongoDB drivers and tools talk to Postgres underneath.FaunaArchivedCommercialA serverless, globally replicated document database with strictly serializable transactions and its own query language, FQL; the service shut down in May 2025.

A leaderboard that pushes changes to the client · js

const r = require('rethinkdb');
const conn = await r.connect({ host: 'localhost', port: 28015 });

await r.tableCreate('game').run(conn);
await r.table('game').indexCreate('score').run(conn);
await r.table('game').indexWait('score').run(conn);

// the top three scores, kept open: every change that affects them is pushed
const feed = await r.table('game')
  .orderBy({ index: r.desc('score') }).limit(3)
  .changes({ includeInitial: true })
  .run(conn);

feed.each((err, change) => {
  // { old_val: {...} | null, new_val: {...} | null }
  console.log(change.new_val);
});

// elsewhere: r.table('game').get('ada').update({ score: 4200 }).run(conn)

See it in a real stack

No architecture uses RethinkDB yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2009–2025

Slava Akhmechet and Michael Glukhovsky started RethinkDB in 2009 with seed money from Y Combinator. It began as a storage engine for MySQL tuned for solid-state drives, then became a distributed JSON database; the first public release, 1.2, came in November 2012. Changefeeds became its defining feature, and the repository still calls it “the open-source database for the realtime web”. Version 2.0, in April 2015, was the first release the company called production-ready.

The company never found a business. On 5 October 2016 Akhmechet announced that RethinkDB the company was shutting down and that much of the engineering team was joining Stripe, while the code stayed open source. In February 2017 the CNCF paid $25,000 for the source code, copyrights and assets, relicensed them from AGPLv3, which some companies had refused to use, to Apache 2.0, and contributed the project to the Linux Foundation. Community maintainers released 2.3.6, the first release under community governance, then 2.4 in December 2019 with write hooks, and since then fix releases up to 2.4.5 in November 2025.

Why it’s built this way

Push query results, don’t make apps poll
Realtime apps built on other databases had to poll or bolt on a message broker; changefeeds let the query itself be the subscription.
A query language embedded in the host language
ReQL is built from ordinary method calls, so queries compose like code and can’t be broken by string concatenation.
Relicense to Apache 2.0 after the shutdown
AGPLv3 had kept some companies from using or contributing; the CNCF called the purchase a chance “to salvage an enormous investment with a small incremental contribution”.

Timeline

  1. 2009

    Founded with Y Combinator seed funding, first as a MySQL storage engine for SSDs

  2. 2012

    First public release, 1.2 (November)

  3. 2015

    RethinkDB 2.0, called production-ready (April)

  4. 2016

    The company shuts down; engineers join Stripe (October)

  5. 2017

    CNCF buys the code for $25,000, relicenses it to Apache 2.0 and contributes it to the Linux Foundation (February)

  6. 2019

    RethinkDB 2.4 with write hooks (December), the last feature release

  7. 2025

    2.4.5, a build-fix release (November)

Sources9 · facts checked 28 October 2026

Improve this page on GitHub