openfold-3: an Apache 2.0 reimplementation of AlphaFold 3 for structure prediction

A research preview with a name that says preview twice

The repository is called openfold-3, and the model it contains is called OpenFold3-preview. The README is clear about what that means: it is a research preview intended to gather community feedback and let developers start building on top of the OpenFold ecosystem. The stated aim is to be a bitwise reproduction of DeepMind's AlphaFold3, and the work comes from the AlQuraishi Lab at Columbia University together with the OpenFold consortium. A bitwise reproduction is a strong claim and an unusual goal for a reimplementation, since it implies the numeric output should match rather than merely be equivalent. The project states that the repository is freely available for academic and commercial use under the Apache 2.0 licence, and the licence field in the package metadata says the same. The preview framing matters for how you read the release history: the tags are v0.5.0, 0.4.5 and 0.4.4, and the version numbering has not reached 1.0.

The default weights changed in 0.5.0, and that breaks older instructions

This is the single most important operational detail in the README, and it is easy to miss because it sits in a section about parameters. Each parameter set is compatible with a specific range of OpenFold3 releases, and the documentation holds a table of parameter sets against the versions they work with. The default parameters shipped with OpenFold3 0.5.0 and later are OpenBind-0, which is trained using the forthcoming OpenFold3 architecture with a June 2025 training cutoff. The recommendation is to use OpenBind-0 over OpenFold3-preview2 for everyday usage. If you want the older weights, the instruction is to install an older release of OpenFold3, and the documentation has a page on using an older set of parameters. The technical report on the project portal describes the OpenFold3-preview2 model version, and the README notes that those weights need an older release. In other words, a tutorial written for preview2 will not run unchanged on a current install, and the technical report you are most likely to find describes parameters the current release no longer defaults to.

Three commands from a fresh install to a predicted structure

The quick start is short, and it is worth following exactly, because the second step is what downloads the model parameters and the third step is what actually runs a prediction. The package comes from pip:

pip install openfold3 

Then the setup command, which prepares the installation and downloads the model parameters:

setup_openfold

And finally the inference binary, run against one of the bundled example inputs, using the ColabFold MSA server:

run_openfold predict --query_json=examples/example_inference_inputs/query_ubiquitin.json

The README warns that you may also need to configure your environment variables depending on your system, and links to the environment variable section of the installation documentation for that. The example inputs live in the examples directory of the repository, and more input and output examples are published on Hugging Face under the OpenFold organisation, so a first run does not require you to author a query file before you can see output. The example given is a ubiquitin query, which is a small protein and a reasonable first target.

What the model actually predicts

The feature list is a description of the input surface the model replicates, and it says the project replicates the input features described in the AlphaFold3 publication, plus batch job support and efficient kernel-accelerated inference. Concretely, it does structure prediction for standard and non-canonical protein, RNA and DNA chains, and for small molecules. That last combination is what separates AlphaFold 3 style models from the protein-only tools that came before, and the README claims that openfold-3 is the only model to match AlphaFold3's performance on monomeric RNA structures. For input preparation, there are pipelines for generating MSAs either through the ColabFold server or locally with JackHMMER and hhblits following the AlphaFold3 protocol, and there are structure templates for protein monomers. The practical consequence is that the MSA step, which is where a lot of the compute traditionally goes, can be done on someone else's servers or on your own machine, and that choice affects both cost and reproducibility.

Kernels and multi-GPU are the parts that need hardware

Two performance features are singled out, and they are the ones that make the project interesting to run at scale. Kernel acceleration comes through cuEquivariance and through DeepSpeed4Science kernels for the Evoformer attention, with a dedicated documentation page describing how to enable them. Batch job support means predictions can be submitted as jobs rather than one at a time, and multi-query jobs are supported with distributed predictions across multiple GPUs. There are also custom settings for memory constrained GPU resources, described in the documentation as a low memory mode, which matters because structure prediction on large complexes is exactly where a GPU runs out of memory. The honest framing here is that this is the part of the project where the hardware bill shows up, and the multi-GPU and kernel paths are where the performance numbers in the benchmark section come from.

The training data is published, not just the model

The commitment behind this repository is deeper than shipping weights, and the dataset section is the reason. The project provides the full training data for reproducing OpenFold3-preview, including its reproduction of the MGnify-based 13M-sequence distillation dataset described in the AlphaFold3 paper. There is a datasets page on the project portal with access details. A model release is a fixed artefact, while a training data release is a way for other groups to redo the work, check it, or train something different on the same footing. The dependency list shows what that costs in practice: PyTorch Lightning at 2.1 or newer for the training loop, wandb for experiment tracking, lmdb for the data store, and AWS libraries including awscli, awscrt and boto3, which is what you need to pull the dataset down at volume. The dev extra adds pytest with several plugins, including pytest-regressions and pytest-vcr, alongside mypy, ruff and pre-commit, and the repository carries a mypy-baseline.txt file, which tells you the type checking is run but with a recorded set of accepted exceptions.

Benchmarks are published, and the comparisons are named

The README publishes benchmark results against other models, and being specific about which benchmarks is what makes them checkable. The OpenFold3-preview2 results are shown for Runs N Poses performance, for the FoldBench interface performance, and for the AF3 antibody-antigen set, each as a figure in the repository. The underlying sources are named: Runs and Poses and FoldBench are biorxiv preprints, and the antibody-antigen set comes from the AlphaFold3 publication in Nature. The whitepaper for the preview2 model on the project portal covers the inference procedures and benchmarking methods in more detail. The stated claim is that OpenFold3-preview performs competitively with the state of the art in open source biomolecular structure prediction, while being the only model to match AlphaFold3's performance on monomeric RNA structures. Treat these as the project's own reported results on published benchmarks, and note that the figures are for preview2, which is not the default parameter set in the current release.

An Apache 2.0 licence is the reason to prefer this over a research-only release

The licence is the practical differentiator, and it is stated in two places. The README says the repository is freely available for academic and commercial use under the Apache 2.0 licence, and the package metadata records the same licence with the OSI approved Apache Software License classifier, alongside POSIX Linux as the operating system and Python 3.10 through 3.14 as the supported versions. Apache 2.0 permits commercial use and modification with attribution and with the patent and notice conditions attached, and that is a meaningful difference from the position you are in with a model whose weights are available for research but whose licence restricts commercial use. The project also states a commitment to long-term maintenance and open source support, and the last push was on 2026-10-19, with the most recent release v0.5.0 on 2026-08-21 described as the OpenBind Model Release. What the licence does not do is make the model accurate, and the preview status means the interface and the defaults may still change under you, as the 0.5.0 parameter switch shows.

Editorial conclusion

openfold-3 suits a research group that needs AlphaFold 3 style prediction under a permissive licence, wants the training data so it can retrain rather than only run inference, and has the GPU budget for the cuEquivariance and DeepSpeed4Science kernels. It does not suit someone who needs a stable, supported model today, because the default parameters changed with the 0.5.0 release and the technical report on the portal still describes preview2. Before running anything, check which parameter set your installed release expects, because the OpenBind-0 weights need 0.5.0 or newer and the preview2 weights need an older release, and read the environment variable page if your system is not a plain Linux install.

Frequently asked questions

Official sources

1. aqlaboratory/openfold-3 on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases