RFdiffusion3

Generate¶

Run the generate action for RFdiffusion3.

from biolmai import BioLM
response = BioLM(
    entity="rfd3",
    action="generate",
    params={'num_diffusion_steps': 100,
     'diffusion_batch_size': 1,
     'seed': 42,
     'temperature': 1.0,
     'conditioning_mode': 'unconditional',
     'output_format': 'cif',
     'include_trajectories': False},
    items=[{'name': 'simple_design',
      'components': [{'name': 'protein',
                      'sequence': 'MKLLILAVVFTVFGTAVQAAYPYDDAAQLTEEQRKNEELRGQLQPTEGRPVEMDAPPSTGPIQRLANMLYTGIISFWMCSGNMLWVFFPVVLFWALVQY'}]}]
)
print(response)

curl -X POST https://biolm.ai/api/v3/rfd3/generate/ \
  -H "Authorization: Token YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
  "params": {
    "num_diffusion_steps": 100,
    "diffusion_batch_size": 1,
    "seed": 42,
    "temperature": 1.0,
    "conditioning_mode": "unconditional",
    "output_format": "cif",
    "include_trajectories": false
  },
  "items": [
    {
      "name": "simple_design",
      "components": [
        {
          "name": "protein",
          "sequence": "MKLLILAVVFTVFGTAVQAAYPYDDAAQLTEEQRKNEELRGQLQPTEGRPVEMDAPPSTGPIQRLANMLYTGIISFWMCSGNMLWVFFPVVLFWALVQY"
        }
      ]
    }
  ]
}'

import requests

url = "https://biolm.ai/api/v3/rfd3/generate/"
headers = {
    "Authorization": "Token YOUR_API_KEY",
    "Content-Type": "application/json"
}
payload = {
      "params": {
        "num_diffusion_steps": 100,
        "diffusion_batch_size": 1,
        "seed": 42,
        "temperature": 1.0,
        "conditioning_mode": "unconditional",
        "output_format": "cif",
        "include_trajectories": false
      },
      "items": [
        {
          "name": "simple_design",
          "components": [
            {
              "name": "protein",
              "sequence": "MKLLILAVVFTVFGTAVQAAYPYDDAAQLTEEQRKNEELRGQLQPTEGRPVEMDAPPSTGPIQRLANMLYTGIISFWMCSGNMLWVFFPVVLFWALVQY"
            }
          ]
        }
      ]
    }

response = requests.post(url, headers=headers, json=payload)
print(response.json())

library(httr)

url <- "https://biolm.ai/api/v3/rfd3/generate/"
headers <- c("Authorization" = "Token YOUR_API_KEY", "Content-Type" = "application/json")
body <- list(
  params = list(
    num_diffusion_steps = 100,
    diffusion_batch_size = 1,
    seed = 42,
    temperature = 1.0,
    conditioning_mode = "unconditional",
    output_format = "cif",
    include_trajectories = FALSE
  ),
  items = list(
    list(
      name = "simple_design",
      components = list(
        list(
          name = "protein",
          sequence = "MKLLILAVVFTVFGTAVQAAYPYDDAAQLTEEQRKNEELRGQLQPTEGRPVEMDAPPSTGPIQRLANMLYTGIISFWMCSGNMLWVFFPVVLFWALVQY"
        )
      )
    )
  )
)

res <- POST(url, add_headers(.headers = headers), body = body, encode = "json")
print(content(res))

POST /api/v3/rfd3/generate/¶

Generate endpoint for RFdiffusion3.

Request Headers:

• Content-Type – application/json

• Authorization – Token YOUR_API_KEY

Request

• params (object, optional) — Configuration parameters:

  • num_diffusion_steps (int, range: 50-500, default: 200) — Number of diffusion sampling steps

  • diffusion_batch_size (int, range: 1-16, default: 1) — Number of designs to generate

  • seed (int, optional) — Random seed for reproducibility

  • temperature (float, range: 0.1-2.0, default: 1.0) — Sampling temperature

  • conditioning_mode (string, default: “unconditional”) — Type of conditioning to apply; one of: “unconditional”, “motif_scaffolding”, “binder_design”, “partial_diffusion”, “symmetric_design”

  • symmetry (string, optional) — Symmetry specification (e.g., “C3”, “D2”)

  • cyclic_chains (array of strings, optional) — List of chain IDs to cyclize

  • step_scale (float, range: 1.0-2.0, optional) — Scales diffusion step size (default: 1.5)

  • noise_scale (float, range: 1.0-2.0, optional) — Noise scale for diffusion (default: 1.003)

  • center_option (string, optional) — Center option: “all”, “motif”, or “diffuse” (default: “all”)

  • output_format (string, default: “cif”) — Output format; one of: “cif”, “pdb”

  • include_trajectories (bool, default: false) — Include denoising trajectories in output

