Plant-DNA-Designer

🌱 Plant DNA Designer

Design plant expression cassettes de novo — automatically.

📄 Paper (bioRxiv)  ·  📦 Zenodo archive  ·  💻 GitHub  ·  🤗 Hugging Face

⏱️ 30-second version. Pick a crop and one or more traits. The tool maps each trait to its validated effector protein, generates a fresh, crop-optimized DNA coding sequence for it with a translation-aware optimizer, and returns a full report on expression, gene-editing targets, stability and safety — ready to synthesize. No AI, no cloud; runs on your machine.

---

Table of Contents

• Overview
• Translation-Aware Optimization Engine
• Benchmark
• Screenshots
• Quick start
• How it works
• Glossary
• Architecture
• API endpoints
• The science
• Citation
• License

---

Overview

Scientists who want a plant to do something new (survive drought, resist disease, improve yield) need a custom piece of DNA designed for it. Writing that DNA by hand is slow and error-prone: the plant might ignore it, silence it, or read it incorrectly.

Plant DNA Designer turns a crop + trait choice into a ready-to-test DNA cassette. It supports 46 validated traits across 18 crops — from submergence tolerance (SUB1A) and Golden-Rice provitamin-A (PSY) to nitrogen-use efficiency (GRF4), stem-rust resistance (Sr35), cotton fiber quality (GhMYB25) and sugarcane sucrose accumulation (SPS1). The key is its biological target layer: each trait is mapped to a validated plant mechanism and the effector protein known to drive it (e.g. drought tolerance → DRE/CRT dehydration signaling → the DREB2A transcription factor). The tool then generates a de-novo, crop-optimized coding sequence for that effector using a translation-aware evolutionary optimizer that balances codon adaptation, codon harmony, mRNA structure, translational pausing, expression quality, and sequence safety — built by optimization rather than retrieved from a database — and runs a full health check covering expression, gene-editing targets, stability, and safety. Everything runs on your own machine with simple, transparent math.

What "de novo" means here: the protein is a validated plant effector (with citations); the nucleotide sequence is generated fresh — synonymous, crop-codon-optimized, and expression-engineered — not copied from any gene in a database. You can also override the target with your own validated protein.

💡 No AI, no cloud, no cost. Every score is computed with published, open formulas — there are no paid AI/LLM calls and nothing leaves your computer. The biology is tuned specifically for plants, not humans or animals.

★ What makes it different: unlike ordinary codon optimizers, it designs the whole expression cassette — and is one of the few plant-focused design platforms that automatically designs IME-enhancing introns (Intron-Mediated Enhancement), a plant-exclusive trick that can lift expression 10–50× by auto-designing an enhancing intron for the 5′UTR. (See the flagship section below.)

---

Translation-Aware Optimization Engine

Plant DNA Designer does not simply maximize the Codon Adaptation Index (CAI).

The optimization engine uses a multi-objective evolutionary framework that models several stages of gene expression simultaneously:

• Position-dependent mRNA structure — keeps the translation-initiation region accessible while maintaining beneficial downstream structure.
• Codon-harmony optimization — matches natural codon-usage distributions instead of forcing CAI toward unrealistic extremes.
• Translation-dynamics optimization — models the ribosome's velocity trajectory along the transcript (local speed, velocity gradients, congestion) and shapes it to a folding-friendly schedule: a slow start-up ramp, fast domain interiors, and pauses at predicted inter-domain linkers so each domain can fold before the next emerges. Optimization of translation dynamics, not isolated codon scores.
• Dimensionless objective framework — every objective is normalized and weighted on a common scale, preventing any single metric from dominating the search.
• Liability-directed evolution — mutations preferentially target problematic sequence regions rather than relying entirely on random exploration.
• Cached structure evaluation — avoids redundant folding calculations for significantly faster optimization.
• Crop-aware throughout (monocot vs dicot) — the grass/broadleaf clade of the chosen crop drives a species-specific Kozak initiation context, intron splicing composition (AU-rich for dicots, GC-balanced for monocots), and miRNA library — not just the codon table.

The result is a translation-aware design strategy that optimizes initiation, elongation, folding, and sequence quality together, rather than treating codon optimization as a single-metric problem.

Why this matters: most tools do one of — trait→mechanism→effector mapping, translation-aware sequence design, or plant-specific optimization. Plant DNA Designer combines all three in a single workflow.

---

Benchmark

Sophisticated ideas only count if they produce different, measurable outcomes — and the comparison has to be external, not a set of in-house strawmen. The repo ships a reproducible benchmark (cool/benchmark.py) in which every comparator faithfully reproduces the published algorithm of a named, widely-used external tool — JCat / OPTIMIZER / ATGme (one-amino-acid-one-codon CAI-max), IDT (balanced codon usage), and TISIGNER (5′-initiation optimization) — run on the same panel of 6 real plant effector proteins (DREB2A, SUB1A, PSY, GRF4, Sr35, Ferritin) with the same plant metrics. Reproducing the algorithm is fairer than scraping each tool's web output, which targets generic microbial/mammalian hosts and varies by host and GC settings:

cd cool && python -m benchmark

Higher is better for CAI, Harmony, tAI, MTDR, Dynamics, Body ΔG; closer-to-0 is better for 5′-openness; lower is better for Safety (liability penalty) and GC dev. tAI now uses the dos Reis wobble weights (so a codon read only through an inefficient wobble tRNA scores below its Watson–Crick synonym), MTDR is the tRNA supply/demand match. Note CAI-max scores highest on tAI/MTDR — in GC-rich rice the argmax codons are also the high-tGCN ones, which is exactly why tAI alone isn't sufficient and PDD trades a little of it for harmony, safety and GC fidelity. "Dynamics" is the ribosome-velocity-trajectory match; GC dev is deviation from a neutral 50% synthesis target.

What the numbers show — including where we don't win. Each external-tool algorithm excels on the one axis it optimizes and fails on the others. JCat/ OPTIMIZER/ATGme hit a perfect CAI (1.000) but the worst harmony (0.422) and — on the real GC-rich rice codon table — a catastrophic 21.8 pp GC deviation (argmax drives GC to ~72%). IDT's balanced-usage algorithm beats Plant DNA Designer on harmony (0.930 vs 0.774) — exactly as expected, since matching natural frequencies is IDT's sole objective. TISIGNER gets decent start-codon openness but among the worst safety. That a dedicated single-objective tool beats us on its own axis is evidence the benchmark is fair, not rigged.

Plant DNA Designer's contribution is not winning any single axis but being the only strategy that holds every axis within bounds at once:

• Codon harmony +84% vs CAI-max (0.422 → 0.774) — far more native-like.
• Better ribosome dynamics (0.649 → 0.741, 0.761 in folding mode).
• Start codon far more accessible (−0.347 → −0.114).
• More downstream structure (0.358 → 0.387) — for mRNA half-life.
• Safety liabilities — the decisive gap: every external-tool algorithm leaves 2.3–3.5 cloning-blocking liabilities per sequence; PDD cuts this to 0.00 (default) / 0.25 (folding). No single-metric tool addresses safety at all.
• GC fidelity — the other decisive gap: naive CAI-max lands 21.8 pp off a 50% target on real rice codons; PDD steers to 4.0 pp.

Consistent across the panel, not an averaging artifact. Per protein, PDD beats all four external-tool algorithms on safety (6/6) and GC fidelity (6/6), and on body structure (4/6), start-openness (3/6) and dynamics (2/6), folding mode highest overall. It does not win harmony — IDT's single-objective design takes that — nor tAI/MTDR, which CAI-max wins because in GC-rich rice the argmax codons are also the high-tGCN ones. An honest non-dominance rather than a clean sweep. python -m benchmark prints the full per-protein table and win counts.

Folding mode (the harmonize toggle) pushes hardest on the folding-relevant axes — best translation dynamics and start openness — at a deliberately lower CAI (0.775), exactly the trade the codon-harmony / translation-dynamics literature argues for.

Caveat: these are in-silico proxy metrics on a fixed panel — evidence that the design strategies produce measurably different sequences, not a wet-lab expression claim. The hosted tools are web-only and host-generic, so each comparator reproduces the tool's documented algorithm rather than scraping its server. Definitive external validation requires head-to-head wet-lab expression of PDD-designed vs. tool-designed sequences.

---

Screenshots

Every panel is rendered as self-contained SVG/HTML — no external chart libraries.

Design Report Card & simple view — a one-word grade, a 0–100 score, and four plain-language traffic-light checks; switch to Expert for all 15 analysis panels.

Translation dynamics (flagship) — the ribosome's velocity trajectory (green) shaped to an ideal folding schedule (orange): a slow start-up ramp, fast domain interiors, and a pause at each predicted inter-domain linker.

Intron-Mediated Enhancement (flagship) — scores intron potential (IMEter) and auto-designs a splice-competent, enhancer-packed intron for the 5′UTR — a plant-only route to 10–50× higher expression.

Full expression cassette — promoter → 5′UTR → IME intron → CDS → terminator, assembled from validated, cited parts and compatibility-checked.

<details> <summary><b>📸 More screenshots</b> — biological target, GA/Pareto, CRISPR, pathway, safety</summary> <br> </details>

---

Quick start

You need Python 3.12+ (NumPy ≥ 2.5 requires it).

cd cool
pip install -r requirements.txt
python -m uvicorn api.main:app --reload --port 8000

Then open http://localhost:8000 in your browser, pick a crop and a trait, and click Generate.

