GraphForge vs. RocksDB

Build on a key-value engine, or use a higher-level graph system?

RocksDB is the persistent LSM key-value engine under MyRocks, TiKV, Apache Flink, and many other systems. It provides column families, transactions, checkpoints, and finely tunable compaction, but no query language, graph model, or algorithms. Building a graph on RocksDB means designing key encodings, indexes, and traversal code yourself. GraphForge provides that layer ready to use, with Cypher, algorithms, and Arrow results.

Not a like-for-like swap. RocksDB is not a graph database. It is a storage foundation. The comparison is building your own graph layer on it versus adopting a graph engine.

Products compared
GraphForgeRocksDB
ModelEmbedded property graphKey-value (LSM tree)
Version0.5.2 stable · 0.6.0-rc.5211.8.1 (2026-08-07)18
LicenseApache-2.0 (since 0.5.0)Dual-licensed GPLv2 or Apache 2.0 (user's choice)
StatusActively maintained2Actively maintained18

Researched 2026-10-19 · 28 primary sources · Head-to-head benchmarks not yet run

On this page

Should I choose RocksDB or GraphForge?

RocksDB to build your own storage layer; GraphForge to get graph queries and algorithms ready-made.

Choose GraphForge when

  • You want graph queries and algorithms rather than an adjacency encoding to maintain yourself.
  • The workload is analysis, so the cost of building and tuning a custom graph layer is not justified.
  • Results should be Arrow tables, not raw byte streams.

Choose RocksDB when

  • You are building a database or storage service and need full control over keys, layout, and compaction.
  • Write throughput and amplification trade-offs must be tuned for specific hardware.
  • Your access pattern is point lookups and range scans, not graph queries.

What can each one do?

22 of 26 capabilities differ. For 12, RocksDB's docs did not confirm support, so they are marked Not established rather than No.

Each capability has a status and a source. “Not established” means we could not confirm the feature from RocksDB's primary documentation. It does not mean RocksDB lacks it.

CapabilityGraphForgeRocksDB
Property graph modelShippedNo
Key-value accessNot offeredYes
Graph algorithmsShippedNo
Embedded / in-processShippedYes
Snapshots / time travelShippedPartial
Capabilities of GraphForge and RocksDB, with release status and sources
CapabilityGraphForgeRocksDB
Storage
Property graph modelShipped

Labeled property graph with typed properties.

1
No

Not a graph database: keys and values are opaque byte streams; any graph encoding is application-defined.

19
Document modelNot offered

No document-store model; properties accept nested, heterogeneous values.

1
Not established

No document model; wide-column entities add named per-key columns.

Relational tablesNot offered

Not a relational database; results arrive as Arrow tables.

1
No

No query language or schema; API is Get/Put/Delete/iterators. SQL layers such as MyRocks are separate projects.

1926
Key-value accessNot offered

No key-value API; data is a property graph.

1
Yes

Sorted key-value store with point lookups, MultiGet and range scans.

19
Columnar storageShipped

Durable projects store graph data as Arrow and Parquet.

4
Not established

Row-per-key LSM storage; wide columns are a per-key data model, not columnar storage.

Vector searchShipped

Exact cosine retrieval over embeddings you supply; no ANN index.

5
Not established

No vector index documented.

Full-text searchShipped

Tantivy-backed BM25; hybrid text and vector retrieval through find().

5
Not established

No full-text index documented.

GeospatialNot offered

No spatial types or indexes are documented.

Not established

No geospatial index documented.

Execution
Transactional workloads (OLTP)Partial

Local analytical scope; durable atomic writes with queued and optimistic writer modes.

6
Partial

Storage engine for point reads, writes and transactions; no query layer.

1920
Analytical workloads (OLAP)Shipped

Analytical verbs and Cypher over a local columnar project.

7
Not established

Range scans only; no analytical query engine.

Graph traversalShipped

Cypher MATCH patterns plus BFS, DFS, Dijkstra, A*, and reachability.

8
No

No query language; traversals must be coded as key lookups and iterator scans.

19
Variable-length pathsShipped

Bounded and unbounded patterns and shortestPath().

8
No

No query language or path semantics.

19
Graph algorithmsShipped

94 native algorithms behind analysis verbs, not Cypher CALL procedures.

37
No

No algorithm library; storage engine only.

19
Incremental computationNot offered

Algorithms recompute on request; no incremental mode is documented.

7
Not established

No incremental view maintenance; merge operators handle per-key read-modify-write only.

Deployment
Embedded / in-processShipped

In-process library; no server, daemon, or connection string.

9
Yes

C++ library; multiple databases can run in one process.

1719
Server modePlanned

Optional remote peer extension planned after 0.6.0.

11
No

A library that is a building block for servers; ships no server.

17
WebAssemblyNot planned

A browser WebAssembly engine was declined in ADR 0027.

12
Not established

No official WebAssembly build documented.

Distributed clusterNot planned

Distributed clusters and HA replication are out of scope.

9
Not established

Single-node engine; distributed systems such as TiKV build on it.

Managed cloudNot planned

No hosted compute. The graphforge.sh Hub distributes repositories; execution stays local.

13
Not established

No managed service.

Investigation
BranchingExperimental

Research versions, branches, slices, proposals, and forks ship in 0.6.0 release candidates.

14
Partial

A checkpoint can be opened read-write as a writable snapshot in a separate directory.

28
Snapshots / time travelShipped

Named checkpoints you can diff and revert, plus transaction-time snapshots.

3
Partial

Read-only checkpoints and user-defined timestamps allow point-in-time reads; in-memory snapshots end at restart.

2528
Immutable historyShipped

Knowledge ledger records immutable assertions and evidence lineage.

16
Partial

With user-defined timestamps, compaction keeps history until full_history_ts_low trims it.

25
ProvenanceShipped

Provenance and knowledge ledger with evidence lineage.

16
Not established

No provenance feature documented.

Competing hypothesesShipped

Immutable hypothesis groups with membership and selection events.

3
Not established
Operations
ACID transactionsPartial

Acknowledged-durable atomic publication; docs do not claim general ACID or serializable isolation.

6
Yes

Atomic WriteBatch; pessimistic TransactionDB and OptimisticTransactionDB.

1920
ReplicationNot planned

HA replication is out of scope.

9
Partial

No built-in replication; helpers include checkpoints, GetUpdatesSince log tailing and secondary instances.

2324

Showing 26 of 26 capabilities.

How is each one built?

RocksDB: key-value (lsm tree). GraphForge: an embedded property graph library in Rust, persisted as Parquet.

GraphForge

GraphForge is a Rust library that runs inside your process: no daemon, server, or connection string. Projects persist to a local directory as Arrow and Parquet data plus JSON metadata, and every query and analysis verb returns an Apache Arrow table. Algorithms run in the same native engine as Cypher and are called as API verbs (rank, cluster, paths, analyze, similar), not as Cypher procedures.

RocksDB

RocksDB stores arbitrary byte keys and values in an LSM tree with multi-threaded compaction. Column families partition data with atomic cross-family writes. Pessimistic and optimistic transactions, checkpoints, user-defined timestamps, and wide columns are all available. Only one read-write instance may open a database at a time.

RocksDB is a lower layer than GraphForge, not an alternative at the same level. A benchmark between them only makes sense against a graph layer built on RocksDB, with that adapter disclosed.

What the documentation says about RocksDB

  • RocksDB is a persistent key-value store for flash and RAM, built on earlier work on Google's LevelDB.17
  • RocksDB uses an LSM design with tunable trade-offs between write, read and space amplification, and multi-threaded compactions.17
  • Keys and values are arbitrarily sized byte streams, and core operations are Get, NewIterator, Put, Delete and SingleDelete.19
  • Column families logically partition a database and support atomic writes and a consistent view across families.21
  • RocksDB offers both pessimistic (TransactionDB) and optimistic (OptimisticTransactionDB) transactions with BEGIN/COMMIT/ROLLBACK.20
  • RocksDB is dual-licensed under GPLv2 and Apache 2.0, at the user's option.17
  • The RocksDB wiki lists MyRocks, TiKV and Apache Flink among systems that use RocksDB as their storage layer.26
  • Wide columns let multiple named columns attach to a key, with the column set varying from row to row.27
  • User-defined timestamps are enabled per column family and stored between the user key and sequence number.25

Which one is faster?

Not measured yet. No head-to-head run has been published, so this page shows no performance chart.

Charts appear only after a reproducible run exists: pinned versions, disclosed hardware, generated data, raw results, and scripts.

No comparative results yet

The suites below apply to GraphForge and RocksDB. Each will be reported separately per benchmark class, never merged into one leaderboard.

Ingestion and writes

SuiteWorkloadsMetricsStatus
INGESTCSV, JSONL, Parquet, graph edge listsRecords/s, MB/s, total elapsedNot run
MUTATEInsert, update, delete, upsertOps/s, p50/p95/p99 latencyNot run

Query, analytics, and system

SuiteWorkloadsMetricsStatus
LOOKUPID lookup, indexed property filterp50/p95/p99 latencyNot run
TRAVERSEBFS, k-hop, variable-length pathLatency, visited edges/sNot run
EMBEDStartup, load, reopen, binary sizems, MiB, disk footprintNot run
DURABLERestart, recovery, persistenceRecovery time, data integrityNot run

Which graph algorithms ship?

GraphForge: 94 native algorithms. RocksDB: no named algorithm library in its docs.

Algorithms are listed by name, as documented. Counts of extension modules or third-party libraries are not presented as native coverage.

GraphForge

94 Rust algorithms run in the engine behind five analysis verbs (rank, cluster, paths, analyze, similar) and return Arrow tables.37

A selection of the catalog:

  • PageRank
  • ArticleRank
  • Betweenness (Brandes)
  • Closeness
  • Harmonic closeness
  • Eigenvector
  • HITS
  • CELF influence maximization
  • Triangle count
  • K-core decomposition
  • Louvain
  • Leiden
  • Label propagation
  • Infomap
  • Walktrap
  • Girvan-Newman
  • Weakly connected components
  • Strongly connected components
  • Dijkstra
  • A*
  • Bellman-Ford
  • Yen's k-shortest paths
  • Max flow / min cut
  • Steiner tree
  • Minimum spanning tree
  • Topological sort
  • Node2Vec
  • GraphSAGE
  • Fast random projection
  • Node similarity (Jaccard)

RocksDB

RocksDB has no analytics or graph algorithms; it is a key-value storage engine that higher-level systems build on.19

Delivered as: n/a

No named algorithm catalog was found in the primary documentation.

Where can each one run?

GraphForge runs in-process only. RocksDB: embedded yes, server no, cluster not established.

ModeGraphForgeRocksDB
Embedded / in-processShipped

In-process library; no server, daemon, or connection string.

9
Yes

C++ library; multiple databases can run in one process.

1719
Server modePlanned

Optional remote peer extension planned after 0.6.0.

11
No

A library that is a building block for servers; ships no server.

17
WebAssemblyNot planned

A browser WebAssembly engine was declined in ADR 0027.

12
Not established

No official WebAssembly build documented.

Distributed clusterNot planned

Distributed clusters and HA replication are out of scope.

9
Not established

Single-node engine; distributed systems such as TiKV build on it.

Managed cloudNot planned

No hosted compute. The graphforge.sh Hub distributes repositories; execution stays local.

13
Not established

No managed service.

ReplicationNot planned

HA replication is out of scope.

9
Partial

No built-in replication; helpers include checkpoints, GetUpdatesSince log tailing and secondary instances.

2324

What will my team write?

GraphForge: openCypher from Python, Node.js, Rust. RocksDB: no query language.

RocksDB is programmed through its C++, C, and Java APIs with Get, Put, Delete, and iterators; graph semantics are entirely application code. GraphForge exposes Cypher and analysis verbs from Python, Node.js, and Rust.

Query languages
GraphForge openCypher
RocksDB None
SDKs and bindings
GraphForge Python, Node.js, Rust
RocksDB C++ (official), C API (official), Java (RocksJava, official, in-repo), Third-party bindings: Python, Go, Rust, Node.js and others
Written in
GraphForge Rust
RocksDB C++
Surfaces
GraphForge Python, Node.js, Rust crates, CLI, VS Code extension, Notebooks, Agent skills

What are the trade-offs?

RocksDB leaves the graph model, queries, and algorithms to you. GraphForge gives up control of storage layout.

A fair assessment cuts both ways.

GraphForge

  • Far less control over storage layout and compaction; GraphForge owns its Parquet project format.
  • Not a general-purpose key-value store.
  • Write throughput is not tuned for high-volume ingest serving.

RocksDB

  • RocksDB is not a graph database: it has no query language, graph model or algorithms, so node/edge key encoding and traversal are application code.19
  • Compaction choices trade write, read and space amplification; the tuning guide notes a write amplification of 50 on a 500 MB/s disk sustains only 10 MB/s of writes.22
  • Only one read-write primary instance may open a database; other processes are limited to read-only or secondary instances.24
  • Snapshots are not persisted across database restarts.19

How would I migrate?

Load RocksDB data through Arrow, pandas, or Polars. Data access code is rewritten as Cypher.

Into GraphForge

  • GraphForge 0.5.x loads data through Arrow, pandas, and Polars bulk calls or Cypher scripts; it has no native CSV loader.15
  • Algorithms are API verbs (rank, cluster, paths, analyze, similar), not Cypher CALL procedures, so procedure calls become verb calls.7
  • GraphForge passes the full openCypher 2024.3 TCK, so standard openCypher queries are the portable part of a migration.10

Moving from RocksDB

  • Graph data in RocksDB uses an application-specific key layout, so moving it to a graph engine needs custom code to decode keys into node and edge records.19
  • A checkpoint gives a consistent point-in-time copy that can be opened read-only as the source for an export.28
  • A secondary instance can read and catch up with a live primary, so exports can run without stopping the writer.24

What else do people ask about RocksDB?

Can RocksDB be used as a graph database? RocksDB is storage only, so it can only be compared through a disclosed graph adapter; GraphForge doesn't use it.

Can RocksDB be used as a graph database?

Only as storage. RocksDB has no graph model, query language, or algorithms, so node and edge encoding and traversal are application code. Several graph systems use it as a backend.

How would you benchmark RocksDB against GraphForge?

Only through a disclosed graph adapter built on RocksDB. A pure RocksDB benchmark cannot measure native PageRank or traversal, because RocksDB has neither.

Does GraphForge use RocksDB?

No. GraphForge persists projects as Arrow and Parquet data plus JSON metadata in a local directory.

How was this researched?

From 28 primary sources, accessed 2026-10-19, each cited where it is used.

Capabilities were checked against primary documentation, repositories, and release notes, accessed 2026-10-19. Each cell records two things: the capability’s state and the evidence behind it. Every GraphForge cell carries a release status. Shipped means stable 0.5.2; experimental means 0.6.0 release candidates only. GraphForge is pre-1.0 and makes no backward-compatibility guarantee yet.

  • Yes documented natively
  • Partial limited or caveated
  • Extension official extension or module
  • Paid edition paid or enterprise edition only
  • Removed removed, with the version cited
  • Not established not confirmed by our research; not a “no”
  • Shipped in stable 0.5.2
  • Partial shipped with documented limits
  • Experimental in 0.6.0 release candidates only
  • Planned on the roadmap
  • Not offered outside the product's model
  • Not planned explicitly out of scope

Benchmark classes

  1. Equivalent workloads. The same logical operation with the same correctness requirement on every engine.
  2. Native optimized workloads. Each engine's best supported implementation, including projections, indexes, extensions, and native algorithms.
  3. End-to-end application workloads. Time from raw data to a usable result: import, indexing, projection, computation, and output retrieval.

Sources · accessed 2026-10-19

  1. GraphForge repository README — GitHub
  2. GraphForge releases — GitHub
  3. GraphForge 0.5.0 changelog — GitHub
  4. Storage architecture — GraphForge Book
  5. Analytics integration: search and retrieval — GraphForge Guide
  6. ADR 0018: acknowledged durability and isolation — GitHub
  7. Algorithm verbs — GraphForge Book
  8. Cypher guide — GraphForge Guide
  9. openCypher compatibility — GraphForge Reference
  10. openCypher TCK compliance — GraphForge Reference
  11. Remote authority peer extension (#215) — GitHub
  12. ADR 0027: native runtime boundary — GitHub
  13. Release scope and roadmap — GraphForge Docs
  14. Keep research history — GraphForge Guide
  15. Graph construction — GraphForge Guide
  16. Knowledge public API v1 — GraphForge Book
  17. facebook/rocksdb README — GitHub
  18. Releases · facebook/rocksdb — GitHub
  19. RocksDB Overview — RocksDB wiki
  20. Transactions — RocksDB wiki
  21. Column Families — RocksDB wiki
  22. RocksDB Tuning Guide — RocksDB wiki
  23. Replication Helpers — RocksDB wiki
  24. Read-only and Secondary instances — RocksDB wiki
  25. User-defined Timestamp — RocksDB wiki
  26. RocksDB Users and Use Cases — RocksDB wiki
  27. Wide Columns — RocksDB wiki
  28. Checkpoints — RocksDB wiki

Try GraphForge on your own graph.

Install the package, open a project, and run the same notebook we measure with.