We published 10.8× on the 28,000-node pack and 1.9× at 2.5 million nodes, with CPU already ahead of Neo4j. All benchmark harnesses, public seeds, and verification scripts are open on GitHub.
0.86 ms (GPU) against Neo4j at 9.27 ms. 20,000 people, 8,000 papers.
6.48 ms (GPU) against Neo4j at 12.12 ms. 2.5 million nodes.
The same large pack on CPU only. Ahead of Neo4j at 12.12 ms.
LightningDB on AVX2 against Neo4j on Bolt. This lane runs on standard CPU hardware with Docker and already beats Neo4j at 2.5 million nodes without GPU dependencies.
System requirements: Standard x86_64 host with AVX2 support (Intel Haswell / AMD Zen or newer), Docker 20+, 8–16 GB RAM.
CUDA-accelerated exact cosine retrieval on NVIDIA hardware. Graph hop expansion, compilation, and plan evaluation execute directly in unified memory.
System requirements: NVIDIA GPU (Pascal, Turing, Ampere, Ada, Hopper), NVIDIA Container Toolkit (nvidia-docker2), CUDA 12+, and an enabled license tier. Neo4j has no GPU engine — its column is always standard CPU/Bolt.
When you execute proof_community.sh, the benchmark harness orchestrates an automated 5-phase test pipeline. Here is what to expect at every stage.
Docker container initializes. The harness validates AVX2 instruction support and inspects GPU visibility via nvidia-smi. Neo4j Community 5.26 boots in the background; the JVM allocates heap memory (-Xms2G -Xmx4G) and warms up JIT compiler threads. Python Bolt connectivity is established.
Data is generated or downloaded. For the default bake-off, the harness generates seed-42 Person/Paper entities (~5s). For Wikipedia, it streams Stanford SNAP wiki-topcats (~60–90s). LightningDB creates memory-mapped CSR adjacency tables (<1s). Neo4j imports CSV and creates B-tree indexes (~15–90s).
The harness runs sanity probe queries on both engines to verify 100% graph topology parity. Total node counts, edge counts, and component properties must match identically between LightningDB and Neo4j before benchmark timing begins. Any discrepancy immediately halts the run.
Evaluates 12 query patterns from 1-hop reachability to 6-hop walks and exact cosine vectors. Runs multiple warmup iterations to discard cold-cache and JVM JIT compilation spikes, followed by 20 timed measurement iterations (5 for heavy multi-hop queries) to compute median wall-clock nanoseconds.
Generates audited Markdown comparison tables (bench/out/LADDER.md), latency percentiles and memory usage deltas (REPORT.md, REPORT.json), audited machine hardware specs (host.json), and published JSON clocks matching the website.
Each suite targets a specific architectural stress point: raw pointer dereferencing, multi-hop BFS frontier expansion, high-degree hub explosion, or dense vector SIMD scoring. Times reflect total wall-clock duration.
| Suite & Dataset | Target Workload | Time Breakdown & Total | What It Does & Validates |
|---|---|---|---|
| Default Bake-off 20k people, 8k papers (seed 42) | 1-hop to 6-hop paths, 4-cycles, length-4 walks, exact cosine | ~60–90 seconds Prep: ~5s | Neo4j start: ~20s | Lit: <1s | Neo: ~45s | Loads seed-42 corpus into LightningDB and Neo4j Community 5.26. Verifies exact row count equality across all 12 ladder queries and logs execution time per query to LADDER.md. |
| Wikipedia Hub Explosion SNAP wiki-topcats (1.79M nodes, 28.5M edges) | High-degree frontier expansion (3-hop and 6-hop) from top hub article | ~3–5 minutes Download: ~75s | Ingestion: ~75s | Traversal: ~60s | Downloads real Stanford SNAP Wikipedia hyperlink network. Seeds traversals at highest out-degree hub articles (e.g. United States, Science) to test raw memory bandwidth under exponential frontier expansion without artificial shortcuts. |
| Wikipedia Quick Smoke SNAP wiki-vote (7,115 nodes, 103,689 edges) | Rapid sanity check on real Wikipedia admin voting graph | ~15–20 seconds Download: ~5s | Ingestion: ~5s | Traversal: ~5s | Fast smoke test for continuous integration pipelines, verifying container build health, driver connectivity, and basic Cypher equivalence in seconds. |
| Dual Lane Replay CPU AVX2 + CUDA GPU | AVX2 SIMD vs CUDA exact cosine top-k on identical graph | ~2–3 minutes CPU pass: ~75s | GPU pass: ~60s | Merge: <1s | Executes both AVX2 CPU and CUDA GPU lanes in sequence on the exact same graph. Directly compares hardware acceleration against Neo4j's single CPU/Bolt baseline. |
| GraphRAG Hybrid Pack POST /v1/rag (2.5M nodes) | Exact vector retrieve + 3-hop neighborhood expansion | ~30 seconds Ingestion: ~15s | Top-10 + 3-hop expansion: ~15s | Measures end-to-end prompt assembly latency (target < 15 ms). Validates that combined vector retrieval and graph subgraph extraction finishes in 6.48 ms on GPU and 9.18 ms on CPU. |
| Concurrency Saturation Stress 128 parallel callers | 2,048 POST requests under full saturation | ~10–15 seconds Pool warmup: ~2s | 2,048 requests: ~10s | Floods non-blocking async worker pool with 128 parallel callers. Validates 0 dropped requests, 0 connection resets, and sustained 629 requests per second throughput. |
The query ladder evaluates graph database architecture under increasing structural difficulty, from single-pointer dereferencing to combinatorial path explosion and dense vector scoring. Every row requires 100% matching result counts between engines.
| Workload & Difficulty | Cypher Query Pattern | What It Does & Architectural Test | Typical Clocks |
|---|---|---|---|
| Easy 1-hop friends |
MATCH (p:Person {id: $hub})-[:FOLLOWS]->(x) RETURN count(*)
|
Scans the immediate outward adjacency list of the hub node. Tests direct pointer dereferencing and contiguous memory layout efficiency without intermediate joins. | 0.04 ms vs 0.42 ms 10.5× advantage |
| Easy Papers authored |
MATCH (p:Person {id: $hub})-[:AUTHORED]->(x) RETURN count(*)
|
Traverses secondary relationship-type edges from the origin node. Tests edge-type discrimination and secondary index lookup overhead from a single source entity. | 0.03 ms vs 0.38 ms 12.7× advantage |
| Medium 2-hop reach |
MATCH (p:Person {id: $hub})-[:FOLLOWS*0..2]->(x) RETURN count(DISTINCT x)
|
Expands outward by two relationship hops and counts distinct unique nodes reached. Tests breadth-first frontier queueing and in-memory bitset deduplication efficiency. | 0.12 ms vs 1.15 ms 9.6× advantage |
| Medium 3-hop reach |
MATCH (p:Person {id: $hub})-[:FOLLOWS*0..3]->(x) RETURN count(DISTINCT x)
|
Expands across three relationship hops into the broader cluster. Tests exponential frontier growth management and L2/L3 CPU cache line utilization under moderate fan-out. | 0.48 ms vs 4.82 ms 10.0× advantage |
| Medium Papers of followed colleagues |
MATCH (p:Person {id: $hub})-[:FOLLOWS]->()-[:AUTHORED]->(paper) RETURN count(DISTINCT paper)
|
Follows outgoing social edges and aggregates unique academic papers authored by those connections. Tests heterogeneous two-label join performance without pre-materialized views or index caching. | 0.35 ms vs 3.20 ms 9.1× advantage |
| Hard 6-hop deep reach |
MATCH (p:Person {id: $hub})-[:FOLLOWS*0..6]->(x) RETURN count(DISTINCT x)
|
Traverses deep across the giant connected component of the graph. Evaluates memory bus throughput and latency when the visited frontier substantially overflows CPU L3 cache. | 1.85 ms vs 18.60 ms 10.1× advantage |
| Hard Directed 3-cycles (triangles) |
MATCH (p:Person {id: $hub})-[:FOLLOWS]->()-[:FOLLOWS]->()-[:FOLLOWS]->(p) RETURN count(*)
|
Discovers closed three-node loops returning directly to the origin hub. Tests cycle detection and intersection between the two-hop outward frontier and the hub's incoming edge list. | 0.72 ms vs 6.90 ms 9.6× advantage |
| Hard 2-hop friends then papers |
MATCH (p:Person {id: $hub})-[:FOLLOWS]->()-[:FOLLOWS]->()-[:AUTHORED]->(paper) RETURN count(DISTINCT paper)
|
Branching join traversing two social hops before aggregating authored papers. Tests intermediate pipeline buffering and set deduplication under high-cardinality multi-hop joins. | 0.84 ms vs 7.45 ms 8.9× advantage |
| Very Hard Length-4 walks |
MATCH (p:Person {id: $hub})-[:FOLLOWS]->()-[:FOLLOWS]->()-[:FOLLOWS]->()-[:FOLLOWS]->() RETURN count(*)
|
Enumerates all length-4 paths originating from the hub node without distinct deduplication. Tests raw edge traversal rate under combinatorial path explosion (often traversing hundreds of thousands of paths). | 2.40 ms vs 24.10 ms 10.0× advantage |
| Very Hard Directed 4-cycles |
MATCH (p:Person {id: $hub})-[:FOLLOWS]->()-[:FOLLOWS]->()-[:FOLLOWS]->()-[:FOLLOWS]->(p) RETURN count(*)
|
Finds closed four-node directed loops returning to the origin hub. Requires 3-hop path tracking and back-edge verification, exposing JVM object allocation overhead in Neo4j. | 1.95 ms vs 19.80 ms 10.2× advantage |
| Very Hard Variable-length *2..4 |
MATCH (p:Person {id: $hub})-[:FOLLOWS*2..4]->(x) RETURN count(DISTINCT x)
|
Bounded variable-length path traversal evaluating all reachable unique entities between 2 and 4 hops away. Tests bounded depth-first exploration and visited set pruning across expanding graph neighborhoods. | 1.10 ms vs 11.20 ms 10.2× advantage |
| Very Hard Vector retrieve k=10 |
Exact cosine top-10 papers on 384-dimensional dense vectors (GraphRAG query)
|
Exhaustively scores all entity vectors against a query vector to return the top 10 most similar items without index approximation. Evaluates AVX2 SIMD dot-product throughput on CPU and CUDA tensor core scoring on GPU. Neo4j runs on CPU only. | 0.86 ms (GPU) vs 9.27 ms 10.8× advantage |
Four standard reproduction workflows from repository clone to published verification ladder.
20,000 people, 8,000 papers, seed 42. Generates the baseline query ladder and writes bench/out/LADDER.md.
SNAP wiki-topcats (1.79 million pages, 28.5 million links). Three-hop and six-hop traversals start at the highest-degree hub article.
Executes both AVX2 CPU and CUDA GPU lanes in a single pass to compare hardware speedups on identical graphs.
Support for wiki-talk (2.4M nodes), livejournal (4.8M nodes, 69M edges), orkut (3.1M nodes, 117M edges), and Bitcoin OTC trust networks.
| Flag / Option | Allowed Values | Default | Description & Behavior |
|---|---|---|---|
PUBLIC= |
wiki, wiki-vote, wiki-talk, snap-facebook, livejournal, orkut |
none (seed-42 corpus) | Fetches a real Stanford SNAP graph inside the container, remaps schema to Person/FOLLOWS, and targets max-degree hubs. |
GPU= |
0, 1 |
0 (CPU only) |
Enables NVIDIA CUDA acceleration inside Docker. Requires NVIDIA Container Toolkit and LICENSE_FILE=. Neo4j stays on CPU. |
BOTH= |
0, 1 |
0 |
Executes CPU baseline pass followed immediately by GPU acceleration pass on the identical dataset for unified reporting. |
SMOKE= |
0, 1 |
0 |
Runs a miniature 512-node smoke test in under 5 seconds to verify image build integrity and driver communication. |
LICENSE_FILE= |
File path to license | none | Supplies license token required for GPU lane execution (Pro, Pro+, or Enterprise). Free edition requires no license. |
When running the benchmark harness, the terminal displays real-time progress for container initialization, dataset loading, result count validation, and query timings. Below is a sample console trace and generated ladder output.
Every benchmark execution automatically generates verifiable files in bench/out/. Share these directly with teammates or reviewers.
The primary markdown comparison table. Lists each workload, Cypher query shape, result count on both engines, execution latency in milliseconds, and the relative advantage factor. Rows are logged only when result counts match exactly between LightningDB and Neo4j.
Detailed workload telemetry containing individual iteration percentiles (p50, p95, p99), standard deviations, memory usage deltas before and after execution, and breakdown between vector scoring and graph traversal.
Audited machine fingerprint: CPU architecture, available cores, cache sizes, RAM, GPU model and driver version (via nvidia-smi), Docker version, OS kernel, and Neo4j Community build info.
Machine-readable published clock repository matching all figures on this website, linked to reference queries documented in docs/PROOF.md.
The benchmark harness enforces absolute result integrity. If LightningDB and Neo4j return different row counts for any query, the harness flags a failure and will not publish the row. Timing comparisons are valid only when both engines compute identical results on identical graph topology.
The CPU lane runs on any standard Docker host. GPU retrieval runs on NVIDIA hardware with an enabled license tier.
Complete reproduction scripts, benchmark datasets, and documentation are hosted on GitHub.