HISAT2 vs STAR vs Bowtie2: Which RNA-Seq Aligner Should You Use?

By Dr. Zubair Khalid, DVM, MS, PhD · 2026-11-11

HISAT2 and STAR are splice-aware aligners built for RNA-seq, while Bowtie2 is a general short-read aligner that cannot map reads across splice junctions, so the choice comes down to HISAT2 or STAR for genome-level RNA-seq and Bowtie2 for small RNA-seq, transcriptome-only quantification, or contaminant screening. If you want a single rule of thumb, use STAR when you have about 32 GB of RAM per job and want maximum sensitivity, use HISAT2 when memory is tight or you are processing a large cohort, and reach for Bowtie2 only when your reads will not cross exon-exon junctions.

This guide explains the difference between HISAT2 and STAR and Bowtie2 for RNA-seq in practical terms. It covers how each aligner works, where each one wins, the compute cost you should expect, worked command examples, and the mistakes that most often derail a first RNA-seq analysis.

The Short Answer

For a standard bulk RNA-seq experiment on a well-annotated organism such as human or mouse, STAR and HISAT2 are both excellent choices, and published comparisons show they perform similarly on alignment rate and gene coverage, with HISAT2 running roughly three times faster than the next fastest aligner in a direct benchmark of six common tools [1]. Bowtie2 is not a competitor for that job because it cannot split reads across introns. It belongs in your workflow for miRNA and other small RNA libraries, for aligning reads to a transcriptome reference during quantification, and for screening libraries for contaminating organisms.

A compact decision guide:

Bulk RNA-seq, human-scale genome, generous RAM. Use STAR, ideally with two-pass mode.
Bulk RNA-seq, limited RAM, large sample count, or a large genome. Use HISAT2.
Small RNA-seq such as miRNA profiling. Use Bowtie2 or a dedicated small RNA workflow.
Quantification against a transcriptome with a tool that expects an aligner. Use Bowtie2 as instructed by that tool.
Single-cell RNA-seq with 10x Genomics data. Use STAR through STARsolo or the Cell Ranger pipeline.

If you keep reading, the rest of this article explains each recommendation and shows the commands.

Why RNA-Seq Alignment Is a Special Problem

A DNA sequencing read maps contiguously to a reference genome. An RNA-seq read usually does not. Mature messenger RNA has had its introns removed by splicing, so a 100-base read that starts in one exon and ends in another exists nowhere in the genome as a contiguous sequence. The read must be split, with one part aligned to one exon and the other part aligned to a distant exon, and the gap between them is a splice junction.

This requirement splits the aligner world into two camps. Splice-aware aligners such as STAR and HISAT2 model junctions explicitly and can report an alignment that jumps across tens of kilobases of intronic sequence. Splice-unaware aligners such as Bowtie2 align each read as one continuous stretch, so a read that spans a junction either fails to map or maps incorrectly to whichever exon matches more of its sequence.

The practical consequences show up everywhere in an RNA-seq analysis. If you align with a splice-unaware tool against the genome, you lose a large fraction of reads that come from across junction regions, you bias expression estimates against short exons and junction-proximal sequence, and you cannot detect novel splicing at all. Published pipeline studies in organisms as different as tea flower tissue [2] and wheat leaf responses to stripe rust [3] all depend on this same first step, because every downstream measure, from differential expression to long non-coding RNA discovery, inherits the quality of the alignment.

There is a second path around the splicing problem. If you align reads to a set of mature transcript sequences rather than to the genome, no read ever crosses an intron, because the introns are gone from the reference. Bowtie2 works fine in that setting, and quantification tools built on transcriptome alignment use it for exactly that reason. The tradeoff is that you can only quantify transcripts you already know about, and reads that fall in introns or intergenic regions, which matter for novel transcript discovery, have nowhere to go.

Meet the Three Aligners

STAR

