Nvidia releases BioIR: 2.9× throughput on Boltz-2, 58.5k residues per GPU-hour on 8×H100

Biomolecular structure prediction has shifted from single-protein jobs to proteome-scale runs, and the bottleneck is no longer folding one protein but the rate at which an entire queue of independent targets moves through parsing, featurization, GPU inference and output writing. Nvidia this week published a technical deep-dive on BioNeMo Inference Runtime (BioIR), a Python library that accelerates supported structure-prediction models on its GPUs while preserving a standard PyTorch workflow. The tool is already proven in production: it powered the latest AlphaFold Database expansion, which generated complex structures across 4,777 proteomes — roughly 31 million candidate complexes — of which 1.81 million high-confidence predictions were released.

Available now, no CUDA Toolkit required

BioIR is live as an open GitHub repository with a wheel containing pre-compiled CUBINs. Runtime requirements are Python 3.12+, a compatible Nvidia GPU with a matching driver, a staged model checkpoint, and an A3M-format MSA for each chain. Notably absent: nvcc, CUDA source, CMake, or the full CUDA Toolkit — a meaningful simplification for labs that want to run without managing a complex build environment.

Two usage paths, one model stays a torch.nn.Module

The library offers two routes: an end-to-end processor that takes an InputRequest through parsing, tokenization, feature generation, GPU inference, and PDB or mmCIF writing; and a direct PyTorch integration that lets users construct a supported model or plug selected accelerated modules into custom code. Models remain ordinary torch.nn.Module objects — no engine-build step, no export, no separate artifact between checkpoint and forward pass. The guide demonstrates the processor path with Boltz-2 (model_source="boltz-2"). Every protein chain requires an A3M MSA; paired or unpaired MSAs are accepted for multi-chain non-identical inputs. Templates can be supplied manually because BioIR does not run HHsearch or HMMsearch. The processor supports ligand structure prediction but not ligand affinity prediction.

Three acceleration layers, and what is still missing

BioIR optimizes at three distinct layers, each targeting a different bottleneck. Kernel selection: supported ops choose between BioIR-tuned implementations, cuEquivariance, or a PyTorch fallback based on model configuration, GPU, data type and tensor shape. Module optimization: a separate optimize mechanism enables CUDA Graph capture for compatible modules, cutting launch overhead. Pipeline scaling: a Ray runner places one full model replica on every visible GPU in the node and distributes independent inputs among them; CPU stages (parsing, featurization, writing) overlap with GPU inference. Critically, Ray does not split a single forward pass across multiple GPUs — replica mode increases worklist throughput, not single-target speed. According to the support matrix, context-parallel folding is planned but not yet available. The capacity rule is simple: engine_stage.compute multiplied by num_gpus must not exceed the number of visible GPUs.

Model-level benchmarks: up to 2.6× over torch.compile

At the model forward-pass level, Nvidia's early benchmarks report geometric-mean speedups versus an OSS torch.compile baseline: 1.55× on OpenFold3, 1.78× on Boltz2, and 2.56× on OpenFold2 monomer, all on H100. H200 numbers are similar: 1.54×, 1.75× and 2.61× respectively. Measurements used 17 inputs ranging from 29 to 1,734 residues.

End-to-end benchmark: 1,000 human dimers on 8×H100

To quantify end-to-end delivery, the team ran a matched benchmark on 1,000 human dimer targets with combined sequence length under 2,800 residues. The comparison pitted BioIR-accelerated Boltz-2 against an open Boltz-2 implementation compiled with torch on 8 H100 80 GB GPUs. Both sides used the same targets, pre-prepared MSAs, identical inference recipe (3 recycling cycles, 200 sampling steps, 5 diffusion samples) and identical GPU configuration. Result: 2.90× higher folding throughput and a rate of 58.5 thousand residues per GPU-hour — a figure that makes full-proteome runs practical within reasonable turnaround times.