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

# Solonet

> Run a complete Monad network locally in Docker for testing node operations and validator workflows.

[Solonet](https://github.com/monad-crypto/monad-solonet) lets you spin up a private Monad network on your laptop in seconds. It runs a self-contained chain in Docker — validator nodes, execution client, and RPC endpoint — booted from genesis with unlimited tokens. It uses the same binaries that run on testnet and mainnet, so node behavior closely matches production. Linux is supported natively, and macOS works through a small VM layer.

## When to use Solonet

Solonet gives node operators a fast feedback loop without depending on a public network:

* **Practice node operations**: rehearse upgrades, recoveries, and configuration changes against a disposable local chain.
* **Test validator workflows**: run `staking-cli` operations against your own validator without spending testnet MON or waiting for finality.
* **Develop tooling**: validate scripts, monitoring dashboards, or block-delivery integrations against a chain whose state you fully control.
* **Reproduce issues**: spin up a multi-validator topology to investigate consensus or block-sync edge cases.

For application development that only needs a fast EVM endpoint, `anvil --monad` starts faster and is usually sufficient. Reach for Solonet when you need full node behavior: consensus, staking, archive RPC, or production-like timing.

## Prerequisites

* Linux x86\_64 host, or macOS (Apple Silicon)
* 4+ CPU cores and 16 GB RAM
* Docker on Linux; Homebrew on macOS (used to install the Lima + Colima setup below)

## macOS setup (Apple Silicon)

Solonet's containers are x86\_64 Linux, so on Apple Silicon you need a small Linux VM to host Docker. [Lima](https://lima-vm.io/) and [Colima](https://github.com/abiosoft/colima) handle this:

```bash theme={null}
brew install lima colima lima-additional-guestagents
```

Start an x86\_64 Linux VM with enough resources:

```bash theme={null}
colima start \
  --arch x86_64 \
  --cpu-type max \
  --cpu 8 \
  --memory 16 \
  --disk 300 \
  --foreground
```

Verify Docker is wired to the VM (output should show `Architecture: x86_64`):

```bash theme={null}
docker info
```

The Docker CLI automatically points at the Colima VM, so every `docker compose` command below works identically on macOS and Linux.

To tear everything down later:

```bash theme={null}
colima delete --data
```

## Quick start

Clone the repository and bring up a single-validator network:

```bash theme={null}
git clone https://github.com/monad-crypto/monad-solonet
cd monad-solonet
docker compose up --build
```

Once the network is up:

* RPC: `http://localhost:8080`
* WebSocket: `ws://localhost:8081`
* CORS RPC: `http://localhost:8082/rpc/`
* Dashboard: `http://localhost:8082`

## Other network configurations

Multi-validator network:

```bash theme={null}
docker compose -f networks/multi-validators.yaml up --build
```

Full-components network (validators plus auxiliary services):

```bash theme={null}
docker compose -f networks/full-network.yaml up --build
```

## Included tooling

The Solonet containers come with the tools most commonly used for node operations:

* `forge` and `cast` ([Foundry](https://book.getfoundry.sh/))
* `staking-cli` for validator staking operations
* `monad-status` for inspecting node health

## Notes

* Solonet boots a fresh chain from genesis. State and validator sets are independent of testnet and mainnet, so it is suited for verifying your operational processes against a chain you control.
* Because the chain is local, finality is fast and gas is effectively free. Realistic latency or load tests still require a deployed network.

For installation details, environment variables, and configuration options, see the [Solonet README](https://github.com/monad-crypto/monad-solonet#readme).