Recombination Cloning

Run the BP and LR reactions on real sequences and see the entry and expression clones they produce.

What it doesCopy Anchor Link

Site-specific recombination joins two molecules — or rearranges one — at short sequences a recombinase enzyme recognises, without cutting anywhere else and without needing compatible restriction ends. Four chemistries are here, and they all answer the same question: given these molecules, what does the enzyme actually make?

• Gateway (BP and LR). BP joins an attB-flanked fragment to an attP donor and gives the entry clone; LR joins that entry clone's attL sites to a destination vector's attR sites and gives the expression clone. Both reactions are reversible in principle, which is why the sites change name as they recombine.
• Cre-lox. Cre recombines two lox sites. Two molecules with one site each integrate; one molecule with two sites excises the DNA between them if they point the same way, and inverts it if they oppose. The mutant pair lox66 × lox71 is here too — it integrates and then cannot go back.
• Any other recombinase. Give both half-sites and the reaction runs. Case is meaningful in the half-site: the lower-case middle is the spacer, and the spacer must match for the strands to resolve.
• Homologous recombination, including CRISPR knock-in — homologous recombination that keeps only the outcome where every guide's cut falls inside the region the repair template restores.

Every product is a real molecule you can carry on with, not a picture of one: its length, topology and the sites it now carries are read off the product itself.

When you’d use thisCopy Anchor Link

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

Moving one insert through a Gateway collection. You have a PCR product with attB tails and you want it expressed. The route is BP with a donor (pDONR-type) → the entry clone → LR with a destination vector → the expression clone. Both steps happen here, one after the other: the entry clone the first reaction produces becomes the second reaction's input with one click, so you never export it and re-import it to continue.

Removing a marker after selection. A cassette flanked by lox sites goes in by integration; the excision reaction later tells you exactly what comes out and what is left behind, including whether the geometry gives you an excision or an inversion.

Knocking a payload into a locus. Design the guide, check where it cuts, then run the knock-in with a repair template carrying homology arms. If a guide also cuts outside the repaired region, that outcome is dropped and counted — because a guide that cuts twice is a fact about your guide, not a detail to hide.

What this computesCopy Anchor Link

Five reaction systems, each returning real molecules rather than a diagram of one. Everything below is read off the product itself.

Per input molecule, before you run

• The recognition-site inventory — every attB / attP / attL / attR site (Gateway) and every loxP / lox66 / lox71 site (Cre-lox) found on the molecule, each with its 0-based, end- inclusive start and end and its orientation, so a site pointing the wrong way is visible before it costs you a reaction. An empty inventory is the answer to why did I get nothing.
• Guide cut positions (knock-in) — the blunt cut position on the forward strand for each guide, from the same cas9Cutsites search the reaction itself uses, so the preview and the run can never disagree; plus a non-canonical spacer length flag, raised when a protospacer is not 20 nt, because the ported cut geometry measures its offset from SpCas9's 20-nt assumption and a shorter or longer spacer places the cut wrongly. Reported, never rejected: upstream does not validate it either.

Per product

