Self-Hosted Protein Structure Prediction: OpenFold vs ColabFold vs ESMFold

Introduction

Predicting a protein’s three-dimensional structure from its amino acid sequence has been one of biology’s grand challenges for over 50 years. The breakthrough of AlphaFold2 in 2020 fundamentally changed the field, achieving near-experimental accuracy in the CASP14 competition. Since then, a vibrant ecosystem of open-source alternatives has emerged, making protein structure prediction accessible to research labs without access to AlphaFold’s proprietary infrastructure.

Three leading self-hosted solutions stand out: OpenFold, a trainable PyTorch reproduction of AlphaFold2 with memory optimization; ColabFold, which dramatically accelerates prediction by coupling MMseqs2 for faster multiple sequence alignment; and ESMFold, Meta’s protein language model approach that predicts structures directly without MSA inputs.

Each tool takes a fundamentally different approach to the folding problem, offering unique trade-offs between speed, accuracy, and computational requirements. This guide compares them across deployment complexity, prediction quality, hardware requirements, and practical use cases.

Platform Overview

OpenFold is the most faithful open-source reproduction of AlphaFold2. Developed by a consortium of academic labs, it reproduces the complete AlphaFold2 architecture in PyTorch, including the Evoformer and Structure Module. Unlike AlphaFold’s original codebase, OpenFold is fully trainable — researchers can fine-tune the model on new protein families or retrain from scratch with modified architectures.

ColabFold prioritizes accessibility and speed. By replacing AlphaFold’s computationally expensive HMMer-based MSA generation with MMseqs2, it reduces the most time-consuming step from hours to minutes. ColabFold packages everything into a user-friendly Jupyter notebook interface and provides pre-built Docker containers. It’s the go-to choice for labs that need occasional predictions without managing complex infrastructure.

ESMFold represents a paradigm shift. Rather than using multiple sequence alignments, it uses a large protein language model (ESM-2 with 15 billion parameters) to predict structures directly from sequence. This eliminates the MSA bottleneck entirely, enabling predictions at metagenomic scale — millions of sequences per day.

Deployment and Installation

OpenFold Setup

OpenFold requires significant GPU resources. The minimum viable setup needs an NVIDIA GPU with 16GB+ VRAM:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# Clone repository
git clone https://github.com/aqlaboratory/openfold.git
cd openfold

# Create conda environment
conda env create -f environment.yml
conda activate openfold

# Install OpenFold
python setup.py install

# Download model weights and databases
scripts/download_alphafold_params.sh
scripts/download_openfold_params.sh
scripts/download_data.sh data/

# Run prediction
python run_pretrained_openfold.py     fasta_dir=path/to/fasta/files     output_dir=./predictions     data_dir=./data     model_device=cuda:0     config_preset=model_1

For production deployment, OpenFold benefits from a multi-GPU setup:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# openfold-docker-compose.yml
version: '3.8'
services:
  openfold:
    image: nvidia/cuda:12.1.0-runtime-ubuntu22.04
    runtime: nvidia
    environment:
      NVIDIA_VISIBLE_DEVICES: all
      NVIDIA_DRIVER_CAPABILITIES: compute,utility
    volumes:
      - ./openfold:/workspace/openfold
      - ./data:/data
      - ./predictions:/output
      - ./fasta:/input
    working_dir: /workspace/openfold
    command: >
      python run_pretrained_openfold.py
      fasta_dir=/input
      output_dir=/output
      data_dir=/data
      model_device=cuda:0
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]

Memory requirements scale with protein length: 16GB VRAM handles proteins up to ~800 residues; 24GB handles up to ~1,500 residues; 40GB (A100) handles up to ~2,500 residues.

ColabFold with Docker

ColabFold provides official Docker images, making it the most accessible option:

1
2
3
4
5
6
7
8

# Pull the official Docker image
docker pull ghcr.io/sokrypton/colabfold:latest

# Run prediction with GPU
docker run --gpus all     -v $(pwd)/input:/input     -v $(pwd)/output:/output     ghcr.io/sokrypton/colabfold:latest     colabfold_batch     /input/sequences.fasta     /output/     --num-recycle 3     --use-gpu-relax

# For CPU-only prediction (slower but works without GPU)
docker run     -v $(pwd)/input:/input     -v $(pwd)/output:/output     ghcr.io/sokrypton/colabfold:latest     colabfold_batch     /input/sequences.fasta     /output/     --cpu

ColabFold’s key configuration parameters:

1
2
3
4
5
6

colabfold_batch input.fasta output/     --num-recycle 3          # Recycling iterations (1-20, default 3)
    --use-gpu-relax          # Use GPU for energy minimization
    --num-models 5           # Number of model runs (1-5)
    --use-ambe               # Use Amber relaxation
    --zip                    # Compress output files
    --num-seeds 1            # Random seeds for diversity

For a production API service around ColabFold, deploy with localcolabfold:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

from colabfold.batch import get_queries, run
from colabfold.download import download_alphafold_params

# Download model params once
download_alphafold_params('path/to/params')

# Batch prediction
queries, is_complex = get_queries("input.fasta")
results = run(
    queries=queries,
    use_templates=False,
    use_amber=False,
    num_models=5,
    num_recycles=3,
    model_order=[1,2,3,4,5],
)

ESMFold Deployment

ESMFold’s advantage is its ability to run on CPU, though GPU provides dramatic speedup:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# Clone repository
git clone https://github.com/facebookresearch/esm.git
cd esm
pip install -e .

# Download model (15B parameter ESM-2)
python scripts/download_weights.py esm2_t36_3B_UR50D

# Predict structure
python scripts/fold.py     --input sequences.fasta     --output-dir ./predictions/     --model esm2_t36_3B_UR50D     --num-recycles 4

