---
title: "Installation"
sidebar_position: 3
description: "Install Erigon from pre-built binaries, Docker, or source — step-by-step guides for Linux, macOS, and Windows."
---

import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';

export const sectionForMethod = {
  'install-docker':   'all-operating-systems',
  'install-prebuilt': 'linuxmacos',
  'install-source':   'linuxmacos',
  'install-native':   'windows',
  'install-wsl':      'windows',
  'install-arm':      'ethereum-on-arm',
};

export const go = (id, e) => {
  if (e) e.preventDefault();
  const el = document.getElementById(id);
  if (!el) return;

  document.querySelectorAll('details[id^="install-"]').forEach(d => {
    if (d !== el && d.open) {
      const s = d.querySelector('summary');
      if (s) s.click();
      else d.open = false;
    }
  });

  if (!el.open) {
    const summary = el.querySelector('summary');
    if (summary) summary.click();
    else el.open = true;
  }

  const sectionId = sectionForMethod[id];
  if (sectionId) {
    history.replaceState(null, '', '#' + sectionId);
  }

  const resolveTarget = () => {
    let t = sectionId && document.getElementById(sectionId);
    if (!t) {
      let cursor = el.previousElementSibling;
      while (cursor && !/^H[1-6]$/.test(cursor.tagName)) {
        cursor = cursor.previousElementSibling;
      }
      t = cursor || el;
    }
    return t;
  };

  let lastHeight = document.body.scrollHeight;
  let stableFrames = 0;
  let totalFrames = 0;
  const waitForStableLayout = () => {
    const h = document.body.scrollHeight;
    if (h === lastHeight) stableFrames++;
    else { stableFrames = 0; lastHeight = h; }
    totalFrames++;
    if (stableFrames >= 6 || totalFrames >= 90) {
      resolveTarget().scrollIntoView({ behavior: 'smooth', block: 'start' });
    } else {
      requestAnimationFrame(waitForStableLayout);
    }
  };
  requestAnimationFrame(waitForStableLayout);
};


# Installation

To install Erigon, begin by choosing an installation method suited to your operating system and technical preference. Options range from the simplest to the most complex, including pre-built images, containers, or source compilation.

<Tabs>
<TabItem value="linux" label="Linux">
<ul>
  <li><a href="#install-prebuilt" onClick={e => { e.preventDefault(); go('install-prebuilt'); }}><strong>Pre-built Binaries</strong></a> — Fastest way to get started. Download and run a pre-compiled binary for your architecture.</li>
  <li><a href="#install-docker" onClick={e => { e.preventDefault(); go('install-docker'); }}><strong>Docker</strong></a> — Run Erigon in an isolated container. Recommended for most users.</li>
  <li><a href="#install-source" onClick={e => { e.preventDefault(); go('install-source'); }}><strong>Build from Source</strong></a> — Full control over the build. Requires Go, C++ compiler, and CLI experience.</li>
  <li><a href="#install-arm" onClick={e => { e.preventDefault(); go('install-arm'); }}><strong>Ethereum on ARM</strong></a> — Community image and APT repository for ARM single-board computers (Raspberry Pi, Rock 5B, Orange Pi 5).</li>
</ul>
</TabItem>
<TabItem value="macos" label="macOS">
<ul>
  <li><a href="#install-docker" onClick={e => { e.preventDefault(); go('install-docker'); }}><strong>Docker</strong></a> — Run Erigon in an isolated container. The recommended method on macOS.</li>
  <li><a href="#install-source" onClick={e => { e.preventDefault(); go('install-source'); }}><strong>Build from Source</strong></a> — Compile directly on your Mac. Requires Go, Clang/GCC, and CLI experience.</li>
</ul>
</TabItem>
<TabItem value="windows" label="Windows">
<ul>
  <li><a href="#install-native" onClick={e => { e.preventDefault(); go('install-native'); }}><strong>Native Compilation</strong></a> — Compile and run Erigon directly on Windows using Chocolatey, MinGW, and Go.</li>
  <li><a href="#install-wsl" onClick={e => { e.preventDefault(); go('install-wsl'); }}><strong>WSL (Windows Subsystem for Linux)</strong></a> — Run a full Linux environment on Windows. Recommended for best performance.</li>
</ul>
</TabItem>
</Tabs>

### All Operating Systems