STAR, which stands for Spliced Transcripts Alignment to a Reference, was designed around a simple observation. Spliced alignment is hard for algorithms that index the genome compactly, so STAR uses an uncompressed suffix array instead. The index is huge but lookups are extremely fast, which is why STAR can align tens of millions of reads per minute on a modern server while using tens of gigabytes of memory.

For the human genome, the STAR manual recommends roughly 32 GB of RAM, and the precomputed genome index alone occupies tens of gigabytes on disk. Memory demand scales with genome size, which matters when you move to large plant or animal genomes.

STAR detects splice junctions in two ways. You can supply a gene annotation file in GTF or GFF format when building the index, using the -sjdbGTFfile option, and STAR will align reads against the known junctions directly. It also detects novel junctions on the fly from reads that split at unmapped boundaries. The recommended practice for maximum sensitivity is two-pass alignment. In the first pass STAR collects a set of junctions detected across your samples, and in the second pass it realigns all reads with those junctions inserted into the index. The simplest form is the per-sample option -twopassMode Basic, which performs both passes in a single command.

STAR is the aligner used in large public production pipelines for RNA-seq, and the 10x Genomics Cell Ranger pipeline and the STARsolo mode built into STAR both descend from it, which makes STAR experience directly transferable to single-cell work.

HISAT2

HISAT2 is the successor to HISAT and TopHat2. Where STAR buys speed with a memory-hungry index, HISAT2 uses a hierarchical graph FM index, a compressed structure related to the Burrows-Wheeler transform that keeps memory modest while still supporting fast, splice-aware alignment. For the human genome, HISAT2 runs comfortably in roughly 8 GB of RAM, and its index is small enough to store and share easily.

Two design features distinguish HISAT2. First, it is genuinely fast. In a head-to-head benchmark of six aligners on an RNA-seq dataset from 48 geographic samples of the grapevine powdery mildew fungus, HISAT2 ran about three times faster than the next fastest tool, and the authors treated runtime as a secondary consideration behind alignment quality [1]. Second, HISAT2 can build a graph index that encodes population variation. You can supply known SNP sites, known splice sites, and exon boundaries with the -snp, -ss, and -exon options, and the published prebuilt indices for human and model organisms already include this information. Reads carrying common variants align correctly on the first pass without a separate variant-aware workflow.

HISAT2 superseded TopHat2, and the same benchmark found that TopHat2 lagged behind every other aligner tested on alignment rate and gene coverage, so legacy pipelines still running TopHat2 should be migrated [1].

One flag matters enough to memorize. The -dta option formats output alignments for downstream transcript assembly with StringTie. If your workflow ends in transcript-level quantification and differential transcript expression, use it.

Bowtie2

Bowtie2 is a general-purpose short-read aligner built on an FM index of the reference. It aligns each read end to end, allowing gaps and local alignments, with a seed-and-extend heuristic that is accurate and memory-efficient. For the human genome the index occupies a few gigabytes and alignment runs comfortably on a laptop-class machine.

What Bowtie2 does not do is splicing. A read that spans an exon-exon junction must map as one contiguous stretch, and for genome-aligned RNA-seq that requirement is fatal for a meaningful fraction of reads. This is not a defect. Bowtie2 was designed for problems where reads do map contiguously, and it excels at them.

The places Bowtie2 belongs in an RNA-seq context are specific and useful:

Small RNA-seq. miRNA reads are about 18 to 30 bases, come from mature molecules, and never span introns. Bowtie2 with permissive multimapping settings is a standard choice here.
Transcriptome quantification. Statistical tools such as RSEM take Bowtie2 alignments against a set of transcript sequences and convert them into abundance estimates.
Contaminant and co-infection screening. Aligning a subset of reads against bacterial, viral, or rRNA references before your main analysis is cheap insurance, and Bowtie2 is well suited to it.
Allele-specific and other specialized workflows. Bowtie2 appears alongside STAR and HISAT2 as one of the suitable mapping programs for SNPsplit, a tool that sorts existing alignments by allelic origin using an N-masked reference genome [4].

