Ejecuta cualquier Skill en Manus
con un clic

Ejecuta cualquier Skill en Manus con un clic

genie3

Estrellas2

Forks0

Actualizado12 de mayo de 2026 a las 11:07

Run de-novo protein design with Genie 3 — a fast, all-atom, SE(3)-equivariant diffusion model. Use this skill when: (1) Generating unconditional monomeric protein backbones (length 50–600+), (2) Solving motif-scaffolding problems (single- and multi-motif), (3) Designing protein binders for a target with hotspot residues, (4) Running beam search or iterative-conditioning binder pipelines, (5) Loading legacy Genie 2 (Cα-trace) checkpoints, (6) Training the Genie 3 model from scratch. This skill covers installation, the unified `genie3` CLI (run / generate / evaluate / status / train), the experiment YAML schema, the three application workflows, multi-GPU + multi-node sharding, problem-set preparation, output layout, and the in-silico success filters. Pairs with: `proteinmpnn` (inverse folding), `colabfold` / `esmfold` (structure prediction back-ends used by the evaluation pipeline), `foldseek` (cluster successful designs), `protein-qc` (QC thresholds), and `binder-design` (tool selection between Genie 3, BindCr

Instalación

Instalar con Codex o Claude Copia este prompt, pégalo en Codex, Claude u otro asistente, y deja que revise la página de la skill y la instale por ti.

Ejecutar en Manus

Fuente

LiorZ

LiorZ/protein-design-skills

Abrir repositorio de GitHub Ver repositorios del creador

Descarga

Ejecutar en Manus

Ocupaciones relacionadasSOC

Basado en la clasificación ocupacional SOC

Bioquímicos y biofísicosCiencias de la vida, físicas y sociales·SOC 19-1021

Explorador de archivos

21 archivos

SKILL.md

readonly

Más de este repositorio

mismo repositorio

bioemu

LiorZ/protein-design-skills

Run BioEmu (Biomolecular Emulator) — Microsoft Research's deep generative model that samples from the **approximated equilibrium (Boltzmann) distribution** of structures for a protein monomer, given its amino acid sequence. BioEmu is **not** a single-structure predictor: it's the AF3-class "many predictors" diffusion model whose output is an **ensemble** (an `.xtc` trajectory of backbone frames) approximating MD-style equilibrium, at orders-of-magnitude lower cost than running MD. Use this skill when: (1) Sampling a **conformational ensemble** of a protein monomer from its sequence (the headline use case — chignolin, folded/unfolded coexistence, fast-folder benchmarks, etc.), (2) Mapping **conformational changes** relevant to function — formation of **cryptic pockets**, local **unfolding** events, large-scale **domain rearrangements**, (3) Predicting **folding free energies / protein stability** (ΔG_fold) directly from the sampled ensemble (the v1.1 and v1.2 checkpoints were trained wi

2026-06-052

bindcraft

LiorZ/protein-design-skills

Run BindCraft — a hallucination-based de novo binder design pipeline that couples **AF2 backpropagation** (ColabDesign), **ProteinMPNN** redesign, **AF2 reprediction**, and a full **PyRosetta** interface-score filter pass against a single target PDB. One `bindcraft.py` (or `sbatch bindcraft.slurm`) call runs an endless trajectory loop until the requested number of designs that pass every filter is reached. Use this skill when: (1) De novo designing **mini-protein binders** (~65–150 aa) against a protein target — the canonical BindCraft use case, (2) Designing **peptide binders** (≤ ~25 aa) using the dedicated `peptide_3stage_multimer` advanced preset + `peptide_filters`, (3) Designing for a **β-sheet-rich** target or a target where the binder *should* be β-sheet (`betasheet_4stage_multimer` preset), (4) Selecting a **hotspot patch** (`target_hotspot_residues`: `"56"`, `"A1-10,B1-20"`, `"A"`, or `null`) to focus AF2 on a specific epitope, (5) Producing AF2-validated designs ranked by **interfac

2026-06-052

caver

LiorZ/protein-design-skills

Run **CAVER 3.0 / 3.01** — the canonical tool from the Loschmidt Laboratories / Masaryk University for **identification, geometric characterization, clustering, and visualization of transport pathways (tunnels, channels, pores)** in macromolecular structures. CAVER operates on PDB files (a single static structure or an ensemble of MD snapshots) and returns the tunnels leading from a user-specified starting point inside the protein to the bulk solvent. Use this skill when: (1) Finding the access tunnel(s) connecting a buried active site / cofactor / co-substrate / catalytic residue to the protein surface, with their bottleneck radius, length, curvature, throughput, and priority — the headline CAVER use case, (2) Analyzing tunnel **dynamics** across a molecular-dynamics trajectory (10 / 100 / 1 000+ snapshots), clustering equivalent tunnels across frames into a small number of stable channels and ranking them by `Priority` (averaged throughput), (3) Comparing tunnels across **multiple ho

2026-05-312

esm-biohub

LiorZ/protein-design-skills

Run the **Biohub `esm` repository** (formerly EvolutionaryScale) — the world model of protein biology that ships **ESMC** (state-of-the-art protein language model), **ESMFold2** (AF3-class structure prediction with proteins + DNA + RNA + ligands), **ESM3** (generative model over sequence / structure / function), and **ESMC Sparse Autoencoders** (interpretable feature decomposition of ESMC's internal representations). Use this skill when: (1) Producing **per-residue or pooled embeddings** of one or many sequences with ESMC (300M / 600M / 6B) for downstream classification, regression, retrieval, clustering, or representation learning, (2) **Zero-shot mutation scoring / pseudo-perplexity / entropy** on a sequence by sampling masked logits (the headline ESMC use case for variant-effect prediction), (3) **Fine-tuning** ESMC for a task (PEFT / LoRA classification or regression head) or doing a **layer sweep** to find the best feature layer for a downstream probe, (4) Predicting **all-atom 3D

2026-05-282

biotite

LiorZ/protein-design-skills

Use Biotite — a fast, NumPy-backed Python library for computational molecular biology — to read, manipulate, analyze, and write biomolecular structures and sequences, and to fetch data from biological databases. This is the toolkit/"glue" library of the collection: it does not fold or design proteins, it lets you operate on the structures and sequences that the predictors/designers consume and produce. Use this skill when: (1) Parsing, editing, or writing **structure files** — PDB, mmCIF / PDBx, BinaryCIF, MOL / SDF, GRO, and MD trajectories (XTC / TRR / DCD / NetCDF), (2) Selecting / filtering atoms, residues, or chains with NumPy boolean masks over annotation arrays (the `AtomArray` / `AtomArrayStack` data model), (3) **Superimposing** structures and computing **RMSD / RMSF / lDDT / TM-score** — e.g. comparing a designed backbone to its AlphaFold3 / Boltz / Chai prediction, or two predictions to each other, (4) Structural analysis: **SASA**, **secondary-structure** assignment, **hydrogen

2026-05-282

protenix

LiorZ/protein-design-skills

Run Protenix — ByteDance's open-source, trainable reproduction of AlphaFold 3 for high-accuracy biomolecular structure prediction. Protenix folds complexes of proteins, DNA, RNA, small-molecule ligands, and ions in one pass, with post-translational/nucleotide modifications, covalent bonds, MSAs, templates, and optional pocket/contact constraints. Use this skill when: (1) Predicting the 3D structure of a **protein / nucleic-acid / ligand complex** from sequences + ligand specs (the headline use case), (2) Folding a **single protein** (monomer or homo-/hetero-oligomer via `count` / `id`) with an MMseqs2 MSA searched automatically, (3) Modeling **protein–ligand** binding where the ligand is a CCD code, a SMILES string, or a 3D structure file (SDF/MOL/MOL2/PDB), (4) Predicting **protein–DNA / protein–RNA** complexes, optionally with RNA MSA, modified bases, and double-stranded DNA (two complementary strands), (5) Adding **covalent bonds** (e.g. glycosylation, covalent inhibitors, cyclic peptid

2026-05-252

name	genie3
description	Run de-novo protein design with Genie 3 — a fast, all-atom, SE(3)-equivariant diffusion model. Use this skill when: (1) Generating unconditional monomeric protein backbones (length 50–600+), (2) Solving motif-scaffolding problems (single- and multi-motif), (3) Designing protein binders for a target with hotspot residues, (4) Running beam search or iterative-conditioning binder pipelines, (5) Loading legacy Genie 2 (Cα-trace) checkpoints, (6) Training the Genie 3 model from scratch. This skill covers installation, the unified `genie3` CLI (run / generate / evaluate / status / train), the experiment YAML schema, the three application workflows, multi-GPU + multi-node sharding, problem-set preparation, output layout, and the in-silico success filters. Pairs with: `proteinmpnn` (inverse folding), `colabfold` / `esmfold` (structure prediction back-ends used by the evaluation pipeline), `foldseek` (cluster successful designs), `protein-qc` (QC thresholds), and `binder-design` (tool selection between Genie 3, BindCraft, RFdiffusion, BoltzGen).
license	MIT
category	design-tools
tags	["structure-design","backbone-generation","motif-scaffolding","binder","diffusion","equivariant"]
repo	https://github.com/aqlaboratory/genie3
preprint	https://www.biorxiv.org/content/10.64898/2026.05.01.722168v1

Genie 3 — Fast All-Atom SE(3)-Equivariant Protein Design

What this is

Genie 3 is a single diffusion model with three application modes selected by the YAML config:

`generation.dataset.source`	`evaluation.version`	What it does
`unconditional`	`unconditional`	De-novo monomers; sweep length range
`motif`	`scaffold`	Motif scaffolding (single or multi)
`target`	`binder`	Binder design against a target PDB + hotspots

All workflows are driven by one CLI: genie3 {run, generate, evaluate, status, train}. A single genie3 conda env covers everything (incl. ColabFold, ESMFold, ProteinMPNN, FoldSeek, TMscore, DSSP).

Prerequisites

Requirement	Minimum	Notes
OS	Linux (x86_64)	Setup script targets Linux
GPU	NVIDIA, CUDA 12+	Required for generation, ColabFold, ESMFold
GPU VRAM	24 GB	40+ GB for long monomers / beam search / large complexes
Conda	Any modern conda	The setup script creates the `genie3` env (Python 3.10)
Disk	~30 GB	ColabFold AF2 multimer weights + pretrained Genie 3 checkpoint + datasets
Network	Internet at setup	HuggingFace + ColabFold MSA server (only at problem-prep time)

Three-step quick start

1) Install (one-time)

git clone https://github.com/aqlaboratory/genie3.git
cd genie3
bash scripts/setup/setup.sh        # creates conda env "genie3", installs all deps
bash scripts/setup/download.sh     # downloads pretrained weights + training data
conda activate genie3

The setup script installs into the genie3 conda env: torch 2.7.1, ColabFold (alphafold-multimer-v3 weights), ESMFold (openfold + ESM2), ProteinMPNN, FoldSeek, TMscore/TMalign, DSSP. See references/setup.md.

2) Pick an example config

genie3 run -c examples/unconditional/experiment.yaml      # de-novo monomers
genie3 run -c examples/motif_scaffolding/experiment.yaml  # motif scaffolding
genie3 run -c examples/binder_design/experiment.yaml      # binder design

run chains generate → evaluate → reduce in three child processes (so GPU memory is freed between stages). To split stages or run multi-node, see step 3.

3) Inspect outputs

