AlphaFold: A Deep Learning System for Protein Three-Dimensional Structure Prediction

New
License: Code is Apache-2.0; model parameters and CASP15 prediction data are CC BY 4.0 · Updated 2026-11-12
My rating

1. Overview

AlphaFold is the structure prediction system released by Google DeepMind in 2021 and maintained as an open-source repository since then. It predicts a protein's three-dimensional atomic coordinates directly from its amino-acid sequence, and at the CASP14 assessment held between May and July 2020 it reached a median backbone accuracy of 0.96 Angstrom r.m.s.d. at 95 percent residue coverage, against 2.8 Angstrom for the next best performing method. The paper describing this result, "Highly accurate protein structure prediction with AlphaFold", appeared in Nature volume 596, pages 583 to 589, on 15 July 2021, with DOI 10.1038/s41586-021-03819-2 under a CC BY 4.0 licence.

The official repository is google-deepmind/alphafold, created on 17 June 2021, with the last code push recorded on 22 April 2026. At the time of verification it carries roughly 14900 stars, 2960 forks and 311 open issues, is written mainly in Python, is not archived, and uses main as its default branch. The repository is a complete inference package rather than a bare model definition: it contains the model code under alphafold/model with modules for all-atom prediction, folding, r3 transforms and quaternion affine operations, the data pipeline under alphafold/data with wrappers for hhblits, hhsearch, jackhmmer and kalign, the relaxation code under alphafold/relax built on Amber and OpenMM, a Docker entry point under docker, a web server under server, a technical note at docs/technical_note_v2.3.0.md and the CASP15 prediction archive at docs/casp15_predictions.zip.

Licensing is layered across objects and each layer must be checked separately. The source code is under the Apache 2.0 licence, the trained parameters and the CASP15 prediction data are released under CC BY 4.0, and the mirrored genetic databases carry their own terms, with BFD and UniRef30 under CC BY-SA 4.0 and MGnify under CC0 1.0. The README also carries an explicit disclaimer stating that AlphaFold 2 and its output are for theoretical modelling only, are not intended, validated or approved for clinical use, and that outputs are predictions with varying levels of confidence that should be interpreted carefully.

Two related but distinct projects share the name and should not be conflated with this repository. The AlphaFold Protein Structure Database at alphafold.ebi.ac.uk distributes predicted structures programmatically, and its 2022 Nucleic Acids Research paper describes an initial release of more than 360000 predicted structures across 21 model-organism proteomes, with expansion toward the representative sequences of UniRef90. AlphaFold 3, published in Nature volume 630, pages 493 to 500 on 8 May 2024 with DOI 10.1038/s41586-024-07487-w, extends the framework to joint modelling of proteins, nucleic acids, small molecules, ions and modified residues, and ships in a separate repository google-deepmind/alphafold3 whose weights are distributed by Google directly under a separate terms-of-use document.

2. How It Works

The network has two stages. The trunk processes the inputs through repeated layers of a block the authors term Evoformer, and a structure module then converts the resulting representation into atomic coordinates. The Evoformer trunk in the released configuration contains 48 blocks, and it updates two representations in parallel: a representation of the multiple sequence alignment in which columns are residues and rows are database sequences, and a representation of the protein structure where rows are residues and columns are positions in the template or in the current model.

Evolutionary information enters through the multiple sequence alignment. The pipeline performs a genetic search with hhblits against BFD or the reduced BFD, a UniRef30 profile search with hhblits, a UniRef90 search with jackhmmer, and a template search against PDB70 by date. The resulting alignment is reduced by clustering and by selecting the most diverse sequences, which keeps the cost bounded for large inputs. A pairing track builds a representation of which residue pairs are close in three dimensions, derived from the alignment and the template, and it is this track that lets the network reason about coevolution without ever seeing a solved structure.

The pair representation is updated by an operation known as triangle multiplication, which propagates information through triplets of residues, and by triangle self-attention, which lets a pair attend to the pairs around it. The single representation is updated by row and column attention with a bias derived from the alignment and from the pair representation, so that residue-to-residue attention is conditioned on evolutionary evidence. Sequence-to-pair and pair-to-sequence communication is bidirectional in every block.

