CRISPR Guide Design

Find the guides in a target sequence and check where else they could cut.

What it doesCopy Anchor Link

Finds every position in your sequence where the nuclease you picked can cut, scores each candidate for how well it should work and how likely it is to cut somewhere else, and draws the survivors on the map so you can see them against your features rather than reading a table of coordinates.

The output is a track, not a set of annotations: 3,857 candidates on a 20 kb locus is a normal result, and none of them belong in your record. The track is remembered with your project and can be switched off; the one or two guides you actually order become real annotations when you say so.

When you’d use thisCopy Anchor Link

Used in: Design a CRISPR guide, check where else it binds, and measure the edit you got

Two questions this answers, and they are not the same one.

"Where can I cut?" — you have a target region and need candidates. Set the target to the feature or selection, pick your nuclease, press Find guides, then sort by score and filter out the ones your cloning route cannot use (see Controls).

"Is this guide any good?" — you already have a spacer, from a paper or a collaborator. Find it in the results by sequence and read its scores and off-target profile rather than trusting that it worked in someone else's cell line.

Downstream, a chosen guide leads to: validation primers around the cut site, sgRNA cloning oligos for your expression vector, an ssODN repair template for a knock-in, or a paired-nickase design if specificity matters more than efficiency — all from the guide's own menu.

Pro tip. Design against the sequence you will actually transfect, not a reference. A silent SNP under the PAM or in the seed region is the difference between a guide that works and one that does nothing, and it will not show up in a design run against the reference allele.

The whole build package, in one passCopy Anchor Link

A knockout or a tag is not one design, it is six: the guide, the off-target check, the repair template, the primers that tell an edited colony from an unedited one, the order in which it is done, and the DNA to buy. Driving those one at a time means re-typing coordinates between them, and that is where a knock-in goes wrong — a homology arm placed against a different cut than the guide makes, or a screening primer that sits inside the arms and so amplifies the donor as readily as the locus, leaving an assay that cannot tell a real edit from plasmid carry-over.

Producing them together removes that class of mistake. You state the three things that follow your delivery method and organism rather than from any rule — how long the homology arms are, how far outside them the screening primers must bind, and how many guides to compare — and the package comes back as one object: the guides scored, the off-target census for the chosen one, a repair template whose arms sit on that guide's cut and whose PAM-disrupting mutation is silent wherever the cut falls in a coding sequence, a screening PCR with the two product sizes an agarose gel would show, the protocol in order, and the fragments and oligos to order. Every span it names is drawn on the map.

Two things it will refuse rather than guess: a target with no PAM in it, and homology arms that run off the end of a linear molecule — each naming which end and by how much. And one thing it warns about rather than hiding: a repair template with no insert templates a scarless rejoin, so the edited and unedited loci are the same length and size alone cannot distinguish them.

What this computesCopy Anchor Link

Every candidate the nuclease can cut in the target, each carrying its own numbers. Nothing here is a display-only derivation: every column is an engine readout.

Per guide

