Free & open source · macOS

Cryptic splicing, from RNA-seq to the bench

Detect cryptic splicing from any knockdown or perturbation, design and validate the assays that confirm it, and keep the whole workflow — from primer to gel to lab notebook — in one place. Eighteen tools, one app, entirely on your own machine.

A real Mac app — not a browser tab · macOS 12 or later · Apple silicon & Intel · installs R for you on first launch

Lit2Bench
The Lit2Bench Cryptic Splicing Engine showing a sashimi plot for UNC13A: control and TDP-43-knockdown coverage tracks with splice-junction arcs, novel junctions picked out in red, above the transcript's gene track. Summary cards report 11 novel junctions and 3 candidate exons.
18tools, from BAM to ordering sheet
4classes of splicing defect detected
0bytes of your data leave the machine
MITlicensed, and free forever
Why it works this way

Deterministic by default

Every number Lit2Bench shows you comes from plain arithmetic or a real external tool — primer3, UCSC, NCBI — never from a guess. That is a design constraint, not an accident.

Real tools, real references

Primers come out of primer3. Sequence and annotation come from the UCSC REST API, citations from NCBI E-utilities. Nothing is approximated when the authoritative source is one request away.

Your data never leaves

Everything runs on your own Mac — there is no account, no backend and nothing to sign into. Multi-gigabyte BAMs are read off your disk in place, never uploaded. Notebook entries are plain JSON files you own.

One optional model, on a short leash

A plain-language interpretation step can run against a local Ollama model. It is off by default, never leaves your machine, and is only ever handed the numbers the detector already computed.

The toolset

Eighteen tools that hand off to each other

Pick an exon in one tool and it arrives pre-filled in the next. Filter by what you're doing, or search for the thing you need.

🔬

Cryptic Splicing Engine

Reads control vs. knockdown BAMs over a locus and screens for all four recognised splicing defects — cryptic exon inclusion, cryptic splice-site selection, exitrons and intron retention — in an IGV-style sashimi plot. Double-click to zoom.

Design
🧬

Primer & Schematic

Designs a junction-spanning primer pair against live reference sequence and shows the expected canonical vs. cryptic-exon product sizes, with a schematic you can export.

Design
📓

Lab Notebook

Reusable procedures and the experiments you spin up from them, with editable tables for setup and results. Saves to disk as JSON and reopens across sessions.

Notebook
🗂

Panel Runner

Runs the full cryptic-detection pipeline across a whole gene or locus list against one BAM pair, returning a row per locus. Click any hit to open it in the engine.

Design
🧭

Transcript Explorer

Search a gene symbol, RefSeq/Ensembl transcript ID or a locus and see every annotated isoform in the region — strand, length, coding status, exon and intron counts, CDS and UTR spans.

Design
✂️

Exon Extractor

Pulls real exon and intron sequence for a chosen transcript, exports BED/FASTA/CSV/JSON/GTF, and hands a chosen exon straight to the primer designer — no copying coordinates by hand.

Design
🔎

Plasmid QC

QC Plasmidsaurus (or any) reads against a reference plasmid: local pairwise alignment on both strands, a PASS / GENE_FOUND / FLAGGED verdict, called substitutions and indels, and NCBI screening of unmatched flanks.

Design
🔗

Gibson Assembly

Designs the primer pairs to Gibson/NEBuilder-assemble an ordered set of fragments: a gene-specific annealing region sized to your target Tm, plus the homology tail that builds each junction.

Design
🔄

Plasmid Creator

Joins your parts end to end, circularises them, and draws the resulting map.

Design
🧪

PCR Setup

Scales stock and final concentrations into a master mix for N reactions plus excess, in the units you actually pipette in.

Design
📉

qPCR (ΔΔCt)

Relative expression by 2−ΔΔCt against a chosen calibrator sample, with QC warnings when replicates or reference genes misbehave.

Analysis
📊

Densitometry

Normalises target band intensity to a loading control across lanes.

Analysis
📈

Standard Curve

Fits a standard curve — linear or quadratic — and back-calculates unknown concentrations from it.

Analysis
📋

Methods & Ordering

Collects the session into three paste-ready artifacts: a primer ordering sheet, a templated Methods paragraph and a references list — built from what you actually ran, with blanks marked rather than invented.

Analysis
⚖️

Protein Normalization

Works out lysate, water and dye volumes for equal-protein-mass loading.

Calculators
🧫

A280 Calculator

Converts A280 absorbance to concentration via Beer–Lambert, using your extinction coefficient and molecular weight.

Calculators
🧮

Protein Parameters

Computes molecular weight, pI and extinction coefficient directly from an amino-acid sequence.

Calculators
💧

Dilution Calculator

Solves C₁V₁ = C₂V₂ for stock volume and diluent volume.

Calculators
How a day goes

Detect, design, validate, record

The tools are built around one loop. Each step hands its result to the next, so nothing gets retyped and nothing gets transcribed wrong.

