Standalone systems artifacts that earn the bio-computing job — orthogonal technologies, not AI-agent glue
2026-06-27 · verdicts rechecked 2026-07-02 · for a Rust/low-latency engineer choosing a build that doubles as a hire signal
Ship one self-contained Rust artifact a stranger cargo adds and uses on day one, where the SIMD/cache/determinism work is the whole product and no biology or co-builder is required. That is what you put on the table when Ginkgo, Asimov, or Arc asks "show me systems work." This page ranks those artifacts, names the gap each fills, and ends with the lower-risk opening move: contribute to noodles first.
Build a Rust simulated-bifurcation QUBO/Ising solver — no focused SIMD Rust QUBO solver exists (the only pure-Rust crate, sbm-rs, is a 2-star toy; qbsolv is dead; Toshiba SQBM+ is closed and now scales to 1B variables), the inner loop is a sparse matrix-vector product you SIMD and cache-block, and the day-one users are your own tribe: quant desks doing portfolio-under-cardinality and DEX arb-cycle detection. Two runner-ups shifted on 2026-07-02: the sparse-solver gap is narrowing (faer now ships pure-Rust Cholesky + pivoted LU) and bgzf-turbo is mostly closed (noodles shipped multithreaded reader and writer). Contribute to noodles first to bank credibility while the solver lands.
In: self-contained Rust artifacts (a solver, codec, or perf crate) where low-latency/SIMD/cache work is the moat and no biology or domain knowledge is required to be the first user. Out: anything user-coupled (query engines glued onto DataFusion, ML-pipeline feature extractors), anything co-built (FEM, P-systems), and anything that is AI-agent orchestration glue. A research-loop / DBTL-orchestrator runtime and an interaction-net runtime are both off the table: the first needs co-builders and reads as agent glue, the second has near-zero standalone users.
cargo add, feeds it a matrix or an array, gets a result. The competition is a C library or a slow Python port; you win on speed and a no-C-toolchain build.
| # | Artifact | The gap (one line) | Who, day one | Scope | Already done by |
|---|---|---|---|---|---|
| 1 | Rust SB/QUBO-Ising solver (simulated bifurcation) ✓ gap real · 2026-07-02 | Only pure-Rust crate is a 2-star toy (sbm-rs); FOSS reference is torch-bound Python; prod paywalled Toshiba, now 1B vars; qbsolv dead | Quant desks (portfolio under cardinality, DEX arb cycles), logistics, max-cut | weekend→month | sbm-rs (toy), bqth29 (Python/torch), Toshiba SQBM+ (closed) |
| 2 | Error-bounded float compressor (zfp/SZ3-class) ✓ gap real · 2026-07-02 | Only C FFI (zfp-sys) exists; native Rust is lossless-only (pco), no spatial error-bounded zfp/SZ3-class codec, no no_std/WASM path | Anyone writing sci arrays to disk/object-store; zarrs/Blosc users wanting no C toolchain | weekend→month | SZ3, zfp — C/C++; zfp-sys (FFI only) |
| 3 | Pure-Rust sparse DIRECT solver (Cholesky/LDLᵀ → LU) ● narrowing · 2026-07-02 | faer now ships pure-Rust LLT/LDLT/Bunch-Kaufman + pivoted LU; remaining gap is supernodal, CHOLMOD-beating, ordering-quality perf | Clarabel, diffsol, every FEM crate, quant KKT/covariance solves | month→quarter | faer (basics shipped), SuiteSparse (C); CHOLMOD-parity still open |
| 4 | bgzf-turbo (block-parallel BGZF decoder + seek index) ✗ mostly closed · 2026-07-02 | noodles v0.47 now ships MultithreadedReader and MultithreadedWriter; only a throughput-win reframe (libdeflate/ISA-L, SIMD CRC) survives | Every Rust genomics tool is DEFLATE-bound; oxbow drop-in win | weekend→month | noodles (multithreaded R/W shipped), gzp, htslib (C) |
| 5 | Deterministic fixed-point DSP kernels (Q-format biquad/FIR/CIC/CORDIC/FFT) | No general bit-exact fixed-point Rust DSP suite; idsp deliberately narrow | Embedded/audio/SDR as CMSIS-DSP replacement; determinism = HFT replay | month | idsp narrow, CMSIS-DSP (C) |
Feed it a QUBO or Ising matrix, get a near-optimal spin vector in milliseconds. The core is a ballistic/discrete simulated-bifurcation update (symplectic-Euler over coupled nonlinear oscillators), and the inner loop is a sparse matrix-vector product per step, fully SIMD-able and cache-blockable. An Ising machine in software: the same primitive Toshiba sells as SQBM+ behind a paywall.
The FOSS reference is bqth29, a torch-bound Python implementation; the production tool is Toshiba SQBM+, paywalled and cloud-billed — its v2.2 (June 2026) scales to 1 billion variables, so the commercial ceiling is rising, not the open one. The only pure-Rust crate, sbm-rs, is a 2-star, single-commit toy with no SIMD. There is no focused SIMD Rust QUBO solver. The deterministic-RNG, cache-blocked MV-product inner loop is the entire product: a systems problem, not a math problem.
A native Rust crate with zero torch dependency and zero cloud bill that a quant embeds directly. The gap is verified by absence (checked 2026-07-02): bqth29 is Python, SQBM+ is closed, sbm-rs is abandoned toy-tier, and qbsolv is dead (deprecated end-2021, archived Jan 2023) so that slot is now empty too. The FOSS baseline to beat is neal on speed and bqth29 on quality — nothing in between exists.
The day-one users are your own peers. Portfolio optimization under a cardinality constraint and DEX arbitrage-cycle detection are both textbook QUBO formulations (FX arbitrage via simulated bifurcation, QUBO portfolio). No co-building, no glue. A quant desk runs cargo add and gets an annealer on its own hardware.
Dense bSB solving G-set max-cut, then sparse CSR, parallel tempering, a QUBO builder, and a benchmark suite versus neal and bqth29. The benchmark carries the page: a table showing the optimality gap holding against neal on real instances at a fraction of the wall-clock. Full scope, milestones, and honest risk: the v0 build spec.
What it is. Error-bounded lossy compression for f32/f64 N-D arrays: zfp-style block transform and/or SZ-style predict+quantize, take an abs/rel/PSNR bound, emit a stream that decompresses within it.
Open gap. The HPC sci-data world runs on C zfp/SZ3 and Rust has only FFI (zfp-sys, cmake+bindgen to LLNL's C). The native-Rust crate that exists, pco, is lossless-only for 1-D sequences — no spatial, multidimensional error bound. A no_std/WASM-capable, error-bounded crate with no C build dependency is worth real time to any zarrs or embedded-sensor user.
Why standalone. Anyone writing scientific arrays to disk or object-store uses it day one; no biology, no co-builder.
v0. Fixed-rate zfp-style block codec for f32 with a ratio + GB/s benchmark vs zfp on SDRBench corpora, then error-bounded modes, f64, AVX2/NEON, a Zarr v3/Blosc2 codec shim.
Risk. The algorithms are nontrivial and parity benchmarking is mandatory; without a credible table vs zfp it looks like a toy.
What it is. A supernodal sparse Cholesky with AMD/METIS fill-reducing ordering, symbolic+numeric split, refactor-same-pattern: the factorization every IPM, FEM, and GP calls in its inner loop.
Gap narrowing. The prior "no production Rust" framing is now too strong. faer (v0.17.x) ships pure-Rust sparse LLT, LDLT, Bunch-Kaufman and sparse LU with row/full pivoting — a real maintained sparse direct solver exists. The remaining gap is narrower: no published evidence any Rust solver matches CHOLMOD/PARDISO on large ill-conditioned systems with supernodal BLAS-3 kernels and METIS/nested-dissection ordering. The June 2026 eval benchmarks faer's iterative kernels (SpMV, Lanczos), leaving direct-factorization perf vs CHOLMOD unmeasured.
Why standalone. Clarabel, diffsol, every FEM crate, every quant KKT/covariance solve depend on it; nobody co-builds, they call factor()/solve().
v0. Don't rebuild faer's basic factorization — beat it (and CHOLMOD) on the supernodal SPD Cholesky with METIS ordering and BLAS-3 supernode kernels, thread-safe and permissively licensed. Publish the missing benchmark: faer/rsparse/yours vs CHOLMOD + PARDISO on the SuiteSparse collection — that benchmark is itself a gap.
Risk. The floor moved: faer already covers the weekend "LDLáµ works" milestone, so the bar is now supernodal CHOLMOD-parity from day one. Getting METIS ordering and supernode detection right is the hard, unglamorous core.
What it is. rapidgzip but BGZF-native and pure Rust: thread-pool over independent blocks, SIMD/libdeflate-class inner DEFLATE loop, seekable virtual-offset index, cold-file boundary discovery.
Gap mostly closed. Since the June shortlist, noodles-bgzf (v0.47, ~June 2026) ships both a MultithreadedReader and a MultithreadedWriter; the original parallel-compression request (issue #17, 2021) reads as resolved. gzp already does multi-threaded BGZF too. "Parallel BGZF doesn't exist in Rust" is no longer true.
Why it survives only reframed. A standalone crate is now redundant unless it wins a specific axis: beat noodles/gzp/htslib on throughput via a libdeflate/ISA-L backend, better block scheduling, or SIMD CRC — a "fastest BGZF codec" bet, not a "parallel BGZF exists" bet. Better yet, contribute that perf into noodles.
v0. If pursued: a throughput benchmark beating noodles' MultithreadedReader with an ISA-L/libdeflate inner loop. The multithreading is done for you; the only defensible moat left is the inner-loop codec.
Risk. The core premise expired. Ship this only as a throughput win over an already-parallel incumbent, or fold the effort into noodles as a perf PR.
What it is. A no_std bit-exact fixed-point DSP crate — Q-format biquad cascades, FIR, CIC/half-band decimators, NCO/CORDIC, fixed-point FFT — reproducible across platforms, no float nondeterminism.
Open gap. No general bit-exact fixed-point Rust DSP suite; idsp is deliberately narrow.
Why standalone. Embedded/audio/SDR engineers use it day one as a CMSIS-DSP replacement, and determinism matters for HFT replay and verification. Rust already benched 1.8× over CMSIS-DSP, so the perf case is proven; the library is just missing.
v0. Biquad/FIR/decimator/CORDIC core with cycle-count benchmarks vs CMSIS-DSP.
Risk. Lower prestige than a solver, and idsp covers the biquad slice. The bet is that a general deterministic suite is worth more than its parts.
The lower-risk opening move is to land a real PR in a known Rust genomics library before (or alongside) building your own. Faster proof, a public commit history, and a foot in the exact ecosystem the target employers staff. noodles is the canonical pure-Rust bioinformatics I/O stack and the right target.
| Order | Contribution | Why | Carries into |
|---|---|---|---|
| 1st | noodles PR #296 — async indexed reader | Scoped, self-contained, lands credibility fast; an async indexed reader is plumbing you can finish cleanly | warms you to the codebase before the harder parallel work |
| 2nd | noodles-bgzf perf PR — faster codec, not parallel plumbing | Parallel BGZF already shipped (MultithreadedReader + Writer, v0.47), so the open lane is a throughput win: libdeflate/ISA-L backend or SIMD CRC on top of the existing thread pool | seeds the reframed bgzf-turbo throughput bet |
| avoid | noodles #374 — CRAM | CRAM is a deep, slow, format-spec grind — high effort, low signal-per-hour for breaking in | — |
Where a Rust systems dev has leverage, and where the gaps actually are — the ecosystem is real but bottom-heavy:
| Target | State | Move |
|---|---|---|
| noodles (711★, very active), rust-bio (1807★), rust-htslib, needletail | healthy, clear systems work | parsers, indexing, parallel I/O, SIMD hot loops — the safe contribution surface |
| sage (proteomics search) | fast, active | fragment-index memory layout, SIMD scoring — a low-latency profile |
| nanopore POD5 | open gap — only incomplete crates (pod5-rs, podders) | a mature pure-Rust POD5 crate is greenfield and matters |
| cryo-EM MRC + compute pipelines | open gap | format + parallel-pipeline work with no strong Rust incumbent |
| mmCIF / mzML / VEP-class | NOT gaps anymore | crates exist (pdbtbx, mzdata); fastVEP (2026, 130×) closed the VEP lane — compete/contribute, don't greenfield |
The employers in frame — Ginkgo (autonomous-lab scheduling and drivers), Asimov (modeling, simulation, platform SWE), Arc (virtual-cell infrastructure), plus Isomorphic and Insitro — hire on demonstrated systems work, not on a biology resume you don't have. A merged noodles PR plus a benchmarked solo crate is that evidence, legible to a hiring manager in five minutes.
Contribute first (noodles #296, then a bgzf throughput PR), build the QUBO/Ising solver as the flagship — the one gap the 2026-07-02 recheck left fully open. The sparse-solver bet is now supernodal-CHOLMOD-parity or nothing, and parallel BGZF already shipped. One body of work, still three hire signals.