Pick by input and by what you need to do with the model, not by a leaderboard. ESMFold (Lin et al., Science 2023), RoseTTAFold (Baek et al., Science 2021) and OpenFold (Ahdritz et al., Nature Methods 2024) are the open structure predictors people most often weigh against AlphaFold2 (Jumper et al., Nature 2021). ESMFold folds from one sequence and skips the alignment search, so it is the fast option and the only one of the three that works when there are no homologs to align. RoseTTAFold uses an alignment and a three-track network, and it was built to model complexes from sequence. OpenFold is a faithful, trainable PyTorch reproduction of AlphaFold2: same accuracy, faster inference, and the one you choose when you need to retrain the model itself. On typical proteins their reported accuracies sit close together. The differences that decide a project are input requirements, runtime, complexes and licence.
The honest framing for this page: .bloom* runs ESMFold as a job, and it looks up stored AlphaFold DB models by UniProt accession. RoseTTAFold and OpenFold are not offered on .bloom*. Everything below about them describes external packages you would install and run yourself, which is often the right call.
At a Glance#
| Aspect | ESMFold | RoseTTAFold | OpenFold |
|---|---|---|---|
| What it is | Folding head on the ESM-2 protein language model | Three-track network (1D sequence, 2D distance, 3D coordinates) | Trainable PyTorch reproduction of AlphaFold2 |
| Needs an MSA | No, single sequence | Yes, plus a template search | Yes, as AlphaFold2 does |
| Reported accuracy | TM-score 0.83 (CAMEO), 0.68 (CASP14) | TM-score 0.82 (CAMEO, as reported in the ESMFold paper) | Matches AlphaFold2; 0.902 lDDT-Cα on its CAMEO validation set |
| Reported speed | 14.2 s for 384 residues on one V100, no search step | ~1.5 h search, then ~10 min network for < 400 residues | 3–5× faster than AlphaFold2 for most proteins |
| Complexes | No; trained on single chains | Yes, from sequence; All-Atom variant adds ligands and nucleic acids | Lower memory fits very long proteins and complexes on one GPU |
| Retrainable | Not the design goal | Not the design goal | Yes, that is its purpose |
| Code / weights licence | MIT (repository) | Code MIT; weights non-commercial (Rosetta-DL licence) | Code Apache 2.0; AlphaFold2 parameters CC BY 4.0 |
| Runs on .bloom* | Yes, as esmfold_predict | No, run it yourself | No, run it yourself |
The accuracy row mixes test sets and eras, so read it as an order of magnitude, not a ranking. The only same-benchmark comparison among the three is the ESMFold paper's CAMEO table, covered below.
How Each One Works#
ESMFold: the language model stands in for the alignment#
AlphaFold2 and RoseTTAFold learn co-evolution from a multiple sequence alignment (MSA) built at prediction time. ESMFold moves that work into training. Its trunk reads embeddings from ESM-2, a protein language model trained on masked-residue prediction across millions of sequences, and a folding head turns those embeddings into atomic coordinates. The ESMFold authors scaled ESM-2 from 8 million to 15 billion parameters and report that structure accuracy improves with scale, and that it tracks how well the language model understands a given sequence, measured as perplexity (Lin et al. 2023).
That coupling is the main thing to remember about ESMFold. On a sequence the language model finds unsurprising, the prediction comes close to AlphaFold2. On a sequence it finds surprising, accuracy drops, and there is no alignment to fall back on.
RoseTTAFold: three tracks, one network#
RoseTTAFold passes information back and forth between three representations: the 1D sequence, the 2D map of residue–residue distances, and the 3D coordinates. Its authors explored several architectures inspired by AlphaFold2's CASP14 results and found the three-track design performed best. They report accuracy approaching DeepMind's in CASP14 (Baek et al. 2021). It takes an MSA and templates as input, like AlphaFold2.
Because chains are modelled in the context of each other, the same network can produce protein–protein complex models directly from sequence, instead of predicting each subunit and then docking them. The follow-up, RoseTTAFold All-Atom, adds an atomic representation for everything that is not an amino acid or a DNA base. That lets it model assemblies with nucleic acids, small molecules, metals and covalent modifications (Krishna et al., Science 2024).
OpenFold: AlphaFold2 you can retrain#
OpenFold is not a new architecture. It is a faithful, trainable PyTorch reproduction of AlphaFold2. DeepMind's release did not include the code and data needed to train new models, and OpenFold was built to fill that gap. Its authors trained it from scratch and report matching AlphaFold2's accuracy. They then used it to study how the model learns and how well it generalises (Ahdritz et al. 2024). At inference it takes the same inputs as AlphaFold2, MSA included, and it can load either its own trained weights or AlphaFold2's parameters.
Accuracy: What the Papers Actually Measured#
The three papers did not run one shared benchmark, so the numbers are not interchangeable. Here is what each one measured, on what.
| Source and test set | ESMFold | RoseTTAFold | AlphaFold2 | OpenFold |
|---|---|---|---|---|
| ESMFold paper, CAMEO, 194 structures (Apr–Jun 2022), TM-score | 0.83 | 0.82 | 0.88 | not evaluated |
| ESMFold paper, CASP14, 51 structures, TM-score | 0.68 | not reported here | 0.85 | not evaluated |
| OpenFold paper, CAMEO validation (~200 structures), lDDT-Cα | not evaluated | not evaluated | concordant with OpenFold | 0.902 (full training) |
ESMFold. The authors compared ESMFold with AlphaFold2 and RoseTTAFold on CAMEO and CASP14, using held-out structures the models had not been trained on (preprint full text). ESMFold is competitive with RoseTTAFold on CAMEO and trails AlphaFold2, with the gap widest on the harder CASP14 targets. Two further results matter in practice:
- Confidence is informative. For predictions with pLDDT above 0.7, the authors report ESMFold LDDT of 0.83 against AlphaFold2's 0.85 on CAMEO. A confident ESMFold model is close to what AlphaFold2 would give you.
- Without an alignment, the others degrade. When the authors ran AlphaFold2 and RoseTTAFold on single sequences with the MSA removed, performance fell well below ESMFold's. They note this is an artificial setting, because neither model was trained for it.
RoseTTAFold. RoseTTAFold was scored blind on CAMEO from 15 May 2021. Over the 69 medium and hard targets released in its first five weeks there, its authors report that it outperformed every other server evaluated, including Robetta, IntFold6-TS and SWISS-MODEL (Baek et al. 2021). AlphaFold2 was not one of those servers, so this result does not rank RoseTTAFold against AlphaFold2.
OpenFold. The OpenFold authors report very high concordance with AlphaFold2 in lDDT-Cα on about 200 CAMEO validation structures. A model trained to completion reached 0.902 on that set. The data-ablation results are the paper's distinctive contribution. Trained on 10,000 protein chains, about 7.6% of the training data, OpenFold reached essentially the same early accuracy as the full-data model. Even 1,000 chains gave 0.64 lDDT-Cα, above the 0.62 median the first AlphaFold achieved at CASP13 (Ahdritz et al. 2024).
The reading across all three: on typical, well-represented proteins, all three land close to AlphaFold2. The clearest gap in these papers is ESMFold against AlphaFold2 on the hard CASP14 targets. How close a predicted model gets to an experimental structure, and how to read pLDDT against resolution, is covered in predicted structure vs X-ray vs cryo-EM.
Speed and Compute#
Runtime is where the three differ most, and most of the difference is the alignment search, not the network.
| Step | ESMFold | RoseTTAFold | OpenFold |
|---|---|---|---|
| Sequence / template search | None | ~1.5 h reported | Required, as for AlphaFold2 |
| Network, one chain | 14.2 s for 384 residues on one V100 | ~10 min on an RTX 2080 for < 400 residues | 3–5× faster than AlphaFold2 for most proteins |
| Complex from sequence | Not supported | ~30 min on a 24 GB TITAN RTX | Fits on one GPU thanks to lower memory use |
- ESMFold reports a 384-residue prediction in 14.2 seconds on one NVIDIA V100, about six times faster than a single AlphaFold2 model, rising to about 60 times on short sequences. The authors add that the MSA search they skip can take over 10 minutes with the high-sensitivity pipelines AlphaFold2 and RoseTTAFold use, so the end-to-end speed-up is larger than the network numbers alone (preprint full text).
- RoseTTAFold's authors report about 1.5 hours of sequence and template search, then about 10 minutes on an RTX 2080 GPU for backbone coordinates of a protein under 400 residues with the end-to-end version. The pyRosetta version needs about 5 minutes of GPU time plus about an hour on 15 CPU cores for all-atom models (Baek et al. 2021).
- OpenFold keeps the alignment step but reports a network three to five times faster than AlphaFold2 for most proteins, with lower memory use. It is also written in PyTorch rather than AlphaFold2's JAX (Ahdritz et al. 2024).
These are the authors' own hardware and timings. Re-measure them on yours before you plan a large batch.
When to Use Each#
Use ESMFold when#
- You have many sequences and want structures quickly, for triage, screening designed variants, or a first look at a target.
- The sequence has few or no homologs, so an alignment would be thin or empty: designed proteins, metagenomic sequences, orphan proteins.
- You want one tool with no database dependencies. There are no sequence databases to download and keep current.
Use RoseTTAFold when#
- You need a complex modelled from sequence and want the chains predicted together rather than docked afterwards.
- You need ligands, nucleic acids, metals or covalent modifications in the model. That is the RoseTTAFold All-Atom variant.
- Your use is non-commercial, or you have cleared the Rosetta-DL weights licence. The code is MIT, but the trained weights are licensed for non-commercial use only.
Use OpenFold when#
- You need AlphaFold2-level accuracy and you will run it on your own GPUs, where its faster, lower-memory inference saves real time.
- You need to retrain or fine-tune: a new task, a specialised protein family, or a study of what the model learns. Retraining is the reason OpenFold exists.
- You want a permissive licence. OpenFold's code is Apache 2.0, and the AlphaFold2 parameters it can load are CC BY 4.0.
Use none of them when#
- The protein is already in the AlphaFold Protein Structure Database. Look up the stored model instead of re-predicting it.
- An experimental structure of your construct exists. Download it.
For the narrower ESMFold-versus-AlphaFold2 decision, see ESMFold vs AlphaFold2.
Limitations to Keep in View#
- The benchmarks are not head-to-head. Only the ESMFold paper scores more than one of these predictors on the same set, and it predates OpenFold's publication. Different test sets, eras and metrics (TM-score, lDDT-Cα) can't be lined up into one ranking.
- pLDDT is local. A model can be confident in every domain and still place two domains wrongly relative to each other. You need a pairwise error estimate (PAE) or an experimental structure to judge domain placement.
- ESMFold accuracy follows the language model. Sequences the language model finds surprising tend to fold worse, and those are often the novel sequences you most wanted a structure for. Treat low pLDDT on a designed or orphan sequence as an answer, not a nuisance.
- One sequence in, one conformation out. All three return a single static model. Alternative conformations, induced fit and disordered regions are not represented faithfully. A confident model is not a description of dynamics.
- A model is not a measurement. None of these predictors replaces an experimental structure for decisions that hinge on the exact position of a few side chains, such as a binding-site hypothesis. Check those against a deposited structure, or treat them as hypotheses to test.
How to Run It on .bloom*#
Of the three, .bloom* runs ESMFold. RoseTTAFold and OpenFold are not offered on .bloom*, so if your project needs complexes from RoseTTAFold or a retrained OpenFold, run those in your own environment and bring the PDB back.
Ask Ivy for a structure in plain words, by sequence or by UniProt accession, and it plans the run and picks the lookup or the prediction that fits (how orchestration works). Or call the tool directly:
- Input.
esmfold_predicttakes one protein sequence of 10 to 2,500 residues in the 20 standard amino-acid letters, with no FASTA header, or a UniProt accession. The optionalnum_recyclesruns from 1 to 10 and defaults to 3. Lengths, composition and the other options are in the ESMFold inputs reference. - Lookup before prediction. Given an accession, the tool checks AlphaFold DB first by default. When a stored model exists, you get that model and no GPU run happens. Set
try_alphafold_firstto false to force a fresh ESMFold prediction, for instance to compare the two models of one protein. The stored model and its PAE come from the AlphaFold DB lookup. - Output. You get a PDB file with per-residue pLDDT, the mean pLDDT and a predicted TM-score, and a structure preview coloured by confidence. ESMFold on .bloom* returns no PAE matrix, so judge domain placement from the AlphaFold DB entry or a deposited structure from the PDB.
- Runtime and access. It runs as a GPU job and usually returns in seconds to about a minute, depending on length. ESMFold runs without an account.
- Next steps. Feed the PDB into pocket detection with P2Rank. For a complex, use Boltz-2, which predicts multi-chain and protein–ligand structures and needs a signed-in account.
What you leave with is a PDB you can open in any viewer and a per-residue confidence profile that tells you which parts of it to trust. How ESMFold results have held up against experimental structures, with citations, is in how ESMFold results compare to the bench.
Key Takeaways#
- Accuracy is close on typical proteins. On the one shared benchmark, ESMFold and RoseTTAFold average TM-scores of 0.83 and 0.82 on CAMEO, with AlphaFold2 at 0.88. OpenFold reports parity with AlphaFold2.
- ESMFold trades accuracy on hard targets for speed and independence from alignments. It is the fast option, and the one to use when there is nothing to align.
- RoseTTAFold is the complex modeller of the three, and its All-Atom variant adds ligands, nucleic acids and metals. Its trained weights are for non-commercial use only.
- OpenFold is AlphaFold2 you can retrain, with faster, lower-memory inference and permissive licences on code and parameters.
- Read pLDDT as local confidence. It doesn't tell you how domains sit relative to each other, so use PAE or an experimental structure for that.
- Check the database first. If AlphaFold DB or the PDB already has the protein, a lookup beats a prediction.
Start with the cheapest answer that is good enough: a stored model if one exists, an ESMFold prediction if not. Fold your own sequences with ESMFold, with per-residue confidence on every model, on the .bloom* platform.
References#
- Lin, Z., Akin, H., Rao, R. et al. "Evolutionary-scale prediction of atomic-level protein structure with a language model." Science 379, 1123–1130 (2023). doi:10.1126/science.ade2574 · code: facebookresearch/esm
- Lin, Z., Akin, H., Rao, R. et al. "Evolutionary-scale prediction of atomic level protein structure with a language model." bioRxiv (2022). doi:10.1101/2022.07.20.500902
- Baek, M., DiMaio, F., Anishchenko, I. et al. "Accurate prediction of protein structures and interactions using a three-track neural network." Science 373, 871–876 (2021). doi:10.1126/science.abj8754 · code: RosettaCommons/RoseTTAFold
- Krishna, R., Wang, J., Ahern, W. et al. "Generalized biomolecular modeling and design with RoseTTAFold All-Atom." Science 384 (2024). doi:10.1126/science.adl2528 · code: baker-laboratory/RoseTTAFold-All-Atom
- Ahdritz, G., Bouatta, N., Floristean, C. et al. "OpenFold: retraining AlphaFold2 yields new insights into its learning mechanisms and capacity for generalization." Nature Methods 21, 1514–1524 (2024). doi:10.1038/s41592-024-02272-z · code: aqlaboratory/openfold
- Jumper, J., Evans, R., Pritzel, A. et al. "Highly accurate protein structure prediction with AlphaFold." Nature 596, 583–589 (2021). doi:10.1038/s41586-021-03819-2 · code: google-deepmind/alphafold