Install:

pip install requests bioservices

Usage:

import requests

# Fetch protein by accession
r = requests.get("https://rest.uniprot.org/uniprotkb/P00533.json")
data = r.json()
print(data["sequence"]["value"])

# Search by name/function
r = requests.get(
    "https://rest.uniprot.org/uniprotkb/search",
    params={"query": "EGFR AND reviewed:true", "format": "json", "size": 10}
)

Install:

pip install requests

Usage:

import requests

uniprot_id = "P00533"
r = requests.get(f"https://alphafold.ebi.ac.uk/api/prediction/{uniprot_id}")
entries = r.json()
# Download predicted structure
pdb_url = entries[0]["pdbUrl"]
pdb_data = requests.get(pdb_url).text
with open(f"{uniprot_id}_AF2.pdb","w") as f:
    f.write(pdb_data)

Install:

pip install pubchempy

Usage:

import pubchempy as pcp

# Search by name
compounds = pcp.get_compounds("aspirin", "name")
c = compounds[0]
print(c.canonical_smiles, c.molecular_weight, c.xlogp)

# Search by SMILES
compounds = pcp.get_compounds("CC(=O)Oc1ccccc1C(=O)O", "smiles")

# Get assay data
pcp.download("JSON", "aspirin_data.json", "aspirin", "name", record_type="3d")

Install:

pip install requests pandas

Usage:

import requests

# REST API - search by target
url = "https://bindingdb.org/axis2/services/BDBService/getLigandsByUniprots"
r = requests.get(url, params={"uniprot": "P00533", "response": "application/json"})
data = r.json()
# Bulk: download full tab-sep file from https://www.bindingdb.org/bind/chemsearch/marvin/Download.jsp

Install:

# Conda (recommended)
conda install -c conda-forge -c bioconda foldseek

# Or binary
wget https://mmseqs.com/foldseek/foldseek-linux-avx2.tar.gz
tar xvzf foldseek-linux-avx2.tar.gz
export PATH=$(pwd)/foldseek/bin/:$PATH

Usage:

# Build database from PDB files
foldseek createdb query_pdbs/ queryDB
foldseek createdb target_pdbs/ targetDB

# Search
foldseek easy-search query.pdb targetDB results.m8 tmpFolder

# Use web API
curl -X POST https://search.foldseek.com/api/ticket \
  -F "[email protected]" \
  -F "database[]=pdb100" -F "mode=3diaa"

Install:

conda install -c conda-forge -c bioconda mmseqs2
# or Docker:
docker pull ghcr.io/soedinglab/mmseqs2

Usage:

# Easy search (FASTA vs FASTA)
mmseqs easy-search query.fasta target.fasta result.m8 tmp --format-mode 4

# Easy cluster
mmseqs easy-cluster sequences.fasta clusterRes tmp --min-seq-id 0.9

# REST API (used by ColabFold for MSA generation)
curl -X POST https://api.mmseqs.com/ticket/msa \
  -d "q=>seq\nMKTVRQERLKSIVRI" -d "database[]=UniRef30_2302"

Install:

pip install biopython

Usage:

from Bio.Blast import NCBIWWW, NCBIXML

sequence = "MKTVRQERLKSIVRILERSKEPVSGAQLAEELS"
result_handle = NCBIWWW.qblast("blastp", "pdb", sequence)
blast_records = NCBIXML.parse(result_handle)
for record in blast_records:
    for alignment in record.alignments[:3]:
        print(alignment.title, alignment.hsps[0].score)

Install:

pip install requests pandas

Usage:

import requests, pandas as pd

# Get all nanobody structures
r = requests.get(
    "https://opig.stats.ox.ac.uk/webapps/sabdab-sabpred/sabdab/search/",
    params={"ABtype": "Nanobody", "resulttype": "json"}
)
df = pd.DataFrame(r.json()["result"])
# Download specific structure
pdb_id = df.iloc[0]["pdb"]
struct = requests.get(f"https://files.rcsb.org/download/{pdb_id}.pdb").text

Usage:

import requests
# Bulk unit downloads via OAS web interface; programmatic bulk via:
# https://opig.stats.ox.ac.uk/webapps/oas/api/bulk
r = requests.get(
    "https://opig.stats.ox.ac.uk/webapps/oas/api/",
    params={"species": "human", "chain": "Heavy", "isotype": "IgG"}
)
units = r.json()["units"]  # list of downloadable dataset units

Install:

conda install -c conda-forge biopython
conda install -c bioconda hmmer=3.3.2
pip install anarci

Usage:

# CLI
ANARCI -i EVQLVESGGGVVQPGGSLRLSCAASGFTFNSYGMHWVRQAPGKGLE --scheme imgt

# Python

from anarci import anarci
sequences = [("VHH1", "EVQLVESGGGVVQPGGSLRLSCAASGFTFNSYGMHWVRQAPGKGLE")]
results = anarci(sequences, scheme="imgt", output=True)

Install:

pip install pyir
pyir setup  # downloads IgBLAST databases

Usage:

from pyir.pyir import PyIR

p = PyIR(query="sequences.fasta", args=["--outfmt", "json"])
result = p.run()

Install:

pip install requests pandas

Usage:

import requests, pandas as pd

# Download full database as CSV
r = requests.get("https://opig.stats.ox.ac.uk/webapps/covabdab/covabdab/download/")
with open("covabdab.csv", "wb") as f:
    f.write(r.content)
df = pd.read_csv("covabdab.csv")

# Filter nanobodies binding Spike RBD
nb_rbd = df[(df["Ab or Nb"] == "Nb") & (df["Protein + Epitope"].str.contains("RBD", na=False))]
print(nb_rbd[["Name", "Heavy VDJ", "Neutralising Vs"]].head())

Usage:

# Download dataset from https://research.naturalantibody.com/nbthermo
# Used as training set for ML thermostability predictors:
import pandas as pd
df = pd.read_csv("nbthermo.csv")
# Columns: sequence, Tm, CDR_lengths, source

Install:

pip install requests

Usage:

import requests

# Text search
r = requests.get("https://rnacentral.org/api/v1/rna/", 
                 params={"search": "aptamer thrombin", "format": "json"})
data = r.json()
for entry in data["results"][:3]:
    print(entry["rnacentral_id"], entry["sequence"])

Install:

pip install requests
# Bulk downloads via FTP:
# ftp://ftp.ebi.ac.uk/pub/databases/Rfam

Usage:

import requests

# REST API — get family by accession
r = requests.get("https://rfam.org/family/RF00001", headers={"Accept": "application/json"})
print(r.json()["rfam"]["acc"], r.json()["rfam"]["id"])

# Search a sequence against all Rfam families
r = requests.post("https://rfam.org/search/sequence",
    data={"seq": "GCGGAUUUAGCUCAGUUGGGAGAGCGCCAGACUGAAGAUCUGGAGGUCCUGUGUUCGAUCCACAGAAUUCGCA"})
print(r.json())

# Infernal (Rfam's annotation tool) for local annotation:
# conda install -c bioconda infernal
# cmscan --rfam --cut_ga --nohmmonly Rfam.cm aptamer.fasta

Usage:

import requests

# Browse online or download dataset:
# http://lmmd.ecust.edu.cn/aptadb/download.php
# Columns: Aptamer_ID, Sequence, Target, Kd, Method, Source

import pandas as pd
df = pd.read_csv("AptaDB_sequences.csv")
rna_aptamers = df[df["Type"] == "RNA"]
print(rna_aptamers.head())

Usage:

# Web interface with filter and export options
# Download full dataset from: https://sites.utexas.edu/aptamerdatabase/download/
import pandas as pd
df = pd.read_csv("aptamer_database.csv")
thrombin = df[df["Target"].str.contains("thrombin", case=False, na=False)]
print(thrombin[["Name", "Sequence", "Kd"]])

Install:

git clone <repo_url>  # Repository not publicly available as of May 2026
pip install -r requirements.txt

Usage:

from aptabench import AptaBench

# Load standardized benchmark dataset
benchmark = AptaBench.load(task="binding_affinity", split="random")
train_seqs, train_labels = benchmark.get_train()
test_seqs, test_labels = benchmark.get_test()

# Evaluate a custom model
from aptabench.evaluator import BenchmarkEvaluator

evaluator = BenchmarkEvaluator(benchmark)
results = evaluator.evaluate(my_model_predictions)
print(results)  # RMSE, Pearson r, Spearman r vs. experimental affinities

Install:

pip install unimol-tools  # easy-use wrapper
# Full repo:
git clone https://github.com/dptech-corp/Uni-Mol.git
conda env create -f Uni-Mol/unimol/environment.yml

Usage:

from unimol_tools import MolTrain, MolPredict

# Property prediction
clf = MolTrain(task='classification', data_type='molecule',
               epochs=10, batch_size=16, metrics='auc')
clf.fit(data={'smiles': smiles_list, 'target': labels})

pred = MolPredict(load_model='./exp')
results = pred.predict(data={'smiles': test_smiles})

Install:

conda create -n chemprop python=3.11 && conda activate chemprop
pip install chemprop

Usage:

# CLI training
chemprop train --data-path data.csv --task-type regression --smiles-column smiles \
  --target-columns activity --save-dir checkpoints/

# CLI predict
chemprop predict --test-path test.csv --model-path checkpoints/ --preds-path preds.csv

# Python API
from chemprop import data, featurizers, models, nn
import lightning.pytorch as pl

mpnn = models.MPNN(nn.BondMessagePassing(), nn.MeanAggregation(), nn.RegressionFFN())
trainer = pl.Trainer(max_epochs=20)
# ... load DataModule and train

Install:

pip install transformers datasets torch

Usage:

from transformers import AutoTokenizer, AutoModel
import torch

tokenizer = AutoTokenizer.from_pretrained("seyonec/ChemBERTa-zinc-base-v1")
model = AutoModel.from_pretrained("seyonec/ChemBERTa-zinc-base-v1")

smiles = "CC(=O)Oc1ccccc1C(=O)O"
inputs = tokenizer(smiles, return_tensors="pt")
with torch.no_grad():
    outputs = model(**inputs)
embedding = outputs.last_hidden_state[:, 0, :]  # [CLS] token: (1, 768)

Install:

pip install molfeat
pip install "molfeat[all]"   # full extras including DGL, HuggingFace models

Usage:

from molfeat.calc import FPCalculator
from molfeat.trans import MoleculeTransformer

# Morgan fingerprints
calc = FPCalculator("ecfp")
transformer = MoleculeTransformer(calc)
fps = transformer.transform(["CC(=O)Oc1ccccc1C(=O)O", "c1ccccc1"])

# Use pretrained ChemBERTa embeddings
from molfeat.trans.pretrained import PretrainedHFTransformer
embedder = PretrainedHFTransformer(kind="ChemBERTa-77M-MLM", notation="smiles")
embs = embedder.transform(["CC(=O)Oc1ccccc1C(=O)O"])

