v0.6.3

[0.6.3] - 2026-08-17

Binding affinity runs on the card. Boltz-2's affinity model kept its 64-block trunk in
fp32 on the host CPU, which is why a single ligand took minutes and looked CPU-bound; it
now runs in fp32 on device, and FKBP12+SB3 at the default affinity protocol goes from
294 s to 206 s per ligand on one Blackhole p150a.

Large targets fit a 12 GiB card. Every structure model folds targets up to at least 1095
residues on a single Wormhole chip, OpenDDE included, by switching the pair track to
row-blocked execution above a size threshold smaller targets never reach. Their speed and
numerics are unchanged.

--trace no longer returns wrong structures. One process folding several same-size
Protenix-v2 or OpenDDE targets replayed the first target's conditioning for all of them.

Added

• Targets up to at least 1095 residues fold on a single 12 GiB Wormhole card, on every
  structure model. The pair track row-blocks above a size threshold; below it nothing
  changes. See docs/large-targets.md.

Changed

• Boltz-2 binding affinity runs entirely on the card. The affinity model's 64-block
  trunk used to run in fp32 on the host CPU by default, which made a single ligand
  take minutes and look like a CPU bottleneck; it now runs in fp32 on device.
  A whole tt-bio predict on FKBP12+SB3 at the default affinity protocol drops from
  294 s to 206 s per ligand, 1.43x, on one Blackhole p150a. Three timed reps per arm,
  0.6.2 installed from its released PyPI wheel and 0.6.3 from this release's wheel, same
  card and same input; the arms do not overlap. All six committed affinity parity legs
  keep their committed verdicts. BOLTZ2_AFFINITY_TRUNK_FP32_HOST and
  BOLTZ2_AFFINITY_TRUNK_FP32_DEVICE are removed; the fp32 affinity trunk is no
  longer configurable, because a lower precision there shifts the predicted
  log10(IC50).
• RFdiffusion3 ships both fused bias kernels on by default (881704d2). The sparse
  attention bias is built in one pass instead of a poke walk (5.83x at the op,
  703d12a1) and the whole score+bias chain is one kernel (4.42x at the op,
  923a9396); both learned multiplicity batching, worth 6.26x at batch 2
  (fa7246da). Every step is bit-exact: the fold A/B legs land byte-identical
  designs at +12.36 %, +5.10 %, +6.83 % and +4.65 % on ms/step (583961c4,
  ee4a8980, 64a14e68, 599d81ff). The published throughput table in
  docs/rfd3-design.md was regenerated with them on (5123065e).
• Triangle attention runs the q-split at or below 1024 padded tokens and gates it
  off above (063f89db).
• Three paths ship off on purpose, each behind one environment variable.
  BOLTZ2_TOKEN_DIT_SDPA=1 runs Boltz-2's token-DiT attention as a fused SDPA; it is
  faster and it is not bit-exact, because the exponentiated scores go through a bf16
  buffer. TT_PROTENIX_CONF_DEVICE=1 keeps Protenix-v2's confidence head on the card;
  it correlates 0.98071 against a 0.99 floor, which is why it is not the default.
  OPENDDE_DIFFUSION_FP32=1 lifts the bf16 pin on OpenDDE's diffusion for an A/B. Every
  other lever in this release is on by default.

Fixed

• OpenDDE folded with a corrupt pair track, and no host-side check could see it. The
  pair-init bias was uploaded flat and reshaped at the end, which splits a tiled
  tensor's row axis whenever the token count is not a multiple of 32. The tensor reads
  back through ttnn.to_torch bit-exact and is wrong only as an operand of the next op,
  so the reference comparisons all passed while the fold's pair track was wrong.
  Introduced by 6c3f5eca on 2026-08-08, the day after 0.6.2 was cut, and fixed by
  1ea1e6f3 before this release: no released version ever shipped it.
• --trace with Protenix-v2 or OpenDDE silently returned wrong structures for every
  target after the first when one process folded several targets of the same size: the
  captured trace was keyed on shape alone and replayed the first target's conditioning.
  The trace is now re-captured when the conditioning changes. Regression gate:
  scripts/trace_multitarget_parity.py (two same-size targets, one process, trace on
  vs off, byte-identical CIFs required). Boltz-2 and BoltzGen were not affected: their
  predict path resets the trace cache between targets.
• Protenix-v2 crashed on targets between 385 and 506 residues: the h=1.5 normed pair
  tensor was held past its last use (142e0109). ESMFold2 hit the same class at large
  targets and now frees the pair-conditioning intermediates rather than row-tiling them
  (08565983). OpenDDE uploads z_struct as one allocation into an intact hole
  (28a91107) and frees the expander's row chunks after the loop (d2ad024b).
• A clean pip install was missing kernel sources: the wheel and sdist now ship every
  file under tt_bio/kernels/ through recursive globs, so a new kernel directory cannot
  drop out again (cb3ef828, baa6ad0a).
• On a tt-metal built from source, tt-bio could not find the fabric mesh-graph
  descriptor (ee73d9a4) or the generic_op kernel sources (e2fb610a), so a lone
  Blackhole P300 chip would not open and the fused kernels would not build.
• A worker that died of an uncaught exception reported silence (a5921d2d), and a
  process holding a card could outlive whoever spawned it (3bd84f04, 26a8c085).
• Protenix-v2 falls back to ttnn's own matmul planner when a tuned config clashes
  instead of failing the fold (5a207fee).

Performance

• OpenFold3 at 512 residues: 51.19 -> 44.535 s on one Blackhole p150a, from running
  TriangleAttention's fp32-softmax tail height-sharded in L1 rather than
  DRAM-interleaved. Bit-exact — the same CIF digest (da9b4ed68f8c0405) and plDDT as the
  control arm, and it holds at 768 and 1024 aa (abbf42ba, d0589dca; four warm folds
  on main in perf/of3x3/ab_512_postmerge_qb2c3.json, spread 0.126 s).
• The trimul output tail's two projections and its gate are one kernel: -679.47 ms on
  the trimul body wall at 512 aa, byte-identical (747e1b75, re-verified on main
  0febf057).
• BoltzGen skips the template round trip when the input carries no template, worth 8.8 %
  (4d07b39e).
• ESMFold2's pair-FFN row blocking extends to 1024 residues: -3.858 s (1.0242x) at
  1024 aa, bit-exact (ca9b6703).
• End to end, from the release wheel against 0.6.2's released wheel on the same card and
  the same input: ESMFold2 at 512 residues single-sequence goes 233.5 -> 197.5 s
  (1.18x), and Boltz-2 affinity on FKBP12+SB3 goes 294 -> 206 s (1.43x). Both are three
  timed reps per arm on one Blackhole p150a with the arms interleaved.
• Boltz-2's diffusion hoists the per-step attention bias slices out of the step loop and
  memoises the AdaLN s terms, both on by default and both bit-exact: 24.822 -> 23.504 s
  at 512 residues (bae4d627, 6c07446f, 6ce62967).