> ## Documentation Index
> Fetch the complete documentation index at: https://docs.parallaxprotocol.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Installing the Parallax Client

There are several ways to install the Parallax client, including via a package manager, downloading a pre-built bundle, running as a docker container or building from downloaded source code.

<Note>
  Not comfortable with the terminal? **[Parallax Desktop](../../guides/client/desktop)** is a native GUI application that bundles a full Parallax node in a single installer for Windows, macOS, and Linux — no command line required. The rest of this page covers the CLI client.
</Note>

On this page the various installation options are explained for several major operating systems. Users prioritizing ease of installation should choose to use a package manager or prebuilt bundle. Users prioritizing customization should build from source. It is important to run the latest version of the Parallax client because each release includes bug fixes and improvements over the previous versions. The stable releases are recommended for most users because they have been fully tested. A list of stable releases can be found [here](https://github.com/ParallaxProtocol/parallax/releases). Instructions for updating existing Parallax installations are also provided in each section.

## Package managers

Not yet available in package managers.

## Standalone bundle

Stable releases and development builds are provided as standalone bundles. These are useful for users who: a) wish to install a specific version of the Parallax client (e.g., for reproducible environments); b) wish to install on machines without internet access (e.g. air-gapped computers); or c) wish to avoid automatic updates and instead prefer to manually install software.

The following standalone bundles are available:

* 32bit, 64bit, ARMv5, ARMv6, ARMv7 and ARM64 archives (.tar.gz) on Linux
* 64bit archives (.tar.gz) on macOS
* 32bit and 64bit archives (.zip) and installers (.exe) on Windows

Some archives contain only the Parallax suite — `parallaxd` (full-node daemon), `parallax-cli` (JSON-RPC client) and `parallax` (multi-call wrapper) — while other archives bundle the suite together with the developer tools (clef, devp2p, abigen, bootnode, evm, rlpdump).

