Molecular docking sits at the heart of structure-based drug discovery. If we can reliably predict how a small molecule binds in a protein pocket, we can prioritize compounds faster, reason about interactions more clearly, and build better pipelines for hit discovery and lead optimization. But in practice, docking is still a difficult problem: classical methods are often robust but imperfect, while recent deep learning approaches have sometimes looked promising on headline metrics without consistently producing chemically plausible poses.
SigmaDock was built to address exactly that gap. Instead of treating docking as a problem of directly diffusing on torsion angles or unconstrained atomic coordinates, SigmaDock represents ligands as collections of rigid fragments and learns how to reassemble them inside the binding pocket using diffusion on . In plain English: rather than trying to “wiggle” every flexible degree of freedom in a tangled way, SigmaDock breaks the ligand into chemically meaningful rigid pieces and learns where those pieces should go, and how they should reorient, to recover a valid bound pose.
Why fragment-based diffusion?
A central observation behind SigmaDock is that torsional models are elegant in theory, but difficult in practice. Small changes in torsion angles can create large, non-local changes in Cartesian coordinates, which makes the learning problem highly entangled. SigmaDock avoids that by moving to fragment space: each rigid fragment is handled as a body in , and the model learns rigid-body translations and rotations rather than directly predicting torsional updates. The result is a cleaner geometric parameterization and a more stable generative problem.
This is paired with a fragmentation strategy called “FR3D”, which does more than just cut every rotatable bond. A naïve split would often create too many fragments and inflate the degrees of freedom. FR3D recursively merges adjacent fragments to reach an irreducible representation, reducing the number of independent rigid bodies while preserving the chemistry that matters. On top of that, SigmaDock adds soft triangulation constraints so the model keeps bond lengths and bond angles consistent across fragment boundaries — without locking the dihedral degrees of freedom it still needs to explore.
bonds and removes over-constrained dummies in the process (denoted by the coloured rings), which otherwise define a dihedral across the merged fragment; (c) Over-constrained dummies removed and triangulation edges displayed under a different stochastic reduction (equiprobable to the fragmentation shown in b).
What makes SigmaDock different architecturally?
At the modelling level, SigmaDock uses an SE(3) Riemannian diffusion process over fragment translations and rotations, together with an SO(3)-equivariant architecture built on top of EquiformerV2-style reasoning for protein–ligand geometry. The model also augments the graph with virtual nodes and edges to improve long-range information flow, and uses pseudo-force predictions to make the score parameterization invariant to arbitrary choices of local fragment coordinate axes.
That sounds abstract, but the practical point is simple: SigmaDock was designed so that the geometry, chemistry, and inductive biases all line up with the actual structure of the problem. The paper’s main message is not just that a bigger model can do better docking, but that a better geometric formulation can make the learning task fundamentally easier and more reliable.
How well does it work?
In the paper, SigmaDock is evaluated on the standard re-docking setup with a fixed receptor and known pocket. On the PoseBusters split, the reported Top-1 success rate with both RMSD < 2 Å and PB-validity is 79.9%, and the paper presents SigmaDock as the first deep-learning docking method to surpass classical docking under the intended PoseBusters train/test split. The paper also reports strong generalization to unseen proteins and near-perfect Top-1 performance above 90% on the Astex Diverse Set.
Just as importantly, the paper emphasizes that SigmaDock achieves these results without relying on a separate confidence model to filter poor generations. Instead, it uses lightweight post hoc ranking based on pseudo-binding energy and physicochemical checks. The paper also reports that performance is competitive with AF3-level docking performance while using a much smaller training set and substantially faster sampling.
What’s in the codebase?
The GitHub repo is the official implementation for training, sampling, and evaluation. It includes:
- installation via
install.sh - Hydra-based training and sampling scripts
- experiment configs under
conf/experiments/ - sampling config under
conf/sampling/base.yaml - SLURM helper scripts
- notebooks for visualization, pocket inspection, sampling, and metrics
- optional checkpoint-based inference from the repo’s release flow.
The repository is currently marked as a beta release, so APIs and behavior may still evolve.
How to use SigmaDock
Getting started is straightforward.
1) Install from source
git clone https://github.com/alvaroprat97/sigmadock.git cd sigmadock conda create -y -n sigmadock python=3.12 conda activate sigmadock bash install.sh
You can also specify a CUDA build and optional extras such as train, dev, and test. The repo documentation lists Python >=3.9, <3.13 and CUDA support for GPU training/sampling.
2) Prepare your data
SigmaDock expects a data root with one folder per complex. For a simple re-docking case, each complex folder should contain a protein .pdb and ligand .sdf. The repo also supports workflows where a separate reference ligand defines the pocket and center-of-mass, which is useful for cross-docking-style setups. These patterns are controlled through experiment configs such as pdb_regex, sdf_regex, and optional ref_sdf_regex.
A minimal layout looks like this:
<data_root>/ <experiment_subdir>/ 1abc/ protein.pdb ligand.sdf
3) Run sampling with a checkpoint
The repo documents a released-checkpoint workflow through scripts/sample.py. A typical command looks like this:
python scripts/sample.py \ sampling.experiments.name=posebusters \ sampling.data.data_dir=/path/to/data \ sampling.model.ckpt_dir=/path/to/checkpoint.ckpt \ sampling.data.batch_size=16
Sampling is driven by Hydra configs, so most behavior can be overridden from the command line or via YAML.
4) Optional rescoring and validation
SigmaDock can optionally use GNINA for AutoDock Vina/Vinardo-style rescoring. If GNINA is not installed, the pipeline still runs and falls back to heuristic physicochemical metrics for pose selection. The repo also supports PoseBusters checks through sampling config options.
Why this matters
One of the recurring questions in ML for molecular modelling is whether progress is coming from better ideas or simply from more data and more compute. SigmaDock makes a strong case for the former. The project is built around a geometric reparameterization of docking that is chemically motivated, computationally lighter than co-folding, and empirically much more reliable than many prior generative docking baselines when chemical validity is taken seriously.
That is also why I think SigmaDock is interesting beyond a single benchmark result. The fragment-space SE(3) formulation naturally suggests extensions to flexible docking and even co-folding, because the same framework can be extended by treating selected side chains or other movable units as additional fragments. The paper explicitly points to those directions as future work.
Current limitations
It is worth being clear about what SigmaDock is and is not solving today.
First, the paper deliberately focuses on rigid-receptor re-docking with a specified pocket, because that is still the fairest regime for direct comparison with established docking baselines. Second, the model currently depends on a user-specified pocket center at inference time, so poor pocket specification can bias the search region. Third, the training setup was intentionally restricted to PDBBind v.2020 to enable fair comparison on the PoseBusters split, which means out-of-distribution robustness can likely improve further with more curated data, augmentation, pretraining, or larger-scale training.
That honesty is one of the strengths of the work: the paper does not pretend SigmaDock is the final answer to all docking settings. Instead, it argues that fragment-based SE(3) diffusion is a principled foundation that already performs strongly in the classical docking regime and should scale well into harder settings.
Final thoughts
SigmaDock started from a simple but powerful idea: docking becomes easier when the model is allowed to reason in the right space. By operating on rigid fragments in SE(3), rather than directly wrestling with a tangled torsional representation, SigmaDock turns molecular docking into a cleaner geometric generative problem. The result is a method that is not only accurate, but also much more chemically coherent and practically usable.
If you are interested in geometric deep learning for chemistry, diffusion models on manifolds, or practical protein–ligand docking, SigmaDock is meant to be both a research contribution and a usable codebase. The repository already provides the pieces needed to install, prepare data, sample from checkpoints, validate outputs, and build on top of the method.
