Lacuna Cryptic Pocket Detection on HPC or Any Cloud

What this workflow does

This workflow finds cryptic binding pockets. A cryptic pocket looks closed or shallow in an unbound structure. It only opens when something binds.

The workflow wraps Lacuna, published on PyPI as lacuna-pockets. Lacuna generates a conformational ensemble from the input structure. It detects pockets in every conformer. It clusters the pockets across the ensemble, so a site that appears in only a few frames still gets reported. It then ranks the survivors with a fitted model. The model also scores how much each site opens relative to the input. This is the crypticity score.

fpocket only proposes a pocket where the surface is already concave. A cryptic site breaks that assumption. Lacuna 1.1.0 adds a learned surface detector next to the original geometric one. The workflow pools both with --detector surface-fusion. Per the Lacuna README, pooling takes held-out CryptoBench coverage from 68.5% to 86.4%, and top-five recovery from 57.1% to 73.9%, over the geometric detector alone.

The bundled example is PDB 4LDJ, an apo, GDP-bound KRAS(G12C) structure with no switch-II inhibitor present. The switch-II pocket is absent from apo KRAS structures. It only forms on covalent inhibitor binding. KRAS is not in the benchmark that Lacuna's models were fitted on. Lacuna still surfaces the switch-II pocket twice in the top ten. Every site ranked above it is the GDP pocket, a real pocket with a real ligand already bound.

The compute problem

The workflow has two stages with different weights.

The discover stage generates the ensemble, runs detection on every conformer, clusters and ranks. This stage is the expensive one. It scales with the number of conformers and the ensemble backend. The default normal mode analysis backend runs on a CPU. The example takes about one to two minutes with 20 conformers.

The report stage turns the JSON report into an HTML page and a CSV table. It uses the Python standard library only. It runs in under a second.

Higher-fidelity ensembles change the hardware picture. The openmm backend runs short implicit-solvent MD. The boltz backend uses diffusion sampling and needs a GPU. A larger ensemble on either backend outgrows a laptop.

How Horus solves it

Horus builds the Lacuna environment for you. The uv_python_environment executor installs lacuna-pockets into a dedicated venv on the first run. No conda or container toolchain is needed for the defaults.

Each stage has its own executor and target. The report stage stays local. To scale ensemble generation onto a cluster, give the discover task a target: and a resources: block. The runtime.command string does not change. The same YAML file runs on a laptop and on a cluster.

Horus moves the pocket folder back from the discover host to the report stage. You write no copy commands.

Pipeline

receptor.pdb ──► discover (uv venv, CPU) ──► results/pockets/
                    │  ensemble → per-conformer detection → clustering → ranking
                    │  pocket_report.json + pocket_*.pdb
                 report (local, stdlib) ──► results/report.html + results/pockets.csv

Inputs and outputs

Inputs

• receptor.pdb: an unbound (apo) PDB or mmCIF structure. The bundled example is apo KRAS(G12C), PDB 4LDJ. Repoint the receptor artifact to use your own.

Outputs land in horus_workflow_results/results/:

• pockets/pocket_report.json: every surviving pocket cluster with rank, druggability, persistence, crypticity, contact residues and per-conformer detail. Persistence is the fraction of conformers a pocket appears in.
• pockets/pocket_*.pdb: one pseudoatom PDB file per pocket, for visualization.
• report.html: a single-file ranked report with a sortable, filterable table and an interactive Mol* view of the receptor. Each row's View button selects that pocket's lining residues and moves the camera to them. The page loads its viewer from a public CDN, so it needs internet access.
• pockets.csv: the same ranking as a flat table.

Run the workflow

Install the horus-runtime and the plugins one time:

uv sync

If you do not have uv, install it first:

curl -LsSf https://astral.sh/uv/install.sh | sh

You can also install the packages with pip:

pip install horus-runtime horus-environments

Then run the workflow. The first run builds the Lacuna environment:

uv run horus run workflow.yaml

All parameters live in the command of the discover task:

• --conformers sets the ensemble size. The example uses 20.
• --backend sets the ensemble backend. nma is the default. openmm and boltz need the matching extra in requirements:.
• --detector picks the pocket detector: alpha, surface, surface-fusion, p2rank or fusion.
• --rank-by picks the ranking strategy: learned, learned-plm, crypticity, druggability, balanced or persistence.
• --min-druggability, --min-persistence and --min-crypticity filter the results.
• --homodimer finds dimer-interface pockets. It needs a biological-assembly PDB with BIOMT records.

With --detector surface-fusion and the default --rank-by, Lacuna switches to the learned-fused ranker, fitted on the pooled candidate set. The input structure is always conformer 0, so a pocket that never leaves the crystal structure is still reported.

This workflow stops at discovery. To dock a ligand library into the top pocket, see Lacuna + AutoDock Vina Docking.

References

• Lacuna on GitHub
• lacuna-pockets on PyPI
• Moore CW. Lacuna: Cryptic Binding Pocket Discovery via Conformational Ensemble Analysis. bioRxiv 2026. doi:10.64898/2026.08.14.744956
• Moore CW. Cryptic binding sites are detected but not ranked: coverage, conversion, and the limits of detector consensus. bioRxiv 2026. doi:10.64898/2026.08.11.743381
• CryptoBench: Vavra et al. 2024
• PDB 4LDJ