anchor build

Build Anchor programs with optional IDL generation and verifiable builds

Overview

The anchor build command compiles Solana programs in the workspace using cargo build-sbf and generates Interface Definition Language (IDL) files.

Command Syntax

anchor build [OPTIONS]

Alias

anchor b

Options

Build Configuration

--skip-lint · flag · default: "false"

Skip checking for safety comments (“CHECK”) in the code

--ignore-keys · flag · default: "false"

Skip checking for program ID mismatch between keypair and declare_id!

--program-name · string

Name of a specific program to build (builds all programs if not specified)

--arch · enum · default: "sbf"

Architecture to use when building the program

Options: sbf, bpf

IDL Options

--no-idl · flag · default: "false"

Do not build the IDL

--idl · string

Output directory for the IDL (defaults to target/idl)

--idl-ts · string

Output directory for the TypeScript IDL (defaults to target/types)

--no-docs · flag · default: "false"

Suppress doc strings in IDL output

Verifiable Builds

--verifiable · flag · default: "false"

Build artifact must be deterministic and verifiable using Docker

--solana-version · string

Solana toolchain version to use (for verifiable builds only)

--docker-image · string

Custom Docker image to use (for verifiable builds only)

--bootstrap · enum · default: "none"

Bootstrap Docker image from scratch, installing all requirements

Options: none, debian

--env · array

Environment variables to pass into the Docker container (for verifiable builds)

Additional Arguments

cargo_args · string

Arguments to pass to the underlying cargo build-sbf command (use -- to separate)

Examples

Basic Build

Build all programs in the workspace:

anchor build

Output:

Building program...
Build success

Build Specific Program

anchor build --program-name my_program

Verifiable Build

Create a deterministic build that can be verified:

anchor build --verifiable

With a specific Solana version:

anchor build --verifiable --solana-version 2.0.6

Custom IDL Output

anchor build --idl ./custom-idl --idl-ts ./custom-types

Build Without IDL

anchor build --no-idl

Pass Additional Cargo Arguments

anchor build -- --features "my-feature"

Build with Environment Variables (Verifiable)

anchor build --verifiable --env "VAR1=value1" --env "VAR2=value2"

Output Structure

After a successful build, artifacts are located in:

target/
├── deploy/
│   ├── my_program.so          # Compiled program binary
│   └── my_program-keypair.json
├── idl/
│   └── my_program.json        # JSON IDL
├── types/
│   └── my_program.ts          # TypeScript types
└── verifiable/                 # Verifiable build artifacts (if --verifiable)
    └── my_program.so

Verifiable Builds

Verifiable builds use Docker to ensure deterministic compilation:

1. Creates a Docker container with the specified Solana version
2. Compiles the program inside the container
3. Copies the build artifact to target/verifiable/
4. Allows anyone to reproduce the exact same binary

Verifiable builds require Docker to be installed and running on your system.

Build Process

The build command:

1. Checks for program ID mismatches (unless --ignore-keys is set)
2. Runs pre-build hooks (if configured in Anchor.toml)
3. Compiles the Rust program using cargo build-sbf
4. Generates IDL from the compiled program (unless --no-idl is set)
5. Writes IDL JSON and TypeScript types to output directories
6. Runs post-build hooks (if configured)

IDL Generation

The IDL is automatically generated and includes:

• Program instructions and their parameters
• Account structures
• Custom types and enums
• Error codes
• Documentation strings (unless --no-docs is specified)

Notes

Overflow checks are required in the release profile. The build will fail if they are disabled.

Use --verifiable when preparing programs for public deployment to allow others to verify your build matches the on-chain bytecode.

The default architecture is sbf (Solana Bytecode Format). The bpf option is for legacy compatibility.