{"id":48524639,"url":"https://github.com/hevnsnt/collider","last_synced_at":"2026-05-21T02:13:12.099Z","repository":{"id":336380315,"uuid":"1149419805","full_name":"hevnsnt/collider","owner":"hevnsnt","description":"GPU-accelerated Bitcoin Puzzle solver using Pollard's Kangaroo algorithm. K=1.15 efficiency. CUDA + Metal.","archived":false,"fork":false,"pushed_at":"2026-05-19T20:43:18.000Z","size":30730,"stargazers_count":8,"open_issues_count":1,"forks_count":6,"subscribers_count":3,"default_branch":"main","last_synced_at":"2026-05-19T23:03:32.614Z","etag":null,"topics":["bitcoin","bitcoin-puzzle","cryptocurrency","cuda","ecdlp","gpu","mining-pool","open-source","pollard-kangaroo","secp256k1"],"latest_commit_sha":null,"homepage":null,"language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/hevnsnt.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2026-02-04T04:59:56.000Z","updated_at":"2026-05-19T20:43:22.000Z","dependencies_parsed_at":null,"dependency_job_id":null,"html_url":"https://github.com/hevnsnt/collider","commit_stats":null,"previous_names":["hevnsnt/collider"],"tags_count":27,"template":false,"template_full_name":null,"purl":"pkg:github/hevnsnt/collider","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hevnsnt%2Fcollider","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hevnsnt%2Fcollider/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hevnsnt%2Fcollider/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hevnsnt%2Fcollider/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/hevnsnt","download_url":"https://codeload.github.com/hevnsnt/collider/tar.gz/refs/heads/main","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/hevnsnt%2Fcollider/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":33285268,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-20T15:12:43.734Z","status":"online","status_checked_at":"2026-05-21T02:00:07.181Z","response_time":62,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["bitcoin","bitcoin-puzzle","cryptocurrency","cuda","ecdlp","gpu","mining-pool","open-source","pollard-kangaroo","secp256k1"],"created_at":"2026-04-07T22:01:25.795Z","updated_at":"2026-05-21T02:13:12.092Z","avatar_url":"https://github.com/hevnsnt.png","language":"C++","funding_links":[],"categories":[],"sub_categories":[],"readme":"# theCollider\n\n\u003e A GPU-accelerated solver for the [Bitcoin Puzzle Challenge](https://privatekeys.pw/puzzles/bitcoin-puzzle-tx), built for the unsolved keys at the hard end of the curve.\n\ntheCollider is the most complete open-source toolkit for the Bitcoin Puzzle Challenge today: solo Pollard's Kangaroo and brute-force search on CUDA (Windows, Linux) and Metal (macOS Apple Silicon), a pool client for distributed solving via the [Collision Protocol](https://collisionprotocol.com) pool, and the canonical bundled record of every solved puzzle to date. A paid Pro edition adds a brain-wallet opportunistic pipeline and Brainwallet cracker on top of the same core.\n\n```\n$ ./collider --puzzle 135 --kangaroo\n```\n\nThat command, today, on commodity hardware, takes a real swing at puzzle #135, currently the smallest unsolved kangaroo-able puzzle in the challenge.\n\n---\n\n## The puzzle, briefly\n\nIn 2015, the author of Bitcoin Core funded 160 addresses on the Bitcoin mainnet. The N-th address holds a private key drawn from the range `[2^(N-1), 2^N)`. The total reward across all 160 addresses approaches 1000 BTC. The addresses are public; the keys are not. The challenge is to find them.\n\nEvery puzzle from 1 to 70 has been solved, plus every multiple of 5 from 75 to 130 (82 in total; bundled in `data/puzzle_history.json`). The remaining unsolved puzzles split into two populations with very different mathematics:\n\n| Bit range                                          | Status                                    | Solvable how                                                 |\n| -------------------------------------------------- | ----------------------------------------- | ------------------------------------------------------------ |\n| 1 to 65 (contiguous)                               | Solved                                    | Bundled, for record and reference                            |\n| 66 to 70 (contiguous)                              | Solved                                    | Bundled                                                      |\n| 75, 80, 85 ... 130 (mult. of 5)                    | Solved (partially-spent, pubkey revealed) | Bundled                                                      |\n| 135, 140, 145, 150, 155, 160                       | **Unsolved, pubkey revealed**             | Pollard's Kangaroo, distributed                              |\n| 71, 72, 73, 74, 76, 77, ... non-mult-of-5 above 70 | **Unsolved, pubkey unknown**              | Brute force only (computationally infeasible above ~64 bits) |\n\nThat second-to-last row is the tractable frontier. Puzzles #135 through #160 (the multiples of 5) were each originally funded with a reward proportional to the puzzle number; #135 held an original deposit on the order of 13.5 BTC, #160 on the order of 16 BTC. Live balances drift as the original wallet broadcasts further partial-spend transactions; the `--puzzle` banner queries mempool.space at solve time to report the current balance. The public keys for these targets are knowable today because the original wallet has, at some point, broadcast a partial-spend transaction, exposing the pubkey on-chain.\n\nThe bottom row is mathematically locked. Without a spending transaction, the pubkey is unknown to anyone, anywhere, and SHA-256 plus RIPEMD-160 keep it that way. Brute force is the only remaining option, and at 71+ bits, brute force on consumer hardware is multi-decade work.\n\ntheCollider concentrates on what is solvable: kangaroo against revealed pubkeys, alone or as part of a pool.\n\n---\n\n## Quick start\n\n\u003e Three OS commands, one `./collider` invocation. No SDK install, no account, no auth.\n\n### Linux (CUDA)\n\n```bash\ncurl -fsSL -o collider \\\n  https://github.com/hevnsnt/collider/releases/latest/download/collider-linux-x64-cuda\nchmod +x collider\n./collider\n```\n\n### Windows (CUDA)\n\n```powershell\niwr -OutFile collider.exe `\n  https://github.com/hevnsnt/collider/releases/latest/download/collider-windows-x64-cuda.exe\n.\\collider.exe\n```\n\n### macOS (Apple Silicon, Metal)\n\n```bash\ncurl -fsSL -o collider \\\n  https://github.com/hevnsnt/collider/releases/latest/download/collider-macos-arm64-metal\nchmod +x collider\n./collider\n```\n\nThe default `./collider` invocation:\n\n1. Detects every visible GPU and calibrates batch size on first launch.\n2. ROI-ranks the unsolved puzzles by reward divided by expected operations.\n3. Picks the best target, fires kangaroo if the pubkey is bundled, falls back to brute force otherwise.\n\nTo target a specific puzzle:\n\n```bash\n./collider --puzzle 135 --kangaroo\n```\n\nTo join the public pool and distribute the work:\n\n```bash\n./collider --pool jlps://collisionprotocol.com:17403 \\\n           --worker 1YourBitcoinAddress...\n```\n\nThe full CLI reference is below.\n\n---\n\n## How it compares\n\ntheCollider is not the first GPU solver for this problem. Several open-source projects have moved the state of the art forward, and theCollider builds directly on one of them.\n\n### RCKangaroo (RetiredCoder)\n\n[RCKangaroo](https://github.com/RetiredCoder/RCKangaroo) is a state-of-the-art kangaroo implementation. It introduced the SOTA method with K=1.15 (versus K=2.1 for classic three-way kangaroo, ~1.8x fewer operations and ~1.8x less DP storage), and it benchmarks at roughly 8 GKeys/s on an RTX 4090. **theCollider uses RCKangaroo as its CUDA kangaroo backend.** Credit where it belongs: the kernel doing the heavy lifting on Windows and Linux is RetiredCoder's, redistributed here under its GPLv3 license in `third_party/RCKangaroo/`.\n\nWhat theCollider adds on top:\n\n| Capability                                                     | RCKangaroo               | theCollider                                                 |\n| -------------------------------------------------------------- | ------------------------ | ----------------------------------------------------------- |\n| SOTA kangaroo on CUDA (Windows, Linux)                         | Yes (the implementation) | Yes (links RCKangaroo)                                      |\n| Apple Silicon / Metal kangaroo                                 | No (CUDA only)           | Yes (native Jacobian Metal port, v1.4.1)                    |\n| Apple Silicon / Metal brute force                              | No                       | Yes (v1.4.1)                                                |\n| Distributed / pool solving                                     | No (solo only)           | Yes (JLP wire protocol over TCP+TLS)                        |\n| Bundled puzzle metadata (addresses, ranges, pubkeys)           | Manual per run           | All 82 solved puzzles plus revealed-pubkey unsolved bundled |\n| Automatic puzzle selection (ROI ranking)                       | No                       | Yes                                                         |\n| Graceful kangaroo to brute-force fallback on no-pubkey puzzles | No                       | Yes (v1.4.1)                                                |\n| Live BTC balance on the solved banner (mempool.space)          | No                       | Yes (v1.4.1)                                                |\n| Brain-wallet + funded-address scanner (100M+ addresses)        | No                       | Yes, Pro edition                                            |\n| Hashcat-style rule engine + bloom-filter lookup                | No                       | Yes, Pro edition                                            |\n| License                                                        | GPLv3                    | MIT (Free), commercial (Pro)                                |\n\nOn raw CUDA kangaroo throughput the two are identical, because theCollider links RCKangaroo's kernel directly (see `third_party/RCKangaroo/` and `src/gpu/rckangaroo_wrapper.cu`). RCKangaroo gives you the solver kernel; theCollider gives you the solver kernel plus Apple Silicon support (Metal kangaroo, our own implementation), a pool client and JLP protocol, multi-GPU orchestration, brute-force kernels for the smaller puzzles, and the operator tooling around all of it. The two are complementary, not competitive: theCollider is \"RCKangaroo plus everything around it that you would otherwise have to build yourself.\"\n\n### Other solvers in the space\n\n- [BSGS / Pollard's Rho variants](https://github.com/JeanLucPons/BSGS) tend to be 32- to 64-bit ceilings; they are not viable at puzzle #135 scale.\n- [Kangaroo (JLP)](https://github.com/JeanLucPons/Kangaroo) is the canonical older kangaroo solver; predates the SOTA method.\n- Web-based \"checkers\" are not solvers; they query precomputed databases.\n\ntheCollider treats kangaroo, brute force, and the brain-wallet path (Pro) as one product with shared scaffolding (CLI, config, multi-GPU calibration, pool, telemetry, checkpointing), instead of three separate tools.\n\n---\n\n## Pool mode (Collision Protocol)\n\nFor puzzles above #135, no single machine has the compute budget to finish in a reasonable time. The pool solves this by sharding the search range across many workers and letting them share distinguished points (DPs). When a collision is detected on the server, the private key falls out of the math.\n\n```bash\n./collider --pool jlps://collisionprotocol.com:17403 --worker 1YourBitcoinAddressForRewards\n```\n\nWhat happens after AUTH:\n\n1. The server assigns your worker a chunk of the kangaroo search range plus a `work_id` attestation token.\n2. Your GPU runs kangaroo on that chunk, producing distinguished points (X coordinate with a configurable bit-count of leading zeros).\n3. Your client batches DPs into `DP_BATCH_V2` frames every few seconds and submits.\n4. The server tracks the cumulative DP count per worker. The Bitcoin address you authenticated with is the reward-accrual key.\n5. When two DPs collide (one tame, one wild), the server reconstructs the private key and pushes a `SOLUTION` frame to every connected worker.\n6. Workers who contributed valid DPs accrue share-of-pool credit, redeemable when a puzzle is solved per the pool's payout policy. See [docs/POOL.md](docs/POOL.md) for the mechanics.\n\nThe wire protocol has anti-cheat: every DP carries a `work_id` attestation (you cannot resubmit captured DPs against a different chunk) and a per-DP monotonic `sequence` nonce (you cannot replay a captured `DP_BATCH`). AUTH replay is blocked by a 30-second timestamp drift window. Invalid DPs cost you reputation per IP, with bans escalating from 1 hour to permanent.\n\nThe reference server is the [Collision Protocol](https://github.com/hevnsnt/collision-protocol) project, deployed at `collisionprotocol.com`. Third-party servers can implement the same protocol (it is documented in full at [docs/JLP-PROTOCOL.md](docs/JLP-PROTOCOL.md)).\n\n---\n\n## Free vs. Pro\n\ntheCollider ships in two editions from one source tree.\n\n| Capability                                                              | Free (MIT) | Pro (commercial) |\n| ----------------------------------------------------------------------- | ---------- | ---------------- |\n| Pollard's Kangaroo (CUDA, Metal)                                        | Yes        | Yes              |\n| Brute-force puzzle search (CUDA, Metal)                                 | Yes        | Yes              |\n| Pool client (JLP, TLS)                                                  | Yes        | Yes              |\n| Bundled puzzle history (all 82 solved)                                  | Yes        | Yes              |\n| Multi-GPU support with calibration                                      | Yes        | Yes              |\n| Save / resume checkpoints                                               | Yes        | Yes              |\n| GPU benchmark                                                           | Yes        | Yes              |\n| Brain-wallet passphrase pipeline + 100M+ funded-address bloom filter    |            | Yes              |\n| Hashcat-style rule engine on GPU (mutate any wordlist into billions)    |            | Yes              |\n| PCFG + Markov passphrase generators (high-probability candidates first) |            | Yes              |\n| v2 multi-scheme kernel: weak-PRNG sweeps (Milk Sad, Profanity, etc.)    |            | Yes              |\n| License gating (HMAC-SHA256, offline-verifiable)                        |            | Yes              |\n\nPro licenses are available at [collisionprotocol.com/pro](https://collisionprotocol.com/pro). The Pro source tree is not public; the Free build is the same source minus the Pro modules, generated automatically by GitHub and published at [github.com/hevnsnt/collider](https://github.com/hevnsnt/collider).\n\n---\n\n## Pro: every key is a lottery ticket\n\nFree is a complete puzzle solver. **Pro turns the same binary into a treasure hunter.**\n\nYour GPU is grinding billions of private keys to find puzzle 135. In Free, every key is checked against exactly one target. In Pro, **every key is also checked against a 100 million entry funded-address bloom filter**, automatically, in the same GPU kernel pass, at essentially zero marginal cost.\n\n### The killer feature: opportunistic scanning during pool and standalone work\n\n```\nFree pool mode:\n  GPU computes pubkey -\u003e derives DP -\u003e sends DP to pool server.\n  (One target. Puzzle 135. That is the whole story.)\n\nPro pool mode:\n  GPU computes pubkey -\u003e derives DP -\u003e hashes to Bitcoin address -\u003e\n    queries bloom filter for 100M+ funded addresses -\u003e\n    hit? log to bloom_hits.txt for verification.\n  Sends DP to pool server.\n  (Still mining puzzle 135. AND scanning every key against every\n   funded Bitcoin wallet that has ever existed.)\n```\n\nYou bought the hardware. You pay the power bill. Pro makes sure every key your GPU computes is doing as much work for you as it possibly can. Tail `bloom_hits.txt` in another terminal and walk away.\n\n### Plus: dedicated brain-wallet and weak-PRNG modes\n\nWhen you are not pool-mining, Pro flips into dedicated treasure-hunter modes:\n\n- **Brain wallets**: PCFG + Markov + hashcat-style rule engine drive a fused GPU pipeline (SHA-256 -\u003e secp256k1 -\u003e hash160 -\u003e bloom probe) at tens to hundreds of millions of candidate checks per second on Ampere through Blackwell GPUs. Measure your card with `./collider --benchmark`. `SHA256(\"correct horse battery staple\")` is a real private key; tens of thousands of these wallets were created between 2011 and 2014, and many still hold real Bitcoin today.\n- **Weak-PRNG sweeps (v2 multi-scheme kernel)**: scans for keys produced by historically-broken random number generators. Milk Sad (CVE-2023-39910), Profanity (CVE-2022-40769), Trust Wallet, glibc, MSVC, Java. Five Bitcoin address types per candidate seed, eight scheme variants per pass.\n\nSame install. Same UI. License-gated via HMAC-SHA256, verified offline.\n\n### **See [docs/PRO.md](docs/PRO.md) for the full Pro pitch, including the math behind opportunistic scanning, generator details, the bloom-filter internals, and the pricing tiers.**\n\nPro licenses are at [collisionprotocol.com/pro](https://collisionprotocol.com/pro).\n\n---\n\n## CLI reference\n\nFull list: `./collider --help`. Highlights below; the source of truth is [`src/cli/cli_parser.cpp`](src/cli/cli_parser.cpp).\n\n### Puzzle mode\n\n| Flag                                         | Effect                                                                                          |\n| -------------------------------------------- | ----------------------------------------------------------------------------------------------- |\n| `--puzzle N`, `-P`                           | Target puzzle N. Default: ROI-pick the best unsolved puzzle.                                    |\n| `--kangaroo`                                 | Force Pollard's Kangaroo. Demotes to brute force gracefully when no pubkey is bundled (v1.4.1). |\n| `--all-unsolved`                             | Auto-progress through unsolved puzzles in turn.                                                 |\n| `--auto-next`                                | After a solve, advance to the next puzzle automatically.                                        |\n| `--puzzle-min-bits N`, `--puzzle-max-bits N` | Bound `--all-unsolved` to a bit range.                                                          |\n| `--puzzle-target \u003caddr\u003e`                     | Override target Bitcoin address (independent of `--puzzle N`).                                  |\n| `--puzzle-start \u003chex\u003e`                       | Override range start (`0x...`).                                                                 |\n| `--puzzle-end \u003chex\u003e`                         | Override range end.                                                                             |\n| `--pubkey \u003chex\u003e`                             | 33-byte compressed pubkey. Only needed for non-bundled targets.                                 |\n| `--puzzle-checkpoint \u003cfile\u003e`                 | Save / resume search state across runs.                                                         |\n| `--dp-bits N`                                | Distinguished-point bits for kangaroo. Default auto. Manual: 16 to 28.                          |\n| `--random` / `--sequential`                  | Search direction within the range. Default: random.                                             |\n| `--analyze`                                  | Print ROI ranking and exit. No search.                                                          |\n| `--no-smart`                                 | Disable ROI-based auto-selection; pick the lowest-numbered unsolved instead.                    |\n\n### Pool mode\n\n| Flag                     | Effect                                                              |\n| ------------------------ | ------------------------------------------------------------------- |\n| `--pool \u003curl\u003e`, `-p`     | `jlps://` (TLS), `jlp://` (plaintext), or `http://` (HTTP variant). |\n| `--worker \u003caddr\u003e`, `-w`  | Bitcoin address for pool rewards. Required for `--pool`.            |\n| `--pool-password \u003cpass\u003e` | Optional. Collision Protocol does not require it.                   |\n| `--pool-api-key \u003ckey\u003e`   | Optional, for HTTP pools.                                           |\n\n### GPU and tuning\n\n| Flag                     | Effect                                                                |\n| ------------------------ | --------------------------------------------------------------------- |\n| `--gpus 0,1,3`, `-g`     | Specific GPU IDs. Default: all detected.                              |\n| `--batch-size N`         | Keys per batch. Default 4M. Tune with `--calibrate`.                  |\n| `--calibrate`            | Run batch-size calibration (also runs automatically on first launch). |\n| `--force-calibrate`      | Force re-calibration even if a saved value exists.                    |\n| `--benchmark`            | Synthetic GPU benchmark. Default 30 seconds.                          |\n| `--benchmark-time \u003csec\u003e` | Benchmark duration override.                                          |\n\n### General\n\n| Flag                    | Effect                                                                                       |\n| ----------------------- | -------------------------------------------------------------------------------------------- |\n| `--config \u003cfile\u003e`, `-c` | Config file path. Default search: `./config.yml`, `./config.yaml`, `~/.collider/config.yml`. |\n| `--verbose`, `-v`       | Verbose output.                                                                              |\n| `--debug`               | Debug output.                                                                                |\n| `--help`, `-h`          | Help.                                                                                        |\n\n### Pro mode (license-gated) **(PRO VERSION ONLY)**\n\nThese flags belong to the brain-wallet pipeline that ships only in the Pro edition. The Free parser accepts them but the runner short-circuits with a Pro-feature hint, so they are visible in `./collider --help` everywhere; the actual work happens in a Pro build.\n\n| Flag                  | Effect                                                                                       |\n| --------------------- | -------------------------------------------------------------------------------------------- |\n| `--brainwallet`       | **(PRO VERSION ONLY)** Brain-wallet pipeline. Requires `--bloom`.                            |\n| `--brainwallet-setup` | **(PRO VERSION ONLY)** Interactive setup wizard for the brain-wallet pipeline.               |\n| `--bloom \u003cfile.blf\u003e`  | **(PRO VERSION ONLY)** Bloom filter of funded addresses (built with the `build_bloom` tool). |\n| `--resume`            | **(PRO VERSION ONLY)** Resume the brain-wallet scan from the last checkpoint.                |\n| `--save-interval N`   | **(PRO VERSION ONLY)** Save state every N candidates.                                        |\n| `--cpu-rules`         | **(PRO VERSION ONLY)** Force CPU-side rule expansion.                                        |\n\nPro license activation is handled at first run via the interactive flow, not a separate flag. A binary that requires activation will prompt and direct you to [collisionprotocol.com/pro](https://collisionprotocol.com/pro) on first launch.\n\n---\n\n## Configuration\n\nCLI flags always win. Anything not on the command line falls through to `config.yml` (in the working directory or `~/.collider/`), then to the built-in defaults.\n\nA documented example with every section is at [`example-config.yml`](example-config.yml). The full schema is in [`src/core/yaml_config.hpp`](src/core/yaml_config.hpp).\n\nMinimum pool config:\n\n```yaml\npool:\n  worker: \"1YourBitcoinAddressForRewards\"\n  url: \"jlps://collisionprotocol.com:17403\"\n```\n\nStandalone with a custom range:\n\n```yaml\npuzzle:\n  number: 71 # Used for record-keeping; range below overrides.\n  kangaroo: false # No bundled pubkey for arbitrary addresses.\n  target: \"13zb1hQbWVsc2S7ZTZnP2G4undNNpdh5so\"\n  start: \"0x40000000000000000\"\n  end: \"0x7ffffffffffffffff\"\n```\n\nFull schema and precedence rules: [docs/CONFIGURATION.md](docs/CONFIGURATION.md).\n\n---\n\n## Build from source\n\nPrebuilt binaries are the path of least resistance ([GitHub Releases](https://github.com/hevnsnt/collider/releases)). For source builds, the canonical entry points are:\n\n- **Linux**: `cmake -B build -G Ninja -DCMAKE_BUILD_TYPE=Release \u0026\u0026 cmake --build build --parallel`\n- **Windows**: same, from the \"x64 Native Tools Command Prompt for VS 2022\". vcpkg auto-bootstraps for OpenSSL.\n- **macOS**: `./build_macos.sh free` (sets `OPENSSL_ROOT_DIR` from Homebrew and runs Ninja).\n\nFull per-platform guides:\n\n- [docs/INSTALL.md](docs/INSTALL.md) - prerequisites, CUDA setup, troubleshooting.\n- [docs/BUILD-MACOS.md](docs/BUILD-MACOS.md) - Metal specifics, embedded shaders, build flags.\n\nCUDA architecture defaults: `75;86;89;120` (Turing, Ampere, Ada, Blackwell desktop). Override with `-DCMAKE_CUDA_ARCHITECTURES=\"89\"` (or whichever SM matches your card) for ~3x faster compile times. Note: sm_120 is desktop Blackwell (RTX 5090, RTX PRO 6000); sm_100 is datacenter Blackwell (B100/B200) and is not in the default.\n\n---\n\n## Performance\n\nBenchmarked per-GPU numbers live in the [release notes](https://github.com/hevnsnt/collider/releases) for each tagged version. Throughput depends strongly on driver version, batch size, and which kernel path is exercised; static numbers in a README go stale within weeks of the next driver release.\n\nFor a fresh number on your hardware:\n\n```bash\n./collider --benchmark\n./collider --benchmark --benchmark-time 60\n```\n\nThe Free benchmark measures CPU and GPU SHA-256 throughput so operators can validate that the hardware is reachable and approximately matches what other tools see on the same silicon. The Pro benchmark runs the full brain-wallet fused kernel (SHA-256 -\u003e secp256k1 -\u003e hash160 -\u003e bloom probe) and reports per-stage and end-to-end rates. For the standalone benchmark driver with the full per-stage table:\n\n```bash\n./bench_gpu_pipeline --time 30 --gpu 0\n```\n\n---\n\n## Status\n\nCurrent release: **v1.4.2 (stable, public)**.\n\nv1.4.2 is the \"correctness shipped\" release. It locks in the puzzle and brain-wallet pipelines as solved problems and adds the operational hardening (save/resume, pool resilience, multi-panel brain-wallet TUI) that day-to-day operators need. Performance work is the next milestone, not this one.\n\n### Performance expectations (v1.4.2)\n\ntheCollider's CUDA secp256k1 + bloom pipeline currently runs at roughly **30 to 50% of the state-of-the-art** (RCKangaroo, libsecp256k1, brainflayer) on the same silicon. The kangaroo path links RCKangaroo directly and inherits its throughput; the brain-wallet fused pipeline does not yet share that field arithmetic and is the gap.\n\nThe gap is concentrated in three known areas, all queued for the next release:\n\n- 32-bit limb PTX field arithmetic where SOTA uses hand-tuned 64-bit limbs.\n- No GLV decomposition on the brain-wallet scalar multiply path (`src/gpu/glv_decompose.cuh` exists but is not wired into `fused_pipeline.cu`).\n- Single-threaded host generators that can starve a 4090/5090 pipeline.\n\nUse the built-in benchmark for fresh numbers on your hardware:\n\n```bash\n./collider --benchmark\n./collider --benchmark --benchmark-time 60\n```\n\n### Scheduled work\n\n- **v1.5.0 (perf): crypto pipeline rewrite.** 64-bit limb PTX field arithmetic, GLV + Strauss-Shamir simultaneous double-scalar mul on the brain-wallet fused kernel, batched Montgomery inverse, host-generator thread pool. Target: 2.5 to 3.5x throughput vs v1.4.2 on the same GPU. Estimated 3 to 4 weeks for one engineer.\n- **v1.6.0 (anticipated): puzzle and pool TUI parallel overhaul.** The multi-panel TUI shipped in v1.4.2 covers brain-wallet mode only; puzzle and pool modes still use single-line flat progress. v1.6.0 brings the same multi-panel treatment (range coverage, GPU panel, connection state, DP sparkline, hotkeys) to those modes.\n\n### Known limitations in v1.4.2\n\n- **Standalone puzzle kangaroo save/resume**: works. Auto-saved to `~/.collider/state/kangaroo_herd_puzzle_\u003cN\u003e.kang` on shutdown (SIGINT or solve completion); resumed with `--resume-kangaroo`. Routes through a patched RCKangaroo (`third_party/RCKangaroo/.patches/save-load-state.patch`).\n- **Pool kangaroo save/resume**: works. Auto-saved to `~/.collider/state/kangaroo_herd_\u003cwork_id\u003e.kang` and resumed on next chunk assignment.\n- **Puzzle and pool TUI**: flat-line single-line progress. Multi-panel TUI is the v1.6.0 scope; the brain-wallet TUI already shipped at v1.4.2.\n- **CUDA crypto pipeline throughput**: see \"Performance expectations\" above. v1.5.0 closes this gap.\n- **AMD ROCm and Apple Silicon Metal**: AMD has no ROCm port. Metal kangaroo and brute force ship in v1.4.2 (since v1.4.1) but the v1.5.0 field rewrite is CUDA-only because Metal lacks the PTX equivalent; a separate Metal field rewrite is out of scope for v1.5.0.\n\n### v1.4.2 highlights vs v1.4.1\n\n- Pool kangaroo herd save/resume (`Tier C`) across SIGINT and chunk reassignment.\n- Standalone puzzle kangaroo herd save/resume via a vendored RCKangaroo patch.\n- Brain-wallet multi-panel FTXUI experience (header, GPU panel, range coverage, DP sparkline, hotkeys, help overlay).\n- Empty-hit dual-bloom workflow (`--bloom-tight`, `--verify-set`, `--track-empty-hits`).\n- WarpWallet brain-wallet scheme (`--warpwallet-salt`).\n- v2 multi-scheme weak-PRNG kernel (Milk Sad, Profanity, Trust Wallet, glibc, MSVC, Java) wired through the puzzle pipeline.\n- DP sequence-nonce window on the pool wire (`DP_BATCH_V2`).\n- Apple Silicon kangaroo and brute force (no more CPU fallback on Mac).\n- All 82 confirmed-solved puzzles bundled (1 to 70 plus every multiple of 5 from 75 to 130).\n- Graceful kangaroo to brute-force demotion when no pubkey is available.\n- Live BTC balance on solved banners via mempool.space.\n- BTC payout address persistence (`~/.collider/config.yml`) from guided mode.\n\nFull history: [docs/CHANGELOG.md](docs/CHANGELOG.md).\n\n| Platform          | GPU backend            | Status        |\n| ----------------- | ---------------------- | ------------- |\n| Linux x64         | CUDA 12.x              | Supported     |\n| Windows x64       | CUDA 12.x              | Supported     |\n| macOS arm64       | Metal (M1, M2, M3, M4) | Supported     |\n| macOS x64 (Intel) | none                   | Not supported |\n\n---\n\n## Where to go from here\n\n| For                                         | See                                                                            |\n| ------------------------------------------- | ------------------------------------------------------------------------------ |\n| Install on a new machine                    | [docs/INSTALL.md](docs/INSTALL.md)                                             |\n| Build options, CMake flags, troubleshooting | [docs/INSTALL.md](docs/INSTALL.md), [docs/BUILD-MACOS.md](docs/BUILD-MACOS.md) |\n| `config.yml` schema and precedence          | [docs/CONFIGURATION.md](docs/CONFIGURATION.md)                                 |\n| Source tree map for contributors            | [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md)                                   |\n| Joining the pool, share accrual, etiquette  | [docs/POOL.md](docs/POOL.md)                                                   |\n| JLP wire protocol (third-party clients)     | [docs/JLP-PROTOCOL.md](docs/JLP-PROTOCOL.md)                                   |\n| GPU crypto correctness tests                | [docs/CRYPTO-VALIDATION.md](docs/CRYPTO-VALIDATION.md)                         |\n| Full release history                        | [docs/CHANGELOG.md](docs/CHANGELOG.md)                                         |\n\n---\n\n## License and community\n\nThe Free edition is **MIT-licensed**. See [LICENSE](LICENSE).\n\n`third_party/RCKangaroo/` is GPLv3-licensed (RetiredCoder, 2024). Builds that link RCKangaroo carry its license forward in the binary.\n\nThe Pro edition is a separate, license-gated build. Pro source is **not** MIT; binaries are delivered to paying customers at [collisionprotocol.com/pro](https://collisionprotocol.com/pro).\n\nIssues, bug reports, and feature requests:\n\n- Public (Free edition): [github.com/hevnsnt/collider/issues](https://github.com/hevnsnt/collider/issues)\n- Pool / protocol questions: see [github.com/hevnsnt/collision-protocol](https://github.com/hevnsnt/collision-protocol)\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fhevnsnt%2Fcollider","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fhevnsnt%2Fcollider","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fhevnsnt%2Fcollider/lists"}