• items (array of objects, min: 1, max: 1) — Input design tasks:

  • name (string, required) — Name for this design task

  • components (array of objects, min: 1, required) — List of components for design:

    • name (string, required) — Component name

    • sequence (string, optional) — Sequence (if providing structure or for length determination)

    • smiles (string, optional) — SMILES string for small molecule

    • ccd_code (string, optional) — Chemical Component Dictionary code

    • structure_cif (string, optional) — Structure in mmCIF format (for fixed regions)

    • chain_id (string, optional) — Chain identifier

    • fixed_atoms (array of strings, optional) — List of atom specifications to fix (e.g., [“A/ALA/10/CA”])

    • fixed_residues (array of strings, optional) — List of residue specifications to fix (e.g., [“A/10-20”])

  • bonds (array of 2-element string arrays, optional) — Custom bonds as pairs of atom specifications

  • motif_selection (array of strings, optional) — Motif residue selections to scaffold around

  • target_chain (string, optional) — Target chain ID for binder design

  • input_structure_path (string, optional) — Path to input PDB/CIF file (for motif scaffolding or partial diffusion)

  • contig (string, optional) — Contig string specifying fixed/diffused regions (e.g., “A1-100,50-80,/0”)

  • unindex (array of strings, optional) — List of unindexed residue components (e.g., [“A107”, “A109”, “A126”])

  • ligands (array of strings, optional) — List of ligand residue names to include (e.g., [“ZN”, “NAI”])

  • partial_t (float, range: ≥0.0, optional) — Noise level in Angstroms for partial diffusion

  • length (string, optional) — Length constraint: integer or “min-max” range (e.g., “200” or “180-200”)

Example request:

http Copy

POST /api/v3/rfd3/generate/ HTTP/1.1
Host: biolm.ai
Authorization: Token YOUR_API_KEY
Content-Type: application/json

      {
  "params": {
    "num_diffusion_steps": 100,
    "diffusion_batch_size": 1,
    "seed": 42,
    "temperature": 1.0,
    "conditioning_mode": "unconditional",
    "output_format": "cif",
    "include_trajectories": false
  },
  "items": [
    {
      "name": "simple_design",
      "components": [
        {
          "name": "protein",
          "sequence": "MKLLILAVVFTVFGTAVQAAYPYDDAAQLTEEQRKNEELRGQLQPTEGRPVEMDAPPSTGPIQRLANMLYTGIISFWMCSGNMLWVFFPVVLFWALVQY"
        }
      ]
    }
  ]
}

Status Codes:

• 200 OK – Successful response

• 400 Bad Request – Invalid input

• 500 Internal Server Error – Internal server error

Response

• results (array of arrays of objects) — One result per input item, in the order requested:

  • Each inner array has length equal to the number of generated designs for that item (diffusion_batch_size, range: 1–16)

  • structure_cif (string) — Designed structure in mmCIF text format, containing all generated atoms and residues

  • trajectory_cif (string, optional) — Denoising trajectory in mmCIF text format, concatenating intermediate structures over num_diffusion_steps (50–500)

Example response:

http Copy

HTTP/1.1 200 OK
Content-Type: application/json

      {
  "results": [
    [
      {
        "structure_cif": "data_design_input_simple_design_model_0\n#\n_entry.id       design_input_simple_design_model_0\n_entry.author   unknown_user\n_entry.date     2026-04-30\n_entry.time     19:53:59\n#\nloop_\n_atom_site.group_P... (truncated for documentation)"
      }
    ]
  ]
}

Performance¶

