Ligation

Join cut DNA and see what comes out before you set the reaction up.

What it doesCopy Anchor Link

Takes the DNA fragments you are about to put in a tube and works out what T4 DNA ligase can make from them. Every fragment's real end structure — which overhang, how long, which strand, or blunt — is read first, joins are found between ends that are actually compatible, and the products are assembled in full, circular and linear.

It also runs the one-pot case, where the enzyme and the ligase are in the tube together: each input is digested first, the fragments are ligated, and the cycle repeats until nothing new is made. That is Golden Gate's chemistry and any other cut-and-paste-in-one-tube reaction.

When you'd use thisCopy Anchor Link

Before you set the reaction up, when you want to know whether it can work at all. Three questions this answers that a gel afterwards answers expensively:

• Will these ends even join? Two fragments cut with different enzymes may or may not leave compatible overhangs, and compatibility is not the same as "the same enzyme".
• How many products, and is the one I want unique? A pot with several compatible ends usually makes more than one circle, and the count is what tells you whether your reaction is a clean one or a lottery you will need to screen through.
• Which band do I gel-purify? Taking one fragment out of a digest is usually the difference between a product and none — ligating every band of every input together is exactly what a real reaction does not do.

The route is Digest → Ligation → Verification: cut, join, then check the product against the design. Coming from a Golden Gate or Gibson design, use those tools instead — they know about fusion sites and homology arms, which a plain ligation does not.

What this computesCopy Anchor Link

Per input, before anything runs

• the fragments each input contributes, with each fragment's length and both of its ends stated explicitly: overhang sequence, its length, whether it is a 5′ or 3′ extension, or blunt
• why an input contributes nothing — an enzyme that does not cut it, a selection with no cut inside it — named against the input rather than left as an empty result

Per reaction

• every product, circular and linear, with its full assembled sequence and length
• the number of products, which is the ambiguity readout: more than one circular product means the reaction is not clean
• every junction in a product, each carrying the overhang it was made by and where it sits
• the layout of the product: which span of the product came from which input fragment, and in which orientation — this is what the map draws
• remaining recognition sites in each product, for the one-pot case, since a product that can be re-cut is a product the reaction will keep consuming

Fragment-as-oligos: any fragment can be read back as the two oligos that would anneal to make it, top and bottom strand, 5′→3′ — which is how a short sticky-ended insert gets ordered rather than cut.

Where it livesCopy Anchor Link

Tools → Cloning → Ligation, in the right rail beside the map. Molecules are pulled from the live editor — the whole sequence, or the current selection — or handed over from the Digest tool, so nothing is re-typed. A product's fragments can be highlighted on the map, one at a time or all together.

Inputs and outputsCopy Anchor Link

Accepts any number of molecules, each supplied as the open sequence, the current selection, pasted bases, or a pair of annealed oligos. Each molecule is marked circular or linear and may be marked as the vector. Each may carry its own enzymes, which are applied to it before ligation.

Refuses out loud, never silently. Every input is inspected and reported before the run, with its fragments and their ends listed, so "no product" is never the first feedback you get — by the time you press run you can already see that two ends do not match. An input whose enzymes do not cut it says so against that input.

Produces the products with their sequences, junctions and layout. The first product can be opened as a new record in the project.

DemoCopy Anchor Link

There is no screencast on this page. The Ligation (sticky & blunt) sample project is the demo: it opens with the molecules already loaded, so the worked example below is reproducible in two clicks rather than described.

Worked exampleCopy Anchor Link

Open the Ligation (sticky & blunt) sample project and run it as it comes. The panel lists each molecule's fragments with their ends before you press anything — that listing is the part worth reading, because it is where you can see which pair of overhangs is going to join and which is not. Run it, and the products appear with their junctions; select a product and highlight its fragments on the map to see which piece of which input became which span.

Then change one thing: turn Allow blunt ends on. Blunt joins are compatible with everything, so the product count rises and the products stop being unique — which is the honest picture of a blunt ligation and the reason blunt cloning is screened rather than trusted.

ControlsCopy Anchor Link

Per molecule

Per reaction

The ends, the oligos and the reaction mix

Algorithms you can chooseCopy Anchor Link

One reaction model, two entry points. Ligation joins the fragments you give it. One-pot restriction–ligation digests, ligates, and repeats until the set of products stops changing — the fixed point is the answer, because in a real one-pot reaction a product that can still be cut is cut again.

There is no thermodynamic or kinetic model here: this predicts what can be made, not what fraction of the tube each product will be. Yield is a bench question. A molar-ratio helper is offered alongside — set the vector mass and the insert

End chemistry, and the nicked productCopy Anchor Link

