Golden Gate Assembly

Digest parts with a Type IIS enzyme, match the resulting four-base overhangs, and see the construct they assemble into.

What it doesCopy Anchor Link

A Type IIS enzyme cuts outside its own recognition sequence. That is the whole trick: put the site in the flanking DNA pointing inward, and the enzyme excises your part while leaving a four-base single-stranded overhang of your choosing at each end — the recognition site itself is carried away on the offcut and never appears in the product. Parts whose overhangs are complementary anneal in exactly one order, so digestion and ligation can run in one pot, cycling between the two, until everything that can join has joined.

This tool simulates that reaction. It digests each part with the chosen enzyme using that enzyme's real recognition sequence and cut geometry, reads the four-base overhang left at each end, matches each overhang against every other, and reports the construct — or constructs — the parts can close into, with the parent annotations carried onto the product.

It also does the thing the tube does that the diagram does not: it tells you how likely the right construct is, given that four-base overhangs mis-ligate at measurable rates.

When you'd use thisCopy Anchor Link

Used in: Clone an insert into a vector, and prove it worked · Optimize a coding sequence for expression in another host

You have a set of parts with designed overhangs — a MoClo or GoldenBraid level, a set of domesticated coding sequences, an acceptor vector — and you want to check the design before setting up the reaction. Three questions this answers on the bench's behalf:

• Will it close at all? An overhang that matches nothing leaves a part stranded, and the run says which part and which overhang rather than returning nothing.
• Will it close in one way, or several? Two parts sharing an overhang means more than one construct, which is a design bug you would otherwise discover by sequencing colonies.
• How often will it be right? With more than about twenty junctions the fidelity of the overhang set, not the cloning, is what decides your screening burden.

The route through the workbench: parts arrive as files or from PCR Simulation; assemble here; then check the product with a diagnostic Restriction Digest and gel, and confirm the built clone with Sequencing Verification.

Reach for something else when your parts join by terminal identity rather than by designed overhangs — that is Gibson Assembly; when you want a part's grammar compliance checked before assembling — Grammar Assembly; when the build has levels that feed each other — Assembly Plan, which runs this same chemistry as one step of many.

What this computesCopy Anchor Link

• Digestion using the chosen enzyme's real cut geometry — the offsets on each strand, not a fixed rule — so an overhang's length, position and strand come out of the enzyme. Cutting is circular-aware, so an acceptor's sites are found across the origin
• Assembly by overhang complementarity: each part's two ends read as four-base single strands, every end matched against every other, and the resulting graph searched for paths that close. A part appearing in two paths means two constructs, and both are reported
• A ligation-fidelity score per junction and per assembly — from measured data, not a model. The published matrices record, for every pair of four-base overhangs, how often T4 ligase joined them under defined cycling conditions; a junction's score is its correct ligations over its total
• A designed overhang set for a reaction of a given size, on request: the highest-fidelity set of N junctions the measured matrix supports, with the junctions that already scored well pinned so only the ones the measurement objected to are moved. The search is a greedy build followed by steepest-ascent swaps, scored at every step against the same measured matrix — so every number is real data while the route to the set is a heuristic, and no claim is made that it is the best set that exists. How wide that search looks is yours to set, as the number of strongest-annealing overhangs it considers: a wider search reaches a better set and takes longer, and it never changes how a set is SCORED, only which ones are tried. On the 35-junction Pryor 2020 set, a narrow search reaches 62.1% against the 61.1% you start with and a wide one reaches 72.5%
• What to change when a junction scores badly: the highest-scoring replacement overhangs for that junction with the rest of the set held fixed, each one a full re-score rather than a ranking, and the largest mutually-compatible subset of the junctions you already have. How many replacements to rank is yours to set — each one costs a full re-score of the whole set, so the count buys breadth rather than accuracy
• Where to CUT a sequence you do not yet have as parts, choosing the split positions and the overhangs they create together — because moving a cut by one base changes which overhang it makes, so the two cannot be chosen separately. Every arrangement of fragments inside your length window is searched, and each is scored by the measured efficiency and fidelity of the junctions it would produce. The score is a product across junctions, not an average, which is the honest arithmetic: one bad junction limits the whole assembly, and averaging would hide it
• The runners-up, not just the winner. The best arrangement is rarely the only acceptable one, and the second often cuts somewhere you would rather cut — through a spacer instead of a promoter, say. Each alternative is listed with its own score, and picking one shows its fragments
• Connectors tried only when the parts alone do not close a valid construct, and kept out of the main parts list on purpose — a connector silently used when it was not needed would hide a gap in your design
• Circular and linear parts distinguished, because a circular acceptor and a linear insert digest differently

