Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/axelarnetwork/axelar-core/llms.txt

Use this file to discover all available pages before exploring further.

Building axelard from source gives you full control over the binary you run. The Axelar Core repository supports three build paths: a statically linked binary (recommended for production), a dynamically linked binary for local development, and Docker images for containerized deployments. Before building, you must also supply gateway smart contract bytecode from the axelar-cgp-solidity releases.

​
Prerequisites

Go 1.25+

Required for all build paths. The go.mod declares go 1.25. Download from go.dev.

Docker

Required for the static build. The make build-static target extracts the binary from an Alpine-based image.

gcc / glibc

Required for the dynamic make build path. The resulting binary is tied to your system’s glibc version.

make

GNU Make drives all build targets. Ensure make is on your PATH along with standard build tools.
For a release build, check out the release tag first:
git checkout vX.Y.Z

​
Smart Contract Bytecode Dependency

Axelar Core embeds bytecode from the Axelar gateway smart contracts at compile time. You must supply this before running make generate or any build target that triggers code generation.
1

Find the required contract version

Inspect contract-version.json at the root of the repository to learn which release you need:
cat contract-version.json
# {"gateway":"v6.1.0"}
2

Download from axelar-cgp-solidity releases

Go to the axelar-cgp-solidity releases page and download the matching Bytecode-vX.Y.Z archive. For example:
wget https://github.com/axelarnetwork/axelar-cgp-solidity/releases/download/v6.1.0/Bytecode-v6.1.0.zip
3

Unzip into contract-artifacts/

unzip Bytecode-v6.1.0.zip -d contract-artifacts/
4

Generate the contracts Go file

make generate
This runs go generate ./... and produces x/evm/types/contracts.go from the JSON artifacts.
The static build produces a fully self-contained Linux binary with no runtime dependencies on glibc. It uses an Alpine Linux Docker image that links against musl libc and the static CosmWasm VM library (libwasmvm_muslc.a). The resulting binary runs on any Linux distribution. 
make build-static
This target:
  1. Builds the axelar/core Docker image (Alpine-based, with musl libc).
  2. Creates a temporary container named axelar-extract.
  3. Copies /usr/local/bin/axelard out of the container into ./bin/axelard.
  4. Removes the temporary container.
# Optional overrides
make build-static WASM=false          # Build without CosmWasm support
make build-static IBC_WASM_HOOKS=true # Enable IBC Wasm hooks
After the build completes, confirm the binary is statically linked:
file ./bin/axelard
# axelard: ELF 64-bit LSB executable, x86-64, statically linked

​
Dynamic Build

The dynamic build links against your host system’s glibc. It is faster than the static build because it skips the Docker step, but the binary may not run on systems with a different glibc version. 
make build
The binary is placed at ./bin/axelard. This target sets CGO_ENABLED=1 and uses the ledger build tag by default.
A binary built on Ubuntu 22.04 will not run on Alpine Linux or older glibc versions. For portable production binaries, prefer make build-static.

​
Build Tags

The Makefile controls build tags through the BUILD_TAGS variable:
TagPurpose
ledgerEnables Ledger hardware wallet support via HID. Always included.
muslcEnables static linking against musl libc. Automatically set when MUSLC=true.
When MUSLC=true (set automatically during the static build), the linker flags include: 
-linkmode=external -extldflags '-Wl,-z,muldefs -static'

​
Docker Images

​
Release Image

make docker-image
Creates axelar/core:latest — the same Alpine-based image used by make build-static. Build arguments: 
make docker-image WASM=true IBC_WASM_HOOKS=false ARCH=x86_64

​
Debug Image

make docker-image-debug
Creates axelar/core-debug:latest using Dockerfile.debug. This image bundles delve so a remote debugger can be attached to a running node.

​
Multi-arch Builds

make build-push-docker-images SEMVER=v0.35.0 PLATFORM=linux/amd64
Uses docker buildx to cross-compile and optionally push images. Set PUSH_DOCKER_IMAGE=false to build without pushing.

​
Downloading and Verifying a Release Binary

If you prefer to download a pre-built binary from the Axelar Core releases page rather than building from source, verify its GPG signature before use.
1

Download the binary and signature

From the releases page, download both axelard-<os>-<arch>-vX.Y.Z and its companion .asc file.
2

Import Axelar's public key

curl https://keybase.io/axelardev/pgp_keys.asc | gpg --import
3

Trust the imported key

gpg --edit-key 5D9FFADEED11FA5D
At the gpg> prompt, type trust, select option 5 (ultimate trust), then quit.
4

Verify the binary signature

gpg --verify axelard-linux-amd64-v0.35.0.asc axelard-linux-amd64-v0.35.0
A successful verification prints:
Good signature from "Axelar Network Devs <eng@axelar.network>" [ultimate]
5

Make the binary executable

chmod +x axelard-linux-amd64-v0.35.0
mv axelard-linux-amd64-v0.35.0 /usr/local/bin/axelard

​
Developer Tooling

Install code generation prerequisites required by make generate: 
make prereqs
This installs goimports, stringer, moq, statik, golangci-lint, and mdformat. Ensure $(go env GOPATH)/bin is on your PATH.

Build docs developers (and LLMs) love

Get started for freeTalk to us