Every config sets paths.rootdir. Results land under <rootdir>/results/ (or <rootdir>/<problem_name>/results/ for per-problem tasks). The most useful files:

info.csv — per-design metrics (one row per generated sample)
successful_*_generations/ and v0_success/ — PDBs that passed in-silico filters
successful_*_cluster.csv — FoldSeek clusters at TM 0.5/0.6/0.8

See references/outputs.md for full schema and success criteria.

CLI at a glance

Command	Description
`genie3 run -c <CFG>`	Generate + evaluate + reduce, all in one
`genie3 generate -c <CFG>`	Generation only (one shard)
`genie3 evaluate -c <CFG>`	Evaluate one shard
`genie3 evaluate --reduce -c <CFG>`	Merge shard outputs and produce final CSVs
`genie3 status -c <CFG>`	Show shard/round progress
`genie3 train --config <CFG> -d N`	Train the model

Shared flags: -c/--config, --num-devices N, --shard-id ID, --num-shards N, --verbose, --log-dir <DIR>. Full reference in references/cli.md.

Choosing the right reference doc

You want to…	Read
Install the env or download weights	references/setup.md
Understand every CLI flag and process model	references/cli.md
Author or modify an experiment YAML	references/configuration.md
Run unconditional generation	references/unconditional.md
Run motif scaffolding (single or multi-motif)	references/motif-scaffolding.md
Run binder design (basic)	references/binder-design.md
Use beam search or iterative conditioning for binders	references/iterative-and-beam.md
Build a new binder problem set from PDB targets	references/problem-prep.md
Distribute work across many GPUs / nodes	references/multi-node.md
Read the per-design CSV columns and success filters	references/outputs.md
Train the model from scratch	references/training.md
Diagnose failures	references/troubleshooting.md