Side-by-Side Comparison: HISAT2 vs STAR vs Bowtie2

Feature	STAR	HISAT2	Bowtie2
Splice-aware	Yes	Yes	No
Core algorithm	Uncompressed suffix array	Hierarchical graph FM index	FM index with seed-and-extend
RAM for human genome	Roughly 32 GB recommended by the manual	Roughly 8 GB	A few gigabytes
Speed on RNA-seq	Very fast	Very fast, about three times faster than the next fastest of six aligners in one benchmark [1]	Slower for genome-scale RNA-seq, and the wrong tool for that job anyway
Splice junction handling	Annotation-guided plus de novo detection, two-pass mode for best sensitivity	Annotation-guided plus de novo detection, population graph index encodes known junctions and SNPs	Not applicable, reads align contiguously
Bulk RNA-seq on the genome	Excellent	Excellent	Inappropriate
Small RNA-seq	Possible but unnecessary	Possible but unnecessary	Excellent fit
Transcriptome-only quantification support	Less common	Less common	Standard, for example with RSEM
Single-cell 10x data	STARsolo and Cell Ranger lineage	Not a standard choice	Not used
Output formats	SAM, BAM, sorted and indexed in one command	SAM, streamable to samtools	SAM, streamable to samtools
Typical role	Reference-grade bulk and single-cell alignment on well-resourced systems	High-throughput cohorts, constrained compute, large genomes	Small RNA, transcriptome quantification, contamination checks

How They Compare on the Criteria That Matter

Speed and Compute Cost

Speed differences matter less than people expect, because alignment is usually a one-time cost per project, but they matter a lot when you have hundreds of samples or a modest budget.

In the direct six-aligner benchmark, HISAT2 was about three times faster than the next fastest aligner, and the authors explicitly ranked runtime behind alignment rate and gene coverage when judging tools [1]. STAR and HISAT2 both finish a typical 30-million-pair human RNA-seq library in minutes to tens of minutes on a multicore server. Bowtie2 takes longer on the same genome-scale input and, more to the point, produces an unusable alignment for gene-level analysis because it cannot cross junctions.

Memory is where the real decision lives. The STAR manual recommends about 32 GB of RAM for the human genome, and genome generation is itself a heavy step. HISAT2 needs on the order of 8 GB. Bowtie2 needs a few gigabytes. On a 16 GB workstation, STAR for human is off the table, HISAT2 is comfortable, and cloud or institutional HPC access changes the calculus back toward whichever aligner fits your pipeline.

Sensitivity, Specificity, and Splice Junction Detection

Alignment rate and gene coverage are the two metrics biologists most often use to judge an aligner, and in the benchmark that compared them directly, Bowtie2, BWA, HISAT2, MUMmer4, and STAR all performed well on both, while TopHat2 lagged and was superseded by HISAT2 [1]. BWA, which is a genomic aligner rather than an RNA-seq specialist, performed best on those metrics overall, except for longer transcripts over 500 bases, where HISAT2 and STAR performed well [1].

Two cautions apply when reading any benchmark. First, results depend on the organism and the read length. A fungal genome with compact introns, as in that benchmark, stresses aligners differently than mammalian genomes with long introns and deep repeat content. Second, alignment rate alone can mislead. A high rate that comes from misplacing reads near junctions is worse than a slightly lower rate with correct placements, which is why gene coverage and junction-level accuracy deserve attention alongside the headline number.

For novel junction discovery, STAR's two-pass approach and HISAT2's de novo spliced alignment both work. STAR's two-pass mode is the more widely documented pattern for maximizing junction detection across a cohort, because junctions found in any sample in pass one benefit every sample in pass two. HISAT2 takes a different route to a similar end, baking known junctions and variants from a population into its graph index so that a single pass already benefits from prior knowledge.

Known Versus Novel Splice Junctions

