Guide

Master servers

Master servers are how the Server Browser finds community servers, and how players reach servers behind routers. No single one holds the list: every server reports to three default masters, masters share their listings and the masters they know, servers turn to backup masters when the ones they report to are down, and anyone can run one. A master needs no game files, only the Project Reclaimer program.

Work in progressEarly development build. What this page describes may still change.

0game files a master needs
49175the port to open, on TCP and UDP
60 sbetween two masters sharing what they know
0game traffic through a master

What a master does

A master server is a small program that listens on one port number, 49175 by default, for two things:

  • On TCP, a plain HTTP service that keeps a list of where servers are. A listing is one server's game address, such as 203.0.113.4:49176, its network key, the master that introduces players to it, and when it expires, signed with the server's key. A listing holds no name, map or players. A master holds up to 9,999 listings.
  • On UDP, the rendezvous. Servers register their game socket here, players ask to be introduced to a server behind a router, and anyone can ask where their router shows them (STUN). Playing games also say here which server they play on, which is how a master counts a server's players. See introductions and STUN.

The Server Browser reads two masters at a time and merges their lists, giving each 1.5 seconds to take the connection and 2.5 seconds to answer, so a master far away or a lost packet doesn't leave the list empty. Then it asks every listed server, on the server's own game port, what it's playing: its name, map, game type, players, mods and Project Reclaimer version. It measures the ping on the way. So what players see comes live from each server, not from a master, and a server that doesn't answer is left out.

How listings travel between servers, masters and players A dedicated server reports its listing to the three default masters and to its own machine's master; a game hosted online reports to the default masters, and to a community master as a backup while both are down. The masters share listings and the masters they know every 60 seconds. The Server Browser reads the default masters two at a time, and the other masters only when the default ones can't be reached or list nothing, then asks each server directly what it's playing and measures its ping. SERVERS MASTERS PLAYERS backup share listings and masters every 60 s asks each server what it's playing, and its ping, on the server's game port Dedicated server with a master on its machine Online game hosted from Host Game Default masters every server reports to all three Host's master beside dedicated servers Community master run on its own Server Browser reads several masters, then asks each server
  • Servers report their listing
  • Backup while every default master is down
  • Masters share
  • The browser reads masters
  • The browser asks each server

Four masters are built into every game: three public ones, at http://148.251.153.44:44340, http://75.98.127.228:44340 and http://23.159.176.140:44340, and http://127.0.0.1:49175, a master on the player's own PC, such as the one a dedicated server setup runs. The three public ones are the default masters: every listed dedicated server reports to all of them, and each holds every server's listing, so while one is down, servers stay listed and players still see them. The second of them runs on two machines behind its one address: when one machine stops, the other answers as the same master.

Players can change that list under Settings → Online services → Master servers, up to 64 masters. A refresh reads the master on the player's own PC and the first two others on the list together, and the next one only in the place of one that didn't answer: the default masters swap their listings, so two of them hold every server and the list is the same with fewer requests. Whenever one of them returns valid listings, the browser uses only those. It turns to other masters, the ones it learned, only when none on its list can be reached or none lists a valid server; see when a master goes down. Favorites are asked directly at every refresh.

While its masters list servers, each refresh also checks two other masters, without using their listings, so the browser keeps a list of masters that answer for when its own are down; see how masters share.

Masters and the stats service speak plain HTTP on purpose: a listing is public, and it's signed by the server that made it. A master address is always http://host:port; the game refuses https:// for one.

How a server gets listed

The server signs its listing

A server's network key, kept in its own folder, signs its game address. The same key proves who it is when a player connects, so a listing can't send players to a different machine. A listing is good for 3 minutes, and the server renews it long before then.

It reports to masters

Every 30 seconds, a dedicated server sends the listing to the three default masters and to the masters its host added under [master] peers, and every 5 seconds to the master on its own machine. A game hosted online from the game reports to the masters on that player's list.

It registers its game socket

From its game port, the server registers with the UDP side of up to four masters that answered it, every 20 seconds. Each master's copy of the listing names that master, so any of them can introduce players to it.

