Skip to content

This is the multi-page printable view of this section. .

Return to the regular view of this page.

Contribution Guidelines

Read the contribution process before submitting code or documentation. Separate pages cover committer nominations, mailing-list subscriptions, and release validation. Contributor agreements follow the official ASF ICLA/CCLA process.

1 - Contribute to the HugeGraph Community

Choose How to Contribute

You can report problems through GitHub Issues, or contribute code, tests, or documentation. Before starting a substantial change, consider opening an issue that explains its scope to avoid duplicated work.

The following example uses apache/hugegraph. The same process applies to other HugeGraph repositories, but follow each repository’s README.md, AGENTS.md, and CI configuration for its build and test commands.

Prepare the Repository

Fork the HugeGraph repository on GitHub

Fork apache/hugegraph on GitHub, then clone your fork:

1git clone https://github.com/<your-name>/hugegraph.git
2cd hugegraph
3git remote add upstream https://github.com/apache/hugegraph.git
4git fetch upstream master

Do not develop directly on master. Use a separate branch for each change:

1git switch master
2git merge --ff-only upstream/master
3git switch -c fix/<short-description>

Make and Verify Changes

HugeGraph Server code is under hugegraph-server/. For example, the core module is located at:

1hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/

Current top-level Maven modules are listed below. Server’s hugegraph-server/hugegraph-hstore/ storage adapter is distinct from the standalone hugegraph-store/ storage-node project.

PathSubmodules
hugegraph-server/hugegraph-core/, hugegraph-api/, hugegraph-example/, hugegraph-dist/, hugegraph-test/, hugegraph-rocksdb/, hugegraph-hbase/, hugegraph-hstore/
hugegraph-pd/hg-pd-common/, hg-pd-client/, hg-pd-core/, hg-pd-service/, hg-pd-dist/, hg-pd-cli/, hg-pd-grpc/, hg-pd-test/
hugegraph-store/hg-store-common/, hg-store-client/, hg-store-core/, hg-store-node/, hg-store-dist/, hg-store-cli/, hg-store-grpc/, hg-store-rocksdb/, hg-store-test/
hugegraph-commons/hugegraph-common/, hugegraph-rpc/
hugegraph-cluster-test/hugegraph-clustertest-minicluster/, hugegraph-clustertest-dist/, hugegraph-clustertest-test/
Independent root moduleshugegraph-struct/, install-dist/

These names come from the root and subproject pom.xml files. Use the structure of the branch you are working on.

For the 1.8.0 shared-foundation changes merged into Server master, see the shared-foundation ownership and Java migration guide.

Build current Server master with Java 17 and Maven 3.6.3 or later. CI-friendly versions are flattened during process-resources, so installed and deployed POMs contain concrete versions. Run the reactor with install before building modules separately, and keep Maven Resolver validation enabled, including with Maven 3.10.

Run the tests directly related to your change first. Common Server test commands include:

1# Core tests with the in-memory backend
2mvn test -pl hugegraph-server/hugegraph-test -am -P core-test,memory
3
4# API tests with the RocksDB backend
5mvn test -pl hugegraph-server/hugegraph-test -am -P api-test,rocksdb
6
7# Format files and verify compilation
8mvn editorconfig:format
9mvn clean compile -Dmaven.javadoc.skip=true

GitHub requires a username and token for Git authentication instead of a username and password. Create a personal access token at https://github.com/settings/tokens:

Authenticate Git pushes with a personal access token

When adding a third-party dependency, also update the license information included in the distribution:

  1. Add the dependency’s license file to install-dist/release-docs/licenses/.

  2. Update install-dist/release-docs/LICENSE. If the dependency includes a NOTICE file, update NOTICE as well.

  3. From the repository root, prepare the current revision’s Server, PD and Store distribution libraries before regenerating the inventory:

    1mvn clean install -DskipTests -Dmaven.javadoc.skip=true
2bash install-dist/scripts/dependency/regenerate_known_dependencies.sh

    Clean rebuilds the current revision’s distributions to avoid stale dependency jars. It also removes every *.tar and *.tar.gz file directly under hugegraph-server/, hugegraph-pd/ and hugegraph-store/, plus the current revision’s apache-hugegraph-<revision>.tar.gz in the repository root; directories of other revisions remain.

    This build skips tests. Collection combines Maven runtime dependencies with actual flat and nested distribution jars, including Spring Boot BOOT-INF/lib dependencies introduced by repackaging. Missing distributions must fail collection; POM inspection alone does not establish the complete shipped inventory. Review strict additions/removals in install-dist/scripts/dependency/known-dependencies.txt and their license/NOTICE coverage, including release platform/profile variants.

Submit a Pull Request

GitHub no longer accepts an account username and password for pushing code. If you need a personal access token, create one with the necessary permissions in token settings.