This distinction drives real choices. If your analysis targets known genes and known isoforms, annotation-guided alignment is enough, and both STAR with a GTF file and HISAT2 with a prebuilt graph index serve well. If your analysis aims to characterize novel splicing, new isoforms, or splicing changes between conditions, you want de novo junction detection, and STAR's two-pass mode is the most commonly used configuration.

For non-model organisms with incomplete annotations, de novo capability matters even more. A strand-specific RNA-seq study in wheat that identified thousands of long intergenic non-coding RNAs associated with stripe rust resistance had to characterize transcription units well beyond a curated annotation set [3], and that kind of discovery depends on an aligner that can find junctions the GTF file does not yet know about.

Downstream Compatibility

The aligner is only the first half of the expression-measurement step. What happens to the BAM file decides the rest.

Gene-level counts. featureCounts and HTSeq-count both consume spliced BAM files from STAR or HISAT2 directly. You must tell featureCounts the library strandedness with the -s flag, because a mismatch silently halves your signal.
Transcript-level assembly and quantification. StringTie consumes HISAT2 output produced with -dta or STAR output, assembles transcripts per sample, and merges them across samples for differential transcript analysis.
Alignment-free quantification. Salmon and kallisto skip alignment entirely and estimate transcript abundance from pseudoalignments. These are legitimate modern alternatives, and many current pipelines use them instead of a genomic aligner for quantification-only questions.
Allele-specific expression. If you need to split reads by parental haplotype, the SNPsplit workflow masks known SNP positions with the ambiguity base N in the reference, aligns against that masked genome with a suitable program such as Bowtie2, STAR, or HISAT2, and then assigns reads to alleles at the masked sites [4]. All three aligners in this article are compatible with that pipeline, which means your allele-specific needs do not have to dictate the main aligner choice [4].

Multi-omics reanalysis projects make the reproducibility point concretely. A systematic review of Leishmania infection transcriptomics reanalyzed raw data from many public studies under a single unified pipeline with standardized quality control, and the ability to integrate results across studies depended on harmonizing exactly these early choices [5].

Single-Cell RNA-Seq

Single-cell experiments change the picture. Data from 10x Genomics and similar droplet platforms carry cell barcodes and unique molecular identifiers, and the alignment step must also process those. STARsolo, a mode built into STAR, ingests the raw matrix files from a 10x run and produces a gene-by-cell count matrix in one program, and Cell Ranger, the vendor pipeline, is built on a STAR variant. If you plan single-cell work, choosing STAR opens a direct path into that ecosystem.

The single-cell literature shows how much downstream analysis rides on this step. Studies that cluster tens of thousands of cells, infer trajectories, and map cell-cell communication, whether in wound-healing fibroblasts [6], inflamed colon stem cell states [7], or macrophage subpopulations in pediatric pneumonia [8], all start from a count matrix that was born in an aligner. Errors and biases at alignment propagate into every cluster and every pseudotime trajectory.

HISAT2 and Bowtie2 are not standard choices for droplet single-cell processing. You can align single-cell reads with HISAT2 and feed custom pipelines, but you lose the mature barcode-aware tooling, so most single-cell analysts run STAR or a pseudoalignment-based quantifier.

Non-Model and Large Genomes

Genome size stresses aligners in different ways. STAR's memory footprint scales with genome length, so a 15 to 17 gigabase wheat genome or another large polyploid plant genome pushes the suffix array into memory territory that many labs cannot fund. HISAT2's compressed index holds up far better under that pressure, which is one of the strongest practical arguments for HISAT2 outside mammalian genomics.

Plant and fungal RNA-seq studies illustrate both sides. The fungal aligner benchmark that crowned HISAT2's speed ran on Erysiphe necator, a modestly sized genome [1]. Large-genome projects such as the wheat lincRNA study [3] and the tea flower tissue transcriptome atlas, which profiled 21 samples across seven dissected tissues with matched RNA-seq and small RNA-seq libraries [2], show the range of reference complexity a real plant pipeline must handle. For such projects, HISAT2's memory profile is often the deciding factor.

