Gibson Assembly

Give the tool a vector and one or more inserts. It finds the terminal homology between them, works out the order they can join in, and builds the assembled product.

What it doesCopy Anchor Link

Gibson assembly joins DNA fragments that share identical sequence at their ends. In the tube, an exonuclease chews back one strand to expose those ends, the matching single strands anneal, and a polymerase and ligase close the gaps. There are no restriction sites and no scar: the shared sequence appears once in the product.

This tool simulates that. You give it fragments; it searches every end against every other end for a shared run of bases within your size window, treats each match as a possible join, and enumerates the constructs that can be built from the fragments you supplied. A construct is only reported if the path uses the fragments consistently, so a fragment that cannot reach the others is an error with a reason rather than a silently missing product.

The shared sequence is counted once. Two fragments of 8355 bp and 2283 bp sharing 40 bp at each end give a circular product of 8355 + 2283 - 40 - 40 = 10558 bp, not 10638.

When you'd use thisCopy Anchor Link

Used in: Clone an insert into a vector, and prove it worked

You have a backbone and one or more inserts, and you want the joins to leave no scar — no restriction site, no extra bases at the junction. That is the case Gibson exists for, and it is why it is the default choice for putting a coding sequence into an expression vector, for stitching several parts into one construct in a single reaction, and for any design where a leftover six-base site would sit inside a fusion protein.

The route through the workbench, and the tools either side of it:

1. Get your fragments. A part you already have opens as a file. A part you have to amplify comes from Primer Designer → PCR Simulation, whose product lands here as a fragment without an export step. A backbone that is still a closed plasmid is opened with this panel's own Linearize control, which is Restriction Digest inline.

2. If the ends do not already overlap, design the primers that make them overlap. This is the ordinary case: two molecules that have never met share nothing at their ends, and Gibson joins molecules by their ends. The Primers tab designs a Tm-matched pair per fragment in the order you listed them, each carrying a 5′ tail copied from its neighbour, so the PCR product of one fragment ends in the first bases of the next. Order those oligos, run the PCRs, and it is the products that go into the assembly reaction, not the templates you started from.

   The panel models that last step rather than leaving it implied: Assemble these amplicons runs the assembly on the PCR products the designed primers make, and says their lengths before it does. Your fragment rows are left as they are, because the amplicon is a different molecule from the template and the list should keep saying what you actually have.

   The construct is the fragments fused, with nothing gained and nothing lost — the homology arms are copies of the neighbouring fragment's own terminal bases, not extra sequence, so a 4,365 bp backbone and a 2,283 bp insert give 6,648 bp however long an overlap you design. That holds for fragments that only abut. Fragments that already overlap need no tails, and tailing them anyway copies the shared bases a second time: the three-arc pBR322 starter assembles to 4,361 bp from its rows and to 4,481 bp from the amplicons, a repeat at each of the three junctions. The sentence under the button says so whenever the rows already overlap.

3. Assemble here. Confirm the homology the engine found is the homology you designed — it is painted on the sequence map in green, so a junction too short to anneal is visible rather than merely tabulated.

4. Check the product. Restriction Digest plus the gel bench predicts the diagnostic digest you will actually run; Sequencing Verification grades the Sanger read of the finished clone against the sequence this tool predicted.

Step 4 is the one worth insisting on: this tool tells you what should come out of the tube, and it is only worth having if you later compare it against what did.

Reach for something else when: your design uses Type IIS overhangs and a one-pot digest-ligation — that is Golden Gate; your parts carry att sites — that is Recombination Cloning; you are cutting and re-joining with enzymes and sticky ends — that is Ligation.

Worked end to end: Clone an insert into a vector, and prove it worked.

What this computesCopy Anchor Link

Every number and verdict this tool reports, named in the words you would search for.

Assembly. Terminal homology between fragment ends (the shared run of identical sequence); the assembly path — which fragments join, in which order, and in which orientation, with a marker on any fragment used reverse-complemented; the assembled sequence and its length; product topology, circular or linear; the count of distinct constructs the fragment set permits.

Per junction. The overlap sequence, its length in base pairs, and its GC fraction; its position on the finished product; a flag on the junction that closes a circle. Two melting temperatures, each named rather than blended: the nearest-neighbour Tm (SantaLucia, salt-corrected — the one to compare against an annealing temperature) and the gate value, the linear 2 °C/4 °C sum the assembly's own minimum- and maximum-Tm filters are applied to. They diverge by tens of degrees on a long overlap, and the section above says which to read when.