Make sure the email address used for your commits is associated with your GitHub account. Use email settings:

Verify your commit email on GitHub

Use the type(module): message format for commit messages, for example:

1git add <changed-files>
2git commit -m "fix(core): handle empty vertex query"
3git push -u origin fix/<short-description>

Then open a pull request from your fork branch to apache/hugegraph:master. Explain the problem, the implementation, and the validation commands you actually ran. Include screenshots for UI changes.

Address Review Feedback

If CI fails or a reviewer requests changes, continue committing and pushing to the same branch. Rebase when you need to synchronize with upstream:

1git fetch upstream master
2git rebase upstream/master
3git push --force-with-lease

Do not overwrite the remote branch with plain --force. After all CI and review requirements are satisfied, a project maintainer will merge the pull request.

Contributor agreements follow the official ASF process. See the Contributor Agreement.

2 - Subscribe to the Community Mailing List

HugeGraph uses dev@hugegraph.apache.org for development and usage discussions. Subscribe before sending messages to the list; messages from non-subscribers may be rejected.

Subscribe

  1. From the email address you want to subscribe, send a message with any subject and body to dev-subscribe@hugegraph.apache.org.
  2. Reply directly to the confirmation message.
  3. After receiving the subscription confirmation, you can send messages to dev@hugegraph.apache.org.

If the confirmation does not arrive, check your spam folder and automatic mail categories. If it is still missing, wait a while and send the subscription message again.

You can browse public messages in the ASF Mailing List Archives without subscribing.

Unsubscribe

  1. From your subscribed address, send a message to dev-unsubscribe@hugegraph.apache.org.
  2. Reply directly to the confirmation message from dev-help@hugegraph.apache.org.
  3. Unsubscription is complete when you receive a message whose subject contains GOODBYE.

For general ASF mailing-list guidance, see Apache Mailing Lists.

3 - Validate Apache Release

Note: this doc will be updated continuously. Use Java 17 to build and verify HugeGraph 1.8.0 release packages (the Maven build accepts only JDK 17); use Java 11 for 1.7.0. Since version 1.5.0, components other than the client no longer support Java 8.

Graduation note: Apache HugeGraph graduated in January 2026. Official release voting is now completed within the HugeGraph community (PMC binding votes on dev@hugegraph.apache.org), and no longer requires Incubator general@incubator.apache.org approval.

Automated release validation

The workflow and dist/validate-release.sh use the same Java 17 checks. Specify the package version and SVN RC path separately, and use the Maven staging repository from the vote email. The four Server/Toolchain source and binary archives are required. The same directory may also contain AI and Computer source archives. Every archive must include SHA512 and GPG signatures; unknown packages and mismatched versions are rejected. All present archives receive integrity, contents and license checks; Computer sources are also rebuilt with Maven. AI and Computer product runtime validation remains a separate task.

1bash dist/validate-release.sh --svn-path 1.8.0/RC1 \
2  --staging-repository https://repository.apache.org/content/repositories/<staging-id>/ 1.8.0 imbajin
3# Existing local-package interface is preserved:
4bash dist/validate-release.sh 1.8.0 imbajin /path/to/rc 17

Strict RC validation builds with fresh, separate Maven repositories and does not preinstall a local Server SDK. It validates both source-built and downloaded binaries through Server, Client, ordinary Loader, Tools and Hubble business assertions. Logs remain available after failures. The source-prevalidation workflow mode uses exact Server/Toolchain commit SHAs and unsigned archives; its result does not prove real RC signatures, downloads or remote staging dependency resolution. Review license-review-*.txt for license choices and exceptions; explicit Category-X-only dependencies block validation. Automatic success does not approve the release. The console and GitHub Job Summary show the result, failed phase, review notes and log location. Source prevalidation is clearly separate from RC acceptance. See the validator instructions for local prevalidation and evidence paths.

Verification

When the internal temporary release and packaging work is completed, other community developers ( especially PMC) need to participate in verification based on ASF release policy and checklist references:

  • ASF release policy
  • Incubator checklist (historical reference) To ensure the “correctness + completeness” of someone’s published version, here requires **everyone ** to participate as much as possible, and then explain which items you have checked in the subsequent email reply.(The following are the core items)

1. prepare

If there is no svn or gpg or wget environment locally, it is recommended to install it first (windows recommend using WSL2 environment, or at least git-bash), also make sure to install java (Java 17 for HugeGraph 1.8.0+, Java 11 for 1.7.0) and maven software (≥ 3.6.3)

 1# 1. install svn
 2# ubuntu/debian
 3sudo apt install subversion -y
 4# MacOS
 5brew install subversion
 6# To verify that the installation was successful, execute the following command:
 7svn --version
 8
 9# 2. install gpg