Cutting a sequence into partsCopy Anchor Link

Golden Gate overhang design asks two different questions, and which one you have depends on where you are.

If you already know your parts, the question is which junctions should join them — a set of four-base overhangs that are mutually distinguishable, so the pieces assemble in exactly one order. That is what the fidelity score and the designed overhang set above are for.

If instead you have one long sequence — a gene you are about to order, a construct too long to synthesise in one piece — the question is the other one: where should this be cut. Here the overhangs are not yours to choose freely. Each cut position determines the four bases at that junction, so choosing a good set of overhangs and choosing where to cut are the same decision.

This is what Split sites does. You give it the shortest and longest fragment your synthesis vendor will accept, and pick the Ligation data (the measured four-base ligation matrix the junctions are ranked by); it searches every arrangement of fragments inside that window and ranks them by how well the junctions each one would create are measured to ligate. The fragments it returns become parts in the list above, so the design continues straight into the assembly simulation.

Two things are worth setting deliberately. Efficiency and fidelity are different failure modes — a junction can ligate eagerly and promiscuously, or reluctantly and correctly — and the two weights let you say which you would rather protect. And maximum overhang identity is how similar two junctions may be before they are treated as confusable; lowering it rules out more arrangements and makes the surviving ones safer.

What it will not do is pretend. If no cut fits your length window the sequence comes back whole, said in those words rather than presented as a successful split.

Where it livesCopy Anchor Link

Tools → Cloning → Golden Gate Assembly, and the command palette.

Parts are taken from the open project, from the current canvas selection, from imported files or from pasted bases, so a part you have just amplified or edited is already available. The finished construct opens as a product you can take onward.

Inputs and outputsCopy Anchor Link

Parts are linear or circular molecules, each flagged as one or the other, since a circular acceptor and a linear insert digest differently. Each part shows its length, and a part may be supplied more than once.

A connector library can be supplied separately: optional bridging linkers that are tried only when the parts alone do not already close a valid construct. Keeping them out of the main list is deliberate — a connector that is silently used when it was not needed would hide a gap in your design.

What it refuses, and what it says. Before any assembly, a pre-flight check reports whether every part carries exactly two flanking sites for the chosen enzyme. That is the condition for a part being usable at all:

• No sites — the part cannot be excised; it is not domesticated for this enzyme.
• One site — one end is not defined by the enzyme.
• More than two — an internal site, which is the classic undomesticated part: the enzyme will cut inside your sequence and destroy it.

Unmatched overhangs, unused parts and parts that fork into more than one partner are each reported with the parts named.

Outputs: the construct's sequence, length and topology; the assembly plan and the order the parts join in; the fusion site at every junction; the ligation-fidelity report; and the parts' own annotations, carried onto the construct and counted, so the number can be checked against the records you supplied.

Which annotations are carried. All of them — a record's features, its primer-binding sites and its part definitions alike. Annotation kinds are frequently stored separately in a sequence file, and reading only one of them is a quiet way to lose the primer sites and part boundaries that a cloning product is normally judged on, so every kind is read. An annotation that only partly falls inside the fragment being used is counted rather than trimmed to fit: a promoter half-caught by a selection is not a promoter, and shrinking it to fit would put a real annotation somewhere it is not.

Your part list belongs to the project, not the session. Parts, the connector library and every assembly setting are saved with the project as you work, so closing the tab or reloading the page brings the build back as you left it — and the construct is re-derived from those parts rather than stored beside them, which means what you come back to is always something your current part list actually makes. The panel says what it restored and when it was saved. If a project has sequence files but no saved build, it says that too, and offers to load them as parts in one click.

DemoCopy Anchor Link

Not recorded yet. The worked example below is a real run on a shipped sample project.

Worked exampleCopy Anchor Link

