OpenDDE-Preview

OpenDDE is an open-source, all-atom biomolecular foundation model that turns co-folding into a scalable engine for structure prediction, design, and optimization in drug discovery.

[!IMPORTANT] OpenDDE is a preview release. CLI flags, input/output JSON fields, and released checkpoints may change between versions, and predictions are not guaranteed to be reproducible across releases. It is not yet intended for production pipelines. Please open an issue for bugs, regressions, or feature requests.

News

2026-10-09: We release OpenDDE v1.2.0 with constraint-guided (conditional) inference! Read the technical report.
- Steer the sampler with partial knowledge of an antibody–antigen interface (contacts, movable chains, epitope) via --use_tfg_guidance true, without changing the weights. See docs/tfg_constraint_guidance.md
- Ready-to-run examples are available in examples/tfg, and the new antibody–antigen panel lists are in benchmarks/OpenBench2026
2026-07-03: We release OpenDDE-preview (co-folding)! Read the technical report and visit the website.
- Model weights can be downloaded from Hugging Face: opendde.pt | opendde_abag.pt
- The Docker image can be pulled with docker pull aurekaresearch/opendde:v1
- The 2026ARK-AB Benchmark is now available

Installation

OpenDDE supports CPython 3.11, 3.12, and 3.13. We recommend uv for Python installations. Choose one of the following methods.

Install from PyPI

uv venv --python 3.11

CPU:

uv pip install --python .venv --torch-backend cpu opendde

NVIDIA GPU (Linux x86_64, CUDA 12.6):

uv pip install --python .venv --torch-backend cu126 "opendde[gpu]"

Install from source

git clone https://github.com/aurekaresearch/OpenDDE.git
cd OpenDDE
uv venv --python 3.11

CPU:

uv pip install --python .venv --torch-backend cpu -e .

NVIDIA GPU (Linux x86_64, CUDA 12.6):

uv pip install --python .venv --torch-backend cu126 -e ".[gpu]"

After a PyPI or source installation, verify the environment with:

uv run --no-project --python .venv opendde doctor

Use Docker

The prebuilt image targets NVIDIA GPU inference:

docker pull aurekaresearch/opendde:v1

See the Docker guide for GPU setup, runtime-data mounts, and a complete docker run example.

[!NOTE] --torch-backend selects the PyTorch build, while [gpu] adds the optional cuEquivariance kernels. Linux wheels require glibc 2.28 or newer. Apple Silicon runs on CPU or on the Metal (MPS) backend with --device mps; Intel macOS is unsupported, and Windows has not been validated. At runtime, --device auto uses CUDA when available, then MPS, and otherwise falls back to CPU.

For runtime-data setup and additional installation details, see the inference instructions.

Model and Runtime Data

OpenDDE reads checkpoints and runtime assets from OPENDDE_ROOT_DIR, defaulting to ~/.cache/opendde when the environment variable is unset:

$OPENDDE_ROOT_DIR/
├── checkpoint/opendde.pt
├── common/
└── search_database/        # needed for local template/RNA-MSA preprocessing

From a source checkout, use the repository helper script to prepare the runtime layout:

export OPENDDE_ROOT_DIR=/path/to/opendde_data
bash scripts/download_opendde_data.sh

The helper script lives in the source tree and is not installed with the opendde Python package. If you installed OpenDDE from a wheel or package index, either run the script from a cloned checkout, or let opendde pred download the default checkpoint and common runtime files when they are missing. You can also place checkpoint files manually under $OPENDDE_ROOT_DIR/checkpoint/.

Python-managed checkpoint and common-asset downloads use a release-pinned revision, published size, and SHA-256 before atomic replacement. The source helper independently verifies released checkpoints; external search databases are prepared separately. A checkpoint supplied with --load_checkpoint_path is never replaced automatically.

For a prediction that disables protein MSA, template search, and RNA MSA, the large search_database/ files are not needed. From a source checkout, use:

bash scripts/download_opendde_data.sh --skip-search-database

Released checkpoints:

Checkpoint	Use case	Download
`opendde.pt`	General-purpose checkpoint.	opendde.pt
`opendde_abag.pt`	Checkpoint tuned on antibody-antigen.	opendde_abag.pt

Use opendde.pt with -n opendde_v1 for the default model. For ABAG runs, keep the filename as opendde_abag.pt and pass it explicitly:

opendde pred \
  -i input.json \
  -o ./output \
  --load_checkpoint_path "$OPENDDE_ROOT_DIR/checkpoint/opendde_abag.pt"

Detailed asset setup, mirrors, and Docker data mounts are documented in inference instructions.

Running Your First Prediction

Save this minimal OpenDDE input as tiny.json:

[
    {
        "name": "tiny",
        "modelSeeds": [101],
        "sequences": [
            {
                "proteinChain": {
                    "sequence": "ACDEFGHIK",
                    "count": 1
                }
            }
        ]
    }
]

Run a small compatibility-oriented prediction. This disables external feature searches, so only the checkpoint and common runtime files are required:

opendde pred \
  -i tiny.json \
  -o ./output \
  -n opendde_v1 \
  --use_msa false \
  --use_template false \
  --use_rna_msa false \
  --sample 1 \
  --step 200 \
  --cycle 10

Defaults are applied automatically: inference runs in bf16 with TF32 off, triangle kernels use auto dispatch, and seeds come from the job's modelSeeds unless --seeds is provided. On CPU this example may be slow, but it avoids GPU-only kernels and large search databases.

Outputs are written under:

output//seed_/predictions/

For production runs, enable the preprocessing features you need, for example --use_msa true, --use_template true, or --use_rna_msa true. Those paths may require network access, HMMER/Kalign binaries, and large local search databases; see the inference guide for details.

Multi-GPU Fold-CP Inference

[!IMPORTANT] Multi-GPU Fold-CP does not support cuEquivariance triangle kernels, so use --trimul_kernel torch --triatt_kernel torch. Distributed auto requests resolve to these PyTorch kernels, while an explicit cuEquivariance request is rejected before model loading. On CUDA BF16, the distributed PyTorch triangle-attention path uses the Triton dependency from the GPU install extra to fuse attention-bias addition. See the Fold-CP reproduction guide for controlled launch commands and validation guidance.

OpenDDE supports a 1 x P Fold-CP inference mode for larger inputs, where P can be any available GPU count greater than one. Launch it with torchrun so that one process runs on each GPU. For example, four GPUs use:

CUDA_VISIBLE_DEVICES=0,1,2,3 torchrun --standalone --nproc_per_node 4 \
  -m runner.batch_inference pred \
  -i examples/cofold/protein_200.json \
  -o ./output_foldcp \
  -n opendde_v1 \
  --use_msa false \
  --use_template false \
  --use_rna_msa false \
  --sample 1 \
  --step 200 \
  --cycle 10 \
  --trimul_kernel torch \
  --triatt_kernel torch \
  --foldcp_mode distributed \
  --foldcp_size_dp 1 \
  --foldcp_size_cp 4

Only the 1 x P topology is supported. --nproc_per_node must equal --foldcp_size_cp P; --foldcp_size_dp is retained only for command-line compatibility and must remain 1. The example uses P=4; replace both occurrences of 4 with the desired P. For normal single-GPU or CPU inference, omit the Fold-CP flags or use --foldcp_mode single --foldcp_size_cp 1.

Input JSON

OpenDDE input is a top-level list of jobs. Each job contains sequences entries such as proteinChain, dnaSequence, rnaSequence, ligand, or ion. covalent_bonds is optional and should be added only when explicit covalent links are needed.

See the input JSON format for the full schema, including covalent bonds, ligands, modifications, MSA paths, and template paths.

CLI Overview

opendde pred    # run inference
opendde doctor  # inspect Python/CUDA/kernel setup
opendde json    # convert PDB/CIF structures to OpenDDE JSON
opendde msa     # protein MSA preprocessing
opendde mt      # protein MSA + template preprocessing
opendde prep    # protein MSA + template + RNA MSA preprocessing

Use opendde --help for command-specific options. Public model names currently include opendde_v1; use --load_checkpoint_path for alternate checkpoint files such as opendde_abag.pt.

Documentation

Citation and Acknowledgements

If you use OpenDDE in your work, please cite this software and the related work. OpenDDE builds on ideas and components from the AlphaFold 3 ecosystem, including AlphaFold 3, Protenix, OpenFold, and ColabFold.

License

OpenDDE is released under the Apache-2.0 license. See LICENSE.

OpenDDE