Transforming macromolecular structures into simulations of self-assembly with ioNERDSS

The paper introduces ioNERDSS, a user-friendly Python package that converts static 3D macromolecular structures into coarse-grained models to simulate their self-assembly pathways using the NERDSS software, enabling the study of complex, multi-component assembly processes at biologically relevant timescales.

The Gist

Imagine you have a picture of a finished LEGO castle. You can see the towers, the flags, and the drawbridge. But the picture doesn't tell you how to build it. Did you start with the base? Did you build the towers first? Did you accidentally glue two towers together before the base was ready, creating a wobbly mess that you had to take apart?

In the world of biology, cells are constantly building massive, complex machines out of protein "LEGO bricks." Scientists have great photos of the finished machines (thanks to databases like the Protein Data Bank), but they often don't know the step-by-step instructions for how the cell assembles them.

This paper introduces a new tool called ioNERDSS (which stands for "Input-Output NERDSS," a bit of a mouthful, but think of it as a "Structure-to-Simulation" translator). Here is how it works, explained simply:

1. The Problem: The "Static Photo" vs. The "Moving Movie"

Scientists have high-resolution photos of giant protein machines (like the ribosome, which is the cell's factory, or viral shells). But a photo is static. It doesn't show the process.

• The Challenge: To understand how these machines build themselves, scientists need to run computer simulations. But building a simulation from scratch is like trying to write a movie script by hand for every single brick in a castle. It takes forever and is incredibly hard to get right.
• The Old Way: You had to manually tell the computer, "This protein sticks to that one here, and that one there," and guess the rules. It was slow and prone to human error.

2. The Solution: ioNERDSS (The "Magic Translator")

The authors created a Python software package called ioNERDSS. Think of it as a universal translator that turns a static photo of a protein structure into a live, moving simulation.

• How it works: You feed it a 3D file of a protein complex (the "blueprint").
• What it does: It automatically breaks the complex down into individual "bricks" (subunits). It figures out exactly where the "sticky spots" (interfaces) are on each brick. It then calculates how strong those sticky spots are (using AI to predict how well they fit together).
• The Output: It spits out a set of instructions that a simulation engine (called NERDSS) can read immediately. This engine then runs a "movie" showing the proteins floating around, bumping into each other, and snapping together to form the final machine.

3. The Tricky Part: The "Identical Twins" Problem

In many biological machines, the same protein brick is used over and over again (like the repeating tiles on a virus shell).

• The Analogy: Imagine you have a box of 100 identical red LEGO bricks. If you just tell the computer "Red Brick A sticks to Red Brick B," the computer might get confused. It might try to stick two bricks together in a way that doesn't make sense for the final shape, or it might get stuck in a loop.
• The Fix: ioNERDSS is smart enough to look at the blueprint and say, "Ah, even though these bricks look identical, in this specific spot, they need to face a slightly different direction." It "regularizes" the model, ensuring that when the simulation runs, the identical bricks assemble into the perfect, symmetrical shape (like a soccer ball or a virus) rather than a messy pile.

4. Why This Matters: Avoiding "Kinetic Traps"

One of the biggest discoveries in this field is that just because a shape is stable doesn't mean it's easy to build.

• The Analogy: Imagine trying to build a house of cards. If you try to put the roof on before the walls are up, the whole thing collapses. In biology, proteins can get stuck in "kinetic traps"—they build a small, stable piece that looks good but can't grow into the final machine.
• The Benefit: ioNERDSS lets scientists run thousands of simulations in minutes. They can ask: "If we have too many of Brick A and too few of Brick B, does the machine still build?" or "Does the machine get stuck halfway?"
• Real-world use: This helps explain why some viruses assemble perfectly every time, while others fail. It also helps scientists design new synthetic materials or drugs that can stop a virus from assembling by messing up its "instructions."

5. The "Platonic Solids" Library

The authors also included a "toy box" of perfect shapes (like dodecahedrons and icosahedrons). You can tell the software, "I want to build a perfect 12-sided ball," and it will instantly generate the rules for how the bricks should connect to make that shape. This is great for testing theories or designing new materials from scratch.

Summary

ioNERDSS is like a Rosetta Stone for protein assembly.

• Input: A static photo of a finished protein machine.
• Process: It uses math and AI to figure out the "rules of the road" for how the pieces fit together.
• Output: A fast, interactive movie showing the machine building itself in real-time.

It takes a task that used to require a team of experts and months of work and turns it into something a student or a biologist can do in a few minutes on a laptop. This opens the door to understanding how life builds its most complex machinery, and how we might hack that process to cure diseases or build new technologies.

Technical Summary

1. Problem Statement

Macromolecular self-assembly is a fundamental biological process responsible for forming complex structures like ribosomes, viral capsids, and cytoskeletal filaments. While high-resolution static structures of these final complexes are increasingly available via the Protein Data Bank (PDB) and predictive tools like AlphaFold3, these static snapshots do not reveal the dynamic pathways, kinetics, or thermodynamic drivers of how these structures assemble.

Current computational approaches face significant hurdles:

• All-atom Molecular Dynamics (MD): Too computationally expensive to simulate the slow timescales (minutes to hours) and large system sizes (thousands of subunits) required for self-assembly.
• Coarse-Grained (CG) Models: While more efficient, constructing them is labor-intensive. Existing tools often lack the ability to automatically convert 3D atomic structures into rule-based CG models that preserve geometric constraints, orientational specificity, and thermodynamic reversibility.
• Enumeration Limits: Traditional rule-based methods often require full enumeration of all possible intermediate states, which scales exponentially with assembly size, making large complexes intractable.

There is a critical gap in tools that can automatically transform a static PDB structure into a simulation-ready, stochastic reaction-diffusion model capable of exploring assembly pathways without requiring extensive manual parameterization or computational expertise.

2. Methodology: The ioNERDSS Pipeline

The authors present ioNERDSS, a user-friendly Python library that automates the conversion of atomic structures into coarse-grained models for the NERDSS (Nonequilibrium Simulator for Multibody Self-Assembly) software. The pipeline operates through the following steps:

• Structure Parsing & Coarse-Graining:

  • Reads PDB/mmCIF files using Biopython to identify protein chains.
  • Computes the geometric center of mass (COM) and molecular radius for each subunit to assign translational and rotational diffusion coefficients (via Einstein-Stokes relation).
  • Identifies interaction interfaces using KD-tree queries on $C_\alpha$ coordinates within a distance cutoff (default 6 Å). A contact is validated only if both chains contribute at least 3 residues.
  • Maps each interface to a single rigid-body "interface point" at the geometric center of contacting residues.

• Handling Repeated Subunits (Regularization):

  • For homomeric complexes (e.g., viral capsids), the pipeline identifies repeated chains via sequence alignment or polymer-entity IDs.
  • It distinguishes between homotypic (identical interface binding to identical interface) and heterotypic (identical subunit binding to different interfaces) interactions.
  • It regularizes the structure by aligning all repeated subunits to a single rigid template geometry, averaging bond lengths and angles (using circular means for dihedrals) to ensure consistent topology across stochastic pathways.
  • Special handling is applied for structures with radial symmetry (e.g., spheres) to enforce a single curvature during assembly.

• Parameterization of Kinetics and Thermodynamics:

  • Binding Affinities ($\Delta G$): Uses ProAffinity-GNN, a machine-learning tool combining graph neural networks and protein language models (ESM-2), to predict binding free energies for each pairwise interface directly from the structure.
  • Reaction Rates:
    • Association rates ($k_{on}$) are set near the diffusion limit ($7.2 \times 10^5 M^{-1}s^{-1}$).
    • Dissociation rates ($k_{off}$) are derived from the predicted $\Delta G$ and $k_{on}$ using the relation $k_{off} = k_{on} \cdot C^\circ \cdot \exp(\Delta G / RT)$.
  • This ensures the model is thermodynamically reversible and converges to a defined equilibrium steady-state.

• Simulation & Validation:

  • Generates input files (.mol, .inp) for NERDSS to perform stochastic, rigid-body reaction-diffusion simulations.
  • For small complexes (<12 subunits), it automatically enumerates all structurally admissible intermediates to generate a deterministic system of Ordinary Differential Equations (ODEs) for comparison.
  • Includes a "Lego-like" validation protocol using irreversible binding to verify that the designed CG structure can be assembled from monomers with low RMSD.

3. Key Contributions

• Automation of Model Construction: ioNERDSS is the first tool to fully automate the transition from a static PDB structure to a stochastic reaction-diffusion simulation model, removing the need for manual definition of interfaces and reaction rules.
• Handling of Complex Topologies: It robustly handles repeated subunits, distinguishing between homotypic and heterotypic interactions, and regularizing structures to prevent topological errors in large assemblies (e.g., viral lattices).
• Integration of Machine Learning: By integrating ProAffinity-GNN, the tool provides structure-informed thermodynamic constraints, moving beyond arbitrary energy assignments.
• Dual-Model Approach: It generates both spatial stochastic models (NERDSS) and non-spatial deterministic ODE models (for small systems), allowing users to compare spatial effects with well-mixed kinetics.
• Accessibility: The tool is open-source, includes a web server (nerdssdemo.org), and provides visualization outputs compatible with Simularium and OVITO.

4. Results & Benchmarking

• Large-Scale Validation: The pipeline was benchmarked on >44,000 PDB structures (3–12 chains).
  • Heteromeric complexes: >99% successfully assembled to the target structure with RMSD < $10^{-6}$ nm.
  • Homomeric/Repeated subunits: 73% of valid structures assembled correctly. The remaining failures were primarily due to disconnected graphs (missing interfaces) or high RMSD due to structural heterogeneity in the source PDB.
• Case Studies:
  • Proteasome (28 subunits): Successfully modeled the assembly of the 28-mer proteasome. The authors demonstrated that without hierarchical assembly (titration of subunits), the system suffers from kinetic traps (monomer starvation).
  • HIV-1 Gag Lattice: Modeled the assembly of a fragment of the immature lattice, successfully regularizing 18 repeated chains into a single rigid template to support growth into larger lattices.
  • Actin Filaments: Demonstrated the ability to simulate persistent growth of filaments beyond the size of the input PDB fragment, correctly capturing the helical twist.
  • Platonic Solids: Provided a library to generate ideal dodecahedrons and icosahedrons with tunable radii, useful for designing synthetic viral capsids.
• ODE vs. Stochastic Comparison: For small complexes (e.g., heterotrimers, homotetramers), the stochastic NERDSS trajectories showed excellent agreement with the generated deterministic ODE solutions, validating the kinetic parameterization.

5. Significance

• Bridging Structure and Dynamics: ioNERDSS bridges the gap between static structural biology and dynamic systems biology, enabling researchers to ask "how" and "how fast" a complex assembles, not just "what" it looks like.
• Hypothesis Testing: It allows for rapid testing of assembly mechanisms, such as the role of subunit stoichiometry, binding hierarchies, and kinetic traps in determining assembly yield.
• Synthetic Biology & Materials Design: The tool facilitates the rational design of self-assembling nanomaterials and synthetic protein complexes by providing a predictive framework for assembly outcomes.
• Democratization of Simulation: By automating the setup of complex CG models, ioNERDSS makes stochastic reaction-diffusion simulations accessible to structural biologists and non-experts, fostering broader adoption of these powerful computational tools.

In conclusion, ioNERDSS represents a major step forward in computational biophysics, transforming the static "parts list" of the PDB into dynamic, testable models of life's molecular machinery.