{"slug": "protein-design-with-rfd4-proteina-and-hugging-face-spaces", "title": "Protein Design with RFD4-Proteina and Hugging Face Spaces", "summary": "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.", "body_md": "[0.4B • Updated   •  314  •  5](https://huggingface.co/nvidia/RFD4-Proteina)  \n\n# \n\t\tProtein Design with RFD4-Proteina and Hugging Face Spaces\n\t\n\n [Enterprise + Article](https://huggingface.co/blog)\n\n## \n\t\tDefine the design task, generate proteins, and build a repeatable design workflow.\n\t\n\nProtein 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.\n\n[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).\n\nRFD4-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.\n\nYou 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.\n\nFrom **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).\n\n[Try RFD4-Proteina](https://huggingface.co/spaces/nvidia/rfd4-proteina-space)  •  [Explore the RFD4-Proteina model](https://huggingface.co/nvidia/RFD4-Proteina)\n\n**Figure 1. Inspect the annotated design input**\n\n*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.*\n\n# \n\t\tDesign a protein in the browser\n\t\n\nOpen 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.\n\nEvery 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.\n\nWith 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.\n\nYou 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.\n\nNote the seed number that was used. This gives you a baseline for the comparison below.\n\n**Figure 2. PD-L1 target and generated binder**\n\n*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.*\n\nWith 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).\n\nDownload 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.\n\nAfter 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).\n\n# \n\t\tChoose a thinking setting\n\t\n\nRFD4-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.\n\n## \n\t\tMeasured design efficiency\n\t\n\nIn 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.\n\n*Structure prediction model refold: binder pTM ≥ 0.80, minimum interface PAE ≤ 1.5 Å, target-aligned binder backbone RMSD ≤ 2.5 Å\n\n# \n\t\tSearching across trajectories\n\t\n\nBeyond 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.\n\nReward-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.\n\n# \n\t\tContinue in Python and larger workflows\n\t\n\nFor 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.\n\nUse 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.\n\nRecord 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.\n\n## \n\t\tThe PD-L1 code example\n\t\n\nEverything 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.\n\n### \n\t\tInstall, and get the input\n\t\n\nClone the repository for the full workflow:\n\n```\ngit clone https://github.com/RosettaCommons/RFD4-Proteina.git\ncd RFD4-Proteina\nmake setup\nsource .venv/bin/activate\n```\n\n`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.\n\nOr pip install the package into your own environment, which needs Python 3.12 already installed:\n\n```\npython3.12 -m venv .venv && source .venv/bin/activate\npip install \"rfd4-proteina[all-cuda13]\"\n```\n\nRun 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:\n\n```\nhf download nvidia/RFD4-Proteina --revision a06e2509c7033b010fc43614e9fd840303588502 \\\n    --local-dir ./rfd4-examples examples/protein_binder/input.cif\ncp rfd4-examples/examples/protein_binder/input.cif pdl1_studio.cif\n```\n\n### \n\t\tSteer binder designs toward structural diversity\n\t\n\nSecondary-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.\n\nSpecifying 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.\n\nSecondary 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.\n\n``` python\nimport numpy as np\nfrom atomworks.io import parse\nfrom atomworks.ml.utils.expandable_segment import realize_expandable_segments\nfrom atomworks.io.utils.atom_array_plus import as_atom_array_plus\nfrom atomworks.io.utils.io_utils import to_cif_file\nfrom rfproteina.conditions import C_SEC, SSEnum\nfrom rfproteina.utils.parse_presets import ANNOTATED_CIF\n\naa = as_atom_array_plus(parse(\"pdl1_studio.cif\", config=ANNOTATED_CIF)[\"assemblies\"][\"1\"][0])\n\n# Materialize one binder length before selecting numbered residues.\naa = realize_expandable_segments(aa, rng=np.random.default_rng(42))\n\n# Select the binder residues you want to constrain, then set one value per atom.\nhelix_island_res_mask = (aa.chain_id == \"B\") & np.isin(aa.res_id, range(10, 30))\nsheet_island_res_mask = (aa.chain_id == \"B\") & np.isin(aa.res_id, range(45, 55))\n\nassert helix_island_res_mask.any(), \"Helix selection matched no atoms\"\nassert sheet_island_res_mask.any(), \"Sheet selection matched no atoms\"\n\nss = C_SEC.annotation(aa, default=\"generate\").copy()\nss[helix_island_res_mask] = SSEnum.HELIX\nss[sheet_island_res_mask] = SSEnum.SHEET\nC_SEC.set_annotation(aa, ss.astype(int))\n\nto_cif_file(aa, \"pdl1_islands.cif\", save_standard_annotations=True, chain_disambiguation=\"chain_iid\")\n```\n\nAlternatively, 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.\n\n### \n\t\tThree ways to run the same task\n\t\n\nAll three use `pdl1_islands.cif` and the same annotated input.\n\n#### \n\t\tFrom the command line\n\t\n\n```\nrfd4-generate inputs=pdl1_islands.cif num_replicates=4 out_dir=./runs/pdl1-cli \\\n    seed=42 recycle_strategy=thinking_high '~metrics' compile_lengths=null\n```\n\n#### \n\t\tFrom Python\n\t\n\nThe 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.\n\n``` python\nfrom hydra import compose, initialize_config_dir\nimport rootutils\nimport rfproteina\nfrom rfd4_proteina import Proteina\nfrom rfproteina.generate import run_generation\n\nmodel = Proteina.from_pretrained(\"nvidia/RFD4-Proteina\", device=\"cuda\")\nconfig_dir = rootutils.find_root(rfproteina.__file__, indicator=\".project-root\") / \"configs\"\nwith initialize_config_dir(config_dir=str(config_dir), version_base=\"1.3\"):\n    cfg = compose(config_name=\"inference\", overrides=[\n        \"inputs=pdl1_islands.cif\", \"out_dir=runs/pdl1-python\", \"num_replicates=4\", \"seed=42\",\n        \"recycle_strategy=thinking_high\", \"~metrics\", \"compile_lengths=null\",\n    ])\nrun_generation(cfg, model=model)\n```\n\nDesigns 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.\n\n#### \n\t\tWith Diffusers\n\t\n\nIf 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.\n\n```\n# Until the next Diffusers release:\npip install \\\n    git+https://github.com/huggingface/diffusers@537887041938fc6fe61ad583c3ae77477c9ebac9 \\\n    git+https://huggingface.co/nvidia/RFD4-Proteina-prep@c9959efdebd75ac7fe9129fbbf0e291a6e0487d5 \\\n    accelerate\n\n# Once it is out:\npip install diffusers git+https://huggingface.co/nvidia/RFD4-Proteina-prep@c9959efdebd75ac7fe9129fbbf0e291a6e0487d5\npython\nimport torch\nfrom diffusers import RFD4ProteinaPipeline\nfrom rfd4_proteina_prep import prepare_cif, write_cif\n\npipe = RFD4ProteinaPipeline.from_pretrained(\n    \"nvidia/RFD4-Proteina-Diffusers\", dtype=torch.bfloat16\n).to(\"cuda\")\nfeatures, atoms = prepare_cif(\"pdl1_islands.cif\", seed=42, device=pipe.device)\n\nnum_designs = 4\nbatch = {k: v.repeat(num_designs, *[1] * (v.ndim - 1)) for k, v in features.items()}\n\nnamed = [\"padding_mask\", \"is_in_context_conditioning\", \"supports_local_latent\",\n         \"token_type\", \"atom37_mask\", \"coords_nm\"]\noutput = pipe(\n    **{k: batch[k] for k in named},\n    conditioning_features={k: v for k, v in batch.items() if k not in named},\n    generator=[torch.Generator(\"cuda\").manual_seed(s) for s in range(num_designs)],\n)\nfor i in range(num_designs):\n    write_cif(output, batch, atoms, f\"pdl1_{i}.cif\", row=i)\n```\n\n`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.\n\n## \n\t\tScreening, and where this runs\n\t\n\nRFD4-Proteina on Hugging Face Spaces runs [SecureDNA](https://securedna.org) 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.\n\n# \n\t\tTry a competition challenge\n\t\n\nUse RFD4-Proteina on Hugging Face to generate candidate binders for relevant open challenges in the [Anthropic × Adaptyv Protein Design Competition](https://proteinbase.com/competitions/anthropic-adaptyv-2026). The open track accepts any design method. Check each challenge's target, functional requirements, deadlines, and submission format before you start.\n\nEvaluate 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](https://proteinbase.com/competitions/anthropic-adaptyv-2026/terms).\n\n# \n\t\tKeep building\n\t\n\n- **Try** :[RFD4-Proteina Space](https://huggingface.co/spaces/nvidia/rfd4-proteina-space) . Generate and inspect a design in the browser.\n- **Review** :[Model card and weights](https://huggingface.co/nvidia/RFD4-Proteina) and the[dataset](https://huggingface.co/datasets/nvidia/RFD4-Proteina) . Checkpoints, hardware requirements, benchmarks, and license terms.\n- **Run it yourself** :[Source code](https://github.com/RosettaCommons/RFD4-Proteina) and[documentation](https://rfd4-proteina.org/latest/) . Install and generate from the command line, Python, or Diffusers.", "url": "https://wpnews.pro/news/protein-design-with-rfd4-proteina-and-hugging-face-spaces", "canonical_source": "https://huggingface.co/blog/nvidia/rfd4-proteina-protein-design", "published_at": "2026-10-21 12:39:49+00:00", "updated_at": "2026-10-21 12:46:35.626627+00:00", "lang": "en", "topics": ["ai-research", "machine-learning", "artificial-intelligence"], "entities": ["NVIDIA", "RFD4-Proteina", "University of Washington Institute for Protein Design", "Hugging Face", "BioNeMo", "AtomWorks Studio", "Anthropic", "Adaptyv"], "also_reported_by": [], "alternates": {"html": "https://wpnews.pro/news/protein-design-with-rfd4-proteina-and-hugging-face-spaces", "markdown": "https://wpnews.pro/news/protein-design-with-rfd4-proteina-and-hugging-face-spaces.md", "text": "https://wpnews.pro/news/protein-design-with-rfd4-proteina-and-hugging-face-spaces.txt", "jsonld": "https://wpnews.pro/news/protein-design-with-rfd4-proteina-and-hugging-face-spaces.jsonld"}}