Install:

git clone https://github.com/tencent-ailab/grover.git && cd grover
conda create -n grover python=3.7 && conda activate grover
pip install -r requirements.txt
# Download pretrained weights from the repo's README (grover_base.pt / grover_large.pt)

Usage:

# Fine-tune on a classification task (e.g., HIV actives)
python main.py finetune \
  --data_path data/hiv.csv \
  --dataset_type classification \
  --model_dir checkpoints/grover_base.pt \
  --save_dir finetune_output/

# Predict
python main.py predict \
  --data_path data/test.csv \
  --model_dir finetune_output/ \
  --preds_path preds.csv

Install:

pip install molbert
# or from source:
git clone https://github.com/BenevolentAI/MolBERT.git && cd MolBERT
pip install -e .

Usage:

from molbert.utils.featurizer.molbert_featurizer import MolBertFeaturizer

# Load pretrained model (downloads automatically)
featurizer = MolBertFeaturizer("bertseq_both", max_seq_len=512, embedding_type="average-1-cat-2")

smiles = ["CC(=O)Oc1ccccc1C(=O)O", "c1ccccc1"]
embeddings, masks = featurizer.transform(smiles)
print(embeddings.shape)  # (2, 768)

Install:

git clone https://github.com/gcorso/torsional-diffusion.git
conda env create -f environment.yml && conda activate torsional_diffusion

Usage:

python generate_confs.py --torsional_diffusion \
  --smiles "CC(=O)Oc1ccccc1C(=O)O" \
  --num_confs 10 \
  --out_file confs.sdf

Install:

git clone https://github.com/PattanaikL/GeoMol.git && cd GeoMol
conda env create -f environment.yml -n geomol && conda activate geomol

Usage:

from model.model import GeoMol
import torch

# Load pretrained checkpoint
model = GeoMol.load_from_checkpoint("trained_models/drugs/best_model.ckpt")
model.eval()

# Generate conformers for aspirin
from data.featurization import featurize_mol_from_smiles
data = featurize_mol_from_smiles("CC(=O)Oc1ccccc1C(=O)O", dataset="drugs")
with torch.no_grad():
    out = model(data, inference=True, n_model_confs=10)
# Returns torsion angles → use to reconstruct 3D coordinates via RDKit

Install:

git clone https://github.com/facebookresearch/all-atom-diffusion-transformer.git
pip install -e .

Usage:

# See Colab notebook for generation examples
# Generates diverse small molecules and materials via latent diffusion

Install:

# Download precompiled binary (Java 17+ required)
wget https://github.com/rdk/p2rank/releases/download/2.5/p2rank_2.5.tar.gz
tar -xzf p2rank_2.5.tar.gz

Usage:

# Predict binding sites on a PDB file
./prank predict -f protein.pdb

# Batch prediction
./prank predict -l proteins_list.txt -o output_dir/

# Output: protein.pdb_predictions.csv (pockets ranked by score)

Install:

conda install -c bioconda fpocket

Usage:

fpocket -f protein.pdb
# Outputs: protein_out/ directory with pocket PDBs and info file

# Parse results
import pandas as pd
df = pd.read_csv("protein_out/protein_info.txt", sep="\t")

Install:

git clone https://github.com/LBM-EPFL/PeSTo.git && cd PeSTo
conda env create -f pesto.yml && conda activate pesto

Usage:

python predict.py --pdb protein.pdb --output predictions.pdb
# Binding probabilities stored in B-factor column
# Visualize in PyMOL: spectrum b, blue_white_red, all, 0, 1

Install:

git clone https://github.com/LBM-EPFL/PeSTo-Carbs.git && cd PeSTo-Carbs
pip install -r requirements.txt

Usage:

python apply_model.py  # set model_path and data_path in script
# Outputs: <pdbid>_i0.pdb (carbohydrate) and <pdbid>_i1.pdb (cyclodextrin)

Install:

git clone https://github.com/oxpig/binding-sites.git
conda env create -f esm_env.yml && conda activate esm_env

Usage:

python predict_binding_sites.py --pdb protein.pdb --output sites.csv

Install:

git clone -b pocket_pred https://github.com/Mickdub/gvp.git && cd gvp
pip install -r requirements.txt

Usage:

python predict_pockets.py --pdb protein.pdb --output pockets.csv

Install:

git clone https://github.com/xichengeva/DeepGlycanSite.git && cd DeepGlycanSite
pip install -r requirements.txt

Usage:

python predict.py --pdb protein.pdb --glycan GLC --output predictions.csv

Install:

git clone https://github.com/arneschneuing/DiffSBDD.git
conda env create -f environment.yaml -n diffsbdd && conda activate diffsbdd
# Download pretrained models from Zenodo (links in README)

Usage:

python generate_ligands.py checkpoints/crossdocked_fullatom_cond.ckpt \
  --pdbfile protein.pdb \
  --outfile generated_mols.sdf \
  --ref_ligand ref_ligand.sdf \
  --n_samples 100

Install:

git clone https://github.com/pengxingang/Pocket2Mol.git
conda env create -f env.yml && conda activate Pocket2Mol

Usage:

# Sample for a custom PDB pocket
python sample_for_pdb.py \
  --pdb_path protein.pdb \
  --center "10.0,20.0,15.0" \
  --outdir outputs/

Install:

git clone https://github.com/guanjq/targetdiff.git && cd targetdiff
conda create -n targetdiff python=3.8 && conda activate targetdiff
pip install torch torch-scatter torch-sparse torch-geometric
pip install -r requirements.txt
# Download pretrained checkpoint from README

Usage:

python scripts/sample_diffusion.py \
  --config configs/sampling.yml \
  --ckpt checkpoints/pretrained.pt \
  --pdb_file protein.pdb \
  --ref_ligand ref.sdf \
  --n_samples 100 \
  --result_path outputs/

Install:

git clone https://github.com/bytedance/DecompDiff.git && cd DecompDiff
conda env create -f env.yml && conda activate decompdiff

Usage:

# Generate molecules for a target pocket
python scripts/sample.py \
  --config configs/sample_for_pocket.yml \
  --ckpt checkpoints/decompdiff.pt \
  --pdb_path protein.pdb \
  --ref_ligand ref.sdf \
  --n_samples 100 \
  --outdir outputs/

Install:

git clone https://github.com/MolecularAI/REINVENT4.git && cd REINVENT4
conda create -n reinvent4 python=3.10 && conda activate reinvent4
pip install -e ".[dev]"   # specify --cuda/--rocm/--cpu flag as needed

Usage:

# Run with TOML config
reinvent config/de_novo.toml

# Example TOML snippet:
# [parameters]
# smiles_file = "input.smi"
# [scoring.component.custom_alerts]
# ...

Install:

git clone https://github.com/devalab/molgpt.git
pip install torch numpy rdkit pandas

Usage:

# See generate.py in repo; property-conditioned generation:
# python generate.py --model_weight weights/molgpt.pt \
#   --n_samples 1000 --logp 3.0 --tpsa 80.0 --qed 0.8

Install:

git clone https://github.com/oxpig/DeLinker.git && cd DeLinker
conda env create -f environment.yml && conda activate delinker

Usage:

from delinker.delinker import DeLinker

model = DeLinker(model_path="models/pretrained.pt")
# Input: two fragments as SMILES + 3D coordinates defining distance constraint
linkers = model.generate(
    frag1="c1ccc(N)cc1",
    frag2="C1CCCCC1",
    distance=6.0,
    n_samples=100
)

Install:

pip install aizynthfinder
# Download stock + policy models
aizynthcli --download public

Usage:

from aizynthfinder.aizynthfinder import AiZynthFinder

finder = AiZynthFinder(configfile="config.yml")
finder.target_smiles = "CC(=O)Oc1ccccc1C(=O)O"
finder.tree_search()
finder.build_routes()

# Display top route
print(finder.routes[0])

# CLI
aizynthcli --smiles "CC(=O)Oc1ccccc1C(=O)O" --config config.yml --output routes.json

Install:

pip install selfies rdkit
git clone https://github.com/aspuru-guzik-group/stoned-selfies.git

Usage:

from selfies import encoder, decoder
import stoned

# Generate neighbors of a molecule
smiles = "CC(=O)Oc1ccccc1C(=O)O"
neighbors = stoned.get_random_selfies_neighbors(smiles, n_neighbors=100)

Install:

git clone https://github.com/zoom-wang112358/MOLLEO.git
pip install -r requirements.txt

Usage:

python run.py --task JNK3 --oracle 500 --llm gpt-4o-mini

Install:

pip install rdkit joblib
git clone https://github.com/jensengroup/GB-GA.git

Install:

pip install admet-ai

Usage:

from admet_ai import ADMETModel

model = ADMETModel()
preds = model.predict(smiles=["CC(=O)Oc1ccccc1C(=O)O", "c1ccccc1"])
print(preds)  # DataFrame with 41 ADMET properties

Usage:

import requests
r = requests.post("https://admetlab3.scbdd.com/api/admet",
    json={"smiles": ["CC(=O)Oc1ccccc1C(=O)O"]})
print(r.json())

Install:

conda create -n DeepPurpose python=3.6 && conda activate DeepPurpose
pip install DeepPurpose

Usage:

from DeepPurpose import DTI as models
from DeepPurpose.utils import *
from DeepPurpose.dataset import *

X_drug, X_target, y = process_BindingDB('./data/', y='Kd', binary=False)
drug_encoding, target_encoding = 'MPNN', 'Transformer'
train, val, test = data_process(X_drug, X_target, y, drug_encoding, target_encoding)
config = generate_config(drug_encoding, target_encoding, train_epoch=3)
net = models.model_initialize(**config)
net.train(train, val, test)

Install:

pip install PyTDC

Usage:

from tdc.single_pred import ADME, Tox
from tdc.utils import retrieve_label_name_list

# Load Caco-2 permeability dataset
data = ADME(name='Caco2_Wang')
split = data.get_split()
print(split['train'].head())

# List all ADMET tasks
print(retrieve_label_name_list('ADME'))

Usage (web API via POST):

import requests

smiles_list = ["CC(=O)Oc1ccccc1C(=O)O", "Cc1ccc(S(N)(=O)=O)cc1"]
r = requests.post(
    "https://www.swissadme.ch/include/dispatcher.php",
    data={"smiles": "\n".join(smiles_list)}
)
# Parse returned HTML or use the CSV download option
# For batch programmatic use, consider ADMET-AI or ADMETlab 3.0 instead

Notes: No official REST API; best for interactive use of ≤100 molecules. For programmatic access, pair with admet_ai or ADMETlab3.

Install:

pip install FPSim2

Usage:

from FPSim2 import FPSim2Engine
from FPSim2.io import create_db_file

