NVIDIA 开源 RFD4-Proteina 简化蛋白质设计流程

Back to Articles

Protein Design with RFD4-Proteina and Hugging Face Spaces

Community Article Published October 21, 2026 Upvote 1

Kyle Gion kyle-gion nvidia Kieran Didi kierandidi nvidia Kyle Tretina AllThingsApx nvidia Christian sacdallago nvidia

Define the design task, generate proteins, and build a repeatable design workflow.

Protein design starts with setting a goal: a target to bind, a molecule to recognize, or an arrangement of atoms to preserve. Turning that goal into a design has usually meant splitting up the workflow across models that each handle one modality or one stage and reassembling the pieces afterward. Information is lost at every handoff.

RFD4-Proteina is a BioNeMo open model for programmable protein design, co-developed by NVIDIA and the University of Washington's Institute for Protein Design. It brings protein sequence and all-atom structure generation into one model, reducing the handoffs between separate backbone, sequence, and all-atom structure design models. It can generate proteins in molecular contexts that include other proteins, small molecules, nucleic acids, glycans, metal ions, and modified amino acids (e.g., a phosphorylated residue on a target protein).

RFD4-Proteina pairs a flow-matching model with an autoencoder. The autoencoder represents each standard or modified amino acid, sugar, DNA, or RNA nucleotide as an anchor-atom coordinate (for amino acids, the alpha carbon) and a learned latent vector encoding its chemical identity and local geometry. The flow model generates anchor coordinates and latent vectors together, and the decoder expands them into all-atom 3D structures and sequences. This lets the model generate sequences and structures together around a supplied constraint: the target a binder must engage, or the catalytic motif a protein must contain.

You can run the model in your browser before installing anything, in either of two Hugging Face Spaces: the dedicated RFD4-Proteina Space, which runs on dedicated GPUs, and the ZeroGPU Space, which runs on shared capacity. Start with a supplied example, inspect a target and its generated designs, and save the input and output for further work.

From October 21 to November 4, 2026, NVIDIA is sponsoring free access to the dedicated RFD4-Proteina Space, which runs on NVIDIA RTX PRO 6000 GPUs. Try it on your own design problems, including the protein design competition sponsored by Anthropic and Adaptyv.

Try RFD4-Proteina • Explore the RFD4-Proteina model

Figure 1. Inspect the annotated design input

The built-in PD-L1 example shows the target and its design annotations before generation. The expandable binder segment is part of the input specification.

Design a protein in the browser

Open the dedicated RFD4-Proteina Space and choose a supplied example. Both Spaces run AtomWorks Studio, a browser-based viewer and annotation editor for molecular inputs that also runs standalone.

Every design starts from a design context: at minimum, a protein structure (the target) you want to design binders against, a region where the binder should bind, and the specific residues or atoms you want the design process to engage. Those engagement points are called hotspots, and they are marked on the target atoms themselves.

With the context defined, generate a single design using the example's default settings. The design appears in the interactive viewer when generation finishes. Locate the designed protein and supplied target and check that the designed protein contacts the marked target hotspots.

You can also download the generated designs, the annotated target, and their complexes in CIF file format. This will let you compare this first design against the runs you will do next.

Note the seed number that was used. This gives you a baseline for the comparison below.

Figure 2. PD-L1 target and generated binder

The target is teal, and the three conditioned hotspot residues are highlighted in light green. Generated from the model-repository example input: one sample using medium thinking. This is a computational result; experimental validation would be needed to confirm binding.

With one design in hand, change the generation settings to learn how each affects the resulting designs. Start with the seed: holding the input and everything else fixed, a new seed generates a different sample from the same design space, and those binders will usually look quite different from your first set. From there, try the other generation settings, such as the thinking setting (see the next section to learn more).

Download the generated binders, the annotated target, and the binder-target complexes to validate designs in silico with your own tools. The files are annotated CIFs that carry the design context with them, so you can reload everything in a later session. From there you can predict developability properties from the generated sequence or structure, such as thermal stability or aggregation potential, to decide which designs are worth experimental characterization.

After the sponsored window closes on November 4, 2026, the dedicated Space stops being free, but the ZeroGPU Space remains free to use. It runs the same interface on shared capacity, subject to Hugging Face account quotas.

Choose a thinking setting

RFD4-Proteina introduces a thinking setting for protein design, similar to how LLMs can refine their answers. The thinking setting (low, medium [default], high) determines how much the model refines each design while generating it. Additional refinement increases the likelihood of high-quality designs that pass in silico filters, but also increases the compute required per design.

Measured design efficiency

In a design benchmark across 24 protein-binding targets, RFD4-Proteina at high thinking produced 76.40 structurally distinct designs per GPU-hour that met the defined computational criteria*, compared with 13.24 for Proteina-Complexa, the second-strongest method in the benchmark.