Insect and arthropod genomes add their own complications with repeats and gene family expansions. A transcriptomic comparison of mass-reared and wild Mexican fruit fly strains, which identified more than 1,300 differentially expressed genes per strain and prominent reorganization of chemosensory receptor expression [9], represents the kind of analysis where alignment sensitivity in repetitive receptor gene families directly shapes the biological conclusion.

When to Use HISAT2

The question "when to use HISAT2" has a cleaner answer than most aligner questions, because HISAT2 occupies a well-defined niche between STAR and Bowtie2.

Your compute is constrained. If your largest machine has 16 to 32 GB of RAM and you cannot get sustained access to more, HISAT2 is the splice-aware aligner that will run comfortably while STAR for a mammalian genome will not.
Your cohort is large. HISAT2's speed advantage, measured at roughly three-fold over the next fastest tool in the six-aligner benchmark [1], multiplies across hundreds of samples into real calendar time saved.
Your genome is large or fragmented. Memory scaling makes HISAT2 the safer default for big plant genomes and for assemblies with many contigs.
You want variant-aware alignment out of the box. Prebuilt HISAT2 graph indices for human incorporate population SNPs, splice sites, and exons, so a single alignment pass already accounts for common variation.
You are migrating an old TopHat2 pipeline. TopHat2 was superseded by HISAT2, and the benchmark data showed TopHat2 trailing every other aligner tested on alignment rate and gene coverage [1].

The honest counterpoint is that when RAM is abundant and the genome is human-scale, STAR and HISAT2 both do the job well, and the difference in final gene counts after quantification is usually small compared with the effect of library strandedness, annotation version, and counting mode. The choice between them is more about logistics and ecosystem fit than about accuracy.

Worked Scenarios

Scenario 1: Forty Human Bulk RNA-Seq Samples for Differential Expression

You have 40 patient tumor and adjacent normal samples, 150-base paired-end reads, a 32-core server with 256 GB of RAM, and the goal of gene-level differential expression.

Use STAR with two-pass mode. Build the index once against GRCh38 with a matched Gencode GTF, run each sample with -twopassMode Basic and -outSAMtype BAM SortedByCoordinate, then count with featureCounts, supplying the correct strandedness. Alignment will take minutes per sample, and the two-pass mode maximizes junction sensitivity without extra effort. STAR is chosen here not because HISAT2 would fail but because the resources allow the most widely documented reference pattern, and single-cell extensions later reuse the same skills.

Scenario 2: A Single-Cell 10x Experiment

You have 24 samples from a droplet single-cell run and plan clustering and trajectory analysis.

Use STAR through STARsolo, or Cell Ranger if your institution licenses it and you prefer vendor support. Provide the 10x chemistry parameters and the reference transcriptome build that matches your genome annotation, and STARsolo produces filtered feature-barcode matrices ready for Seurat or Scanpy. Everything downstream, from integration across samples to cell-cell communication inference, assumes a sensible count matrix from this step.

Scenario 3: Small RNA-Seq for miRNA Profiling

You have plasma small RNA libraries, reads about 22 bases long, and you want miRNA abundance.

Use Bowtie2. These reads come from mature miRNAs and never span introns, so splice awareness buys nothing. Align against a mature miRNA reference with permissive multimapping, because miRNA families share near-identical sequences, and quantify with a tool designed for small RNA counting. The same library prep philosophy appears in plant work, where the tea flower study generated matched RNA-seq and small RNA-seq libraries from the same 21 samples to integrate mRNA and miRNA profiles [2]. The aligner for each library type differs, and that is correct, not inconsistent.

Scenario 4: A Non-Model Organism on a Modest Workstation

You have RNA-seq from a crop species with a 12-gigabase genome, a partially annotated reference, and a 64 GB server shared with other users.

