Collective search

Join in three steps

You run one program. It fetches small pieces of the search from this server, works on them with as many cores as you allow, and reports back by itself. Everything is controlled from a page it opens in your browser. Stopping is always safe: unfinished work is handed back in seconds and nothing is lost.

1 · Tools (once)

• Linux (Debian/Ubuntu): sudo apt install build-essential git python3 zlib1g-dev
• macOS: xcode-select --install (Python 3 is included)
• Windows: install WSL (Ubuntu) and follow the Linux line inside it

2 · Get the code and build the worker (once, and again when the panel asks you to update)

git clone https://github.com/DarthCalculus/Pathology-Puzzle-Searcher.git
cd Pathology-Puzzle-Searcher/backsearch
./build_pgo.sh -o backsearch_worker_nt --no-torch

The build runs a short training search and takes a few minutes. The result is a single file, backsearch_worker_nt. Already joined campaign #1? Update both the client and the worker: cd Pathology-Puzzle-Searcher && git pull && cd backsearch && ./build_pgo.sh -o backsearch_worker_nt --no-torch. The server refuses older clients and workers and says so.

3 · Start the client and open the control panel

Your browser opens http://localhost:8765/: the control panel. From there you can

• set how many workers run (each is one search process using up to about 0.5 GB of memory; the client starts half your logical cores by default, one per core is fine on an otherwise idle machine, and use fewer if memory is tight),
• pick which exit position you want to work on, or leave it on "any"; or Big jobs: the few jobs an ordinary worker has too little memory for. They need the big worker: build it once in backsearch with ./build_pgo.sh --big --no-torch, then pick Big jobs here (or start the client with --prefer-big). One big job can use up to about 5 GB and runs alone, so choose it only with 8 GB or more to spare,
• Pause (freezes the workers instantly, keeps your jobs reserved for up to 12 hours) and Resume,
• Stop (each worker prints exactly what it had left, the client hands it back, done in seconds),
• watch the board each worker is expanding, the longest level found on your machine in the last second and the last hour, the longest known for your exit, and your own statistics: jobs, CPU hours, rank.

Headless machine? Add --no-ui. Laptop sleep is fine. If the server is unreachable your finished work waits in an outbox and is delivered later. The client refuses to run a worker build that is not on this server's list, and tells you the two commands to update. Your name is only a label; there are no accounts. When the whole campaign is finished the client says so, delivers its last results and exits by itself (add --keep-going to wait for the next campaign instead). Details: README · how the whole thing is designed.

Right now

"Roots covered" counts the top-level pieces of each exit that are completely searched. The total amount of work is not known in advance, so no percentage of the whole is shown. The full dashboard has every volunteer's live boards and the audit links; finished searches are on the completed campaigns page.

Longest levels found so far

Who is running

How it works, briefly

• A job is a subtree. The search is a tree of board states. A job names one node and means "search everything below it". Subtrees never overlap, so pieces can be handed out freely.
• Long jobs split themselves. After 30 minutes a worker stops, prints the exact list of subtrees it has not finished, and those become new jobs for anyone. Small leftovers are finished on the spot instead of being sent back. Nothing is ever skipped or counted twice.
• Leases, not sign-ups. The server lends a job for an hour and renews the lease while your client keeps in touch. If a client vanishes, the job returns to the pool by itself.
• Trust, verified. Every report carries the worker's source hash and must match this server's list. About 2 % of finished jobs are quietly re-run by someone else and the results compared. The longest level of each exit is re-solved by the site's own solver. An exit is declared finished only when an audit finds every top-level piece covered and every state whose check was inconclusive resolved.
• What comes out. When all six exit positions of the 6x6 board are covered, the result is an exhaustive proof: the longest 6x6 level with no holes, credited to everyone who took part. Campaign #1 settled 5x5 with at most 3 holes (149 moves); see completed campaigns.