FoldaVirus, a knowledge-based icosahedral capsid builder using AlphaFold

FoldaVirus is a knowledge-based web tool that integrates AlphaFold-predicted coat protein structures with known icosahedral symmetry principles and energy minimization to generate and validate accurate 3D capsid models for spherical viruses, effectively bridging the gap between the vast sequence space and limited experimental structural data.

The Gist

Imagine you have a box of Lego instructions for building a complex castle, but the instructions only show you what a single brick looks like. You know the brick is important, but you have no idea how 60, 180, or even 720 of them snap together to form the final castle.

This is the problem scientists face with viruses. We have the genetic "blueprint" (the amino acid sequence) for millions of virus coat proteins, but we only have the actual 3D "photos" (structures) of a tiny fraction of them. Building these viral shells, called capsids, is like trying to assemble a giant, spherical puzzle where the pieces are constantly shifting.

Enter FoldaVirus, a new digital tool created by a team of researchers that acts as a "smart assembly guide" to bridge this gap. Here is how it works, explained simply:

1. The Problem: The "Super-Brick" Limitation

Scientists have a powerful AI tool called AlphaFold that is amazing at predicting what a single virus "brick" (protein) looks like. It's like having a robot that can perfectly sculpt a single Lego piece based on a description.

However, AlphaFold hits a wall when asked to build the whole castle. It gets overwhelmed by the sheer number of pieces needed to make a virus shell. It might build a few pieces, but it often fails to figure out the correct way to snap them together into a perfect sphere. It's like the robot can make a perfect brick, but it doesn't know if that brick belongs on the roof or the wall.

2. The Solution: The "Knowledge-Based" Architect

The FoldaVirus team realized that viruses in the same "family" (like the Picornaviruses) always build their castles in the exact same shape, just with slightly different bricks.

• The Analogy: Imagine you want to build a new type of igloo, but you've never seen one. However, you know that all igloos in your village follow the same architectural rules. You don't need to invent the shape from scratch; you just need to know the pattern.
• How FoldaVirus does it:
  1. The Search: You give FoldaVirus the "recipe" (sequence) of a new virus protein.
  2. The Match: It looks at its massive library of known virus structures (VIPERdb) and says, "Ah! This new protein looks 90% like the proteins in the Picornavirus family. Therefore, it will likely build a T=3 castle."
  3. The Assembly: Instead of guessing the whole shape, it takes the AlphaFold prediction of the single brick and forces it to fit into the known "T=3" architectural blueprint. It essentially says, "We know the shape; just put your new brick in the right spot."

3. The "Tuning" Process: Smoothing the Rough Edges

When you force a new brick into an old mold, it might not fit perfectly. It might stick out or bump into its neighbors.

• The Analogy: Imagine trying to fit a slightly oversized puzzle piece into a puzzle. It might get stuck or crack the surrounding pieces.
• The Fix: FoldaVirus uses a physics engine (called Amber) to gently "massage" the structure. It runs a simulation that pushes the atoms apart if they are too close (relieving "steric clashes") and pulls them together if they are too loose. It's like a digital sculptor smoothing out the clay until the whole shell is perfectly round and stable.

4. The Quality Check: The "Outlier" Detector

How do we know the new castle is built correctly?

• The Analogy: Imagine you build a new house. To check if it's a "good" house, you compare it to a neighborhood of similar houses. If your house has a roof made of cheese and a door made of jelly, it's an "outlier"—it doesn't fit the neighborhood pattern.
• The Math: FoldaVirus calculates something called the Mahalanobis Distance. This is a fancy statistical way of asking: "Does this new virus shell look like the other members of its family?"
  • If the distance is low, the model is a good fit (it looks like a normal virus).
  • If the distance is high, the model is weird (an outlier), and scientists know to double-check their work.

Why Does This Matter?

Currently, there are thousands of virus sequences but very few known 3D structures. Determining a structure experimentally (using microscopes or X-rays) is slow, expensive, and sometimes impossible.

FoldaVirus is the bridge. It allows scientists to take a simple genetic sequence and instantly generate a reliable 3D model of the virus shell. This is crucial for:

• Vaccine Design: Seeing the shape helps us design better vaccines.
• Drug Development: If we know the shape of the virus's "door," we can design a key to lock it.
• Understanding Viruses: It helps us understand how viruses evolve and change.

In a Nutshell

FoldaVirus is a smart tool that combines the super-power of AI (AlphaFold) with the wisdom of known virus patterns. It takes a single protein recipe, figures out what kind of virus shell it belongs to, snaps it into the correct shape, smooths out the bumps, and checks to make sure it looks like a real virus. It turns a "mystery sequence" into a "3D model" in a matter of hours, helping scientists fight viruses faster than ever before.

Technical Summary

1. Problem Statement

While AlphaFold (AF2 and AF3) has revolutionized the prediction of individual protein tertiary structures, it faces significant limitations in predicting large, symmetric quaternary assemblies like viral capsids.

• Memory Constraints: Generating complete capsids (e.g., T=1 capsids with 60 copies) directly via AlphaFold is currently impossible due to GPU memory limitations.
• Oligomer Prediction Failure: AlphaFold often fails to predict the correct oligomeric state representing the Icosahedral Asymmetric Unit (IAU), particularly for complex architectures (T $\ge$ 3, and sometimes T=3). It may produce degenerate configurations (e.g., open hexamers instead of closed rings) that cannot be simply expanded using symmetry operators to form a valid capsid.
• Sequence-Structure Gap: There is a massive disparity between the number of available viral coat protein (CP) sequences (millions) and experimentally determined 3D structures (~1,700 in VIPERdb). Traditional structural biology (Cryo-EM, X-ray) is too slow and expensive to bridge this gap.

