Protein Design with RFD4-Proteina and Hugging Face Spaces NVIDIA and the University of Washington's Institute for Protein Design released RFD4-Proteina, a BioNeMo open model that generates protein sequences and all-atom 3D structures in a single model, cutting the handoffs between separate backbone, sequence, and structure design tools. RFD4-Proteina pairs a flow-matching model with an autoencoder that encodes each standard or modified amino acid, sugar, DNA, or RNA nucleotide as an anchor-atom coordinate and a learned latent vector, letting the model design around a supplied target or catalytic motif. NVIDIA is sponsoring free access to the dedicated RFD4-Proteina Hugging Face Space, running on NVIDIA RTX PRO 6000 GPUs, from October 21 to November 4, 2026, and a ZeroGPU Space runs on shared capacity. 0.4B • Updated • 314 • 5 https://huggingface.co/nvidia/RFD4-Proteina Protein Design with RFD4-Proteina and Hugging Face Spaces Enterprise + Article https://huggingface.co/blog 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 https://huggingface.co/nvidia/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 https://huggingface.co/spaces/nvidia/rfd4-proteina-space , which runs on dedicated GPUs, and the ZeroGPU Space https://huggingface.co/spaces/nvidia/rfd4-proteina-zerogpu , 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 https://huggingface.co/spaces/nvidia/rfd4-proteina-space , which runs on NVIDIA RTX PRO 6000 GPUs https://www.nvidia.com/en-us/products/workstations/professional-desktop-gpus/rtx-pro-6000/ . Try it on your own design problems, including the protein design competition sponsored by Anthropic and Adaptyv https://proteinbase.com/competitions/anthropic-adaptyv-2026 . Try RFD4-Proteina https://huggingface.co/spaces/nvidia/rfd4-proteina-space • Explore the RFD4-Proteina model https://huggingface.co/nvidia/RFD4-Proteina 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 https://huggingface.co/spaces/nvidia/rfd4-proteina-space and choose a supplied example. Both Spaces run AtomWorks Studio https://github.com/RosettaCommons/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 https://huggingface.co/nvidia/RFD4-Proteina 3-design-a-pd-l1-binder-or-an-enzyme-scaffold 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 https://huggingface.co/spaces/nvidia/rfd4-proteina-zerogpu remains free to use. It runs the same interface on shared capacity, subject to Hugging Face account quotas https://huggingface.co/docs/hub/spaces-zerogpu . 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 https://huggingface.co/nvidia/RFD4-Proteina measured-design-efficiency 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 https://rfd4-proteina.org/latest/ for the generation settings supported by your workflow. Continue in Python and larger workflows For programmatic generation, begin with the quickstart https://huggingface.co/nvidia/RFD4-Proteina start-with-one-design . 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 https://rfd4-proteina.org/latest/ for the native and container instructions. Use the PD-L1 code example https://huggingface.co/nvidia/RFD4-Proteina 3-design-a-pd-l1-binder-or-an-enzyme-scaffold 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 https://github.com/huggingface/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. python 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 Materialize one binder length before selecting numbered residues. aa = realize expandable segments aa, rng=np.random.default rng 42 Select the binder residues you want to constrain, then set one value per atom. 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. python 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="