The master checks that it's there

A couple of seconds after a server's first report, the master asks the server itself on its game port, as a browser does, and lists it once it answers with the key that signed the listing. A server that doesn't answer within 5 seconds isn't listed, and its reports aren't looked at again for two minutes.

Masters share it

Every 60 seconds, each master swaps listings with the masters it knows, so a listing that reached one master reaches the others.

The browser finds it

When a player opens the Server Browser or refreshes it, the browser reads the masters, then asks the server what it's playing.

A server that stops drops off every list within 3 minutes of its last renewal. A hidden server reports nowhere: players reach it only by Direct Connect.

The answer to a report tells the server the address the master saw. A server with no public_address is listed at that address, and its copy for each master is signed by that master's clock, so a wrong clock on the server's machine doesn't hide it.

What a master lists

A master only lists servers that are really there, at the address they give:

  • A server reports from its own address. A master takes a listing only when the report came from the IP address the listing names, so nobody can announce servers at somebody else's address. A server whose reports leave from another address than its public_address, such as a machine with several addresses, or a report over IPv6 for a game listed by IPv4, isn't listed by that master. Other masters still pass servers on.
  • A server answers the master. A server the master can't reach, directly or through its UDP side, isn't listed. A new server shows up a couple of seconds after its first report.
  • Four servers per address. A master lists at most four servers at one IP address, the four that answered first, and takes at most four listings from one sender. Hosts behind one public address share its four. A host with more servers on one address asks the master's operator to be let through; see keep servers off your list.
  • A machine's own master lists all of its servers, without asking them and without the limit of four.

Player counts

What a server says it's playing is the server's own word, and that includes how many players it has. So the masters count players themselves, and the Server Browser shows no more players on a server than the masters counted.

  • Each playing game says where it plays. Within 2 seconds of joining, every 20 seconds after that and once more as it leaves, a player's game tells the UDP side of each master on its list which server it's on and how many players are at that PC. Nothing else: no names. A game that crashes still counts for 60 seconds.
  • A master counts by address. One address vouches for at most 4 players on a server, and plays on at most 4 servers at once, so a host can't fill its servers from its own machines. More than 4 players behind one address on one server, such as a LAN party listed online, count as 4. A master keeps the counts in memory only.
  • The browser shows the lower number. A row shows the server's own count or the most one of its masters counted, whichever is lower. Only the masters on the browser's own list count for this. The count of the server a player has selected is asked again every 5 seconds, so it follows joins and leaves without a refresh.
  • Where nothing is counted, the server's word stands: a game on the player's own network, a hidden server kept as a favorite, a server only a master without counts lists.

A server needs the game's current version to be counted: an older one shows no players in the browser, whatever it says. Nothing changes in a server's own console or settings. For a time when players' games can't reach a master, its operator can start it with --trust-unwitnessed: a server it counted nobody on is then listed with the count the server itself reports, and a server with at least one counted player keeps the counted number.

Introductions and STUN

Every master's UDP side helps players reach servers whose routers don't forward the game port. Nothing goes through a master but these few small packets: the game itself, voice and mod downloads go straight between the player and the server.

  • Registration: a server proves its address and its key, then repeats that every 20 seconds. A registration lasts a minute.
  • Introduction: a player's game asks the master to introduce it to a server, again every second until the server answers. The master tells each side where the other is, and both send packets at once, which opens both routers. This is hole punching.
  • STUN: anyone can ask a master where their router shows them, with a standard Binding request (RFC 8489). Servers, joining players and the Server Browser compare the answers of two or more masters to learn what their router does, and so which ports to try.

A master can't be used to aim packets at someone: an introduction needs a cookie for the asker's own address, and a server only obeys orders signed with the key its registration proved. A master's UDP side allows 20 requests in a burst and then 10 a second per address, and 256 introductions in a burst and then 64 a second, since everyone behind a provider's shared address shares that allowance.

Which routers connect, and what still can't, is on the hosting page: hosts behind routers.

How masters share