A join seals only when both strands at the junction carry a 5′-phosphate. The two phosphates come from opposite molecules, so treating one side is enough to stop a join — which is exactly how a dephosphorylated vector is kept from self-ligating. Each molecule states what made its ends (a digest, a synthetic oligo, a PCR product) and what was done to them afterwards (a phosphatase — CIP, rSAP, Quick CIP — or T4 polynucleotide kinase). A synthetic oligo arrives 5′-OH, so an adapter ligated as supplied comes back with every junction marked nicked: the backbone is covalently discontinuous, which still transforms and is repaired in vivo but is not a sealed circle. Add T4 PNK and the same reaction closes. The reading names each nicked junction and why, rather than reporting a sealed circle that is not one.

The scienceCopy Anchor Link

Ligation is a question about ends, and the whole tool is built on that. Two ends join when their single-stranded extensions are reverse complements of each other over their whole length and are on the same strand polarity — a 4-base 5′ overhang joins another 4-base 5′ overhang with the complementary sequence, and joins nothing else. Blunt ends join any other blunt end, which is why they are permissive and why they are off by default here.

The consequence worth internalising: compatibility is a property of the overhang, not of the enzyme. Two different enzymes can leave the same overhang and ligate cleanly; one enzyme can leave different overhangs at different sites and fail to close a circle with itself.

For circular products, the join between the last fragment and the first is a junction like any other, and an annotation that crosses that point is a real, origin-spanning feature rather than an error.

LimitationsCopy Anchor Link

• This is a prediction of what is possible, not of what you will get. No yield, no molar ratios, no incubation temperature or time. A reaction that makes three products here will make three products at the bench in proportions this cannot tell you.
• Yield is not modelled. Molar ratios feed the planning helper, not the prediction: a reaction that makes three products here will make three at the bench in proportions this cannot tell you.
• No partial digestion. Every site an enzyme recognises is assumed cut. A real partial digest produces fragments this will not show.
• Methylation is not considered, so an enzyme blocked by Dam or Dcm methylation in your strain is treated as cutting.
• Large inputs make large product sets. Many compatible ends combine combinatorially; the circular-only default exists partly to keep that readable.

Compared with other toolsCopy Anchor Link

Desktop cloning packages simulate ligation as part of a restriction-cloning wizard, which is convenient when you are following the wizard's route and unhelpful when you are not. The difference here is that the inputs are inspected and reported before the run — the fragment-and-end listing is the tool, and it is what turns a failed reaction from a mystery into something you could have seen coming. Whether that suits you depends on whether you want a route or an answer.

ExportCopy Anchor Link

Products can be opened as new records in the project, from which every export format is available. The fragment-as-oligos readout gives the two sequences you would order for a short insert.

APICopy Anchor Link

import { inspectLigationInputs, runLigation, runRestrictionLigation } from '@ports/ligation';

// What are my ends, before anything runs?
const report = inspectLigationInputs([{ name: 'vector', sequence, circular: true, enzymes: ['EcoRI', 'BamHI'] }]);
report[0].fragments[0].leftEnd;   // { kind: 'sticky5', overhang: 'AATT', length: 4 } | blunt

const result = runLigation({ fragments, blunt: false, circularOnly: true });
result.products.length;            // >1 means the ligation is ambiguous
result.products[0].junctions;      // each with the overhang that made it

runRestrictionLigation takes the same inputs plus the pot's enzymes and iterates the digest-and-ligate cycle to its fixed point. ligationProductLayout turns a product into the spans the map draws. Everything is pure and synchronous, with no DOM.

AutomationCopy Anchor Link

The workflow node is ligate_fragments, category build. Its fragments port takes records, so upstream nodes wire straight in, and the node's own subject is included by default.

The parameter that most changes the answer is fragment_indices — which band to take from each input's digest, counting from zero. Left empty, every fragment of every input goes into the pot, which frequently yields no product, exactly as at the bench. Setting it is the digest-to-ligation hand-off.

Outputs are record (the first product), products, productCount (greater than one means the ligation was ambiguous), junctions and layout.

The one-pot cut-and-ligate is its own node, restriction_ligate: it makes its own ends, so it takes the pot's enzymes rather than pre-cut fragments, and adds recognitionSites — a product still carrying a site is an intermediate the reaction keeps consuming. Both nodes report nickedJunctions, and both take end chemistry per input (end_origins, end_treatments) so a dephosphorylated vector or a 5′-OH oligo behaves at these doors exactly as it does in the panel.

ProvenanceCopy Anchor Link

The reaction model follows pydna's ligation assembly, and the end-compatibility rules are the standard ones for T4 DNA ligase. Enzyme recognition sequences and cut positions come from REBASE, so an overhang predicted here is the overhang the authority describes for that enzyme.

ScreenshotsCopy Anchor Link

RelatedCopy Anchor Link

Digest cuts the molecules this joins, and hands its fragments over directly. Golden Gate and Gibson Assembly are the right tools when your design has fusion sites or homology arms rather than plain compatible ends. Verification checks the product you actually got against the one predicted here.