STEP 01

Detect

Point the engine at a locus and a control/knockdown BAM pair. It flags junctions and exons that appear on knockdown but aren't in the reference annotation.

Cryptic EnginePanel Runner
STEP 02

Design

Click a candidate exon and go straight to primer design against live reference sequence — with the canonical and cryptic product sizes you'd expect on a gel.

Exon ExtractorPrimer & Schematic
STEP 03

Validate

Scale the master mix, run the reaction, then quantify: ΔΔCt for qPCR, densitometry for the Western, a standard curve where you need one.

PCR SetupqPCRDensitometry
STEP 04

Record

Write the experiment up against a reusable procedure, and let the session assemble its own ordering sheet, references and Methods paragraph.

Lab NotebookMethods & Ordering
See it work

Any locus, any perturbation, BAM to primer pair

A real run against a real control/knockdown BAM pair — UNC13A and TDP-43 here, but the engine takes any locus and any perturbation. Every number on screen is computed live, and the detection timing is the app's own: nothing is sped up to flatter it.

Lit2Bench

Every number on screen is computed live — junction counts from the BAMs, primers from primer3, coordinates and sequence from UCSC. Detection runs in under ten seconds against two ~9 GB BAMs, because it reads one locus through the index rather than the whole file, and the clip holds that wait for exactly as long as it really took.

Get it

Two clicks, then it handles the rest

The download is small because it ships the app, not a runtime. On first launch it finds R — or installs it from CRAN for you — pulls down the R packages, and opens the toolkit in its own window. Every launch after that is instant.

Lit2Bench for macOS Universal · macOS 12 Monterey or later
Download the .dmg
Version 0.1.0 Size ~1.4 MB Licence MIT
  1. Open the .dmg and drag Lit2Bench to Applications.

    The usual macOS install — nothing unusual in the disk image.

  2. Launch it. Setup runs in the app window.

    A progress view walks through finding R, installing the packages, and starting up, then hands over to the toolkit. First run takes a few minutes; after that, seconds.

  3. Use it like any other Mac app.

    Its own window, its own Dock icon, a normal menu bar, ⌘Q to quit. Exports land in Downloads; your notebook is stored under ~/Library/Application Support/Lit2Bench.

⚠️ macOS says the app is from an unidentified developer

Expected, and it doesn't mean anything is wrong with the download. Lit2Bench is signed ad hoc rather than with a paid Apple Developer ID, so Gatekeeper won't open it on the first try.

Open System Settings → Privacy & Security, scroll to the bottom, and click Open Anyway next to the Lit2Bench message. You'll only do this once. If you'd rather clear the quarantine flag from a terminal:

xattr -dr com.apple.quarantine /Applications/Lit2Bench.app

Prefer to run from source?

Lit2Bench is a script-sourced Shiny app — no package structure and no build step. If you already have R, this is all it takes.

git clone https://github.com/codyciabarra/lit2bench.git cd lit2bench Rscript setup.R # installs everything, once Rscript run.R # launches, opens your browser

setup.R pulls the core CRAN packages plus the per-tool ones (Rsamtools, GenomicAlignments, pwalign, httr), so every tool works out of the box.

Two things stay optional: primer3 for primer design (brew install primer3) and a local Ollama model for the interpretation step. The app tells you how to get them if you use a tool that wants one.

What's next

Where this is going

Lit2Bench is built and maintained alongside real bench work, so the roadmap follows what the science actually needs next.

Shipping now

The macOS app

A real double-click install that bootstraps R and every package for you, so using the toolkit doesn't require knowing what CRAN is.

Up next

Windows and Linux builds

The same bootstrap-on-first-launch approach, packaged as an installer and a desktop launcher. The app itself is already cross-platform — only the wrapper is macOS-specific today.

Up next

Signed and notarised releases

An Apple Developer ID signature so the download opens on the first click, with no Privacy & Security detour.

Up next

Automatic updates

The About tab already knows how to update a source checkout. The installed app should check for a new release and update itself the same way.

Exploring

Genome-wide screening

The Panel Runner covers a gene list today. The natural next step is running detection across the whole annotation and ranking what comes back.

Exploring

Shareable notebook entries

Notebook documents are already portable JSON. Exporting an experiment — figures, primers, methods and all — as one file a labmate can open is the obvious follow-on.

Who built it

Made in the Gitler Lab

Lit2Bench is built at Stanford University, in a lab studying the genetics of neurodegeneration — including the cryptic-splicing biology the toolkit targets.

Cody CiabarraResearch Intern · Programmer
Aaron D. Gitler, Ph.D.Professor of Genetics · Lab supervisor
Yi Zeng, Ph.D.Postdoctoral Fellow · Code mentor

The Plasmid QC tool is an R port of GeneAlign by Alex Luu. Reference sequence and annotation come from the UCSC Genome Browser; citations from PubMed; primer design from primer3.