A pure-Rust simulated-bifurcation solver: SIMD inner loop, deterministic runs, single static binary
2026-07-02 · the flagship standalone build, scoped honest
This is the v0 spec for the lead bet from the standalone-build shortlist: a native-Rust simulated-bifurcation (SB) solver for QUBO and Ising problems. Feed it a coupling matrix, get a near-optimal spin vector in milliseconds. No Python, no PyTorch, no cloud bill — a static binary and a clean crate API a stranger cargo adds. This page is scope, not marketing: what to build, in what order, and how it can honestly fail.
No fast, maintained, SIMD pure-Rust simulated-bifurcation QUBO/Ising solver exists — and the whole moat is the inner loop, a sparse matrix-vector product you SIMD and cache-block. Ship dense ballistic SB on G-set max-cut first, then sparse CSR + discrete SB + parallel tempering, all deterministic, as a single static binary with a real crate API no competitor offers. The bar: beat D-Wave neal on wall-clock at equal solution quality, match bqth29 on quality without its torch dependency.
Simulated bifurcation is an Ising machine in software: a symplectic-Euler integration over coupled nonlinear oscillators that relaxes to a near-optimal spin configuration. The core update per step is a matrix-vector product against the coupling matrix — sparse for most real problems — fully SIMD-able and cache-blockable. That inner loop is the entire product. It is a systems problem, not a math problem, which is exactly why a Rust/low-latency engineer owns it.
The gap is verified by absence (checked 2026-07-02):
| Tool | State | Why it leaves the slot open |
|---|---|---|
| sbm-rs | 2-star, ~1 commit, no releases, no SIMD | the only pure-Rust SB crate — effectively a toy, abandoned |
| qbsolv | dead — deprecated end-2021, archived Jan 2023 | the old "qbsolv competitor" line is stale; that slot is empty |
| bqth29 | the FOSS reference, but Python / PyTorch (CPU+GPU) | drags a torch dependency; the quality baseline to match without it |
| Toshiba SQBM+ | closed-source, cloud/AWS-billed; v2.2 (Jun 2026) hits 1 billion vars | commercial ceiling is rising, the open one is not |
std::simd / wide), cache-block the sparse traversal, thread it with rayon, and keep the RNG deterministic. Everything defensible lives in those four moves. No competitor ships them together in a Rust crate.
Build in a strict order so each layer is validated before the next lands on top of it.
std::simd or wide) on the MV-product inner loop; rayon for multithreading across replicas/blocks. Deterministic runs — a fixed seed reproduces the exact spin vector, so a quant can replay and verify. Ship a single static binary plus a clean crate API.
Native QUBO and Ising both, with a tested conversion between them (QUBO {0,1} ↔ Ising {-1,+1}). Sparse coupling matrices as first-class input — most real problems are sparse, and that is where the cache-blocking pays.
A single static binary + clean crate API is the thing no competitor offers. bqth29 makes you bring a Python/torch runtime; SQBM+ makes you bring a cloud account. A crate a quant embeds directly, with no toolchain and no bill, is the whole wedge.
The benchmark suite is a first-class artifact, not an afterthought. Without a credible parity table it reads as a toy. Two named incumbents, two axes:
| Against | Axis | Target |
|---|---|---|
| D-Wave neal (classical SA, Python) | wall-clock | Beat neal at equal solution quality — same optimality gap, less time |
| bqth29 (SB reference, Python/torch) | solution quality | Match bqth29 on the optimality gap — without a Python/PyTorch dependency |
Instances: standard Ising benchmarks — the G-set collection and MaxCut problems, where best-known cuts are published so the gap is measurable, not asserted.
The first users are a real tribe, not a solo hobby: the quant / DeFi crowd. Two textbook QUBO formulations put working problems in front of the solver immediately.
cargo add and gets an annealer on its own hardware — no cloud round-trip, no torch. (QUBO portfolio.)
An SB solver is an Ising machine in software — the same non-von-Neumann primitive Toshiba sells as SQBM+. That threads directly into the esoteric / non-von-Neumann computers line: annealers, oscillator networks, and physical Ising machines as a class of computer that isn't a CPU. This crate is the software instance of that class you can actually ship.
| Version | Scope | Proof |
|---|---|---|
| v0 | Dense ballistic SB (bSB), QUBO+Ising ingest, deterministic RNG, single static binary + crate API | Correct on G-set max-cut against published best-known cuts |
| v0.1 | Sparse CSR coupling, portable SIMD inner loop, rayon multithreading | Benchmark table: beat neal on wall-clock at equal quality on G-set / MaxCut |
| v0.2 | Discrete SB (dSB) + parallel tempering; hardened benchmark suite as a first-class artifact | Match bqth29 quality with no torch dep; optimality-gap table across the instance set |
The builder is also the most obvious customer — a quant building a tool for quants. That is a real conflict: it makes early validation easy but external adoption unproven. The bet only lands on one condition.
The solver has to prove its optimality gap holds against neal on real instances. Without that table it reads as a toy, however clean the code is. Ship the benchmark suite as a first-class artifact from v0.1, not an afterthought — the table is the product's credibility.