The geometric core is invariant point attention. Each residue carries a frame of rotation and translation alongside its scalar features. Attention is computed in the local frame of the query residue, so the operation is equivariant to global rotation and translation, and it acts on both the scalar features and the three-dimensional points attached to each residue. This is what allows the network to reason about chirality, which matters for the handedness of helices and for the placement of side chains.

The structure module emits a residue frame and a side-chain torsion angle for each residue, using a residue gas representation in which the backbone is a rigid body and the side chain is described by chi angles. The structure module is run a fixed number of times, and between iterations the network feeds the current structure back in a step called recycling, which lets the prediction be refined by a recurrent process rather than committed in a single pass. The training objective is a combination of a frame-aligned point error term, which compares predicted and true frames in the local coordinate system, and an error on side-chain torsions.

Physical realism is restored after the network runs. A relaxation step applies the Amber force field with OpenMM to the predicted structure, which corrects bond lengths, bond angles and steric clashes. The paper is explicit that this relaxation does not improve the accuracy metrics, neither GDT nor lDDT-C-alpha, and that its purpose is to remove stereochemical violations so that the output can be inspected by structural biologists and fed to downstream tools.

The multimer system replaces the single chain with a set of chains. Each chain keeps its own MSA, the pairwise track is extended to cover cross-chain residue pairs, and a pair representation is added that encodes the stoichiometry and relative arrangement of the chains. The ranking that selects the final model uses a combination of pTM and ipTM, where ipTM scores the interface separately from the overall fold.

3. Scope and Assumptions

The operating system is fixed by the README. AlphaFold requires Linux, and the container toolkit for NVIDIA GPUs is a prerequisite. The full installation needs up to 3 TB of disk space for the genetic databases, with SSD storage recommended because the MSA tools are I/O bound.

The database footprint is the dominant practical constraint. The download script fetches roughly 556 GB compressed and roughly 2.62 TB after decompression. The breakdown is BFD at about 1.8 TB, the reduced small BFD at about 17 GB, MGnify at about 120 GB, pdb_mmcif at about 238 GB with approximately 199000 cif files, pdb70 at about 56 GB, pdb_seqres at about 0.2 GB, UniProt at about 105 GB, UniRef30 at about 206 GB and UniRef90 at about 67 GB, plus roughly 5.3 GB of parameters. Two presets trade this off. The reduced_dbs preset runs against the reduced BFD and needs 8 vCPU, 8 GB of RAM and 600 GB of disk, while full_dbs uses every database that was used at CASP14.

The model presets encode different compromises. The monomer preset is the original CASP14 model without ensembling. The monomer_casp14 preset adds num_ensemble of 8 to reproduce the CASP14 configuration exactly, at 8 times the computational cost for an average GDT gain of about 0.1 on CASP14 domains, so the README presents it mainly for reproducibility. The monomer_ptm preset is the CASP14 model fine-tuned with a pTM head, giving a pairwise confidence measure at slightly reduced accuracy. The multimer preset handles complexes and additionally requires the UniProt database.

Inputs and templates are dated. The example commands pass --max_template_date, with 2021-11-01 in the monomer examples and 2020-05-14 in the multimer example, so the template content is pinned to a cutoff and the results are reproducible against a fixed template set. The README also states that the exact database versions used at CASP14 are not provided, which means a fresh run reproduces the method but not the exact CASP14 numbers.

A stricter assumption governs training data. The released weights were trained on structures released before 30 April 2018, a cutoff chosen to coincide with the start of CASP13. The v2.3.0 technical note, updated on 11 March 2026, describes newly fine-tuned AlphaFold-Multimer weights using an identical architecture but a cutoff of 30 September 2021, which adds roughly 30 percent more training data, four times as many electron microscopy structures and twice as many large structures above 2000 residues, and it raises the training crop from 384 to 640 residues. The multimer configuration raises training chains from 8 to 20 and the maximum MSA sequences from 1152 to 2048 in 3 of the 5 multimer models.

4. Getting Started