• Architectural performance characteristics - RFD3 uses a lean ≈168M‑parameter transformer-based U‑Net diffusion module with only 2 Pairformer-style conditioning layers (vs. ~48 in AlphaFold3’s conditioning stack), and removes triangle multiplicative/attention updates used in RFdiffusion1/2 and RoseTTAFold-derived models, reducing per‑step FLOPs - Sparse attention over spatially local atoms/residues reduces effective quadratic scaling with system size; in practice this yields substantially lower compute per denoising step for comparable complex sizes (proteins ± nucleic acids ± ligands) - Joint backbone+side-chain all‑atom diffusion (14 atoms per residue including virtual atoms) adds a modest constant‑factor overhead versus backbone‑only diffusion, but avoids a second rotamer‑packing pass and improves downstream sequence designability for typical RFD3 → (Ligand)MPNN → predictor workflows

• Runtime performance and relative speed - Relative to RFdiffusion2 (hybrid residue-frame + catalytic atom diffusion), RFD3 achieves roughly a 10× reduction in wall‑clock inference time across typical monomer design lengths (100–300 residues) at comparable diffusion schedules; this holds both in the paper’s A6000 benchmarks and in BioLM’s datacenter deployments - Compared to RFdiffusion1 (backbone-only RoseTTAFold-style stack), RFD3 is empirically faster at equal design lengths despite producing all‑atom structures, because its simplified conditioning stack and sparse attention reduce compute more than multi‑atom outputs increase it - Versus structure prediction models offered on BioLM:

  • AlphaFold2 / RoseTTAFold2: a single RFD3 diffusion trajectory is usually slower than a single AF2/RF2 forward pass at the same length, but full design workflows always require inverse folding plus prediction; in those pipelines, the marginal cost of RFD3 is similar to or lower than AF2/RF2‑based validation

  • ESMFold: substantially faster for single‑structure prediction but non‑generative; RFD3 should be treated as a design‑time cost, not a replacement for rapid prediction workloads

• Accuracy and designability versus related models - Unconditional de novo protein design:

  • For 100–200‑residue targets, ≈98% of RFD3 backbones have at least one ProteinMPNN‑designed sequence that AF3 predicts to refold within 1.5 Å Cα RMSD, narrowing or eliminating the historical gap between generative RFdiffusion1/2 backbones and hand‑crafted Rosetta backbones while increasing fold diversity

  • Conditional interaction design:

    • Protein–protein binders: on five therapeutic targets, RFD3 yields more AF3‑successful binders than RFdiffusion1 on 4/5 targets and increases the number of unique successful backbone clusters (TM‑score 0.6) from 1.4 to 8.2 on average, improving both per‑task success and exploration of binding modes

    • Protein–DNA and protein–small‑molecule design: RFdiffusion1/2 and ESMFold lack native all‑atom co‑design; compared to RFdiffusion All‑Atom, RFD3 improves AF3‑based success rates on all four benchmark ligands and produces more structurally diverse, novel, and energetically favorable binders, directly sampling both protein and partner conformations

    • Enzyme active‑site scaffolding: on the AME benchmark, RFD3 outperforms RFdiffusion2 on 37/41 tasks and increases pass rates from 4% to 15% for the most fragmented multi‑island motifs, indicating that fully atomistic diffusion simplifies complex active‑site placement

• Scaling and throughput characteristics in BioLM deployments - RFD3 is deployed on datacenter‑class GPUs in the A100 40 GB class, with all‑atom coordinate handling (proteins, nucleic acids, ligands) kept on‑GPU; chunked attention and sparse neighborhoods are used to maintain stable memory use across complex sizes and conditioning modes - Compared to heavier prediction‑only models (AlphaFold2, Boltz‑2, Chai‑1), RFD3 is usually not the dominant cost unless many independent diffusion trajectories are requested; in typical BioLM pipelines, AF‑family/Chai‑1/Boltz‑2 validation and sequence‑level ranking contribute a similar or larger share of total compute - In multi‑model workflows such as RFD3 → ProteinMPNN/LigandMPNN → AlphaFold2/AF3/Chai‑1, end‑to‑end throughput is generally governed by the prediction/ranking stage; BioLM executes diffusion and prediction stages concurrently so the added generative step does not linearly increase wall‑clock time per candidate reaching experimental evaluation

Applications¶

• All-atom de novo binder design to structured protein targets for therapeutic and diagnostic programs, using RFdiffusion3’s atom-level diffusion (backbone + sidechains) in binder_design mode to generate complete binding interfaces against a supplied target structure (e.g., cytokine receptors, enzymes, viral surface proteins). This is valuable when teams need compact, non-antibody binders (alternative scaffolds, recruiters, degraders) with engineered hotspots and diverse docking modes, and when traditional docking or library screening is too narrow or costly. Not optimal for disordered, highly flexible targets where no stable binding epitope can be defined.