Feature transfer. The annotations carried from each parent fragment onto the product, cropped at the junctions; the count of annotations that could not be carried because they were only partly inside the fragment or spanned the origin; part-provenance bands saying which stretch came from which input. Every input annotation is accounted for, matched to the product by type and bases on either strand: carried, present on both sides of a junction and so kept once (a homology arm is a copy of its neighbour's end, so an annotation inside it arrives twice), or cut by the junction crop and named. On the two-arc pBR322 starter that reads 47 carried of the 51 on the fragments, 2 kept once, 2 cut.

Primer design. Per fragment, a Tm-matched primer pair carrying a 5′ homology tail: the full oligo, its tail and its annealing footprint shown apart, its length, its footprint melting temperature, its GC fraction, and the amplicon the pair produces — its length, and the product sequence itself, which is the molecule that goes into the assembly reaction and can be assembled here directly. Both halves write out: one FASTA of the oligos to order, and one of the products they make, whose headers carry each amplicon's length, the length of its 5′ homology arm (so it is visible that the fragment's own bases do not start at base 1) and the overlap it was designed at. The buffer the target melting temperature is quoted in — salt, magnesium, dNTP and oligo concentrations, the salt-correction method and any DMSO or formamide — is shown and adjustable with it, because a melting temperature with no stated conditions is not a temperature.

Cost. Per oligo, the synthesis product it can be made at, the published list price per base for that product, and the price for its length; the total for the set, and how many oligos that total covers. Reported with the supplier, the product, and the date the prices were read.

Diagnostics and refusals. Whether each fragment can take part and why not if it cannot; the structured failure modes — no path through the fragments, unused fragments, a dead end, a fragment forking into two possible partners — each naming the fragments involved; the fragment and connection diagrams behind them; and an outcome tally of valid, cancelled and errored constructs.

A reading of the run in words, built from the result rather than chosen from a list of sentences: whether this is one construct, several arrangements of the same parts, or none — and when none, which pair of ends failed to join and which of the four reasons it was (they share nothing in either orientation · the arm is shorter than your minimum · the arm is at or past your maximum · the arm passes on length but falls outside the melting-temperature window).

Both engines are checked against the published libraries themselves: outputs captured by running those libraries and asserted byte for byte, with the source clones kept on disk so the vectors stay regenerable.

Uncertainty, stated honestly. The junction Tm values are model predictions, not measurements, and the gate value is deliberately not a physical temperature. The cost is a list price from one supplier on one day. Neither is a claim about what will happen at the bench.

Where it livesCopy Anchor Link

Tools → Gibson Assembly opens it in the right rail. It is also on the editor toolbar, in the canvas right-click menu, and in the command palette.

It is part of the editor, not a calculator beside it:

• Opening the panel adds the open project's sequences as fragments automatically, so a PCR product built by another tool is already there.
• Add from the current selection, so you can take a region off the canvas rather than copy-pasting bases.
• Detected homology is painted onto the map in green while the panel is open, so a junction that is too short to anneal is visible on the sequence rather than only stated in a table.

Inputs and outputsCopy Anchor Link

Fragments come from five places: the open sequence, the current canvas selection, an imported file, a public sequence database, or pasted bases. Imports go through the app's bio-parsers, so GenBank, FASTA, FASTQ and the editor's own JSON all work.

Fetch from database searches NCBI Nucleotide, NCBI Protein, ENA, UniProtKB and EBI Dbfetch by accession, by keyword, or by organism, and drops the record straight into the fragment list — which is usually the shortest route to a backbone, since most cloning vectors have an accession (pUC19 is L09137, pBR322 is J01749). You can fetch a sub-region rather than the whole record by giving start and end coordinates and a strand, so a 3 kb arm of a large genome arrives as a 3 kb fragment.

A record that arrives circular is kept, not refused — a closed plasmid is a normal thing to fetch and the next step is to open it with an enzyme, which the Linearize control on the fragment row does. A record that is protein is refused by name, because Gibson joins DNA ends; the search reaches protein databases, so this is easy to do by accident and the tool says which record it declined and why rather than assembling nothing.

The iGEM Registry and Addgene are searchable here too, by part name or accession, and a hit lands in the fragment list as a fragment with the registry's own sequence. Neither catalogue serves a browser directly — iGEM's API answers only its own site and Addgene's is issued per-account under a data licence — so both are read through a relay rather than from the page, which is why they behave slightly differently from the accession databases above. Addgene's sequence file has required an account since August 2026; when that is what you need, the tool says so and links the deposit page rather than returning an empty result.

