All posts

November 8, 2026 · Temple Compute

nf-core/rnaseq Benchmark: 35% Faster, 32% Cheaper

We took the most-run pipeline in bioinformatics, nf-core/rnaseq, and ran it twice: once with Nextflow, once with Horus, on the same Slurm cluster, the same 12 human samples, the same containers and the same reference. With right-sized tasks, Horus finished 35% faster and cost 32% less, and the key outputs were byte-identical.

This post gives the numbers, the method and what produced the gap. Every figure below comes from the run reports published in the benchmark repository.

How much faster and cheaper is Horus than Nextflow?

On nf-core/rnaseq 3.27.0 with 12 human samples (15M read pairs each) on an AWS ParallelCluster Slurm cluster, Horus with right-sized tasks took 5,739 s and $6.38. Nextflow with nf-core default resources averaged 8,767 s and $9.43 over two runs. That is 34.5% less wall time and 32.3% less cost.

ArmResourcesWall timeRun costCPU-h requestedCPU-h usedMean queue wait
Nextflow, run 1nf-core labels8,908 s$9.5466.929.4567 s
Nextflow, run 2nf-core labels8,626 s$9.3165.129.2551 s
Horus, same sizesnf-core labels8,210 s$8.8362.228.1468 s
Horus, right-sizedmeasured5,739 s$6.3847.430.053 s

Per sample, that is roughly $0.79 with Nextflow and $0.53 with right-sized Horus. Against each Nextflow run individually, right-sized Horus was 35.6% and 33.5% faster, and 33.1% and 31.5% cheaper.

Even with the same resource requests as Nextflow, Horus finished up to 7.8% faster and 7.4% cheaper. Measuring and right-sizing every task is what turns that into 35%.

What was benchmarked?

The pipeline, data and cluster were the same for every arm. Only the engine and the resource requests changed.

  • Pipeline: nf-core/rnaseq 3.27.0. Nextflow 26.10.4 ran the official pipeline. Horus (horus-runtime 0.8.7 with horus-slurm 0.6.2) ran a native port of the same pipeline from our open Pantheon workflow library, using the same container images.
  • Data: 12 human RNA-seq samples, each cut to 15M read pairs. GM12878, K562, MCF7 and H1 come from the nf-core test_full set; HPF and HCM come from ENA. Reference: GENCODE v46, GRCh38.
  • Cluster: AWS ParallelCluster 3.16.2 in eu-west-1, Slurm, on-demand nodes. Head node m7i.large. A compute queue of up to 3 m7i.4xlarge nodes and a highmem queue of up to 4 r7i.2xlarge nodes.
  • Storage and containers: Apptainer 1.5.5 images on FSx for Lustre (SCRATCH_2, 1.2 TB), shared by both engines. No data copied between nodes.
  • Cold starts: every run starts with no warm nodes and no cache.
  • Cost: each compute node billed from launch to termination, including the 5-minute idle scale-down, plus the head node and FSx for the run.

Were the results the same?

Yes. A benchmark where one side cuts corners is worthless, so outputs were compared file by file with a concordance script on the cluster.

  • Byte-identical: Salmon gene and transcript tables for both routes, all 12 featureCounts summaries, and all 36 bigWig coverage tracks.
  • Metric-identical: every value in STAR Log.final.out and every Picard metric.
  • MultiQC general stats: 32 to 34 cells differ at the 14th significant digit, which is float formatting of a duplicate percentage.

The right-sized Horus run produced the same biology as Nextflow. It got there in 50 fewer minutes and for $3 less.

Why was right-sized Horus 35% faster?

Because nf-core's default resources ask Slurm for more than twice what the jobs use, and Slurm makes you wait for what you ask for.

nf-core labels give most processes 6 CPUs and 36 GB. On a 64 GB compute node, that means one such task at a time. Across the run, Nextflow requested 65 to 67 CPU-hours and used about 29. The compute nodes were 16% busy. Small tasks like RSeQC and bedClip ran for about 100 seconds but spent 1,000 seconds or more between submit and finish, almost all of it in the queue.