Quick decision tree (which application?)

You want diverse de-novo monomers, no constraint → unconditional. Tune direction_scale (0.8 short / 0.0 long) and length range.
You have a functional motif (active site, epitope) and want a scaffold around it → motif. Define the motif PDB with REMARK 999 headers + a problem JSON (segment_config_str).
You have a target PDB and want a binder for it → target. Provide hotspot residues and binder length range. Choose folding mode: template (no MSA) for speed or msa for accuracy.

If you don't know whether Genie 3 is the right tool vs BindCraft / RFdiffusion / BoltzGen, consult the binder-design skill (tool selection guide).

Hard rules / gotchas

Always activate the env first: conda activate genie3. The CLI dispatches to itself via subprocess, so genie3 must be on PATH.
paths.rootdir is the single source of truth for output. Do not also set generation.io.outdir — the loader will reject conflicting values.
Do not set generation.dataset.datadir — use paths.dataset instead. Same for reward.reward.datadir.
First chain in any binder PDB must be the binder chain. The reducer extracts chain A as the binder.
Re-running genie3 run resumes from the last incomplete stage (sharded or iterative). Sentinel files (.generate_done, .evaluate_done, .shard_markers/) drive this.
genie3 evaluate --reduce runs once after all evaluation shards finish. Don't shard the reduce step.
direction_scale heavily affects quality/diversity. Defaults: 0.8 for short monomers (≤300), 0.0 for long monomers (>300) and binders, 0.1 for motif scaffolding.
ColabFold MSAs are only needed for problem prep (prepare.py) and for evaluation.folding.mode: msa. The MSA server is queried over the network at prep time.
Beam search batches: n_sample in beam mode means number of beam-search runs, and the loader auto-divides by beam_width to hit your requested total. See references/iterative-and-beam.md.
Iterative cond_strategy: iter_common* computes the common interface from prior rounds' successes and caches it under <rootdir>/problems/<problem>.json — that is the dataset path used by subsequent rounds.

Where to install the skill

This directory (skill/) is the skill payload. To make it discoverable to a Claude Code agent on this machine:

mkdir -p ~/.claude/skills
ln -s "$(pwd)/skill" ~/.claude/skills/genie3
# or copy:
cp -R skill ~/.claude/skills/genie3

After that, an agent can invoke it via the Skill tool with skill: genie3 (or you can include the marketplace structure if publishing). Skills are loaded by name from ~/.claude/skills/<name>/SKILL.md and may reference files in their own directory.

Citation

@article{lin2026genie3,
  title   = {Fast and Ultra-Capable Protein Design: Advancing the Frontier
             Through Atomistic SE(3)-Equivariance with Genie 3},
  author  = {Lin, Yeqing and Lee, Minji and Vermani, Aakarsh and Jiang, Ellena
             and {De Cooman}, Sebastiaan and Spetko, Matej and AlQuraishi, Mohammed},
  journal = {bioRxiv},
  year    = {2026},
  doi     = {10.64898/2026.05.01.722168}
}