Modern biology generates enormous amounts of sequencing data, especially from RNA sequencing, which measures how genes are expressed inside cells. Analyzing these datasets can take significant computing time, even with efficient tools. A new report led by researchers at the University of Iceland shows how graphics processing units, GPUs, can dramatically accelerate this process.

Many researchers use a software tool called kallisto to estimate how much RNA is produced from each gene or transcript in a sample. Kallisto works by comparing RNA sequencing reads with known transcript sequences using an approach called pseudoalignment. This method is already fast compared with traditional alignment tools, but the growing size of sequencing datasets continues to push computational limits.

The researchers redesigned the key algorithms used by kallisto so they could run efficiently on GPUs. GPUs were originally developed to render graphics in video games, but their ability to perform many calculations simultaneously makes them powerful for scientific computing. Instead of simply transferring existing software to GPUs, the team reworked the core computational steps, including pseudoalignment, equivalence class intersection, and the expectation maximization algorithm, to fully take advantage of the hardware.

A schematic overview of the kallisto algorithm
and how each step is implemented in the GPU framework

A A schematic of three transcripts (colored) from one gene, sharing an exon structure and a sequencing read (black). B The target de Bruijn graph showin k-mers (nodes) and the paths traced by each transcript in the graph. C The k-mers in the sequencing read correspond to a path in the de Bruijn graph shown by shaded nodes. D The set of equivalence classes in the graph. E The processing of the read in GPU memory, read sequences are transformed to k-mers, each k-mer is mapped to an equivalence class, the set of equivalence classes are deduplicated, each equivalence class is expanded to its corresponding transcript set, the intersection of the transcript sets is computed, and the result is converted into the corresponding equivalence class.

The results are impressive. The GPU version achieved a 30 to 50 fold speed increase compared with the standard multithreaded CPU implementation of kallisto. In benchmarking tests using 100 RNA sequencing samples from the Geuvadis dataset, the system processed paired end reads at a rate of about 3.6 million reads per second. A typical RNA sequencing sample could be analyzed in seconds rather than minutes.

The advantage becomes even clearer with very large datasets. For example, processing a dataset containing 295 million reads dropped from about 40 minutes to just 50 seconds. This type of acceleration could make a major difference for projects analyzing hundreds or thousands of samples.

Fast analysis has practical implications across many areas of biology and medicine. Researchers studying gene regulation, disease mechanisms, or drug responses often rely on RNA sequencing to measure changes in gene expression. Faster processing means scientists can explore datasets more interactively, run more analyses, and scale studies to larger populations.

The work also highlights an important lesson for computational biology. Simply moving existing software to faster hardware is not enough. To fully benefit from modern processors like GPUs, algorithms often need to be redesigned specifically for parallel computation. When that redesign is done carefully, as demonstrated here, the payoff can be dramatic.

As sequencing technologies continue to generate larger datasets, advances like this will be critical for keeping data analysis practical and accessible.

Availability – The code for the GPU implementation of kallisto is available on GitHub at https://github.com/pachterlab/kallisto under the gpu branch.