10# ubuntu/debian
11sudo apt-get install gnupg -y
12# MacOS
13brew install gnupg
14# To verify that the installation was successful, execute the following command:
15gpg --version
16
17# 3. install wget (we will enhance it later, like use `curl`)
18# ubuntu/debian
19sudo apt-get install wget -y
20# MacOS
21brew install wget
22
23# 4. Download the hugegraph-svn directory 
24# For version number, pay attention to fill in the verification version
25svn co https://dist.apache.org/repos/dist/dev/hugegraph/1.x.x/
26# (Note) If svn downloads a file very slowly, 
27# you can consider wget to download a single file, as follows (or consider using a proxy)
28wget https://dist.apache.org/repos/dist/dev/hugegraph/1.x.x/apache-hugegraph-toolchain-1.x.x.tar.gz

2. check hash value

First you need to check the file integrity of the source + binary package, Verify by shasum to ensure that it is consistent with the hash value published on apache/GitHub (Usually sha512), Here is the same as the last step of 0x02 inspection.

1execute the following command:
2for i in *.tar.gz; do echo $i; shasum -a 512 --check  $i.sha512; done

3. check gpg signature

This is to ensure that the published package is uploaded by a reliable person. Assuming tom signs and uploads, others should download A’s public key and then perform signature confirmation.

Related commands:

 1# 1. Download project trusted public key to local (required for the first time) & import
 2curl  https://downloads.apache.org/hugegraph/KEYS > KEYS
 3gpg --import KEYS
 4
 5# After importing, you can see the following output, which means that x user public keys have been imported
 6gpg: /home/ubuntu/.gnupg/trustdb.gpg: trustdb created
 7gpg: key BA7E78F8A81A885E: public key "imbajin (apache mail) <jin@apache.org>" imported
 8gpg: key 818108E7924549CC: public key "vaughn <vaughn@apache.org>" imported
 9gpg: key 28DCAED849C4180E: public key "coderzc (CODE SIGNING KEY) <zhaocong@apache.org>" imported
10...
11gpg: Total number processed: x
12gpg:               imported: x
13
14# 2. Compare the full primary-key fingerprint with the release vote email
15release_signer_fingerprint='<signer-full-fingerprint>'
16gpg --fingerprint -- "$release_signer_fingerprint"
17
18# 3. Use a subshell so verification failure does not exit your interactive terminal
19(
20  for archive in *.tar.gz; do
21    gpg --status-fd 1 --verify -- "$archive.asc" "$archive" > "$archive.status" || {
22      status=$?
23      printf 'Signature verification failed: %s\n' "$archive" >&2
24      cat "$archive.status"
25      exit "$status"
26    }
27    cat "$archive.status"
28    if grep -Eq '^\[GNUPG:\] (REVKEYSIG|EXPKEYSIG|EXPSIG)( |$)' "$archive.status"; then
29      printf 'Expired or revoked signature: %s\n' "$archive" >&2
30      exit 1
31    fi
32    grep -q '^\[GNUPG:\] VALIDSIG ' "$archive.status" || {
33      printf 'Missing valid signature: %s\n' "$archive" >&2
34      exit 1
35    }
36  done
37)

Require exit code zero and a VALIDSIG fingerprint matching the vote signer. When a signing subkey is used, compare its reported primary-key fingerprint. A key-trust warning alone does not invalidate a signature; do not infer success from localized Good signature text. Stop on REVKEYSIG, EXPKEYSIG or EXPSIG, even alongside VALIDSIG or exit code zero; ask the release manager to review or update the candidate. See the GnuPG status format.

First confirm the overall integrity/consistency, and then confirm the specific content (key)

4. Check the archive contents

Check the contents of the archive downloaded from preparation work. Divided into two aspects: source code package + binary package, The source code package is stricter, it can be said that the core part (Because it is longer, For a complete list refer to the official Wiki)

A. source package

After decompressing *hugegraph*src.tar.gz, Do the following checks:

  1. package/folder naming should match the release line (historical releases may still contain incubating), and no empty files/folders
  2. LICENSE + NOTICE exist and the content is normal; DISCLAIMER is required for historical incubating artifacts
  3. does not exist binaries (without LICENSE)
  4. The source code files all contain the standard ASF License header (this could be done with the Maven-MAT plugin)
  5. Check whether the pom.xml version number of each parent/child module is consistent (and meet expectations)
  6. Finally, make sure the source code works/compiles correctly
1# prefer to use/switch to `java 17` for HugeGraph 1.8.0+ (`java 11` for 1.7.0) for the following operations (compiling/running) (Note: `Computer` only supports `java >= 11`)
2# java --version
3
4# try to compile in the Unix env to check if it works well (-P is optional)
5mvn -s /path/to/staging-settings.xml -Dmaven.repo.local=/path/to/fresh-m2 \
6  clean install -Papache-release -DskipTests -Dgpg.skip=true

