Simulated cloning

Cloning happens in two places, split by what each thing works on.

The Cloning tab in the sidebar is about the document in front of you, and draws on its views. Its picker chooses one of three: Digest, which cuts the document with restriction enzymes and describes the fragments end by end, PCR, which amplifies a stretch of it with two primers, and Mutate, which designs the primers for a point mutation, insertion or deletion. The fragments and PCR products you keep go on the shelf.

The Bench, a tab of its own beside Files in the tab strip, is where the parts are joined, from any number of documents: Ligation, which joins shelf fragments by their overhangs, Golden Gate, Modular (MoClo and Yeast Toolkit positions, and every combination of parts), Gibson (with the In-Fusion and NEBuilder primer design), Overlap PCR (fusing fragments by PCR, with the primers designed), and Gateway. Beside the reaction it draws what the reaction would make, and a digest to check it by.

In both places the reactions are alternatives, so one is shown at a time and the choice is remembered. Whichever you use, the product opens as a new document with the features of its parts.

Digest

The digest uses the enzymes ticked in the Enzymes tab, less any site the document's own methylation blocks (see Where the DNA was grown). Tick the enzymes you would put in the tube, then come back. It follows the ticks alone: the toolbar's Cut sites toggle only hides the sites drawn in the views, so a decluttered map still digests with everything ticked. Fragments are listed largest first, each with:

• its length (click it to select the fragment in the views) and range;
• its two ends: the enzyme that made the cut, whether the end is blunt or has a 5′ or 3′ overhang, and the overhang bases;
• the features it carries. A feature a cut runs through is trimmed to the part in the fragment and marked partial. A circle cut once opens up inside such a feature, so the linear piece has it at both ends, as two partial features rather than one joined across the ends: an insert ligated at the cut then sits between them instead of being skipped. Each piece remembers the feature it was cut from, and ligation puts the pieces back together as that feature only where they meet again exactly as they were cut, as closing the vector on itself does, or religating a digest's fragments in their own order: no base lost or gained between them (a dropout, a fill-in or a chewed-back end leaves them apart), a cut in an intron gets its own bases back, and every base of the feature is its own again (a base edited in a piece since the cut, or a PCR primer's mismatch, leaves them apart). The feature comes back whole, with its /translation and a /transl_except whose codon the cut had split. Pieces of two features that merely look alike (the same name in two plasmids) stay apart. The memory lasts while the app is open and through the shelf; a fragment saved and reopened as a file starts afresh, its pieces then staying apart;
• Add, which puts it on the shelf, and Open, which opens it as a document of its own. Add reads Added ✓ for a moment, and the Bench tab's count flashes. While the fragment is on the shelf its row says On shelf (On shelf ×2 for two copies, and so on, counting a copy turned over or dephosphorylated on the Bench), and the button reads Add again: a second copy is allowed, since a tandem insert needs one, but it should be one you meant.

An uncut linear molecule is one fragment with the ends the molecule already has; an uncut circular molecule gives nothing to work with.

Right after an edit the list gives way to Scanning for restriction sites… until the document has been scanned again, usually in a fraction of a second. The views keep drawing the sites the edit left alone in the meantime, but an edit can make a site as well as break one, so the digest waits rather than list or shelve fragments the tube would not give. If the scan fails it is tried twice more, and then an error says so.

Partial digest lists every piece a digest that misses some of the sites can give, not only the complete digest's: each stretch from one cut to any later one, with the sites between left uncut, and on a circle the whole molecule opened at each single site. It is how an insert is cut out when the enzyme also cuts inside it. Each piece says how many sites it leaves uncut (none for a complete digest's). The count grows fast — two sites give 4 pieces on a circle, 35 give over a thousand — so beyond 200 the list keeps the pieces that miss the fewest sites, which are what a partial digest mostly gives, and only the piece under the pointer is drawn on the views.

Every fragment is also drawn on the map and in the sequence view while the tab is open, in the dashed preview colour (see Previews), with a tick where each cut falls. Nothing is added to the document. Hovering a row draws that one fragment as a solid arrow instead, which is how you see at a glance which piece is the backbone and which is the insert — the sizes alone cannot tell you where they are.

Click a fragment in either view to put it on the shelf, which is what Add in its row does. On the map that is the thin dashed ring just inside the backbone; in the sequence view it is the band outside the feature lanes. The last line of the Cloning tab counts what is on the shelf, so you see it land, and Open the Bench takes you to it.

Sticky ends on a document

A fragment you Open, and a linear ligation product, is a molecule whose two strands stop in different places, and it is kept that way: the document remembers each end's shape, overhang and enzyme. The toolbar says so next to the length (538 bp, linear · AlwNI 3′ CCA / BsaI 5′ ACCG), and the sequence view draws it:

• bases with nothing opposite them — the single-stranded part of the overhang — are washed over and have a gap on the complement line;
• where the other strand runs past the sequence instead, its bases are drawn just outside the first or last column.

On the circular map, where a linear molecule is an open ring, every end has a cap across the backbone, numbered 1 and the length. A cut or sticky end has a longer cap in the cut-site colour, and the ends are named under the length in the middle.

Digesting such a molecule again gives its outer fragments the ends it came with, so a piece can be cut, opened and cut again without losing track of what will ligate to what.

The ends are saved with the document. GenBank has nowhere to put them, so they travel as a comment line of ours (PlasmidPop-ends: ...) that other software ignores and PlasmidPop reads back; FASTA carries the same in its header, and SnapGene files bring their own overhangs with them (see Files and storage).

Editing the molecule's tip — typing over an overhang base, deleting the first or last bases, pasting at either end — leaves an end that is no longer the one the enzyme made, so that end goes back to being a plain blunt one. An edit in the middle leaves both ends alone. Making the molecule circular drops them, since a circle has no ends; reverse-complementing swaps them and moves the sequence to the other strand's window, which is a few bases longer or shorter (see Editing the sequence).

Blunting the ends

To join an end to one it does not match — an EcoRI end to a SmaI one, say — make it blunt first. With a sticky-ended linear molecule open, the edit bar offers two ways, as the bench does:

• Blunt (fill in) is Klenow or T4 DNA polymerase: a 5′ overhang is filled in, so its bases become base pairs and the molecule grows by them where they were on the other strand, and a 3′ overhang is chewed back.
• Blunt (trim) is mung bean nuclease: every overhang, 5′ or 3′, is removed.

Both ends are blunted at once, and features move with the bases. It is an edit like any other, so Undo takes it back and the History names it. To blunt one end only, do it before cutting the other: digest with the first enzyme, Open the fragment, blunt it, then digest that with the second. To put the blunted piece on the shelf, untick every enzyme: an uncut linear document is one fragment, with the ends it has, and Add shelves it. A blunted end is still the enzyme's end, shown as, say, "KpnI blunt": the molecule is still a cut vector that can close on itself, so the Bench's empty-vector lane works for it, unlike for a PCR product.

PCR

PCR is where a part comes from. The other three reactions join pieces that already exist somewhere; a PCR makes one that is in no file yet, because what a primer carries at its 5′ end ends up in the product.

Choose PCR in the picker and paste the two oligos, written 5′ to 3′ as you would order them. Nothing else is asked, because everything a designer decided is already in those two sequences. They stay in the boxes while you look at the digest, another sidebar tab or another document, and come back with this one; Mutate's change does the same. A primer from My primers can be put in a box from the Primers tab (PCR fwd, PCR rev); its name then shows beside the box and on the product's primer features, until you edit the bases.

The template is the document in front of you. With more than one tab open, Template picks another one instead, so an insert can be amplified out of one plasmid while you look at the vector it is going into. Its products are listed and can be opened or shelved, but they are not drawn: the views show the document in front of you, and another molecule's positions would land in the wrong places.

• Only the 3′ end has to match the template. A cloning primer is a 3′ part that anneals and a 5′ tail that does not — a restriction site, a Gibson homology arm, a tag, a His stretch. The tail is copied into the product all the same. Under each box the panel says how long the oligo is, how much of it is tail, the melting temperature of the part that anneals and where it lands. A tailed or mismatched primer gets two temperatures: the first on the template, counting only the 3′ bases up to the first mismatch, and the second once the product — which carries the whole primer — is the template. The usual advice for such primers, a few cycles at the lower temperature before the rest at the higher, follows from the two.
• The last 5 bases must match exactly, as they must on the bench: a polymerase extends from the 3′ end, and a mismatch under it stops the reaction whatever the rest of the oligo does. Up to two mismatches further back are allowed.
• Degenerate primers work. An ambiguity code in a primer (N, R, NNK for a codon library) pairs with every base it stands for, and is written into the product as the code it is, so a library made with Mutate amplifies here. Its melting temperature is that of the molecule in the mix that matches the template.
• A mismatch is a mutation, not an error. The product is the primers' sequence, not the template's, so a deliberate mismatch is carried into every copy. That is site-directed mutagenesis, and it needs nothing else here: design the primer with the change in it and amplify.
• The product lists what it would be: its length, the stretch of template it copies, and whether it runs over the origin. Show draws it and its two primers on the map and in the sequence view (see Previews), a primer's mismatches marked on it; Open opens it as a document, with the template's features and a primer_bind feature for each oligo, tail and all. Clicking the previewed product in either view opens it too. Shelve puts it on the shelf instead, the same molecule with blunt ends, ready for a ligation, a Golden Gate or a Gibson.
• Upper case in the product means "not from the template". The bases that came from the template are written in the case the template writes them (usually lower, in a GenBank file), so what is left in capitals is the 5′ tails and any mismatch — the way a primer is written out in a paper.
• More than one product is what a real tube gives when a primer binds in more than one place. They are listed cleanest and shortest first, because an exactly-matched short amplicon out-competes the rest, and drawn as a gel so you can see whether the bands could be told apart — on the agarose percentage and beside the ladder chosen under it (see The gel).