The documented path is Docker, and the README states that the simplest way to run AlphaFold is the provided Docker script. The reference machine used for testing was a Google Cloud instance with the nvidia-gpu-cloud-image, 12 vCPUs, 85 GB of RAM, a 100 GB boot disk, the databases on an additional 3 TB disk and one A100 GPU. Installation proceeds through the Docker build, then the download script, then the run.

Data preparation is a single script. Running scripts/download_all_data.sh with the download directory as the argument fetches the full databases, while adding the reduced_dbs argument fetches the reduced set that pairs with the corresponding database preset at run time. The README warns that the database directory must not be a subdirectory of the repository, because the Docker build would then copy the databases into the image and become very slow, and it warns that missing read and write permissions produce opaque errors from the MSA tools, with chmod 755 recommended over the download directory.

Inference is driven by docker/run_docker.py. A monomer run passes a single-sequence FASTA, --model_preset=monomer, --db_preset, --data_dir and --output_dir, and the README gives worked examples for a monomer, a homomer with three identical chains, a heteromer with an A2B3 stoichiometry and folding several monomers in sequence. For complexes the multimer preset is used together with a multi-sequence FASTA. The --max_template_date flag pins the template cutoff.

Two database presets control the speed and quality tradeoff. The reduced_dbs preset optimizes for speed and lower hardware requirements, running against the reduced BFD with 8 vCPU, 8 GB of RAM and 600 GB of disk, while full_dbs runs with all genetic databases used at CASP14. The GPU device selection is controlled by --gpu_devices, which accepts a comma-separated list of GPU UUIDs or indices, and by default the system attempts to use all visible devices.

Output handling has its own options. By default only the best model by pLDDT is relaxed, and --models_to_relax accepts best, all or none. Relaxation runs on the GPU by default through --enable_gpu_relax=true, with CPU relaxation described as slower but more stable. The --use_precomputed_msas=true option reuses alignments for the same sequence across runs, which saves the search cost when only the model parameters change.

The multimer defaults produce a large output. Each model runs 5 seeds by default, giving 25 predictions in total, and --num_multimer_predictions_per_model=1 reduces this to one seed per model at a small drop in accuracy. The output directory contains ranked_0 through ranked_4 PDB files, relaxed_model files, a ranking_debug.json with the pTM and ipTM scores of each prediction, relax_metrics.json with the geometry statistics of the relaxed structure, timings.json with the measured runtimes, features.pkl and result_model files with the raw network outputs, and the msas directory with the alignments that were used.

The server component exists as well. The repository ships a server directory for running the same pipeline behind a request interface, and AlphaFold Server at alphafoldserver.com provides a hosted version for non-commercial use with a more limited set of ligands and covalent modifications, which is the route most people take when a single prediction suffices.

5. Comparison with Alternatives

The closest open alternatives are the other CASP14 systems. RoseTTAFold, published in Science in 2021 by the Baker laboratory at the University of Washington, uses a three-track network that updates a one-dimensional sequence track, a two-dimensional distance track and a three-dimensional coordinate track simultaneously, and it performed strongly on the same assessment. Its distinguishing feature is the explicit distance prediction track, which is interpretable and was used to design the RoseTTAFold filter for binding-site prediction. The AlphaFold lineage uses an explicit pair representation with invariant point attention, which is more expressive for the geometry of the backbone and the side chain.

OpenFold is a faithful and trainable PyTorch reproduction of this system, developed at Columbia University, and it is covered separately in this collection. Where the official repository publishes inference code only, OpenFold publishes the training code as well, together with the OpenProteinSet sequence database. That difference in scope, inference only against trainable, is the practical dividing line for research groups that need to fine-tune or to retrain.

Physics-based methods occupy a different position. Classical approaches such as comparative modelling, fold recognition and fragment assembly remained part of the CASP pipeline and are still relevant for cases where the evolutionary signal is weak or where experimental constraints such as restraints from small-molecule binding must be satisfied exactly. The AlphaFold approach replaces the search over conformations with a learned prior over protein structure space, which is a fundamentally different source of generalisation.