There's no central list that everything depends on. The masters form a network, and each part of it learns about the rest:

  • Masters name other masters. Every master's answer carries its listings and the other masters it reached lately, up to 64. When the browser has to fall back on other masters, it asks those too, in the same refresh, and remembers the ones that answer. That's how it finds servers while its own masters can't help.
  • The browser checks masters ahead of time. A refresh whose masters list servers also checks two other masters: first the ones those masters name or the browser remembers that it has never checked, then the ones it checked longest ago. Their listings aren't used. The list still shows only what its own masters list, and the browser has masters that answer ready for an outage.
  • Masters swap every 60 seconds. Each master sends its listings to the masters it was told to keep (--peer, or [master] peers), reads up to 12 others, in two waves of six, from those, the masters it remembers and the ones that wrote to it, then sends its listings on to the ones it read.
  • New masters introduce themselves. A master that sends its listings to another names its own address (--origin, or [master] origin). The other checks that address at its next swap and, once it answers, passes it on to everyone who asks. A master with no origin, or no peer to tell, stays unknown. See get it known.
  • The default masters keep to themselves. They swap with each other only: they take no listings pushed by other masters and name no other masters. Every server reports to them directly, so they miss nothing, and a community master can still read them and list their servers. A master of your own can run the same way, with --closed.
  • Everyone remembers. Browsers and masters each keep up to 64 masters that answered, in peers.json, for 30 days, one per IP address, and forget one that fails two checks in a row.

Listings stay intact on the way. They're signed, so a master that passes one on can't change its address or make it last longer, and when several masters hand out the same listing, the browser keeps the newest signed copy.

Masters only hand out what the asker can use. A master takes a listing only if it could work from where it came, and gives a listing to a player only if that player can reach it: a server at 127.0.0.1 goes only to players on that machine, and one at 192.168.x.x only to players on that network.

When a master goes down

The three default masters are the places every dedicated server reports to and every game knows. Each holds every listing, so while one is down, the Server Browser reads the next one in its place and nothing changes for players or hosts. The network is built to keep working without all of them, too.

For players

  • When no master on a player's list answers with a valid listing, the browser asks the masters it remembers, up to 12 in a refresh, six at a time. Those masters hold the listings servers sent them and the ones they swapped with other masters.
  • The line under the server list counts the masters that answered, and says Limited discovery: fewer than two sources reachable. when fewer than two did.
  • Favorites are asked directly at every refresh, so they show up even when no master lists them.
  • The browser learns other masters from community masters on its list, not from the default ones. A game whose list holds only the defaults knows no others. Adding one by hand fixes that, which is where a community's own master helps: share its address.
  • The browser reads a master on the internet only when the master says it lists just the servers that answered it. One that doesn't, because it hasn't been updated or runs with --unverified, is counted as not answering. A master on the player's own PC or network is always read.

For servers

  • A master's answer to a server's report names other masters it knows, starting at a random one, so different servers learn different masters. It only names masters the server's players can reach.
  • While none of the masters a server reports to takes its listing, the server also reports it to three of those learned masters, every 30 seconds. One that stops answering is replaced, and one that failed is tried again only when no untried master is left.
  • A master on the server's own machine counts: with one running, it always takes the listing, so that server doesn't turn to backups even while every default master is down. Add community masters to [master] peers to have it reported to them anyway.
  • A game hosted online from the game starts with the masters that PC's Server Browser remembers, so one started during an outage is listed through those.
  • Once a master it reports to takes the listing again, the server goes back to those alone, and the backups' copies expire within 3 minutes.

The server's log says when it starts and stops using backups:

server.log
[h3list] no default master took this server's listing; reporting it to http://…, http://…, http://… until one does
[h3list] a default master takes this server's listing again

If the server hasn't learned any masters yet, the first line ends in no other master is known yet instead. Every master keeps a copy of the listings it hears about, so each master someone runs is one more place the Server Browser can find servers while the default masters are down.

What a master can't do

A master can't

