GraphForge vs. Apache HugeGraph
How do distributed property graph workloads scale, and when is that complexity unnecessary?
Apache HugeGraph graduated to an Apache top-level project in February 2026. It is a full-stack graph system: a Gremlin and Cypher OLTP server, standalone or distributed with Raft-replicated storage; separate Vermeer and Computer engines for algorithms; a loader for files, JDBC, and Kafka; and a GraphRAG toolkit. GraphForge collapses those layers into one in-process engine for single-machine analysis.
On this page
Should I choose Apache HugeGraph or GraphForge?
HugeGraph for a distributed graph service with separate OLAP engines; GraphForge for one-machine analysis.
Choose GraphForge when
- You want algorithms in the same engine that answers queries, not a separate OLAP deployment.
- The analysis fits on one machine and should run with no services.
- You need provenance and recorded hypotheses for an investigation.
Choose Apache HugeGraph when
- You need a distributed OLTP graph service with partition management and replication.
- Ingestion comes from HDFS, relational databases over JDBC, or Kafka through a managed loader.
- You want GraphRAG and graph ML tooling from the same project.
What can each one do?
22 of 26 capabilities differ. For 14, Apache HugeGraph'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 Apache HugeGraph's primary documentation. It does not mean Apache HugeGraph lacks it.
| Capability | GraphForge | Apache HugeGraph |
|---|---|---|
| Storage | ||
| Property graph model | Shipped Labeled property graph with typed properties. 1 | Yes Property graph with explicit schema: VertexLabel, EdgeLabel, PropertyKey, IndexLabel. 19 |
| Document model | Not offered No document-store model; properties accept nested, heterogeneous values. 1 | Not established No document data model documented. |
| Relational tables | Not offered Not a relational database; results arrive as Arrow tables. 1 | Not established No SQL interface; relational databases are only Loader import sources. |
| Key-value access | Not offered No key-value API; data is a property graph. 1 | Not established Stores data in RocksDB internally, but exposes no key-value API. |
| Columnar storage | Shipped Durable projects store graph data as Arrow and Parquet. 4 | Not established No columnar storage documented. |
| Vector search | Shipped Exact cosine retrieval over embeddings you supply; no ANN index. 5 | Partial HugeGraph-AI keeps vectors in external FAISS, Milvus, or Qdrant indexes, not in the graph store. 28 |
| Full-text search | Shipped Tantivy-backed BM25; hybrid text and vector retrieval through find(). 5 | Partial Text search on properties via configurable analyzers (search.text_analyzer); Chinese-oriented analyzer set. 27 |
| Geospatial | Not offered No spatial types or indexes are documented. | Not established No geospatial types or predicates documented. |
| Execution | ||
| Transactional workloads (OLTP) | Partial Local analytical scope; durable atomic writes with queued and optimistic writer modes. 6 | Yes HugeGraph Server is the OLTP engine for real-time queries and transactions. 19 |
| Analytical workloads (OLAP) | Shipped Analytical verbs and Cypher over a local columnar project. 7 | Extension OLAP via separate official engines Vermeer (in-memory) and Computer (distributed BSP), reading HugeGraph data. 1922 |
| Graph traversal | Shipped Cypher MATCH patterns plus BFS, DFS, Dijkstra, A*, and reachability. 8 | Yes Gremlin via TinkerPop-compliant Gremlin Server, plus Cypher and REST traversal APIs. 2023 |
| Variable-length paths | Shipped Bounded and unbounded patterns and shortestPath(). 8 | Yes REST traverser APIs for k-out, k-neighbor, paths, rings, shortest paths; Gremlin repeat(). 24 |
| Graph algorithms | Shipped 94 native algorithms behind analysis verbs, not Cypher CALL procedures. 37 | Extension Algorithms run in separate Vermeer (Go, in-memory) or Computer (Java BSP) engines. 1922 |
| Incremental computation | Not offered Algorithms recompute on request; no incremental mode is documented. 7 | Not established No incremental algorithm maintenance documented. |
| Deployment | ||
| Embedded / in-process | Shipped In-process library; no server, daemon, or connection string. 9 | Not established RocksDB is embedded in the server; no in-process library mode for applications documented. |
| Server mode | Planned Optional remote peer extension planned after 0.6.0. 11 | Yes HugeGraph Server exposes REST (:8080), Gremlin, and Cypher endpoints. 20 |
| WebAssembly | Not planned A browser WebAssembly engine was declined in ADR 0027. 12 | Not established No WebAssembly build documented. |
| Distributed cluster | Not planned Distributed clusters and HA replication are out of scope. 9 | Yes Distributed mode: Server + PD (placement/partitions) + HStore (Raft); docs cite up to 1 PB. 1925 |
| Managed cloud | Not planned No hosted compute. The graphforge.sh Hub distributes repositories; execution stays local. 13 | Not established No official managed service documented; self-deploy via Docker/Helm. |
| Investigation | ||
| Branching | Experimental Research versions, branches, slices, proposals, and forks ship in 0.6.0 release candidates. 14 | Not established No graph branching documented. |
| Snapshots / time travel | Shipped Named checkpoints you can diff and revert, plus transaction-time snapshots. 3 | Not established No point-in-time historical queries documented. |
| Immutable history | Shipped Knowledge ledger records immutable assertions and evidence lineage. 16 | Not established No immutable history documented. |
| Provenance | Shipped Provenance and knowledge ledger with evidence lineage. 16 | Not established Server audit logs exist, but no data 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 | Partial TinkerPop-style transactions; docs say isolation/rollback depend on backend, not cross-backend guarantees. 26 |
| Replication | Not planned HA replication is out of scope. 9 | Yes Each HStore partition is a separate Raft group, surviving loss of a minority of replicas. 25 |
Showing 26 of 26 capabilities.
How is each one built?
Apache HugeGraph: schema-based property graph. 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.
Apache HugeGraph
HugeGraph Server, written in Java, runs with embedded RocksDB in standalone mode. Distributed mode adds HugeGraph-PD for placement and HStore for Raft-replicated partitions. Algorithms run in Vermeer, an in-memory Go engine and the recommended default, or Computer, a Java Pregel engine on Kubernetes or YARN.
HugeGraph separates OLTP, OLAP, and AI into deployable services. GraphForge keeps queries, algorithms, and search together in one engine, which removes data movement but caps scale at one machine.
What the documentation says about Apache HugeGraph
- The ASF announced on 2026-02-12 that Apache HugeGraph graduated from the Incubator to a Top-Level Project.18
- HugeGraph presents itself as a full-stack graph system covering graph database (OLTP), graph computing (OLAP), and graph AI (GraphRAG, graph ML).19
- Standalone mode pairs HugeGraph Server with embedded RocksDB; distributed mode adds HugeGraph-PD for partition management and HStore for Raft-replicated storage.20
- Current mainline drops MySQL, PostgreSQL, Cassandra, ScyllaDB, and Palo backends; HBase is deprecated, with removal planned for 2.x.21
- HugeGraph Server supports both Gremlin (TinkerPop 3) and Cypher (OpenCypher), plus a REST API for schema, data, and traversals.19
- Vermeer is a Go, memory-first, master-worker engine; Computer is a Java BSP/Pregel engine that runs on Kubernetes, YARN, or locally and can spill to disk.19
- HugeGraph-Loader imports from local TEXT/CSV/JSON files, HDFS, relational databases via JDBC, Kafka, or another HugeGraph graph.19
- HugeGraph-AI provides hugegraph-llm (GraphRAG, knowledge-graph construction, Text2Gremlin) and hugegraph-ml (node/graph classification, embeddings, link prediction).19
- Version 1.5.0 and later require Java 11; 1.3.0 was the last release supporting Java 8.17
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 Apache HugeGraph. 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 |
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 |
| ALGO | PageRank, WCC, SCC, Louvain, SSSP | Time, memory, correctness | Not run |
| SCALE | Increasing graph size and density | Throughput degradation, limits | Not run |
| CONCUR | Mixed readers and writers | Throughput, tail latency | Not run |
Which graph algorithms ship?
GraphForge: 94 native algorithms. Apache HugeGraph: 16 named in its docs, delivered as separate product.
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)
Apache HugeGraph
Graph algorithms are not in HugeGraph Server; they run in the HugeGraph-Computer repository's two OLAP engines: Vermeer (Go, in-memory, recommended default, 15+ algorithms) and Computer (Java BSP/Pregel on Kubernetes or YARN). The Server adds REST traverser APIs for path and neighborhood queries.2219
Delivered as: separate product
- PageRank
- Personalized PageRank
- Weakly Connected Components (WCC)
- Strongly Connected Components (SCC)
- Label Propagation (LPA)
- Louvain
- Degree Centrality
- Closeness Centrality
- Betweenness Centrality
- Triangle Count
- K-Core
- Clustering Coefficient
- Single Source Shortest Path (SSSP)
- KOUT
- Global Kout
- Jaccard Similarity Coefficient
Where can each one run?
GraphForge runs in-process only. Apache HugeGraph: embedded not established, server yes, cluster yes.
| Mode | GraphForge | Apache HugeGraph |
|---|---|---|
| Embedded / in-process | Shipped In-process library; no server, daemon, or connection string. 9 | Not established RocksDB is embedded in the server; no in-process library mode for applications documented. |
| Server mode | Planned Optional remote peer extension planned after 0.6.0. 11 | Yes HugeGraph Server exposes REST (:8080), Gremlin, and Cypher endpoints. 20 |
| WebAssembly | Not planned A browser WebAssembly engine was declined in ADR 0027. 12 | Not established No WebAssembly build documented. |
| Distributed cluster | Not planned Distributed clusters and HA replication are out of scope. 9 | Yes Distributed mode: Server + PD (placement/partitions) + HStore (Raft); docs cite up to 1 PB. 1925 |
| Managed cloud | Not planned No hosted compute. The graphforge.sh Hub distributes repositories; execution stays local. 13 | Not established No official managed service documented; self-deploy via Docker/Helm. |
| Replication | Not planned HA replication is out of scope. 9 | Yes Each HStore partition is a separate Raft group, surviving loss of a minority of replicas. 25 |
What will my team write?
GraphForge: openCypher from Python, Node.js, Rust. Apache HugeGraph: Gremlin (Apache TinkerPop 3), Cypher (OpenCypher), REST traverser API.
HugeGraph is reached through Gremlin, Cypher, or REST from Java, Python, Go, or Rust clients. The Cypher API requires an Authorization header even when authentication is disabled. GraphForge is called in-process.
- Query languages
- GraphForge openCypher
- Apache HugeGraph Gremlin (Apache TinkerPop 3), Cypher (OpenCypher), REST traverser API
- SDKs and bindings
- GraphForge Python, Node.js, Rust
- Apache HugeGraph Java, Python, Go, Rust (in development)
- Written in
- GraphForge Rust
- Apache HugeGraph Java (Server, PD, Store, Computer); Go (Vermeer); Python (HugeGraph-AI)
- Surfaces
- GraphForge Python, Node.js, Rust crates, CLI, VS Code extension, Notebooks, Agent skills
What are the trade-offs?
HugeGraph splits OLTP, OLAP, and AI into separate deployments. GraphForge is single-machine with no server.
A fair assessment cuts both ways.
GraphForge
- Single machine only; no partitioned or replicated deployment.
- No managed loader for HDFS, JDBC, or Kafka sources.
- No server mode today.
Apache HugeGraph
- Docs state transaction isolation and rollback boundaries depend on the backend and are not cross-backend guarantees.26
- Users of removed legacy backends (MySQL, PostgreSQL, Cassandra, etc.) must keep running an older compatible release.21
- Vermeer and Computer are separate implementations whose deployment and job configurations are not interchangeable.22
- The Cypher API rejects requests without an Authorization header, even when server authentication is disabled.23
How would I migrate?
Load Apache HugeGraph data through Arrow, pandas, or Polars. Standard openCypher carries over; procedure calls become verb calls.
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 Apache HugeGraph
- Gremlin workloads from other TinkerPop systems are a natural fit; Cypher is also accepted over a dedicated REST endpoint.23
- Data from files, HDFS, JDBC databases, and Kafka is bulk-loaded with HugeGraph-Loader after defining an explicit schema.19
- REST resource paths now include a graph space (/graphspaces/{graphspace}/graphs/{graph}), so older clients and scripts may need path updates.19
What else do people ask about Apache HugeGraph?
Is Apache HugeGraph a top-level Apache project? HugeGraph is an Apache top-level project; its algorithms run in separate Vermeer or Computer engines.
Is Apache HugeGraph a top-level Apache project?
Yes. The Apache Software Foundation announced HugeGraph's graduation from the Incubator on 12 February 2026.
Where do HugeGraph's graph algorithms run?
Not in HugeGraph Server. They run in Vermeer, an in-memory Go engine, or Computer, a Java BSP engine, both in the HugeGraph-Computer repository and deployed separately.
Does HugeGraph support Cypher?
HugeGraph Server supports Gremlin and openCypher plus REST traversal APIs. GraphForge supports openCypher and passes the full openCypher 2024.3 TCK.
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
- Download Apache HugeGraph — hugegraph.apache.org
- The Apache Software Foundation Announces New Top-Level Project (HugeGraph) — ASF News
- Apache HugeGraph Introduction — HugeGraph docs
- apache/hugegraph README — GitHub
- HugeGraph Server README: Backend Evolution and Compatibility — GitHub
- HugeGraph-Vermeer Quick Start — HugeGraph docs
- Cypher API — HugeGraph docs
- Traverser API — HugeGraph docs
- HugeGraph-Store (HStore) Quick Start — HugeGraph docs
- HugeGraph Design Concepts (transaction overview) — HugeGraph docs
- HugeGraph Server Configuration Options — HugeGraph docs
- HugeGraph-LLM — HugeGraph docs
Try GraphForge on your own graph.
Install the package, open a project, and run the same notebook we measure with.