AF-Multimer and the later AlphaFold 3 change the comparison for complexes. The Multimer preprint "Protein complex prediction with AlphaFold-Multimer", posted on bioRxiv on 4 October 2021 with DOI 10.1101/2021.10.04.463034, reports that a model trained specifically for multimeric inputs of known stoichiometry increases interface accuracy substantially over the input-adapted single-chain system while keeping intra-chain accuracy high, evaluated on a benchmark of 17 heterodimer proteins without templates. AlphaFold 3 goes further in the types of interaction it models.

Against experimental determination the comparison is about speed and coverage. X-ray crystallography and cryo-electron microscopy remain the reference methods, and AlphaFold does not replace either. The paper is careful on this point, noting that the number of experimentally determined structures is on the order of 100000 unique proteins, a small fraction of the billions of known sequences, and that the two approaches are complementary.

6. Benchmarks and Evidence

The headline number is from CASP14. AlphaFold reached a median backbone accuracy of 0.96 Angstrom r.m.s.d. at 95 percent residue coverage, with a 95 percent confidence interval of 0.85 to 1.16 Angstrom, while the next best performing method gave 2.8 Angstrom with a 95 percent confidence interval of 2.7 to 4.0 Angstrom, measured on CASP domains. The paper reports this as the first time the accuracy of experimental structures was matched on a blind assessment.

The ablation study isolates what the databases contribute. Removing BFD reduced mean accuracy by 0.4 GDT, removing MGnify reduced it by 0.7 GDT, and removing both reduced it by 6.1 GDT. The pattern shows that the paired large databases carry most of the signal, which is the central reason full installation costs terabytes of storage.

The paper also reports that the depth of the alignment matters, with a threshold around 30 sequences needed before the network gains useful signal, and that the number of recycling iterations has a diminishing effect beyond a few rounds. The structure module and the invariant point attention are both necessary for the reported accuracy, and the paper presents the corresponding ablations for each.

Runtime figures come from the repository README rather than the paper, and the conditions matter. The table measures unrelaxed structure prediction with three recycles while excluding the runtime of MSA and template search, on a single A100 GPU. Times are 4.9 seconds for 100 residues, 7.7 seconds for 200, 13 seconds for 300, 18 seconds for 400, 29 seconds for 500, 36 for 600, 53 for 700, 60 for 800, 91 for 900, 96 seconds for 1000, 140 for 1100, 280 for 1500, 450 for 2000, 969 for 2500, 1240 for 3000, 2465 for 3500, 5660 for 4000, 12475 for 4500 and 18824 seconds for 5000 residues. The scaling is therefore close to quadratic in the sequence length above a thousand residues, and the MSA search cost sits outside these numbers entirely.

The CASP15 archive ships with the repository at docs/casp15_predictions.zip, so the CASP15-era performance of the system can be checked directly against the released files. The technical note also records that for the CASP15 baseline the team used a more expensive inference setting than the default, raising the number of seeds per model to 20 and the maximum number of recyclings to 20 with early stopping, and that the same setting is recommended for very large or difficult targets while remaining off by default because of the computational time.

7. Role in Physics-AI Workflows

AlphaFold serves a specific role in a computational physics workflow, and it is worth being precise about which one. Its output is a structural prior, not a physical simulation result. For molecular simulation the structure is the initial condition, and the accuracy of the structure sets the ceiling on how faithful any downstream simulation can be. This is the same division of labour that a machine-learned interatomic potential plays in the force calculation, and the two approaches compose naturally.

The same structural prior enters materials work. A predicted fold can seed a binding pocket hypothesis, define a construct for a mutational scan, or provide the geometry for a coarse-grained representation. In workflows built around general-purpose machine learning potentials, such as the universal interatomic potentials covered in this collection, an accurate apo structure removes a recurring source of setup friction in preparing simulation systems.

The pattern of sampling, filtering and re-ranking transfers directly. AlphaFold produces an ensemble of candidate structures with confidence scores attached, the same three-stage structure that many physics AI pipelines use, where a generative or surrogate model proposes candidates, a cheap filter removes the implausible ones and an expensive simulation confirms the survivors. The pLDDT and PAE outputs map onto the confidence and uncertainty channels that such pipelines already carry.

