[opensourcedex]

hugegraph is a free, open source databases project written in Java and released under Apache-2.0. It has 3,182 GitHub stars, 636 forks and 373 open issues, and was last pushed 4 hours ago. On this registry it ranks #65 of 81 tracked projects in Databases, with 5 head-to-head comparisons available. It gained 6 stars over the last 3 tracked days.

What is hugegraph?

What it is

Apache HugeGraph is a graph database written in Java and released under the Apache-2.0 license. It lives in the Apache ecosystem and stores vertices and edges for graph traversal workloads. The project includes an OLTP engine, a REST API, and pluggable backend stores. The repository tagline states support for more than 100+ billion data, while the README excerpt states support for more than 10 billion vertices and edges.

The concrete problem it solves is the need to store, index, and query highly connected data without building a custom graph layer. HugeGraph provides schema metadata, multi-type indexes, and standard query interfaces for graph data. It also connects to big-data systems such as Flink, Spark, and HDFS, which helps teams move graph data through existing data-processing pipelines.

Key capabilities

  • Schema metadata management covers VertexLabel, EdgeLabel, PropertyKey, and IndexLabel.
  • Multi-type indexes support exact query, range query, and complex condition combination query.
  • The plug-in backend store framework uses RocksDB for standalone deployments and HStore for distributed clusters.
  • Dual query language support includes Gremlin through Apache TinkerPop 3 and Cypher through OpenCypher.
  • The client layer exposes Gremlin Console, REST API, Cypher, and SDK or tools access to HugeGraph Server on port 8080.
  • Big data integration is listed for Flink, Spark, and HDFS.
  • The surrounding ecosystem includes Loader, Dashboard, Tool, Java and Python clients, graph computing, and graph AI or knowledge graph components.

Who uses it and how

  • Developers use Gremlin Console, REST API, Cypher, or Java and Python clients to query graph data from HugeGraph Server.
  • Data engineers use Loader to import data and Dashboard to visualize graph data.
  • Operators use standalone deployments with RocksDB when they need to run HugeGraph as a standalone system.
  • Operators use distributed deployments with HStore when they need to scale beyond standalone storage.
  • Analytics teams use the ecosystem components for graph computing, graph AI, or knowledge graph work.

Getting started

Start HugeGraph Server on port 8080, configure RocksDB or HStore as the backend store, and connect through Gremlin Console, REST API, Cypher, or client SDKs.

When to use it — and when not to

Use HugeGraph when you need an Apache-licensed, Java-based graph database with Gremlin and Cypher access and can operate your own backend storage. Self-hosters must run HugeGraph Server, choose and maintain RocksDB or HStore, and manage distributed cluster components when using HStore. The facts do not list a hosted option, Docker image names, package-manager installation steps, or replacement of a named paid product.

project readme (upstream, from github) — read inline

hugegraph-logo

A graph database that supports more than 10 billion vertices & edges, high performance and scalability

License HugeGraph-Server CI HugeGraph-PD & Store CI GitHub Releases Downloads Ask DeepWiki

Quick Navigation: Architecture • Quick Start • Module Map • Ecosystem • For Contributors • Community

What is Apache HugeGraph?

HugeGraph is a fast and highly-scalable graph database. Billions of vertices and edges can be easily stored into and queried from HugeGraph due to its excellent OLTP capabilities. HugeGraph is compliant with the Apache TinkerPop 3 framework allowing complicated graph queries to be achieved through the powerful Gremlin graph traversal language.

Features

  • Schema Metadata Management: VertexLabel, EdgeLabel, PropertyKey, and IndexLabel
  • Multi-type Indexes: Exact query, range query, and complex conditions combination query
  • Plug-in Backend Store Framework: RocksDB powers standalone deployments and HStore powers distributed clusters. See the backend evolution guide for compatibility details.
  • Big Data Integration: Seamless integration with Flink/Spark/HDFS
  • Complete Graph Ecosystem: In/out-memory Graph Computing + Graph Visualization & Tools + Graph Learning & AI
  • Dual Query Language Support: Gremlin (via Apache TinkerPop 3) and Cypher (OpenCypher)

Ecosystem

Complete HugeGraph ecosystem components:

  1. hugegraph-toolchain - Graph tools suite

    • Loader - Data import tool
    • Dashboard - Web visualization platform
    • Tool - Command-line utilities
    • Client - Java/Python client SDK

  2. hugegraph-computer - Integrated graph computing system

  3. hugegraph-ai - Graph AI/LLM/Knowledge Graph integration

  4. hugegraph-website - Documentation & website repository