# Build database
create_db_file(['CC(=O)Oc1ccccc1C(=O)O', 'c1ccccc1'], 'mols.h5', 'Morgan', {'radius': 2, 'nBits': 2048})

# Search
fpe = FPSim2Engine('mols.h5')
results = fpe.similarity('CC(=O)Oc1ccccc1C(=O)O', 0.7, n_workers=4)
print(results)  # idx, similarity

Install:

pip install scaffoldgraph

Usage:

import scaffoldgraph as sg

network = sg.ScaffoldNetwork.from_smiles(['CC(=O)Oc1ccccc1C(=O)O', 'CCOc1ccccc1C(=O)O'])
print(network.num_scaffold_nodes, network.num_molecule_nodes)

Install:

git clone https://github.com/gcorso/DiffDock.git
conda env create --file environment.yml && conda activate diffdock
# Or Docker:
docker pull rbgcsail/diffdock

Usage:

python -m inference \
  --config default_inference_args.yaml \
  --protein_ligand_csv data/protein_ligand_example.csv \
  --out_dir results/
# CSV format: complex_name, protein_path, ligand_description

Install:

pip install vina
conda install -c conda-forge autodock-vina

Usage:

from vina import Vina

v = Vina(sf_name='vina')
v.set_receptor('protein.pdbqt')
v.set_ligand_from_file('ligand.pdbqt')
v.compute_vina_maps(center=[10.0, 20.0, 15.0], box_size=[20, 20, 20])
v.dock(exhaustiveness=8, n_poses=5)
v.write_poses('docked.pdbqt', overwrite=True)

Install:

# Download binary
wget https://github.com/gnina/gnina/releases/download/v1.1/gnina
chmod +x gnina

Usage:

./gnina -r protein.pdbqt -l ligand.pdbqt \
  --autobox_ligand ref_ligand.pdbqt \
  -o docked_gnina.sdf --num_modes 9

Install:

pip install unimol-tools

Usage:

from unimol_tools import UniMolDocking

docking = UniMolDocking()
result = docking.predict(
    protein_path="protein.pdb",
    ligand_smiles="CC(=O)Oc1ccccc1C(=O)O",
    ref_ligand_path="ref.sdf"   # optional for pocket definition
)

Install:

git clone https://github.com/zrqiao/NeuralPLexer.git && cd NeuralPLexer
conda env create -f environment.yml && conda activate neuralplexer
# Download model weights from HuggingFace (see README)

Usage:

# Predict complex structure from protein sequence and ligand SMILES
python scripts/run_inference.py \
  --task=batched_structure_sampling \
  --input_receptor protein.fasta \
  --input_ligand ligand.smi \
  --out_path outputs/ \
  --n_samples 40 \
  --chunk_size 2

Install:

git clone https://github.com/QizhiPei/FABind.git && cd FABind
conda create -n fabind python=3.9 && conda activate fabind
pip install torch torch-geometric rdkit biopython
pip install -r requirements.txt

Usage:

# Blind docking (no pocket specification needed)
python fabind/main_fabind.py \
  --mode inference \
  --protein protein.pdb \
  --ligand ligand.sdf \
  --output outputs/

Install:

git clone https://github.com/luwei0917/TankBind.git && cd TankBind
conda env create -f environment.yml && conda activate tankbind

Usage:

from tankbind import TANKBind, get_protein_feature, get_ligand_feature

model = TANKBind.load_from_checkpoint("checkpoints/tankbind.ckpt")
protein_feat = get_protein_feature("protein.pdb")
ligand_feat = get_ligand_feature("CC(=O)Oc1ccccc1C(=O)O")  # SMILES

# Predict binding affinity and pose
pred_affinity, pred_coords = model.predict(protein_feat, ligand_feat)
print(f"Predicted pKd: {pred_affinity:.2f}")

Install:

git clone https://github.com/HannesStark/EquiBind.git && cd EquiBind
pip install -r requirements.txt

Usage:

python inference.py \
  --config configs/inference.yml \
  --protein_path protein.pdb \
  --ligand_path ligand.sdf \
  --out_dir results/

Install:

pip install posebusters

Usage:

from posebusters import PoseBusters

pb = PoseBusters(config="dock")
results = pb.bust(mol_pred="docked.sdf", mol_true="crystal.sdf", protein="protein.pdb")
print(results)  # DataFrame: pass/fail for each geometric check

# CLI
bust docked.sdf -p protein.pdb --config dock

Install:

pip install plip
conda install -c conda-forge plip

Usage:

# CLI analysis
plip -f complex.pdb -o interaction_report/ -x  # XML output

# Python API
from plip.structure.preparation import PDBComplex
my_mol = PDBComplex()
my_mol.load_pdb("complex.pdb")
my_mol.analyze()
for bsid, interactions in my_mol.interaction_sets.items():
    print(f"Pocket: {bsid}")
    print(f"  H-bonds: {len(interactions.hbonds_pdon + interactions.hbonds_ldon)}")
    print(f"  Hydrophobic: {len(interactions.hydrophobic_contacts)}")

Install:

git clone https://github.com/samsledje/ConPLex.git && cd ConPLex
pip install -e .

Usage:

from conplex import ConPLex

model = ConPLex.from_pretrained("conplex_v1")
scores = model.predict(
    proteins=["MKTVRQERLKSIVRI..."],
    molecules=["CC(=O)Oc1ccccc1C(=O)O"]
)
print(f"Binding score: {scores[0]:.3f}")

Install:

git clone https://github.com/peizhenbai/DrugBAN.git && cd DrugBAN
pip install -r requirements.txt

Usage:

python main.py --cfg configs/DrugBAN.yaml --data bindingdb
python predict.py --model checkpoints/drugban_bindingdb.pt \
  --drug_smiles "CC(=O)Oc1ccccc1C(=O)O" \
  --protein_seq "MKTVRQERLKSIVRI..."

Install:

git clone https://github.com/huankoh/PSICHIC.git && cd PSICHIC
conda env create -f environment_linux.yml  # or environment_osx.yml
conda activate psichic

Usage:

# Virtual screening: protein sequence + ligand SMILES pairs
python predict.py \
  --protein_seq "MKTVRQERLKSIVRI..." \
  --smiles_file compounds.csv \
  --output predictions.csv

Install:

git clone https://github.com/luwei0917/DynamicBind.git
conda env create -f environment.yml && conda activate dynamicbind

Usage:

python predict.py \
  --protein protein.pdb \
  --ligand ligand.sdf \
  --output_dir results/

Install:

git clone https://github.com/bytedance/Protenix-Dock.git && cd Protenix-Dock
conda env create -f environment.yml && conda activate protenix-dock
pip install -e .

Usage:

protenix-dock dock \
  --receptor protein.pdb \
  --ligand ligand.sdf \
  --output docked.sdf

Install:

git clone https://github.com/isakvals/AEV-PLIG.git && cd AEV-PLIG
conda env create -f environment.yml && conda activate aev-plig

Usage:

from aev_plig import AEVPlig

model = AEVPlig.load_pretrained()
affinity = model.predict("complex.pdb")
print(f"Predicted pKd: {affinity:.2f}")

Install:

git clone https://github.com/AIDD-Lab/FlashBind.git && cd FlashBind
pip install -r requirements.txt

Usage:

python predict.py --protein protein.pdb --ligand ligand.sdf --task affinity --output results.csv

Install:

conda install -c conda-forge openmm

Usage:

from openmm.app import *
from openmm import *
from openmm.unit import *

pdb = PDBFile('input.pdb')
forcefield = ForceField('amber14-all.xml', 'amber14/tip3pfb.xml')
system = forcefield.createSystem(pdb.topology, nonbondedMethod=PME, 
                                  nonbondedCutoff=1*nanometer, constraints=HBonds)
integrator = LangevinMiddleIntegrator(300*kelvin, 1/picosecond, 0.004*picoseconds)
simulation = Simulation(pdb.topology, system, integrator)
simulation.context.setPositions(pdb.positions)
simulation.minimizeEnergy()
simulation.step(10000)
simulation.reporters.append(DCDReporter('traj.dcd', 1000))

Install:

mamba install -c conda-forge openfe

Usage:

import openfe
from openfe import SolventComponent, SmallMoleculeComponent, ProteinComponent

ligA = SmallMoleculeComponent.from_rdkit(mol_a)
ligB = SmallMoleculeComponent.from_rdkit(mol_b)
protein = ProteinComponent.from_pdb_file("protein.pdb")
solvent = SolventComponent()

rbfe = openfe.protocols.openmm_rbfe.RelativeHybridTopologyProtocol(
    settings=openfe.protocols.openmm_rbfe.RelativeHybridTopologyProtocol.default_settings()
)
dag = rbfe.create(
    stateA=openfe.ChemicalSystem({"ligand": ligA, "protein": protein, "solvent": solvent}),
    stateB=openfe.ChemicalSystem({"ligand": ligB, "protein": protein, "solvent": solvent}),
    mapping=openfe.LigandAtomMapping(ligA, ligB, {})
)

Install:

mamba install -c conda-forge -c biosimspace biosimspace

Usage:

import BioSimSpace as BSS

# Load system
system = BSS.IO.readMolecules(["protein.prm7", "protein.rst7"])

# Set up equilibration protocol
protocol = BSS.Protocol.Equilibration(runtime=0.5 * BSS.Units.Time.nanosecond,
                                       temperature=300 * BSS.Units.Temperature.kelvin)

# Run with GROMACS
process = BSS.Process.Gromacs(system, protocol)
process.start()
process.wait()

# Relative free energy
protocol_fep = BSS.Protocol.FreeEnergy(runtime=4 * BSS.Units.Time.nanosecond)

Install:

conda install htmd -c acellera -c conda-forge

Usage:

from htmd.ui import *

# Build a solvated protein-ligand system
prot = Molecule("protein.pdb")
prot.filter("protein")
prot = systemPrepare(prot)

ligand = Molecule("ligand.mol2")
system = proteinPrepare(prot)
built, _ = build(system, outdir="built/", ff=["amber14", "gaff2"], saltconc=0.15)

# Run adaptive sampling with ACEMD
md = Acemd("built/")
md.run(nsteps=500000, dt=4, output="production/")

Install:

pip install MDAnalysis MDAnalysisTests
conda install -c conda-forge mdanalysis

Usage:

import MDAnalysis as mda
from MDAnalysis.analysis import rms, contacts

u = mda.Universe("system.tpr", "trajectory.xtc")

# RMSD
R = rms.RMSD(u, select="backbone").run()
print(R.results.rmsd[:5])

# Native contacts
nc = contacts.Contacts(u, select=("protein and name CA", "resname LIG"),
                       refgroup=(u.select_atoms("protein"), u.select_atoms("resname LIG")),
                       radius=4.5).run()

Install:

conda install -c conda-forge gmx_mmpbsa

Usage:

# Basic MMPBSA calculation
gmx_MMPBSA -O -i mmpbsa.in -cs com.tpr -ct com_traj.xtc \
  -ci index.ndx -cg 1 13 -cp topol.top \
  -o FINAL_RESULTS_MMPBSA.dat -eo FINAL_RESULTS_MMPBSA.csv

# Python API
from GMXMMPBSA import run
# Or analyze results
import pandas as pd
results = pd.read_csv("FINAL_RESULTS_MMPBSA.csv")
print(f"ΔG_bind = {results['TOTAL'].mean():.1f} ± {results['TOTAL'].std():.1f} kcal/mol")

Install:

pip install deepmd-kit
# With CUDA:
pip install deepmd-kit[gpu]
# Or via conda:
conda install deepmd-kit -c conda-forge

Usage:

# Train a DeepPot-SE model
dp train input.json

# Run MD with LAMMPS + DeePMD
lmp -in lammps.in  # uses pair_style deepmd frozen_model.pb

# Freeze model for deployment
dp freeze -o frozen_model.pb

Install:

pip install torchmd-net
# or from source:
git clone https://github.com/torchmd/torchmd-net.git && cd torchmd-net
pip install -e .

Usage:

from torchmdnet.models import load_model
import torch

# Load pretrained model (e.g., ANI-2x compatible)
model = load_model("checkpoints/tensornet_qm9.ckpt")

# Predict energy and forces
positions = torch.randn(10, 3)  # atom coordinates
atomic_numbers = torch.tensor([6, 1, 1, 1, 1, 6, 1, 1, 1, 1])
energy, forces = model(atomic_numbers, positions)

# Train custom model
torchmd-train --conf train_config.yaml --dataset qm9

Install:

git clone https://github.com/jamesgleave/Deep-Docking.git
conda env create -f environment.yml

Usage:

# Phase 1: Initial docking of random subset
python phase_1.py --input_path zinc_library/ --docking_software glide

# Phase 2: Train deep learning model and select next iteration
python phase_2.py --input_path zinc_library/ --iteration 1

Install:

pip install deepchem
# With GPU support:
pip install deepchem[torch]

Usage:

import deepchem as dc

# Load MoleculeNet benchmark dataset
tasks, datasets, transformers = dc.molnet.load_tox21()
train, valid, test = datasets

# Train a Graph Convolutional model
model = dc.models.GraphConvModel(n_tasks=len(tasks), mode='classification')
model.fit(train, nb_epoch=50)

# Evaluate
metric = dc.metrics.Metric(dc.metrics.roc_auc_score)
print(model.evaluate(test, [metric]))

Install:

pip install mordred

Usage:

from mordred import Calculator, descriptors
from rdkit import Chem

calc = Calculator(descriptors, ignore_3D=True)
mol = Chem.MolFromSmiles("CC(=O)Oc1ccccc1C(=O)O")
result = calc(mol)
print(f"Computed {len(result)} descriptors")
print(result[:5])  # First 5 descriptor values

# Batch computation as DataFrame
import pandas as pd
mols = [Chem.MolFromSmiles(s) for s in ["CC(=O)O", "c1ccccc1", "CCO"]]
df = calc.pandas(mols)
print(df.shape)  # (3, 1826)

Install:

pip install fair-esm          # ESM-2 + ESMFold

Usage (ESM-2 embeddings):

import torch, esm

model, alphabet = esm.pretrained.esm2_t33_650M_UR50D()
batch_converter = alphabet.get_batch_converter()
model.eval()

data = [("binder1", "MKTVRQERLKSIVRILERSKEPVSGAQLAEELS")]
_, _, tokens = batch_converter(data)

with torch.no_grad():
    results = model(tokens, repr_layers=[33], return_contacts=True)
embeddings = results["representations"][33]  # (B, L, 1280)

Usage (ESMFold structure prediction):

import esm, torch
model = esm.pretrained.esmfold_v1().eval().cuda()
with torch.no_grad():
    pdb_str = model.infer_pdb("MKTVRQERLKSIVRILERSKEPVSGAQLAEELS")
with open("predicted.pdb", "w") as f:
    f.write(pdb_str)

Install:

pip install esm               # ESM-3 + ESM-C (via EvolutionaryScale)

Usage (ESM-3 multimodal generation):

from esm.models.esm3 import ESM3
from esm.sdk.api import ESMProtein, GenerationConfig

model = ESM3.from_pretrained("esm3-open").to("cuda")
protein = ESMProtein(sequence="MKTVRQERLKSIVRILERSKEPVSGAQLAEELS")
# Generate structure from sequence
result = model.generate(protein, GenerationConfig(track="structure", num_steps=10))

Usage (ESM-C embeddings):

from esm.models.esmc import ESMC

model = ESMC.from_pretrained("esmc-300m").to("cuda")
protein = ESMProtein(sequence="MKTVRQERLKSIVRILERSKEPVSGAQLAEELS")
output = model.encode(protein)
# output.embeddings → per-residue embeddings

Install:

pip install transformers torch sentencepiece

Usage:

from transformers import T5Tokenizer, T5EncoderModel
import torch, re

tokenizer = T5Tokenizer.from_pretrained("Rostlab/prot_t5_xl_uniref50", do_lower_case=False)
model = T5EncoderModel.from_pretrained("Rostlab/prot_t5_xl_uniref50").eval()

seq = "MKTVRQERLKS"
seq_spaced = " ".join(list(seq))
seq_spaced = re.sub(r"[UZOB]", "X", seq_spaced)
ids = tokenizer(seq_spaced, return_tensors="pt", add_special_tokens=True)

with torch.no_grad():
    embedding = model(input_ids=ids['input_ids']).last_hidden_state
print(embedding.shape)  # (1, L+1, 1024)

Install:

pip install ankh

Usage:

import ankh, torch

# Load model and tokenizer
model, tokenizer = ankh.load_large_model()
model.eval()

sequences = ["MKTVRQERLKSIVRILERSKEPVSGAQLAEELS"]
outputs = tokenizer.batch_encode_plus(
    [list(seq) for seq in sequences],
    add_special_tokens=True,
    padding=True,
    is_split_into_words=True,
    return_tensors="pt"
)

with torch.no_grad():
    embeddings = model(
        input_ids=outputs['input_ids'],
        attention_mask=outputs['attention_mask']
    )
print(embeddings.last_hidden_state.shape)  # (1, L+2, 1536)

Install:

git clone https://github.com/salesforce/progen.git
cd progen/progen2
pip install -r requirements.txt

Usage:

# Generate novel protein sequences conditioned on UniProt taxonomy tokens
from tokenizers import Tokenizer
import torch

# Load model (e.g. progen2-base, progen2-medium, progen2-xlarge)
from transformers import AutoModelForCausalLM
model = AutoModelForCausalLM.from_pretrained("hugohrban/progen2-small")
tokenizer = Tokenizer.from_file("progen2/tokenizer.json")

# Conditional generation with context token
context = "1<|endoftext|>"   # '1' = human; append desired context tokens
input_ids = tokenizer.encode(context).ids
output = model.generate(
    torch.tensor([input_ids]),
    do_sample=True,
    temperature=1.0,
    max_length=256
)
seq = tokenizer.decode(output[0].tolist())
print(seq)

Install:

pip install evodiff
# or from source:
git clone https://github.com/microsoft/evodiff.git && cd evodiff
pip install -e .

Usage:

from evodiff.pretrained import OA_DM_640M
from evodiff.generate import generate_oaardm

# Load pretrained model
model, collater, tokenizer, scheme = OA_DM_640M()

# Unconditional generation
generated_seqs = generate_oaardm(model, tokenizer, n_sequences=10, seq_length=100)
for seq in generated_seqs:
    print(seq)

Install:

pip install transformers torch

Usage:

from transformers import pipeline

generator = pipeline("text-generation", model="nferruz/ProtGPT2")
sequences = generator("<|endoftext|>", max_length=200, do_sample=True,
                      top_k=950, repetition_penalty=1.2, num_return_sequences=5,
                      eos_token_id=0)
for s in sequences:
    print(s["generated_text"])

Install:

pip install torch torch-geometric torch-scatter torch-sparse
git clone https://github.com/drorlab/gvp-pytorch.git && cd gvp-pytorch
pip install -e .

Usage:

import torch
from gvp import GVP, GVPConvLayer
from gvp.data import ProteinGraphDataset

# Build protein graph dataset from PDB files
dataset = ProteinGraphDataset(pdb_dir="pdbs/", node_scalar_dim=6, node_vector_dim=3)

# Use GVP layers in custom model
layer = GVPConvLayer(node_dims=(100, 16), edge_dims=(32, 1))

Install:

pip install torchdrug torch-scatter torch-cluster
git clone https://github.com/DeepGraphLearning/GearNet.git && cd GearNet

Usage:

import torchdrug
from torchdrug import datasets, transforms, models, tasks

# Load pretrained GearNet-Edge
model = models.GearNet(input_dim=21, hidden_dims=[512, 512, 512],
                       num_relation=7, edge_input_dim=59, batch_norm=True)
# Load pretrained weights
model.load_state_dict(torch.load("gearnet_edge_mc.pt"))

# Fine-tune on function prediction
task = tasks.PropertyPrediction(model, task="Gene Ontology", num_class=489)

Install:

git clone https://github.com/LucaOne/LucaOne.git && cd LucaOne
pip install -r requirements.txt

Usage:

from lucaone import LucaOne

model = LucaOne.from_pretrained()
# Encode protein, DNA, or RNA sequences
emb = model.encode("MKTVRQERLKS...", modality="protein")

Install:

pip install evo2
# or from source:
git clone https://github.com/arcinstitute/evo2.git && cd evo2
pip install -e .

Usage:

from evo2 import Evo2

model = Evo2.from_pretrained("evo2-40b")
# Generate DNA sequence
output = model.generate("ATGAAAGCC", max_length=1000)
# Score sequence likelihood
score = model.score("ATGAAAGCCATTTTC...")

Install:

git clone https://github.com/jiaor17/EPT.git && cd EPT
conda env create -f env.yml && conda activate EPT

Install:

git clone https://github.com/bytedance/dplm.git && cd dplm
pip install -e .

Usage:

# Unconditional protein generation
python scripts/generate.py --model dplm2 --n_samples 100 --length 120

# Inverse folding (structure → sequence)
python scripts/inverse_fold.py --pdb backbone.pdb --n_samples 50

# Forward folding (sequence → structure)
python scripts/fold.py --sequence "MKTVRQERLKS..."

Install:

git clone https://github.com/VarunUllanat/mint.git && cd mint
conda env create --name mint --file=environment.yml && conda activate mint

Usage:

from mint import MINT

model = MINT.from_pretrained("mint-base")
# Predict interaction between two proteins
score = model.predict_interaction(seq_a="MKTVRQ...", seq_b="DIVMTQ...")
print(f"Interaction score: {score:.3f}")

Install:

git clone https://github.com/oxpig/CaLM.git && cd CaLM
python setup.py install

Usage:

from calm import CaLM

model = CaLM.from_pretrained()
embeddings = model.encode("ATGAAAGCCATTTTC...")  # DNA codon sequence
# Use embeddings for downstream protein engineering tasks

Install:

pip install "fair-esm[esmfold]"

(See ESM-2 usage above for structure prediction example)

Install:

git clone https://github.com/uw-ipd/RoseTTAFold2.git && cd RoseTTAFold2
conda env create -f RF2-linux.yml && conda activate RF2
pip install -e .
bash install_dependencies.sh

Usage:

python run_RF2.py \
  --input query.fasta \
  --output_dir ./output \
  --num_recycles 3

Install:

git clone https://github.com/baker-laboratory/RoseTTAFold-All-Atom.git
conda env create -f RFAA/environment.yaml && conda activate RFAA
bash RFAA/install_dependencies.sh

Usage:

python -m rf2aa.run_inference \
  --config-name base_inference \
  protein_inputs.0.fasta=query.fasta \
  loader_params.MAXCYCLE=10 \
  output_path=./output

Install:

pip install chai_lab

Usage:

import chai_lab
# See documentation for FASTA + entity specification
# Supports protein, RNA, DNA, ligand (SMILES) inputs

Install:

pip install boltz

Usage:

boltz predict input.yaml --use_msa_server --output_format pdb
# input.yaml specifies sequences + entity types (protein/ligand/RNA)
# Boltz-2 adds confidence scoring and affinity estimation

Install:

pip install "colabfold[alphafold]"
# Or for local colabfold:
bash install_colabbatch_linux.sh

Usage:

# Predict monomer or complex from FASTA
colabfold_batch input.fasta ./output/ \
  --num-recycle 3 \
  --num-models 5 \
  --model-type alphafold2_multimer_v3 \
  --amber   # optional Amber relaxation

# For a binder-target complex, put sequences in one FASTA with ':' separator:
# >complex
# BINDSEQ:TARGETSEQ

Install:

git clone https://github.com/bytedance/Protenix.git && cd Protenix
pip install -e .

Usage:

python predict.py --input input.json --output_dir results/
# input.json specifies protein sequences, ligand SMILES, RNA sequences, etc.

Install:

git clone https://github.com/patrickbryant1/Cfold.git && cd Cfold
bash install_dependencies.sh

Usage:

# Predict alternative conformations
python predict.py --fasta query.fasta --output_dir results/ --n_samples 5

Install:

git clone https://github.com/patrickbryant1/Umol.git && cd Umol
bash install_dependencies.sh

Usage:

bash predict.sh protein.fasta "CCO" results/
# protein.fasta = protein sequence, "CCO" = ligand SMILES

Install:

git clone https://github.com/CongLabCode/RoseTTAFold2-PPI.git
cd RoseTTAFold2-PPI/src/models
wget --no-check-certificate https://conglab.swmed.edu/humanPPI/downloads/RF2-PPI.pt

Usage:

python predict_ppi.py --fasta_a protein_a.fasta --fasta_b protein_b.fasta --output results/

Install:

git clone https://github.com/bjing2016/alphaflow.git && cd alphaflow
pip install -e .
# Download pretrained weights from HuggingFace

Usage:

from alphaflow import AlphaFlow

model = AlphaFlow.from_pretrained("alphaflow_md_distilled")
# Generate ensemble (100 conformations)
ensemble = model.sample(sequence="MKTVRQERLKS...", n_samples=100)
ensemble.save_pdb("conformations.pdb")

Install:

git clone https://github.com/microsoft/bioemu.git && cd bioemu
pip install -e .

Usage:

from bioemu import BioEmu

model = BioEmu.from_pretrained()
ensemble = model.generate(sequence="MKTVRQERLKSIVRI...", n_conformations=500)
# Returns ensemble of full-atom structures with Boltzmann weights

Install:

git clone https://github.com/bytedance/ConfDiff.git && cd ConfDiff
conda env create -f environment.yml && conda activate confdiff

Usage:

python generate.py --pdb protein.pdb --n_samples 100 --output conformations/

Install:

git clone https://github.com/LPDI-EPFL/masif.git
conda env create -f masif/environment.yml

Install:

pip install git+https://github.com/sokrypton/ColabDesign.git
# For AF2 hallucination, also need AlphaFold weights

Usage:

from colabdesign import mk_afdesign_model, clear_mem

# Binder hallucination targeting a specific protein
model = mk_afdesign_model(protocol="binder")
model.prep_inputs(pdb_filename="target.pdb", chain="A", binder_len=80)
model.restart(seed=0)
model.design_3stage(soft_iters=100, temp_iters=100, hard_iters=10)

print(model.get_seqs())          # Designed binder sequence
print(model.aux["log"])          # pLDDT, pAE, i_pae scores
model.save_pdb("designed_binder.pdb")

Install:

git clone https://github.com/martinpacesa/BindCraft.git && cd BindCraft
pip install -e .
# Requires AlphaFold2 weights

Usage:

python bindcraft.py \
  --target target.pdb \
  --target_chain A \
  --hotspot_residues "A30,A33,A37" \
  --binder_length 80 \
  --n_designs 100 \
  --output designs/

Install:

git clone https://github.com/LPDI-EPFL/masif-neosurf.git
cd masif-neosurf
docker build . -t masif-neosurf
docker run -it -v $PWD:/home/$(basename $PWD) masif-neosurf

Usage:

# Preprocess a PDB with a bound ligand
./preprocess_pdb.sh example/1a7x.pdb 1A7X_A -l FKA_B -s example/1a7x_C_FKA.sdf -o example/output/

# Run seed search (find complementary surface patches from a database)
python source/seed_search.py --input example/output/ --db seed_database/ --top_k 100

# Seed refinement and grafting onto scaffold
python source/seed_refine.py --seed results/top_seeds.npy --scaffold scaffold.pdb --output refined_binders/

Install:

git clone https://github.com/NVIDIA-Digital-Bio/proteina.git && cd proteina
pip install -e .

Usage:

from proteina import Proteina

model = Proteina.from_pretrained("proteina_base")
# Unconditional backbone generation
backbones = model.sample(n_samples=50, seq_length=120)
backbones.save_pdb("generated_backbones/")

Install:

git clone https://github.com/RosettaCommons/RFdiffusion.git && cd RFdiffusion
conda env create -f env/SE3nv.yml && conda activate SE3nv
pip install -e .
# Download model weights
mkdir models && cd models
wget http://files.ipd.uw.edu/pub/RFdiffusion/6f5902ac237024bdd0c176cb93063dc4/Base_ckpt.pt
wget http://files.ipd.uw.edu/pub/RFdiffusion/e29311f6f1bf1af907f9ef9f44b8328b/Complex_base_ckpt.pt

Usage:

# Binder design targeting a specific hotspot on a receptor
./scripts/run_inference.py \
  'contigmap.contigs=[A1-100/0 70-100]' \
  'ppi.hotspot_res=[A30,A33,A67]' \
  'inference.input_pdb=receptor.pdb' \
  'inference.output_prefix=outputs/binder' \
  'inference.num_designs=100'

# Cyclic peptide design
./scripts/run_inference.py \
  'contigmap.contigs=[10-20]' \
  'inference.output_prefix=outputs/cyclic_peptide' \
  '+cyclic_offset=1'

Install:

pip install generate-chroma  # requires free API key from generatebiomedicines.com

Usage:

from chroma import Chroma, Protein, conditioners

chroma = Chroma()  # requires CHROMA_API_KEY env variable

# Unconditional generation
protein = chroma.sample(chain_lengths=[100])
protein.to("designed_protein.pdb")

# Conditioned on symmetry
sym = conditioners.SymmetryConditioner(G="C3", num_chain_neighbors=2)
protein, _ = chroma.sample(chain_lengths=[100], conditioner=sym)

Install:

git clone https://github.com/RosettaCommons/protein_generator.git
conda env create -f environment.yml && conda activate proteingenerator
# Download model weights (see README)

Usage:

python ./inference.py \
  -input_json ./examples/out/design_000000_args.json \
  -num_designs 10 \
  -out ./outputs/

Install:

git clone https://github.com/aqlaboratory/genie2.git && cd genie2
conda env create -f environment.yml && conda activate genie2
# Download weights from Zenodo (link in README)

Usage:

# Unconditional sampling
python sample_unconditional.py \
  --model_path weights/genie2_large.pt \
  --n_samples 100 \
  --length 100 \
  --output_dir outputs/

# Motif scaffolding
python sample_motif_scaffolding.py \
  --motif_pdb motif.pdb \
  --n_samples 50 \
  --output_dir outputs_scaffolded/

Install:

git clone https://github.com/jasonkyuyim/se3_diffusion.git
conda env create -f se3.yml && conda activate se3
pip install -e .
# Download model weights (link in README)

Usage:

# Unconditional protein backbone generation
python experiments/inference_se3_diffusion.py \
  --inference_dir ./inference_outputs/ \
  --inference.num_t 100 \
  --samples 100

Install (Apptainer/Singularity container):

git clone https://github.com/baker-laboratory/rf_diffusion_all_atom.git
# Download container and weights
wget http://files.ipd.uw.edu/pub/RF-All-Atom/containers/rf_se3_diffusion.sif
wget http://files.ipd.uw.edu/pub/RF-All-Atom/weights/RFDiffusionAA_paper_weights.pt

Usage:

/usr/bin/apptainer run --nv rf_se3_diffusion.sif \
  -u run_inference.py \
  inference.deterministic=True \
  diffuser.T=100 \
  inference.output_prefix=output/sample \
  inference.input_pdb=input/7v11.pdb \
  contigmap.contigs=['150-150'] \
  inference.ligand=OQO \
  inference.num_designs=10

Install:

# Same environment as RFdiffusion
git clone https://github.com/RosettaCommons/RFdiffusion.git && cd RFdiffusion
conda env create -f env/SE3nv.yml && conda activate SE3nv
pip install -e .
# Download partial diffusion & cyclic peptide weights
wget http://files.ipd.uw.edu/pub/RFdiffusion/cyclic_peptide/CyclicPeptide_ckpt.pt -P models/

Usage:

# Design a cyclic peptide binder targeting a hotspot
./scripts/run_inference.py \
  'contigmap.contigs=[10-20]' \
  '+cyclic_offset=1' \
  'ppi.hotspot_res=[A45,A78,A102]' \
  'inference.input_pdb=target.pdb' \
  'inference.output_prefix=outputs/cyclic_binder' \
  'inference.num_designs=200'

# Sequence design with ProteinMPNN (cyclic-aware)
python ProteinMPNN/protein_mpnn_run.py \
  --pdb_path outputs/cyclic_binder_0.pdb \
  --out_folder mpnn_seqs/ \
  --num_seq_per_target 100 \
  --sampling_temp 0.05