Two primers pointing away from each other on a plasmid amplify the long way round — inverse PCR, which is how a vector is linearised for a Gibson. It needs nothing special here: it is simply the product that happens to be nearly the whole molecule.

Polymerase chooses what comes out. A proofreading enzyme (Q5, Phusion, Pfu) leaves the product blunt and reaches 20 kb; Taq adds one A to each 3′ end, which is what TA cloning joins by (a TA vector's single 3′ T overhangs pair with them on the shelf), and is taken to reach 5 kb. A pairing that would give a longer product is reported and not built. A Taq product's length counts its added A, as the length of any fragment counts the overhang its top strand carries: a 500 bp amplicon is listed, drawn and shelved as 501.

5′-phosphorylated primers: oligos are made without a 5′ phosphate unless ordered with one, and a PCR product's 5′ ends are its primers'. So a shelved product is marked dephosphorylated (see Ligation) unless this is ticked, and will not ligate into a dephosphorylated vector — as on the bench.

Primer dimers. When the 3′ end of one primer pairs with the other, or with a second copy of itself, over more than 4 bases, the panel says so: a polymerase can extend the pair into a short product of its own.

The Bench

The Bench is the tab after Files in the tab strip; its count is the number of parts on the shelf. Files and the Bench are always in the strip, even with every document closed and the shelf empty. It has three columns:

• the shelf on the left;
• the reaction in the middle: Ligation, Golden Gate, Modular, Gibson, Overlap PCR or Gateway, picked at the top. What each is set to — the parts left out of its tube, its enzymes, the tabs it uses, a name you have started typing — stays as it was while you look at a document, and across a reload;
• what it makes on the right, once the parts go together: the product's map, drawn as the editor draws one, with the check digest's cuts marked on it. Hover a feature or a cut site to bring back a label the ring had no room for; zoom with the mouse wheel, a pinch or the +/− buttons under the map, drag a zoomed map to pan it, double-click a feature to fit it, and Fit to see the whole circle again. There is nothing to select until you Assemble and the product opens as a document.

Under the map is Check by digest: the product cut with one enzyme, beside the empty vector cut with the same one. What a miniprep screen asks is whether a colony took the insert or carries the vector without it, so the enzyme list (every enzyme that cuts the product between once and six times, with the product's own methylation allowed for) puts first the one whose two lanes differ most clearly, and says of each what the empty vector gives, (same) where it gives the product's bands.

The empty vector is taken from the longest part in the tube; Against picks another. A circular vector is the empty vector as it went in (an uncut destination vector in Golden Gate, Gibson or Gateway); a cut one is that piece closed on itself, when its two ends join. A vector cut with two enzymes, or dephosphorylated, cannot close, and a PCR product has no phosphates to close with: then the Bench says so and ranks the product's lane alone, clearest first, as the Enzymes tab's band separation sort does. An enzyme that does not cut the empty vector leaves it uncut, and a supercoiled circle does not run at its size, so that lane is not drawn.

The phone reader has no Bench.

The shelf

Add in the digest, and Shelve under a PCR product, put a part on the shelf. The shelf belongs to the Bench rather than to one reaction: Ligation joins its fragments, and Golden Gate and Gibson take them into the tube beside the open documents. A shelved part is a copy, sequence, ends and features, so it does not need the file it came from: it survives closing every tab, deleting the file and reloading the page. Fragments you collected on Friday are still there on Monday.

On the Bench each part shows its name, length and ends. −P dephosphorylates it (see below), ⇄ flips a fragment (reverse complement, ends swapped), ↑ ↓ reorder, ✕ removes, and Clear shelf empties it. The order and the flips are what Ligation joins by; Golden Gate and Gibson work out their own order and ignore them. A reaction leaves the shelf as it is, so a vector cut once can take one insert after another.

Undo and Redo in the toolbar, and Ctrl+Z / Ctrl+Shift+Z, undo and redo changes to the shelf while the Bench is in front, including parts added from the Cloning tab. The shelf keeps a history of its own: undoing on the Bench never touches a document, and a document's undo never touches the shelf. Hover Undo to see what it will take back.

Site-directed mutagenesis

Mutate designs the two primers for a change to the document in front of you, and opens the plasmid they would make.

1. Select the bases to change, or put the cursor where new bases go.
2. Type what they become in Change to (for a cursor, Bases to insert). Leave it empty to delete the selection. Ambiguity codes are accepted, for a degenerate codon. A U is read as T, and spaces and digits are ignored; anything else that is not a base is left out, and a note under the box says what was (_U read as T. Left out, not bases: “#”._).

Inside a CDS you can name the residue instead of the bases. Change a residue says which codon the cursor is in (tet V14 (GTC)); pick the new amino acid under To and the codons for it appear, the one your Host uses most first and starred, each with its share of that residue's codons in the host's genes and, on hover, how many bases it changes. Click one and it selects the codon and fills Change to in for you — complemented already if the CDS reads on the reverse strand. The hosts are E. coli, yeast, _P. pastoris_, human, mouse and CHO, from the Codon Usage Database.

Library puts a degenerate codon there instead — NNK, NNS, NNN or NDT — and says what it covers: how many codons, how many amino acids, how many stops, and roughly how many colonies to screen to be 95 % sure of meeting any one codon.

On a linear sequence a change at or near an end leaves a primer too few bases to anneal to; the design then says so rather than showing a primer with no annealing part.

1. Choose the design: - Back to back is NEB's Q5 site-directed mutagenesis: the primers point away from each other and meet at the change, which rides on the forward primer's 5′ end (a long insert is split between the two). Each primer's annealing part grows until it reaches 60 °C by the nearest-neighbour Tm the rest of the app uses. Beside it each primer also carries NEB Q5, the Tm NEB's own calculator gives for Q5 — it reads a few degrees higher, because Q5's buffer does — and the panel says what to anneal at, which is NEB's number: a degree over the lower primer's Q5 Tm, to a tenth of a degree, and no more than 72 °C. A self-complementary primer (one that reads the same on both strands) gets the lower Tm NEB gives it. Amplify the whole plasmid, then phosphorylate, ligate and digest the template (KLD). - Overlapping is Agilent's QuikChange: two complementary primers with the change in the middle, grown until they reach 78 °C by Agilent's formula. Copy the plasmid round, digest the template with DpnI, and transform.
2. The panel names the change (A801G, Δ1,001–1,030, `+GACTAC… after

1,500; through the origin of a 2,500 bp plasmid, TTCT2,499–2CATG, the old bases read round the origin and the end counted from 1 again) and what it does to every CDS it falls in — the residue changed (lacZ K12R`), a silent change, or a frameshift — read with the feature's own genetic code and strand. Each primer is written 5′ to 3′ as you would order it, new bases in upper case, with Copy.

1. Open mutant opens the plasmid with the change made. It opens as the template renamed, with the change as its one edit, so the edit marks show it and Undo takes it back.

A design that cannot reach its temperature within 60 bases says so.

Ligation

Ligation joins the shelf's fragments in the order they stand on the shelf. The usual workflow is:

1. Open the vector, tick the enzymes, add the backbone fragment.
2. Open the file with the insert (it gets a tab of its own), tick the same (or compatible) enzymes, add the insert fragment.
3. Open the Bench and choose Ligation. Every shelf fragment is in the ligation to begin with; untick one to leave it out, for instance a piece you collected for a Gibson.
4. Arrange the parts on the shelf. Between consecutive parts in the Ligation list a junction line shows ✓ when the ends can be ligated, ✕ ends do not match when they cannot. With Circular product ticked there is also a closing junction from the last part back to the first.
5. Once every junction is compatible, a Product line says what the ligation would make: its length, whether it is circular, and the features it carries. Give the product a name (or keep the suggested one) and click Assemble.

The product opens as a new circular or linear document carrying the parts' features; the shelf keeps its fragments. The product is kept in the browser like any other document; download it to get a file.

Ends are compatible when both are blunt, or when they have the same kind of overhang with complementary bases. A PstI end will not join an EcoRI end, and a BamHI end will join a BglII end (both leave GATC). An ambiguity code in an overhang pairs with any base it stands for: N with anything, R with A or G.

Dephosphorylation. A ligase joins a strand only to a 5′ phosphate, which a restriction enzyme leaves on every end. Treating a vector with a phosphatase (CIP, rSAP) — −P on its shelf row — takes those phosphates away, so the vector can no longer close on itself: its closing junction says both sides dephosphorylated and Assemble stays off. An insert with its phosphates still joins it, one strand at each junction, as on the bench. Two dephosphorylated parts do not join each other at all. The treatment belongs to the shelf part; a part you Open as a document does not carry it.

Golden Gate

Golden Gate is a different reaction; choose it on the Bench. Every part carries the same Type IIS enzyme's site at each end, pointing inwards, so cutting takes the sites away with the flanks and leaves a four-base overhang the designer chose. Cutting and ligating happen in one tube, and the overhangs, not you, decide the order.

The panel works that out:

1. Put the destination vector and every part in the tube. Anything open is one, each in its own tab, and so is anything on the shelf — a piece already cut out of a plasmid goes in beside a file, and the list says which is which.
2. Choose the enzyme the parts were designed for. BsaI is the default; BsmBI, BbsI and SapI are there too, along with the other Type IIS enzymes in the table that leave an overhang. For parts made for two enzymes — a BsaI vector taking a BsmBI part, say — choose the second in and; both then cut everything in the tube, and a piece keeping either site is cut again.
3. Untick anything that is not in the tube. Everything is in it to begin with.
4. The panel digests each part, throws out the pieces that still carry a recognition site (those are cut again in a real reaction) and any piece with a blunt end, then follows the overhangs from one piece to the next. It reports the order it found, the overhang each part joins on, and a Product line with the circle's length and the features it carries. A part with no site in it — a fragment off the shelf, usually — survives the digest whole and joins on the sticky ends it already has, which is what happens in the tube.
5. Name the product if you like, then Assemble. It opens as a new circular document with the parts' features.

When the parts assemble, the panel also checks the set of overhangs the product joins on, as a designer would, and lists what could make a ligase join the wrong ends:

• the same overhang at two junctions, or an ambiguity code that could be another junction's overhang (AGGN and AGGA), so the parts there can swap;
• two overhangs one base apart, like AATG and AATC;
• an overhang one base (or none) from another one read the other way round, since a ligase pairs an overhang with the complement of the other's too;
• an overhang that is its own reverse complement (GATC), which lets a part join a copy of itself back to front;
• an ambiguity code, which pairs with every base it could stand for.

These are warnings: the product shown is the one the design intends, and Assemble still works, but the tube may give other products as well.

Measured fidelity

The warnings above are design rules, and a rule cannot say how _much_ of the reaction goes wrong. A ligase end-joining table can: it counts how often every pair of overhangs was actually joined, so a set of junctions can be scored before the oligos are ordered.

PlasmidPop does not ship one — the published tables are not ours to pass on — so bring your own, as you do for REBASE enzymes: Import a ligase fidelity table under the assembly, then choose the file or drop it on the box. It should be a square matrix — a first row of overhangs, then a row per overhang, each cell a count — which is the shape ligase-fidelity tables are published in. It is read in your browser, never uploaded, and kept for the next visit until you forget it again.

The file can be an Excel workbook (.xlsx), as most published tables come, or the table saved as CSV or tab-separated text. In a workbook the first sheet that starts with a row of overhangs is read. An old-style .xls workbook or an OpenDocument .ods one has to be saved as .xlsx or CSV first; PlasmidPop says so if you open one.

In the supporting information of Potapov et al. 2018 (doi 10.1021/acssynbio.8b00333), the end-joining tables are files S01–S04 (T4 DNA ligase, 1 h or 18 h, 25 °C or 37 °C; S04, 18 h at 37 °C, is the one NEB's tools are built on) and S06 and S08 (T7 DNA ligase). The other files are the results of whole assemblies, with their overhangs numbered rather than spelled out, and none of their sheets is a table to import.

With a table loaded the panel shows Fidelity, the share of assemblies expected to come out right, and names the pairs that cost the most — a mis-join, or an overhang that joins a copy of itself. It is measured end-joining for that table's ligase, temperature and time, not a prediction of your reaction, and it does not replace the warnings above: a palindromic overhang joins a copy of itself as readily as its partner, which no end-joining table can see, because to the experiment the two are the same pairing.

A set in which two junctions can be the same one — an overhang twice, an overhang and its reverse complement (GGAG and CTCC), or an ambiguity code that could be either — is not scored: the panel says Fidelity not scored and names the pair, since the parts at those junctions can go in either order and no share of right assemblies describes that. Each mis-join is named once, at the rate of the junction it costs most, although it counts against both junctions it joins.

_N_ pieces left out expands to say what was discarded and why. In a well-designed set that is the vector's stuffer and each part's two flanks.

A part goes in whichever way round its overhangs demand, so a part ordered back to front is turned around for you and the order says (flipped) beside it. If two parts offer the same overhang, or none offers the one the reaction has reached, the panel says so rather than guessing: Golden Gate needs every overhang to be distinct, and an ambiguous set is a design problem worth seeing.

The product is always circular, and always the whole set: a reaction that would use only some of the parts is reported as a failure, not quietly assembled from what fits.

Modular cloning

Golden Gate on its own joins whatever is in the tube. Modular cloning (MoClo, the Yeast Toolkit) works from a standard: a list of named positions, such as Promoter, 5′UTR, CDS and Terminator, each with the two overhangs its part is cut with. Choose Modular on the Bench to work that way.

1. Put the destination vector and the parts in the tube, as for Golden Gate.
2. Choose the standard. MoClo plant common syntax and Yeast Toolkit (YTK) come with the app; they are only overhang sequences, taken from the papers named under the picker. Others, GoldenBraid or CIDAR say, are not bundled: Import a standard reads a text or CSV file with one position per line, Promoter,GGAG,TACT, and an optional first line # My kit, BsmBI for its name and enzyme. An imported standard is kept in this browser; remove forgets it.
3. Choose the enzyme the parts were designed for. A standard starts it on its own, and the second enzyme works as in Golden Gate.
4. Every part is placed. The panel digests it, and a piece whose two ends are one position's, read either way round, belongs there; a piece that closes the gap from the last position back to the first is a Destination. The list Positions shows what was found. Set a part's position by hand from its menu when the panel could not (a part with a different enzyme, or a part with an internal site), or choose Leave out. A part that was set by hand stays set.
5. The plan is one slot per position that has a part, with the destination first. Two parts in one slot are alternatives: the plan makes every way of choosing one per slot, so two promoters and three CDSs give six assemblies. Each runs as the Golden Gate it is. The count says how many assemble and how many cannot, and the list names the ones that cannot, with the reason, ahead of the ones that can. Up to 500 combinations are run; untick parts to get under it.
6. Assemble beside a product opens it as a new document, with the parts it was made from in its history. Assemble all opens every one that forms, up to 24 at a time.

If an end of a slot meets no other slot (a position left out of a chain), the panel says which, before the reaction does. Below the list it shows the overhang warnings and, if you imported a fidelity table, the fidelity of the junctions the plan uses; these depend on the positions, so they are the same for every product of the plan.

Not covered: lab inventory and well positions, and a design of the oligos that make a new part. A standard that needs a different enzyme at each level is planned one level at a time, choosing the enzyme for that level.

Gibson

Gibson assembly has no enzyme and no site. Each piece is made to end in the same 15–40 bases the next one starts with — by the tails of the primers it was amplified with, usually — and in the tube an exonuclease, a polymerase and a ligase join them. The product is seamless: the shared stretch appears once, and there is no scar to design around.

So the panel asks only what is in the tube. Choose Gibson on the Bench, then:

1. Put the parts in the tube. Anything open is one: the linearised (or PCR-amplified) vector and the inserts, each in its own tab. So is anything on the shelf, which is how a backbone cut out of a plasmid joins an insert amplified from somewhere else — the two are one list with a tick each, and a piece off the shelf says so beside its size. A circular document is left out, because it has no ends to join by; digest or linearise it first.
2. Untick anything that is not in the reaction. Set Overlap to the shortest homology to accept; 15 bp is the default and what NEB's protocol asks for.
3. The panel finds the longest shared stretch between the end of one part and the start of another, however long it is, follows the chain, and reports the order. A part whose ends only fit the other way round is turned around for you and says (flipped).
4. Each junction line gives the length of the homology and its melting temperature, and a Product line under them the length, topology and features of what would come out. The reaction is held at 50 °C, so a junction under 48 °C is marked: the homology is there, but it may not anneal.
5. Assemble opens the product as a new document with every part's features. Untick Circular product for a linear one.

One part on its own is an assembly too, if its two ends share homology: that is how a PCR product is circularised.

When the parts assemble, the panel also lists what could make the tube give something else:

• Homology found elsewhere. The exonuclease leaves each end as a long single strand, and it anneals to whatever pairs with it. So each junction's homology is looked for everywhere else in the tube, on both strands, in stretches as long as Overlap; a hit is named with its part and position, as somewhere a chewed-back end could anneal instead.
• A short part. A piece under 200 bp may be chewed away from both ends before it anneals; NEB suggests adding it in a 5-fold excess.
• Short overlaps for the number of pieces. NEB asks for 15–20 bp with two or three pieces and 20–30 bp with four to six.

These are warnings; Assemble still works.

If two parts could follow the same one, or nothing follows a part, the panel says which and assembles nothing. Homology that is unique to each junction is what makes a Gibson design work, and a set that is ambiguous on paper is worth seeing before it is ambiguous in the tube.

In-Fusion and NEBuilder: designing the insert primers

In-Fusion (Takara) and NEBuilder HiFi (NEB) work the way Gibson does, so the reaction is the one above; what they need is the two primers that put the vector's ends on the insert. Design insert primers, under the Gibson panel, makes them.

1. Linearise the vector — digest it, or amplify it by inverse PCR — and open it in a tab.
2. Open the template to amplify the insert from.
3. Choose In-Fusion (15 bases of homology) or NEBuilder HiFi (20), then the two tabs, then the Insert: the template tab's selection, if it has one, any of its features, or, for a linear template, all of it.

Each primer is the vector's end in upper case followed by the bases that anneal to the template, grown until they melt at 60 °C. The panel then _runs_ the design — amplifies the insert with those primers and assembles the amplicon with the vector — so what it shows is the circle they would really make, not a promise. Open product opens it.

It warns when the vector has sticky ends, and when the primers would amplify something else from the template as well.

Overlap PCR

Overlap-extension PCR (SOE, or OE-PCR) fuses two or more fragments with nothing but a polymerase: each fragment is amplified with a primer whose 5′ tail is the end of its neighbour, so the first-round products share a stretch where they meet. Mixed and cycled they anneal there and extend into one molecule, and the two outer primers amplify it. It is a cloning-free way to fuse parts, to add a tag, or, with two pieces of the same template, to make a deletion. Overlap PCR on the Bench designs the primers.

1. Open the fragments, each in a tab. A fragment can be all of a document, its selection, or one of its features; to make a deletion, use the same tab twice, with the piece before the deletion first and the piece after it second.
2. Under Overlap PCR on the Bench, choose for Fragment 1 its tab and which Part of it, then the same for Fragment 2. Add fragment adds more, up to eight; the arrows put them in order and Remove drops one.
3. Choose the Overlap Tm (60 °C by default). Each junction's overlap grows, half from each neighbour, until it melts at about that temperature.

The panel lists the primers in the order to ask for them: F1 and R2 (for two fragments) are the outer primers, with no tail; the inner ones carry the neighbour's end in upper case, and the two inner primers of a junction are complementary over the whole overlap, as they are usually drawn. Each annealing part is grown to melt at 60 °C. Under them are each junction's overlap and its melting temperature, the size of each first-round product, and the fused molecule.

The panel _runs_ every step it describes, with the same PCR simulation as the PCR panel: each fragment is amplified from its own tab, the products are joined by their overlaps, and the outer primers amplify the join. What it shows as the product is what the outer primers would really amplify; a design that does not come out as the fragments end to end is refused with the reason, not shown.

It warns when:

• an overlap is short: under 15 bases, or melting under 50 °C;
• an overlap is not unique: it occurs again in the fused molecule, so a first-round product can anneal at the wrong place;
• a primer's own annealing part melts well below its target, because its fragment gave it no room to grow, and when its primers amplify more than one product from a template;
• a gene is read out of frame across a junction. For each CDS that runs up to a junction, the frame it is in there is compared with the frame the CDS on the other side was read in: a deletion inside a gene of a number of bases that is not a multiple of three, or a tag fused a base or two off the frame of the gene before it, is named.

Open product opens the fused molecule with the outer primers drawn on it and how it was made recorded (What a product was made from), so Protocol… lists every primer and lists the fusion step as a reaction of its own. Save primers keeps all of the primers in My primers, named after the fragments (or the name you typed for the product).

Ambiguous bases (N, R, Y…) in a fragment are refused, as a primer cannot be designed over them, and so is a fragment under 36 bases, which cannot carry a primer at each end.

Gateway

Gateway is recombination, not cutting and joining: an integrase pairs two att sites that share a core and swaps the DNA on either side. Two sites on one plasmid and their partners on another therefore exchange the stretches between them, which is why every reaction makes two circles.

• BP: an attB substrate × a donor vector (attP) → an entry clone (attL) and a byproduct (attR).
• LR: an entry clone (attL) × a destination vector (attR) → an expression clone (attB) and a byproduct (attP).

The att sites are read from the annotation the files carry. A real donor, entry or destination vector labels them (attP1, attR2, attL5, attP2r), and so does a PCR product once its attB tails are annotated. Nothing is bundled and nothing is guessed from the sequence: if a plasmid does not label its sites, the panel says so, and you can annotate them yourself (see Features).

1. Open both plasmids, each in its own tab.
2. On the Bench choose Gateway, then BP or LR. Each picker lists every open tab with the att sites it annotates.
3. The panel recombines them and describes the clone. Open clone opens it; Open byproduct opens the other circle.

The numbers are what pair: attL1 recombines only with attR1, never with attR2, and the panel says so rather than guessing when they do not match. The crossover point is found from the two plasmids themselves — partner sites share a core, so the longest stretch they have in common is it — and each recombinant site is half of each parent's, named for what it has become.

Which of the two circles is the clone is read off the att sites, not off what anything is called. The piece that moves is the one between the insert's two sites, and the two sites of a real pair face opposite ways, so a map that draws attL1 on the forward strand and attL2 on the reverse is read correctly however the plasmid is rotated — including when the insert wraps the origin, which an entry clone made here routinely does. If a file draws both sites on the same strand, the names are used instead, in the order the kits lay their sites out rather than the order they count in: a MultiSite expression clone reads attB4–attB1–attB5–attB2–attB3, so attB4–element–attB1r and attB5–element–attB2 run the way they are written. That is a guess, so if it would put the vector's ccdB gene on the clone the other circle is taken instead and a warning says so. Check the sites' strands when a clone comes out looking like the byproduct.

A MultiSite reaction is run one fragment at a time: each attB-flanked element with its own pDONR (attB4/attB1r with pDONR P4-P1R, and so on), and a plasmid annotating more than two sites of a kind is refused rather than guessed at.

It also tells you:

• that the ccdB cassette leaves on the byproduct, so the clone that grows in an ordinary strain is the one you want;
• when the clone itself carries the ccdB gene and the byproduct does not, which is the wrong way round and usually means the att sites of the insert are mislabelled;
• when a pair shares less than a full att core, which usually means a site is annotated over only part of its length;
• when a tag in the backbone reads out of frame into the insert across an att site — the commonest Gateway mistake, and one the sequence can answer.

A vector written on the other strand from the insert — its att sites annotated on the reverse strand where the insert's are on the forward — is the same plasmid read the other way round, and recombines the same. One pair of sites on the same strand and the other on opposite strands is not an exchange, and the panel says so.

A linear attB substrate (a PCR product) gives a clone but no byproduct circle: its two flanks come away as loose ends and are lost.

One pair of sites at a time, so a multisite LR is done a fragment at a time.

What a product was made from

Every product remembers how it was made: a fragment you Open, a PCR product, a ligation, a Golden Gate, Gibson, In-Fusion or NEBuilder assembly, an overlap-extension fusion, a Gateway clone and a mutant. A part on the shelf remembers too, so a plasmid ligated from a shelved fragment of a PCR product goes all the way back to the template the PCR was run on. Each step keeps the reaction and what set it apart: the enzymes and where the fragment lay, how many sites a partial digest left uncut, the primers and polymerase, the order and which parts were turned over, the kit, the Gateway reaction, the mutation and how it was designed, and a dephosphorylation on the shelf. For each molecule it keeps the name, size, topology and checksum, but not the sequence.

To see it, open the History tab and expand Made from at the top. The tree is described in History, and a protocol for the bench can be built from it.

Editing a product afterwards does not rewrite it. The tree says what the product was made from, and the History list says what has been done to it since; the top of the tree then reads edited since. If an edited product goes into another reaction, the new product's tree shows the edited version made from the original.

The tree is saved with the document. GenBank has no field for it, so it travels as a block of PlasmidPop-made-from: comment lines. Other software sees an ordinary comment, and PlasmidPop reads it back. A share link carries it too, since a link carries the GenBank text. FASTA has no room for it, so a FASTA export leaves it out. A block edited by hand into something that no longer reads is kept as an ordinary comment. The tree keeps at most 64 molecules; beyond that, the oldest steps are replaced by a line saying how many earlier molecules were left out.

SnapGene keeps a history of its own in its .dna files, which PlasmidPop does not read yet.

Protocol for a product

A product records how it was made, and Protocol… turns that record into a page to take to the bench. It is under the Made from tree in the History tab and under the map of a Bench product, and appears wherever the document carries a record. A document with no record has no protocol.

The page lists, in this order:

• the oligos to order: every primer the PCRs and mutagenesis steps used, once each, with what it is for. One whose bases are already in My primers says so, under whatever name it has there, instead of "order";
• the reactions, in order, each before the one that uses its product. A PCR gives the template, the primers and the product length, the melting temperature of each primer, a suggested annealing temperature and the extension time for the product's length. A primer longer than 30 bases is taken to have a tail, so its melting temperature is from its last 22 bases: check it against the PCR panel when the primers are tailed. A digest gives its enzymes and fragment. A ligation, Golden Gate or Gibson gives each part's length, ng and pmol, and the program;
• the expected diagnostic digest: the enzymes of the set in use that cut the product once to six times, clearest first, with the bands each gives.

The dialog asks for the only things the record cannot say: the vector in ng (50 by default), the insert : vector molar ratio (3 for a ligation, 2 for Golden Gate and Gibson, unless you type one), and, for each part, its concentration in ng/µL, which adds a µL column to the tables. The longest part is taken to be the vector. The preview is the page itself; Download HTML saves it as one file with its own styles, Download Markdown as text.

Everything comes from what the app already works out. The programs are the usual ones for each reaction, and buffers are not given: PlasmidPop holds no enzyme buffer data, so a digest says to take it from the supplier's table. A tree trimmed to 64 molecules, or a product edited after it was made, is noted at the top of the page.

Not yet

How much more readily a short product amplifies than a long one is not modelled beyond the order the products are listed in, and a mismatched primer's first-cycle temperature leaves out what the mismatched stretch still contributes. Gibson does not model the chew-back itself, only the length rules above. Golden Gate's overhang warnings follow design rules; measured fidelity needs a table you import. In-Fusion and NEBuilder differ here only in how much homology they ask for; their exonucleases are not modelled separately. Overlap PCR does not model how efficiently the first-round products anneal to each other, a hairpin inside an overlap, or a fragment's own secondary structure. Gateway reads att sites from a file's annotation rather than finding them by sequence, and runs one pair at a time, so a multisite LR takes several passes.