*Structure prediction model refold: binder pTM ≥ 0.80, minimum interface PAE ≤ 1.5 Å, target-aligned binder backbone RMSD ≤ 2.5 Å

Searching across trajectories

Beyond refining a single design, the model can reason across multiple designs during generation: comparing designs against computational criteria, ranking and filtering them, and generating new designs based on the ones that pass the criteria.

Reward-guided search is a separate option in the generation workflow. It scores designs with external evaluators, such as a structure prediction model or a physics-based energy calculator, to guide exploration toward properties you define: interface area, hydrogen bonding, or ligand binding energy. Check the documentation for the generation settings supported by your workflow.

Continue in Python and larger workflows

For programmatic generation, begin with the quickstart. It provides installation steps, a pinned checkpoint, annotated inputs, and generation commands. The documented runtime requires Linux x86_64, Python 3.12, a supported NVIDIA GPU, and a CUDA 13-compatible driver. Check yours with nvidia-smi before installing: both routes below are CUDA 13 builds, and they install cleanly on a CUDA 12 driver before failing on the first GPU call. The project also ships a CUDA 12 build, which pairs the all-cuda12 extra with a cu126 PyTorch; see the documentation for the native and container instructions.

Use the PD-L1 code example to continue with the same type of task. Keep the original annotated conditioning input and follow the instructions for your chosen implementation; native model bundles and Diffusers-format checkpoints are laid out differently.

Record the input, the model and software revisions, the seed, the sampling settings, and the hardware alongside each result. Generation is stochastic, and without those five things a promising design can be hard to reproduce.

The PD-L1 code example

Everything below starts from an annotated CIF and runs the same PD-L1 binder task. The design task is specified in the CIF file, so the command line, native Python, and the Diffusers library all consume the same annotated input, though they expose different sampling controls and can produce different designs.

Install, and get the input

Clone the repository for the full workflow:

git clone https://github.com/RosettaCommons/RFD4-Proteina.git
cd RFD4-Proteina
make setup
source .venv/bin/activate

make setup asks which structure-prediction environments to build. To skip those questions, run bash setup.sh --skip-search-envs instead; the make target passes no arguments through. Either way, setup prints an export DATA_PATH=... line at the end that you will need.

Or pip install the package into your own environment, which needs Python 3.12 already installed:

python3.12 -m venv .venv && source .venv/bin/activate
pip install "rfd4-proteina[all-cuda13]"

Run everything below from one working directory with that environment active. Save the annotated CIF exported from the Space there as pdl1_studio.cif, or download the same PD-L1 input from the model repository:

hf download nvidia/RFD4-Proteina --revision a06e2509c7033b010fc43614e9fd840303588502 \
    --local-dir ./rfd4-examples examples/protein_binder/input.cif
cp rfd4-examples/examples/protein_binder/input.cif pdl1_studio.cif

Steer binder designs toward structural diversity

Secondary-structure conditioning can increase the structural diversity of generated designs. Without it, you can generate a binder that is a copy of your target, because protein-protein interfaces in the PDB are dominated by homodimers.

Specifying alpha-helical segments ("islands") in the binder steers the model toward helical protein designs, which express and fold reliably and are the usual starting point for therapeutic campaigns. The example below sets one helical island and one beta-sheet island, so you can see both.

Secondary structure is set per residue, so the binder needs concrete residues before you can place islands on it. The example input carries chain B as an expandable 50–120 segment, so the code materializes one length first. That fixes the binder in pdl1_islands.cif at 56 residues; keep pdl1_studio.cif if you want to sample other lengths. For your own Space export, check the binder's chain ID and residue numbering before reusing these ranges.

import numpy as np
from atomworks.io import parse
from atomworks.ml.utils.expandable_segment import realize_expandable_segments
from atomworks.io.utils.atom_array_plus import as_atom_array_plus
from atomworks.io.utils.io_utils import to_cif_file
from rfproteina.conditions import C_SEC, SSEnum
from rfproteina.utils.parse_presets import ANNOTATED_CIF

aa = as_atom_array_plus(parse("pdl1_studio.cif", config=ANNOTATED_CIF)["assemblies"]["1"][0])

aa = realize_expandable_segments(aa, rng=np.random.default_rng(42))

helix_island_res_mask = (aa.chain_id == "B") & np.isin(aa.res_id, range(10, 30))
sheet_island_res_mask = (aa.chain_id == "B") & np.isin(aa.res_id, range(45, 55))

assert helix_island_res_mask.any(), "Helix selection matched no atoms"
assert sheet_island_res_mask.any(), "Sheet selection matched no atoms"