<details id="install-docker">

<summary>Docker</summary>

Docker is like a portable container for software. It packages Erigon and everything it needs to run, so you don't have to install complicated dependencies on your computer.

This Docker image is fully supported on **Linux**, **macOS**, and **Windows**.

_(Note: The container itself is built on multi-platform Linux architectures (linux/amd64 and linux/arm64), which is handled automatically by your Docker setup.)_

#### **Prerequisites**

[Docker Engine](https://docs.docker.com/engine/install) if you run Linux or [Docker Desktop](https://docs.docker.com/desktop/) if you run macOS/Windows.

**General Info**

* The Docker images feature several binaries, including: `erigon`, `downloader`, `evm`, `caplin`, `capcli`, `integration`, `rpcdaemon`, `sentry`, and `txpool`.
* The multi-platform Docker image is available for `linux/amd64/v2` and `linux/arm64` platforms and is now based on Debian Bookworm. There's no need to pull a different image for another supported platform.
* All build flags are now passed to the release workflow, allowing users to view previously missed build information in the released binaries and Docker images. This change is also expected to result in better build optimization.
* Docker images now contain the label `org.opencontainers.image.revision`, which refers to the commit ID from the Erigon project used to build the artifacts.
* With recent updates, all build configurations are now included in the release process. This provides users with more comprehensive build information for both binaries and Docker images, along with enhanced build optimizations.
* Images are stored at [https://hub.docker.com/r/erigontech/erigon](https://hub.docker.com/r/erigontech/erigon).

:::warning
**Windows**: note that Docker on Windows is affected by [WSL2 Performance and Data Storage](/get-started/installation/#install-wsl).
:::

#### **Download and start Erigon in Docker**

Here are the steps to download and start Erigon in Docker.

**1. Check which version you want to download**

Check in the GitHub [Release Notes](https://github.com/erigontech/erigon/releases) page which version you want to download (normally latest is the best choice).

**2. Download Erigon container**

Download the chosen version replacing `<version_tag>` with the actual version:

```sh
docker pull erigontech/erigon:<version_tag>
```

For example:

```sh
docker pull erigontech/erigon:v{ERIGON_VERSION}
```

**3. Start the Erigon container**

Start the Erigon container in your terminal:

```sh
docker run -it erigontech/erigon:<version_tag> <flags>
```


For example:

```sh
docker run -it erigontech/erigon:v{ERIGON_VERSION} --chain=hoodi --prune.mode=minimal --datadir /erigon-data
```


* `-v` connects a folder on your computer to the container (must have authorization)
* `-it` lets you see what's happening and interact with Erigon
* `--chain=hoodi` specifies which [network](/fundamentals/supported-networks) to sync
* `--prune.mode=minimal` tells Erigon to use minimal [Pruning Mode](/fundamentals/pruning-modes)
* `--datadir` tells Erigon where to store data inside the container

</details>

### Linux/macOS

<details id="install-prebuilt">

<summary>Pre-built Binaries (Linux Only)</summary>

**1. Select Your Processor Architecture and Download**

Go to the Erigon [releases page](https://github.com/erigontech/erigon/releases) on GitHub and select the latest stable version (e.g., v{ERIGON_VERSION}) or whichever version you prefer.



Download the appropriate binary file for your processor architecture:

| Processor Type | Binary File Type | Example File Name |
| --- | --- | --- |
| 64-bit Intel/AMD | Debian Package (.deb) | erigon_{ERIGON_VERSION}_amd64.deb |
| 64-bit ARM | Debian Package (.deb) | erigon_{ERIGON_VERSION}_arm64.deb |
| 64-bit Intel/AMD | Compressed Archive (.tar.gz) | erigon_v{ERIGON_VERSION}_linux_amd64.tar.gz |
| 64-bit Intel/AMDv2 | Compressed Archive (.tar.gz) | erigon_v{ERIGON_VERSION}_linux_amd64v2.tar.gz |
| 64-bit ARM | Compressed Archive (.tar.gz) | erigon_v{ERIGON_VERSION}_linux_arm64.tar.gz |


Note that the Release Page Assets table contains also the **checksum** for each file and a checksum file.

**2. Verifying Binary Integrity with Checksums**

To verify the integrity and ensure your downloaded Erigon file hasn't been corrupted or tampered with, use the SHA256 checksums provided in the official release by following these steps:

**2.1 Generate the Checksum of Your Downloaded File**

Next, use the `sha256sum` command followed by the name of your downloaded binary (e.g., `erigon_v3.x.x_linux_amd64.tar.gz`).

```sh
sha256sum <DOWNLOADED_FILE_NAME>
```

Example with a `tar.gz` file:

```sh
sha256sum erigon_v{ERIGON_VERSION}_linux_amd64.tar.gz
```

This command will output a long string (the computed checksum) followed by the file name.

**2.2 Compare the Checksums**

Compare the checksum found in the previous step with those in the Release Notes Assets table or the <kbd>erigon\_v3.x.x\_checksums.txt</kbd> file in the same table.

The two checksum strings must match exactly. If they do not match, the file is corrupted, and you should delete it and download it again.

**3. Installing the Binary Executable**

After downloading and verifying the checksum, follow the instructions below based on the file type you chose.

**a. Using Debian Package (`.deb`)**

This method uses your distribution's package manager (like <kbd>dpkg</kbd>) to install Erigon system-wide.

1.  Navigate to the directory where you downloaded the pre-built binary, e.g. Downloads:

    ```bash
    cd ~/Downloads
    ```
2.  Install the package:

    ```bash
    sudo dpkg -i erigon_3.x.x_amd64.deb
    ```

    (Replace the filename with your downloaded version)

**b. Using Compressed Archive (`.tar.gz`)**

This method gives you a standalone executable that can be run from any directory.

1.  Extract the archive:

    ```bash
    tar -xzf erigon_v3.x.x_linux_amd64.tar.gz
    ```

    (Replace the filename with your downloaded version)
2.  Move the resulting `erigon` executable to a directory included in your system's <kbd>$PATH</kbd>(e.g., <kbd>$/usr/local/bin</kbd>) to run it from anywhere:

    ```bash
    sudo mv erigon /usr/local/bin/
    ```

**4. Running Erigon**

After installation, you can run Erigon from your terminal:

```bash
erigon [options]
```

</details>

<details id="install-source">

<summary>Build from Source</summary>

:::info
Building from source gives you full control over the compilation process and lets you run any specific version or branch. It requires Go, a C++ compiler, and basic familiarity with the command line.

If you prefer a simpler setup, the pre-built binaries or Docker options above are recommended for most users.
:::

**1. Software Requirements**

If you intend to build Erigon from source, you must first meet the necessary prerequisites.

**1.1 Git**

Git is a tool that helps download and manage the Erigon source code. To install Git, visit [https://git-scm.com/downloads](https://git-scm.com/downloads).

**1.2 Build essential and Cmake (Linux only)**

Install **Build-essential** and **Cmake**:

```bash
sudo apt install build-essential cmake -y
```

**1.3 Go Programming Language**

Erigon utilizes Go (also known as Golang) version 1.25 or newer for part of its development. It is recommended to have a
fresh Go installation. If you have an older version, consider deleting the `/usr/local/go` folder (you may need to use
`sudo`) and re-extract the new version in its place.

To install the latest Go version, visit the official documentation at [https://golang.org/doc/install](https://golang.org/doc/install).

**1.4 C++ Compiler**

This turns the C++ part of Erigon's code into a program your computer can run. You can use either **Clang** or **GCC**:

* For **Clang** follow the instructions at [https://clang.llvm.org/get\_started.html](https://clang.llvm.org/get_started.html);
* For **GCC** (version 10 or newer): [https://gcc.gnu.org/install/index.html](https://gcc.gnu.org/install/index.html).

**2. Building Erigon from Source**

The basic Erigon configuration is suitable for most users who simply want to run a node. To ensure you are building a specific, stable release, use Git tags.

**2.1 Clone the Erigon repository**

First, clone the Erigon repository (you do not need to specify a branch):

```text
git clone https://github.com/erigontech/erigon.git
cd erigon
```

**2.2 Check Out the Desired Stable Version (Tag)**

Next, fetch all available release tags:

```sh
git fetch --tags
```

Check out the desired version tag by replacing `<tag_name>` with the version you want. Normally latest stable version is the best, check the official [Release Notes](https://github.com/erigontech/erigon/releases). For example:

```sh
git checkout v{ERIGON_VERSION}
```

**2.3 Compile the Software**

Compile the Erigon binary using the `make` command.

Standard Compilation:

```sh
make erigon
```

Fast Compilation (Recommended): to significantly speed up the process, specify the number of processors you want to use with the `-j<n>` option, where `<n>` is the number of processor you want to use (we recommend using a number slightly less than your total core count):

```sh
make -j<n> erigon
```

The resulting executable binary will be created in the `./build/bin/erigon` path.

**3. Running Erigon**

After installation, you can run Erigon from your terminal:

```sh
./build/bin/erigon [options]
```

</details>

### Windows

<details id="install-native">

<summary>Native Compilation</summary>

**1. Software Prerequisites**

You must install the following software and set the below environment variables before compiling Erigon.

**1.1 Chocolatey**

Install _Chocolatey package manager_ by following these [instructions](https://docs.chocolatey.org/en-us/choco/setup).

Once your Windows machine has the above installed, open the **Command Prompt** by typing "**cmd**" in the search bar and check that you have correctly installed Chocolatey:

```bash
choco -v
```



**1.2 `cmake`, `make`, `mingw`**

Now you need to install the following components: `cmake`, `make`, `mingw` by:

```bash
choco install cmake make mingw
```

:::warning
**Important note about Anti-Virus:**

During the compiler detection phase of **MinGW**, some temporary executable files are generated to test the compiler capabilities. It's been reported that some anti-virus programs detect these files as possibly infected with the `Win64/Kryptic.CIS` Trojan horse (or a variant of it). Although these are false positives, we have no control over the 100+ vendors of security products for Windows and their respective detection algorithms and we understand that this may make your experience with Windows builds uncomfortable. To work around this, you can either set exclusions for your antivirus software specifically for the`build\bin\mdbx\CMakeFiles` subfolder of the cloned repo, or you can run Erigon using the other two options below.
:::

**1.3 Git**

Git is a tool that helps download and manage the Erigon source code. To install Git, visit [https://git-scm.com/downloads](https://git-scm.com/downloads).

**1.4 Go Programming Language**

Erigon utilizes Go (also known as Golang) version 1.25 or newer for part of its development. It is recommended to have a
fresh Go installation. If you have an older version, consider deleting the `/usr/local/go` folder (you may need to use
`sudo`) and re-extract the new version in its place.

To install the latest Go version, visit the official documentation at [https://golang.org/doc/install](https://golang.org/doc/install).

**1.5 Set the System Environment Variable**

Make sure that the Windows System Path variable is set correctly. Use the search bar on your computer to search for “**Edit the system environment variable**”.



Click the “**Environment Variables...**” button.



Look down at the "**System variables**" box and double click on "**Path**" to add a new path (or select and click on "**Edit**").



Then click on the "**New**" button and paste the following path:

```bash
 C:\ProgramData\chocolatey\lib\mingw\tools\install\mingw64\bin
```



**2. Clone the Erigon repository**

Open the Command Prompt and type the following:

```bash
git clone https://github.com/erigontech/erigon.git
cd erigon
```

Next, fetch all available release tags:

```bash
git fetch --tags
```

Check out the desired version tag by replacing `<tag_name>` with the version you want. Normally latest stable version is the best, check the official [Release Notes](https://github.com/erigontech/erigon/releases). For example:

```bash
git checkout v{ERIGON_VERSION}
```

You might need to change the `ExecutionPolicy` to allow scripts created locally or signed by a trusted publisher to run. Open a **Powershell session as Administrator** and type:

```powershell
Set-ExecutionPolicy RemoteSigned
```

**3. Compiling Erigon**

This section outlines how to compile the Erigon client and its associated modules directly from the source code on a Windows environment. Compiling from source ensures you are running the latest version and gives you control over the final binaries. All successfully compiled binaries will be placed in the `.\build\bin\` subfolder of your Erigon directory.

Open Git Bash (the shell that comes with Git for Windows) and change to the Erigon directory:

```bash
cd erigon
```

Compile Erigon and its components using `make`:

```bash
make
```

This builds all modules. All binaries will be placed in the `.\build\bin\` subfolder. The executable binary `erigon.exe` should have been created there.

You can also build specific targets, for example:

```bash
make erigon
```

You can use the same command to build other binaries such as `RPCDaemon`, `TxPool`, `Sentry` and `Downloader`.

**4. Running Erigon**

To make Erigon executable from anywhere from your terminal repeat step 1.5 and add Erigon executable path

```text
C:\Users\your-user\erigon.\build\bin\
```

You can now start Erigon by simply using:

```powershell
erigon.exe [options]
```

:::warning
**Note**: When you first start Erigon, Windows Firewall may prompt you to allow internet access. Select "YES" to proceed.
:::

</details>

<details id="install-wsl">

<summary>Window Subsystem for Linux (WSL)</summary>

WSL enables you to run a complete GNU/Linux environment natively within Windows, offering Linux compatibility without the performance and resource overhead of traditional virtual machines.

**Installation and Version**

* Official Installation: Follow Microsoft's official guide to install WSL2: [https://learn.microsoft.com/en-us/windows/wsl/install](https://learn.microsoft.com/en-us/windows/wsl/install)
* Required Version: WSL version 2 is the only version supported by Erigon.

**Building Erigon**

Once WSL2 is set up, you can build and run Erigon exactly as you would on a regular [Linux/macOS](/get-started/installation/#linuxmacos) distribution.

**Performance and Data Storage**

The location of your Erigon data directory (`datadir`) is the most crucial factor for performance in WSL.

| **Data Location**                                                         | **Performance & Configuration**                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| ------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Recommended: Native Linux Filesystem (e.g., in your Linux home directory) | Optimal Performance. Erigon runs without restrictions, and the embedded RPC Daemon works efficiently.                                                                                                                                                                                                                                                                                                                                                            |
| Avoid: Mounted Windows Partitions (e.g., `/mnt/c/`, `/mnt/d/`)            | Performance is reduced as the native Windows drives are mounted using DrvFS (a slower network file system). This affects MDBX database access, and complicates filesystem operations that expect unix-like behaviour. Setting [`automount.options=metadata`](https://learn.microsoft.com/en-us/windows/wsl/wsl-config#automount-options) in `/etc/wsl.conf` in your distribution is recommended, but not required. Note that Docker on Windows is also affected. |

**RPC Daemon Configuration**

The choice of data location directly impacts how you must configure the RPC Daemon:

| **Scenario**                                  | **RPC Daemon Requirement**                                                               |
| --------------------------------------------- | ---------------------------------------------------------------------------------------- |
| Data on Native Linux Filesystem (Recommended) | Use the Embedded RPC Daemon. This is the highly preferred and most efficient method.     |
| Data on Mounted Windows Partition             | The `rpcdaemon` must be configured as a remote DB even when running on the same machine. |

:::warning
⚠️ Warning: The remote DB RPC Daemon is an experimental feature, is not recommended, and is extremely slow. Always aim to use the embedded RPC Daemon by keeping your data on the native Linux filesystem.
:::

**Networking Notes**

Be aware that the default WSL2 environment uses its own internal IP address, which is distinct from the IP address of your Windows host machine.

If you need to connect to Erigon from an external network (e.g., opening a port on your home router for peering on port `30303`), you must account for this separate WSL2 IP address when configuring NAT on your router. Alternatively consider [Mirrored mode networking](https://learn.microsoft.com/en-us/windows/wsl/networking#mirrored-mode-networking).

</details>

### Ethereum on ARM

<details id="install-arm">

<summary>Install with APT on ARM boards</summary>

[Ethereum on ARM](https://ethereum-on-arm-documentation.readthedocs.io/) is a community project that provides a custom Linux image for ARM single-board computers (such as Raspberry Pi, Rock 5B, and Orange Pi 5) with an APT repository preconfigured to install and update Ethereum clients — including Erigon — as native system packages.

Once the image is installed, Erigon can be installed and kept up to date with your system's package manager:

```sh
sudo apt update && sudo apt install erigon
```

For the full image, supported boards, and setup instructions, see the [Ethereum on ARM documentation](https://ethereum-on-arm-documentation.readthedocs.io/) and the [project on GitHub](https://github.com/EOA-Blockchain-Labs/ethereumonarm).

:::info
Ethereum on ARM is maintained independently by the community and is not an official Erigon distribution channel. The Erigon version available through its APT repository may lag behind the latest [GitHub release](https://github.com/erigontech/erigon/releases).
:::

</details>

Once you have Erigon installed, you can see [Basic Usage](/fundamentals/basic-usage) to configure your node and confirm it is syncing.