Each fragment carries a topology (circular or linear) and an optional backbone flag. The backbone flag does two things: it names the product after that fragment, and it lets "keep vector origin" rotate the finished circle so the product starts where the vector did.

What it refuses, and what it says:

• Fewer than two fragments. Assembly needs something to join.
• A circular backbone. A circular fragment has no ends, so it has no terminal homology to find. The run is refused by name and the fragment row turns red — open the plasmid with the row's Linearize control, or mark it linear if it already is. The refusal matters: a closed plasmid treated as linear would assemble as though its sequence happened to begin and end at the homologies, which is a wrong product from an input that looked accepted.
• No path through the fragments, unused fragments, a dead end, or a fragment that forks into two possible partners. Each of these is reported as a structured error naming the fragments involved and what to change, not as an empty result.

Outputs: the assembled sequence, the fragment order around the construct, a junction table, and the features carried over from the parent fragments.

DemoCopy Anchor Link

Silent, 21 seconds, recorded on the Gibson test sample project. The vector and the insert arrive staged, and the panel has already assembled them: one circular product of 10,558 bp from two 40 bp junctions, at 67.9 °C and 72.7 °C nearest-neighbour Tm. The recording steps through the fragment list and the result, then opens the product in a new tab, where its map shows both homology arms. The starter also opens the Primer Designer, which is the panel that slides in at the end. The worked example below is the same run, number for number.

Worked exampleCopy Anchor Link

The Gibson test sample project in the lobby, which is two real files from the pydna and sgffp test corpora:

Flag the vector as the backbone, leave the homology window at 20 to 80 bp, topology circular, keep vector origin on. Running it gives:

errors    []
warnings  []

product   gibson_test_vector   10558 bp   circular
order     gibson_test_vector -> gibson_test_insert

junction 1   40 bp   Tm (NN) 67.9 °C   Gate 106 °C   GC 32.5%   at 8235..8274
             ATAGTCGCTTTGTTAAATCAATGCAAACAGTAATGATGGA
junction 2 ↺ 40 bp   Tm (NN) 72.7 °C   Gate 118 °C   GC 47.5%   at 10478..10517
             GGGGAGAAGAAGGCTTTTAATATGCTCGAGAGATCTGTCG

Four features land on the product: the two source fragments, each noted From <fragment>, and both junctions, annotated homology.

Two melting temperatures, and which one to useCopy Anchor Link

Each junction reports its overlap's Tm on two different scales, because they answer two different questions and they disagree by roughly 50 °C on a 40 bp arm.

The gate rule is only meaningful for oligos under about 14 bases; over a 40 bp homology arm it returns numbers above 100 °C, which no duplex does. It is shown anyway, and labelled, because it is the criterion the assembly actually applies when it accepts or rejects an overlap — hiding it would leave the Tm filter with no visible scale. Do not carry a Gate value into a protocol. Junction 2 is the one that closes the circle — marked ↺ in the table, and noted Closing junction (circularization) on the map.

Read the numbers as follows. 10558 is the arithmetic above, and is the check that both overlaps were consumed rather than duplicated — and both now appear in the table, which is what 8355 + 2283 − 40 − 40 says should be there. 40 bp is the homology the engine actually found, not the window you asked for. 32.5% GC is 13 G or C bases in 40. 106 °C is not a physical melting temperature; see Limitations.

ControlsCopy Anchor Link

Per fragment: name, topology (circular or linear), the backbone flag, order (drag by the grip handle, or the up and down buttons, which are the keyboard-reachable equivalent), remove, and two preparation controls:

• Linearize — open a molecule with restriction enzyme(s) and choose which piece to assemble. The picker shows every enzyme's site count on that fragment, and each resulting piece with its length, the enzyme that made each end, its end structure and how many features survived. Partial digest is a switch, and it matters: a complete digest cuts every site, so an enzyme with two sites in your backbone only ever gives you the two arcs. The whole plasmid opened once — usually the piece you want — exists only in the partial set, where it is listed and flagged.
• Flip — reverse-complement the fragment, features included, for a part whose homology sits on the other strand.

A prepared fragment carries a badge saying what was done to it, because it is no longer the file it came from.

Under each row: the terminal homology that fragment shares with its neighbours in the order you have them, so a missing overlap is visible before you run rather than as an empty result after.

Homology window

