All posts

November 8, 2026 · Temple Compute

Run nf-core Pipelines Without the Command Line

How do you run an nf-core pipeline without the command line?

You run an nf-core style pipeline without the command line by launching it from a visual platform instead of a terminal. In Horus, by Temple Compute, you open a workflow from the library, fill in a form with your samples and reference, and click Run. Horus submits every stage to your cluster or cloud and shows the whole run live in your browser.

That is the entire workflow for the person running the analysis. No nextflow run, no -profile, no nextflow.config, no #SBATCH lines, no SSH session left open overnight. The bioinformatician validates the pipeline once; everyone else launches it.

This post walks through what that looks like end to end, using RNA-seq as the example because it is the pipeline most labs run most often.

Why is nf-core hard for biologists to run?

nf-core pipelines are excellent science wrapped in an engineer's interface. Running nf-core/rnaseq the standard way means installing Java and Nextflow, choosing a container profile, writing a samplesheet CSV, picking a reference, writing or borrowing a cluster config so the jobs land on the right partition, and then keeping a terminal session alive while hundreds of jobs run. When something fails, the answer is in a .nextflow.log and a work directory with hashed folder names.

None of that is biology. It is the reason the bioinformatician becomes a queue: every RNA-seq run in the lab routes through the one person who knows the incantation. When that person is busy, results wait. When that person leaves, the pipeline calcifies. A visual platform removes the incantation without removing the pipeline.

Step 1: Pick the workflow from the library

The Horus workflow library holds ready-to-run workflows across bioinformatics, molecular dynamics, docking and machine learning. Each one shows its stages as a graph before you run it, so you can see what the pipeline does: trimming, alignment, quantification, QC, reporting.

The hosted library today is strongest in molecular dynamics, docking and virtual screening, and the launch flow is identical for every workflow in it. For RNA-seq, Temple Compute maintains a native port of nf-core/rnaseq 3.27.0 in Pantheon, our open GitHub workflow library, under its nf-core ports. Import it into the hosted platform once, point its stages at your Slurm target once, and from then on it launches the same way. "Port" means the same tools, the same containers and the same parameters, expressed as a Horus workflow instead of Nextflow code. It is not an approximation: in our benchmark, the key outputs (Salmon tables, featureCounts summaries, bigWigs) were byte-identical to the Nextflow run.

Step 2: Set inputs in a form, not a config file

Inputs are fields: your FASTQ files, the samplesheet, the genome and annotation, and the handful of parameters a biologist actually decides, such as strandedness or which aligner route to use. Everything else is fixed by whoever built the workflow.

For stages that run on cloud machines, Horus checks the projected cost before launch, and if the run would push you past a budget your organization set, it tells you before anything starts rather than after the invoice arrives. That is the difference between a tool your IT department tolerates and one it approves. Details are in research computing cost control.

Step 3: Click Run, and watch every stage

Clicking Run is the last thing you have to do. Horus connects to your Slurm cluster over plain SSH, with nothing installed on the cluster, and submits each stage as a job using the Apptainer or Docker images the workflow specifies. Stages that are set to run in the cloud get machines created for them on demand; those machines are destroyed when the run ends.

While it runs, the graph lights up stage by stage. Click any stage to see:

  • its live status and logs
  • which machine or partition it is running on
  • the CPU, memory and wall time it is using
  • the artifacts it produced, with their lineage back to the inputs

Nobody has to tail a log file or decode a hashed work directory. If a stage fails, you see which one, on which sample, with its log one click away.

Step 4: Read the results where they were produced

When the run finishes, results are in the browser next to the run that made them: QC reports, count tables, coverage tracks. Every artifact carries its provenance, so "which reference and which parameters produced this table?" has an answer months later, without a lab notebook entry.

Re-running is cheap. Horus caches artifacts, so if you change a downstream parameter, upstream stages whose inputs did not change are reused instead of recomputed. A downstream tweak does not rerun the whole pipeline.

Does a visual tool cost you speed?

No. It makes you faster. On nf-core/rnaseq, Horus with right-sized tasks ran 35% faster and 32% cheaper than Nextflow with nf-core defaults.

The reason is per-task measurement. nf-core's default resource labels requested about 65 CPU-hours for a run that used about 29. Horus measures what every task actually uses, and a scripted sizing step turned those measurements into right-sized requests, so more of them shared each node and queue wait collapsed. The nf-core/rnaseq benchmark has the full table and the method.

Before and after

What changes for each person in the lab when pipelines move from a terminal to a platform:

The biologist

  • Before: emails the bioinformatician a spreadsheet and waits.
  • After: launches the validated workflow from a form, watches it, reads results.

The bioinformatician

  • Before: runs every analysis by hand and debugs other people's samplesheets.
  • After: builds and validates workflows once, visually, in YAML or with the Python API, then publishes them to the team.

The PI

  • Before: cannot tell what ran, with which version, on which data.
  • After: every run, artifact and parameter is recorded and visible.

IT and research computing

  • Before: finds out about cloud spend from the bill and about cluster abuse from fair-share reports.
  • After: sets cloud budgets per user, organization and workflow; runs whose projected cloud cost would cross them are refused before launch.

Who builds the workflows?

Somebody still has to build and validate each workflow, and that person is usually the bioinformatician who used to run everything by hand. Horus gives them three ways to do it: a visual builder that wires stages together, YAML for people who like text, and a Python API where a decorated function becomes a workflow step. Roles keep the two jobs separate: builders design and publish workflows, runners launch them, viewers read results.

This is the split that scales a lab. One bioinformatician supporting ten biologists through a platform gets more done than one bioinformatician running ten biologists' analyses.

Where to go next

FAQ

Can I run nf-core pipelines without using the command line?

Yes. With Horus by Temple Compute, workflows in the hosted library launch from a form with no config: set the inputs, click Run, and watch each stage live in the browser. The nf-core/rnaseq port lives in the open Pantheon repository; it is imported once and needs a Slurm target configured once, after which biologists launch it the same way with no terminal and no Groovy.

Is the Horus RNA-seq workflow the same as nf-core/rnaseq?

It is a native port of nf-core/rnaseq 3.27.0. In our benchmark on 12 human samples, its key outputs (Salmon tables, featureCounts summaries, bigWigs) were byte-identical to the Nextflow run, and every STAR and Picard metric matched.

Can biologists run RNA-seq analysis without coding?

Yes. The analysis logic lives in the workflow, which a bioinformatician validates once. A biologist then launches it from a form with their samples and reference, watches each stage, and downloads or views results in the browser. The pipeline cannot be accidentally broken from the launch form.

Where do the jobs actually run?

Wherever the workflow's stages point: your Slurm cluster over plain SSH, your own workstations or GPU servers, or cloud machines that Horus creates for the run and destroys when it ends. Each stage can run on different hardware.

What does it cost to try?

The horus-runtime engine is free and open source. The hosted platform has a Free tier with monthly tokens for evaluation, and paid plans for teams. See the pricing page for the current tiers.