NEBULA CLUSTER · EARLY ACCESS

A database that stays up.

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.

WHY IT MATTERS

One server is one outage waiting.

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.

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.

Acknowledged means kept

A write is acknowledged once most of the servers have it on disk. Whichever server is lost next, the write is on another one.

Nothing new to operate

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.

SEE IT WORK

Lose a server and watch.

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.

Nebula Cluster: a database that stays up: Watch three servers hold one database between them: send a write to any server, see it acknowledged once most of them have it, stop the leader and watch another take over, cut a leader off in the middle of a write, give your applications one address with the router, add a fourth server and empty an old one with a statement each, and lose a server for good to watch the cluster make its copy again.

This interactive demo needs WebGL. Read about it.

Nebula Cluster: a database that stays upOpen the full demo →
WHAT IT DOES

It behaves like one database.

Connecting to a cluster feels like connecting to a single server, because every server does the routing itself.

Any server takes any request

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.

Reads see every acknowledged write

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.

A server that returns catches up

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.

Servers come and go while it runs

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.

Users and roles are the cluster's

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.

Encrypted between servers

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.

THE CONTROL PLANE

It keeps itself in order.

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.

It places every copy

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.

It repairs what is lost

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.

It evens the servers out

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.

It shows what it is doing

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.

Backups while it serves

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.

One address, when you want one

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.

MEASURED

Killed on purpose, a million times over.

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.

2.6 sFrom the leader being killed to the next accepted write
1,000,000Simulated runs of 10,000 steps each, with no rule broken

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.

What running it looks like.

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.crt

Adding a fourth server

Start 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;

One address for your applications

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:7687
  • Health and metrics for each server on the Prometheus endpoint you already scrape.
  • A readiness check that answers only when the server can serve.
EARLY ACCESS

Run it with the people who built it.

Tell us about your workload, how many servers you run and where. We will plan the cluster with you and stay with you while it goes into service.

Questions

Do I need a different driver or connection string?

No. 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.

What happens when a server is lost?

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.

How many servers does a cluster need?

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.

Do I need a load balancer in front of it?

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.

What happens to a server that is lost for good?

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.

How is a cluster backed up?

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.

What does my application see while the leader changes?

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.

Does a read on a follower see my last write?

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.

How do I get Nebula Cluster?

Nebula Cluster is in early access. Tell us about your workload and how many servers you run, and we will plan it with you.

Try it with your own data.

Community is free for any use and needs no account or licence key. One Compose file starts the database and Explorer.