There is a deeper methodological parallel worth naming. The system learns a prior over a physically meaningful object, in this case the conformational space of proteins, from a database that spans both the physics and the evolutionary history of the object. This is the same idea as learning a prior over solution fields for a partial differential equation from simulation data, with the additional twist that the training set contains measurements rather than simulations. The transferable lesson is about data curation, since the quality of the learned prior depends on how carefully the training set is assembled, deduplicated and date-cut, and the CASP14 reproducibility note in the README is a concrete instance of that discipline.

8. Limitations and Failure Modes

The most consequential limitation is stated by the project itself. The README disclaimer says that AlphaFold 2 and its output are for theoretical modelling only, that they are not intended, validated or approved for clinical use, and that the outputs are predictions with varying levels of confidence that should be interpreted carefully. Any workflow that consumes these structures in a regulated context inherits this boundary.

Confidence is per-residue and can be read off the output directly, since the pLDDT value is written into the B-factor field of the PDB file. Low pLDDT regions mark disordered segments, flexible loops and regions whose evolutionary signal is weak, and they are a signal about the input rather than a defect of the model. The expected aligned error gives the pairwise version of the same information, indicating which residue pairs are well determined relative to each other.

Multi-domain and dynamic proteins are harder. The network was trained on crops of up to 640 residues, so very large assemblies fall outside the training distribution, and the multimer models were trained on up to 20 chains with an MSA cap of 2048 sequences. Proteins with intrinsically disordered regions, with large conformational changes between states, or with strong quaternary rearrangement can produce confident-looking but wrong global arrangements.

The inference cost grows steeply. The README table reaches 18824 seconds for 5000 residues on one A100, and this excludes the MSA and template search, which for a full database installation dominate the wall-clock time of a fresh run. Practical batch processing of a proteome therefore requires either the reduced database preset, precomputed alignments, or the hosted server.

The evolutionary assumption is the deepest structural limit. The method infers structure from the statistical coupling between residues across a sequence family, so a protein with no close relatives and no usable template has little to work with, and a protein whose fold has shifted during evolution carries a different coupling pattern. The paper is candid that the coverage of experimentally determined structures is a tiny fraction of known sequences, so the training data has a long tail of underrepresented sequence space.

Reliability of the confidence estimate itself is a research topic. The pLDDT and PAE outputs are calibrated against the training distribution, and their behaviour on out-of-distribution inputs, such as designed proteins or heavily engineered constructs, has weaker empirical support than the headline benchmarks suggest.

The installation path carries its own fragility. The README documents opaque errors from the MSA tools when permissions are missing, a requirement for up to 3 TB of storage, a Linux-only environment, and the need for the NVIDIA container toolkit. The repository carried 311 open issues at the time of verification, including reports of MSA download errors, of insufficient memory on consumer GPUs, of compatibility problems with recent NVIDIA architectures and of missing training code, all of which are community reports that deserve independent checking during reproduction.

9. Version and Source Notes

Several versions coexist and each is a distinct artefact. The model weights are distributed as alphafold_params_2022-12-06.tar, which contains 5 CASP14 models, 5 pTM models and 5 AlphaFold-Multimer models plus a licence file, 16 files in total. Older weight sets remain reachable: alphafold_params_2022-03-02.tar for the deprecated v2.2.0 multimer weights and alphafold_params_2022-01-19.tar for the deprecated v2.1.0 weights, each requiring an edit to the SOURCE_URL in the download script and a corresponding change to the model preset name in config.py.

The technical note carries the version history. The file docs/technical_note_v2.3.0.md was updated on 11 March 2026 and describes the v2.3.0 release, which keeps the v2 architecture and the training methodology unchanged while moving the cutoff to 30 September 2021 and enlarging the training crops, chain count and MSA depth. An earlier version of the note records a change in the self-distillation filtering, from clusters with more than 10 sequences to more than 2 sequences.

Naming has drifted across the project and needs care. The code and the paper use AlphaFold2 for the original system, the repository directory and the weight files use AlphaFold without a number, the README discusses model presets rather than numbered releases, and the successor system carries the explicit name AlphaFold 3 in its own repository and paper. A citation should name the specific artefact being used.