2. Methodology: The FoldaVirus Pipeline

FoldaVirus is a web-based tool (https://foldavirus.org) that combines AlphaFold predictions with a knowledge-based approach derived from the VIPERdb database to construct full capsid models. The workflow consists of 20 steps, summarized as follows:

• Input & Template Selection:

  • Users submit CP amino acid sequences (FASTA) or UniProt IDs.
  • The system performs a local BLAST search against VIPERdb to identify the virus family and the likely Triangulation (T) number (e.g., T=1, 3, 4, 7, 9) based on sequence similarity.
  • Users can select a specific reference structure from the same family if multiple capsid states exist (e.g., empty vs. full capsids).

• Sequence Pre-processing:

  • Unstructured regions (typically N- and C-termini) are identified and trimmed. AlphaFold often generates "spaghetti-like" models for these disordered regions, which cause steric clashes in full capsid assembly.

• AlphaFold Prediction & IAU Reconstruction:

  • The trimmed sequence is submitted to AlphaFold (AF2) to predict the structure of the IAU.
  • Critical Correction: Since AlphaFold often fails to predict the correct oligomeric arrangement for the IAU, FoldaVirus performs a structural superposition of the AF-predicted chains onto the corresponding chains of the known reference structure. This "rebuilt" IAU is oriented according to VIPER conventions.

• Energy Minimization (Amber):

  • The reconstructed IAU is subjected to two rounds of energy minimization using AmberTools (sander) to relieve steric clashes:
    1. Round 1: 100 cycles (50 Steepest Descent, 50 Conjugate Gradient) with heavy atoms restrained (except Hydrogens).
    2. Round 2: 100 cycles with only backbone atoms (CA, N, C) restrained.
  • A partial capsid (IAU + surrounding neighbors) is generated using the VIPERdb Oligomer_Generator API and subjected to a similar minimization regimen to relax inter-subunit interfaces.

• Full Capsid Assembly:

  • The relaxed IAU is extracted and expanded into a full capsid by applying standard 60-fold icosahedral symmetry matrices.

• Validation & Analysis:

  • Structural Metrics: Standard metrics like pLDDT, pTM, and TM-score are calculated.
  • Mahalanobis Distance (MD) Validation: This is the core novelty. The system classifies residues into core, interface, and surface categories based on Solvent Accessible Surface Area (SASA) calculations. It then calculates the robust Mahalanobis distance between the predicted model's residue distribution and the distribution of known structures in the same virus family.
    • A low MD indicates the model fits the family's quaternary organization.
    • A high MD suggests the model is an outlier.
  • VIPER Analysis: Calculates buried surface areas (BSA), association energies, capsid diameter, and net surface charge.

3. Key Contributions

• Hybrid Workflow: Successfully bridges the gap between de novo prediction (AlphaFold) and knowledge-based modeling (VIPERdb) to generate full icosahedral capsids up to T=9 symmetry.
• IAU Correction Mechanism: Solves the specific problem of AlphaFold's inability to predict correct oligomeric states for complex T-numbers by using structural superposition against known templates.
• Robust Validation Metric: Introduces the Mahalanobis Distance based on residue classification (core/interface/surface) as a "gold standard" for validating quaternary assembly quality, rather than just tertiary structure accuracy.
• Web Utility: Provides a freely accessible, automated pipeline (https://foldavirus.org) that handles sequence trimming, AF execution, energy minimization, and visualization (via Mol*).
• Handling Polymorphism: Capable of handling viruses with pseudo-symmetry (e.g., Picornaviruses with pseudo-T=3) and multiple CP types (VP1, VP2, VP3).

4. Results

• Success Rate: The tool successfully generated capsid models for various test cases, including Picornaviruses (pseudo-T=3) and other families with T-numbers up to 9.
• Validation: Models were validated against known structures. The Mahalanobis distance analysis confirmed that FoldaVirus-generated models fall within the main distribution of known structures for their respective families, distinguishing them from outliers.
• Performance:
  • Processing time ranges from 30 minutes to 4 hours depending on CP size and T-number.
  • The pipeline is modular, allowing jobs to be paused and restarted at specific steps (up to 20 steps).
• Limitations:
  • Currently restricted to T $\le$ 9 due to GPU memory constraints.
  • The AlphaFold3 pipeline was implemented locally (3-4x faster) but cannot be released publicly due to licensing restrictions.
  • The system can detect and reject non-capsid forming proteins (e.g., Hemoglobin).

5. Significance

FoldaVirus addresses a critical bottleneck in structural virology. By leveraging the conserved nature of capsid architectures within virus families, it allows researchers to generate high-quality 3D models for thousands of viral sequences that lack experimental structures.

• Applications: The generated models are valuable for rational vaccine design, identifying broadly neutralizing antibodies, understanding virus-host interactions, and studying capsid assembly mechanisms.
• Impact: It effectively bridges the gap between the vast sequence space of viral coat proteins and the limited structural space, providing a scalable solution for the structural characterization of the viral world.