kallisto quantifies RNA-Seq by pseudoalignment instead of alignment

Quantification without alignment

kallisto is a program for quantifying abundances of transcripts from RNA-Seq data, or more generally of target sequences using high-throughput sequencing reads. It is written in C and comes from the Pachter lab, and the licence is BSD-2.

The core idea is pseudoalignment. Instead of working out where each read comes from, kallisto rapidly determines the compatibility of reads with targets, without the need for alignment. The README calls this a novel idea and says pseudoalignment of reads preserves the key information needed for quantification, which is the argument for why skipping alignment does not cost accuracy.

The performance claim is specific. On benchmarks with standard RNA-Seq data, kallisto can quantify 30 million human bulk RNA-seq reads in less than 3 minutes on a Mac desktop computer, using only the read sequences and a transcriptome index that itself takes less than 10 minutes to build.

The accuracy claim is qualified in a way worth noticing. The README says kallisto is comparably accurate to other existing quantification tools, and that because the pseudoalignment procedure tolerates errors in the reads, in many benchmarks kallisto significantly outperforms existing tools. The phrase in many benchmarks is doing real work there.

The method is described in a paper by Bray, Pimentel, Melsted and Pachter, Near optimal probabilistic RNA-seq quantification, in Nature Biotechnology volume 34, pages 525 to 527, from 2016.

The paper, and the scripts that reproduce it

The README links the paper and then makes a point that many research tools do not: scripts reproducing all the results of the paper are available, in a separate repository called kallisto_paper_analysis.

That is a meaningful thing for a tool to offer. A quantification method is only as trustworthy as its evaluation, and most methods are published with a results table that nobody can rerun. Handing over the scripts means a claim can be checked against the published numbers rather than taken on faith.

The same repository structure tells you how the project is developed. The top level holds a src directory, test and unit_tests and func_tests directories, a CMakeLists.txt, an ext directory for third party code, a .gitmodules file, and build scripts named .make_binaries.linux.txt, .make_binaries.windows.txt and .make_binaries.sh, plus a gen_release.sh. There is a gulpfile.js, a .ycm_extra_conf.py for the YouCompleteMe language server, a .clang-format and an astyle.txt.

So this is a C project with a C++ and JavaScript mixed build environment, which is a more conventional shape than the single-language repositories that dominate this list. The presence of a clang-format configuration and an astyle configuration also suggests the code is kept to a specific style, which matters when you are reading a C codebase of any size.

The manual is the documentation

There is no command in the README. The manual is at http://pachterlab.github.io/kallisto/manual.html, and the README's Manual section consists of exactly one instruction: please visit that address for the manual.

There is also an INSTALL.md file in the repository root, and the repository carries a CMakeLists.txt, so the build is a standard CMake project rather than something exotic. The release scripts and the .make_binaries scripts suggest binaries are built per platform, and the project is distributed under the BSD-2 licence with the licence text in license.txt in the repository, which the README asks you to read before using kallisto.

For a tool that has been in use since 2016, the manual being the single source of installation and usage instructions is normal rather than a gap, but it does mean the repository itself is not enough to get started. Anyone evaluating it needs to fetch the manual, and that is where the index build step, the run command and the output formats are described.

The homepage is pachterlab.github.io/kallisto, and the project also has a Google Group, kallisto-and-applications, for questions about running it.

sleuth for bulk, bustools for single cell

The README is explicit that kallisto is a component in a larger workflow rather than an end to end analysis tool, and it names the two companions.

For bulk RNA-Seq, kallisto output can be analysed with sleuth, which is the differential expression method built on top of kallisto quantification. The two belong together: kallisto gives the transcript abundances and sleuth gives you the differential analysis with its own statistical model, so swapping one for another without the other breaks the chain.

For single-cell RNA-Seq, kallisto is used together with bustools to pre-process the data, and the README points at the kallistobus.tools website for the instructions. The pre-processing step is what makes a single cell workflow tractable at all, since individual cells are sparse enough that a bulk quantifier cannot simply be pointed at them.

The distinction matters for anyone choosing a tool. If your data is bulk and you want differential expression, the pairing to evaluate is kallisto plus sleuth. If your data is single cell, the pairing is kallisto plus bustools. Neither companion is bundled with kallisto, so adopting it means adopting a small stack, and the versions have to be compatible in a way the README does not spell out.

What pseudoalignment cannot tell you

The honest limitation is the same as the design decision. kallisto does not produce alignments, and a large part of the RNA-Seq toolchain is built on top of alignments. If you need to know where an individual read came from, to look at novel transcripts, to run a splice-aware alignment, or to inspect a specific locus, kallisto is the wrong tool and no amount of tuning will change that.

The second limitation is that the accuracy claims are benchmarked. The README speaks of standard RNA-Seq data, human bulk RNA-Seq reads, and many benchmarks. It does not claim a result for every organism, every library type, or every experimental protocol, and pseudoalignment relies on a k-mer style compatibility model, so unusual or highly repetitive references are where the assumptions are most likely to be strained.

The third is the version spread in the release history. Version 0.52.0 came in February 2026 with the note that Genomebam and pseudobam are back, and before that 0.51.1 from September 2024 and 0.51.0 from July 2024. A project that removes and restores outputs between releases has changed its interface more than once, so pinning a version for a published analysis is the safe habit rather than a cautious one.

The repository is not archived and the last push was on 2026-07-12.

Where kallisto sits against the alternatives

The meaningful comparison is with alignment based quantification, and the difference in approach is large enough to be worth stating plainly.

An alignment based pipeline maps reads to a genome, then counts reads per transcript, and the accuracy of the counts depends on how well the aligner handles the transcript structure. kallisto skips that step and instead computes, for each read, the set of transcripts it is compatible with, then solves for abundances with a probabilistic model. The paper describes the method as near optimal, and the speed follows from never building an alignment.

That speed is the reason to care. A quantification that takes three minutes instead of an hour changes what is possible in an analysis, particularly for exploratory work where you want to run the same pipeline over many parameter settings, or in a pipeline that re-quantifies on every iteration.

The cost is the loss of per-read information. If the question is which transcript a read came from, pseudoalignment answers it approximately, in aggregate, and does not give you a position. That is fine for abundance estimation and useless for anything that needs coordinates.

So the choice is not which tool is better but which question you are asking. Abundances, quickly, with a published benchmark behind them, versus alignments, slowly, with positions.

Editorial conclusion

kallisto suits an RNA-Seq analyst who wants fast, reproducible transcript abundances and is willing to accept a pseudoalignment model, because the index build and the quantification both run quickly and the accuracy claim rests on a published benchmark. It is the wrong tool if you need per read alignments, or if you are working with a species kallisto was not benchmarked on. Before adopting it, read the manual at pachterlab.github.io/kallisto/manual.html, build the transcriptome index for your reference, and decide whether you want the sleuth workflow for differential analysis or the bustools workflow for single-cell data.

Frequently asked questions

Official sources

1. License: BSD-2-Clause
2. pachterlab/kallisto on GitHub
3. Project website
4. README
5. Releases