Architecture

HugeGraph supports both standalone and distributed deployments:

                        ┌─────────────────────────────────────────────────────┐
                        │                    Client Layer                     │
                        │  Gremlin Console │ REST API │ Cypher │ SDK/Tools    │
                        └─────────────────────────┬───────────────────────────┘
                                                  │
                        ┌─────────────────────────▼───────────────────────────┐
                        │             HugeGraph Server (:8080)                │
                        │  ┌──────────┐  ┌──────────┐  ┌──────────────────┐   │
                        │  │ REST API │  │ Gremlin  │  │   Cypher Engine  │   │
                        │  │(Jersey 3)│  │ (TP 3.5) │  │   (OpenCypher)   │   │
                        │  └────┬─────┘  └────┬─────┘  └────────┬─────────┘   │
                        │       └─────────────┼─────────────────┘             │
                        │            ┌────────▼────────┐                      │
                        │            │  Graph Engine   │                      │
                        │            │(hugegraph-core) │                      │
                        │            └────────┬────────┘                      │
                        └─────────────────────┼───────────────────────────────┘
                                              │
                            ┌─────────────────┴─────────────────┐
                            │                                   │
             ┌──────────────▼──────────────┐     ┌──────────────▼──────────────┐
             │        Standalone Mode      │     │       Distributed Mode      │
             │  ┌───────────────────────┐  │     │  ┌───────────────────────┐  │
             │  │        RocksDB        │  │     │  │     HugeGraph-PD      │  │
             │  │      (embedded)       │  │     │  │   (Raft, 3-5 nodes)   │  │
             │  └───────────────────────┘  │     │  │      :8620/:8686      │  │
             │                             │     │  └───────────┬───────────┘  │
             │  Use Case:                  │     │              │              │
             │  Development/Testing        │     │  ┌───────────▼───────────┐  │
             │  Single Node                │     │  │         HStore        │  │
             │                             │     │  │    (Raft, 3+ nodes)   │  │
             │  Data Scale: < 1TB          │     │  │         :8520         │  │
             └─────────────────────────────┘     │  └───────────────────────┘  │
                                                 │                             │
                                                 │  Use Case:                  │
                                                 │  Production/HA/Cluster      │
                                                 │                             │
                                                 │  Data Scale: < 1000 TB      │
                                                 └─────────────────────────────┘

See the backend evolution guide for lifecycle and historical compatibility guidance.

Deployment Mode Comparison

Mode Components Use Case Data Scale High Availability
Standalone Server + RocksDB Development, Testing, Single Node
📊 Click to view detailed architecture diagram (Mermaid)
flowchart TB
    CLIENTS["Client Layer<br/>Gremlin Console · REST Client · Cypher Client · SDK/Tools"]

    subgraph Server["HugeGraph Server :8080"]
        API[REST API<br/>Jersey 3]
        GS[Gremlin Server<br/>TinkerPop 3.5]
        CS[Cypher Engine<br/>OpenCypher]
        CORE[Graph Engine<br/>hugegraph-core]

        API --> CORE
        GS --> CORE
        CS --> CORE
    end

    subgraph Storage["Storage Layer"]
        subgraph Standalone["Standalone Mode"]
            ROCKS[(RocksDB<br/>Embedded)]
        end

        subgraph Distributed["Distributed Mode"]
            PD_HSTORE[PD + HStore<br/>Raft Cluster]
        end
    end

    CLIENTS --> Server
    CORE --> ROCKS
    CORE --> PD_HSTORE

    style Server fill:#e1f5ff
    style Distributed fill:#fff4e1
    style Standalone fill:#f0f0f0

Quick Start

5 Minutes Quick Start

## Start HugeGraph (standalone mode)
docker run -itd --name=hugegraph -p 8080:8080 hugegraph/hugegraph:1.7.0

## Verify server is running
curl http://lo

readme truncated — read the full docs on github

Frequently asked questions

Is hugegraph free to use?

hugegraph is open source under the Apache-2.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does hugegraph do?

A graph database that supports more than 100+ billion data, high performance and scalability (Include OLTP Engine & REST-API & Backends)

What is hugegraph written in?

hugegraph is primarily written in Java. Its source is publicly available at https://github.com/apache/hugegraph, and it has 3,182 GitHub stars.