Research summary
Why we rebuilt SpliceAI: an open, retrainable splice-site predictor
Your genes are written in pieces. Before a gene becomes a protein, the cell has to cut out the introns and stitch the exons back together — a process called RNA splicing — and it has to find the boundaries exactly, down to the single base. When splicing goes wrong, the consequences are severe: somewhere between 15% and 50% of disease-causing mutations in humans act by disrupting a splice site. So a model that can read a stretch of DNA and tell you where splicing will happen — and how a mutation might change it — is enormously useful, both for basic biology and for making sense of the variants we find in patients.
In 2019, SpliceAI did exactly that, and did it remarkably well: a deep neural network that predicts splice sites straight from sequence, with no hand-engineered features. It quickly became the gold standard. So why would we spend a year rebuilding it?
Why rebuild a tool that already works?
Two reasons — and both are about using SpliceAI rather than out-predicting it.
First, the engineering had aged. SpliceAI’s official implementation is built on an older version of TensorFlow and Keras. That made it awkward to run inside modern pipelines, slow on large inputs, and hard to extend or fine-tune — and most of the field has since moved to PyTorch. If you wanted to adapt SpliceAI, you spent your time fighting the framework.
Second, and more fundamentally, SpliceAI was trained only on human. Splicing signals are broadly conserved, but they are not identical across the tree of life, and a human-only model leaves accuracy on the table for every other species. In Steven Salzberg’s and Mihaela Pertea’s groups at Johns Hopkins, where I did my Ph.D., we annotate genomes across that whole tree — mouse, plants, insects, fish — and we kept hitting the same wall: we couldn’t easily retrain SpliceAI for the organism in front of us.
I’d already built a splice-site model of my own, Splam, so I knew the problem space well. OpenSpliceAI was the natural next step, and I took it on with Alan Mao — an undergraduate I was mentoring, and a co-first author on the paper. The goal was never a cleverer algorithm. It was to take the best splice-site model and make it open, modern, and retrainable by anyone — true to a motto I keep coming back to: build what you need, use what you build.
What OpenSpliceAI is
OpenSpliceAI is a faithful, open-source reimplementation of SpliceAI in PyTorch, wrapped in a modular toolkit. It keeps SpliceAI’s deep residual convolutional architecture — the network reads a window of DNA together with thousands of bases of flanking context and labels every position a splice donor, a splice acceptor, or neither — but rebuilds everything around it in a stack that plugs straight into today’s machine-learning ecosystem.
Figure 1. The OpenSpliceAI toolkit. Six modular subcommands take you from a genome to splice predictions: create-data turns a genome assembly + annotation into training tensors; train trains a model from scratch; calibrate tunes its output probabilities; transfer adapts a trained model to a new species; predict scores every base of a sequence; and variant scores the splicing impact of mutations in a VCF.
That structure is the whole point. You can start from a reference genome and its annotation, build a training set, train or transfer-learn a model, calibrate it so its scores mean what they say, and then turn it loose on a genome or a list of variants — all with one consistent, scriptable tool.
What it showed
It matches SpliceAI — but runs far lighter. The first thing to check for any reimplementation is that it faithfully reproduces the original, and it does. Across a range of flanking-context sizes, OpenSpliceAI’s donor and acceptor accuracy tracks the original SpliceAI almost exactly, and in-silico mutagenesis and calibration analyses confirm the two models rely on the same sequence features and produce similarly trustworthy probabilities. The difference is efficiency: because it’s built on PyTorch, OpenSpliceAI runs substantially faster and on a fraction of the memory, so you can score whole chromosomes on a single GPU.
Figure 2. Faithful, but far more efficient. (C, D) Donor and acceptor Top-1 accuracy for OpenSpliceAI and the original SpliceAI-Keras (both on human MANE genes) are nearly indistinguishable across flanking-context sizes. (E) At prediction time, the PyTorch implementation is dramatically faster and far lighter on memory than the Keras original as the input grows.
It retrains across the tree of life. This is the capability we most needed. With OpenSpliceAI you can train a model from scratch on a new genome or — faster — transfer-learn from the human model and let it adapt. When we did this for mouse, zebrafish, honeybee, and Arabidopsis, the species-specific models clearly outperformed the off-the-shelf human SpliceAI, and the gap widened the further the species sat from human: mouse, our closest relative here, gained the least; the plant and the insect gained the most. Transfer learning reached high accuracy in just a few epochs, which makes adapting the model to a new organism cheap.
It catches cryptic, disease-causing splicing. Because the variant module scores how a mutation shifts the splice landscape, OpenSpliceAI can flag the kind of cryptic splicing that underlies genetic disease — a single base change that silences a normal splice site or wakes up a dormant one.
Figure 3. Reading the splicing impact of clinical variants. For a cardiomyopathy variant in MYBPC3 and an optic-atrophy variant in OPA1, a single base change creates a cryptic acceptor or donor site. OpenSpliceAI’s scores (green) shift sharply — for example, an acceptor score jumping from 0.00 to 0.998 in MYBPC3 — and track the original SpliceAI’s (red), pinpointing the splicing change the mutation causes.
In both of these real disease examples, the model reads the reference sequence as unremarkable and then, after a one-base change, lights up a brand-new splice site — exactly the signal a researcher or clinician needs to connect a noncoding variant to a splicing defect.
The bigger picture
OpenSpliceAI isn’t a new idea about splicing; it’s an argument about how research tools should be built. SpliceAI proved that deep learning can read the splicing code. But a method is only as useful as it is usable, and a model locked to an aging framework and a single species is one the rest of us can’t fully build on. Re-implementing it in the open, in a modern stack, with first-class support for retraining, turns a fixed artifact into a foundation: now any lab can point splice-site prediction at any genome, or at any list of variants, without reverse-engineering someone else’s code.
That, to me, is much of what computational biology needs more of — not just better models, but open, maintained, adaptable ones. There’s plenty left to do: tissue-specific splicing, longer-range context, richer variant interpretation. But the foundation is open now, and that’s the point.
OpenSpliceAI is free and open source — the code, the trained models, and the documentation are all online.
Read the paper in eLife, browse the code, or work through the documentation. OpenSpliceAI was built with Alan Mao, Anqi Liu, Steven Salzberg, and Mihaela Pertea at Johns Hopkins.
Further reading: the original SpliceAI (Jaganathan et al., Cell 2019), which OpenSpliceAI reimplements; and Splam (Chao et al., Genome Biology 2024), our compact splice-site model for cleaning up RNA-seq alignments.