AlphaFold3 is Google DeepMind's official command-line application for running AlphaFold 3 biomolecular structure prediction inference. The dominant character is a production-grade scientific application, though it is heavily intertwined with research data pipelines: it ingests a JSON job specification describing protein, RNA, DNA, and ligand chains, runs Jackhmmer/Nhmmer searches over large genetic databases, builds multiple sequence alignments, searches structural templates with HMMER, featurizes the input into JAX/Haiku tensors, samples structures with a diffusion model, and writes predicted structures as mmCIF files plus confidence JSON (pLDDT, PAE, pTM, ipTM). The codebase is not a training repository; it provides inference only and requires separately downloaded model parameters under restrictive legal terms. Architecturally, the system is a multi-stage pipeline driven by the `run_alphafold.py` entry point. Core modules include the data pipeline (`src/alphafold3/data/pipeline.py`), MSA/template tools (`src/alphafold3/data/tools/`), a structure representation layer (`src/alphafold3/structure/`), JAX geometric primitives (`src/alphafold3/jax/geometry/`), the neural network model (`src/alphafold3/model/`), and performance-critical C++ pybind11 extensions for mmCIF parsing, MSA feature extraction, and string/array operations. It depends on external binaries (Jackhmmer, Nhmmer, HMMER suite), RDKit for ligand conformer generation, JAX/Haiku for model execution, and ~630 GB of downloadable sequence and structure databases. The repository is actively maintained, with recent commits and CI running CPU-only data tests. Technical drift is low for a research release: dependencies are pinned via `pyproject.toml` and `uv.lock`, and active maintenance keeps it aligned with its ecosystem, though the C++ build, GPU-specific requirements, and external database URLs remain fragility points.
Protenix is a production-oriented PyTorch implementation of AlphaFold 3 for biomolecular structure prediction, maintained by ByteDance. It is best classified as an application rather than a pure research codebase: it ships a `protenix` CLI with commands for prediction, input conversion, MSA/template/RNA-MSA search, and data preparation, plus training/fine-tuning entry points, batch inference runners, Docker deployment, web-service helpers, and PyPI packaging. The code ingests PDB/CIF, FASTA, SMILES/SDF, and JSON descriptors covering proteins, DNA, RNA, ligands, ions, modified residues, covalent bonds, and contact/pocket constraints, then outputs predicted 3D CIF structures with confidence metrics such as pLDDT, PAE, pTM, and ipTM.
PLINDER is a comprehensive protein-ligand interaction dataset and evaluation resource, providing over 400,000 annotated systems with 750+ annotation columns derived from the PDB. The repository contains a full data generation pipeline (Metaflow-based, configurable via YAML) that downloads, annotates, scores, clusters, and splits structures into train/val/test sets with leakage control. It also includes a Python API (PlinderSystem, PlinderDataset) for accessing the dataset, querying similarity scores, and loading structures, as well as an evaluation harness (ModelScores, StratifiedTestSet) for benchmarking docking algorithms using metrics like lDDT-PLI, DockQ, and posebusters checks. The codebase is hybrid: primarily a data research project with strong software engineering practices (Docker, CI/CD, extensive tests, config-driven pipelines), but the core value is the curated dataset and the tools to generate and evaluate it.
BoltzGen is a deep learning pipeline for computational protein and peptide binder design. It provides a command-line interface (boltzgen) that orchestrates a multi-step workflow: diffusion-based backbone generation, inverse folding (sequence design given structure), folding with Boltz-2, affinity prediction, analysis, and filtering/ranking of designs. The system supports diverse protocols including protein, peptide, nanobody, antibody, and small-molecule targeting, with extensive conditioning options like binding sites, disulfide bonds, cyclization, and per-residue constraints. The codebase is structured as a Python package with modular components for data parsing (YAML design specs, mmCIF/PDB), featurization, tokenization, cropping, and model layers (pairformer, attention, diffusion, inverse folding). It includes training pipelines with Hydra configuration, PyTorch Lightning, and validation splits. While primarily an application, it also contains research-grade example datasets and a Jupyter notebook for filtering, reflecting its origin in a bioRxiv publication. The architecture is well-organized but shows some technical drift (hardcoded paths, print statements, broad exception handling) and dependency on specific CUDA versions.
SimpleFold is a research repository focused on protein structure prediction using flow-matching generative models. While it includes application-like features such as a CLI and inference scripts, its core architecture is designed for ML research, specifically training and evaluating large-scale diffusion transformers (FoldingDiT) on structural biology data. The codebase is hybrid in nature, combining rigorous data engineering pipelines (parsing MMCIF, filtering, tokenization) with standard deep learning frameworks (PyTorch Lightning, Hydra). It supports dual backends (PyTorch and MLX) for inference, indicating a focus on accessibility across hardware platforms. The repository's primary value lies in its data processing pipeline, which is heavily adapted from the Boltz-1 project. It handles complex structural data (PDB, SwissProt, AFESM) through a modular pipeline including parsing, filtering, and tokenization. The model architecture implements flow-matching with ESM-2 embeddings for sequence context. Evaluation metrics include pLDDT confidence, TM-score, and RMSD, typical for structural biology research. However, the codebase exhibits signs of research-to-production transition challenges. Hardcoded paths (e.g., `/mnt/task_runtime/...`) and reliance on external binaries (TMscore, OpenStructure) reduce portability. The data pipeline is a fork of an external project (`boltz`), introducing maintenance overhead for divergence. Despite these issues, the use of Hydra for configuration management and PyTorch Lightning for training orchestration demonstrates solid engineering practices for an ML research project.
IgGM is a generative foundation model for antibody and nanobody design, implemented as a deep learning library with a command-line interface. The system performs tasks such as CDR loop design, framework region redesign (humanization), inverse design from complex structures, affinity maturation, and structure prediction. It uses a diffusion-based approach to co-design amino acid sequences and 3D backbone structures, leveraging an ESM2-based protein language model, Evoformer blocks with triangular attention, invariant point attention, and a structure module similar to AlphaFold2. The pipeline is orchestrated by the `AbDesigner` class and invoked via the `design.py` script, accepting PDB and FASTA inputs and generating output sequences and structures. The repository includes well-structured reusable components for rigid-body transformations (Rotation, Rigid), PDB parsing, coordinate conversion, and diffusion schedules, though some research artifacts (misspellings, commented code) and dependency pinning to older PyTorch/CUDA versions indicate moderate technical drift.