Change a listing's address or make it last longer. Let anyone into a server: players join the server itself, and its key is checked. See what happens in a game, or who plays: it holds addresses and keys, and counts how many players each address says it has on a server. Carry any game traffic. Hand out an address players can't reach: one on a player's PC (127.0.0.1) or local network (192.168.x.x) only goes to players on that PC or network.

A master can

Leave listings out, by address or by name or for no reason, hand out a listing again until it expires, or, if it's a bad one, list addresses nobody hosts. The browser asks at most 9,999 servers per refresh and at most 32 on one IP address, so a bad master can't aim players' browsers at anyone. Like any web server, it sees the IP address of everyone who reads it. Its UDP side also sees the address and port of every server that registers and of each player who asks it for an introduction or a STUN answer, and which server each playing game on its list of masters says it's on.

What a server says it's playing comes from the server itself. Signatures prove a listing wasn't changed on the way, not that its host is honest. See Legal & privacy for what the default masters and servers see.

Host a master

Running a master gives your community its own way into the Server Browser, one that keeps working when the default masters don't, and one more place for servers to register and players to be introduced. It needs no game files, no Steam and no game install: only the Project Reclaimer program and one open port number.

Beside dedicated servers

Every dedicated server setup already runs a master on port 49175 ([master] enabled = true), and its servers are listed on it. To have other masters learn it, set its peers and origin: see get it known and the configuration file.

A master on its own

On a machine without the game, such as a small VPS, run only the master: one command on Windows, Linux or macOS, or the image in Docker.

WhatDetails
SoftwareAny package from the download page: every one of them has the master, as the list-master command. For a machine that hosts nothing else, take the server-only package. Docker uses the dedicated server image.
Game filesNone.
WindowsWindows 10, 11 or Server 2019 or newer (x64), on a processor with SSE4.2: any Intel Core i3, i5 or i7 and newer, AMD FX and newer, and every Ryzen.
Linuxx86-64, with the same processors as Windows, or ARM64, built on Debian 12 (glibc 2.36). Docker: x86-64, Engine and Compose 2.24 or newer.
macOSmacOS 11 or newer, Apple Silicon.
NetworkPort 49175 open to the internet on TCP and UDP, at an address that doesn't change, since players and other masters remember it: a fixed IP address or a DNS name. The master also connects out to other masters on their ports. Behind a router, forward both.

A master is light: it holds a list in memory and keeps only its key and peers.json on disk.

Run 0.10.3 or newer. Players' browsers read a master on the internet only when it lists just the servers that answered it, which masters do from 0.10.3 on. They leave an older master's list out, and read it again by themselves once it's updated. Servers are still joined by address and found through the updated masters meanwhile. Place the master where it sees its senders' real addresses and can reach the servers it lists: not behind a proxy.

Masters from 0.9

0.10 has a new master, with a new protocol. A master and the games and servers that use it must be on the same side of that line: 0.10 games and servers can't use a 0.9 master, and 0.9 games can't use a 0.10 master. If you run a master, update it when your community updates.

The project's default masters run 0.10's master on port 44340, two of them beside 0.9's on 49175 on the same machines, so both games keep their server lists while 0.9 is still played. A list of masters saved by 0.9, or a --peer naming 0.9's default masters, asks the 0.10 masters that took over from them.

What0.90.10
Commanddiscovery-master --bind …list-master --bind …, with the options below
PortsTCP 49175; UDP on the two default masters aloneTCP and UDP on every master: open the UDP port too. 49175 by default; the default masters serve on 44340, two of them beside 0.9's on 49175
Reaching servers behind routersOnly the two default masters introduced playersAny master a server registers with, up to four, with STUN
LinuxThe Windows program under Wine, in DockerNative, from a tarball or the image
Getting knownAdded by hand, or from a dedicated setup--peer and --origin introduce it to other masters
Where it keeps thingsThe player folder's discovery, or RECLAIMER_DISCOVERY_DIR--key and --data name them

