Failover that needs nobody
With a replica, somebody has to notice, decide and run PROMOTE, usually at night. In a cluster the servers settle it between themselves: a write was accepted 2.6 seconds after we killed the leader.
Three servers hold your data. When one is lost, another takes over within seconds and every acknowledged write is still there. Your application connects with the Bolt driver and the bolt:// address it uses today.
A single server stops for a failed disk, a kernel update or a cloud zone having a bad afternoon, and everything that depends on it stops with it. The cost is the orders that did not go through and the people who were paged.
With a replica, somebody has to notice, decide and run PROMOTE, usually at night. In a cluster the servers settle it between themselves: a write was accepted 2.6 seconds after we killed the leader.
A write is acknowledged once most of the servers have it on disk. Whichever server is lost next, the write is on another one.
There is no coordinator service to run beside the database and no special driver. The servers are the cluster, and they keep it in order themselves.
Send writes to any server, stop the leader, put the router in front, and lose a server for good to watch the cluster make its copy again. Each step shows the statement or setting behind it.
Connecting to a cluster feels like connecting to a single server, because every server does the routing itself.
Point your application at any server, or at all of them behind a load balancer. A write that reaches a server which does not lead is carried to the leader and answered on the same connection.
A read runs on the server you are connected to. It first checks how far the cluster has committed, so it never answers from before a write you were told had succeeded.
The leader keeps the log a server that is away still needs, and sends it when the server comes back. One that was away too long is given a fresh copy by another server and carries on by itself.
Start a server, say ENABLE SERVER, and the cluster may place copies on it. DRAIN SERVER empties one while it serves, and DROP SERVER takes it out.
CREATE USER, GRANT and DROP USER sent to any server take effect on all of them. A user who is dropped is refused everywhere, in sessions already open too.
Servers speak to each other over mutual TLS 1.3 with certificates from your own authority, on a port separate from the one your applications use.
You say how many copies a database has. Placing them, repairing them and evening them out is the cluster's work, done by whichever server leads at the time, so there is nothing extra to install or keep alive.
CREATE DATABASE orders OPTIONS {replicas: 3}, sent to any server, puts three copies on the servers that hold least. ALTER DATABASE changes the number later, and the cluster adds or removes copies to match.
A server that goes silent is marked down. If it is still gone after ten minutes, its copies are made again on servers that hold none. A server that restarts inside that time catches up and carries on.
Add a server and enable it, and copies move onto it until the servers are even. Each move adds the new copy before it removes the old, so a database never has fewer copies than you asked for.
SHOW SERVERS and SHOW PLACEMENT say what is where. gdb.cluster.operations lists each move under way and the reason for it, and gdb.cluster.pause holds it all still while you work.
gdb.backup.create writes a database's pages as they are, or only what they have gained since the last backup. A server that does not lead takes it, and restoring makes a new database beside the old.
The router is a small program of ours for the front of the cluster. Your applications connect to it, and each new connection goes to a server that is ready, the one with the fewest connections.
We wrote the consensus code ourselves, on the standard library alone, so there is no third-party cluster library to trust or patch. Then we tried to break it.
Measured on Nebula Cluster 3.0.0-alpha.1, 19 November 2026, on an Intel Core i9-13900K with 64 GB of RAM: three server processes on one machine with the default timings. The leader's process was killed and a write sent through another server was accepted between 2,562 and 2,624 ms later, in six runs out of six.
The simulator delays, reorders, duplicates and drops messages, cuts links, and decides when a server crashes and what the crash loses. After every step it checks that no two servers disagree about a committed write, that no acknowledged write is lost, and that no read is answered from before a write it should have seen. Those runs committed 367 million entries, elected 7.5 million leaders and checked 154.6 million reads.
Each server is given the cluster's shape in its environment and a certificate. One server is named as where the cluster starts, and its users and data become the cluster's.
GDB_CLUSTER=true
GDB_CLUSTER_ID=5157
GDB_NODE_ID=1
GDB_CLUSTER_PEERS=1=a.example:7688,2=b.example:7688,3=c.example:7688
GDB_CLUSTER_DATABASES=orders
GDB_CLUSTER_INIT=true
GDB_CLUSTER_TLS_CERT=/run/secrets/node.crt
GDB_CLUSTER_TLS_KEY=/run/secrets/node.key
GDB_CLUSTER_TLS_CA=/run/secrets/ca.crtStart it with the same settings and its own id. Then, from any server:
CALL gdb.cluster.addNode(4, 'd.example:7688');
ENABLE SERVER 4;
SHOW SERVERS;
SHOW PLACEMENT FOR DATABASE orders;Run the router wherever suits, and two of them if you like. It keeps no state:
GDB_BALANCER_SERVERS=a.example:9187,b.example:9187
GDB_BALANCER_BIND=0.0.0.0:7687No. Any Bolt driver connects to any server with a plain bolt:// address. A write sent to a server that does not lead is carried to the one that does, on the same connection, and its result comes back the same way.
If it led a database, the others choose a new leader between them. In our test a write was accepted 2.6 seconds after the leader's process was killed. Every write that was acknowledged before is still there, because a write is only acknowledged once most of the servers have it on disk.
Three servers keep serving through the loss of one, and five through the loss of two. You can add a server to a running cluster and take one out, with a statement each.
No, because every server takes any request. When you want one address for your applications, run the router: a small program of ours that gives each new connection to a server that is ready, the one with the fewest connections, and learns the servers from the cluster.
The cluster marks it down, and if it is still gone after ten minutes it makes that server's copies again on a server that holds none, so each database is back to the number of copies you asked for. With four servers and three copies of a database, losing one for good needs nobody to do anything. The ten minutes is a setting.
With one statement, while it serves. A backup is taken by a server that does not lead, so the work stays off the one taking writes. It holds the database's pages as they are, or only what they have gained since the last backup, and restoring one makes a new database beside the old.
A transaction that was open on the old leader fails with Galactus.TransientError.Cluster.LeaderChanged, which the retry functions in Bolt drivers already handle: nothing of it was kept, and it runs again as it is. A commit that could not be confirmed says so with its own code and is never reported as a success.
Yes. Before it answers, a server checks how far the cluster has committed and waits until it has caught up, so a read on any server sees every write acknowledged before it.
Nebula Cluster is in early access. Tell us about your workload and how many servers you run, and we will plan it with you.
Community is free for any use and needs no account or licence key. One Compose file starts the database and Explorer.