Running a Storer node.

Overview

A node stores the network’s replicated data — public and followers-only posts, profiles, and the activity around them — serves it to Pixelmine apps, and continuously reconciles it with other nodes. It can also host its own community, whose posts and chats live on that node. It runs as a single self-contained program — there is no database to set up and nothing to wire together.

Running a node strengthens the network and earns points for the work it does (see Network Incentives). The more independent nodes there are, the more resilient the network becomes.

Requirements

• A 64-bit Windows (x64), macOS (Apple silicon or Intel), or Linux (x64 or ARM64) machine. The Linux builds need a glibc-based distribution.
• Disk space for the data it stores (grows with the network — start with a few GB free).
• An always-on internet connection is recommended, since uptime is one of the ways a node earns.
• One open inbound port (default 8001) so other nodes and apps can reach yours. A node can still pull data without it, but it can’t serve peers or apps.

Install & run

Download the build for your platform from the download page. It is a single program, not an archive. Put it in its own folder and rename it to storer (storer.exe on Windows) — the built-in updater looks for that name. Then run it from a terminal, from inside that folder:

# macOS / Linux — a browser download arrives WITHOUT the execute bit.
mkdir -p ~/storer && mv ~/Downloads/storer-darwin-arm64 ~/storer/storer
cd ~/storer
chmod +x storer
./storer

# Windows (PowerShell), after renaming the download to storer.exe
cd C:\storer
.\storer.exe

First launch

The very first time it runs, the node asks for a name and an optional description, generates its own cryptographic identity, prints its node ID, and writes config.json into the folder you ran it from. Its data (store.pxl, files/, storer.log) goes in the same folder.

No config file found, creating default config.json
Enter node name: tokyo-node-1
Enter node description: A Pixelmine node run from Tokyo
Node ID: 3f9c…

This first run must be interactive. From then on it starts without input: on each launch it registers with the network, begins syncing and announcing itself to peers, opens its interface on port 8001, and starts its updater.

Configuration

Settings live in config.json, created on first run. The main fields:

{
  "id": "…node id…",
  "name": "tokyo-node-1",
  "description": "A Pixelmine node run from Tokyo",
  "app_port": "8001",
  "public_key": "…",
  "private_key": "…keep secret…",
  "jwt_secret": "…keep secret…",
  "peer_auth_mode": "enforce",
  "storage": { "max_storage_mb": 1024 },
  "points": {
    "user_share_percent": 60,
    "min_withdrawal_pxl": 1,
    "min_withdrawal": 500,
    "rules": { … }
  }
}

• name / description — how your node appears to the network.
• app_port — the port the node serves on. It must be a string, e.g. "8001"; a number stops the node from starting.
• public_key / private_key / jwt_secret — the node’s identity and session secret. Keep them private.
• storage.max_storage_mb — shown in the status view as used / cap. The node does not yet enforce it as a limit.
• points.user_share_percent — shown as the node’s community share. The share that is actually paid is set by Pixelmine for each node (60% by default).
• points.min_withdrawal_pxl — the minimum a member must reach before exchanging points, as a percentage of the community’s total points (1 = 1%). min_withdrawal is only a fallback when that total can’t be read.
• points.rules — how many points members earn for each kind of activity in your community.

Restart the node after editing config.json — most settings are read once at start-up (points.rulesis re-read as it is used). Changing the name or description just refreshes the node’s details; replacing its keys creates a new node.

What it does

Once running, the node does six things on its own:

Serves apps

It exposes an interface that Pixelmine apps connect to — reading feeds and profiles, and uploading or fetching media. Private messages and followers-only posts are encrypted on the device before they reach the node, so the node stores that content sealed.

Discovers peers

The node registers itself with the network’s coordination service automatically, then announces itself to the peers it knows about every five minutes (and again if its IP changes). Peers reply with the nodes they know, so knowledge of the network spreads on its own. A new node starts from a built-in list of seed peers.

Syncs the network

Every minute it compares fingerprints of its data with its known peers, takes the majority view, and pulls only what differs. New records are also pushed between peers as they are written. The comparison is cheap even when almost everything already matches.

Verifies what it receives

Records arriving from peers are checked against their author’s signature before they are stored, and records that fail are rejected. Records from an author the node doesn’t know yet are fetched again later, once that author’s own record has arrived.

Stores & serves media

Files are held on disk and served on request. Media in chats and followers-only posts arrives already encrypted by the app, and the node requires a signed-in session to serve it. Files downloaded from peers are checked against the signed hash in their metadata.

Earns points

As it works, the node reports its contribution across four categories: syncing with peers, holding files other nodes verify, staying reachable, and completing syncs. See Earning points below.

Keeping it running

The node runs in the foreground. In a terminal it shows a live status view; its log is always written to storer.log in its folder. To keep it up across reboots and disconnects — which is what earns uptime — run it under a service manager.

On Linux, once /opt/storer/config.json exists, a minimal service looks like this:

# /etc/systemd/system/storer.service
[Unit]
Description=Pixelmine Storer
Wants=network-online.target
After=network-online.target

[Service]
WorkingDirectory=/opt/storer
ExecStart=/opt/storer/storer
Restart=always

[Install]
WantedBy=multi-user.target

sudo systemctl enable --now storer
sudo systemctl status storer
tail -f /opt/storer/storer.log

Staying up to date

The node starts its own updater and checks that it is still running every minute — there is nothing to run separately. Every five minutes the updater looks for a newer release, checks its size, hash, and signature against keys built into the program, then stops the node, swaps in the new binary, and starts it again. To turn it off, set "disable_updater": true in config.json or STORER_DISABLE_UPDATER=1.

Earning points

A running node earns points for the work it does. Reports are checked against the keys nodes registered, and point tallies are kept by the network rather than on the node. There are four categories:

Point tallies are kept away from the node itself, so an operator with full control of their own machine still cannot edit their own score.

Points distribution

Points decide how a shared pool is divided. The model is two divisions.

1 · Across the network

Pixelmine puts up a pool, which is split among nodes in proportion to the points each has earned. Your node’s slice is its share of all points across the network:

node slice    =   node points   ÷   all network points   ×   pool

2 · Within your community

A share of each node’s slice goes to the people in its community. That share is set by Pixelmine for each node — 60% by default — not in config.json. The members’ pool is divided among them by the points they each earned in that community.

members pool  =   node slice   ×   community share

A worked example

With round numbers:

Shared pool                     ¥5,000,000
All nodes' points                   10,000
Your node's points                   2,000    →  20% of the network

Your node's slice               ¥1,000,000    (20% of the pool)
Community share (60%)             ¥600,000    →  shared among your members
Operator keep   (40%)             ¥400,000    →  yours

Earn more points and your slice of the same pool grows; earn the same while the network grows around you and it shrinks — a share is always relative to everyone else’s. Members can exchange points once their balance passes your node’s threshold (min_withdrawal_pxl, 1% of the community’s points by default).