Use HISAT2. STAR's index for a genome that size would demand RAM far beyond the machine, while HISAT2's compressed graph index fits and runs. Build the index with the GTF if one exists, allow de novo junction detection, and plan to iterate as the annotation improves. This is the classic setting in which HISAT2 is not merely acceptable but clearly the right engineering choice.

Command-Line Starting Points

These commands follow the official tool documentation and are safe starting points. Adjust paths, thread counts, and read lengths for your system.

Building a STAR index for human:

STAR --runMode genomeGenerate \
     --genomeDir /refs/STAR/GRCh38 \
     --genomeFastaFiles GRCh38.fa \
     --sjdbGTFfile gencode.v44.annotation.gtf \
     --sjdbOverhang 149 \
     --genomeSAindexNbases 14

The -sjdbOverhang value equals the maximum read length minus one, so 150-base reads use 149. The -genomeSAindexNbases value of 14 suits large mammalian genomes, and smaller genomes need a smaller value.

Aligning one sample with STAR in two-pass mode:

STAR --genomeDir /refs/STAR/GRCh38 \
     --readFilesIn sample_R1.fq.gz sample_R2.fq.gz \
     --readFilesCommand zcat \
     --outSAMtype BAM SortedByCoordinate \
     --twopassMode Basic \
     --outFileNamePrefix sample01_

Aligning one sample with HISAT2, with output formatted for StringTie:

hisat2 -p 16 -x /refs/hisat2/GRCh38_genome \
       -1 sample_R1.fq.gz -2 sample_R2.fq.gz \
       --dta | samtools sort -o sample01.sorted.bam
samtools index sample01.sorted.bam

If you downloaded a prebuilt HISAT2 graph index for your organism, the -x prefix points at it and the index already contains population SNPs and splice sites.

Aligning a small RNA library with Bowtie2:

bowtie2 -p 8 -x /refs/smallrna/mature_miRNA \
        -1 smallrna_R1.fq.gz -U smallrna_R2.fq.gz \
        --very-sensitive -k 20 \
        | samtools sort -o smallrna.sorted.bam

The -k 20 setting reports up to 20 alignments per read, which suits the heavy multimapping that miRNA families produce. Read the Bowtie2 manual section on multimapping before settling on these values for your project.

A practical exercise if you are starting to learn bioinformatics: download a small subset of one public RNA-seq sample, align 100,000 read pairs against the same genome with both HISAT2 and Bowtie2, and compare the overall alignment rates. The gap you observe is the cost of ignoring splicing, demonstrated on your own data rather than taken on authority. Watching that gap close when you switch to a splice-aware aligner teaches more about RNA-seq than any slide in a bioinformatics course, and it is the kind of exercise a good structured course will assign early.

Common Mistakes and Limitations

Using Bowtie2 for genome-level RNA-seq. This is the single most common beginner error. Bowtie2 cannot cross splice junctions, so a large fraction of reads fail to map or map to the wrong exon, and every downstream number is compromised. Bowtie2 is excellent for small RNA and transcriptome-only workflows, and wrong for the main alignment step of a bulk RNA-seq experiment.
Mixing aligners within one study. Differential expression compares counts across samples. If half your samples were aligned with STAR and half with HISAT2, sample-to-sample differences include a systematic aligner effect. One aligner, one index, one annotation build, applied to every sample.
Ignoring strandedness. Both counting tools and aligner flags encode library strandedness. Setting the wrong value in featureCounts roughly halves your apparent expression and can invert it for antisense transcripts. Confirm strandedness from the library prep documentation, not by guessing.
Mismatched genome build and annotation. Aligning against GRCh38 while counting against a GTF built for an older assembly misassigns reads at region boundaries and silently discards reads at coordinates that moved. Download the genome FASTA and the GTF from the same source and version, and record both in your methods.
Leaving -sjdbOverhang at a default that does not match your read length. For STAR, this parameter tells the index builder how long the overhang across a junction can be, and it should equal your maximum read length minus one. A mismatched value degrades junction alignment, subtly and pervasively.
Treating a high alignment rate as proof of quality. Contamination by rRNA or foreign organisms can inflate or deflate rates, and multimapping inflates reported alignments if you count them naively. Screen a small read subset against common contaminants first, and check the multimapping statistics your aligner reports.
Expecting aligner choice to fix weak data. If library quality is poor, no aligner rescues it. A reasonable caution that applies across all of computational biology is that the aligner is one link in a chain that starts at wet-lab sample preparation.
Still running TopHat2. It was superseded by HISAT2, and in a direct six-aligner comparison it trailed every other tool on alignment rate and gene coverage [1]. Migration is straightforward because the surrounding pipeline barely changes.
Benchmark results do not transfer automatically. The strongest head-to-head data available in the literature for these three tools comes from specific organisms and read configurations, including a fungal RNA-seq dataset [1]. Treat published rankings as priors, then validate on one or two of your own samples before committing a cohort.
Underestimating reproducibility requirements. When you or others reanalyze public data later, as modern meta-analytic workflows do with standardized pipelines [5], the recorded aligner, version, index, and flags are what make that possible. Write them into your methods section verbatim.

