GraphForge vs. GraphScope
How does an embedded engine handle graph analytics that a distributed platform would split across a cluster?
GraphScope is Alibaba's distributed graph computing platform. It combines an analytics engine (GAE) with 23 native algorithms, an interactive Gremlin and Cypher engine, and a GNN learning engine, partitioned across Kubernetes. Its graphscope.nx layer accepts NetworkX code but forwards most algorithms to NetworkX itself. It has had no release since January 2025, and its README says it is not recommended for production yet. GraphForge targets the opposite end: one machine, in-process, with 94 native algorithms.
On this page
Should I choose GraphScope or GraphForge?
GraphScope when the graph must be partitioned across a cluster; GraphForge when it fits on one machine.
Choose GraphForge when
- The graph fits on one machine, which covers many investigations, and you want no cluster to operate.
- You want a stable, actively released engine with durable local persistence.
- You need native algorithms beyond GAE's 23, without falling back to Python NetworkX code.
Choose GraphScope when
- The graph does not fit on one machine and analytics must be partitioned across a cluster.
- You need distributed GNN training over billion-node graphs.
- You run Kubernetes and accept a computing framework without full database guarantees.
What can each one do?
20 of 26 capabilities differ. For 14, GraphScope'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 GraphScope's primary documentation. It does not mean GraphScope lacks it.
| Capability | GraphForge | GraphScope |
|---|---|---|
| Storage | ||
| Property graph model | Shipped Labeled property graph with typed properties. 1 | Yes GAE and GIE operate on the property graph model; graphs partitioned into fragments. 27 |
| 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 relational/SQL interface documented. |
| Key-value access | Not offered No key-value API; data is a property graph. 1 | Not established Groot is built on RocksDB internally, but no key-value API is exposed. |
| Columnar storage | Shipped Durable projects store graph data as Arrow and Parquet. 4 | Partial Vineyard is an in-memory columnar graph store for analytics, not a columnar table engine. 24 |
| Vector search | Shipped Exact cosine retrieval over embeddings you supply; no ANN index. 5 | Not established No vector index in GraphScope docs; HNSW vector search ships in separate NeuG project. |
| Full-text search | Shipped Tantivy-backed BM25; hybrid text and vector retrieval through find(). 5 | Not established No full-text index in GraphScope docs; BM25 FTS ships in separate NeuG project. |
| Geospatial | Not offered No spatial types or indexes are documented. | Not established No geospatial types or indexes documented. |
| Execution | ||
| Transactional workloads (OLTP) | Partial Local analytical scope; durable atomic writes with queued and optimistic writer modes. 6 | Partial Interactive targets high-QPS read queries; writes unsupported there; Groot accepts writes without strict snapshot isolation. 2224 |
| Analytical workloads (OLAP) | Shipped Analytical verbs and Cypher over a local columnar project. 7 | Yes GAE (GRAPE-based) runs distributed whole-graph analytics; core focus of the platform. 2027 |
| Graph traversal | Shipped Cypher MATCH patterns plus BFS, DFS, Dijkstra, A*, and reachability. 8 | Yes GIE executes Gremlin traversals and Cypher read queries over distributed graphs. 2322 |
| Variable-length paths | Shipped Bounded and unbounded patterns and shortestPath(). 8 | Yes GIE supports multi-hop PathExpand and repeat() steps. 23 |
| Graph algorithms | Shipped 94 native algorithms behind analysis verbs, not Cypher CALL procedures. 37 | Yes 23 built-in GAE algorithms (PIE model); custom Pregel/PIE algorithms supported. 19 |
| Incremental computation | Not offered Algorithms recompute on request; no incremental mode is documented. 7 | Partial Ingress framework incrementalizes vertex-centric algorithms; documented under GAE, not general. 26 |
| Deployment | ||
| Embedded / in-process | Shipped In-process library; no server, daemon, or connection string. 9 | Not established No in-process embedded mode documented; Alibaba's embeddable option is separate NeuG. |
| Server mode | Planned Optional remote peer extension planned after 0.6.0. 11 | Yes Interactive exposes Bolt/Cypher endpoint (port 7687); Groot runs as a Gremlin service. 2224 |
| 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 Edge-cut partitioned fragments across Kubernetes pods; engines run cluster-wide. 2725 |
| Managed cloud | Not planned No hosted compute. The graphforge.sh Hub distributes repositories; execution stays local. 13 | Not established Docs cover self-deployment (Helm, Kubernetes); no managed service documented. |
| 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 Groot keeps multi-version rows by snapshot ID, but no historical query API documented. |
| Immutable history | Shipped Knowledge ledger records immutable assertions and evidence lineage. 16 | Not established No immutable history feature documented. |
| Provenance | Shipped Provenance and knowledge ledger with evidence lineage. 16 | Not established No provenance tracking 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 | No Interactive docs: 'ACID is currently not supported'; positioning cites limited transaction support. 2220 |
| Replication | Not planned HA replication is out of scope. 9 | Partial Groot Helm chart has store replica count and optional HA backup store pod. 24 |
Showing 26 of 26 capabilities.
How is each one built?
GraphScope: distributed graph computing. 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.
GraphScope
GraphScope links three engines (GAE, GIE, and GLE) through the Vineyard in-memory store, with Groot as an optional RocksDB-based persistent store. GAE partitions graphs into fragments by edge-cut and runs algorithms with the PIE model. Kubernetes failover relaunches computation but does not recover graph data.
GraphScope scales out by partitioning; GraphForge stays on one machine. Alibaba's own embeddable engine, NeuG, now builds on GraphScope Flex technology. See the NeuG comparison.
What the documentation says about GraphScope
- GraphScope combines three engines: GAE for analytics, GIE for interactive graph queries, and GLE for graph learning, linked by the Vineyard in-memory store.20
- GraphScope's own positioning describes it as a computing framework with limited storage and transaction support, not a full graph DBMS.20
- Its graph stores (in-memory Vineyard and persistent Groot) are described as caching layers; Kubernetes failover relaunches computation but does not recover graph data.20
- GAE partitions large graphs into fragments using an edge-cut strategy.27
- Replacing `import networkx as nx` with `import graphscope.nx as nx` keeps NetworkX code; functions without a GAE builtin are forwarded to NetworkX's own implementation.21
- GraphScope Interactive, built on GraphScope Flex, targets high-throughput concurrent queries and supports Cypher plus C++ stored procedures.22
- Groot is a distributed, RocksDB-based, multi-versioned persistent graph store that serves Gremlin queries and is deployed with Helm on Kubernetes.24
- GLE decouples graph sampling from model training into independently scalable stages for billion-node GNN training.20
- NeuG, Alibaba's embeddable transactional graph database with Cypher, vector, and full-text search, names GraphScope Flex as its engine foundation.28
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 GraphScope. 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 |
|---|---|---|---|
| TRAVERSE | BFS, k-hop, variable-length path | Latency, visited edges/s | Not run |
| ALGO | PageRank, WCC, SCC, Louvain, SSSP | Time, memory, correctness | Not run |
| EMBED | Startup, load, reopen, binary size | ms, MiB, disk footprint | Not run |
| SCALE | Increasing graph size and density | Throughput degradation, limits | Not run |
Which graph algorithms ship?
GraphForge: 94 native algorithms. GraphScope: 23 named in its docs, delivered as bundled.
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)
GraphScope
GAE ships 23 natively implemented built-in algorithms. graphscope.nx natively dispatches a smaller set (~35 NetworkX-named functions) to GAE and forwards every other NetworkX algorithm to NetworkX's own Python code, so NetworkX-accessible algorithms are not GAE-native.1921
Delivered as: bundled
- PageRank
- Single-Source Shortest Paths (SSSP)
- All Pairs Shortest Path Length
- Breadth-First Search (BFS)
- Depth-First Search (DFS)
- Weakly Connected Components (WCC)
- Community Detection Label Propagation (CDLP)
- Label Propagation Algorithm (LPA)
- Local Clustering Coefficient (LCC)
- Clustering
- Betweenness Centrality
- Closeness Centrality
- Degree Centrality
- Eigenvector Centrality
- Katz Centrality
- HITS
- VoteRank
- K-Core
- K-Shell
- Attribute Assortativity
- Degree Assortativity Coefficient
- Average Degree Connectivity
- Sampling Path
Where can each one run?
GraphForge runs in-process only. GraphScope: embedded not established, server yes, cluster yes.
| Mode | GraphForge | GraphScope |
|---|---|---|
| Embedded / in-process | Shipped In-process library; no server, daemon, or connection string. 9 | Not established No in-process embedded mode documented; Alibaba's embeddable option is separate NeuG. |
| Server mode | Planned Optional remote peer extension planned after 0.6.0. 11 | Yes Interactive exposes Bolt/Cypher endpoint (port 7687); Groot runs as a Gremlin service. 2224 |
| 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 Edge-cut partitioned fragments across Kubernetes pods; engines run cluster-wide. 2725 |
| Managed cloud | Not planned No hosted compute. The graphforge.sh Hub distributes repositories; execution stays local. 13 | Not established Docs cover self-deployment (Helm, Kubernetes); no managed service documented. |
| Replication | Not planned HA replication is out of scope. 9 | Partial Groot Helm chart has store replica count and optional HA backup store pod. 24 |
What will my team write?
GraphForge: openCypher from Python, Node.js, Rust. GraphScope: Gremlin, Cypher (read-only subset), Python API (graphscope / graphscope.nx), Pregel/PIE algorithm APIs (C++, Java, Python).
GraphScope is driven from a Python client that launches cluster sessions, with Gremlin, a Cypher subset, and Pregel or PIE APIs for custom algorithms. GraphForge is imported as a package and called directly.
- Query languages
- GraphForge openCypher
- GraphScope Gremlin, Cypher (read-only subset), Python API (graphscope / graphscope.nx), Pregel/PIE algorithm APIs (C++, Java, Python)
- SDKs and bindings
- GraphForge Python, Node.js, Rust
- GraphScope Python, Java, C++
- Written in
- GraphForge Rust
- GraphScope C++ and Rust engines, Java query compiler and store, Python client
- Surfaces
- GraphForge Python, Node.js, Rust crates, CLI, VS Code extension, Notebooks, Agent skills
What are the trade-offs?
GraphScope has had no release since January 2025 and lacks auth. GraphForge is single-machine only.
A fair assessment cuts both ways.
GraphForge
- Single machine only; no partitioning or distributed execution.
- No graph neural network training engine; GraphSAGE and Node2Vec embeddings run in-process.
- No published capacity certification; GraphForge's scale docs state none exists yet.
GraphScope
- The README states the release lacks authentication and encryption and is 'NOT recommended for production use (yet)'.25
- GraphScope Interactive supports only a subset of Cypher read clauses; writes and DDL are not provided and ACID is not supported.22
- Groot groups writes by low-resolution snapshot IDs, giving less consistency than strict snapshot isolation.24
- The last tagged release is v0.31.0 (January 2025), and repository activity in 2026 is sparse.18
How would I migrate?
Load GraphScope 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 GraphScope
- NetworkX scripts can be ported by changing the import to graphscope.nx, but only algorithms with GAE builtins gain distributed execution.21
- Gremlin traversals can target GIE, though only the documented subset of steps is supported.23
- Neo4j-style Cypher read queries run on Interactive over Bolt; write and schema-changing Cypher must be reworked.22
What else do people ask about GraphScope?
How many native algorithms does GraphScope have? GraphScope ships 23 native algorithms; Alibaba's newer embeddable work ships as NeuG.
How many native algorithms does GraphScope have?
GAE ships 23 natively implemented algorithms. graphscope.nx dispatches about 35 NetworkX-named functions to GAE and forwards the rest to NetworkX's own Python implementations, so those are not native.
Is GraphScope still maintained?
Its last tagged release is v0.31.0 from January 2025, and 2026 activity is mostly docs and CI. Alibaba's newer embeddable work ships as NeuG, which builds on GraphScope Flex.
When does a graph need a distributed platform?
When it no longer fits in one machine's memory and disk for the analysis you need. GraphForge publishes no certified capacity limit yet; the benchmark notebook measures a 25,000-node profile.
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
- Release v0.31.0 — alibaba/GraphScope (GitHub)
- Commit history (main) — alibaba/GraphScope (GitHub)
- Built-in Algorithms — GraphScope docs
- Positioning of GraphScope — GraphScope docs (GitHub)
- graphscope.nx algorithms module (builtin dispatch + NetworkX forwarding) — GitHub
- GraphScope Interactive Overview — GraphScope docs (GitHub)
- Supported Gremlin Steps — GraphScope docs (GitHub)
- Groot: Persistent Graph Store — GraphScope docs (GitHub)
- GraphScope README — GitHub
- Ingress: Incrementalize Graph Algorithms — GraphScope docs (GitHub)
- GAE Overview and Architecture — GraphScope docs (GitHub)
- NeuG README — alibaba/neug (GitHub)
Try GraphForge on your own graph.
Install the package, open a project, and run the same notebook we measure with.