To run the test suite:

cd cool
python -m pytest tests/ -q      # 172 tests

---

How it works

The pipeline is what turns "pick a trait" into a defensible design:

   Crop
     ↓
   Trait                         (e.g. drought tolerance)
     ↓
   Validated plant mechanism     (DRE/CRT dehydration signaling)
     ↓
   Effector protein              (DREB2A — AP2/ERF transcription factor)
     ↓
   De-novo DNA generation        (genetic algorithm, crop-codon-optimized)
     ↓
   Expression optimization       (5'UTR / IME intron / GC3 / stability)
     ↓
   CRISPR + safety analysis

1. You select a crop and one or more of the traits it supports.
2. The biological target layer resolves the trait to its validated mechanism and the effector protein that confers it (with literature citations). This is the protein the cassette will encode. You can override it with your own validated sequence.
3. A genetic algorithm generates the DNA de novo — it evolves thousands of candidate coding sequences for that effector (each carrying the regulatory signals for your traits), scores them on many goals at once (codon fit, stability, safety) and keeps the best. The nucleotide sequence is produced by optimization, not retrieved from a database.
4. The winner is analyzed by every science module and shown in the report — the sequence and its biological target first, then all the quality and safety checks.

---

Glossary

---

What's under the hood

All the biology lives in a clean, testable core with no web or UI code, so it can be reused and trusted independently.

cool/
├── core/                   # The science — pure Python, fully tested
│   ├── motifs.py           # Plant regulatory motif definitions
│   ├── codons.py           # Codon usage / CAI / tAI accessors (loads real per-species tables)
│   ├── codon_usage_tables.py  # 18 real per-species codon tables (generated from Kazusa CUTG)
│   ├── data/cutg_plant_subset.spsum  # committed Kazusa CUTG source data (18 species)
│   ├── species.py          # 18 crop profiles (monocot + dicot)
│   ├── mechanisms.py       # Trait → mechanism → effector protein knowledge base
│   ├── intron.py           # ★ Intron-Mediated Enhancement: IMEter + intron designer
│   ├── cassette.py         # Full-cassette co-design: validated part libraries + compatibility
│   ├── pathway.py          # Multi-gene pathway: codon-optimality expression balancing + HDGS check
│   ├── gc3.py              # GC3 balance + tRNA-demand (MTDR) scoring
│   ├── stability.py        # mRNA stability + plant miRNA scanners
│   ├── base_editor.py      # CBE / ABE / Cas12a / chromatin scoring
│   ├── expression.py       # Tissue-specificity + expression-quality scoring
│   ├── analyzer.py         # Pulls every metric together
│   ├── crispr.py           # CRISPR on-target (Doench RS2) + off-target (CFD)
│   └── designer.py         # Multi-objective GA: dimensionless weights, position-
│                           # dependent structure, distribution matching, NSGA-II
├── api/                    # FastAPI: turns a request into the full JSON report
├── web/                    # Browser frontend (no build step, no Node/npm)
├── benchmark.py            # Reproducible benchmark vs external-tool algorithms (JCat/IDT/TISIGNER)
└── tests/                  # 172 tests covering the science and the API

Built with: Python · FastAPI · BioPython · a little HTML/CSS/JS. Optional ViennaRNA gives exact RNA folding; without it, a built-in fallback keeps results meaningful.

---

API endpoints

---

The science

For readers who want the detail behind each check (and for the full specification — every objective, formula, weight, normalization and citation — see the Technical Reference):

• Biological target layer — a curated knowledge base maps each supported trait to its established plant mechanism and the validated effector gene(s) that confer it (e.g. drought → DREB2A / LEA / P5CS1; bacterial blight → Xa21 / NPR1 / PR1; salt → NHX1 / HKT1), each with a primary-literature reference. The selected trait's primary effector becomes the design seed; the encoded protein is shown explicitly and can be overridden with a user-validated sequence. This is a reference/design layer — validate the target experimentally before use.
• Intron-Mediated Enhancement (flagship) — an IMEter-style pentamer log-odds model scores how much a sequence resembles promoter-proximal (enhancing) Arabidopsis introns; the designer assembles a splice-competent intron (GT…AG, branch point, polypyrimidine tract) enriched with the TTNGATYTG enhancing signal, for 5′UTR insertion within ~1 kb of the TSS. Refs: Rose 2008 (Plant Cell); Parra & Rose 2011 (NAR 39:5328); Gallegos & Rose 2025 (NAR 53:gkaf097).
• Expression-cassette co-design — assembles promoter → 5′UTR → intron → CDS → terminator by selecting validated, published parts (CaMV 35S, maize Ubi1, rice Act1, UBQ10, NOS; NOS/35S/rbcS-E9/HSP18.2/Os terminators — each cited) matched to clade/strength/context, and compatibility-checks the assembly (Type-IIS sites, cross-part repeats, clade consistency). Conservative by design: regulatory parts are recommended by identity, not invented; only the synthetic-minimal promoter (validated CREs), validated leaders (TMV Ω, AMV) and the IME intron are emitted as ready DNA. See Technical Reference §4b.
• Multi-gene pathway design — selecting ≥2 traits coordinates their effector genes into a balanced pathway: each gene is dialed to a target relative expression by codon-optimality tuning (Welch 2009; Boël 2016), the realized stoichiometry is scored, and each gene gets a distinct validated promoter/terminator to limit homology-dependent silencing (HDGS). Predicted expression is a relative proxy, not absolute; see Technical Reference §4c.
• Codon optimization — a multi-objective genetic algorithm balances CAI, tAI (using real per-species tRNA gene-copy-number (tGCN) tables counted from GtRNAdb — 11 crops have their own sequenced genome; the rest map to their nearest sequenced relative by phylogeny, e.g. potato→tomato, peanut→soybean, sugarcane→sorghum, wheat/barley→Brachypodium, with the source FASTAs committed and rebuildable via tools/build_tgcn.py), GC3, tRNA-demand (MTDR), and mRNA-stability motifs. Each of the 18 crops uses its own real codon-usage table measured from the Kazusa Codon Usage Database (CUTG, plant division) — no cross-species proxies. The committed source data and the generator (tools/build_codon_usage.py) make the tables fully reproducible, and the real data cleanly separates the monocot/dicot clade axis (monocots are GC3-rich, dicots AT-/balanced). Rather than driving CAI to 1.0 (argmax at every codon, which over-optimises and de-tunes folding), it also rewards matching the natural codon-usage distribution (1 − total-variation distance to the reference) — aiming for "high but natural" usage where plain CAI saturates (Angov 2008; Mignon 2018).
• Position-dependent mRNA structure — secondary structure is not uniformly good. The ribosome-loading window (~first 45 nt from the AUG) is optimised to stay open for efficient translation initiation, while the body is optimised to be structured for mRNA half-life (Kudla 2009; Zur & Tuller 2012; Jores et al. 2021), instead of one global "more structure = better" term that fought initiation.
• CRISPR — on-target uses the Doench 2016 RS2 model (80 single + 9 dinucleotide terms, logistic sigmoid, poly-T penalty); off-target uses a CFD 12×20 mismatch matrix.
• Base editing — CBE edits C→T in window 4–8, ABE edits A→G in window 4–7, Cas12a uses a TTTV PAM; chromatin openness from AA/TT 10-bp periodicity + GC.
• mRNA stability — experimentally-derived stabilising/destabilising k-mers; ViennaRNA MFE folding when available, else an H-bond-weighted Nussinov fold (G≡C = 3, A=U = 2, G·U wobble = 1).
• miRNA safety — seed-match scan against 10 conserved plant miRNAs to avoid silencing, plus lineage-specific families (e.g. the monocot/grass-specific miR528) layered in by clade.
• Tissue specificity — TFBS enrichment across 8 plant tissue/stress contexts from PlantCARE and the literature.
• Species-specific expression logic (monocot vs dicot) — the crop's clade drives biology beyond the codon table: a GC-richer Kozak initiation context for monocots vs the A-rich Joshi consensus for dicots (Sawant 2001; Joshi 1997); and intron splicing composition — dicot introns require AU-richness for recognition, monocots splice GC-richer introns efficiently (Goodall & Filipowicz 1989, 1991). Both the Kozak fitness term and the designed IME intron adapt automatically to the selected crop.

---

Ground rules

• No AI / LLM calls — every score is plain, transparent math; nothing is sent to a paid model or external service.
• Plant-specific — all codon tables, miRNA seeds, regulatory motifs and TFBS sets come from plant biology, not human or animal data.

---

Citation

If you use Plant DNA Designer in your research, please cite the preprint:

Dinesh K, Swetha H. Plant DNA Designer: A Computational Framework for Multi-Objective Codon Optimisation and Synthetic Gene Design in Crop Biotechnology. bioRxiv (2026). https://doi.org/10.64898/2026.08.02.742271

Software archive (all versions): Zenodo — https://doi.org/10.5281/zenodo.21848741

@article{dineshk2026plantdnadesigner,
  title   = {Plant DNA Designer: A Computational Framework for Multi-Objective
             Codon Optimisation and Synthetic Gene Design in Crop Biotechnology},
  author  = {Dinesh K and H. Swetha},
  journal = {bioRxiv},
  year    = {2026},
  doi     = {10.64898/2026.08.02.742271},
  url     = {https://doi.org/10.64898/2026.08.02.742271}
}

---

License

Released under the MIT License. © 2026 Dinesh K and H. Swetha, Voxelta Private Limited.