• Active-site–constrained enzyme design for industrial biocatalysis and therapeutic enzyme programs, leveraging RFdiffusion3’s ability to scaffold unindexed atomic motifs and co-diffuse sidechains around specified catalytic geometries (e.g., Cys–His–Asp triads, metal-binding constellations, substrate-like transition states) via motif_scaffolding conditioning and fixed atoms/residues. This enables design of new hydrolases or transferases tuned for specific small-molecule substrates and process constraints when only a minimal set of catalytic atoms is known from mechanism or a reference PDB and no natural scaffold meets stability, pH, or manufacturability requirements. Not ideal when the reaction mechanism or key catalytic geometry is poorly defined or speculative.

• Protein–DNA interface design for gene regulation tools and DNA-targeting biologics, using RFdiffusion3’s joint protein–DNA diffusion to generate DNA-binding domains around a given DNA sequence and approximate conformation, with explicit atom-level control over base contacts and hydrogen-bond donors/acceptors in the major groove. This is useful for engineering programmable repressors/activators, sequence-specific DNA sensors, or genome-targeting fusion proteins when existing transcription factor families (e.g., zinc fingers, TALEs, CRISPR systems) are limiting in IP, size, or off-target profile. Performance is best when a relatively rigid DNA shape around the target site can be specified or reasonably approximated; less suitable when DNA is strongly distorted by nucleosomes or large complexes.

• Small-molecule binder and sensor design for assay development and molecular diagnostics, exploiting RFdiffusion3’s ability to co-generate protein structures and ligand conformations at all-atom resolution to build buried or partially exposed binding pockets around a fixed ligand identity (via SMILES or CCD code) and optional hydrogen-bond and solvent-accessibility constraints. This supports development of binding proteins for biosensors, reporter fusions, or capture reagents that must recognize a specific chemical with high selectivity, and is particularly helpful when ligands have multiple plausible conformers that rigid-docking workflows struggle to accommodate. Not optimal for very large, highly flexible ligands (e.g., long polymers) where the conformational landscape is poorly constrained within the model’s sequence-length and memory limits.

• Symmetric scaffold and nanoparticle design for multivalent display and materials applications, using RFdiffusion3’s symmetric_design conditioning and symmetry specification (e.g., "C3", "C5", "D2") to generate cyclic and dihedral oligomers with matched interfaces and controlled centre-of-mass placement around ligands or functional motifs. This enables creation of self-assembling cages, rings, or lattices for antigen display, multivalent receptor engagement, or enzyme clustering, with symmetry and radius tunable via model conditioning. May be less effective for extremely large architectures or mixed-component assemblies that exceed the API’s practical sequence-length (≤2048 residues total) and single-run memory limits.

Limitations¶

• Maximum design size and batching: Total designed protein sequence length per request is limited by RFD3Params.max_sequence_len (2048 residues) across all components. The top-level items list in RFD3DesignRequest has max_length = 1 (one RFD3DesignRequestInput per call). Within that item, RFD3DesignParams.diffusion_batch_size controls how many designs are sampled in parallel and is capped at RFD3Params.max_num_designs (16). Larger systems (e.g., very large complexes or many chains) must be split across multiple calls, and generating more than 16 variants for the same specification requires repeated requests.

• Outputs are coordinates only, not sequences or functional predictions: Each RFD3DesignResponseResult returns an all-atom structure as structure_cif in mmCIF format (or PDB if output_format = 'pdb'). If include_trajectories = True, an additional denoising trajectory is returned in trajectory_cif. The API does not produce amino acid sequences, stability estimates, binding affinities, or other functional scores; users must apply separate tools (e.g., inverse folding, structure prediction, docking/scoring) downstream.

