available soon Current version 0.2.128

Install

Three ways to run UMNode, none of them public yet: the source repository opens with the first public release, and the prebuilt binaries and the Docker image are being set up. Here is what each will look like.

Requirements

Go 1.25+ for source builds (the module requires go 1.25.0).
Docker 24+ as an alternative to a local Go toolchain, once the image is published.
Outbound network access on TCP/UDP 30303 for dialing peers and UDP discovery. No inbound port is needed: UMNode only ever dials out.

From source available soon

The ofzhur/umnode repository is private while UMNode is pre-alpha and opens with the first public release. The build is a plain Go build:

git clone https://github.com/ofzhur/umnode.git
cd umnode

make build               # produces bin/umnode
./bin/umnode             # joins Ethereum mainnet with the bundled config

Or without the Makefile:

go run . --network mainnet --log-level debug

By default UMNode reads cfg/ethereum.yaml from the current working directory and joins mainnet. Override any setting with a flag, or pick another bundled network:

./bin/umnode --network sepolia \
  --block-db data/sepolia/chain --state-db data/sepolia/state \
  --node-db data/sepolia/p2p/enode --inventory-db data/sepolia/p2p/inventory

Every store is bound to the chain it was created for, so give each network its own data directories. ./bin/umnode --help lists every flag; the quickstart, configuration and flag reference cover the rest.

Prebuilt binaries available soon

Static release binaries are not published yet. When they land they will be listed on the downloads page, with checksums, for these targets:

Target	File	Status
Linux amd64	`umnode-linux-amd64.tar.gz`	soon
Linux arm64	`umnode-linux-arm64.tar.gz`	soon
macOS amd64	`umnode-darwin-amd64.tar.gz`	soon
macOS arm64	`umnode-darwin-arm64.tar.gz`	soon

Docker available soon

A multi-arch image (linux/amd64 and linux/arm64) is being set up and is not published yet. The image is a distroless static build of about 15 MB with cfg/ethereum.yaml baked in for an out-of-the-box mainnet run.

Once it is published, running it will look like this:

docker run --rm -it \
  -v "$PWD/data:/app/data" \
  ofzhur/umnode:latest

No published ports are needed: UMNode dials out and runs discovery outbound but accepts nothing inbound. The data/ mount preserves the peer database and the block store between runs. Mount cfg/ read-only at /app/cfg only to override the bundled config. Flags go after the image name:

docker run --rm -it ofzhur/umnode:latest --log-level debug --max-peers 50

From a checkout of the repository the image is built locally with make docker, which tags ofzhur/umnode:<git-describe> and :latest, and run with make docker-run.

What you should see

On a healthy start UMNode logs that it has loaded the network config, opened its stores and begun discovery. As peers complete the handshake you will see Peer ready lines, and as the head advances the realtime worker logs each block it imports. JSON-RPC is served on 0.0.0.0:8550 by default; open that address in a browser for the built-in method explorer. The quickstart walks through a first run.