Install:

git clone https://gitlab.com/oabdin/pepflow.git
cd pepflow
pip install -e .
# Download model weights from the repository release page

Usage:

from pepflow.model import PepFlow
from pepflow.utils import load_target

# Load target receptor and sample peptide binders
target = load_target("receptor.pdb", chain="A")

model = PepFlow.from_pretrained("weights/pepflow.pt")

# Generate 100 peptide candidates (length 10–20 residues)
samples = model.sample(
    target=target,
    n_samples=100,
    length_range=(10, 20),
    n_flow_steps=100
)

for i, pep in enumerate(samples):
    pep.save(f"peptide_{i:03d}.pdb")

Install:

git clone https://github.com/CycleDesigner/CycleDesigner.git
cd CycleDesigner
pip install -r requirements.txt

Usage:

# Full cyclic peptide design pipeline
python cycledesigner.py \
  --target target.pdb \
  --hotspots "A59,A83" \
  --peptide_length 12 \
  --num_designs 200 \
  --output_dir ./cyclic_output

Install:

pip install pepmlm
# or:
git clone https://github.com/programmablebio/pepmlm.git && pip install -e .

Usage:

from pepmlm import PepMLM

model = PepMLM.from_pretrained("pepmlm-650m")
# Generate peptide binders for a target protein sequence
peptides = model.generate(
    target_sequence="MKTVRQERLKSIVRILERSKEPVSG...",
    peptide_length=15,
    n_samples=100
)
for pep in peptides[:5]:
    print(pep.sequence, pep.score)

Install:

git clone https://github.com/YuzheWangPKU/DiffPepBuilder.git && cd DiffPepBuilder
pip install -r requirements.txt

Usage:

python generate.py \
  --target target.pdb \
  --hotspot_residues "A45,A48,A52" \
  --peptide_length 12 \
  --n_samples 100 \
  --output outputs/

Install:

git clone https://github.com/bytedance/PXDesign.git && cd PXDesign
pip install -e .

Usage:

# Design binders targeting a specific protein
python design.py \
  --target target.pdb \
  --hotspot_residues "A30,A33" \
  --n_designs 100 \
  --output designs/

Install:

git clone https://github.com/kxz18/UniMoMo.git && cd UniMoMo
conda env create -f env_cuda121.yaml && conda activate unimomo

Usage:

# Design binders of any modality for a given target
python design.py --target target.pdb --modality peptide --n_samples 100 --output designs/

Install:

git clone https://github.com/kxz18/PepMimic.git && cd PepMimic
conda env create -f env_cu124.yaml && conda activate pepmimic

Usage:

# Generate peptides mimicking a known binder's interface
python mimic.py \
  --reference_binder binder_complex.pdb \
  --target_chain A \
  --binder_chain B \
  --peptide_length 15 \
  --n_samples 100 \
  --output mimics/

Install:

git clone https://github.com/patrickbryant1/RareFold.git && cd RareFold
bash install.sh

Usage:

# Structure prediction with noncanonical amino acids
python predict_structure.py --fasta query.fasta --output results/

# Design cyclic peptide binders with noncanonical AAs
python evobindrare.py --target target.fasta --peptide_length 15 --cyclic --n_designs 100

Install:

git clone https://gitlab.com/patrickbryant1/binder_design.git && cd binder_design
# Requires FoldSeek, ESM-IF1, AlphaFold2 installations

Install:

git clone https://gitlab.com/patrickbryant1/molpc.git && cd molpc
bash install.sh

Install:

git clone https://github.com/YZY010418/CPSea.git && cd CPSea
pip install -r requirements.txt
# Download datasets from Kaggle/Zenodo (links in README)

Install:

git clone https://github.com/dauparas/ProteinMPNN.git
pip install torch numpy

Usage:

# Design sequences for a monomer
python protein_mpnn_run.py \
  --pdb_path structure.pdb \
  --out_folder outputs/ \
  --num_seq_per_target 100 \
  --sampling_temp 0.1 \
  --batch_size 8

# Fix certain residue positions
python protein_mpnn_run.py \
  --pdb_path structure.pdb \
  --fixed_residues "A10 A11 A20" \
  --num_seq_per_target 100

Install:

git clone https://github.com/dauparas/LigandMPNN.git
pip install torch numpy
bash get_model_params.sh "./model_params"  # download weights

Usage:

python run.py \
  --model_type "ligand_mpnn" \
  --pdb_path complex.pdb \
  --out_folder outputs/ \
  --num_seq_per_target 50 \
  --temperature 0.05

Install:

pip install fair-esm biotite

Usage:

import esm, esm.inverse_folding, torch

model, alphabet = esm.pretrained.esm_if1_gvp4_t16_142M_UR50()
model.eval()

# Sample sequences for a given structure
structure = esm.inverse_folding.util.load_structure("protein.pdb", "A")
coords, native_seq = esm.inverse_folding.util.extract_coords_from_structure(structure)

sampled_seq = model.sample(coords, temperature=1.0)
print(sampled_seq)

Install:

git clone https://github.com/A4Bio/PiFold.git && cd PiFold
pip install -r requirements.txt
# or use provided Colab notebooks in the repo

Usage:

# Load from HuggingFace (see README for full pipeline)
from PiFold.models import PiFold_Model
import torch

model = PiFold_Model.from_pretrained("A4Bio/PiFold")
model.eval()

# Design sequences for a given backbone PDB
sequences = model.design("backbone.pdb", num_samples=100, temperature=0.1)

Install:

pip install transformers
# Model on HuggingFace: westlake-repl/SaProt_650M_AF2

Usage:

from transformers import AutoTokenizer, AutoModelForMaskedLM

tokenizer = AutoTokenizer.from_pretrained("westlake-repl/SaProt_650M_AF2")
model = AutoModelForMaskedLM.from_pretrained("westlake-repl/SaProt_650M_AF2")

# Input: interleaved amino acid + 3Di structural tokens (from Foldseek)
seq = "MdKdTdVd..."  # alternating AA/3Di format
inputs = tokenizer(seq, return_tensors="pt")
outputs = model(**inputs)
# Use for masked residue prediction / inverse folding

Install:

pip install antifold

Usage:

from antifold import AntiFold

model = AntiFold()
# Design CDR-H3 sequences for an antibody-antigen complex
designs = model.design(
    pdb_path="antibody_antigen.pdb",
    heavy_chain="H",
    light_chain="L",
    antigen_chain="A",
    regions=["CDR-H3"],
    n_samples=100,
    temperature=0.2
)
for d in designs[:5]:
    print(d.sequence, d.log_likelihood)

Install:

git clone https://github.com/samuelstanton/lambo.git && cd lambo
pip install -e .

Usage:

from lambo import LaMBO

optimizer = LaMBO(
    objectives=["binding_affinity", "stability", "expression"],
    seed_sequences=initial_antibody_seqs,
    n_rounds=10,
    batch_size=50
)
results = optimizer.optimize()
# Returns Pareto-optimal sequences

Install:

pip install evo-prot-grad

Usage:

from evo_prot_grad import get_expert
from evo_prot_grad.experts.base_experts import ProteinLMExpert

esm_expert = get_expert('esm', temperature=1.0, device='cuda')
evolved_seqs, scores = esm_expert.directed_evolution(
    wt_seq="MKTVRQERLKSIVRILERSKEPVSGAQ",
    n_steps=100,
    n_sequences=50
)

Install:

git clone https://github.com/OATML-Markslab/ProteinGym.git
pip install -e .

Install:

pip install flexs
# Optional: RNA and protein design
conda install -c bioconda viennarna
conda install pyrosetta  # for Rosetta landscapes

Usage:

import flexs

# Use a GFP fluorescence fitness landscape
landscape = flexs.landscapes.GFP(noise_mean=0.0, noise_std=0.01)

# Implement a custom sequence explorer
class GreedyMutant(flexs.Explorer):
    def propose_sequences(self, measured_sequences_data):
        # Return (sequences, predicted_scores) tuples
        return sequences, scores

explorer = GreedyMutant(landscape, rounds=10, sequences_batch_size=100)
results = explorer.run()

Install:

git clone https://github.com/sherrylixuecheng/ODBO.git
cd ODBO
pip install -r requirements.txt

Usage:

from odbo import ODBO

optimizer = ODBO(
    protein_sequence="MQYKLILNGKTLKGETTTEAVDAATAEKVFKQYANDNGVDGEWTYDDATKTFTVTE",
    fitness_oracle=my_assay_function,   # callable returning scalar fitness
    encoding="onehot",
    n_init=20,
    n_iter=50
)
top_variants = optimizer.optimize()
for v in top_variants:
    print(v.sequence, v.fitness)

Install:

git clone https://github.com/luoyunan/ECNet.git && cd ECNet
pip install -r requirements.txt

Usage:

from ecnet import ECNet

model = ECNet(msa_path="alignments/protein.a3m", wt_seq="MKTVRQ...")
model.load_pretrained("checkpoints/ecnet_pretrained.pt")

# Predict fitness of variants
variants = ["M1A", "K2R", "T3S/V4I"]
scores = model.predict(variants)
for var, score in zip(variants, scores):
    print(f"{var}: {score:.3f}")

Install:

git clone https://github.com/dhbrookes/CbAS.git && cd CbAS
pip install -r requirements.txt

Usage:

from cbas import CbAS

# Define oracle (e.g., binding affinity predictor) and initial VAE
optimizer = CbAS(
    generator=vae_model,
    oracle=binding_oracle,
    n_rounds=10,
    samples_per_round=1000,
    quantile=0.95
)

# Run adaptive optimization
best_sequences = optimizer.optimize(seed_sequences=initial_seqs)

Install:

pip install alphamissense
# Or download precomputed predictions:
# https://zenodo.org/records/8208688 (all 71M human variants scored)

Usage:

# Using precomputed scores (most common use case)
import pandas as pd

scores = pd.read_csv("AlphaMissense_aa_substitutions.tsv.gz", sep="\t")
# Filter for your protein (UniProt ID)
protein_scores = scores[scores["uniprot_id"] == "P04637"]  # e.g., TP53
print(protein_scores[["protein_variant", "am_pathogenicity", "am_class"]].head())

Install:

pip install haddock3

Usage:

haddock3 run.toml
# run.toml example:
# [topoaa]
# [rigidbody]
# [caprieval]
# [seletop]
# [flexref]

Install:

git clone https://github.com/octavian-ganea/equidock_public.git && cd equidock_public
pip install -r requirements.txt

Usage:

from equidock import EquiDock

model = EquiDock.load_pretrained("checkpoints/equidock_dips.pt")

# Predict rigid-body docking pose
result = model.dock(receptor_pdb="receptor.pdb", ligand_pdb="ligand_chain.pdb")
result.save("docked_complex.pdb")

Install:

