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.
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.
| Capability | GraphForge | RocksDB |
|---|---|---|
| Storage | ||
| Property graph model | Shipped 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 model | Not 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 tables | Not 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 access | Not 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 storage | Shipped 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 search | Shipped Exact cosine retrieval over embeddings you supply; no ANN index. 5 | Not established No vector index documented. |
| Full-text search | Shipped Tantivy-backed BM25; hybrid text and vector retrieval through find(). 5 | Not established No full-text index documented. |
| Geospatial | Not 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 traversal | Shipped 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 paths | Shipped Bounded and unbounded patterns and shortestPath(). 8 | No No query language or path semantics. 19 |
| Graph algorithms | Shipped 94 native algorithms behind analysis verbs, not Cypher CALL procedures. 37 | No No algorithm library; storage engine only. 19 |
| Incremental computation | Not 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-process | Shipped In-process library; no server, daemon, or connection string. 9 | Yes C++ library; multiple databases can run in one process. 1719 |
| Server mode | Planned Optional remote peer extension planned after 0.6.0. 11 | No A library that is a building block for servers; ships no server. 17 |
| WebAssembly | Not planned A browser WebAssembly engine was declined in ADR 0027. 12 | Not established No official WebAssembly build documented. |
| Distributed cluster | Not 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 cloud | Not planned No hosted compute. The graphforge.sh Hub distributes repositories; execution stays local. 13 | Not established No managed service. |
| Investigation | ||
| Branching | Experimental 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 travel | Shipped 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 history | Shipped 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 |
| Provenance | Shipped Provenance and knowledge ledger with evidence lineage. 16 | Not established No provenance feature documented. |
| Competing hypotheses | Shipped Immutable hypothesis groups with membership and selection events. 3 | Not established |
| Operations | ||
| ACID transactions | Partial Acknowledged-durable atomic publication; docs do not claim general ACID or serializable isolation. 6 | Yes Atomic WriteBatch; pessimistic TransactionDB and OptimisticTransactionDB. 1920 |
| Replication | Not 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
| Suite | Workloads | Metrics | Status |
|---|---|---|---|
| INGEST | CSV, JSONL, Parquet, graph edge lists | Records/s, MB/s, total elapsed | Not run |
| MUTATE | Insert, update, delete, upsert | Ops/s, p50/p95/p99 latency | Not run |
Query, analytics, and system
| Suite | Workloads | Metrics | Status |
|---|---|---|---|
| LOOKUP | ID lookup, indexed property filter | p50/p95/p99 latency | Not run |
| TRAVERSE | BFS, k-hop, variable-length path | Latency, visited edges/s | Not run |
| EMBED | Startup, load, reopen, binary size | ms, MiB, disk footprint | Not run |
| DURABLE | Restart, recovery, persistence | Recovery time, data integrity | Not 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.
| Mode | GraphForge | RocksDB |
|---|---|---|
| Embedded / in-process | Shipped In-process library; no server, daemon, or connection string. 9 | Yes C++ library; multiple databases can run in one process. 1719 |
| Server mode | Planned Optional remote peer extension planned after 0.6.0. 11 | No A library that is a building block for servers; ships no server. 17 |
| WebAssembly | Not planned A browser WebAssembly engine was declined in ADR 0027. 12 | Not established No official WebAssembly build documented. |
| Distributed cluster | Not 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 cloud | Not planned No hosted compute. The graphforge.sh Hub distributes repositories; execution stays local. 13 | Not established No managed service. |
| Replication | Not 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
- Equivalent workloads. The same logical operation with the same correctness requirement on every engine.
- Native optimized workloads. Each engine's best supported implementation, including projections, indexes, extensions, and native algorithms.
- 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
- GraphForge repository README — GitHub
- GraphForge releases — GitHub
- GraphForge 0.5.0 changelog — GitHub
- Storage architecture — GraphForge Book
- Analytics integration: search and retrieval — GraphForge Guide
- ADR 0018: acknowledged durability and isolation — GitHub
- Algorithm verbs — GraphForge Book
- Cypher guide — GraphForge Guide
- openCypher compatibility — GraphForge Reference
- openCypher TCK compliance — GraphForge Reference
- Remote authority peer extension (#215) — GitHub
- ADR 0027: native runtime boundary — GitHub
- Release scope and roadmap — GraphForge Docs
- Keep research history — GraphForge Guide
- Graph construction — GraphForge Guide
- Knowledge public API v1 — GraphForge Book
- facebook/rocksdb README — GitHub
- Releases · facebook/rocksdb — GitHub
- RocksDB Overview — RocksDB wiki
- Transactions — RocksDB wiki
- Column Families — RocksDB wiki
- RocksDB Tuning Guide — RocksDB wiki
- Replication Helpers — RocksDB wiki
- Read-only and Secondary instances — RocksDB wiki
- User-defined Timestamp — RocksDB wiki
- RocksDB Users and Use Cases — RocksDB wiki
- Wide Columns — RocksDB wiki
- Checkpoints — RocksDB wiki
Try GraphForge on your own graph.
Install the package, open a project, and run the same notebook we measure with.