On Windows

  1. Download the programGet project-reclaimer-dedicated-version.exe from the newest release, rename it project-reclaimer.exe and put it in a folder of its own, such as C:\reclaimer-master. Open a terminal in that folder.
  2. Start the master
    PowerShell
    .\project-reclaimer.exe list-master --bind 0.0.0.0:49175 --key h3list.key --data . --origin http://your-address:49175 --peer http://148.251.153.44:44340 --peer http://23.159.176.140:44340
    It says [h3list] master http://your-address:49175 (HTTP on TCP 0.0.0.0:49175, server list on UDP 0.0.0.0:49175) and runs until you press Ctrl+C. Within a minute or two it holds the default masters' listings. Start it from a terminal: the game client opened with a double-click starts the game instead.
  3. Open the port In a terminal opened as administrator:
    PowerShell (administrator)
    New-NetFirewallRule -DisplayName "Reclaimer master" -Direction Inbound -Protocol TCP -LocalPort 49175 -Action Allow
    New-NetFirewallRule -DisplayName "Reclaimer master UDP" -Direction Inbound -Protocol UDP -LocalPort 49175 -Action Allow
    Behind a home router, forward TCP and UDP 49175 to this PC.

To start it with Windows, create a Task Scheduler task that runs C:\reclaimer-master\project-reclaimer.exe with those arguments, starting in C:\reclaimer-master, at startup, whether or not a user is logged on. For another port, change 49175 in --bind and in the firewall rules, and give players that port.

On Linux

  1. Unpack the server-only package Get project-reclaimer-dedicated-version-linux-x86_64.tar.gz, or -linux-aarch64.tar.gz for ARM64, from the newest release:
    Shell
    mkdir -p ~/reclaimer-master
    tar -xzf project-reclaimer-dedicated-v0.10.7-linux-x86_64.tar.gz -C ~/reclaimer-master --strip-components=1
    cd ~/reclaimer-master
  2. Start the master
    Shell
    ./project-reclaimer list-master --bind 0.0.0.0:49175 --key h3list.key --data . \
      --origin http://your-address:49175 \
      --peer http://148.251.153.44:44340 --peer http://23.159.176.140:44340
  3. Open the port
    Shell
    sudo ufw allow 49175/tcp && sudo ufw allow 49175/udp
    Open the same in your provider's firewall or security group.
  4. Run it as a service (optional)
    /etc/systemd/system/reclaimer-master.service
    [Unit]
    Description=Project Reclaimer master
    After=network-online.target
    Wants=network-online.target
    
    [Service]
    User=reclaimer
    WorkingDirectory=/home/reclaimer/reclaimer-master
    ExecStart=/home/reclaimer/reclaimer-master/project-reclaimer list-master --bind 0.0.0.0:49175 --key h3list.key --data . --origin http://your-address:49175 --peer http://148.251.153.44:44340 --peer http://23.159.176.140:44340
    Restart=always
    RestartSec=5
    
    [Install]
    WantedBy=multi-user.target
    Then sudo systemctl enable --now reclaimer-master.

On macOS

The master is in the game's own program, inside Project Reclaimer.app. Start it from Terminal, in a folder of its own for its key:

Terminal
mkdir -p ~/reclaimer-master && cd ~/reclaimer-master
"/Applications/Project Reclaimer.app/Contents/MacOS/project-reclaimer" list-master --bind 0.0.0.0:49175 --key h3list.key --data . \
  --origin http://your-address:49175 \
  --peer http://148.251.153.44:44340 --peer http://23.159.176.140:44340

Allow incoming connections if macOS asks, and forward TCP and UDP 49175 on your router.

In Docker

The dedicated server image includes the master. Run it with the master's command instead of the servers, and without a game folder. The image runs natively, on x86-64 Linux, and holds no game files.

Not yet tested on its own. The image and the master are the ones dedicated servers run, where the master runs beside the servers. A container that runs only the master hasn't been tried yet.