• Spacer, PAM and cut position, with the strand — the position is the guide's own, and clicking a row takes the map there
• On-target scores, all optional and all disagreeing on purpose, each in its own unit, so none of them is averaged with another: Rule Set 1 (Doench 2014), CRISPRscan (Moreno-Mateos 2015) and CRISPRater (Labuhn 2018), each 0–1; Rule Set 3 (DeWeirdt 2022), a z-score across a screen rather than a fraction, so 0 is an average guide; DeepHF (Wang 2019), a predicted knockout efficiency between 0 and 1 for the Cas9 variant and promoter you name; and DeepSpCas9 (Kim 2019), a predicted indel frequency in percent, reported as the model produces it and so able to read below zero for a guide it expects nothing of. A score the model was not trained for reads n/a rather than a number
• Known variants in the spacer or PAM: the dbSNP variants a guide sits on, each with its rsID, alleles and minor allele frequency, and whether it falls in the PAM (which can stop the nuclease binding at all) or the spacer (which weakens it). The guide is flagged, not hidden
• GC% of the spacer
• QC flags: a Pol-III (TTTT) terminator inside the spacer, the longest homopolymer, a cloning-enzyme site in the spacer for each enzyme you named — the last is the one that silently ruins a cloning run, because the spacer is cut when the guide goes into the vector — and the inactive-motif class of Graf 2019, reported as tt or gcc. That last one is a property of the spacer's final bases rather than a score, and it is the reason a guide with a good on-target score can still do nothing
• Folding: the longest self-complementary stem in the spacer (the cheap list-scale screen, CHOPCHOP's), an internal vs backbone hairpin verdict against the sgRNA scaffold you will actually clone into, and, on request, the measured folding free energy ΔG for the spacers you are still considering. A guide that folds onto its own scaffold loads into Cas9 poorly however good its on-target score is: this is the check that explains a good score with no activity

Per run

• Three counts, kept apart: how many guides are shown after your filters, how many are in the region you targeted, and how many exist on the molecule. The scan always covers the whole molecule, so narrowing the region never hides the fact that there are more
• The nuclease's own facts, before you run: the PAM, which side it sits, the spacer length, and where the cut falls relative to the protospacer
• The guide molecule you would order — an sgRNA (spacer + ~76–77 nt scaffold) for Cas9, a crRNA (species-specific direct repeat + spacer) for Cas12a, named as what it is rather than called an sgRNA for both

Off-target, when you ask for it

• Cas-OFFinder search over a sequence you supply, with the mismatch count per site and the two published specificity scores, MIT and CFD
• Host-genome specificity from the published whole-genome census (UCSC CRISPR Targets, computed by CRISPOR), which needs the assembly and where your molecule sits in it. The panel refuses to proceed until the assembly's own sequence at that position matches the molecule on screen — a specificity number computed for the wrong locus is confident and wrong. Only coordinates are sent; your sequence stays here

The oligo pool, when you are building a library rather than picking one guide

• The oligo you would order, per selected guide: the vector's 5′ and 3′ cloning overhangs around the spacer, and optionally one of eleven subpool barcode pairs, so several sub-libraries can be synthesised on one array and amplified apart afterwards. pLentiGuide's overhangs are the default; typing both sides swaps in your own vector. The composition is the one used by CRISPOR's saturating mutagenesis assistant, reproduced exactly, so a pool designed here matches one designed there
• How many guides each target contributed, and why it did not contribute more. Every candidate a filter held back is counted by reason beside its target — the Pol-III terminator, the Graf motif, a cloning-enzyme site, a GC window, a minimum on-target score. A pool that came up short says which rule shortened it
• One well per spacer. A spacer that is a good guide for two overlapping targets is one reagent, not two, so it is counted once and the second target is told it was already taken. Counting it twice would inflate the complexity the screen thinks it has
• The screen's scale, from numbers you supply and only those: cells that must survive selection at your intended representation (cells carrying each guide), cells to put in the transduction at your measured transduction efficiency, reads the readout must return at your chosen sequencing depth, and the guides expected to be missed at that depth — the Poisson zero class, which is what a sequencing depth actually buys you
• What an MOI costs you in interpretability. Give a multiplicity of infection and the panel reports the fraction of transduced cells carrying exactly one guide, Poisson and conditioned on having been transduced at all — the un-transduced cells are removed by selection and never reach the readout, so they are not what an MOI is chosen to control. A cell carrying two guides reports a phenotype neither of them caused
• What the protocol recommends, printed beside the field and never into it. Joung et al. 2017 (Nature Protocols 12
  –863) states >500 cells per sgRNA held through transduction, selection and harvest, an MOI below 0.3, and >500 reads per sgRNA for the screening readout (>100 reads per sgRNA is the shallower depth used to QC a cloned plasmid library, together with <0.5% of guides dropping out and under a 10-fold spread between the 90th and 10th percentiles). A plan below any of these is named as below it, not corrected to it: nothing is pre-filled from the protocol, because a recommendation typed into an input is a default wearing a citation, and a targeted library or a scarce primary cell is a real reason to screen below it. The arithmetic is the tool's; the numbers stay yours

This designs a library. It does not analyse one: turning sequencing counts from a finished screen back into hits is a separate question and no part of it is implemented here.

The build package, when you ask for one

• The repair template: both homology arms with the span each copies from the locus, the insert, the junctions to sequence across as offsets in the template, and every base the donor changes relative to the locus with the reason for each. The PAM-disrupting mutation is reported as silent or not — with the codon change that makes it silent, and the genetic code that decides, when the cut falls in an annotated coding sequence
• Repeated 12-mers inside an arm, which anneal out of register. Reported, never enforced
• The screening assay: the primer pair, the annealing temperature, and the two product lengths — unedited and edited — with the difference between them, so the gel is predicted rather than described
• The order form: every fragment and oligo, its length, and the design decision it comes from
• Off-target specificity within the searched molecule, said in those words. It is never a genome-wide number, and the package states its scope beside it

The run's own reading, generated from the result

Above the table the panel states what this run found, in three levels: the conclusion (the three counts, what the current ranking leads with, and — when you ranked by it — that Rule Set 3 is a z-score across a screen, so 0 is average), then only the cautions this run earned, then the chain, folded away: which nuclease, what was searched, what was reported, what is on screen after your filters, which models scored it, and which enzymes were screened against.

Every clause is built from the result, so it changes with the run rather than being a fixed sentence with numbers dropped into it. A caution names its own measurement and its subject: 129 of 3,010 shown guides carry a Pol-III (TTTT) terminator · 243 sit outside the 30–80% GC window the on-target literature treats as acceptable — a published band, not the GC filter above · this guide folds onto its own sgRNA scaffold. A clean run says nothing at all rather than reassuring you.

Base editors. Switching design mode to CBE (C→T) or ABE (A→G) changes the question from where can I cut to which base would this window change, and the readouts change with it.

Calling hits from a pooled screen

The other end of a screen from designing the pool: read counts come back from sequencing, and the question is which genes dropped out. Every number below is an engine readout, computed by the published BAGEL2 estimator (Kim & Hart 2021) and checked against it.

• Log2 fold change per reagent, per replicate — every column normalised to 10,000,000 reads, a pseudocount added before normalising, and the T0/plasmid columns summed into one control. Summing means a two-replicate day-0 is one control, not two, and is not pseudocounted twice
• A gene-level Bayes factor, with its standard deviation and the number of training iterations it was scored in. It is a log-odds: positive means the gene's dropout looks more like the reference essential genes than like the reference non-essentials. It is a comparison against those two sets, not an absolute fitness cost
• How many reference genes were found in your library, against how many you supplied. This is the number to read first: reference sets are gene symbols, so a library that names genes any other way trains on almost nothing and still returns a ranking that looks complete
• The fitted line the Bayes factor is measured against — slope, intercept, and the fold-change window it was fitted over — plus the kernel density threshold that set that window's lower bound. The model is shown, not only its output
• A precision/recall curve over the ranked genes, with the false-discovery rate at every point, and the Bayes factor your chosen FDR lands on. The FDR is where the list is cut; the curve underneath it does not move when you change it
• Replicate equalisation, off by default. A Bayes factor is a sum over replicates, so a three-replicate screen and a six-replicate one are not comparable until this is set

Two things this deliberately does not do. It does not resample training (BAGEL2's bootstrap and ten-fold modes), so every standard deviation is 0 and every observation count is 1 — the deterministic mode is the one that can be checked number for number. And it does not compute MAGeCK's alpha-RRA or drugZ: those are different statistics that disagree with this one on the same counts, so a hit list has to say which one produced it, and this one says BAGEL2.

Where it livesCopy Anchor Link

Tools → CRISPR Guide Design, or right-click a feature or selection on the map — the CRISPR submenu opens already scoped to what you clicked. Individual guides have their own right-click menu on the map once the track is drawn.

Inputs and outputsCopy Anchor Link

In: the whole sequence, a selection, a feature, or a batch of targets. A nuclease (which fixes the PAM, the spacer length and where the cut falls). Optionally a set of sequences to search for off-targets, and the restriction enzymes your sgRNA vector uses.

Out: a ranked table of candidate guides with position, strand, GC, on-target score, off-target assessment and any flags; the same guides as a track on the map with their PAMs and cut sites; an oligo pool as a CSV a synthesiser can quote from, with the pool drawn on the map as its own pinned set; and CSV export of the table itself.

Pro tip. Show N on map and Clear track are different from hiding the track. Hiding keeps the guides and stops drawing them; clearing throws them away. If the map is too busy, hide.

DemoCopy Anchor Link

Silent, 16 seconds, recorded on the CRISPR guides sample project. The open record is the human EMX1 locus (20.7 kb of chromosome 2). Find guides returns 3,857 SpCas9 guides, each scored, and Show the guide track on the stage draws their density along the locus, in guides per kilobase, above the sortable table. The worked example below is a real run on the same starter.

Worked exampleCopy Anchor Link

Open the CRISPR guides starter. It carries NC_000002, a real 20,703 bp window of human chromosome 2 around EMX1 — the locus most CRISPR papers benchmark on.

The second-ranked guide is the lesson. GTGGACTTGCGAGAGAAGCG (3568−) scores RS3 1.64, all but tied with the winner, and its hairpin verdict is backbone: it folds onto the sgRNA scaffold it would be cloned into. Two guides one hundredth apart on the on-target model, and only one of them is worth ordering — which is why the fold screen sits in the same table as the scores rather than behind a second run.

Note how little the scores agree. On that top guide: RS1 says 0.42, CRISPRscan 0.77, CRISPRater 0.68, RS3 +1.67. They were trained on different screens with different readouts, and the spread is information, not noise.

ControlsCopy Anchor Link

Design mode — Nuclease (cut), CBE (C→T) or ABE (A→G). Cutting and base editing ask different questions, so the readouts change with the mode rather than being filtered afterwards.

Nuclease — ten of them (see Algorithms you can choose). Picking one restates its own facts under the control, before you run: PAM NGG on the 3′ side · spacer 20 nt · blunt cut 3 bp into the protospacer.

Score guides with Rule Set 3, and its tracrRNA (Hsu 2013 · Chen 2013). Off by default because the published model downloads once, about 2.8 MB. Switching it on scores the guides already listed rather than starting a new search, and the two tracrRNA variants score differently — which is the finding the model was built on, so pick the one matching the vector you will express from.

Known variants under the guides: place the target on its genome assembly (it is checked base for base against the assembly before anything is read) and the dbSNP variants in that window are drawn as a lane on the map and matched against every guide. Variant set chooses which variants count: Common (dbSNP 155), All of dbSNP 155, or ClinVar (dbSNP 155). Minimum MAF draws and flags only variants whose minor allele frequency is at least that percentage; 0 keeps every variant, including the ones dbSNP gives no frequency for. The MAF shown is the highest frequency any dbSNP source reported for the minor allele. On the starter's EMX1 locus the common set holds 49 variants and 222 of 3,857 guides carry one, 38 of them in the PAM; a 5% floor draws 43 of the 49 and flags 201 guides. A guide on a common variant may cut one allele and not the other in a heterozygous cell, so pick another where you can.

Target region — whole · selection · feature · batch. The line under it states what was actually chosen and how much of the molecule that is (CDS: EMX1 · 16897 bp of 20703 bp (linear)), so a mis-set target is visible before the run rather than after.

sgRNA cloning enzymes — BbsI, BsmBI, BsaI, SapI, or any enzyme from your own collections. A spacer containing one of these recognition sites is flagged, because that spacer is cut when the guide is cloned into the expression vector.

On the results

• GC% range, strand (both · forward · reverse), hide guides with a Pol-III (TTTT) terminator, hide guides containing a cloning-enzyme site — filters, applied to the run rather than re-running it, and the counts above them say how many each one removed.
• Sort by — Position · Rule Set 1 · CRISPRscan · CRISPRater · Rule Set 3 · Rule Set 3 (target) · Rule Set 3 (total) · DeepHF efficiency · DeepSpCas9 indel % · GC%.
• Fold spacers — measures the folding free energy for the listed spacers, which is the expensive half of the fold screen and so is asked for rather than assumed.
• Show N on map / Clear track — the guides are a track, not annotations: 3,857 candidates do not belong in your record. The track is remembered with the project and can be switched off; a guide you actually order becomes a real annotation when you say so.
• Paired nickase (Cas9 D10A) — pairs from the guides you already have, with the offset window between them as the control.
• Host-genome specificity — the assembly and where this molecule starts in it. The record's own coordinate is offered beside the box when it carries one.
• Downstream design, per selected guide — cloning oligos in your vector's convention, an entry-vector clone for a named enzyme, validation primers around the cut (with their own amplicon size and Tm conditions), and an ssODN repair template whose replaced span and homology-arm length are yours to set.
• Look up the target gene — Ensembl · MyGene · ClinVar · gnomAD · GWAS Catalog, scoped to the feature you targeted, and answered in place rather than in another panel. The question a guide design turns on is usually is this the transcript I think it is and does this position already carry common variation, and both are one press away from the design you are looking at.

Every remaining control, by name

Oligo pool (sgRNA library)

Screen analysis (hit calling)

MYC, looked up in Ensembl from the coding feature already targeted. Until a feature is chosen the section says which authorities it would ask and why it cannot yet — never a button that does nothing.

The guide table is ten columns in a rail that is narrower than they are, so it scrolls horizontally to reach the last one. Widen the rail, or scroll the table.

Algorithms you can chooseCopy Anchor Link

Ten nucleases, and the guide RNA each one actually needsCopy Anchor Link

Picking a nuclease changes four things at once, and the panel shows all four before you run: the PAM it recognises, how long the protospacer is, where it cuts, and — the one most tools leave implicit — what molecule you will end up ordering.

The PAM variants within a family (SpG, SpRY, xCas9, SaCas9-KKH, enAsCas12a) are protein engineering of the domain that reads the PAM. They broaden where you can target; they do not change the guide RNA, which is why they share one constant region with their parent.

Cas9 and Cas12a make different molecules, and it matters when you order oligos. A Cas9 guide is a single-guide RNA: your 20–21 nt spacer with a ~76–77 nt scaffold fused to its 3′ end, standing in for the crRNA

The two Cas12a direct repeats are not interchangeable. AsCas12a's and LbCas12a's differ inside the loop and by one nucleotide of length, and a third orthologue (FnCas12a) differs again. Ordering a crRNA with the wrong species' repeat gives you a molecule the enzyme will not load.

Four on-target scores, and which one to reach forCopy Anchor Link

An on-target score predicts how efficiently a guide will cut — a different question from whether it cuts anywhere else. All four are computed from the sequence around the cut, all four are optional, and they do not agree, which is the point: they were trained on different screens with different readouts, so a guide the older rules like and the newer one does not is telling you something.

Rule Set 3 reads differently from the other three, and misreading it is the common mistake. It is not a 0–1 fraction and not a percentage: it is a z-score across a screen, so 0 is an average guide and higher is better. A guide at +1.6 is far into the top of the distribution; one at −0.5 is below average, not "50% efficient". Ranking by it is what it is for.

The tracrRNA is a control, not a setting. Rule Set 3's headline finding is that small variations in the tracrRNA — the constant half of the guide molecule — change which guides work, enough that a model ignoring it mispredicts. Two variants are offered:

• Hsu 2013, the original tracrRNA, which is what you have if your guides come from pX330 and the large family of vectors derived from it.
• Chen 2013, the extended-stem, A-U-flipped version usually written sgRNA(F+E).

Pick the one matching the vector you will actually express from. The same guide can move noticeably between the two, so scoring against the wrong tracrRNA is a real error rather than a rounding one.

Rule Set 3 is switched on rather than always present, for an honest reason: the published model is 2,279 decision trees, and it downloads once (about 2.8 MB) the first time you ask for it. It then scores the guides already listed — it does not start a new search — and adds an RS3 column you can sort by and export.

DeepHF, and why it asks which Cas9 you haveCopy Anchor Link

The other four scores were each trained on wild-type SpCas9 and say nothing about the high-fidelity variants. DeepHF was trained on all three separately, so choosing the model is a statement about your experiment, not a quality setting:

• WT SpCas9 · U6 promoter — wild-type Cas9 with the guide expressed from a U6 promoter, the usual mammalian vector.
• WT SpCas9 · T7 promoter — the same enzyme with the guide transcribed in vitro from T7. The promoter is in the model because it changes the 5′ end of the transcript, and the same guide can score differently under the two.
• WT SpCas9 · both promoters — the wild-type model trained across both sets.
• eSpCas9(1.1) and SpCas9-HF1 — the two engineered high-fidelity variants.

Scores from two models are not comparable with each other, and DeepHF is not comparable with Rule Set 3 at all: one is a predicted efficiency between 0 and 1, the other a z-score centred on 0. The panel keeps them in separate columns and never combines them.

DeepHF reads the 20-base spacer plus its PAM, and it was trained on canonical NGG PAMs only — a guide with any other PAM reads n/a rather than being extrapolated. Part of what it scores is the shape of the guide RNA: the score depends on how the spacer folds, and on whether the constant tracrRNA scaffold beside it still folds into its normal stem-loop. That is why switching it on is slower than the other scores — each guide is folded twice before the network sees it — and why the panel reports progress rather than appearing to hang.

Correctness is provenanced by authority, not by our own testing: every score is checked against the published network itself, over every guide in a whole human locus, for all five models.

What is deliberately not here. Rule Set 3 as published has two halves. This is the sequence half, which needs only the 30 bases around the cut. The target half additionally uses the transcript structure and the chromatin accessibility of the cell line you are editing; that data is not something this workbench has, so the second half is absent rather than estimated. Treat the number as "how good is this guide's sequence", not "how well will this guide work in my cell line".

The neural scores are absent on purpose. DeepHF and DeepSpCas9 are neural networks with no published form that runs in a browser, and an approximation of a trained model is not the model. They are left out rather than guessed at.

Two ways to ask whether a guide folds badly, and they disagree on purposeCopy Anchor Link

Both ship, because they answer different questions and neither subsumes the other.

• The interaction screen is the published rule set the popular design servers apply: a string search for self-complementarity within the spacer and for pairing against the backbone. It is instant, so it runs for every candidate in the list, and it is what a reviewer comparing your guides against another tool will be checking you against.
• The thermodynamic fold is a real minimum-free-energy calculation (Turner 2004) of the whole transcript. It takes about a millisecond for the spacer alone and up to ~70 ms for the full molecule, which is why it runs on the guide you open rather than on all of them.

The fold reports two independent failure modes, and this is the part a single ΔG cannot show you. A spacer can knot up on its own; separately, a spacer can reach into the constant region and break the stem-loops the enzyme grips. Guides that do the second cleave poorly even when their own ΔG looks perfect — measurably so: of 91 guides scanned across a real 600 bp window, 11 have no structure at all as a bare 20-mer, and 3 of those still break the scaffold's fold once transcribed. A spacer-only screen calls those three clean and is wrong about the molecule.

No good/bad line is drawn, deliberately. Published cutoffs move with the training set, so the panel reports the measurement — how many of the constant region's base pairs survived — and leaves the judgement to you. The one flag it does raise, "this spacer breaks N of M base pairs", is a comparison of two real folds rather than a fitted threshold.

An AsCas12a guide on the human EMX1 locus, folded as a crRNA. The arc diagram is the whole transcript: the direct repeat on the left because for Cas12a it comes first, the spacer on the right, and every base pair drawn as an arc coloured by which half its two ends sit in. Here the repeat folds exactly as it does alone — the spacer left it alone.

The informative case, on the same locus with SaCas9. This spacer's own ΔG is −0.1 kcal/mol — it has essentially no structure by itself — and it still breaks 4 of the scaffold's 27 base pairs once transcribed as a full sgRNA. Grey dashed arcs are the pairs it destroyed; the vermillion ones run from spacer into scaffold. This is the guide a spacer-only screen would have passed.

The scienceCopy Anchor Link

Host-genome specificity — the genome-wide answerCopy Anchor Link

Asking whether a guide is specific only means something once you say specific in what. Editing a human cell line, the guide has to be unique in the human genome; editing a plasmid in E. coli, there is no genome for it to be non-specific in. So the panel asks for the host assembly and where your molecule sits in it, and then reports the census that has already been computed for that assembly rather than searching it live.

Where the numbers come from. For the common assemblies, every possible NGG target site has been scored genome-wide and published as a genome-browser track — built with BWA alignment and the MIT/Hsu and CFD scoring schemes. What you see is that published result, quoted:

Nothing about your sequence is sent anywhere. The request carries an assembly name and coordinates; the matching happens on your machine, against data fetched from the public browser.

Your position is checked before any number is shown. The assembly's own sequence at the position you gave is compared against the molecule on screen — forward or reverse-complemented — and if it does not match, the check refuses and names the first base that disagrees. A specificity score reported for the wrong locus would look exactly like a right one. When your record came from a sequence database and states the region it was cut from, that position is offered to you directly.

Three results that are easy to misread, so the panel spells them out:

• "Not scored" is not a bad score. A spacer that occurs identically somewhere else in the genome is skipped by the census entirely; it is reported as unmeasured, never as zero specificity.
• A count with no site list. For guides with very many off-targets the source publishes the counts but not the individual positions. The counts are still exact — the sites are simply not available, which is different from there being none.
• Sites below CFD 0.023 are not published at all. When checked against experimentally validated off-targets, the large majority of predictions below that threshold were false positives (Haeussler et al. 2016), so a census of "no sites" means none above that line.

On the Moreno-Mateos (CrisprScan) score. Two published implementations of it disagree, in a single weight of the ninety-one: one places an AA term at position 18 of the scored window where the paper's own supplementary table places it at 19. The scores shown here follow the paper, which moves the value by about ten points for the roughly 3% of guides where it matters. If you compare against a tool that reports a different CrisprScan value for such a guide, this is why.

LimitationsCopy Anchor Link

There are two different off-target answers here, and they answer different questions. The off-target search covers what you give it: a guide is checked against sequences present in the project, so a clean result means "clean against what was searched", not "genome-wide safe". The host-genome check is the genome-wide answer, and it only applies when your molecule is a piece of a real assembly — see below.

A genome-wide answer needs a genome, and a plasmid does not have one. If your construct is not a region of a published assembly, no host-genome specificity exists for its guides. The panel says so rather than showing a number that would mean nothing.

Bulges are off by default, and they change what "off-target" means. An ordinary off-target search asks which sites match your guide with up to N substitutions. Turning on a DNA bulge additionally allows the DNA to carry extra bases the guide loops out over; an RNA bulge allows the guide to carry extra bases the DNA does not have. Real nucleases tolerate both, and both find sites a mismatch-only search cannot see — so leaving them off is an assumption, not a safe default.

Two things to know before you read the result:

• A bulged hit is usually reported more than once. The same site can be explained by putting the bulge in several places, each with its own mismatch count, and each is a separate row. That is what the reference implementation does and it is the honest presentation — one of those placements is what actually happens in the cell and nothing on the bench tells you which.
• The cutting-likelihood columns read n/a for bulged hits. MIT and CFD are defined over an ungapped 20-mer against an ungapped protospacer; there is no published score for a gapped alignment, so none is shown. Bulged hits are likewise left out of the aggregate specificity number rather than folded in with an invented weight.

Bulged results are checked against the reference implementation — hit for hit, both strands, for the SpCas9 family with up to 2 nt of DNA bulge and 1 nt of RNA bulge. Push the settings past that range and the panel says so and marks the hits unvalidated: the same algorithm runs, but nothing independent has confirmed it there.

A bulge-enabled search: 17 hits with the mismatch histogram above them. The row reading C-ACTGCAGCCTCGACCTCCTGG is an RNA-bulge hit — the dash marks where the DNA is missing a base the guide has. MIT and CFD read n/a on that row on purpose, and the line above the count confirms these settings are inside the checked range.

Scores rank, they do not predict. On-target scores are trained models: they are good at ordering candidates and poor at promising an efficiency. Use them to shortlist, then test.

The guides are candidates until you annotate them. They are deliberately not part of your record until you keep one, so an exported GenBank will not contain them.

Compared with other toolsCopy Anchor Link

Sources, first-party and dated: https://www.snapgene.com/features and https://www.geneious.com/features, both retrieved 2026-08-08, quoted verbatim above.

What they have that this does not: Geneious names editing-result analysis as part of its CRISPR tools; here that work lives in the trace tools rather than in this panel, and comparing them honestly needs someone who can run both. "Not described on the feature page" means exactly that: neither vendor publishes an exhaustive list.

And what this deliberately does not claim. The Rule Set 3 target half — transcript structure and the chromatin accessibility of your cell line — is absent rather than estimated, because the data is not in this workbench. Read RS3 here as how good is this guide's sequence.

ExportCopy Anchor Link

• CSV of every listed guide, with one column per readout and nothing collapsed: id · spacer · PAM · strand · start · end · cut site (all 1-based) · GC% · Rule Set 1 · CRISPRscan · CRISPRater · Rule Set 3 · Pol-III terminator · longest homopolymer · longest self-complementary stem · spacer fold ΔG · internal hairpin · backbone hairpin · enzyme-site hits. A score the nuclease cannot be scored for carries an explicit _NA in its header rather than an empty column that reads as zero, and the Rule Set 3 column is present whether or not it was switched on, so two exports of the same run cannot quietly differ in shape.
• The guides as a map track — Show N on map — remembered with the project, switchable, and never written into your record as annotations.
• A chosen guide becomes a real annotation when you say so, and its downstream products (cloning oligos, validation primers, the ssODN) are copied or handed to the tools that own them.
• Everything downstream then applies, because a validation amplicon is an ordinary PCR product and an entry-vector clone is an ordinary plasmid.

APICopy Anchor Link

@ports/guide — the search, the scores and the QC, with no editor state:

import { designGuides } from '@ports/guide';

const run = designGuides({
  sequence,                       // bare bases
  circular: false,
  nuclease: 'SpCas9',             // from the nuclease registry, not a hardcoded list
  region: [start, end],           // optional; the SCAN is always whole-molecule
  restrictionEnzymes: ['BbsI'],   // flag spacers carrying these sites
  minStem: 4,                     // shortest self-complementary stem to report
});
// run.guides[i] → { spacer, pam, start, end, cutSite, forward, scores, qc }
// run.totalCandidates → what existed before the region filter

Rule Set 3 is a separate call because it carries a model: it scores guides you already have rather than searching for new ones. Off-target search (Cas-OFFinder) and the published genome census are their own entry points in the same package, and the census one takes an assembly plus coordinates — never your sequence.

AutomationCopy Anchor Link

• Workflow DAG: crispr_design_guides, category design, a read node, so it needs no approval. Parameters are nuclease (whose enum comes from the nuclease registry itself, not a hardcoded allow-list), region_start / region_end, restriction_enzymes and min_stem. Outputs: guides, count (passing the region filter), totalCandidates (before it) and topSpacer. An unknown nuclease or enzyme is reported, never silently answered with no guides.
• screen_guides is the fold half on its own, for spacers you already have — from a paper, a collaborator, or topSpacer wired out of a design run. Its backbone parameter is the sgRNA scaffold the hairpin test runs against (Hsu 2013 or Chen 2013 / +11), and gg / pre_g describe the 5′ bases your construct adds. This is the check that explains a guide with a good score and no activity.
• The copilot calls both by the same names, with the same parameters and the same defaults.

ProvenanceCopy Anchor Link

A run records the question it answered: the nuclease, the target region as it was resolved (the feature's name and its span, not just two numbers), the enzymes screened against, the fold parameters, and whether Rule Set 3 was scored and against which tracrRNA. Those are what make a guide list reproducible — the scores themselves are a pure function of them and the sequence.

The guide track is project state, not document state. It is remembered with the project and restored with it; it is never written into the record, so a design run cannot quietly modify the molecule you designed against. A guide you choose to keep becomes an annotation by an explicit act, and that act is what the record's history records.

Host-genome specificity records the locus it was computed for, because a specificity number is meaningless without one — and the locus is checked against the assembly's own sequence before any number is shown.

Citing the method: the scores are ports of crisprScore (Rule Set 1, CRISPRscan, CRISPRater, Rule Set 3) and the off-target search follows Cas-OFFinder, both checked against those implementations, with the genome census taken from UCSC's CRISPR Targets track as computed by CRISPOR. Name the model, the tracrRNA variant and the nuclease; they are what another lab needs to reproduce the ranking.

ScreenshotsCopy Anchor Link

The EMX1 CDS on the CRISPR guides starter, ranked by Rule Set 3 with the model loaded. The conclusion states the three counts and the top guide with its z-score and what that scale means; two cautions appear because this run earned them (129 guides with a Pol-III terminator, 243 outside the literature's 30–80% GC band) and none of the others do; the chain is open below them, naming the whole-molecule scan, what the region filter left, and that Rule Set 3 is the sequence half only.

RelatedCopy Anchor Link

In this group: Codon Optimization · Back-translate: protein → DNA, codon-usage weighted or degenerate · Genetic Circuit · In-Situ Probes · CRISPR Edit Inference · RBS & Operon Design · Barcode & Index Design · Auto-Annotate · Apply features from a file · Power and sample size: replicates needed to detect an effect, or the power a design has · Trade-offs: which candidates in a table are not beaten on every objective at once