The Golden Gate assembly sample project is the 35-fragment assembly from Pryor et al. (2020), built from the paper's own supplementary table: 34 linear inserts of 120–236 bp plus the real pGGA Select acceptor vector at 2,220 bp.

Open it and the panel arrives with all 35 parts and the enzyme on Auto-select, which reports what it chose and why:

BsmBI recognises CGTCTC, cuts 1 nt downstream leaving a 4 nt overhang (auto-selected).

Pre-flight (BsmBI)
Every part carries exactly two flanking sites — good to assemble.

1 construct · BsmBI
Length 7002 bp     Topology Circular     Parts 35

Fusion sites (35)   35 distinct overhangs
pGGA_Select_vect → insert_01   GGAG
insert_01 → insert_02          CAGA
insert_02 → insert_03          GGTA
…
insert_34 → pGGA_Select_vect   CCAT

Thirty-five parts, thirty-five junctions, thirty-five distinct overhangs — no overhang used twice, which is why exactly one construct comes out rather than a family of them.

The last line of the result block is the one that says the product is a molecule and not just a length:

70 features carried onto the product

Every annotation the parts carried is cropped to where that part sits in the construct and written onto it, so opening the product shows the four-base fusion site at each junction and the part bodies between them, drawn and labelled around the ring — 7,002 bp, circular, 70 features. A construct that arrives annotated can go straight into a diagnostic digest or a verification run; one that arrives as bare bases cannot.

Then the part that is not geometry:

Ligation fidelity          BsmBI-v2, Golden Gate cycling · 4 nt

61.1%   Low — predicted fraction of assemblies with every one of
        the 35 junctions ligated correctly

Pryor et al. (2020) report assembly fidelity degrading sharply past
20 4-base overhangs; this set has 35.

The dataset line names the enzyme the score is measured on, and it follows the enzyme the reaction uses: this build cuts with BsmBI, so the ligation counts come from the BsmBI-v2 profiling run. Change the enzyme and the matrix changes with it. Measured matrices exist for BsaI-HFv2, BsmBI-v2, Esp3I, BbsI-HF and SapI; pick one yourself if you are running conditions closer to another.

That is the interesting answer, and it is the same story at either number: a design that is geometrically perfect — one construct, every overhang distinct — still puts a third of your colonies wrong, because 35 four-base overhangs cannot all be mutually orthogonal. Roughly two thirds of the plates are the correct build and you screen accordingly. The source paper publishes a predicted 65% for this same set and observed 71% of transformants correct; scoring these 35 junctions on the BsaI-HFv2 matrix instead gives 65.0%. Reading the set on more than one measured matrix is the honest way to use the number — it is a prediction with a spread, not a constant.

ControlsCopy Anchor Link

Type-IIS enzyme — Auto-select, or a named Type IIS enzyme. Auto-select states its choice and that enzyme's geometry (recognition sequence, cut distance, overhang length), so the choice is visible rather than implicit.

The list is not a short menu of the usual suspects. It is grouped, and the grouping carries information you would otherwise have to look up:

• Kit enzymes — the canonical Golden Gate and MoClo workhorses: BsaI, BsmBI and its isoschizomer Esp3I, BbsI, SapI, and AarI with its isoschizomer PaqCI.
• Your enzymes — anything you have defined yourself, offered here the moment the reaction can actually cut with it.
• Other Type IIS in the engine — every remaining enzyme that cuts outside its own site and leaves a sticky end. There are over a hundred, and they are offered because the enzyme on your bench is not always the one a protocol was written around.

Every row shows its overhang length, and that number is worth reading before you commit to an enzyme. Fidelity depends on how many bases are available to discriminate one junction from another, so a three-base overhang (SapI) and a four-base one (BsaI) are not interchangeable in a high-order assembly. Seeing it at the moment of choosing is the point; discovering it from a fidelity score afterwards is too late.

The same enzyme under two namesCopy Anchor Link

Restriction enzymes are sold under the name of whoever isolated them, so one specificity often has several. AarI and PaqCI are the same enzyme for your purposes: both recognise CACCTGC and both cut four bases downstream on the top strand and eight on the bottom, leaving an identical four-base overhang. If you buy AarI from one supplier and your collaborator's protocol says PaqCI, you are running the same reaction.