Folder
reclaimer-master/
├─ compose.yaml             the master: image, command, ports
├─ .env                     MASTER_ORIGIN, the address others reach it at
└─ data/                    its key and the masters it learned
  1. Install Docker Docker Engine with the Compose plugin, 2.24 or newer, on any x86-64 Linux:
    Ubuntu
    sudo apt install docker.io docker-compose-v2
  2. Make the folder and add compose.yaml
    Shell
    mkdir -p reclaimer-master/data
    cd reclaimer-master
    echo 'MASTER_ORIGIN=http://your-address:49175' > .env
    Save compose.yaml in reclaimer-master, or copy it from the file below.
  3. Start
    Shell
    docker compose up -d
    docker compose logs -f
    The first start downloads the image. The log then says [h3list] master http://your-address:49175 (HTTP on TCP 0.0.0.0:49175, server list on UDP 0.0.0.0:49175).
  4. Open the portOpen TCP and UDP 49175 in your provider's firewall or security group. Docker opens published ports on the machine itself, past ufw.

docker compose pull && docker compose up -d updates it to the newest release. On a machine that already runs the dedicated server image, don't add this: that container's master already serves port 49175.

compose.yaml

compose.yaml
# A Project Reclaimer master server on its own, in Docker: no game servers
# and no game files. Guide: https://projectreclaimer.dev/masters
#
# Put this file in a folder of its own, next to an empty data/ folder and a
# .env file that says where others reach this master:
#
#   MASTER_ORIGIN=http://your-address:49175
#
# Then:
#
#   docker compose up -d
#   docker compose logs -f
#
# Open port 49175 on TCP and UDP. Update to the newest release:
#   docker compose pull && docker compose up -d
# 0.9's masters and games don't speak to these: see the guide.

name: reclaimer-master

