Run the network yourself

Join the public testnet

Network bitlooper-testnet-2, genesis hash cd7e0af1b0ea1796524314817bf55f3d0f841d628d13b7429bdc7fbb7da7fee0, first peer node.bitlooper.org:26656. These steps work in a terminal on a Mac with Apple silicon or on a Linux x86-64 computer or server.

1. Download the node program and check it

   # Mac (Apple silicon):  F=bitlooper-node-macos-arm64
   # Linux (x86-64):       F=bitlooper-node-linux-x86_64
   F=bitlooper-node-macos-arm64
   curl -LO https://bitlooper.org/downloads/$F
   curl -LO https://bitlooper.org/downloads/SHA256SUMS
   shasum -a 256 -c SHA256SUMS --ignore-missing     # must say: OK
   chmod +x $F && sudo mv $F /usr/local/bin/bitlooper

2. Download the genesis file and check it

   curl -LO https://bitlooper.org/testnet/genesis.json
   bitlooper genesis-hash --genesis genesis.json    # must print cd7e0af1b0ea1796...

   If the hash is different, stop: you are not on the real BitLooper testnet.

3. Create your node and start it

   bitlooper init-node --dir ~/bitlooper-node --genesis genesis.json --peer node.bitlooper.org:26656
   bitlooper run --config ~/bitlooper-node/node.json

   It downloads and checks every block from the start. When its height matches the explorer, you hold a complete, verified copy of the chain. You don't need a key or any coins for this.

4. Keep it running

   On a Linux server, run it as a service so it restarts by itself:

   sudo tee /etc/systemd/system/bitlooper.service >/dev/null <<UNIT
   [Unit]
   Description=BitLooper node
   After=network-online.target
   [Service]
   User=$USER
   ExecStart=/usr/local/bin/bitlooper run --config $HOME/bitlooper-node/node.json
   Restart=always
   [Install]
   WantedBy=multi-user.target
   UNIT
   sudo systemctl enable --now bitlooper

   On a Mac, keep the terminal window open, or use the desktop app, which starts its node at login.

5. Optional, on an always-on server: become a validator

   A validator needs at least 1,000 BLPR bonded. Faucet coins are for trying the wallet, not for staking. Testnet validators receive an equal allotment from the project instead (see how genesis validators are chosen).

   # 1. Set up the node with a validator key (instead of the plain init-node above)
   bitlooper init-node --dir ~/bitlooper-node --genesis genesis.json --peer node.bitlooper.org:26656 --validator
   bitlooper address --key ~/bitlooper-node/validator.key.json    # send this address to the project
   # 2. When the allotment (1,100 BLPR) has arrived and your node has synced:
   bitlooper bond --key ~/bitlooper-node/validator.key.json --amount 1000

   You join the active set at the next epoch (every hour on this testnet). Open port 26656 in the firewall so other nodes can reach you. Back up validator.key.json offline, never run it on two machines, and protect the account with bitlooper protect (vault, cancel key and guardians; see the guides).

Three ways to take part

Storage figures are ceilings under sustained full load, from the paper's section 6. Real early usage is far lower.

Becoming a validator: the process

1. Run a full node and let it sync

   Start from genesis, or from a trusted checkpoint you get from several independent sources.

   bitlooper run --config node.json

2. Create a validator key

   Use ML-DSA-65 for validators. Keep it on this one machine only.

   bitlooper keygen --alg ml-dsa-65 --out validator.key.json

3. Bond stake

   Bond at least the minimum stake from that key's account. It joins the active set at the next epoch (daily on mainnet), ranked by stake. The top 100 are active.

   bitlooper bond --key validator.key.json --amount 1000

4. Add the key to your node and restart

   Set "validator_key": "validator.key.json" in node.json. Your uptime record starts: every block you sign is counted publicly on the Explorer.

5. Stay online and honest

   An offline validator earns nothing for the blocks it misses. A validator that signs two conflicting votes loses at least 5% of its stake, and a coordinated attack by one-third or more loses 100%.

Why no single party can corrupt it

"Can't be corrupted" is only true under stated conditions. Here are the conditions, honestly.

Start the first validator of a new network

One command creates the keys, the genesis file and the configuration. A second starts the node.

1. Create the network

   bitlooper init-validator --dir ~/bitlooper-node --chain-id bitlooper-testnet-2 --stake 100000

   This creates validator.key.json (your ML-DSA-65 validator key: back it up and never copy it to a second running machine), a faucet key, genesis.json and node.json.

2. Start it

   bitlooper run --config ~/bitlooper-node/node.json

   Blocks start within 30 seconds. Check with bitlooper status and bitlooper validators.

3. Keep it running 24/7

   On a Linux server use the systemd service, on a Mac the launchd agent; both restart the node automatically. They're in deploy/.

   sudo systemctl enable --now bitlooper     # Linux server
   launchctl load ~/Library/LaunchAgents/com.bitlooper.node.plist   # Mac

4. Let others join

   Publish genesis.json and your address (<public-ip>:26656, open that port in your firewall). Others run:

   bitlooper init-node --genesis genesis.json --peer <your-ip>:26656 --validator
   bitlooper run --config bitlooper-node/node.json
   bitlooper bond --key bitlooper-node/validator.key.json --amount 1000   # after getting coins

5. Verify every coin

   bitlooper audit

   Checks that reserve, balances, stake, locked and pending coins add up to exactly 100,000,000.

What if nobody else is using it yet?

The chain still runs, and it still pays its validators.

From testnet to mainnet

1. Publish the airdrop rules first

   bitlooper airdrop-rules --out airdrop-rules.json

   Minimum signed blocks, points, the 100,000-coin cap and contributors. Publish the file and its hash before measuring starts.

2. Run the public testnet

   At least six months. Validators build their uptime record, and developers and users build the network.

3. Compute the airdrop from the public record

   bitlooper airdrop --rules airdrop-rules.json --operators operators.json --height <SNAPSHOT_HEIGHT> --out airdrop.json

   Deterministic: anyone with the same rules, the same approved-operators list and the testnet snapshot at that height (served by /validators/at/HEIGHT) gets the same list. Amounts above the caps return to the reserve.

4. Build and publish the mainnet genesis

   bitlooper genesis-mainnet --airdrop airdrop.json --rules rules.json --operators operators.json --foundation <FOUNDATION_ADDR> --foundation-validator-key foundation-validator.pub.json --out genesis-mainnet.json

   15% airdrop, unlocking 1/12 at genesis and 1/12 per month; approved operators (one slot each, at most 50 genesis validators) stake only their unlocked twelfth. The foundation runs exactly one validator with a published key and at most 10% of the genesis stake; the rest of its 5% vests over 48 months. Everything else stays in the reserve. Publish the file and its hash before the genesis time.

5. Launch together

   Genesis validators start their nodes with their testnet keys before the genesis time. The first block appears when more than two-thirds of the stake is online.

Your setup