So each row names the other enzymes that cut identically — AarI · CACCTGC · 4 nt · = PaqCI. Pick the name your tube says; the result is reported under the name you picked, never silently renamed to a supplier's alternative.

One distinction this respects, because it is the difference between a working assembly and a mysterious failure: enzymes that share a recognition sequence do not necessarily cut it in the same place. Those that cut elsewhere are neoschizomers, and they leave different ends. AatII and ZraI both recognise GACGTC, but AatII leaves a four-base 3′ overhang and ZraI cuts it blunt — they are not substitutes for one another, and no ligation will rescue the confusion. Equivalence here is established on the cut positions, not on the recognition sequence alone, so a neoschizomer is never offered as the same enzyme. Recognition sequences and cut positions are checked against REBASE.

Constructs

Per-part actions — each row in the part list carries the operations that belong to that one part, so a design problem is fixed where it is reported rather than in another tool:

Designing fusion-site primers opens a small form for one part:

Connector library — optional bridging linkers, with Add; used only as a fallback, as above.

Ligation fidelity dataset — which measured ligation matrix to score the junction set against. Published matrices exist for BsaI-HFv2, BsmBI-v2, Esp3I, BbsI-HF and SapI, each measured under particular cycling conditions, and the picker names the one in use.

Reading the fidelity tableCopy Anchor Link

One row per junction: the overhang, its fidelity, the raw correct / total ligation counts behind that percentage, and flags:

• weak — a weak Watson–Crick anneal: the overhang pairs with its intended partner less readily than the others.
• self — measurably self-ligating: the overhang can anneal to a copy of itself, which produces a head-to-head junction that no ordering rule prevents.

The overall percentage is the predicted fraction of assemblies in which every junction is correct, so it falls quickly as junctions are added even when each one is individually excellent — which is exactly what the worked example shows.

Algorithms you can chooseCopy Anchor Link

Overhang matching itself has no alternatives: two four-base overhangs are complementary or they are not. What is selectable, and changes the number on screen:

Set design has more than one published approach, and this is one member of the family. What is offered here answers give me N good junctions, which is the question asked when the parts are already decided. The other member of the family asks where should this one sequence be cut, and optimises the split positions and their overhangs together; that is a different input and it is not offered here. The nearest published treatment of it is Mukundan & Madhusudhan's dynamic-programming optimiser (2025), and where an authority disagrees with anything computed here, the authority wins.

The fidelity dataset is the choice that matters most, and it is the one to make deliberately. When no matrix has been published for the enzyme in use, the panel says so in as many words, names the matrix it fell back on, and states that the score is indicative rather than a measurement for your enzyme — as it does for BsmBI in the worked example. The alternative would be presenting a number for an enzyme nobody has measured, which is worse than an honest stand-in.

The scienceCopy Anchor Link

Digestion uses the chosen enzyme's real recognition sequence and cut geometry — the offsets on each strand, not a fixed rule — so the overhang's length, position and strand come out of the enzyme rather than out of an assumption. Cutting is circular-aware, so an acceptor's sites are found across the origin.

Assembly is overhang complementarity: each part's two ends are read as four-base single strands, every end is matched against every other, and the resulting graph is searched for paths that close. A part appearing in two paths means two constructs, and both are reported.

Ligation fidelity is not modelled — it is measured data. The published matrices record, for every pair of four-base overhangs, how often T4 ligase joined them under defined cycling conditions. The score for a junction is its correct ligations over its total, and the assembly's score is the product across junctions, which is why it is reported alongside the count of junctions.

Choosing where to cut is a dynamic program over split position and fragment count, following the method of Mukundan & Madhusudhan's Overhang Optimizer for Golden Gate Assembly (2025). Running efficiency and fidelity are carried along each candidate arrangement and multiplied at every junction, so the arrangement that wins is the one whose WEAKEST junction is strongest — not the one with the best average. The junction readings are the same measured T4 ligase data used everywhere else on this page (18 h at 37 °C, the conditions that method publishes against), so a set designed by cutting and a set graded by hand are scored on the same evidence.

