ALPINE: A Scalable Pipeline for Comprehensive Classification of Gene-Editing Outcomes from Long-Read Amplicon Sequencing

ALPINE is a scalable, reproducible Python-based pipeline that leverages long-read amplicon sequencing to comprehensively classify and quantify diverse gene-editing outcomes, including complex viral vector integrations and structural variants, addressing key limitations of existing short-read tools for therapeutic development.

The Gist

Imagine you are a master chef trying to perfect a new recipe for a life-saving medicine. You have a very precise instruction manual (CRISPR) that tells you exactly where to cut a piece of DNA and what new ingredient to add.

But here's the problem: when you make the cut and try to add the new ingredient, the kitchen gets messy. Sometimes the new ingredient fits perfectly. Other times, you accidentally drop extra ingredients, tear a hole in the recipe, or glue in a whole extra page from a different cookbook (a viral vector) that you didn't mean to use.

In the world of gene therapy, this "mess" is called heterogeneous outcomes. To make sure the medicine is safe and works, scientists need to look at every single edited DNA strand and sort them into neat piles: "Perfect," "Small Mistake," "Big Mistake," or "Accidentally Glued in a Viral Page."

The Problem with Old Tools

For a long time, scientists used tools like CRISPResso2 to sort this mess. But imagine trying to sort a giant pile of long, tangled yarn using only a pair of tiny scissors that can only cut 600 threads at a time.

• The Limitation: These old tools were designed for short DNA snippets. If the DNA strand was long (which it often is when using modern sequencing), the tool would get confused, miss the big tangles, or fail to see that a whole viral page had been glued in.
• The Manual Labor: Because the tools couldn't do it, scientists often had to sit there manually counting and sorting these long strands, which is slow, boring, and prone to human error.

Enter ALPINE: The Smart Sorting Robot

The authors of this paper built a new tool called ALPINE (Amplicon Long-read Pipeline for INtegration Evaluation). Think of ALPINE as a super-smart, automated sorting robot designed specifically for long, tangled yarn.

Here is how ALPINE works, using simple analogies:

1. The Quality Check (The Bouncer)
Before the robot even looks at the DNA, it acts like a strict bouncer at a club. It checks every DNA strand to make sure it's long enough and clear enough to be useful. If a strand is too blurry or broken, it gets kicked out. This ensures the data is clean.

2. The Matchmaker (Alignment)
The robot then takes each DNA strand and tries to match it against a "Wanted Poster." It has three posters:

• The Original: What the DNA looked like before editing.
• The Perfect Edit: What the DNA should look like if everything went right.
• The Viral Glue: What the DNA looks like if a viral vector (AAV) accidentally glued itself in.

3. The Detective Work (Classification)
This is where ALPINE shines. It doesn't just say "Match" or "No Match." It acts like a forensic detective:

• "Did you cut and paste perfectly?" (HDR Knock-in)
• "Did you accidentally glue in a viral page?" (AAV Integration)
• "Did you glue in the viral page but lose the sticky notes (ITRs)?" (Non-HDR with/without ITR)
• "Did you tear out a huge chunk?" (Large Deletion)

It can even tell the difference between two different viral vectors if you used more than one, like knowing which specific brand of glue was used.

4. The "Patcher" (The Safety Net)
Sometimes, a DNA strand is so messy that the robot gets confused and thinks it doesn't belong anywhere. ALPINE has a special "Patcher" module. It takes these confused strands, gives them a second look with a different set of glasses, and says, "Ah! I see now, you are actually a big deletion!" This catches mistakes that other tools miss.

Why Does This Matter?

The researchers tested ALPINE in two ways:

1. The Simulation: They created a fake digital world with 15 different types of DNA messes. ALPINE sorted them with 100% accuracy (or nearly 100%, with the tiny errors being expected noise).
2. Real Life: They used it on real human T-cells (immune cells) that had been edited. It successfully sorted thousands of strands, showing exactly how many cells got the perfect edit versus how many got messy accidents.

The Big Picture

Think of ALPINE as the quality control inspector for the future of gene therapy.

• Before: Inspectors had to squint at blurry photos and guess what was happening.
• Now: ALPINE provides a crystal-clear, automated report that says, "Out of 1,000 cells, 800 are perfect, 100 have small scratches, and 5 have a viral page glued in."

This level of detail is crucial for regulators (the government agencies that approve medicines). They need to know exactly what is happening inside the cells to ensure the medicine is safe. ALPINE makes this process fast, reliable, and ready for the cloud, meaning scientists can run these complex checks on massive batches of data without breaking a sweat.

In short: ALPINE turns a chaotic, messy pile of genetic data into a neat, organized filing cabinet, ensuring that the gene therapies we develop are as safe and effective as possible.

Technical Summary

1. Problem Statement

CRISPR-Cas genome editing, particularly when using viral vectors (like AAV) for homology-directed repair (HDR) knock-ins, produces heterogeneous outcomes. These include intended edits, large deletions, structural variants, and unintended viral vector integrations (full-length genomes or fragments containing Inverted Terminal Repeats, ITRs).

Existing bioinformatics tools face significant limitations in analyzing these complex outcomes using long-read sequencing data:

• CRISPResso2: Optimized for short Illumina reads (~600 bp), it cannot detect large structural variants, full-length HDR knock-ins, or multi-kilobase AAV integrations.
• Knock-knock Pipeline: Supports long reads but lacks specific categories for AAV integrations (e.g., distinguishing between integrations with or without ITRs) and cannot handle experiments involving multiple AAV vectors at a single locus.
• Manual Analysis: Researchers often resort to manual counting of alignments, which is not scalable, reproducible, or suitable for regulatory environments.

There is a critical need for an automated, scalable pipeline capable of classifying long-read amplicon data into specific, regulatory-relevant categories, including distinguishing between different viral vector integration events.

2. Methodology: The ALPINE Pipeline

ALPINE (Amplicon Long-read Pipeline for INtegration Evaluation) is a scalable, reproducible bioinformatics pipeline designed for PacBio HiFi long-read amplicon sequencing. It is implemented in Python, distributed via Docker containers, and supports Common Workflow Language (CWL) for cloud deployment (SevenBridges, Amazon HealthOmics, Arvados).

The workflow consists of five sequential steps:

A. Read Filtering and Alignment

• Filtering: Reads are filtered based on the presence of forward and reverse primers within the first/last 100 bp and a minimum average sequencing quality (default Q30).
• Alignment: Filtered reads are aligned to a reference set (Wild-Type, HDR knock-in, and AAV vector integration sequences) using minimap2 with the map-hifi preset.

B. Read Classification Logic

Classification is based on alignment results and involves a multi-step decision tree:

1. Wild-Type (WT) Aligned Reads:
   • Variant calling is performed within ±20 bp of the cleavage site.
   • Categories include: Unmodified, Small/Large Deletions, Small/Large Insertions, Inversions, Duplications, and SNPs.
   • Large Insertion Handling: Insertions ≥50 bp are extracted and re-aligned to HDR/AAV references to determine if they originate from the transgene or DNA repair template.
2. HDR/AAV Aligned Reads:
   • Reads aligning to HDR or AAV references are evaluated for transgene and AAV content.
   • Differentiation: Distinguishes between perfect HDR knock-ins and "Non-HDR" AAV integrations.
   • ITR Sub-classification: Non-HDR integrations are further split into "With ITR" and "Without ITR" based on the presence of ITR sequences.
3. Re-alignment Modules (to reduce false negatives):
   • Inserted-sequence Re-alignment: For WT reads with large insertions.
   • Clipped-sequence Re-alignment: For WT reads with unmapped soft-clipped segments (≥100 bp) to recover transgene content.
   • WT Re-alignment: For reads initially aligned to HDR/AAV that lack transgene sequence, re-aligning them to WT for variant calling.
4. False-Negative Rescue ("Patcher"):
   • Unclassified reads undergo a secondary alignment pass using minimap2 (v2.16, map-pb preset) to rescue large deletions missed in the initial classification.

C. Counting and Merging

• Reads are quantified per category for each sample.
• Outputs include per-sample classification tables, QC reports (read length/quality histograms), and a merged summary table for multi-sample experiments.
• The pipeline supports multi-vector experiments by attributing integration events to specific vectors.

3. Key Contributions

• Comprehensive Classification: ALPINE classifies reads into 10+ categories, including specific subtypes for AAV vector integrations (with/without ITRs) and multiple donor templates.
• Multi-Vector Support: Unlike previous tools, it can distinguish which specific AAV vector contributed to an integration event when multiple vectors are used in the same experiment.
• Regulatory Readiness: Built with Docker and CWL, it ensures reproducibility and is designed for high-throughput, cloud-based analysis suitable for regulatory submissions.
• Advanced Error Correction: The inclusion of "re-alignment modules" and a "patcher" module significantly reduces misclassification of complex structural variants and large deletions.

4. Results

• Benchmarking on Simulated Data:
  • Tested on 15 groups of simulated reads (20,000 reads/group) covering diverse outcomes (HDR, Non-HDR with/without ITRs, deletions, SNPs).
  • Accuracy: Achieved 100.00% accuracy in 14 of 15 groups.
  • WT Performance: Correctly classified 97.60% of unmodified reads; the remaining were correctly identified as small indels or SNPs consistent with simulated sequencing errors.
• Application to Real Data (T Cells):
  • Applied to PacBio HiFi data from 5 edited human T cell samples (10 datasets total, 2 loci per sample).
  • Findings: Successfully quantified HDR knock-ins as the predominant outcome. Detected low-frequency structural variants and unintended Non-HDR integrations (with/without ITRs).
  • Validation: Read-length distributions correlated strongly with ALPINE's quantitative classifications (e.g., samples with high knock-in rates showed peaks in the expected knock-in read-length range), confirming the pipeline's accuracy.

5. Significance

ALPINE addresses a critical gap in the analysis of gene-editing therapies. By enabling the automated, precise, and regulatory-compliant characterization of complex editing outcomes—specifically AAV integration events and structural variants—it facilitates:

• Safety Assessment: Accurate detection of unintended integrations that could compromise efficacy or introduce safety risks.
• Process Optimization: Rapid comparison of editing efficiencies across different samples and conditions.
• Scalability: The ability to process large datasets in cloud environments, essential for clinical trial development and commercial manufacturing.

While currently optimized for PacBio HiFi data, the framework is designed to be adaptable for other long-read technologies (e.g., Nanopore) in future iterations.