Deep research · Fresh sources
Grafeo vs LadybugDB
Completed October 30, 2026
Grafeo vs LadybugDB
Bottom line: These are two free, open-source, pre-1.0 embedded graph databases with nearly opposite design goals. Grafeo is a pure-Rust engine built for breadth: labeled property graphs and RDF in one database, six query languages, built-in vector search and graph algorithms, embeddable or server mode. LadybugDB is the community successor to Kuzu, a C++ columnar engine built for analytical depth: Cypher only, but first-class DuckDB, Parquet, Arrow, and Iceberg interop and scan-heavy graph analytics. As of October 30, 2026, neither has proven production-grade correctness — both have dated, open reports of silent wrong results and durability gaps, and the only head-to-head benchmark is vendor-run. Pick by workload shape and query language, not by speed claims, and validate on your own data before committing.
The short version
| Dimension | Grafeo | LadybugDB |
|---|---|---|
| License | Apache-2.0 (per GitHub org metadata — verify the repo LICENSE file before relying on it) | MIT (stated in project docs) |
| Maturity | Pre-1.0; 0.6.0 shipped 2026-10-24; one more breaking format change (0.7) before 1.0 | Pre-1.0; 0.21.x stable, 0.22.0 shipped 2026-10-26 |
| Lineage | New pure-Rust project, roughly 800 GitHub stars | Active Kuzu fork announced 2025-10-10, backed by Ladybug Inc., roughly 1.8k stars |
| Data models | Labeled property graph (LPG) + RDF triples | Property graph only |
| Query languages | 6: ISO GQL, Cypher, Gremlin, GraphQL, SPARQL, SQL/PGQ | 1: Cypher |
| Deployment | Embedded library or standalone server; memory or disk | Embedded only; single writer per database file |
| Data-plane interop | CSV/JSONL/TSV/Turtle import; Arrow/ADBC driver still in progress | DuckDB attach, Parquet, Arrow, httpfs/S3, Iceberg 'GraphLake' direction |
| Vector / full-text search | Built-in HNSW vector search and hybrid text search | Full-text and vector/HNSW via extensions installed from a runtime CDN |
| Graph algorithms | Built-in (PageRank, Louvain, k-core, shortest path, and more) | None built in |
| Security features in-engine | Encryption at rest (confidentiality only), role controls, CDC hooks | None documented; security is the host process's job |
| Commercial model | No pricing found; an 'enterprise' Cargo feature exists | Free core; Ladybug Inc. commercial plans not documented |
What each product is
Grafeo is a pure-Rust graph database that can be embedded as a library or run as a standalone database, with optional in-memory or persistent storage project README. Its defining bet is convergence: it supports both the LPG and RDF data models and six major query languages — ISO GQL is the default, alongside Cypher, Gremlin, GraphQL, SPARQL, and SQL/PGQ — plus built-in vector search, hybrid text search, and a graph-algorithm library. Bindings span Python, Node.js/TypeScript, Go, C, C#, Dart, and WebAssembly organization page.
The project is young and moving fast. Version 0.6.0 shipped on 2026-10-24 with a rewritten on-disk container and a v2 write-ahead log (WAL) WAL design issue. Databases from 0.5.x migrate automatically the first time 0.6 opens them read-write migration issue, and the project has scheduled one final, deliberate on-disk format revision at 0.7, after which the format is frozen until 1.0 format-revision issue.
LadybugDB is the open-source, MIT-licensed embedded columnar graph database that succeeded Kuzu after that project was archived following an Apple acquisition GDB-Engines Kuzu entry. It was announced on 2025-10-10 and marked its first anniversary in October 2026 one-year retrospective. It keeps Kuzu's embedded, columnar, vectorized C++ engine and Cypher dialect and pitches itself at analytical workloads on larger graphs project documentation. Its standout strength is ecosystem interop: load data from CSV, Parquet, JSON, pandas/Arrow data frames, and more import documentation, attach DuckDB databases and remote files over httpfs, and — since 0.21 — pursue an Iceberg/Parquet 'graph lakehouse' direction called GraphLake.
When to choose each
Choose Grafeo when you need what only Grafeo offers. It is the only option in this pair for any of these: standards-based ISO GQL, SPARQL and an RDF triple store, SQL/PGQ for SQL-shaped teams, or Gremlin. It is also the choice for built-in vector search and graph algorithms in one process, for a standalone server mode, for browser/WebAssembly deployment with a zero-backend client, and for a deliberately low-memory embedded footprint.
Choose LadybugDB when your workload matches its design. Analytical scan-heavy graph queries, Cypher-only product teams, and Kuzu or Neo4j-style property-graph migrations all fit. It is the stronger pick when your data already lives in Parquet, Arrow, or DuckDB, when you need to query remote files without re-ingesting, or when a permissive MIT license and a company-backed monthly release cadence matter.
Each is also clearly wrong for some workloads. LadybugDB has no RDF model, no non-Cypher query surface, and a single writer per database file — poor for concurrent multi-process writes. Grafeo has a second breaking on-disk migration scheduled before 1.0, a thinner community, and near-single-maintainer governance.
Performance: treat every claim as unverified
There is no independent head-to-head benchmark. The only direct Grafeo-vs-LadybugDB comparison is Grafeo's own graph-bench suite, which its README flags as LDBC-inspired rather than official Linked Data Benchmark Council results project README. Its headline embedded numbers at scale factor SF0.1 are Grafeo at 2,904 ms and 136 MB versus 'LadybugDB(Kuzu)' at 5,333 ms and 4,890 MB.
Do not build a sizing or cost model on those numbers, for three reasons:
- It is a vendor-run suite choosing its own workloads and competitor configurations.
- The exact LadybugDB version and commit are not pinned in the published table — it may be a Kuzu-era build rather than current 0.21/0.22 releases.
- The 4,890 MB figure is implausible for a tiny SF0.1 graph and almost certainly reflects LadybugDB's buffer-pool default (up to 0.8× physical RAM, sized from the host) or a measurement artifact rather than real working memory.
The best-supported third-party performance data is the one-year LadybugDB retrospective one-year retrospective, which ran a 30-query LDBC-derived suite at SF1 (about 3.2 million nodes and 17.3 million relationships): LadybugDB 0.21.1 beat Kuzu 0.11.3 on 23 of 30 queries and Neo4j Community on 26 of 30, but was fastest of the three on only 19, and Neo4j stayed more than 10x faster on one query. That suite does not include Grafeo at all.
Practical takeaways: Grafeo's low-memory positioning is plausible but unproven; LadybugDB's analytical strength is directionally supported but inconsistent query-to-query; and Grafeo should not be assumed fast on reopened databases, since its tracker reports reopened v2 files losing property indexes and falling back to scans 27–33x slower. Both engines' fresh-DB numbers may flatter steady-state behavior.
Stability and correctness: the real gate
Both products are pre-1.0, and both have dated, publicly reported reliability problems. Most are self-filed issue-tracker reports — treat them as signals to reproduce on your own workload, not as audited results.
Grafeo's open risk list (October 2026):
- Reopening a v2 database silently drops property indexes; indexed queries degrade to scans 27–33x slower.
open(path)forgets creation configuration (memory limit, threads, WAL durability, spill path) and reopens with defaults.- Requesting 'Serializable' isolation actually yields snapshot isolation; write skew is not prevented.
- Change data capture (CDC) events live only in memory — they do not survive restart or crash, so audit trails can silently vanish.
- Restore and post-compaction writes are not WAL-protected, and restore is not crash-safe.
- RDF-only feature-flag builds silently lose data on reopen.
- Format discipline is a real strength: 0.7 will refuse 0.5.x files with instructions to migrate via 0.6 first, then freeze the format until 1.0 migration issue, format-revision issue.
LadybugDB's open risk list (October 2026):
- Silent wrong rows in chained
OPTIONAL MATCHon 0.21.0–0.21.2 — duplicates rows or drops matches; reported fixed in 0.22.0, with a 0.21.3 point release requested. - Checkpoint and WAL issues: readers losing snapshots when another connection checkpoints, a WAL unreplayable after process termination, and writes applied after a crash when the buffer pool was full.
- A read-write open that writes nothing still upgrades the storage version, locking out older releases.
INSTALLon 0.21.x fetched extensions built from 0.22 sources that then failed toLOAD— the extension channel is tightly version-coupled and has failed in the field.- Resource defaults read the host rather than container cgroup limits (thread count = hardware concurrency; buffer pool up to 0.8× physical RAM), which has already oversubscribed a 24 GB / 12 CPU cell to 49 GB and 20 threads.
- Documentation lag: official install pages still reference an 0.11-era version as 'latest stable' while releases are at 0.21/0.22. Pin versions from package registries, not docs.
Migration hazards with dated external reports. Kuzu-to-Ladybug is close to drop-in at the storage level but not risk-free. One project's database failed to open after upgrade because a catalog-registered JSON extension was missing from the per-user extension directory downstream upgrade issue. Another hit a schema-migration path that silently did nothing and wrote zero relationship rows into an older database downstream migration issue. Cross-engine moves are harder: Grafeo-to-Ladybug keeps only the Cypher queries and requires mapping RDF onto a property graph; Ladybug-to-Grafeo ports most Cypher read syntax but not the table-style DDL, and data must be converted to CSV/JSONL/TSV because Grafeo has no Parquet/Arrow ingest today.
Cost and operational reality
License cost is zero for both: MIT for LadybugDB, Apache-2.0 indicated by Grafeo's org metadata (verify the repository LICENSE file directly — the patent grant is what usually matters when embedding). The real costs are operational:
- Grafeo commits you to a second migration — the 0.7 format revision — before 1.0, with freeze only after that. Single-maintainer concentration (about 90% of recent commits from one author) is a continuity risk. An 'enterprise' Cargo feature flag exists but is currently a feature profile; post-1.0 enterprise language signals possible future gating.
- LadybugDB bills itself in RAM: the buffer pool can default to 0.8× physical RAM and ignore container limits, turning an unconfigured deploy into an out-of-memory event. Its extension features (full-text, vector) arrive from a runtime CDN whose version coupling has demonstrably failed, so pin and cache those artifacts per release.
- Both carry incident risk from the correctness lists above. A silent wrong query result or a lost audit trail can cost far more than any license fee.
Security and compliance
Neither product is a managed service, and neither publishes SOC 2, ISO/IEC 27001, HIPAA, or PCI DSS attestations — the embedding application carries the compliance burden either way.
Grafeo has more building blocks: AES-256-GCM encryption at rest with Argon2id key derivation, role-based access controls, and CDC hooks for audit trails. Each comes with a sharp edge documented in its own tracker: encryption provides confidentiality only (no integrity or freshness against an attacker who can replace or replay files, with a fix planned pre-1.0); isolation is snapshot-level; access control spans a mix of core engine and a TypeScript object-graph-mapper layer that shipped an authorization bypass (published 2026-10-21, since fixed — verify the fixed version); and CDC events are not durable across restarts. The standalone server's TLS and authentication configuration was not confirmed in this research.
LadybugDB ships effectively no security surface of its own: no built-in authentication, encryption, audit logging, or roles in the documented feature set. Embedded design means your process is the boundary, but that becomes a gap the moment data is exposed through the httpfs remote-read extension or a hand-rolled API server (neither ships documented access controls), and runtime-fetched extension binaries are themselves a supply-chain surface.
Recommendation by scenario
- Migrating from Kuzu or a Cypher-based analytical stack: LadybugDB is the natural path. Copy the database first, test the upgraded open, and re-verify row counts after any schema migration.
- Need GQL, SPARQL, SQL/PGQ, or RDF today: Grafeo is the only option in this pair. Accept the pre-1.0 risk and budget for the 0.7 migration.
- Need vector search or graph algorithms inside the database: Grafeo has both built in; LadybugDB would require extensions for vectors and still lacks an algorithm library.
- Scan-heavy analytics over Parquet/Arrow/DuckDB/Iceberg: LadybugDB is materially ahead, and its GraphLake direction points the same way.
- Need a database server: Grafeo. LadybugDB is embedded-only, so you would build the server layer yourself.
- Production-critical data with audit or compliance requirements: neither is a clean yes today. Pin versions, reproduce the known failure classes on your workload, and add external backups and audit regardless of which you choose.
Before you decide: verification checklist
- Confirm Grafeo's license by reading the repository LICENSE file, not org badges.
- Pull current stable versions from PyPI, crates.io, npm, and Maven rather than the LadybugDB docs, which lag behind releases.
- Confirm whether LadybugDB's vector/HNSW and full-text features require
INSTALL/LOADon your platforms, and cache those artifacts. - Check the trackers for which release fixed each bug above — especially the
OPTIONAL MATCHfix and Grafeo's reopen/index behaviors. - Validate Grafeo's server TLS and authentication before exposing it, and treat both engines' stated isolation levels as unproven until you test them.