An arm that satisfies the window is reported at its true length: the end of one fragment and the start of the next only line up when the compared stretch is exactly the shared one, so a 40 bp arm reads 40 bp whether your minimum is 15 or 40. A run that produces nothing says which of these bounds refused the junction, and what to change it to.

Assembly

Primer design

A longer arm buys specificity exactly where a bigger mix needs it, which is why the guidance rises with fragment count rather than being one number. It is guidance for a particular vendor's chemistry, and the tool says whose, because a kit's recommended arm is not a law of the reaction.

What the oligos cost

Under the designed primer table the tool prices the set. Each oligo is shown with the synthesis product it can be made at, that product's published price per base, and the price for its own length; then the total for the set.

Synthesis scale is yours to choose, because it is an experimental decision rather than a detail: the same 40-mer costs several times more at a 1 µmole scale than at 25 nmole, and the only question that settles it is how much oligo the experiment needs. The default prices each primer at the cheapest product whose published length range covers it, and says on every row which product that was — so a set that straddles a length boundary shows two scales, not one blended figure.

An oligo longer than any listed product will synthesise gets no price at all. It is named, left out of the total, and the total says how many of the set it covers. That case is common in practice: Gibson tails make long primers, and a 40 bp overlap on a 30-base footprint is already a 70-mer.

The figures are one supplier's published list price, read on a stated date, and the readout says so beside them. They cover synthesis only: not purification beyond a product's standard grade, not modifications, plates, shipping or tax, and not whatever your institution has negotiated. Treat them as the order-of-magnitude answer to is this design worth building — which is the question they are there for — and not as a quote.

When more than one construct is possible, every one of them is listed and you pick. More than one product is information, not a failure: it usually means two fragments share compatible ends.

Algorithms you can chooseCopy Anchor Link

This tool offers one assembly algorithm, and the section is kept rather than struck because the absence is the point. Terminal-homology assembly is not a family of competing methods the way melting temperature or alignment scoring is: there is one question — do these two ends share a run of identical bases long enough to anneal — and DnaCauldron's HomologyChecker answers it exactly. A second "method" here would be a second opinion about string equality.

What is selectable is the window the search runs in, and those controls change the answer:

The genuinely different questions live in neighbouring tools, and choosing between them is the real choice: Golden Gate matches four-base Type IIS overhangs rather than terminal identity; Ligation matches enzyme-cut ends; Recombination Cloning matches att site chemistry. Each answers "can these ends join" under a different physical mechanism.

Bring your own: gibsonAssemble from @ports/gibson is pure and synchronous, so the same engine the panel runs is callable directly — see API. Nothing in the panel is doing arithmetic the module does not.

The scienceCopy Anchor Link

The engine is a faithful port of DnaCauldron's homologous assembly. Terminal homology detection is its HomologyChecker: for each ordered pair it compares the end of one fragment against the start of the next, walking match lengths from the minimum upward and returning the first size that satisfies the size and Tm windows. Fragment path enumeration comes from the same library's assembly graph; the underlying sequence handling shares the pydna port that the rest of the cloning tools use.

Both are checked against the published libraries themselves: the outputs are captured by running those libraries and asserted byte for byte, and the source clones are kept on disk so the vectors stay regenerable.

Primer design for fragments that do not already share ends is designGibsonPrimers, faithful to pydna's assembly_fragments: it extends each primer with a tail copied from the neighbouring fragment, so the PCR products come out of the reaction already overlapping.

Shared with other tools: Melting temperature compares how every tool that does this chooses its method.

LimitationsCopy Anchor Link

• This panel assembles one construct at a time. Several assemblies that depend on each other — each level's products feeding the next — are a plan, not a run: Assembly Plan schedules them and simulates them in order, with Gibson available as the chemistry for any step.

• No part-registry import. Fragments come from your projects, files, the editor or the clipboard — not from iGEM or Addgene. Neither registry publishes a documented interface a browser is allowed to call directly, so there is nothing to read from without a server in between.

• The synthesis cost is one supplier's list price, not a quote. This limitation used to read "no synthesis-cost estimate", on the premise that no vendor publishes machine-readable oligo pricing. That premise was tested again and is false: published per-base prices are readable, and the designed set is priced against them. What is still limited is worth knowing before you budget from the figure. It is one supplier of many, at the prices published on a stated date. It covers synthesis only — not purification beyond each product's standard grade, not modifications, not plates, not shipping, not tax, and not whatever your institution has negotiated. It is a sum of list prices with no plate rate, pooling fee or volume break, each of which exists in the catalogue and none of which is in the published table. And an oligo longer than any listed product will make gets no price at all rather than a guess: it is named and left out of the total, which is a real case, because Gibson tails make long primers.

