# Galactus DB and Neo4j: a tale of two graph databases

A graph database has a varied working day: find a person, follow a few
connections, load a batch of records, then do it all again while everyone
else is asking questions too. How do Galactus DB and Neo4j compare at those
jobs? Here are the scores, with a little context to help you read them.

Galactus did well on batch loading, indexed lookups, scans and memory
footprint. Neo4j led on single-client commits when both engines waited for
disk. There is plenty to like here, and the workload matters.

## Before we open the scorecard

Neo4j 5.26.30 Community was measured on 17 September 2026. Galactus DB in its
default buffered mode is version 1.5.5, re-measured on 9 October 2026 with the
unchanged harness, graph, queries and container limits on the same machine;
Neo4j was not re-run. Galactus group-mode figures were not re-run either and
are from 17 September. The numbers describe those builds, rather than promising
what any future `latest` tag will do.

Both databases handled the same graph: 100,000 people, 200,000 `KNOWS`
relationships and an equality index on `Person.id`. The application queries
and parameters were identical, sent over Bolt with the same Python client
and Neo4j driver. Results below use medians from three passes.

Each container had an allowance of 8 CPUs and 8 GB RAM. Galactus used its
published image defaults; Neo4j had a 2 GB heap and 2 GB page cache. The host
was an i9-13900K with 64 GB RAM, running Docker Desktop on Windows 11/WSL2.
Those settings matter, especially when reading the memory figures.

There is also a choice hiding inside the word "committed". Galactus defaults
to **buffered** durability: it acknowledges the log append before a scheduled
disk sync. Recent writes can be lost on a power or operating-system failure.
**Group** mode waits for a shared disk flush before acknowledging a commit,
as the tested Neo4j setup also did. We show both Galactus modes so that the
extra speed from waiting less is visible, rather than buried in a footnote.

## Bringing in the graph

Imports reward batching: give the database a useful chunk of work each time
you ask it to commit. Everyday writes have a different rhythm, so the table
also includes individual commits and several clients writing together.

| | GDB 1.5.5 (buffered, default) | GDB (group, 17 Sept) | Neo4j |
|---|---|---|---|
| Bulk load, nodes/s, batches of 1,000 | 70,600 | 53,302 | 36,297 |
| Bulk load, relationships/s | 107,471 | 68,206 | 42,497 |
| Single client, autocommit CREATE, p50 | 0.50 ms | 4.79 ms | 3.88 ms |
| Single client, commits/s | 1,769 | 199 | 237 |
| 16 concurrent writers, writes/s | 4,031 | 1,878 | 2,049 |
| 16 concurrent writers, p50 / p99 | 3.5 / 12.0 ms | 8.3 / 12.8 ms | 7.4 / 14.1 ms |
| 64 concurrent writers, writes/s | 4,060 | 3,623 | 3,091 |
| 64 concurrent writers, p50 / p99 | 13.6 / 48.4 ms | 16.6 / 38.2 ms | 19.2 / 41.8 ms |

For latency, lower is better; for throughput, higher is better. The p50 is
the median latency, while p99 gives a view of the slower end of the requests.

![Throughput small multiples: bulk load, single-client commits, concurrent writes, concurrent reads](/blog/charts/cmp-throughput.svg)

Buffered Galactus loaded nodes at about **1.9 times** Neo4j's rate and
relationships at about **2.5 times** its rate. Group mode kept a loading
advantage too, at about **1.5 and 1.6 times** respectively, while waiting for
disk.

For a single client making individual durable commits, Neo4j had the lower
median latency: 3.88 ms against 4.79 ms for Galactus group mode. That is a
useful reminder to look at the row that resembles your application.

## When everybody turns up at once

Group commit has more to share when more writers are active. At 64 clients,
Galactus group mode reached 3,623 writes/s against Neo4j's 3,091, with p99
latency of 38.2 ms against 41.8 ms. Buffered mode reached 4,060 writes/s,
although its p99 was higher at 48.4 ms.

![Concurrent writes per second at 16 and 64 clients](/blog/charts/cmp-scaling.svg)

More clients do not automatically mean more throughput. Buffered Galactus
stayed around the same write rate as concurrency increased, so piling more
requests into the queue would not buy much extra capacity in this setup.

## Finding things and following connections

An indexed lookup is the database equivalent of knowing which drawer to open.
A traversal follows the connections from there. A scan has a bigger job:
look through the people and check which ones match.

| | GDB | Neo4j |
|---|---|---|
| Index seek, p50 / p95 | 0.48 / 0.67 ms | 1.07 / 1.39 ms |
| Two-hop neighbourhood count, p50 | 0.54 ms | 1.07 ms |
| shortestPath up to 6 hops, p50 | 1.03 ms | 1.36 ms |
| Filtered label scan, 100k nodes, p50 | 8.9 ms | 15.2 ms |
| 16 concurrent readers, seeks/s | 3,961 | 3,163 |
| 64 concurrent readers, seeks/s | 3,923 | 3,016 |
| 64 concurrent readers, p50 / p99 | 13.9 / 49.0 ms | 20.0 / 46.1 ms |

![Single-client read latency p50 by workload](/blog/charts/cmp-latency.svg)

Indexed lookups and short traversals took about **half as long** on Galactus
with this dataset and client. The shortest-path query also favoured Galactus,
at 1.03 ms against 1.36 ms.

The filtered scan went to Galactus too, at 8.9 ms against 15.2 ms, about 40%
less time. That query was
`MATCH (p:Person) WHERE p.age % 7 = 0 RETURN count(p)`: every person is
checked and the matches counted, so it is a good example of why a quick
lookup and a full scan deserve separate rows on the scorecard.

With concurrent readers, Galactus delivered more seeks per second at both
client counts. As with writes, its throughput stayed broadly level as the
number of clients increased.

## Leaving room for the application

A database shares its home with application code, background jobs and all the
other things a server gets asked to do. Memory footprint is part of that
conversation too.

| | GDB | Neo4j |
|---|---|---|
| During bulk load | 168 MB | 2,674 MB |
| During 16-client writes | 292 MB | 2,793 MB |

![Peak container memory during load and during writes](/blog/charts/cmp-memory.svg)

These are peak container-memory readings from `docker stats`. Galactus 1.5.5
reached about 290 MB during writes with this graph, down from about 400 MB on
17 September. Neo4j's figures reflect
its configured heap and page cache; a smaller heap would change the
comparison. Neither column is a minimum memory requirement.

Galactus keeps graph structure and indexes in memory, so allow for growth as
your graph gets bigger. A small footprint on this dataset is useful evidence,
not a promise that every graph fits in the same space.

## Which rows matter to you?

For batch imports, short traversals, indexed reads and label scans, these
results give Galactus plenty to smile about. If your application spends its
day issuing individual durable commits, that row deserves just as much
attention.

This comparison covers a graph that fitted in memory and single-instance
operation. It does not assess larger-than-memory datasets, clustering, Neo4j
Enterprise or the wider tooling around either database. Different hardware,
settings and query mixes can change the results.

For a closer look at the write trade-off, see
[the durability guide](/blog/galactus-db-durability-modes). For the download
and idle-memory comparison, see
[a graph database that packs light](/blog/galactus-db-image-size).

Neo4j is a registered trademark of Neo4j, Inc. Galactus DB is not affiliated
with Neo4j, Inc.