The manual Maven command must use settings pointing to the staging repository from the vote email and a fresh local repository. Do not preinstall local Server SDK artifacts to hide missing staged dependencies. The automated validator configures these settings for you.

B. binary package

After decompressing xxx-hugegraph.tar.gz, perform the following checks:

  1. package/folder naming should match the release line (historical releases may still contain incubating)
  2. LICENSE and NOTICE file exists and the content is normal (DISCLAIMER applies to historical incubating artifacts)
  3. start server
 1# hugegraph-server
 2bin/start-hugegraph.sh
 3
 4# hugegraph-loader
 5bin/hugegraph-loader.sh -g hugegraph -f example/file/struct.json -s example/file/schema.groovy
 6
 7# hugegraph-hubble
 8bin/start-hubble.sh
 9
10more reference official website: https://hugegraph.apache.org/docs/quickstart

Note: If a third-party dependency is introduced in the binary package, you need to update the LICENSE and add the third-party dependent LICENSE; if the third-party dependent LICENSE is Apache 2.0, and the corresponding project contains NOTICE, you also need to update Our NOTICE file

5. Check the official website and GitHub and other pages

  1. Make sure that the official website at least meets apache website check, and no circular links, etc.
  2. Update download link and release notes updated
  3. …

Mail Template

After the check & test, you should reply to the mail with the following content: (normal devs & PMC)

1[] +1 approve
2
3[] +0 no opinion
4
5[] -1 disapprove with the reason
 1+1 (non-binding)
 2I checked:
 31. Download link/tag in mail are valid
 42. Checksum and GPG signatures are OK
 53. LICENSE & NOTICE exist
 64. Build successfully on XX OS & Version XX
 75. No unexpected binary files
 86. Date is right in the NOTICE file
 97. Compile from source is fine under JavaXX
108. No empty file & directory found
119. Test running XXX service OK
1210. ....

and the PMC members should reply with binding, it’s important for summary the valid votes:

 1+1 (binding)
 2I checked:
 31. Download link/tag in mail are valid
 42. Checksum and GPG signatures are OK
 53. LICENSE & NOTICE exist
 64. Build successfully on XX OS & Version XX
 75. No unexpected binary files
 86. Date is right in the NOTICE file
 97. Compile from source is fine under JavaXX
108. No empty file & directory found
119. Test running XX process OK
1210. ....

4 - Setup Server in IDEA (Dev)

Scope: These IDEA instructions are based on the HugeGraph 1.2.0 release tag and retained as historical debugging steps. For current source layout and verification commands, see the contribution process and Server quick start. Do not infer the current module list from this page.

Background

The Quick Start section provides instructions on how to start and stop HugeGraph-Server using scripts. In this guide, we will explain how to run and debug HugeGraph-Server on the Linux platform using IntelliJ IDEA.

The core steps for local startup are the same as starting with scripts:

  1. Initialize the database backend by executing the InitStore class to initialize the graph.
  2. Start HugeGraph-Server by executing the HugeGraphServer class to load the initialized graph information and start the server.

Before proceeding with the following process, make sure that you have cloned the source code of HugeGraph and have configured the development environment, such as Java 17 for HugeGraph 1.8.0+ (Java 11 for 1.7.0) & you could config your local environment with this config-doc

1git clone https://github.com/apache/hugegraph.git

Steps

1. Copy Configuration Files

To avoid the impact of configuration file changes on Git tracking, it is recommended to copy the required configuration files to a separate folder. Run the following command to copy the files:

1cp -r hugegraph-server/hugegraph-dist/src/assembly/static/scripts \
2      hugegraph-server/hugegraph-dist/src/assembly/static/conf \
3      path-to-your-directory

Replace path-to-your-directory with the path to the directory where you want to copy the files. Run the command from the repository root, the hugegraph-dist module lives under the top-level hugegraph-server directory.

The following ToplingDB steps apply only to historical custom builds. Current master contains neither preload-topling.sh nor the ToplingDB module; skip this note when debugging current master.

2. Configure InitStore to initialize the graph

First, you need to configure the database backend in the configuration files. In this example, we will use RocksDB. Open path-to-your-directory/conf/graphs/hugegraph.properties and configure it as follows:

1backend=rocksdb
2serializer=binary
3rocksdb.data_path=.
4rocksdb.wal_path=.