• Length in bp and topology (circular or linear)
• Every annotation the parent molecules contributed, moved to where the reaction put it. A Gateway expression clone arrives carrying its destination vector's resistance marker, promoters, operator, origin and tags alongside the insert's own coding sequence; a Cre-lox excision hands each product the annotations that fell on its side of the cut; a knock-in carries the repair template's arms and payload, shifted by however far the crossover moved them. Coordinates are 0-based and end-inclusive, the same ones the map uses, and a feature that crosses the origin of a circular product is one feature whose start is greater than its end, not two halves
• What did NOT carry, and why it could not. An annotation the reaction cuts through is dropped rather than trimmed or stretched: half a promoter is not a promoter, and a coding sequence the insert lands inside is genuinely disrupted by the construct you just designed. On the yeast ADH1 knock-in the target's own coding sequence disappears for exactly this reason — the guide cuts inside it — which is the point of that experiment, not a defect in the record
• The recombination sites on the product, detected on the finished molecule the same way an input's are, so which site met which is answerable after the reaction and not only before it
• Where each product joined its inputs (homologous recombination and knock-in, which have no site inventory): the homology arms on every input, 0-based and end-inclusive, drawn on the reaction figure in place of sites. On the ADH1 knock-in the target's arms sit at 470–768 and 769–1069, either side of the guide's cut
• Whether two products are one exchange or alternatives. Two circular products whose lengths add up to what went in (a Gateway LR's expression clone and its by-product) are read as forming together, not as a choice between them
• The provenance class the reaction assigned — GatewaySource, CreLoxRecombinationSource and the rest — which is what names the operation in the history graph rather than a label chosen here
• Product count. More than one product is not an error: it means the inputs admit more than one outcome, which is the thing to look at before ordering anything

Per run

• The reaction that ran, named — Gateway BP reaction, Cre-lox excision/inversion, Recombinase assembly, Homologous recombination integration, CRISPR knock-in — because the geometry decides which of integration, excision and inversion you got, and the name states which
• The discarded-product count (knock-in only): outcomes dropped because a guide also cuts outside the region the repair template restores. A non-zero count is a finding about guide specificity, not a warning to swallow
• The refusal and its reason, before the run rather than after — inputs are not compatible for a BP reaction, the genome must be linear for integration, no cut in this molecule for guide X, a named non-DNA character, an empty molecule, or this system needs at least two molecules (which is per system: Cre-lox and homologous recombination have a legitimate single-molecule form, excision or inversion against itself)

What this does not compute: recombination efficiency. Nothing here estimates how much product you will get in a tube — only which molecules the geometry admits.

Where it livesCopy Anchor Link

Open it from Tools → Recombination Cloning, from the canvas toolbar, from the right-click menu on a sequence, or by searching for it in the command palette. It works on whatever you have open: add the whole sequence, or select a region first and add just that.

The panel and the map stay in step. Every recognition site found on a molecule appears as a chip you can click to select that range on the map, and in a knock-in every guide's cut position is a chip that selects that base — so a coordinate you read in the panel is always one click from the sequence it refers to.

Inputs and outputsCopy Anchor Link

In. Two or more DNA molecules, each taken from an open sequence, from the current selection, or pasted. Topology matters and is yours to set per molecule: an integration needs a linear genome and refuses a circular one, saying so before you run rather than after. Protein sequence is refused by name.

Before the run, each molecule shows what it brings to the reaction — the att or lox sites found on it, with positions. An empty inventory is the answer to "why did I get nothing", and you see it before you press the button, not after.

Out. Each product carries its length, its topology, the recombination sites now on it, and the kind of reaction that made it. From there you can carry it into the next reaction as an input, or save it as a new project with its lineage recorded, so a later reader can see how it was built.

When a reaction is impossible it says why — "inputs are not compatible for a BP reaction", "the genome must be linear for integration", "no cut in this molecule for guide X" — and the run is blocked with the reason next to the button rather than producing an empty table.

DemoCopy Anchor Link

Not recorded yet. A screencast of a real run belongs here and does not exist. Nothing is staged in the meantime: the worked example above is a real run on a bundled sample, and the frames below are captures of it.

Worked exampleCopy Anchor Link

Open the Recombination cloning (Gateway) sample. It contains a real attB-flanked fragment, the donor pDONR221, and the destination vector pET-53-DEST.

1. With the fragment open, add it; switch to pDONR221 and add that. Both molecules list their att sites immediately.
2. Choose BP and run → one circular product, 4,790 bp: the entry clone.
3. Press Use as molecule on that product. It becomes an input, marked as a product, carrying the attL sites the next reaction needs. Remove the two starting molecules.
4. Add pET-53-DEST, choose LR, run → 7,423 bp, the expression clone, alongside the 4,199 bp by-product that carries the vector's original stuffer.

Those four numbers are checked automatically against pydna, the reference implementation, on these exact files — matched by sequence checksum, not merely by length.

ControlsCopy Anchor Link

• Reaction — BP (attB × attP → entry clone) or LR (attL × attR → expression clone).
• Both sites must recombine. On by default. With it off you also get the single-site intermediates — two plasmids fused into one — which are real reaction intermediates but not what a bench scientist is usually looking for.
• Greedy att consensus — more permissive core matching, which finds sites that differ slightly from the consensus. Use it when a site you know is there is not being found.
• Circular products only — drop linear outcomes.
• Topology per molecule — linear or circular, stated for every input rather than guessed.
• Recombinase half-sites and their names. Both half-sites are yours to type, and naming them (attB, attP) labels the sites carried onto every product, so a record read a month later says attB instead of site 1. Use reverse recombinase swaps them for the pair that undoes the reaction, naming the result by the Gateway convention: attB × attP hands back attR/attL.
• Mode — Integration: genome plus donors, Excision or inversion: genome alone, or Assembly: all fragments equal. It decides which molecule is the host and which are the donors.
• Half-site 1 and Half-site 2, with Site 1 name and Site 2 name — the recombinase sites and the names carried onto every product.
• Min homology — 40 bp by default.
• Minimum homology arm — the shortest stretch of identity that counts as an arm, for homologous recombination and for the knock-in.
• Guide RNAs (knock-in) — pulled from the guide designer or pasted as a protospacer. Each guide shows where it cuts in the target before you run. A spacer that is not the canonical 20 nt is flagged rather than rejected, because the cut position it implies is then an assumption.
• Dropped products — when a guide cuts outside the repaired region the outcome is discarded and the count is shown, since that is a finding about guide specificity.

The reaction, drawnCopy Anchor Link

Above the product cards the run draws itself: one rail per input molecule, then the products, every rail to the same scale so a product that lost a cassette is visibly shorter than what went into it. Each rail carries its own recombination sites as marks, and each mark points the way its site reads — which is the part worth checking before you order anything, because an inverted pair of lox sites inverts the segment between them where a direct pair excises it.

Sites that sit on the same bases merge into one mark rather than drawing four hairlines on top of each other: a Gateway donor carries attL1, attP1, attB1 and attR1 over one core, and the merged block's tooltip names all of them.

A site that crosses the origin of a circular product — which is common, because a recombination joins the ends there — is drawn as a mark at each end of the rail, both naming the one site. The rail is a straight line and the molecule is a circle, so the two pieces are the same site seen across the join, not two sites.

Reading it takes seconds and catches the two mistakes that cost a week: a molecule that carries only one usable site (so the reaction can only fuse, not swap), and a product whose sites came out in an orientation you did not intend.

Algorithms you can chooseCopy Anchor Link

Four independent reaction systems, not four settings of one, because the question each answers is different. There is no "best" here to default to: the chemistry on your bench picks the tab.

Conservative att matching is the default because a greedy core also matches sites that differ from the consensus, which finds real but unintended pairings; turn it on when a site you know is there is not being found, and read the extra products it produces as candidates rather than answers.

"Both sites must recombine" is on by default, which drops the single-site intermediates — two plasmids fused into one. They are real reaction intermediates and switching it off shows them; they are not what a bench scientist is usually asking for.

Bring your own path. Every reaction is a plain function over strings in @ports/recombination — runGatewayReaction, runCreLoxReaction, runRecombinaseReaction, runHomologousRecombination, runCrisprIntegration — callable from the Python and JavaScript consoles with no editor state, and inspectRecombinationSites / inspectGuideCuts answer the before you run half on their own.

The scienceCopy Anchor Link

Site-specific recombination cuts and rejoins at a short sequence a recombinase recognises, so what you get is decided by two things only: which sites are present, and which way each one points. A pair in the same orientation on one molecule excises the DNA between them; a pair in opposite orientations inverts it; sites on two molecules integrate them. Gateway's att sites change name as they recombine — attB × attP gives attL and attR — which is why the reaction is directional in practice even though it is reversible in principle, and why the site names on a product are worth reading.

Case is load-bearing in a recombinase half-site. A site is written [A-Z]+[a-z]+[A-Z]+: the lower-case middle is the overlap the strands cross over in, and it must match on both molecules for the reaction to resolve. The engine strips whitespace but deliberately preserves case, because upper-casing a site would destroy that information and gain nothing.

Both halves are ports of pydna 5.5.16, and they sit either side of pydna's own module boundary: site detection is gateway.py, cre_lox.py, recombinase.py and crispr.py; the reactions themselves are assembly2.py, whose gateway_assembly and friends this panel composes with the detected sites. Origin-spanning sites on a circular molecule are found, because the site search runs through the same circular-aware iterator the rest of the engine uses.

The knock-in is homologous recombination with a gate: pydna's crispr_integration keeps only those products whose repair region contains every guide's cut, and discards the rest. The discarded ones are counted rather than hidden, because a guide that also cuts elsewhere is a fact about the guide.

How the reactions are checked. They are compared byte-for-byte against pydna 5.5.16 — the Gateway chain over data/samples/Gateway/*.gb, the loxP and recombinase site dictionaries, the Cas9 cut positions, and the OpenCloning source model — 91 assertions across 9 files, re-run 2026-08-28 (cd packages/ports && bun run test recombination → 91 passed). The generators (gen_gateway_chain_golden.py and the four beside it) are kept next to their vectors, so every number here is regenerable against the library rather than trusted.

LimitationsCopy Anchor Link

• Geometry, not efficiency. This says which molecules the sites admit. It does not estimate how much product a tube gives, and no yield, no reaction time and no enzyme-unit figure appears anywhere — those are bench variables the sequence cannot carry.
• A knock-in cut position assumes a 20-nt SpCas9 spacer. The offset comes from the ported fst5, so a shorter or longer protospacer places the cut wrongly. It is flagged, not refused, matching upstream, which does not validate it either — but treat the position as an assumption when the flag is showing.
• Only SpCas9 geometry. Other nucleases (Cas12a's staggered cut, its 5′ PAM) are not modelled, so their cut positions cannot be previewed here.
• The att and lox dictionaries are consensus patterns, not a catalogue of every commercial variant. A vendor's proprietary site that departs from the consensus may need greedy matching to be found at all, and greedy matching finds unintended pairings too.
• Homologous recombination needs the arms to be exact. Identity is what is searched for, at the minimum arm length you set; a mismatched or degenerate arm is not scored as partial homology, it is simply not an arm.
• A molecule you paste in carries no annotations, and so its product carries none of them. The panel says how many each molecule brings before you run. Add the molecule from an open sequence or from a selection on one to bring its biology into the reaction; pasted bases genuinely have none to bring, and inventing some would be worse than showing the zero.
• An annotation that only partly falls inside a selection is not carried. It is counted and reported instead, because 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.
• A product is a molecule, not a clone. Nothing here models the selection that makes a Gateway reaction work in practice — ccdB counter-selection, antibiotic markers — so a by-product that would never survive selection is still reported, and is still worth seeing.

Compared with other toolsCopy Anchor Link

Sources, first-party and dated: SnapGene's own feature list, "Cloning simulation covers Restriction Cloning, Gateway, Gibson Assembly, NEBuilder HiFi Assembly, In-Fusion, TA & GC Cloning, TOPO Cloning and Golden Gate" and "Provides guide-RNA design for CRISPR" (https://www.snapgene.com/features, retrieved 2026-08-08); Geneious Prime's, "Cloning simulation covering Golden Gate, Gateway, Gibson, Restriction and Parts cloning" and "CRISPR tools to find sites, design guide RNAs and analyse editing results" (https://www.geneious.com/features, retrieved 2026-08-08).

Read the blanks honestly. "Not listed" means the vendor's own feature page does not name it, not that the product cannot do it — neither vendor publishes an exhaustive list, and both are closed software nobody here can run to check. What they have that this does not: both are mature desktop products with a decade of cloning workflows around the reaction, and SnapGene simulates several chemistries (TOPO, In-Fusion, TA) that have no panel here at all.

ExportCopy Anchor Link

• Use as molecule. The product becomes an input to the next reaction in place, carrying the sites it now holds — which is how a Gateway BP and its LR are run one after the other without exporting and re-importing an entry clone.
• Open in new tab. The product joins the project you are in, opens beside its inputs, and records its lineage on its own tab, so the status bar names its parents only while that molecule is the one on screen.
• Save as new project. Non-destructive: every input molecule stays untouched and the product opens as its own project, with its features on the feature track and its construction history on OVE's own lineage track rather than buried among the biology. This is also the path that writes the provenance edge.
• Everything downstream then applies, because the product is an ordinary sequence: digest it, amplify it, run it on the virtual gel, or feed it to another assembly.
• Download GenBank. The product with its carried sites, written through the app's GenBank writer — the same one every other assembly panel uses, so a product from here and a product from Gibson are the same kind of file. It does not write a provenance record; save as a project if the run needs to be traceable.

APICopy Anchor Link

@ports/recombination — plain strings in, plain product objects out, no editor state:

import {
  runGatewayReaction, runCreLoxReaction, runRecombinaseReaction,
  runHomologousRecombination, runCrisprIntegration,
  inspectRecombinationSites, inspectGuideCuts, reverseRecombinase,
  CAS9_SPACER_LENGTH,
} from '@ports/recombination';

const { products, inputs, error } = runGatewayReaction({
  fragments: [
    { name: 'attB-insert', sequence: insertBases },
    { name: 'pDONR221', sequence: donorBases, circular: true },
  ],
  reaction: 'BP',       // or 'LR'
  greedy: false,        // permissive att core matching
  multiSiteOnly: true,  // drop the single-site intermediates
  circularOnly: true,
});

Every entry point returns the same shape: products (each with name, sequence, circular, length, features and the sourceType the reaction assigned), inputs (the per-molecule site inventory), and error — populated instead of throwing when the inputs cannot react, so a caller never has to distinguish "no products" from "did not run". runCrisprIntegration adds discarded. Feature coordinates are 0-based, end-inclusive, with a forward flag — the same convention the map uses, so a coordinate crosses the boundary unchanged.

AutomationCopy Anchor Link

• Workflow DAG: the node is recombine, category build, and it is a write node, so it passes the approval gate before running. Its fragments port takes record inputs so upstream nodes wire straight in, and include_subject (default on) adds the node's own subject as the first reactant. Parameters are system (gateway-BP, gateway-LR, cre-lox, recombinase, homologous, crispr-knock-in), greedy and multi_site_only (shown only for Gateway), circular_only, site1 and site2 (shown only for a bring-your-own recombinase), homology_bp (default 40, shown for the two homology systems) and guides (shown for the knock-in).
• Outputs: record (the first product, for downstream nodes), products, productCount, sites (the per-input site report) and discarded.
• The copilot calls the same tool by the same name, with the same parameters and the same defaults, and the same approval gate applies. See The copilot.
• Arity is per system, not one rule. Cre-lox and homologous recombination accept a single molecule, because a floxed construct acting on itself is the most common thing anyone asks Cre-lox for; the other systems refuse with a message naming the count they got.

ProvenanceCopy Anchor Link

Saving a product as a project records the edge, not just the file: the operation id (gatewayReaction, creLoxRecombination, recombinaseReaction, homologousRecombination, crisprIntegration), the names of every input molecule, and — where an input came from an open project rather than pasted bases — the exact project and file it came from. That is what makes the History panel show this expression clone came from that entry clone and that destination vector rather than a product whose name resembles another product.

On the product itself, construction history is written to OVE's lineage track rather than the feature track, so a full-length "from X" band never buries a promoter or a marker; both tracks switch on and off independently.

Replay. The reaction is a pure function of the input sequences and the options listed under Controls, so recording those reproduces the run exactly — there is no seed, no sampling and no service call anywhere in it.

Citing the method: the reactions are ports of pydna's assembly2 and its site-detection modules (pydna 5.5.16), validated against that library; cite pydna, and say which reaction and which options you ran.

ScreenshotsCopy Anchor Link

The panel as it opens.

Cre-lox, run on a real floxed plasmid (GenBank PQ181256.1, two loxP sites in the same orientation, so it excises rather than inverts). The molecule brings 15 annotations; the two products take 10 and 3 between them, each keeping the ones that fell on its side of the cut plus the loxP site left at the junction. The four that are missing are the four the enzyme cuts through.

The 7,423 bp expression clone from a BP then LR chain, saved as its own project. It carries 17 annotations: the destination vector's lacI, rop, ori, AmpR promoter, f1 ori, Strep-Tag II and T7 terminator, the insert's own coding sequence, and the att sites the reaction left behind. attB1 crosses the origin and is one feature, not two.

The gateway tab.

The homologous tab.

The recombinase tab.

The second half of a Gateway: LR on the carried-forward 4,790 bp entry clone gives the 7,423 bp expression clone and the 4,199 bp by-product, each with its topology and the sites it now carries.

Two guides on the same target: one cuts inside the region the template repairs, one 745 bp away from it. The reaction runs, yields nothing, and says which — one product dropped because a guide also cuts outside the repaired region.

RelatedCopy Anchor Link

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