RENKIN — Retrosynthetic Exploration Network for Knowledge-Informed Navigation

Computer-Aided Synthesis Planning (CASP) · Pure Rust · WebAssembly · Python
Named after 錬金 (れんきん, renkin) — Japanese for alchemy: just as alchemists transformed base metals into gold, RENKIN transforms target molecules back into cheap starting materials.

日本語版 README · Documentation · Live Demo →

What is RENKIN?

RENKIN is an open-source retrosynthesis engine for computer-aided synthesis planning (CASP) that automatically discovers optimal chemical reaction routes from a target molecule back to cheap, commercially available starting materials.

Built entirely in Rust with the chematic cheminformatics crate. Zero C/C++ dependencies.

→ Try the Live Playground — runs entirely in WebAssembly, no installation needed.
→ Full Documentation — API reference, examples, benchmark.

Installation

pip install renkin          # Python
cargo add renkin            # Rust
npm install renkin          # JavaScript / Node.js

Quick Start

import renkin

result = renkin.find_routes(
    "CC(=O)Oc1ccccc1C(=O)O",   # Aspirin
    depth=5,
    max_routes=3,
)

for route in result["routes"]:
    for step in route["steps"]:
        print(f"  {step['target']} → {' + '.join(step['precursors'])}  [{step['rule']}]")

import init, { find_routes } from './pkg/renkin.js';
await init();
const result = JSON.parse(find_routes("CC(=O)Oc1ccccc1C(=O)O", 5, 3, 0));

./target/release/renkin --target "CC(=O)Oc1ccccc1C(=O)O" --depth 5 \
    --templates data/templates_extracted.smi

Key Features

Benchmark

USPTO-50k test set (4,907 molecules, full evaluation):

Evaluation note: All numbers use the standard USPTO-50k train/test split (same corpus). Templates are extracted from the training set and evaluated on the test set — the same methodology as AiZynthFinder and other published tools. Numbers reflect performance within the USPTO-50k domain; out-of-distribution generalization has not been separately evaluated.

* 29/50 chunks, previous binary
† 100-molecule confirmation (71/100); full 4,907-molecule run in progress

On the standard USPTO-50k benchmark, RENKIN surpasses AiZynthFinder (45–53%), Retro* (44.3%), ASKCOS (41%), LocalRetro (53.4%), and GLG (58.0%) — all evaluated under the same train/test split conditions.
Full benchmark details →

Competitive Landscape

RENKIN's goal: match or exceed neural-network-based tools using only curated rules and auto-extracted SMIRKS templates — no GPU, no training data, no black boxes. On the standard USPTO-50k benchmark (same train/test split used by all published tools), RENKIN reaches ~71% (100-molecule confirmation), surpassing AiZynthFinder (45–53%), LocalRetro (53.4%), and GLG (58.0%). Template frequency weighting (Phase A) — the same principle as AiZynthFinder's neural template scoring — delivers +19 pp over uniform weighting. RENKIN runs anywhere: browser, CLI, Python — single cargo build.

Architecture

Target SMILES
     │
     ▼
┌─────────────────────────┐
│     chem_env.rs         │  ← chematic wrapper
│  - SMILES parse         │     canonical-SMILES HashSet BB lookup (O(1))
│  - 314 retro rules      │     fragment sanitization + ring-leak filter
│  - Building block check │     VF2 fallback for small sets
└────────────┬────────────┘
             │  par_iter (rayon / sequential on WASM)
             ▼
┌─────────────────────────┐
│      search.rs          │  ← A* / AND-OR Tree Search
│  - Priority queue       │     SA Score heuristic
│  - Closed list          │     beam search pruning
│  - Degenerate filter    │
└────────────┬────────────┘
             │
             ▼
┌─────────────────────────┐
│      score.rs           │  ← Heuristic / Cost Function
│  - SA Score (chematic)  │     h = Σ(1 + 0.5·(sa−1)/9)
│  - MW step cost         │     g = Σ(1 + total_mw/2000)
└────────────┬────────────┘
             │
             ▼
  JSON  ←  CLI / Python / WASM

Project Structure

renkin/
├── Cargo.toml
├── src/
│   ├── lib.rs               # public library
│   ├── main.rs              # CLI binary  (--templates flag)
│   ├── bin/benchmark.rs     # renkin-bench binary  (--templates flag)
│   ├── chem_env.rs          # 314 retro rules, BB check, template loader
│   ├── score.rs             # SA Score heuristic + step cost
│   ├── search.rs            # A* / AND-OR tree engine + beam pruning
│   ├── python.rs            # PyO3 bindings (--features python)
│   └── wasm.rs              # wasm-bindgen bindings (cfg = wasm32)
├── data/
│   ├── building_blocks.smi          # 463 curated commercial starting materials
│   ├── templates_extracted.smi      # 283 auto-extracted SMIRKS templates (top-500)
│   ├── benchmark_targets.smi        # internal benchmark set
│   └── bench_chunks/                # USPTO-50k per-chunk results
├── scripts/
│   ├── extract_templates.py         # rdchiral template extraction pipeline
│   └── run_benchmark_chunks.sh      # resumable chunked benchmark runner
├── docs/                # MkDocs source → kent-tokyo.github.io/renkin/
└── mkdocs.yml

Roadmap

• Phase 1 — SMIRKS retro-reaction rules + fragment sanitization
• Phase 2 — A* / AND-OR tree search, closed list, degenerate-route filter
• Phase 3 — SA Score heuristic + beam search
• Phase 4 — Parallel rule application (rayon; sequential fallback on WASM)
• Phase 5 — Python bindings (PyO3 + maturin) · pip install renkin
• Phase 6 — WASM build · npm install renkin
• Phase 7 — Benchmark CLI (renkin-bench) + initial USPTO-50k evaluation
• Phase 8 — Unit tests · rules → 31 · building blocks → 463
• Phase 9 — WASM browser playground + i18n (EN/JA/ZH)
• Phase 10 — Graph-based biaryl cleavage · O(1) canonical-SMILES BB index
• Phase 11 — Published to crates.io / PyPI / npm · GitHub Actions CI/CD
• Phase 12 — MkDocs documentation site · GitHub Pages playground
• Phase 13 — Formal USPTO-50k benchmark: 7.5% (depth=3, 31 rules)
• Phase 14 — Auto template extraction (rdchiral): 27.8% (depth=3, 222 rules)
• Phase 17 — chematic 0.4.12: Bug #13 (BFS leakage) + Bug #14 (canonical SMILES) fixed
• Phase 18 — Template frequency weighting (Phase A): ~71% USPTO-50k (100-mol confirmed)
• Phase 19 — Rust engine micro-optimizations (split_fragments, is_bb fast path, element pre-screening)
• Phase 15 — Stereochemistry support (CIP SMIRKS)
• Phase 16 — Large-scale building block DB integration
• Phase B — ONNX template relevance model (molecule-specific template scoring)

License

MIT

GitHub Topics: retrosynthesis cheminformatics wasm rust drug-discovery casp synthesis-planning computational-chemistry