ss = C_SEC.annotation(aa, default="generate").copy()
ss[helix_island_res_mask] = SSEnum.HELIX
ss[sheet_island_res_mask] = SSEnum.SHEET
C_SEC.set_annotation(aa, ss.astype(int))

to_cif_file(aa, "pdl1_islands.cif", save_standard_annotations=True, chain_disambiguation="chain_iid")

Alternatively, use the Hugging Face Space or AtomWorks Studio to load the CIF file and annotate it, or upload the annotated CIF to visualize your annotations.

Three ways to run the same task

All three use pdl1_islands.cif and the same annotated input.

From the command line

rfd4-generate inputs=pdl1_islands.cif num_replicates=4 out_dir=./runs/pdl1-cli \
    seed=42 recycle_strategy=thinking_high '~metrics' compile_lengths=null

From Python

The same install exposes the model to your own code. run_generation takes the config the command line would have built, so you can run it from a script or inside a larger pipeline.

from hydra import compose, initialize_config_dir
import rootutils
import rfproteina
from rfd4_proteina import Proteina
from rfproteina.generate import run_generation

model = Proteina.from_pretrained("nvidia/RFD4-Proteina", device="cuda")
config_dir = rootutils.find_root(rfproteina.__file__, indicator=".project-root") / "configs"
with initialize_config_dir(config_dir=str(config_dir), version_base="1.3"):
    cfg = compose(config_name="inference", overrides=[
        "inputs=pdl1_islands.cif", "out_dir=runs/pdl1-python", "num_replicates=4", "seed=42",
        "recycle_strategy=thinking_high", "~metrics", "compile_lengths=null",
    ])
run_generation(cfg, model=model)

Designs are written under runs/pdl1-cli/inference_samples/ and runs/pdl1-python/inference_samples/, one folder per replicate (pdl1_islands_rep0, pdl1_islands_rep1, and so on). Use a fresh output directory whenever you change settings: designs that already exist are skipped by default. Metrics are switched off here with ~metrics; scoring is a separate step, run with rfd4-evaluate. Pass revision="<commit>" to from_pretrained, or hf_ckpt_revision=<commit> on the command line, to pin a specific checkpoint.

With Diffusers

If you already work in the Diffusers library ecosystem, RFD4-Proteina is a supported model there. Diffusers support ships in the next release; until then, install Diffusers from git. The repository's .venv is built with uv and carries no pip, so use uv pip install there and pip install in your own environment.

pip install \
    git+https://github.com/huggingface/diffusers@537887041938fc6fe61ad583c3ae77477c9ebac9 \
    git+https://huggingface.co/nvidia/RFD4-Proteina-prep@c9959efdebd75ac7fe9129fbbf0e291a6e0487d5 \
    accelerate

pip install diffusers git+https://huggingface.co/nvidia/RFD4-Proteina-prep@c9959efdebd75ac7fe9129fbbf0e291a6e0487d5

import torch
from diffusers import RFD4ProteinaPipeline
from rfd4_proteina_prep import prepare_cif, write_cif

pipe = RFD4ProteinaPipeline.from_pretrained(
    "nvidia/RFD4-Proteina-Diffusers", dtype=torch.bfloat16
).to("cuda")
features, atoms = prepare_cif("pdl1_islands.cif", seed=42, device=pipe.device)

num_designs = 4
batch = {k: v.repeat(num_designs, *[1] * (v.ndim - 1)) for k, v in features.items()}

named = ["padding_mask", "is_in_context_conditioning", "supports_local_latent",
         "token_type", "atom37_mask", "coords_nm"]
output = pipe(
    **{k: batch[k] for k in named},
    conditioning_features={k: v for k, v in batch.items() if k not in named},
    generator=[torch.Generator("cuda").manual_seed(s) for s in range(num_designs)],
)
for i in range(num_designs):
    write_cif(output, batch, atoms, f"pdl1_{i}.cif", row=i)

write_cif will not overwrite, so give each batch its own output prefix, such as run2_pdl1_{i}.cif. Keep running from the directory that holds pdl1_islands.cif, since the input path is relative.

Screening, and where this runs

RFD4-Proteina on Hugging Face Spaces runs SecureDNA biosecurity screening on the input you supply and on every design the model returns. Screening happens inside the Space's own container: a local synthclient hashes and encrypts each sequence before anything leaves the machine, so the sequences themselves are never transmitted.

Try a competition challenge

Use RFD4-Proteina on Hugging Face to generate candidate binders for relevant open challenges in the Anthropic × Adaptyv Protein Design Competition. The open track accepts any design method. Check each challenge's target, functional requirements, deadlines, and submission format before you start.

Evaluate your candidates, then submit them through Proteinbase. Selection for experimental testing is separate from entry, and tested designs and results are made public under the competition terms.