• Flipping a fragment is a convenience, not a requirement. DnaCauldron's assembly graph carries a reverse-complemented copy of every fragment and searches both orientations, so a fragment supplied the wrong way round still assembles into the same construct — the path line marks the ones it flipped with ↔. Use Flip when you want the fragment stored the other way (it changes the exported sequence and the primers designed from it), not to make an assembly work. What you cannot do is force an orientation the homology does not support: that is a property of your ends, not a missing control. The Gibson (flipped part) sample project demonstrates it: two overlapping arcs of pBR322 with the second supplied on the opposite strand, which still close into the same 4,361 bp plasmid carrying the same 47 annotations, with the flipped arc marked ↔.

• Both junctions of a circular product are reported, including the one that closes the ring. Worth stating because the reference implementation annotates only n − 1 of them: the join that closes the circle is written into the sequence it then trims away, so a two-fragment assembly leaves one homology annotation on the product. The closing junction is measured back out and marked ↺ in the table, so the count you read is the number of joins you have to get right.

Compared with other toolsCopy Anchor Link

Every row is a claim from a first-party vendor source, carrying the date it was read (2026-08-08). Nothing here describes another product from memory, and nothing calls their science wrong — we have not run it.

What they do that we do not, plainly. SnapGene simulates several assembly chemistries we have no surface for at all — TOPO, TA/GC, In-Fusion and NEBuilder HiFi are named on its feature list and are absent here. It also ships an automatic graphical history of every cloning step, which is a stronger version of what our provenance record does. Geneious goes much further out of scope again: de novo genome assembly, read mapping, microsatellite analysis, RAxML/PAUP* phylogenetics and a third-party plugin ecosystem, none of which exist here.

What is genuinely different rather than better. The simulation half being free and the data never leaving the machine are architecture, not feature count — and a desktop application keeps your data local too, so the honest contrast with SnapGene is install and licence versus open a tab, not privacy. Against Benchling the contrast is real and the other way round: it is a multi-user cloud platform with a registry and inventory, and we have no collaboration story at all.

Not compared: price. No vendor publishes a single figure, and every number the sweep found came from third-party sites that disagreed with each other. A price row here would be the least reliable claim on the page.

ExportCopy Anchor Link

• Open as a new project. The default, and non-destructive: the source sequences are untouched and the product becomes its own project. This is also the only path that writes a provenance record, so use it if the run needs to be traceable.
• Download GenBank. The product with its carried features, through the app's GenBank writer.
• Everything downstream then applies. The product is an ordinary sequence, so it can go straight into a digest, a PCR simulation, or another assembly.

APICopy Anchor Link

import { gibsonAssemble } from '@ports/gibson';

const result = gibsonAssemble(
  [
    { name: 'vector', sequence: vectorBases, isBackbone: true },
    { name: 'insert', sequence: insertBases },
  ],
  { minHomologyBp: 20, maxHomologyBp: 80, topology: 'circular', preserveBackboneOrigin: true },
);

result.products[0].length;        // 10558
result.products[0].junctions;     // [{ index, sequence, length, tm, tmNN, gc, start, end }]
                                  // tm = the gate scale · tmNN = nearest-neighbour
result.errors;                    // structured, each with a message and a suggestion

Pure and synchronous, no DOM. It throws only on genuinely invalid input, such as an empty fragment list; everything else comes back as a structured entry in errors or warnings. Feature coordinates are 0-based and inclusive, matching the editor, and an origin-spanning feature on a circular product has end < start.

designGibsonPrimers from the same module designs the overlapping-PCR primers for fragments that do not already share ends.

AutomationCopy Anchor Link