conda install pyg pytorch=1.8.0 cudatoolkit=11.1 torchdrug -c pyg -c pytorch -c conda-forge
conda install rdkit easydict pyyaml biopython gdown -c conda-forge

Usage:

python predict.py --pdb complex.pdb --mutations "A:K48R,A:L52A" --output ddg_predictions.csv

Install:

git clone https://github.com/TianZhuAI4S/DiffAffinity.git && cd DiffAffinity
conda create -n DiffAffinity python=3.9 && conda activate DiffAffinity
pip install -r requirements.txt

Usage:

python predict.py --pdb complex.pdb --mutations mutations.csv --output ddg_results.csv

Install:

conda create --name ddg-predict python=3.8 -y && conda activate ddg-predict
conda install pytorch=1.10.2 cudatoolkit=11.3 -c pytorch -y
conda install biopython=1.79 easydict -c conda-forge -y
git clone https://github.com/HeliXonProtein/binding-ddg-predictor.git

Usage:

python predict_ddg.py --pdb complex.pdb --mutations "HA:K48R" --output ddg.csv

Install:

conda env create -f env.yml -n RDE && conda activate RDE

Usage:

python predict.py --pdb complex.pdb --mutations mutations.csv --output rde_predictions.csv

Install:

git clone https://github.com/anton-bushuiev/PPIformer.git && cd PPIformer
pip install -e .

Usage:

# Also available on HuggingFace Spaces
from ppiformer import PPIformer

model = PPIformer.from_pretrained()
ddg = model.predict(pdb="complex.pdb", mutations=["A:K48R", "A:L52A"])

Install:

git clone https://github.com/sodaball/H3-DDG.git && cd H3-DDG
pip install -r requirements.txt

Usage:

python predict.py --pdb complex.pdb --mutations mutations.csv --output h3ddg_results.csv

Install:

git clone https://github.com/luwei0917/BindingGYM.git && cd BindingGYM
bash install.sh

Install:

pip install ablang
# AbLang2 (newer):
pip install ablang2

Usage:

import ablang

# Load heavy chain (works for VHH nanobodies)
heavy_ablang = ablang.pretrained("heavy")
heavy_ablang.freeze()

seqs = ['EVQLVESGGGVVQPGGSLRL*SCAASGFTFNSYGMHWVRQAPGKGLE']

# Get embeddings
embeddings = heavy_ablang(seqs, mode='seqcoding')  # (N, 768)

# Restore masked residues
restored = heavy_ablang(seqs, mode='restore')
print(restored)

Install:

conda install -c conda-forge openmm pdbfixer
pip install ImmuneBuilder

Usage:

from ImmuneBuilder import NanoBodyBuilder2

predictor = NanoBodyBuilder2()
sequences = {'H': 'EVQLVESGGGVVQPGGSLRLSCAASGFTFNSYGMHWVRQAPGKGLEWVAFIRYDS'}
nanobody = predictor.predict(sequences)
nanobody.save("nanobody_model.pdb")

# CLI
NanoBodyBuilder2 --fasta_file nanobody.fasta -v

Install:

pip install igfold
conda install -c conda-forge openmm==7.7.0 pdbfixer   # for refinement

Usage:

from igfold import IgFoldRunner

igfold = IgFoldRunner()

# Nanobody (single heavy chain)
sequences = {"H": "EVQLVESGGGVVQPGGSLRLSCAASGFTFNSYGMHWVRQAPGKGLE"}
igfold.fold("nanobody_pred.pdb", sequences=sequences, do_refine=False, do_renum=True)

Install:

git clone https://github.com/dina-lab3D/NanoNet.git
cd NanoNet
pip install -r requirements.txt

Usage:

# Predict structures for a FASTA file
python NanoNet.py nanobodies.fasta -s -o ./NanoNetResults

# -s flag: save PDB files
# Output: one PDB per sequence in ./NanoNetResults/

from NanoNet import NanoNet

model = NanoNet()
pdb_string = model.predict("EVQLVESGGGVVQPGGSLRLSCAASGFTFNSYGMHWVRQAPGKGLE")
with open("nanobody.pdb", "w") as f:
    f.write(pdb_string)

Install:

pip install ABlooper

Usage:

from ABlooper import CDR_Predictor

pred = CDR_Predictor("antibody.pdb")
pred.predict_CDRs()
pred.write_antibody_with_predicted_CDRs("output.pdb")

Install:

pip install riot-na

Usage:

# CLI — number a VHH sequence
riot_na -s EVQLVESGGGVVQPGGSLRLSCAASGFTFSS --scheme imgt

# Batch numbering from FASTA
riot_na --fasta vhh_sequences.fasta --scheme imgt --output numbered.csv

from riot import Riot

riot = Riot(scheme="imgt")
result = riot.number("EVQLVESGGGVVQPGGSLRLSCAASGFTFSSYGMHWVRQAPG")
print(result.numbered_sequence)   # list of (pos, aa) pairs
print(result.CDRs)                # {'CDR1': [...], 'CDR2': [...], 'CDR3': [...]}

Install:

conda install -c bioconda abnumber
# or
pip install abnumber

Usage:

from abnumber import Chain

# Number a nanobody (VHH) sequence
chain = Chain('EVQLVESGGGVVQPGGSLRLSCAASGFTFNSYGMHWVRQAPGKGLEWVAFIRYDS', scheme='imgt')

print(chain.cdr1_seq)   # CDR1 sequence
print(chain.cdr2_seq)   # CDR2 sequence
print(chain.cdr3_seq)   # CDR3 sequence

# Iterate over numbered positions
for pos, aa in chain:
    print(pos, aa)

# Align two nanobodies
chain2 = Chain('QVQLVESGGGVVQAGGSLRLSCAASGFTFNSYGMHWVRQAPGKGLE', scheme='imgt')
for pos, (aa1, aa2) in chain.align(chain2):
    print(pos, aa1, aa2)

Install:

git clone https://github.com/prescient-design/abdiffuser.git
conda env create -f environment.yml && conda activate abdiffuser

Usage:

python scripts/design_nanobody.py \
  --antigen antigen.pdb \
  --epitope_residues A30,A33,A67 \
  --n_samples 50 \
  --output_dir outputs/

Install:

git clone https://github.com/THUNLP-MT/dyMEAN.git
conda env create -f environment.yml

Usage:

python design.py \
  --antigen_pdb antigen.pdb \
  --epitope A30,A33,A67 \
  --mode codesign \
  --n_samples 100 \
  --out_dir outputs/

Install (Docker):

git clone https://github.com/ProFoldBio/RFantibody.git && cd RFantibody
docker build -t rfantibody .
docker run --name rfantibody --gpus all -v $(pwd):/home -it rfantibody
# Inside container — download weights:
bash include/download_weights.sh

Usage:

# De novo nanobody CDR design targeting an antigen epitope
poetry run python /home/scripts/rfdiffusion_inference.py \
  --config-name antibody \
  antibody.framework_pdb=/home/nanobody_frameworks/h-NbBCII10.pdb \
  'ppi.hotspot_res=[T305,T456]' \
  inference.output_prefix=/home/outputs/nanobody \
  inference.num_designs=10

# ProteinMPNN sequence design on generated frameworks
poetry run python /home/scripts/proteinmpnn_interface_sequence_design.py \
  --pdb_dir /home/outputs/nanobody \
  --out_dir /home/outputs/sequences

Install:

git clone https://github.com/csi-greifflab/Absolut.git
cd Absolut/src
make
# Requires C++ compiler (g++) — no Python dependencies

Usage:

# Download an antigen structure and generate binding landscape
./Absolut getAntigen 1ADQ_A

# Screen a repertoire of nanobody CDR3 sequences against antigen
./Absolut repertoire 1ADQ_A nanobody_cdr3_seqs.txt

# Output: binding energies + structural codes for each sequence
# Use the results to train/evaluate generative models

# Python wrapper for analysis
import pandas as pd
results = pd.read_csv("1ADQ_A_Energies.txt", sep="\t")
top_binders = results.nsmallest(10, "Energy")
print(top_binders[["Sequence", "Energy", "Structure"]])

Usage:

# Requires Rosetta installation
rosetta_scripts.default.linuxgccrelease \
  -parser:protocol snugdock.xml \
  -s nanobody_antigen_start.pdb \
  -nstruct 500

Install:

conda create -n biophi python=3.9 && conda activate biophi
conda install biophi -c bioconda -c conda-forge
# Download OASis database (22GB):
wget https://zenodo.org/record/5164685/files/OASis_9mers_v1.db.gz && gunzip OASis_9mers_v1.db.gz
export OASIS_DB_PATH=/path/to/OASis_9mers_v1.db

Usage:

# Web interface
biophi web

# CLI humanization
biophi humanize input_nanobody.fasta --output humanized.fasta

# CLI OASis humanness scoring  
biophi oasis input_nanobody.fasta --output scores.csv

Usage:

import requests
r = requests.post("https://opig.stats.ox.ac.uk/webapps/sabdab-sabpred/sabpred/tap/api/",
    json={"vh_seq": "EVQLVESGGGVVQPGGSLRLSCAASGFTFNSYGMHWVR..."})
print(r.json())

Install:

git clone https://github.com/KrishnaswamyLab/TEMPRO.git
cd TEMPRO
pip install -r requirements.txt

Usage:

from tempro import TEMPRO

model = TEMPRO()
sequences = [
    "EVQLVESGGGVVQPGGSLRLSCAASGFTFNSYGMHWVRQAPGKGLEWVAFIRYDS",
    "QVQLVESGGGLVQAGGSLRLSCAASGYTFSSYGMHWVRQAPGKGLEWVSVIYSGN"
]
tm_predictions = model.predict(sequences)
for seq, tm in zip(sequences, tm_predictions):
    print(f"Predicted Tm: {tm:.1f} °C")

Install:

pip install iglm

Usage:

from iglm import IgLM

iglm = IgLM()

# Generate sequences conditioned on partial heavy chain
generated = iglm.sample(
    chain_token="[HEAVY]",
    species_token="[HUMAN]",
    seed_seq="EVQLVESGGG",
    n_seqs=100,
    do_sample=True,
    top_p=0.9
)
print(generated[:3])

Install:

pip install antiberty

Usage:

from antiberty import AntiBERTyRunner

runner = AntiBERTyRunner()
sequences = ["EVQLVESGGGVVQPGGSLRLSCAASGFTFNSYGMHWVRQAPGK"]
embeddings = runner.embed(sequences)  # list of (L, 512) tensors

Usage:

from ImmuneBuilder import ABodyBuilder2

predictor = ABodyBuilder2()
sequences = {
    'H': 'EVQLVESGGGVVQPGGSLRLSCAASGFTFNSYGMHWVRQAPGKGLEWVAFIRYDS...',
    'L': 'DIVMTQSPSSLSASVGDRVTITCRASQDIRNYLNWYQQKPGKAPKLLIYAASSLQS...'
}
antibody = predictor.predict(sequences)
antibody.save("antibody_model.pdb")