Next, open the Run/Debug Configurations panel in IntelliJ IDEA and create a new Application configuration. Follow these steps for the configuration:

  • Select hugegraph-dist as the Use classpath of module.
  • Set the Main class to org.apache.hugegraph.cmd.InitStore.
  • Set the program arguments to conf/rest-server.properties. Note that the path here is relative to the working directory, so make sure to set the working directory to path-to-your-directory.
  • (Optional, ToplingDB builds only) ToplingDB requires preloading dynamic libraries via the LD_PRELOAD mechanism. Developers need to set two environment variables: LD_LIBRARY_PATH should point to the library directory extracted by preload-topling.sh, and LD_PRELOAD should be set to libjemalloc.so:librocksdbjni-linux64.so to ensure the necessary libraries are correctly loaded at runtime.
    • LD_LIBRARY_PATH=/path/to/your/library:$LD_LIBRARY_PATH
    • LD_PRELOAD=libjemalloc.so:librocksdbjni-linux64.so

If user authentication (authenticator) is configured for HugeGraph-Server in the Java 11 environment, you need to refer to the script configuration in the binary package and add the following VM options:

1--add-exports=java.base/jdk.internal.reflect=ALL-UNNAMED

Otherwise, an error will occur:

1java.lang.reflect.InaccessibleObjectException: Unable to make public static synchronized void jdk.internal.reflect.Reflection.registerFieldsToFilter(java.lang.Class,java.lang.String[]) accessible: module java.base does not "exports jdk.internal.reflect" to unnamed module @xxx

Once the configuration is completed, run it. If the execution is successful, the following runtime logs will be displayed:

 12023-06-05 00:43:37 [main] [INFO] o.a.h.u.ConfigUtil - Scanning option 'graphs' directory './conf/graphs'
 22023-06-05 00:43:37 [main] [INFO] o.a.h.c.InitStore - Init graph with config file: ./conf/graphs/hugegraph.properties
 3......
 42023-06-05 00:43:39 [main] [INFO] o.a.h.b.s.r.RocksDBStore - Write down the backend version: 1.11
 52023-06-05 00:43:39 [main] [INFO] o.a.h.StandardHugeGraph - Graph 'hugegraph' has been initialized
 62023-06-05 00:43:39 [main] [INFO] o.a.h.StandardHugeGraph - Close graph standardhugegraph[hugegraph]
 72023-06-05 00:43:39 [db-open-1] [INFO] o.a.h.b.s.r.RocksDBStore - Opening RocksDB with data path: ./m
 82023-06-05 00:43:39 [db-open-1] [INFO] o.a.h.b.s.r.RocksDBStore - Opening RocksDB with data path: ./s
 92023-06-05 00:43:39 [db-open-1] [INFO] o.a.h.b.s.r.RocksDBStore - Opening RocksDB with data path: ./g
102023-06-05 00:43:39 [main] [INFO] o.a.h.HugeFactory - HugeFactory shutdown
112023-06-05 00:43:39 [hugegraph-shutdown] [INFO] o.a.h.HugeFactory - HugeGraph is shutting down

3. Running HugeGraphServer

Similarly, open the Run/Debug Configurations panel in IntelliJ IDEA and create a new Application configuration. Follow these steps for the configuration:

  • Select hugegraph-dist as the Use classpath of module.
  • Set the Main class to org.apache.hugegraph.dist.HugeGraphServer.
  • Set the program arguments to conf/gremlin-server.yaml conf/rest-server.properties. Similarly, note that the path here is relative to the working directory, so make sure to set the working directory to path-to-your-directory.

bin/hugegraph-server.sh in the binary package does not start this class directly. It starts org.apache.hugegraph.bootstrap.HugeGraphServerBootstrap, which takes a leading true/false security-check flag before the two configuration paths, installs HugeSecurityManager when that flag is true, and then hands over to HugeGraphServer. Running HugeGraphServer from IDEA skips that wrapper, so the security manager is not installed, which is normally what you want while debugging.

Similarly, if user authentication (authenticator) is configured for HugeGraph-Server in the Java 11 environment, you need to refer to the script configuration in the binary package and add the following VM options:

1--add-exports=java.base/jdk.internal.reflect=ALL-UNNAMED --add-modules=jdk.unsupported --add-exports=java.base/sun.nio.ch=ALL-UNNAMED

Otherwise, an error will occur:

1java.lang.reflect.InaccessibleObjectException: Unable to make public static synchronized void jdk.internal.reflect.Reflection.registerFieldsToFilter(java.lang.Class,java.lang.String[]) accessible: module java.base does not "exports jdk.internal.reflect" to unnamed module @xxx

Once the configuration is completed, run it. If you see the following logs, it means that HugeGraphServer has been successfully started:

1......
22023-06-05 00:51:56 [gremlin-server-boss-1] [INFO] o.a.t.g.s.GremlinServer - Gremlin Server configured with worker thread pool of 1, gremlin pool of 8 and boss thread pool of 1.
32023-06-05 00:51:56 [gremlin-server-boss-1] [INFO] o.a.t.g.s.GremlinServer - Channel started at port 8182.

4. Debugging HugeGraphServer (optional)