The measurement conditions for the speed table are explicit and are easily misquoted. The figures cover unrelaxed prediction with three recycles, exclude MSA and template search, and come from a single A100. The separate statement about eight-fold ensemble cost refers to the monomer_casp14 preset and the roughly 0.1 average GDT gain on CASP14 domains, and it should not be read as a general ensemble benefit.

The template date in the example commands is a reproducibility control rather than a default, and the two examples use different values, 2021-11-01 for monomers and 2020-05-14 for the multimer example. The README further states that the exact database versions used at CASP14 are not provided, so a rerun reproduces the method and its behaviour, not the exact historical numbers.

The database licences are separate from the code licence. Code is Apache 2.0, parameters and CASP15 prediction data are CC BY 4.0, BFD and UniRef30 are CC BY-SA 4.0 and MGnify is CC0 1.0, and the README notes that the database versions available are newer mirrors, with MGnify at the May 2022 release and UniRef30 at the March 2021 release.

Finally, the two successors have different weight access. AlphaFold 3 weights are downloaded from a Google storage bucket and may only be used if received directly from Google, under the terms-of-use document in that repository, and a SynthID-watermarked variant and a leaving-atom variant are published separately. AlphaFold 2 parameters remain freely downloadable under CC BY 4.0.

10. References

  1. Jumper J, Evans R, Pritzel A, et al. Highly accurate protein structure prediction with AlphaFold. Nature, volume 596, pages 583 to 589, 15 July 2021. DOI 10.1038/s41586-021-03819-2. CC BY 4.0.
  2. Official AlphaFold repository at https://github.com/google-deepmind/alphafold , with model, data, relax, docker and server subdirectories.
  3. AlphaFold technical note v2.3.0 at docs/technical_note_v2.3.0.md in the repository, updated 11 March 2026.
  4. Evans R, O'Neill M, Pritzel A, et al. Protein complex prediction with AlphaFold-Multimer. bioRxiv, 4 October 2021. DOI 10.1101/2021.10.04.463034.
  5. Abramson J, Adler J, Dunger J, et al. Accurate structure prediction of biomolecular interactions with AlphaFold 3. Nature, volume 630, pages 493 to 500, 8 May 2024. DOI 10.1038/s41586-024-07487-w.
  6. AlphaFold 3 repository at https://github.com/google-deepmind/alphafold3 , with the model weights terms-of-use document.
  7. Varadi M, Anyango P, Jin M, et al. AlphaFold Protein Structure Database: massively expanding the structural coverage of protein-sequence space with high-accuracy models. Nucleic Acids Research, 2022. DOI 10.1093/nar/gkab1061. CC BY 4.0.
  8. Bertoni D, Tsenkov M, Magana P, et al. AlphaFold Protein Structure Database 2025: a redesigned interface and updated structural coverage. Nucleic Acids Research, 2026. DOI 10.1093/nar/gkaf1226. CC BY 4.0.
  9. AlphaFold Server at https://alphafoldserver.com , the hosted non-commercial prediction service.
  10. Steinegger M, Söding J. Protein homology clustering with MMseqs2. Nature Biotechnology, volume 35, pages 539 to 542, 2017.
  11. Mirdita M, et al. UniRef30: a unified and consistent reference for sequence comparison and search. bioRxiv, 2021.
  12. Mitchell AL, et al. MGnify: the microbiome sequence data analysis resource. Nucleic Acids Research, volume 49, 2021. CC0 1.0.
  13. Eastman P, et al. OpenMM 7: rapid development of high performance algorithms for molecular dynamics. PLoS Computational Biology, volume 13, 2017.
  14. Maier JA, et al. ff14SB: improving the accuracy of protein side chain and backbone parameters from ff99SB. Journal of Chemical Theory and Computation, volume 11, pages 3696 to 3713, 2015.
  15. RoseTTAFold paper, Science, 2021, DOI 10.1126/science.abj8754, the three-track network comparison.
  16. Ahdritz G, Bouatta J, Floristean C, et al. OpenFold: retraining AlphaFold2 yields new insights into its learning mechanisms and capacity for generalization. bioRxiv, 4 October 2022. DOI 10.1101/2022.11.20.517210.
Tags: