{"id":117054,"date":"2026-09-11T01:36:37","date_gmt":"2026-09-11T01:36:37","guid":{"rendered":"https:\/\/youzum.net\/nvidia-details-bionemo-inference-runtime-bioir-2-90x-higher-boltz-2-folding-throughput-and-58-5k-residues-per-gpu-hour-on-8xh100\/"},"modified":"2026-09-11T01:36:37","modified_gmt":"2026-09-11T01:36:37","slug":"nvidia-details-bionemo-inference-runtime-bioir-2-90x-higher-boltz-2-folding-throughput-and-58-5k-residues-per-gpu-hour-on-8xh100","status":"publish","type":"post","link":"https:\/\/youzum.net\/de\/nvidia-details-bionemo-inference-runtime-bioir-2-90x-higher-boltz-2-folding-throughput-and-58-5k-residues-per-gpu-hour-on-8xh100\/","title":{"rendered":"NVIDIA Details BioNeMo Inference Runtime (BioIR): 2.90x Higher Boltz-2 Folding Throughput and 58.5K Residues per GPU-Hour on 8xH100"},"content":{"rendered":"

Biomolecular structure prediction has shifted from single-target runs to proteome-scale worklists. The bottleneck is no longer whether a model can fold a protein. It is how fast an entire queue of independent targets moves through parsing, featurization, GPU inference, and output writing. NVIDIA\u2019s new technical deep dive<\/a> walks through BioNeMo Inference Runtime<\/a> (BioIR), a Python library that accelerates supported structure-prediction models on NVIDIA GPUs while keeping the standard PyTorch workflow. BioIR has already run at production scale. It powered the recent expansion of the AlphaFold Database<\/a>, generating protein-complex structures across 4,777 proteomes, about 31 million candidate complexes, with 1.81 million released as high-confidence predictions.<\/p>\n

Is it deployable? Yes.<\/strong> BioIR is available now as an open GitHub repository<\/a> with a wheel containing precompiled CUBINs. Runtime use needs Python 3.12+, a compatible NVIDIA GPU and driver, a staged model checkpoint, and per-chain A3M MSAs. It does not require nvcc, CUDA source, CMake, or the CUDA toolkit.<\/p>\n

What is BioIR<\/strong><\/h2>\n

BioIR targets the operations that general-purpose inference stacks do not fully optimize. These include Pairformer and Evoformer stacks, triangle operations, pairwise attention, diffusion transformers, and atom-level modules. Models stay ordinary torch.nn.Module<\/code> objects. There is no engine build, export step, or separate artifact between a checkpoint and a forward pass.<\/p>\n

There are 2 ways to use it. The end-to-end processor moves an InputRequest<\/code> through parsing, tokenization, feature generation, GPU inference, and PDB or mmCIF writing. Direct PyTorch integration lets developers construct a supported model or reuse selected optimized modules inside custom code. The tutorial demonstrates the processor path with Boltz-2 (model_source=\"boltz-2\"<\/code>). 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.<\/p>\n

Three Layers of Acceleration<\/strong><\/h2>\n

BioIR optimizes at 3 distinct layers, each targeting a different bottleneck:<\/strong><\/p>\n

    \n
  1. Kernel selection<\/strong>: Supported operations pick compatible BioIR custom, cuEquivariance, or PyTorch fallback implementations based on model configuration, GPU, data type, and tensor shape.<\/li>\n
  2. Module optimization<\/strong>: A separate optimize()<\/code> mechanism enables CUDA Graph capture for compatible modules, cutting launch overhead.<\/li>\n
  3. Pipeline scaling<\/strong>: A Ray executor places 1 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.<\/li>\n<\/ol>\n

    Note: Ray does not split a single forward pass across GPUs. Replica mode scales worklists, not individual targets. Per the support matrix<\/a>, context-parallel folding is planned but not yet available. The capacity rule is simple: engine_stage.compute x num_gpus<\/code> must not exceed visible GPUs.<\/p>\n

    At the model-forward level, NVIDIA\u2019s early benchmarking reports geometric-mean speedups over an OSS torch.compile<\/code> baseline of 1.55x (OpenFold3), 1.78x (Boltz2), and 2.56x (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.<\/p>\n

    \n

    The Benchmark: 1,000 Human Dimers on 8xH100<\/strong><\/h2>\n<\/p>

    To quantify end-to-end delivery, 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.<\/p>\n

    The results:<\/strong><\/p>\n