• Conditioning modes and inputs are strict and largely unchecked: The conditioning_mode in RFD3DesignParams determines how fields in RFD3DesignRequestInput and RFD3Component are interpreted and must match your use case: 'unconditional' (length from components.sequence or length), 'motif_scaffolding' (expects fixed residues/atoms via fixed_residues / fixed_atoms, often with contig / motif_selection), 'binder_design' (expects a target structure via structure_cif, target_chain and optional ligands), 'partial_diffusion' (requires an input structure via input_structure_path or component structure_cif plus a partial_t noise level), and 'symmetric_design' (requires a valid point-group symmetry such as 'C3' or 'D2'). The API does minimal semantic validation: inconsistent chain IDs, contigs, fixed regions, or ligand definitions typically yield low-quality designs rather than explicit errors.

• Model scope: de novo structure generation, not structure prediction or ligand search: RFdiffusion3 generates new all-atom coordinates conditioned on user-specified constraints. It is not intended as a general structure predictor (e.g., AlphaFold-class models) or as a ligand-design engine. RFD3Component.smiles and ccd_code allow including specific small molecules, and nucleic acids can be co-diffused as part of components, but the API does not explore chemical space or change ligand identity—only protein and complex geometries around the provided non-protein atoms. Performance is best for compact, well-folded proteins and structured interfaces; membrane proteins, highly flexible or disordered regions, and large heterogeneous assemblies are less reliable.

• Sampling cost, stochasticity, and design quality variability: Runtime and cost scale with system size and RFD3DesignParams.num_diffusion_steps (allowed range 50–500, default 200). Lower num_diffusion_steps or higher temperature can increase diversity at the expense of physical plausibility. The process is stochastic: changes to seed, temperature, step_scale or noise_scale (if set) will change outputs, and there is no guarantee that any individual design is experimentally viable. In practice, users should treat diffusion_batch_size as a first level of sampling and run multiple calls when they need larger design sets, followed by external scoring and validation.

• Chemical/biophysical realism and task fit are not guaranteed: Although RFdiffusion3 is trained on experimental structures and co-complexes, it does not strictly enforce all stereochemical, electrostatic, or application-specific constraints. Generated binders may show imperfect packing or hydrogen-bonding networks; motif-scaffolded active sites can match input atom positions yet still be catalytically inactive; symmetric designs requested via symmetric_design may misassemble or prefer alternative oligomeric states in vitro. The API is best used as an upstream 3D generator within a broader pipeline that includes sequence design, structure prediction, and experimental or high-fidelity in silico evaluation.

How We Use It¶

RFdiffusion3 enables all-atom, multi-molecule protein design as a programmable component in end-to-end design workflows, covering de novo binders, enzymes, and scaffolds around DNA, RNA, and small molecules. We integrate RFdiffusion3 designs with downstream sequence design (ProteinMPNN/LigandMPNN), structure prediction (AlphaFold-class models), and standardized analytics so teams can move from target concept to experimentally testable candidates through reproducible, API-driven pipelines instead of bespoke scripts.

• Integrated into multi-round optimization: RFdiffusion3 structures act as starting points for iterative, lab-in-the-loop campaigns, where assay data informs updated constraints and follow-on design rounds.

• Supports diverse scientific and commercial programs: including antibody alternatives, diagnostic and affinity binders, enzyme active-site scaffolding, and DNA-binding domains, all accessible through scalable APIs that plug into existing data science and DevOps workflows.

Related¶

• ProteinMPNN – Backbone-to-sequence design model commonly used after RFdiffusion3 to generate diverse sequences for RFD3-designed backbones or complexes before downstream structure validation.

• LigandMPNN – Inverse folding model conditioned on small molecules and nucleic acids; pairs with RFdiffusion3 when co-designing protein interfaces around ligands/DNA/RNA and then fitting compatible sequences.

• Chai-1 – Complex structure prediction and evaluation model used to refold ProteinMPNN/LigandMPNN sequences on RFdiffusion3 backbones, assessing designability of binders, enzymes, and multi-component assemblies.

• Boltz-2 – All-atom structure prediction model that can independently refold RFdiffusion3-designed sequences to check structural self-consistency and prioritize the most robust designs.

References¶

• Butcher, J., Krishna, R., Mitra, R., Brent, R. I., Li, Y., Corley, N., Kim, P., Funk, J., Mathis, S., Salike, S., Muraishi, A., Eisenach, H., Thompson, T. R., Chen, J., Politanska, Y., Sehgal, E., Coventry, B., Zhang, O., Qiang, B., Didi, K., Kazman, M., DiMaio, F., & Baker, D. (2025). De novo design of all-atom biomolecular interactions with RFdiffusion3. bioRxiv preprint.