If You Are Starting to Learn Bioinformatics

Aligner choice is one of the first genuine decisions you meet on the RNA-seq path, and it is a good decision to practice on because the tradeoffs are concrete. If you set out to learn bioinformatics this year, structure your practice around a complete mini-project rather than isolated tool tutorials. Take one public RNA-seq sample, run quality control, align it with HISAT2, quantify genes with featureCounts, and compare your count matrix against the published values for the same run. Then repeat the alignment with Bowtie2 and watch the alignment rate drop.

A structured bioinformatics course earns its cost by sequencing these skills correctly, forcing you to complete each stage before the next, and reviewing your code for the quiet errors that self-teaching misses. The specific aligner a course teaches matters less than whether it explains why splice awareness matters, how strandedness flows through a pipeline, and how to record a workflow so someone else can rerun it. Those three ideas transfer to every aligner, every genome, and every future tool release.

Frequently Asked Questions

Can I use Bowtie2 for bulk RNA-seq?

Not for genome-level bulk RNA-seq, because Bowtie2 cannot align reads across splice junctions and will lose or misplace a large fraction of reads. Use it for small RNA-seq, for transcriptome-only quantification with tools such as RSEM, and for screening libraries for contaminants.

HISAT2 or STAR, which gives better differential expression results?

Both produce high-quality alignments on well-annotated genomes, and published comparisons found them similar on alignment rate and gene coverage, so differences in final differential expression results are usually smaller than differences caused by annotation version, strandedness, and counting choices. Pick based on your RAM budget, cohort size, and ecosystem needs, then use one aligner consistently for all samples.

How much RAM does STAR need for the human genome?

The STAR manual recommends roughly 32 GB of RAM for a human genome index and alignment. Large genomes need proportionally more, which is the main reason HISAT2 becomes the practical choice for big plant genomes or smaller workstations.

Should I run STAR in two-pass mode?

Yes, when you want maximum splice junction sensitivity. Two-pass mode collects junctions in a first pass and realigns with them inserted in the second pass, and the single-command form -twopassMode Basic makes this nearly free in effort. For annotation-only analyses it matters less, but there is little downside for bulk RNA-seq.

Which aligner should I use for single-cell RNA-seq?

Use STAR through STARsolo or the Cell Ranger pipeline for 10x Genomics and similar droplet data, because these tools process cell barcodes and molecular identifiers alongside alignment and produce a count matrix directly. HISAT2 and Bowtie2 are not standard choices in that setting.

When to use HISAT2 instead of STAR?

Use HISAT2 when RAM is limited, when your cohort is large enough that HISAT2's speed advantage adds up, when your genome is large or poorly annotated, or when you want population SNP and splice site information built into the index. When compute is abundant and the genome is mammalian-scale, either aligner serves well and the decision is about workflow fit rather than accuracy.