Provenance of correctness. Digestion and assembly are ports of DnaCauldron and pydna, checked byte for byte against those libraries; the enzyme geometry comes from REBASE; the split-site search is checked byte for byte against the reference implementation of the method above, over every arrangement it ranks and not merely the winner; and the ligation matrices are the published experimental datasets, not a fitted curve. The worked example is independently checkable: the source paper publishes a predicted 65% for the same 35-fragment set and observed 71% correct transformants, and this tool reproduces 65.0% on the BsaI-HFv2 matrix and 61.1% on BsmBI-v2. NEB's Ligase Fidelity Viewer, the tool behind the published predictions, reads the same 35 overhangs as 65% on BsaI-HFv2 and 61% on BsmBI-v2, so the published 65% is a BsaI-HFv2 prediction, even though the figure's title names BsmBI-v2 as the enzyme the reaction ran with. The same viewer reads that set at 62% on Esp3I and 91% on plain T4 ligase after 18 h at 37 °C: one overhang set, a thirty-point spread across conditions, which is why every score here names its dataset. The paper's 13-fragment SapI set is the one case the source tables leave open: they determine twelve junctions, and the viewer gives 79% (the published figure) only with TAA as the thirteenth overhang, where the table itself implies CAT and 78%.

LimitationsCopy Anchor Link

