hugegraph is a free, open source databases project written in Java and released under Apache-2.0. It has 3,196 GitHub stars, 645 forks and 373 open issues, and was last pushed 2 days ago. On this registry it ranks #180 of 206 tracked projects in Databases, with 5 head-to-head comparisons available. It gained 4 stars over the last 30 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
A graph database that supports more than 10 billion vertices & edges, high performance and scalability
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:
hugegraph-toolchain - Graph tools suite
- Loader - Data import tool
- Dashboard - Web visualization platform
- Tool - Command-line utilities
- Client - Java/Python client SDK
hugegraph-computer - Integrated graph computing system
hugegraph-ai - Graph AI/LLM/Knowledge Graph integration
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
📊 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://localhost:8080/versions
# Try a Gremlin query
curl -X POST http://localhost:8080/gremlin \
-H "Content-Type: application/json" \
-d '{"gremlin":"g.V().limit(5)"}'
Production Note: For production environments or public network exposure, you must enable the AuthSystem for security.
Prerequisites
- Java 11+ (required)
- Maven 3.5+ (for building from source)
Option 1: Docker (Fastest)
Docker is the quickest way to get started for testing or development:
# Basic usage
docker run -itd --name=hugegraph -p 8080:8080 hugegraph/hugegraph:1.7.0
# With sample graph preloaded
docker run -itd --name=hugegraph -e PRELOAD=true -p 8080:8080 hugegraph/hugegraph:1.7.0
# With authentication enabled
docker run -itd --name=hugegraph -e PASSWORD=your_password -p 8080:8080 hugegraph/hugegraph:1.7.0
For advanced Docker configurations, see:
Docker Desktop (Mac/Windows): The 3-node distributed cluster (docker/docker-compose-3pd-3store-3server.yml) uses Docker bridge networking and works on all platforms including Docker Desktop. Allocate at least 12 GB memory to Docker Desktop.
Note: Docker images are convenience releases, not official ASF distribution artifacts. See ASF Release Distribution Policy for details.
Version Tags: Use release tags (e.g., 1.7.0) for stable deployments. The latest tag should only be used for testing or development.
Option 2: Download Binary Package
Download pre-built packages from the Download Page:
# Download and extract
# For historical 1.7.0 and earlier releases, use the archive URL and
# set PACKAGE=apache-hugegraph-incubating-{version} instead.
BASE_URL="https://downloads.apache.org/hugegraph/{version}"
PACKAGE="apache-hugegraph-{version}"
# Historical alternative:
# BASE_URL="https://archive.apache.org/dist/incubator/hugegraph/{version}"
# PACKAGE="apache-hugegraph-incubating-{version}"
wget ${BASE_URL}/${PACKAGE}.tar.gz
tar -xzf ${PACKAGE}.tar.gz
cd ${PACKAGE}
# Initialize backend storage
bin/init-store.sh
# Start server
bin/start-hugegraph.sh
# Check server status
bin/monitor-hugegraph.sh
For detailed instructions, see the Binary Installation Guide.
Option 3: Build from Source
Build from source for development or customization:
# Clone repository
git clone https://github.com/apache/hugegraph.git
cd hugegraph
# Build all modules (skip tests for faster build)
mvn clean package -DskipTests
# Extract built package
tar -xzf target/apache-hugegraph-{version}.tar.gz
cd apache-hugegraph-{version}/apache-hugegraph-server-{version}
# Initialize and start
bin/init-store.sh
bin/start-hugegraph.sh
For detailed build instructions, see BUILDING.md and Build from Source Guide.
Verify Installation
Once the server is running, verify the installation:
# Check server version
curl http://localhost:8080/versions
# Expected output:
# {
# "versions": {
# "version": "v1",
# "core": "1.7.0",
# "gremlin": "3.5.1",
# "api": "1.7.0"
# }
# }
# Try Gremlin console (if installed locally)
bin/gremlin-console.sh
# In Gremlin console:
gremlin> :remote connect tinkerpop.server conf/remote.yaml
gremlin> :> g.V().limit(5)
For comprehensive documentation, visit the HugeGraph Documentation.
Module Map
Developer Navigation: Find the right module for your task
For detailed architecture and development guidance, see AGENTS.md.
For Contributors
New to HugeGraph? Follow this path to get started:
Understand the Architecture
Set Up Your Environment
- Install Java 11+ and Maven 3.5+
- Follow BUILDING.md for build instructions
- Configure your IDE to use
.editorconfig for code style and style/checkstyle.xml for Checkstyle rules
Find Your First Issue
Learn the Codebase
- Use the Module Map to navigate
- Try DeepWiki for AI-powered codebase understanding
- Run tests to understand behavior:
mvn test -pl hugegraph-server/hugegraph-test -am -P core-test,memory
- Try modifying a test and see what breaks
Code Standards
- Line length: 120 characters
- Indentation: 4 spaces
- No star imports
- Commit format:
feat|fix|refactor(module): description
Submit Your Contribution
Contributing
Welcome to contribute to HugeGraph!
Thank you to all the contributors who have helped make HugeGraph better!
License
HugeGraph is licensed under Apache 2.0 License.
Community
Get Help & Stay Connected
Thanks
HugeGraph relies on the Apache TinkerPop framework. We are grateful to the TinkerPop community, Titan, and DataStax for their foundational work. Thanks to all contributors and organizations who have helped make HugeGraph possible.
You are welcome to contribute to HugeGraph, and we look forward to working with you to build an excellent open-source community.