Running a Storer node.

Overview

A node holds a full copy of the network’s public data, serves it to Pixelmine apps, and continuously reconciles that copy with other nodes. It runs as a single self-contained program — there is no database to set up and nothing to wire together. Start it once and it keeps itself in sync with the rest of the network.

Running a node strengthens the network and earns rewards 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, macOS, or Linux machine.
• 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) if you want other nodes and apps to reach yours directly. A node still syncs outbound even without it.

Install & run

Download the build for your platform from the download page and unpack it. Then run it from a terminal:

# macOS / Linux
./storer

# Windows
storer.exe

First launch

The very first time it runs, the node introduces itself. It asks for a name and a short description, generates its own cryptographic identity, and writes a configuration file next to the program. Nothing else is required.

Node name: tokyo-node-1
Description: A Pixelmine node run from Tokyo

From then on it starts headless. On each launch it registers with the network, opens its interface on port 8001, discovers peers, and begins syncing — no further input needed.

Configuration

Settings live in a plain config.jsonfile created on first run — and it’s yours to customize. Edit it any time to change how your node presents itself, how much disk it uses, and how much of its rewards it shares with its community. The fields that matter:

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

• name / description — how your node appears to the network.
• app_port — the port the node serves on (default 8001).
• public_key / private_key — the node’s identity. Keep the private key private.
• storage — how much disk the node may use for stored files.
• points.user_share_percent — how much of what your node earns is passed on to the people in its community. Entirely your call.
• points.min_withdrawal — the balance a member must reach before points can be exchanged.

Edit config.jsonand restart the node for changes to take effect — re-introducing itself just refreshes the node’s details, it never creates a duplicate.

What it does

Once running, the node quietly 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 content is encrypted on the device before it ever reaches the node, so the node only ever handles sealed data.

Discovers peers

The node announces itself to the peers it knows about every few minutes and, in return, learns of nodes it didn’t — so knowledge of the network spreads on its own. No central list to register with by hand.

Syncs the network

Roughly once a minute it compares fingerprints of its data with a peer and pulls only what differs. The comparison is cheap even when almost everything already matches, so a node stays current without moving large amounts of data.

Verifies everything

Every record a node receives is checked against its author’s signature before it is stored. A misbehaving or dishonest peer cannot inject forged data — the node accepts data from anyone precisely because each record proves its own authorship.

Stores & serves media

Public files are held on disk and served on request; private media is stored encrypted and is meaningless without the key. Downloaded files are re-checked against their signature before the node trusts them.

Earns points

As it works, the node reports its contribution — signed, so it can’t be faked — across four categories: serving data to peers, storing files, staying reachable, and doing so reliably. See Rewards below.

Keeping it running

The node runs in the foreground and prints a live status view in the terminal. To keep it up across reboots and disconnects — which is what earns uptime — run it under your system’s service manager. On Linux, a minimal service looks like this:

# /etc/systemd/system/storer.service
[Unit]
Description=Pixelmine Storer
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

Staying up to date

The Storer can keep itself current. Run it in updater mode alongside the node to pick up signed releases automatically:

./storer --updater

Earning points

A running node earns pointsfor the work it does. Every report a node makes is signed with its own key, so contributions can’t be forged or claimed on another node’s behalf. 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 quietly edit their own score.

Points distribution

Points decide how the network’s revenue is shared. The model is two divisions and a choice.

1 · Across the network

Revenue for a period is split among nodes in proportion to the points each earned. Your node’s slice is its share of all points across the whole network:

node slice    =   node points   ÷   all network points   ×   revenue

2 · Within your community

Each node then decides how much of its slice to pass onto the people in its community — a percentage the operator chooses. The members’ pool is divided among them by the points they each earned in that community.

members pool  =   node slice   ×   the share the node chose

A worked example

With round numbers, for one revenue period:

Network revenue (period)        ¥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 revenue)
Member share  (you set 60%)       ¥600,000    →  shared among your members
Operator keep (40%)               ¥400,000    →  yours

Earn more points and your slice of the same revenue grows; earn the same while the network grows around you and it shrinks — a share is always relative to everyone else’s. Members can withdraw once their balance passes the network’s minimum.