NVIDIA has released BioNeMo Inference Runtime (BioIR), a Python library designed to accelerate protein structure prediction on its GPUs. The tool targets the specific bottleneck of running entire proteome-scale worklists rather than single protein targets. It powers the recent expansion of the AlphaFold Database, which generated structures for 4,777 proteomes, covering roughly 31 million candidate complexes. Of these, 1.81 million were released as high-confidence predictions.
BioIR is available now as an open GitHub repository. It requires Python 3.12 or later, a compatible NVIDIA GPU and driver, a staged model checkpoint, and per-chain A3M MSAs. The software does not require nvcc, CUDA source code, CMake, or the full CUDA toolkit.
What is BioIR
The library focuses on operations general-purpose inference stacks do not fully optimise. These include Pairformer and Evoformer stacks, triangle operations, pairwise attention, diffusion transformers, and atom-level modules. Models remain standard torch.nn.Module objects. There is no engine build or export step separating the checkpoint from the forward pass.
Users can interact with the system in two ways. The end-to-end processor moves an InputRequest through parsing, tokenization, feature generation, GPU inference, and file writing. Direct PyTorch integration allows developers to construct a supported model or reuse selected optimized modules within custom code. The tutorial demonstrates the processor path using Boltz-2 (model_source="boltz-2"). Each protein chain requires an A3M MSA. Paired or unpaired MSAs are accepted for inputs with multiple non-identical protein chains. 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 Layers of Acceleration
BioIR optimises at three distinct layers, each targeting a different bottleneck:
- Kernel selection: Supported operations pick compatible BioIR custom, cuEquivariance, or PyTorch fallback implementations 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 executor places one complete model replica on each visible GPU in a node and distributes independent inputs among them. CPU stages (parsing, featurization, writing) overlap with GPU folding.
Ray does not split a single forward pass across GPUs. Replica mode scales worklists, not individual targets. Context-parallel folding is planned but not yet available. The capacity rule is simple: engine_stage.compute x num_gpus must not exceed visible GPUs.
At the model-forward level, NVIDIA’s early benchmarking reports geometric-mean speedups over an OSS torch.compile baseline of 1.55x for OpenFold3, 1.78x for Boltz2, and 2.56x for OpenFold2 monomer on H100. H200 numbers are similar at 1.54x, 1.75x, and 2.61x. These were measured across 17 inputs spanning 29 to 1,734 residues.
The Benchmark: 1,000 Human Dimers on 8xH100
To quantify end-to-end delivery, the NVIDIA team ran a matched benchmark on 1,000 human dimer targets with combined sequence lengths below 2,800 residues. The comparison pitted BioIR-accelerated Boltz-2 against a torch-compiled open-source Boltz-2 implementation on 8xH100 80GB GPUs. Both used identical targets, staged MSAs, inference recipe (3 recycles, 200 sampling steps, 5 diffusion samples), and GPU configuration.
The results show:
- BioIR completed all 1,000 targets and delivered 58.5K successfully folded residues per allocated GPU-hour.
- The public implementation delivered 20.2K residues per GPU-hour and ran out of memory on 29 targets.
- Net result: a 2.90x improvement in residue-normalized throughput.
These numbers are folding-stage measurements specific to this dataset and hardware. They exclude MSA generation, preprocessing CPU allocations, storage, data transfer, and retries. The blog explicitly warns against generalizing them to all BioIR-supported models or datasets.
Energy at One Million Targets
Extrapolating the benchmark linearly to 1 million comparable targets, BioIR is estimated to need 11 MWh versus 35 MWh for the public implementation using 8-GPU TDP equivalents. Using full-node maximum-power equivalents, the estimate is 21 MWh versus 64 MWh. These are rated-power, folding-only estimates for IT equipment, not metered measurements, and exclude data center overhead such as PUE. Still, a 23 to 43 MWh saving per million targets is a material number for proteome-scale campaigns.
What it means
Researchers running large-scale analyses no longer need to choose between speed and ease of use. The tool integrates directly into standard PyTorch workflows, removing the need to compile custom code or manage complex build environments. The performance gains translate to tangible savings in compute time and electricity. For a million targets, the energy consumption drops significantly, allowing teams to process more data within existing budget constraints.
