Live distributed search
295,147,905,179,352,825,857
THE CURRENT FRONTIER — NUMBERS BEYOND HERE ARE UNVERIFIED
—

A problem unsolved
for 87 years.
You can help.

The Collatz Conjecture is one of mathematics' most famous mysteries. Every number before 2⁶⁸ has been checked by supercomputers. We start where they left off — together, distributed across any machine that wants to contribute. First to push the frontier past a milestone wins a prize.

Contribute compute What is this?
The conjecture

Deceptively simple.
Completely unsolved.

Take any positive integer. If it's even, divide by two. If it's odd, multiply by three and add one. Repeat. The conjecture states that no matter where you start, you always eventually reach one. Nobody has proved it. Nobody has disproved it. Paul Erdős said mathematics wasn't ready for it.

When n is even
n → n / 2
Always produces a smaller number. Straightforward.
When n is odd
n → 3n + 1
Produces a larger even number. Then divide. Eventually — maybe — reach one.
Sequence from n = 27 — total stopping time: 111 steps
27→82→41→124→62→31→94→47→142→71→214→107→322→161→484→242→121→364→182→91→274→137→412→206→103→310→155→466→233→… (81 more steps) → 1

"Mathematics is not yet ready for such problems."

— Paul Erdős, on the Collatz Conjecture
Why distributed

One machine.
1,482,562 years.

Every number up to 295,147,905,179,352,825,856 has been checked. That took decades of supercomputer time. The search ahead is bigger. No single machine can reach the next milestone in a human lifetime. But distributed across enough machines, it becomes a matter of years — or less.

1.48M
Years
Time for one fast desktop to sweep the target range alone
14,613
Years
Same range across 100 coordinated machines running together
~1
Year
With 1,000 average PCs contributing — each doing their share
1,482,562
Years — one machine
→
~1
Year — 1,000 machines
The milestone prizes

Every frontier advance
is worth something.

The search is divided into named milestones — thresholds at powers of ten. The first contributor whose compute pushes the frontier past each threshold wins a cash prize, cryptographically signed the moment it happens. Prizes double at each level.

$655,350,000
Total prize pool
<
Contribute

Three ways to join.
Any hardware works.

Every machine that connects receives a unique cryptographic identity. If your compute crosses a milestone, the coordinator signs a claim token and saves it to your machine automatically. Your identity is your proof.

01 📱

Browser

No install. No account. The full search algorithm runs in JavaScript in your browser tab. Works on any phone, tablet, or desktop.

  • Scan the QR code or open the link
  • Enter your name
  • Tap Start — you're contributing
Open browser worker →
02 🖥

Python worker

Full speed. Uses all your CPU cores. GPU auto-detected on NVIDIA and AMD hardware — typically 50–400× faster than CPU alone.

  • pip install requests
  • python3 collatz_worker.py --coordinator URL
  • GPU detected automatically if available
Get the worker →
03 ⚙️

Headless service

Set it and forget it. Installs as a systemd service on Linux or Windows Task Scheduler. Survives reboots and SSH disconnects.

  • bash install_worker_service.sh
  • Runs automatically on boot
  • Claim tokens saved to identity file
Install guide →
Technical details

For those who want to know
how it actually works.

The algorithm — three optimisations, ~113× speedup ›

A naïve implementation tests every integer and runs each sequence all the way to 1. Three mathematical observations eliminate almost all of that work without losing coverage:

Early exit at 2⁶⁸. Everything below 2⁶⁸ is already verified. The moment a sequence dips below the threshold, it's guaranteed to reach 1. No need to continue. This reduces the average step count from ~550 to ~45 — roughly a 10× reduction.

Odd-only testing. Any even number immediately halves to a smaller value. If it's below 2⁶⁸ it's already verified. If it's above, we'll reach it as an odd number later. Testing only odd starting values is mathematically complete and cuts the work in half.

Compressed Syracuse steps. For an odd n, the next operation always produces 3n+1 (even), followed by repeated halving until the next odd is reached. Instead of iterating each step individually, we jump directly to the next odd value in one operation using bit arithmetic:

x = 3 * n + 1 # always even for odd n k = (x & -x).bit_length() - 1 # trailing zeros = halvings needed next_odd = x >> k # one operation, not k iterations steps += k + 1

Combined, these reduce average steps per number from ~550 to ~10, yielding a measured speedup of 112.8×.

GPU acceleration — CUDA and OpenCL ›

The search is embarrassingly parallel — each starting number is independent. GPUs are ideal. The worker auto-detects available hardware on startup:

Milestone Value Prize Status
Trillion 10¹² — Pre-verified
Quadrillion 10¹⁵ — Pre-verified
Quintillion 10¹⁸ — Pre-verified
Sextillion ← 10²¹ $10,000 First target
Septillion 10²⁴ $20,000 Unclaimed
Octillion 10²⁷ $40,000 Unclaimed
Nonillion 10³⁰ $80,000 Unclaimed
Decillion 10³³ $160,000 Unclaimed
… doubles at each level …
Vigintillion 10⁶³ $163,840,000 Unclaimed
Centillion 10³⁰³ $327,680,000 Unclaimed
HardwareBackendThroughput
NVIDIA RTX 3080CUDA~400M odd/sec
NVIDIA GTX 1080CUDA~120M odd/sec
AMD RX 6800OpenCL~200M odd/sec
Apple M2OpenCL~40M odd/sec
8-core CPUmultiprocessing~6.4M odd/sec

The GPU kernel uses 128-bit integer arithmetic (two uint64 registers) to handle numbers above 2⁶⁴. Numbers that exceed the safe range during computation are flagged and re-verified on CPU using Python's arbitrary-precision integers.

NVIDIA: pip install numba + CUDA Toolkit from nvidia.com
AMD/Intel/Apple: pip install pyopencl

Cryptographic prize verification — how claim tokens work ›

When the verification frontier crosses a milestone, the coordinator generates a claim token:

token = HMAC-SHA256( coordinator_secret, worker_id + ":" + milestone + ":" + frontier_n + ":" + crossed_at )

This token is returned in the API response and saved to your collatz_identity.json. The coordinator secret never leaves the server — it is never transmitted via any API endpoint and is redacted from the nightly public backup.

To verify a claim, the coordinator recomputes the HMAC and compares it using hmac.compare_digest (timing-safe, preventing timing oracle attacks). The token is mathematically bound to a specific worker UUID, milestone name, frontier value, and timestamp. Changing any one of these by a single character produces a completely different hash and fails verification.

Three checks are required for a valid claim: HMAC matches, milestone appears in the coordinator's milestone log, and the recorded winner's worker ID matches the claimant's. All three must pass.

Distributed architecture — coordinator and workers ›

A single coordinator process owns the number line and divides it into contiguous chunks of 500,000 odd integers. Workers request chunks, test every number, and report back. Workers are stateless — they hold no persistent knowledge of the frontier.

The coordinator checkpoints its state atomically after every 50 completed chunks, writing to a temporary file (chmod 600) then renaming it over the checkpoint. Chunks that are issued but not reported back within 600 seconds are automatically re-issued to the next requesting worker. No verified coverage is ever lost.

The coordinator serves a live dashboard at /status, a leaderboard at /workers, a milestone prize board at /milestones, and a mobile browser worker at /join. All pages auto-refresh every 15 seconds. A nightly job uploads frontier status and a sanitised checkpoint to the public GitHub repository at 01:00 UTC.

Will this ever prove the conjecture? ›

No. The integers are infinite. Any finite search covers a set of measure zero. Brute-force computation cannot prove a universal statement about all positive integers. A proof requires a fundamentally different approach — some structural argument that applies to every number simultaneously.

Terence Tao proved in 2022 that "almost all" Collatz orbits attain "almost bounded" values — the deepest theoretical progress to date, but still short of a proof. The expected number of counterexamples below 10¹⁰⁰ is effectively zero under standard heuristic arguments. This is what makes the problem interesting: the evidence is overwhelming, the proof is nowhere in sight.

What the search does produce is real mathematical value: each milestone is a new, permanent lower bound on the smallest possible counterexample, cited in the mathematical literature. Every number cleared is cleared forever.

Source code, academic paper, and API reference ›

The complete source code is publicly archived at github.com/huggablehacker/Collatz-Frontier under the MIT License.

The repository includes: Python worker (CPU + CUDA + OpenCL), Flask coordinator, systemd service files, Windows batch launchers and PyInstaller specs, nightly GitHub uploader, checkpoint cleanup tools, a prize verification test script, full API reference documentation, security assessment, and a peer-review paper formatted for submission to Mathematics of Computation (AMS MCOM).

The academic paper covers formal correctness proofs for all three algorithmic optimisations, proof of HMAC claim token security, architecture description, mobile browser worker implementation, and empirical benchmarks. References include Oliveira e Silva (2010), Tao (2022), Lagarias (1985), Anderson/BOINC (2004), and Bellare et al. on HMAC security (1996).