services:
  master:
    # The dedicated server image, which includes the master. Set IMAGE in
    # .env to stay on one version.
    image: ${IMAGE:-ghcr.io/projectreclaimer/project-reclaimer-dedicated:latest}
    restart: unless-stopped
    command:
      - project-reclaimer
      - list-master
      - --bind
      - 0.0.0.0:49175
      # Its key and the masters it learned (peers.json), kept in ./data.
      - --key
      - /server/h3list.key
      - --data
      - /server
      # Where others reach it, named to the masters it swaps listings with.
      - --origin
      - ${MASTER_ORIGIN:?Set MASTER_ORIGIN in .env to http://your-address:49175}
      # The masters it always swaps with: two of the default masters, each
      # of which holds every listing.
      - --peer
      - http://148.251.153.44:44340
      - --peer
      - http://23.159.176.140:44340
    # The master stops cleanly on Ctrl+C (SIGINT).
    stop_signal: SIGINT
    stop_grace_period: 10s
    volumes:
      - ./data:/server
    # TCP for the Server Browser and other masters, UDP for servers'
    # registrations, players' introductions and STUN.
    ports:
      - "49175:49175/tcp"
      - "49175:49175/udp"
    # The image's health check watches dedicated servers, which this
    # container doesn't run.
    healthcheck:
      disable: true
    security_opt:
      - no-new-privileges:true
    logging:
      driver: json-file
      options:
        max-size: 10m
        max-file: "3"

The master's options

OptionDefaultMeaning
--bind ADDRESS:PORT[::]:44340Where it listens, on that port number for both TCP and UDP. Use port 49175, the usual one: 0.0.0.0:49175 for IPv4, [::]:49175 for both IPv4 and IPv6.
--key FILEh3list.keyThe UDP side's key, made on the first start, in the folder it runs in unless the path says otherwise. Keep it: servers prove themselves against it.
--data DIRnoneWhere it keeps peers.json, the masters it learned. Without it, it forgets them when it stops.
--peer URLnoneA master it always swaps with, as http://host:port. Repeat it for each one. A master with no peer waits for others to come to it.
--origin URLhttp:// its bound addressWhere others reach it, as http://host:port, named when it writes to other masters. Set it: the default is its own loopback address when it listens on every network, which nobody else can use.
--block FILEnoneAddresses it leaves alone: it answers nothing from them and lists no server at one. See keep servers off your list.
--block-words FILEnoneRules for what servers call themselves. A server whose names match one isn't listed.
--allow-many FILEnoneAddresses that may list more than four servers, in the format of --block.
--sync URLnoneAnother master of yours, as http://host:port, kept in step with this one. Repeat it for each one. See several masters of your own.
--closedoffIt reads and sends to only the masters named with --peer and --sync, learns and names no others, and takes another master's listings only from those. Servers still report to it directly.
--unverifiedoffIt lists servers without asking each first whether it's there. Only for a master placed where it can't reach the servers its players can, such as one for a private network: players' browsers leave an unverified master on the internet out.
--trust-unwitnessedoffA server it counted no player on is listed with the count the server itself reports, instead of none. See player counts.

Keep servers off your list

A master's operator decides what it lists. Three text files do it, each named when the master starts and read again within 5 seconds of a change, so nothing needs a restart. Lines starting with # are comments.

By address: --block

One IPv4 or IPv6 address or network on a line. The master answers nothing from those addresses, takes no listing of a server at one, from its host or from another master, and stops handing out one it held.

blocked.txt
# one address or network a line
203.0.113.7
198.51.100.0/24
2001:db8:5::/48

By name: --block-words

One rule on a line. A server is kept off the list when every term of a rule matches its name, host name, map, game type or variant name, whatever the case:

RuleMatches
slurOne word, as a whole word, not as part of a longer one.
free nitroA combination: both words, anywhere, in any order.
"official server"A phrase: these words in a row.
*casino*Part of a word, also when spelled c.a.s.i.n.o or c a s i n o.

A listing holds no names, so the master asks each server it lists what it calls itself, within 2 seconds of each report, and all of them again when the rules change. A file holds up to 2,000 rules of 200 characters. The rules stay private: a master tells them only to the masters it's kept in step with.

What this can't do: a new server can show for a few seconds before it's asked, and a renamed one for up to 30. A server that doesn't answer the master isn't kept off by name, so block its address instead. A blocked server can still be joined by its address or as a favorite, and a browser that also reads a master without your rules still gets it from there.

More than four servers: --allow-many

A master lists at most four servers at one address. Addresses and networks in this file, in the format of --block, aren't held to that: a hosting company's machines, or your own.

Shell
./project-reclaimer list-master --bind 0.0.0.0:49175 --key h3list.key --data . \
  --origin http://your-address:49175 \
  --block blocked.txt --block-words words.txt --allow-many many.txt

Several masters of your own

Masters run by one operator can be kept in step. Start each with --sync and the address of every other one:

Shell
./project-reclaimer list-master --bind 0.0.0.0:49175 --key h3list.key --data . \
  --origin http://your-address:49175 --sync http://198.51.100.7:49175

Every 2 seconds each tells the others its blocked addresses, its word rules, its --allow-many lines and the playing games it heard from. So:

  • An address blocked on one master is blocked on all of them within seconds, and a line taken out where it was written is let back in everywhere. One file on one master is enough.
  • Every master shows the same player count for a server, even when a player's game reached only one of them. Each game is counted once.
  • They swap listings, as with --peer.

Only the masters you name are believed, and only over a connection from that master's own IP address. Masters that share one outgoing address, or sit behind a proxy, look like one sender to the others.

Get it known

A master started with --peer and default masters, as above, reads their listings, so it lists every public server. The default masters don't name other masters, so a master of your own reaches players and hosts when they add it:

  • Players add it under Settings → Online services → Master servers: http://your-address:49175 on a line of its own. Their browser reads it with the other masters on their list. See Join a game.
  • Dedicated server hosts add it to [master] peers, or to RECLAIMER_DEDICATED_MASTER_PEERS in Docker. Their servers then report to it and register with it, and their master swaps listings with it.
dedicated.toml
[master]
peers = ["http://your-address:49175"]

Community masters that name each other with --peer and --origin pass each other on to everyone who reads them, so players who added one learn the rest.

If you also host dedicated servers, the master in that setup can do all of this, so you don't need a second one. It already swaps with the default masters, and names itself at the servers' public_address on its own port. Set origin when it's reached at another address, and add other community masters to peers.

dedicated.toml
[master]
origin = "http://your-address:49175"
peers = ["http://148.251.153.44:44340", "http://23.159.176.140:44340"]

Check that it works

From another machine, ideally on another network, since many home routers can't reach their own public address from inside:

Shell or PowerShell
curl http://your-address:49175/v3/discovery

It answers with JSON: version, which is 3, listings, the listings it holds, masters, the masters it knows, seen, your address as it saw it, rendezvous_port, its UDP port, witnessed, the players it counted on each server, and level, which is 1 on a master that lists only servers that answered it. A couple of minutes after it starts, it should hold the same listings as the default masters, such as http://148.251.153.44:44340/v3/discovery. In Windows PowerShell 5, type curl.exe: plain curl is another command there.

On a PC with the game, this prints every server a master lists that answers, with its ping, its players and the games and mods its players need:

Shell
project-reclaimer --list-servers http://your-address:49175

Troubleshooting

ProblemWhat to do
Nobody else can reach itOpen TCP and UDP 49175 in the firewall, on the router or in your provider's security group, and test from another network.
It holds no listingsStart it with --peer and a default master. It reads its peers every 60 seconds. Check that the machine can connect out to other masters, on TCP 44340 for the default ones; until it can, it only has what servers report to it directly.
Other masters never name itIt needs --origin with an address they can reach, and a --peer to tell. An address on a private network, or the loopback address it uses without --origin, isn't taken.
Players' browsers count it as not responding, though it answers curlThe browser reads a master on the internet only when its answer has "level": 1. Update it to 0.10.3 or newer, and start it without --unverified. See run 0.10.3 or newer.
A server reports to it but isn't listedThe master lists a server once it answered the master on its game port, from the address it reported from. Check that the server's public_address is the address its connections leave from, that its game port is open on UDP, and that it isn't the fifth server at its address: see what a master lists. A server that didn't answer is looked at again after two minutes.
A full server shows 0 players, or fewer than it hasThe browser shows the players the default masters counted. The server needs the current version, its players' games must reach the masters' UDP port, and one address counts for at most 4 players on a server. See player counts.
Servers report to it, but players still can't reach those behind routersOpen or forward its UDP port. Without UDP it lists servers but introduces nobody.
It says it can't bind the portA dedicated server setup or another master holds it, and already does the job. To run both, give this one another port in --bind.
Beside dedicated servers, the log says another master already serves port 49175That's a dedicated setup sharing a master with another one on the machine. Its servers list themselves there, and it starts its own if that one stops.
Double-clicking the program starts the gameStart the master from a terminal with its command, or from a Task Scheduler task.
The command is unknown, or games can't read your masterYou're on 0.9's master or 0.9's game. discovery-master became list-master, and neither side works with the other: see masters from 0.9.
The master lists a server that the browser doesn't showThe browser asks every server directly and leaves out one that doesn't answer on its UDP game port. The server's host opens and forwards that port; see the hosting guide. Masters help players reach servers whose port isn't forwarded, but not through every router; see hosts behind routers.
A server at 192.168.x.x isn't listed to players on the internetThat's on purpose: masters never hand out a local network's addresses outside it. The server's host sets its public_address, or leaves it empty to be listed at the address the masters see.
A server on another PC of your home network isn't in the browserThe browser searches your own networks too, on every adapter of the PC, virtual LANs included, and a server found there says so on its card. Allow UDP 44329 and the game port through the firewall of the PC that hosts. If it still doesn't show, use Direct Connect with that PC's local address.
The line under the list says 0 masters responded, and the list is emptyNo master answered within 2.5 seconds. Check that the PC can connect out to TCP 44340, the default masters' port, then refresh. During an outage, add a community master by hand under Settings → Online services → Master servers. See when a master goes down.
Servers are missing when a clock is wrongThe Server Browser and every host go by each master's clock, so a wrong clock on a player's or host's PC doesn't hide servers. A master still checks listings against its own clock, so keep the clock of a machine that runs one synced: a master whose clock is wrong can turn listings away.