After completing the above configuration, you can try debugging HugeGraphServer. Run HugeGraphServer in debug mode and set a breakpoint at the following location:

1public String list(@Context GraphManager manager,
2                   @PathParam("graph") String graph, @QueryParam("label") String label,
3                   @QueryParam("properties") String properties, ......) {
4    // ignore log
5    Map<String, Object> props = parseProperties(properties);

Then use the RESTful API to request HugeGraphServer:

1curl "http://localhost:8080/graphspaces/DEFAULT/graphs/hugegraph/graph/vertices" | gunzip

At this point, you can view detailed variable information in the debugger.

5. Log4j2 Configuration

By default, when running InitStore and HugeGraphServer, the Log4j2 configuration file path read is hugegraph-server/hugegraph-dist/src/main/resources/log4j2.xml, not path-to-your-directory/conf/log4j2.xml. This configuration file is read when starting HugeGraph-Server using the script.

To avoid maintaining two separate configuration files, you can modify the Log4j2 configuration file path when running and debugging HugeGraph-Server in IntelliJ IDEA:

  1. Open the previously created Application configuration.
  2. Click on Modify options - Add VM options.
  3. Set the VM options to -Dlog4j.configurationFile=conf/log4j2.xml.

Possible Issues

1. java: package sun.misc does not exist

The reason may be that cross-compilation is triggered when using Java 11 to compile, causing the symbol of sun.misc.Unsafe used in the project to not be found. There are two possible solutions:

  1. In IntelliJ IDEA, go to Preferences/Settings and find the Java Compiler panel. Then, disable the --release option (recommended).
  2. Set the Project SDK to 8 (Deprecated soon).

2. java: *.store.raft.rpc.RaftRequests does not exist (RPC Generated Files)

The reason is that the source code didn’t include the RPC-generated files. You could try 2 ways to fix it:

  1. [CMD]mvn clean compile in the root directory (Recommend)
  2. [UI] right click on the hugegraph repo and select Maven->Generate Sources and Update Folders. This will rebuild the repo and correctly generate the required files.

3. Unable to Print Location Information (%l) in Log4j2

This is because Log4j2 uses asynchronous loggers. You can refer to the official documentation for configuration details.

References

  1. HugeGraph-Server Quick Start: Instructions for setting up HugeGraph-Server.
  2. Local Debugging Guide for HugeGraph Server (Win/Unix)
  3. “package sun.misc does not exist” compilation error
  4. Cannot compile: java: package sun.misc does not exist
  5. The code-style config for HugeGraph in IDEA

5 - Apache HugeGraph Committer Guide

This document outlines the requirements and process for becoming an Apache Committer. The corresponding ASF official document can be found at: https://community.apache.org/newcommitter.html

Candidate Requirements

  1. Candidates must adhere to the Apache Code of Conduct.
  2. PMC members will assess candidates’ interactions with others and contributions through mailing lists, issues, pull requests, and official documentation.
  3. Considerations for evaluating candidates as potential Committers include:
    1. Ability to collaborate with community members
    2. Mentorship capabilities
    3. Community involvement
    4. Level of contribution
    5. Personal skills/abilities

Nomination Process

Discussion → Vote → Invitation → Announcement

Initiate Community Discussion (DISCUSS)

Any PMC member of HugeGraph can initiate a voting discussion. After identifying valuable contributions from a community contributor and obtaining the candidate’s consent, a discussion can be initiated via private@hugegraph.apache.org. The initiator of the discussion should clearly state the candidate’s contributions in the discussion email and provide URLs or other information for confirming the contributions, facilitating discussion and analysis.

Below is a template for HugeGraph emails: (For reference only)

Note: The term xxx will be used to refer to the candidate. Typically, xxx represents an easily readable name (e.g., Simon Jay).

ASF-INFRA recommends avoiding the use of less readable ID directly as a reference to the person in emails (e.g., avoid simon321 or wh0isSim0n 😄).

In addition, it is best to choose the “pure text” mode, otherwise the typesetting may be chaotic in the ASF Mailing-list UI

 1To: private@hugegraph.apache.org
 2Subject: [DISCUSS] XXX as a HugeGraph Committer Candidate
 3
 4Hi all:
 5
 6I am pleased to nominate xxx for the role of HugeGraph Committer based on his/her contributions over the past few months.
 7
 8[ Candidate's Contribution Summary ]
 9
10Here are the relevant PRs (issues) he/she has participated in:
11
12**Core Features:**
13- Feature 1: [ Reference Links ]
14- ...
15
16**Fix/Chore/Release:**
17
18**Doc:**
19
20[ Candidate's Current Notable Contributions ]
21
22His/Her contributions bring the following benefits to the community, helping us in the following ways:
23
24[ Candidate's Contributions and Benefits to the Community ]
25
26In view of the above contributions, I elect xxx as Committer of the HugeGraph project.
27
28[ Reference Links ]
291. PR1
302. PR2
313. ...
32
33Welcome everyone to share opinions~
34
35Thanks!

For contribution links in discussion emails, you can use the statistical feature of GitHub Search by entering corresponding keywords as needed. You can also adjust parameters and add new repositories such as repo:apache/hugegraph-computer. Pay special attention to adjusting the time range (below is a template reference, please adjust the parameters accordingly):

For participation in mailing lists, you can use https://lists.apache.org/list?dev@hugegraph.apache.org:lte=10M:xxx.

Initiate Community Voting Email (VOTE)

If there are no dissenting opinions within the specified time frame of the discussion email, the initiator of the discussion needs to initiate a voting email for the committer election at private@hugegraph.apache.org.

Below is the corresponding email template:

 1To: private@hugegraph.apache.org
 2Subject: [VOTE] xxx as a HugeGraph Committer
 3
 4Hi all:
 5
 6Through the discussion of last week:
 7[ Discussion Mailing List Link ]
 8
 9We have discussed and listed what xxx participated in the HugeGraph community.
10I believe making him/her a Committer will enhance the work for HugeGraph. 
11
12So, I am happy to call VOTE to accept xxx as a HugeGraph Committer.
13 
14Voting will continue for at least 72 hours or until the required number of votes is reached.
15 
16Please vote accordingly:
17[ ] +1 approve
18[ ] +0 no opinion
19[ ] -1 disapprove with the reason  
20
21Thanks!

Then, PMC members reply to the email with +1 or -1 to express their opinions. Generally, at least 3 votes of +1 are needed to conclude the vote.

Announcement of Voting Results (RESULT)

After the voting email concludes, the initiator of the vote needs to remind the end of the voting in the email. Additionally, the initiator needs to announce the voting results via email to private@hugegraph.apache.org. The email template can be as follows:

 1To: private@hugegraph.apache.org
 2Subject: [RESULTS][VOTE] xxx as a HugeGraph Committer
 3
 4Hi all: The vote for "xxx" as a HugeGraph Committer has PASSED and closed now.
 5
 6The result is as follows: X PMC +1 Votes: 
 7- A (PMC ID)
 8- B
 9- C...
10
11Vote thread:
12put vote thread link here
13 
14Then I'm going to invite xxx to join us soon. Thanks for everyone's support!

Send Invitation Email to Candidate (INVITE)

After the announcement of the voting results email is sent, the initiator of the vote should send an invitation email to the candidate. The invitation email is addressed to the candidate and cc’d to private@hugegraph.apache.org. The invited candidate must reply to the specified email address to accept or reject the invitation.

Below is a template for reference:

 1To: [ Candidate's Email ]
 2Cc: private@hugegraph.apache.org
 3Subject: Invitation to become HugeGraph committer: xxx
 4
 5Hello xxx,
 6
 7The HugeGraph Project Management Committee (PMC)
 8hereby offers you committer privileges to the project.
 9These privileges are offered on the understanding that you'll use them
10reasonably and with common sense. We like to work on trust
11rather than unnecessary constraints.
12
13Being a committer enables you to more easily make
14changes without needing to go through the patch
15submission process.
16
17Being a committer does not require you to
18participate any more than you already do. It does
19tend to make one even more committed.  You will
20probably find that you spend more time here.
21
22Of course, you can decline and instead remain as a
23contributor, participating as you do now.
24
25A. This personal invitation is a chance for you to
26accept or decline in private.  Either way, please
27let us know in reply to the private@hugegraph.apache.org
28address only.
29
30B. If you accept, the next step is to register an iCLA:
31    1. Details of the iCLA and the forms are found
32    through this link: https://www.apache.org/licenses/#clas
33
34    2. Instructions for its completion and return to
35    the Secretary of the ASF are found at
36    https://www.apache.org/licenses/#submitting
37
38    3. When you transmit the completed iCLA, request
39    to notify the Apache HugeGraph project and choose a
40    unique Apache ID. Look to see if your preferred
41    ID is already taken at
42    https://people.apache.org/committer-index.html
43    This will allow the Secretary to notify the PMC
44    when your iCLA has been recorded.
45
46When recording of your iCLA is noted, you will
47receive a follow-up message with the next steps for
48establishing you as a committer.
49
50With the expectation of your acceptance, welcome!
51
52The Apache HugeGraph PMC

Candidate Accepts Invitation (ACCEPT)

The candidate should reply to the aforementioned email (select reply all) to indicate acceptance of the invitation. Below is a template for the email:

 1To: [ Sender's Email ]
 2Cc: private@hugegraph.apache.org
 3Subject: Re: Invitation to become HugeGraph committer: xxx
 4
 5Hello Apache HugeGraph PMC,
 6
 7I accept the invitation.
 8
 9Thanks to the Apache HugeGraph Community for recognizing my work, I
10will continue to actively participate in the work of the Apache
11HugeGraph.
12
13Next, I will follow the instructions to complete the next steps:
14Signing and submitting iCLA and registering Apache ID.
15
16xxx

Of course, the candidate may also choose to decline the invitation, in which case there is no template:)

Once the invitation is accepted, the candidate needs to complete the following tasks:

ICLA Signing Process

  1. Download the ICLA
  2. Open the PDF and fill in the required information. All fields must be filled in English. It is recommended to use a PDF tool to edit and sign.
    1. Full name: First name followed by last name
    2. Public name: Optional, defaults to the same as Full name
    3. Check the box only if you entered names with your family name first
    4. Postal Address: English address, starting from small to large, including detailed street address
    5. Country: Country of residence in English
    6. E-mail: Email address, preferably the same as the one used in the invitation email
    7. (optional) preferred Apache id(s): Choose an SVN ID that is not listed on the Apache committer page
    8. (optional) notify project: Apache HugeGraph
    9. Signature: Must be handwritten using a PDF tool
    10. Date: Format as xxxx-xx-xx
  3. After signing, rename icla.pdf to name-pinyin-icla.pdf
  4. Send the following email and attach name-pinyin-icla.pdf as a reference.
 1To: secretary@apache.org
 2Subject: ICLA Information
 3
 4Hello everyone:
 5
 6I have accepted the Apache HugeGraph PMC invitation to
 7become a HugeGraph committer, the attachment is my ICLA information.
 8
 9(Optional) My GitHub account is https://github.com/xxx. Thanks!
10
11xxx

For more details, please refer to https://github.com/apache/hugegraph/issues/1732.

PMC members will await confirmation of the ICLA record from the Apache secretary team. Candidates and PMC members will receive the following email:

1Dear xxx,
2
3This message acknowledges receipt of your ICLA, which has been filed in the Apache Software Foundation records.
4
5Your account (with id xxx) has been requested for you and you should receive email with next steps
6within the next few days (this process can take up to a week).
7
8Please refer to https://www.apache.org/foundation/how-it-works.html#developers
9for more information about roles at Apache.

Setting Up Apache Account and Development Environment (CONFIG)

After the record is completed, the candidate will receive an email from root@apache.org with the subject Welcome to the Apache Software Foundation. At this point, the candidate needs to follow the steps in the email to set up the Apache account and development environment:

  1. Reset the password at https://id.apache.org/reset/enter.
  2. Configure personal information at https://whimsy.apache.org/roster/committer/xxx.
  3. Associate GitHub account at https://gitbox.apache.org/boxer.
    • This step requires configuring GitHub Two-Factor Authentication (2FA).
  4. The nominating PMC member must add the new Committer to the official list of committers via the Roster page. (Important, otherwise repository permissions will not take effect).
    • After this step, the candidate becomes a new Committer and gains write access to the GitHub HugeGraph repository.
  5. (Optional) The new Committer can apply for free use of JetBrains’ full range of products with their Apache account here.

Announcing via Email (ANNOUNCE)

After the candidate completes the above steps, they will officially become a Committer of HugeGraph. At this point, they need to send an announcement email to dev@hugegraph.apache.org. Below is a template for the email:

 1To: dev@hugegraph.apache.org
 2Subject: [ANNOUNCE] New Committer: xxx
 3
 4Hi everyone, The PMC for Apache HugeGraph has invited xxx to
 5become a Committer and we are pleased to announce that he/she has accepted.
 6
 7xxx is being active in the HugeGraph community & dedicated to ... modules, 
 8and we are glad to see his/her more interactions with the community in the future.
 9
10(Optional) His/Her GitHub account is https://github.com/xxx
11
12Welcome xxx, and please enjoy your community journey~ 
13
14Thanks! 
15
16The Apache HugeGraph PMC

Update Governance Information

Since Apache HugeGraph graduated in January 2026, governance information is maintained in ASF committee/project data rather than Incubator clutch pages.

Please check:

If an update is required but does not appear automatically, coordinate with Apache Community Development or ASF Infra according to the official process.

References

  1. https://community.apache.org/newcommitter.html (ASF official documentation)
  2. https://infra.apache.org/new-committers-guide.html
  3. https://www.apache.org/dev/pmc.html#newcommitter
  4. https://linkis.apache.org/zh-CN/community/how-to-vote-a-committer-pmc
  5. https://www.apache.org/licenses/contributor-agreements.html#submitting
  6. https://www.apache.org/licenses/cla-faq.html#printer
  7. https://linkis.apache.org/zh-CN/community/how-to-sign-apache-icla
  8. https://github.com/apache/hugegraph/issues/1732 (HugeGraph ICLA related issue)