The standalone bundles can be downloaded from the [Parallax client Releases](https://github.com/ParallaxProtocol/parallax/releases) page. To update an existing installation, download and manually install the latest version.

## Docker container

Official images are published to [Docker Hub](https://hub.docker.com/r/parallaxprotocol/parallax) for `linux/amd64` and `linux/arm64` on every release, with SBOM and provenance attestations. Each image bundles the full client suite — `parallaxd` (full-node daemon), `parallax-cli` (JSON-RPC client), `parallax-wallet` (offline wallet tool) and the `parallax` multi-call wrapper, which is the image entrypoint — so the familiar subcommands work directly. The container runs as an unprivileged user (uid/gid 1000) and keeps all state under `/home/parallax/.parallax`.

Three kinds of tags are available: `latest` always points at the most recent stable release, version lines such as `2.0` track the newest patch release of that line, and exact versions such as `2.0.0` never move. Prerelease tags (e.g. `2.0.0-rc4`) are published but never move `latest`.

To run a full node with persistent chain data, mount a volume at the datadir and publish the P2P port:

```sh theme={null}
docker run -d --name parallax \
  -v parallax-data:/home/parallax/.parallax \
  -p 32110:32110 -p 32110:32110/udp \
  parallaxprotocol/parallax node
```

The running node can be queried through the bundled RPC client, which connects over the IPC socket inside the container — no HTTP configuration is required:

```sh theme={null}
docker exec parallax parallax rpc info
docker exec parallax parallax rpc blockcount
```

To serve JSON-RPC over HTTP, the server must be bound to the container's external interface, and the published port should stay on loopback (or inside a private Docker network) — an unauthenticated RPC port must never be exposed to the public internet:

```sh theme={null}
docker run -d --name parallax \
  -v parallax-data:/home/parallax/.parallax \
  -p 32110:32110 -p 32110:32110/udp \
  -p 127.0.0.1:8545:8545 \
  parallaxprotocol/parallax node --http --http.addr 0.0.0.0
```

When stopping the node, give the database time to close cleanly rather than accepting Docker's 10-second default kill:

```sh theme={null}
docker stop -t 60 parallax
```

To update an existing installation, pull the newer image and recreate the container; chain data survives in the named volume:

```sh theme={null}
docker pull parallaxprotocol/parallax
docker stop -t 60 parallax && docker rm parallax
docker run -d --name parallax \
  -v parallax-data:/home/parallax/.parallax \
  -p 32110:32110 -p 32110:32110/udp \
  parallaxprotocol/parallax node
```

When mining, the XHash DAGs under `/home/parallax/.xhash` are worth mounting as a second volume so they are not regenerated on every container recreation. The image can also be built locally from the repository root with `docker build -t parallax .`; a `Dockerfile.alltools` variant additionally bundles the developer tools (abigen, clef, devp2p, pvm, rlpdump and friends).

## Build from source code

### Linux and Mac

The [Parallax client repository](https://github.com/ParallaxProtocol/parallax) should be cloned locally. Then, the command `make parallax` configures everything for a temporary build and cleans up afterwards. This method of building only works on UNIX-like operating systems, and a Go installation is still required.

```sh theme={null}
git clone https://github.com/ParallaxProtocol/parallax.git
cd parallax
make parallax
```

These commands create four executable files under `parallax/build/bin/`: `parallaxd` (the full-node daemon), `parallax-cli` (the JSON-RPC client), `parallax-wallet` (the offline wallet tool) and `parallax` (a thin wrapper that dispatches `parallax node …` → `parallaxd`, `parallax rpc …` → `parallax-cli` and `parallax wallet …` → `parallax-wallet`). All four are statically linked and can be moved or copied independently; the wrapper resolves its companions as siblings in its own install directory or via `$PATH`.

To update an existing Parallax client installation simply stop the node, navigate to the project root directory and pull the latest version from the Parallax GitHub repository. Then rebuild and restart the node.

```sh theme={null}
cd parallax
git pull
make parallax
```

### Windows

The Chocolatey package manager provides an easy way to install the required build tools. Chocolatey can be installed by following these [instructions](https://chocolatey.org/). Then, to install the build tool the following commands can be run in an Administrator command prompt:

```sh theme={null}
C:\Windows\system32> choco install git
C:\Windows\system32> choco install golang
C:\Windows\system32> choco install mingw
```

Installing these packages sets up the path environment variables. To get the new path a new command prompt must be opened. To install the Parallax client, a Go workspace directory must first be created, then the Parallax source code can be created and built.

```sh theme={null}
C:\Users\xxx> mkdir src\github.com\ParallaxProtocol
C:\Users\xxx> git clone https://github.com/ParallaxProtocol/parallax src\github.com\ParallaxProtocol\parallax
C:\Users\xxx> cd src\github.com\ParallaxProtocol\parallax
C:\Users\xxx\src\github.com\ParallaxProtocol\parallax> go get -u -v golang.org/x/net/context
C:\Users\xxx\src\github.com\ParallaxProtocol\parallax> go install -v ./cmd/...
```

### FreeBSD

To build the Parallax client from source code on FreeBSD, the Parallax GitHub repository can be cloned into a local directory.

```sh theme={null}
git clone https://github.com/ParallaxProtocol/parallax
```

Then, the Go compiler can be used to build the Parallax client:

```sh theme={null}
pkg install go
```

If the Go version currently installed is >= 1.5, the Parallax client can be built using the following command:

```sh theme={null}
cd parallax
make parallax
```

If the installed Go version is \< 1.5 (quarterly packages, for example), the following command can be used instead:

```sh theme={null}
cd parallax
CC=clang make parallax
```

To start the node, the following command can be run:

```sh theme={null}
build/bin/parallaxd
```

Additionally all the developer tools provided with Parallax (clef, devp2p, abigen, bootnode, evm and rlpdump) can be compiled by running `make all`.

To build a stable release, e.g. v1.0.0, the command `git checkout v1.0.0` retrieves that specific version. Executing that command before running `make parallax` switches the Parallax client to a stable branch.