• No published fidelity data for every enzyme. Matrices exist for five enzymes; for any other, the score is an explicitly-labelled stand-in.
• Fidelity is predicted, not simulated. The number tells you the fraction of correct assemblies to expect; it does not enumerate the wrong constructs or estimate what the incorrect colonies contain.
• Domestication needs a reading frame. A part with an internal site is both reported and fixable here — Domesticate substitutes synonymous codons until the site is gone — but silent substitution only exists inside a coding sequence, so you must name the frame (pick one of the part's own CDS features, or type a range). A site in a promoter, terminator or untranslated region has no synonymous alternative and has to be redesigned, in Sequence Optimization or by hand. The reaction's own flanking sites are refused as targets, since removing one would destroy the part.
• One reaction at a time. A build with levels that feed each other belongs in Assembly Plan, where Golden Gate is available per step.

Compared with other toolsCopy Anchor Link

Every row is a claim from a first-party vendor source, with the date it was read (2026-08-08).

Not compared: ligation fidelity scoring. Neither vendor source read in that sweep makes a claim about scoring an overhang set against measured T4 ligase data, so this page does not assert that they lack it.

ExportCopy Anchor Link

• Open as new project — the construct as a sequence, ready for a digest, a map or a verification run.
• GenBank download, carrying every annotation the parts contributed, at its position in the construct.
• Constructs CSV, Errors CSV, Warnings CSV, Markdown and a text table, for the run's report.

APICopy Anchor Link

import { goldenGateAssemble, goldenGateEnzymeInfo, preflightParts } from '@ports/goldengate';

const result = goldenGateAssemble(parts, {
  enzyme: 'auto',                  // or a named Type IIS enzyme
  expectedConstructs: 'any_number', // or a number, which errors if the count differs
  maxConstructs: 40,
});

result.enzyme;                    // the enzyme actually used, resolved from 'auto'
result.products[0].length;        // 7002
result.products[0].fragmentNames; // parts in assembly order around the construct
result.products[0].junctions;     // { fromPart, toPart, overhang, start, end }
result.errors;                    // unmatched overhangs, unused parts, forking parts

preflightParts runs the site check on its own — how many flanking sites each part carries for a given enzyme — and goldenGateEnzymeInfo returns an enzyme's recognition sequence and cut geometry.

Ligation fidelity is scored separately, against a named published matrix, and designed the same way:

import { scoreOverhangSet, suggestOverhangSet } from '@ports/ligase';

const graded = scoreOverhangSet(result.products[0].overhangs, 'BsmBI-v2');
graded.fidelity;      // 0-1, the fraction of assemblies with EVERY junction correct
graded.meaningful;    // false when a structural fault makes that number degenerate
graded.junctions;     // per junction: correct/total measured events, and where the rest went
graded.worst;         // the junctions to change first

const proposed = suggestOverhangSet(8, { dataset: 'BsaI-HFv2', fixed: ['GGAG'] });
proposed.overhangs;   // pinned junctions first, then the designed ones
proposed.fidelity;    // the same metric, on the same matrix

AutomationCopy Anchor Link

• Workflow DAG: the node is golden_gate_assemble, so a pipeline can build a construct and pass it on.
• Checking parts before you build is its own node, check_golden_gate_parts. Give it parts and an enzyme; it reports, per part, how many recognition sites it carries, whether those are the two deliberate flanks a well-formed part should have, and — for any part carrying more — the exact position and strand of every internal site that will mis-cut it. That is the answer to why will this assembly not work, available before the reaction rather than inferred from an empty result. It reads, so it needs no approval.
• Grading the junctions is score_overhang_fidelity. golden_gate_assemble hands on its construct's junction overhangs, so a pipeline can assemble and grade in two wired steps: the score, every junction's measured correct-over-total counts, the flags, and — beside each flag — the replacement overhangs that would fix it and the largest subset of the junctions worth keeping. It reads, so it needs no approval.
• Designing a set is design_overhang_set: how many junctions the reaction needs, which of them are pinned, and which measured matrix to design against.
• The copilot can call any of these by the same name; golden_gate_assemble goes through the approval gate. See The copilot.

The destination vector plus three of the Pryor fragments, checked against BsmBI: 4 parts · ready yes · 0 needsDomestication. A part carrying an internal site would appear in needsDomestication with the offending position, which is what you need to recode it.

ProvenanceCopy Anchor Link

Opening the construct as a project records the parts that went into it and the enzyme used. That record is what lets a finished plasmid be traced back to the 35 fragments it came from rather than standing alone as a sequence.

ScreenshotsCopy Anchor Link

Real runs on the shipped sample project, not mock-ups.

The Pryor 2020 sample, assembled. The pre-flight line above the controls — every part carries exactly two flanking sites — is the check that decides whether the parts are domesticated for this enzyme at all, and the assembly plan beneath lays the 35 parts out in the order their overhangs put them in.

The half that geometry cannot tell you. 61.1% is the predicted fraction of assemblies with all 35 junctions correct, measured on BsmBI-v2 — the enzyme this build cuts with, and the one the source paper ran this assembly on. The table behind it is measured data: per overhang, the fidelity, the raw correct/total ligation counts, and flags for overhangs that anneal weakly or measurably ligate to themselves. The dataset control at the top right is the point: the score names the profiling run it came from, and where an enzyme has no published matrix the tool says so rather than presenting a neighbour's data as that enzyme's.

The product opened as its own sequence. Every one of the 35 four-base fusion sites is written onto the construct as its own annotation (GGAG, CAGA, GGTA, TAGC, …), alternating with the 35 part bodies, each named for the part it came from — insert_01, insert_02, … around the ring — so you can read which fragment landed where, and in which orientation, off the finished molecule rather than only in the report. The panel on the right reads the construct back independently: 7,002 bp, 53.5% GC, 70 features, 43 cut sites, 7 ORFs.

The other direction: a sequence with no sites yet. Give it the two overhangs you want it to carry and a target annealing Tm, and the pair comes back with the recognition site, spacer and overhang prepended — with the accounting that matters at the bench, since the PCR product and the part it releases are different lengths (215 bp amplified, 189 bp released after digestion).

The real E. coli lac operon added as a part: three BsmBI sites, two of them flanking and one internal, which would be mis-cut. Pointing the tool at the lacZ reading frame removes it by a single synonymous substitution — GAC→GAT at codon 213, a codon used 65% of the time in this host — so the part keeps its protein exactly and loses the site.

RelatedCopy Anchor Link

Feeds it: PCR Simulation and Primer Designer, for parts you amplify with the flanking sites added; Sequence Optimization, for removing an internal site.

Follows it: Restriction Digest and the gel bench, for the diagnostic check; Sequencing Verification, for the built clone.

Alternatives to it: Gibson Assembly for scarless terminal-homology joins, Grammar Assembly for syntax-checked part sets, and Assembly Plan when the build has more than one round.

In this group: Restriction Digest · Ligation · Gibson Assembly · Grammar Assembly · Assembly Plan · Recombination Cloning · Site-Directed Mutagenesis · Site-saturation mutagenesis · Multi-site mutagenesis