• Workflow DAG: the node is gibson_assemble, category build. Its fragments port takes record inputs, so upstream nodes wire straight into it, and include_subject puts the node's own subject in as the first fragment, on by default. It takes every setting the panel takes, opening on the same values: the homology window min_homology_bp and max_homology_bp, the optional gate-scale bounds min_tm and max_tm, topology, preserve_backbone_origin, expect_no_unused_parts and max_constructs. Outputs are record (the first product), products (all of them), productCount (greater than 1 means the assembly was ambiguous) and warnings.
• Designing the overlaps is its own node, design_gibson_primers, category design. Give it fragments in assembly order and it returns a Tm-matched primer pair per fragment, each carrying the 5′ tail cut from its neighbour's real 3′ end — the step that turns a planned assembly into oligos you can order, for fragments that do not already share ends. Its parameters are the five the panel offers, with the same defaults: target_tm (58 °C), overlap (30 bp), circular, min_footprint and synthesis_scale, the last deciding which catalogue product the set is priced at. A target melting temperature is only a temperature in a stated buffer, so it takes a sixth, conditions — salt, magnesium, dNTPs, oligo concentration and the salt-correction method. Leave it alone and it is filled from the reaction conditions you set for the app, exactly as the panel's own designer uses them; with none set, both fall back to the same published Taq defaults. The buffer it designed in comes back on the run as conditions, because a primer set quoted at 58 °C in an unnamed mix is not reproducible. It reads, so it needs no approval. Its outputs are primers, amplicons — the PCR products those primers make, as records carrying each fragment's annotations at their shifted positions, which is what the assembly node should be given rather than the untailed fragments — the whole cost breakdown, costTotal for wiring a budget onward, primerCount, the overlap and circular it used, and the conditions it measured the melting temperatures in.
• The copilot can call either tool by the same name, and the primer design comes back as the same two tables the panel draws — the pairs with their tails, footprints, lengths and melting temperatures, and under them the priced oligos with the supplier and date. It is the design, not a description of one. What it does not carry is the synthesis-scale control: a transcript shows the run that happened at the scale it happened at, and pricing the same set differently is another question you can ask. gibson_assemble is marked write: true, so it goes through the approval gate before it runs; see The copilot.
• Several assemblies at once, including ones that consume each other's products, are run from Assembly Plan rather than from here.

ProvenanceCopy Anchor Link

Opening the product as a new project writes a provenance record: which fragments went in, and what came out. That record is what makes a product traceable back to its parts rather than an anonymous sequence.

Two limits worth knowing. Provenance nests by product name, so it does not yet carry an exact link back to the source projects. And the transferred features keep their From <fragment> note but not upstream DnaCauldron's per-source colouring, so on the map they look like ordinary features.

The GenBank download carries the features and the notes, but not the provenance record.

ScreenshotsCopy Anchor Link

Real runs on the starter projects, not mock-ups.

Two overlapping arcs of pBR322 re-closed into the 4,361 bp plasmid. The ring draws what the assembly made: the two parts and the two junctions, each named, with the 47 annotations carried from the parts one switch away (the product's own tab draws them at full size). The junction table carries both scales side by side, Tm (NN) 83.5 °C beside a muted Gate 134 °C, the closing junction is marked ↺, and the line under it accounts for every annotation on the fragments: 47 carried of 51, 2 that sat on both sides of a junction kept once, and 2 cut by a junction crop, named.

The same two arcs, with the maximum overlap set to 40 — the exact length of the arms. Nothing assembles, and the two red callouts underneath say only wrong number of constructs and some parts are unused, neither of which tells you what to change. The line above them does: pBR322_arc_A → pBR322_arc_B share 40 bp and your overlap window tops out at 40 bp. The upper bound is exclusive, so raise the maximum to 41 bp.

The same table on a run where one part was supplied on the opposite strand: the ↔ after the fragment name is the engine telling you it used that part reverse-complemented. Note the two Tm columns again — 83.5 °C against 134 °C for the same 40 bp overlap. The second number is the filter's scale, not a temperature; see Two melting temperatures, and which one to use above.

Preparing a closed plasmid for assembly. Every enzyme in the picker carries its live cut count on this molecule — BamHI (1 cut) here — so you choose by what the enzyme does to the plasmid in front of you rather than by name. The piece it produces is described completely before you accept it: 4,365 bp · BamHI → BamHI · 5' gatc / 5' gatc · 47 features. The 4,365 against a 4,361 bp plasmid is not an error — opening a circle at a sticky site duplicates the 4-base overhang onto both ends.

Two real parts that share no terminal homology. Rather than an empty result table, the run reports Wrong number of constructs, names both unused parts, states that no fragment in the mix can join another, and offers the errors as a spreadsheet. A reaction that cannot happen should say so.

RelatedCopy Anchor Link

Feeds it: PCR Simulation (products go straight in as fragments), Restriction Digest (linearize a circular backbone), Primer Designer.

Follows it: Restriction Digest and the gel bench, to check the product; Sanger verification, to confirm the built construct against this predicted sequence.

Alternatives to it: Golden Gate Assembly, when the design uses type IIS overhangs rather than terminal homology; Recombination Cloning, for Gateway-style att sites.