# For metagenomic-scale prediction (millions of sequences)
python scripts/fold.py     --input massive_dataset.fasta     --output-dir ./massive_predictions/     --model esm2_t36_3B_UR50D     --num-recycles 1     --chunk-size 128     --max-tokens-per-batch 1024

Docker Compose for ESMFold service:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

version: '3.8'
services:
  esmfold:
    image: pytorch/pytorch:2.1.0-cuda12.1-cudnn8-runtime
    runtime: nvidia
    environment:
      NVIDIA_VISIBLE_DEVICES: all
    volumes:
      - ./esm:/workspace/esm
      - ./models:/root/.cache/torch/hub/checkpoints
      - ./input:/input
      - ./output:/output
    working_dir: /workspace/esm
    command: >
      python scripts/fold.py
      --input /input/sequences.fasta
      --output-dir /output
      --model esm2_t36_3B_UR50D
      --num-recycles 4

Accuracy and Performance Comparison

CASP14 Benchmark Performance

On the CASP14 free-modeling targets (the hardest category):

OpenFold achieves the highest accuracy because it faithfully reproduces AlphaFold2’s complete pipeline including ensembling. ColabFold is virtually identical in quality for most targets while being 3-4x faster thanks to MMseqs2. ESMFold sacrifices some accuracy but gains orders-of-magnitude speed improvement by eliminating MSA dependency.

Scaling to Large Datasets

For large-scale prediction projects (thousands to millions of sequences), the tools diverge significantly:

1
2
3
4

# Processing 10,000 sequences comparison
# OpenFold: ~10,000 × 75 min = 12,500 GPU-hours (~$25,000 on cloud)
# ColabFold: ~10,000 × 14 min = 2,333 GPU-hours (~$4,700 on cloud)
# ESMFold: ~10,000 × 2 min = 333 GPU-hours (~$670 on cloud)

ESMFold’s speed advantage makes it the only practical choice for genome-scale prediction. Meta used ESMFold to predict structures for over 617 million metagenomic proteins in just two weeks — a feat impossible with MSA-based methods.

Why Self-Host Protein Structure Prediction?

Running protein structure prediction on your own infrastructure offers several advantages over cloud-based services like AlphaFold Database or commercial APIs. First, data privacy — many research projects involve proprietary sequences (therapeutic candidates, industrial enzymes) that cannot be uploaded to public servers. Second, batch processing economics — at scale (>1,000 sequences), self-hosted GPU infrastructure is significantly cheaper than per-prediction API pricing. Third, customization — OpenFold’s trainable architecture enables fine-tuning on specific protein families, membrane proteins, or antibody structures that general models may handle poorly.

For related computational biology tools, see our molecular dynamics simulation guide and protein-protein docking comparison. For chemical computation tools, check our cheminformatics platforms guide.

FAQ

Can I run these tools without a GPU?

ColabFold supports CPU-only prediction via the --cpu flag, though expect 10-50x slower performance. ESMFold can run on CPU for smaller models (ESM-2 650M parameters), but the 15B parameter model requires 64GB+ system RAM on CPU. OpenFold practically requires a GPU — CPU-only prediction of even a small protein takes days.

How accurate are these compared to the official AlphaFold2?

OpenFold reproduces AlphaFold2’s accuracy within 0.5% on standard benchmarks when using identical inputs. ColabFold achieves comparable accuracy (within 1-2%) because it uses the same neural network architecture — the speed improvement comes from faster MSA generation, not a simpler model. ESMFold is ~5-10% less accurate on challenging targets but excels on well-studied protein families.

Which tool should I use for antibody/nanobody prediction?

OpenFold is the best choice for antibodies because it supports fine-tuning. The standard AlphaFold2 architecture was trained primarily on soluble globular proteins and can struggle with CDR loops. OpenFold’s trainable design allows researchers to fine-tune on antibody structure databases (SAbDab), significantly improving CDR-H3 loop prediction accuracy. ColabFold and ESMFold use the standard weights and cannot be fine-tuned.

What’s the largest protein I can predict?

With a 24GB GPU (RTX 4090, A5000): OpenFold handles proteins up to ~1,500 residues; ColabFold handles up to ~2,000 residues (chunking helps); ESMFold handles up to ~1,200 residues (uses more memory per token). For larger proteins, use the --max-seq-len flag with chunking or run on A100 80GB GPUs which can handle 3,000+ residues.

Do I need to keep the large sequence databases on disk?

ColabFold’s MMseqs2 workflow queries databases remotely by default, eliminating the need for 2TB+ local databases. OpenFold requires local copies of BFD, Uniclust30, and PDB70 (approximately 2.5TB total). ESMFold requires no sequence databases at all — only the model weights (~7GB). Plan storage accordingly: OpenFold needs 3TB+, ColabFold needs 100GB (for models and results), ESMFold needs 50GB.

Can I build a web API around these tools?

Yes. Several labs have built REST APIs wrapping these tools. ColabFold’s localcolabfold Python package is the easiest to integrate. OpenFold provides a --api flag for serving predictions. For production APIs, consider the FastAPI boilerplate:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

from fastapi import FastAPI, UploadFile
from colabfold.batch import run, get_queries
app = FastAPI()

@app.post("/predict")
async def predict(file: UploadFile):
    content = await file.read()
    queries, _ = get_queries("input.fasta")
    results = run(queries, num_models=1, num_recycles=3)
    return {"pdb": results[0]['pdb']}

💰 想测试你的市场判断力？我用 Polymarket 做预测市场交易——这是全球最大的预测市场平台，从大选结果到技术监管时间线，什么都可以押注。和赌博不同，这是真正的信息市场：你懂的信息越多，胜率越高。我靠预测技术相关事件的走向已经赚了不少。用我的邀请链接注册：Polymarket.com