Install:

git clone https://github.com/RosettaCommons/DeepAb.git
conda env create -f DeepAb/environment.yml && conda activate deepab

Usage:

python DeepAb/predict.py \
  --heavy heavy_chain.fasta \
  --light light_chain.fasta \
  --out antibody_predicted.pdb

Install:

pip install tfold
# or from source:
git clone https://github.com/TencentAI4S/tFold.git && cd tFold
conda env create -f environment.yml && conda activate tfold

Usage:

import tfold

ppi_model  = tfold.model.esm_ppi_650m_ab()
fold_model = tfold.model.tfold_ab_trunk()
predictor  = tfold.deploy.PLMComplexPredictor.restore_from_module(
                 ppi_model, fold_model)

data = [
    {"id": "H", "sequence": "QVQLVQSGAEVKKPGASVKVSC..."},
    {"id": "L", "sequence": "EIVLTQSPGTLSLSPGERATLS..."}
]
predictor.infer_pdb(data, 'output.pdb')

Usage:

# Requires Rosetta
antibody_designer.default.linuxgccrelease \
  -s antibody.pdb \
  -antibody:design_cdrs H3 L3 \
  -nstruct 200

Install:

git clone https://github.com/crowelab/PyIR.git && cd PyIR
pip install .
# Requires IgBLAST database download (script provided in repo)

Usage:

from pyir.pyir import PyIR

parser = PyIR(query='sequences.fasta', args=['--outfmt', '7'])
results = parser.run()    # returns pandas DataFrame
print(results[['sequence_id', 'v_gene', 'j_gene', 'cdr3_aa']])

# CLI
PyIR --outfmt json sequences.fasta > annotated.json

Install:

pip install parapred

Usage:

from parapred import predict_paratope

heavy_seq = "EVQLVESGGGVVQPGGSLRLSCAASGFTFNSYGMHWVRQAPGK"
light_seq = "DIVMTQSPSSLSASVGDRVTITCRASQDIRNYLNWYQQKPGK"

probs = predict_paratope(heavy_seq, light_seq)
# probs: per-residue probability of being in paratope

Install:

# Web server — no pip package; access via DTU server or REST API
curl -X POST "https://services.healthtech.dtu.dk/cgi-bin/webface3.fcgi" \
  -F "[email protected]" \
  -F "method=bepipred3"

Install:

git clone https://github.com/luost26/diffab.git
conda env create -f env.yaml -n diffab && conda activate diffab
# Download weights from HuggingFace (see README)

Usage:

# Design CDRs for an antibody-antigen complex
python design_pdb.py ./data/examples/7DK2_AB_C.pdb \
  --config ./configs/test/codesign_single.yml

# Design all 6 CDRs simultaneously  
python design_pdb.py antigen_antibody.pdb \
  --config ./configs/test/codesign_multicdrs.yml

Install:

git clone https://github.com/THUNLP-MT/MEAN.git && cd MEAN
pip install -r requirements.txt

Usage:

# Design CDR-H3 conditioned on antigen
python design.py \
  --antigen antigen.pdb \
  --framework framework.pdb \
  --cdr H3 \
  --n_samples 100 \
  --output designed_cdrs/

Install:

git clone https://github.com/23AIBox/DualGPT-AB.git && cd ab-gen
pip install -r requirement.txt

Usage:

python generate.py --target antigen --n_seqs 1000 --properties "specificity,stability"

Install:

git clone https://github.com/bytedance/AnewOmni.git && cd AnewOmni
conda env create -f env_cuda124.yaml && conda activate anewomni

Usage:

python run.py --target antigen.pdb --design_mode cdr_h3 --n_designs 100

Install:

git clone https://github.com/yangnianzu0515/MFDesign.git && cd MFDesign
pip install -r requirements.txt

Usage:

python design.py --antigen antigen.pdb --cdr_regions H3 --n_designs 100 --output designs/

Install:

git clone https://github.com/jiawei-chen/MAPE-PPI.git
pip install -r requirements.txt

Install:

git clone https://github.com/oxpig/Graphinity.git && cd Graphinity
pip install -r requirements.txt

Usage:

python predict.py --pdb antibody_antigen.pdb --mutations "H:K48R,H:L52A" --output ddg.csv

Install:

git clone https://github.com/rs239/ablm.git && cd ablm
pip install -e .

Usage:

from ablm import AbMAP

model = AbMAP.load_pretrained('abmap_sars2')
variants = ["EVQLVESGGG...", "EVQMVESGGG..."]
scores = model.predict_affinity(variants, antigen="spike_RBD")
# Returns list of predicted affinity scores
top_hits = sorted(zip(scores, variants), reverse=True)[:10]

Install:

git clone https://github.com/patrickbryant1/EvoBind.git
# Colab: https://colab.research.google.com/github/patrickbryant1/EvoBind/blob/master/EvoBind.ipynb
# Local: requires AlphaFold2 installation
pip install alphafold

Usage:

# Run directed evolution loop (50 rounds, CDR-H3 target)
python3 evobind.py \
  --target_pdb antigen.pdb \
  --peptide_seq EVQLVESGGG \
  --hotspot_residues A30,A33,A34 \
  --n_rounds 50 \
  --n_mutations_per_round 5 \
  --output_dir ./evobind_results/

Install:

git clone https://github.com/TencentAI4S/HuDiff.git && cd HuDiff
pip install -e .
# Download model weights (see README)

Usage:

# Humanize antibody (VH+VL FASTA)
python humanize.py \
  --input chimeric_ab.fa \
  --output humanized_ab.fa \
  --model hudiff_ab   # or hudiff_nb for nanobody

# Evaluate humanness score before/after
python score_humanness.py --input humanized_ab.fa

Install:

git clone https://github.com/wengong-jin/abdockgen.git && cd abdockgen
pip install -r requirements.txt
# Download pretrained checkpoints from README link
wget https://zenodo.org/record/... -O ckpts.tar.gz && tar xf ckpts.tar.gz

Usage:

# Docking only (HERN)
python predict.py ckpts/HERN_dock.ckpt data/rabd/test_data.jsonl

# CDR H3 generation + docking (ABDockGen)
python generate.py ckpts/HERN_gen.ckpt data/rabd/test_data.jsonl 1 > results/HERN.txt

Install:

pip install rna-fm
# or from source:
git clone https://github.com/ml4bio/RNA-FM.git
conda env create -f environment.yml && conda activate RNA-FM
pip install .

Usage:

import torch, fm

model, alphabet = fm.pretrained.rna_fm_t12()
batch_converter = alphabet.get_batch_converter()
model.eval()

data = [("aptamer1", "GGTTGGTGTGGTTGG")]  # thrombin aptamer
_, _, tokens = batch_converter(data)

with torch.no_grad():
    results = model(tokens, repr_layers=[12])
embedding = results["representations"][12]  # (1, L+2, 640)

# Predict secondary structure via CLI
python launch/predict.py \
  --config pretrained/ss_prediction.yml \
  --data_path sequences.fasta \
  --save_dir ./results

Install:

git clone https://github.com/CatIIIIIIII/ERNIE-RNA.git
pip install -r requirements.txt

Install:

git clone https://github.com/yikunpku/RNA-MSM.git && cd RNA-MSM
conda env create -f environment.yml && conda activate RNA-MSM
# Download weights from repo releases page

Usage:

# Generate embeddings from MSA
python RNA_MSM_Inference.py \
  --input_fasta aptamer.fasta \
  --output_dir ./embeddings \
  --task ss_prediction   # secondary structure

import torch
from esm import pretrained

model, alphabet = pretrained.load_model_and_alphabet('RNA-MSM')
model.eval()
batch_converter = alphabet.get_batch_converter()
data = [("aptamer", "GGUUGGUGGUGUUGG")]
_, _, tokens = batch_converter(data)
with torch.no_grad():
    results = model(tokens, repr_layers=[33], return_contacts=True)
embeddings = results["representations"][33]

Install:

git clone https://github.com/automl/RNAformer.git && cd RNAformer
pip install -e .
# Or directly:
pip install rnaformer

Usage:

python infer_RNAformer.py \
  --sequence GGTTGGTGTGGTTGG \
  --model_config configs/RNAformer_32M_config.yaml \
  --pretrained_model pretrained/RNAformer_32M.pth

from RNAformer.model.RNAformer import RiboFormer
import yaml, torch

with open("configs/RNAformer_32M_config.yaml") as f:
    cfg = yaml.safe_load(f)
model = RiboFormer(cfg)
model.load_state_dict(torch.load("pretrained/RNAformer_32M.pth"))
model.eval()

Install:

git clone https://github.com/lbcb-sci/RiNALMo.git && cd RiNALMo
pip install .
pip install flash-attn==2.3.2 --no-build-isolation

Usage:

import torch
from rinalmo.pretrained import get_pretrained_model

model, alphabet = get_pretrained_model(model_name="giga-v1")
model = model.cuda()
model.eval()

seqs = ["GGTTGGTGTGGTTGG"]  # thrombin DNA aptamer / RNA sequence
tokens = torch.tensor(alphabet.batch_tokenize(seqs), dtype=torch.int64, device="cuda")

with torch.no_grad():
    outputs = model(tokens)

# outputs["representation"] → (batch, seq_len, 1280) embeddings
embeddings = outputs["representation"]

# Predict secondary structure
python scripts/secondary_structure/predict.py \
  --input aptamer.fasta \
  --output aptamer_ss.ct \
  --model_name giga-v1

Install:

git clone https://github.com/AIRI-Institute/Uni-RNA.git && cd Uni-RNA
pip install -e .
# Download weights from HuggingFace: AIRI-Institute/Uni-RNA

Usage:

from transformers import AutoTokenizer, AutoModel
import torch

tokenizer = AutoTokenizer.from_pretrained("AIRI-Institute/uni-rna")
model = AutoModel.from_pretrained("AIRI-Institute/uni-rna")
model.eval()

sequence = "GGTTGGTGTGGTTGG"
tokens = tokenizer(sequence, return_tensors="pt")

with torch.no_grad():
    outputs = model(**tokens)

# outputs.last_hidden_state → (1, seq_len, 768)
embeddings = outputs.last_hidden_state

Install:

git clone https://github.com/Sanofi-Public/CodonBERT.git && cd CodonBERT
pip install poetry
poetry install

Usage:

from codonbert import CodonBERT

model = CodonBERT.load_pretrained()

# Predict translation efficiency from codon sequence
mrna_seq = "ATGAAAGCCATTTTCAGAAATTTGTAA"
te_score = model.predict_translation_efficiency(mrna_seq)
print(f"Predicted TE: {te_score:.3f}")

# Get codon-level embeddings
embeddings = model.encode(mrna_seq)  # (n_codons, 768)