Horus measures every task as part of the run: mean CPU cores, peak memory and wall time, read back over the same SSH connection Horus uses to run the job. We turned one measured run into resource sizes with a simple rule, and reran.

Processnf-core requestMeasured useRight-sized request
salmon_strand6 CPU / 36 GB0.63 cores / 0.07 GB1 CPU / 2 GB
stringtie6 CPU / 36 GB1.44 cores / 0.96 GB1 CPU / 2 GB
markdup6 CPU / 36 GB1.07 cores / 19.1 GB1 CPU / 29 GB
sort6 CPU / 36 GB4.00 cores / 5.4 GB4 CPU / 9 GB
salmon_quant6 CPU / 36 GB5.55 cores / 8.6 GB6 CPU / 13 GB
star_align8 CPU / 58 GB4.27 cores / 35.3 GB8 CPU / 58 GB (kept)

The rule: CPUs equal the rounded mean cores used (at least 1), memory equals 1.5 times the measured peak (at least 2 GB). No task ran out of memory. Requested CPU-hours fell from 62 to 47, mean queue wait fell from 468 s to 53 s, and compute nodes went from 16% to 30% busy. Node-hours dropped from 9.7 to 7.4, and that is the cost saving. For the general method, see how to right-size Slurm jobs.

Why does measuring every task matter?

Horus measures every task in every run, automatically, on Slurm, cloud or a workstation, and puts the result in one report next to the workflow. Over-requested resources show up the first time you run a pipeline, and fixing them is an edit to the same workflow configuration you run from.

Most pipelines never get that treatment. Default requests are copied forward from template to template, and the cluster pays for the padding on every run. In this benchmark, the nf-core defaults asked for 2.2 times the CPU the jobs used. Horus closed that gap from a single measured run.

When measurement is built in, teams use it. A lab running an AMBER molecular dynamics protocol on Horus cut its CPU core requests by 76% the same way.

How to run nf-core/rnaseq with Horus

The native nf-core/rnaseq port is in the open Pantheon library. Install the engine with pip install horus-runtime, point the Slurm target at your partition and account, and run. To skip the command line entirely, import the workflow into the hosted platform and launch it from the browser, as covered in running nf-core pipelines without code.

After the first run, open the resource report, set each step's CPUs and memory to what it used, and run again. That second run is where the 35% comes from.

Comparing engines more broadly? See the Nextflow and Seqera alternative page, Snakemake vs Nextflow, and Airflow vs Nextflow.

FAQ

How much faster is Horus than Nextflow on nf-core/rnaseq?

On nf-core/rnaseq 3.27.0 with 12 human samples of 15M read pairs on an AWS ParallelCluster Slurm cluster, Horus with right-sized tasks finished in 5,739 seconds against a Nextflow mean of 8,767 seconds: 34.5% faster, which we round to 35%. Cost fell from $9.43 to $6.38, 32% cheaper. Key outputs were byte-identical.

How much does it cost to run nf-core/rnaseq on AWS?

In this benchmark, 12 human samples at 15M read pairs each cost $9.31 to $9.54 per run with Nextflow and nf-core default resources (about $0.79 per sample), and $6.38 with Horus and right-sized tasks (about $0.53 per sample). That covers on-demand m7i and r7i nodes from launch to termination, the head node and FSx for Lustre in eu-west-1.

Where does the speedup come from?

From measurement. Horus records the CPU, memory and wall time of every task in every run. nf-core default labels requested 65 to 67 CPU-hours for jobs that used about 29, so tasks waited in the Slurm queue for space they never used. Sizing each step from one measured Horus run cut requested CPU-hours to 47 and mean queue wait from 468 to 53 seconds.

Are the Horus and Nextflow outputs identical?

Yes. Salmon quantification tables, all 12 featureCounts summaries and all 36 bigWigs were byte-identical. Every STAR Log.final.out and Picard metric matched. MultiQC general stats differed only at the 14th significant digit, from float formatting.

Can I reproduce the benchmark?

Yes. Per-run reports and raw results are published in the benchmark repository linked from this post, and the Horus port of nf-core/rnaseq, including the right-sized configuration, is in the open Pantheon workflow library on GitHub.