Reproducing InterProScan 6

InterProScan 6 annotates protein sequences with domains, families and functional sites by combining many member-database methods in one Nextflow workflow. This site rebuilds a small, honest slice of that job in your browser and gives you the commands to run the real pipeline.

At a glance

Where to go

• Visualisations — 117 charts of the real annotations, benchmarks and paper tables: coverage, top domains, signature frequencies, runtime, memory, reproducibility, positional amino-acid enrichment, parallel coordinates and entry co-occurrence.
• Annotate — paste a FASTA and scan it in the browser with a miniature six-pattern scanner; useful for seeing what a domain hit looks like before you run the real thing.
• Compare — load any two InterProScan-style TSVs (including the real files in annotations/) and get agreement and coverage, with the differing rows listed.
• Benchmark — run the scanner under five configurations, time it, and check that every configuration produces byte-identical sorted output.
• Paper data — the published InterProScan 6 results (Blum et al. 2026): runtime for nine proteomes, agreement with InterProScan 5, cloud costs.
• Real pipeline — the exact Nextflow commands, a timing wrapper and a configuration matrix for reproducing the benchmark on your own hardware.
• Methodology — the measurements in plain words: coverage, agreement, wall time, peak memory and how reproducibility is checked with fingerprints.
• Your results — a table to log your own runs (time, memory, coverage, fingerprints) and export them as CSV, with a comparison against the paper's numbers.

Headline numbers from the paper

The full nine-proteome table is on the Paper data page and in results/paper_table1_runtimes.csv; the reduction and speed-up columns were computed here from the reported times.

The paper this reproduces

Blum M, Hobbs E, Florentino L, Bateman A. InterProScan 6: a modern large-scale protein function annotation pipeline. Bioinformatics Advances 2026; 6(1): vbag141. doi:10.1093/bioadv/vbag141. Open access under CC BY 4.0. European Molecular Biology Laboratory, European Bioinformatics Institute (EMBL-EBI), Hinxton, Cambridge, UK.

The paper introduces InterProScan 6, a Nextflow reimplementation of the InterProScan pipeline, and reports:

• a runtime benchmark against InterProScan 5.77-108.0 across nine UniProt reference proteomes, on eight CPU cores, as the median of five runs (Table 1 — charted on the Paper data page and the Visualisations page),
• agreement between the two versions on all 573,661 Swiss-Prot sequences, for every member database, with matches counted as the same when they overlap reciprocally by at least 80% (Table 2),
• cloud costs and hybrid spot-instance runs for the human proteome, finishing in under two hours (Section 3.2), and
• a match lookup that answers sequences already known to UniParc from their checksum in minutes instead of hours.

Data and sources

• Sequences: UniProt reference proteomes UP000000625 (E. coli) and UP000001584 (M. tuberculosis), release 2026_03.
• Annotations: UniProt member-database cross-references enriched with InterPro 110.0 (annotations/*.tsv); cross-checked against the InterPro API (results/reference_agreement.csv).
• Benchmarks: local reproduce runs recorded in results/benchmark_runs.csv (four configurations × three repeats per proteome), plus the published paper tables above.

How reproducibility is checked

Every run's output is normalised (the date column is dropped), sorted and hashed, so two runs count as identical only if every annotation matches. Twelve runs per proteome — four chunk sizes and input orders, three repeats each — produced a single fingerprint each, and the same fingerprint across configurations.

cut -f1-10,12-15 runs/baseline/proteins.faa.tsv | sort | sha256sum

Run it yourself

python3 scripts/fetch_real_data.py        # download the proteomes and annotations
python3 scripts/real_benchmark.py         # fingerprints, timing and the API agreement check
python3 scripts/build_visualizations.py   # regenerate the chart data (site/viz-data.js)
python3 -m http.server -d site            # then open http://localhost:8000

The full Nextflow pipeline needs tens of gigabytes of member-database data and a container engine; the commands to run it (and the configuration matrix) are on the Real pipeline page.

Contact

Questions, corrections or feedback: harshinisuresha7@gmail.com

Annotate

Paste a protein FASTA or load a small real set or paste your own FASTA, then scan.

Compare

Paste or load two TSV files (this site’s output or real InterProScan output). Matching uses column 1 (protein) plus the signature in column 5 or the InterPro entry in column 12. Nothing is uploaded.

Agreement is the Jaccard overlap of (protein, accession) pairs. Coverage is the share of input proteins with at least one annotation.

Benchmark

Runs the same scan under five configurations that change chunk size and input order, then checks whether the sorted output is byte-identical. Time is wall-clock in this browser; memory uses the heap counter where the browser exposes one (Chromium).

Real pipeline

Confirm flag names and database setup in the official repository. The commands below follow its README for version 6.0.1. You need Nextflow 25.10.4 or later and a container engine; the data files download by themselves into --datadir on the first run. Pin both the pipeline version and the InterPro release.

First, the built-in test

nextflow run ebi-pf-team/interproscan6 -r 6.0.1 -profile docker,test --datadir data --interpro 108.0

Then your own proteins

nextflow run ebi-pf-team/interproscan6 \
  -r 6.0.1 \
  -profile docker \
  --input data/proteins.faa \
  --datadir data \
  --interpro 108.0

Results are written to the working directory, named after the input (for example proteins.faa.tsv, plus JSON, XML and GFF3 files). Check that 108.0 is still available; the paper used it.

Timing wrapper

#!/usr/bin/env bash
name=$1; shift; mkdir -p runs/$name; cd runs/$name
/usr/bin/time -v -o time.txt \
  nextflow run ebi-pf-team/interproscan6 -r 6.0.1 -profile docker \
  --input ../../data/proteins.faa --datadir ../../data --interpro 108.0 "$@"
grep -E "Elapsed|Maximum resident" time.txt

Configuration matrix

Load each run’s TSV into the Compare page to get agreement and coverage. Start with 50 to 200 proteins.

Methodology in plain words

The question

InterProScan 6 reads a protein’s amino-acid sequence and says what it probably does, by finding known domains, families and functional sites in it. This project asks four simple things. Can we run it ourselves and get sensible annotations? Do those annotations match trusted reference records? How much time and memory does it need? And does it give the same answer every time, however we set it up?

What you need

• A small set of protein sequences in FASTA format, 50 to 200 to start. Note where they came from: [dataset name and source].
• Reference records for the same proteins, such as the UniProt or InterPro entries for each one: [reference source and download date].
• The pipeline version [version] and the database release [release], written down before you start.
• A computer: [CPU model, cores, RAM, operating system]. A CPU is enough, but the database download is big, so check free disk space first.

Steps

1. Pick the proteins and save them as one FASTA file. Do not change it afterwards.
2. Install Nextflow and a container engine, then download the pipeline databases as the official instructions describe.
3. Run the pipeline’s own test first, to prove the setup works before using your data.
4. Run your FASTA once as the baseline, wrapped in the timing script so time and memory are recorded.
5. Compare the baseline output with the reference records on the Compare page, and note coverage and agreement.
6. Repeat the run changing one thing at a time: the container engine, the number of CPUs, then a second run with identical settings. Record time and memory each time.
7. Check whether the outputs are identical (see below), and log everything on the Your results page.

What we measure, and how

Checking reproducibility

Two outputs can be the same in substance but differ in row order or in the date column. So remove the date, sort the rows, then make a fingerprint. Identical fingerprints mean identical annotations. Check your file’s columns first, since the date is normally column 11.

cut -f1-10,12-15 runs/baseline/proteins.faa.tsv | sort | sha256sum

Do this for every run and paste the first characters of each fingerprint into the results table. If two runs with the same inputs give different fingerprints, use the Compare page to see exactly which matches differ.

Reading the results fairly

• Agreement with a reference tells you how similar the two are, not which one is right. The reference can be incomplete or older.
• Changing the database release will change results for good reasons. Report that apart from reproducibility problems.
• Time depends on the machine, so always state the hardware.
• A small protein set gives rough numbers. Say how many proteins you used.
• The browser Annotate and Benchmark pages are a miniature with six patterns. Do not report their numbers as InterProScan results.

Real data from the paper

These are the published results of InterProScan 6, copied from Blum M, Hobbs E, Florentino L, Bateman A. InterProScan 6: a modern large-scale protein function annotation pipeline. Bioinformatics Advances 2026; 6(1): vbag141. doi:10.1093/bioadv/vbag141 (open access, CC BY 4.0). I did not run anything to get them.

How the paper measured it

• Nine UniProt reference proteomes (release 2025_04, one protein sequence per gene).
• InterProScan 5.77-108.0 against InterProScan 6.0.0 run through Nextflow with Singularity, both using InterPro release 108.0.
• EMBL-EBI Slurm cluster, 8 CPU cores per task (Intel Xeon Gold 6252), 90 GB memory requested per job.
• Median of five runs. Times are full pipeline runs and exclude one-time data downloads. Run-to-run spread (MAD/median) was under 6%.

Runtime, Table 1

*Computed here from the reported times, not stated in the paper in this form.

With the match lookup switched on, sequences already known to UniParc are looked up by checksum instead of being analysed again, which is why those times are minutes.

Agreement between versions, Table 2

All 573,661 Swiss-Prot sequences (release 2025_04). InterProScan 5 is the reference, and two matches count as the same when they overlap reciprocally by at least 80%.

Cloud cost, Section 3.2

Full human proteome. The hybrid runs took under two hours and used spot instances.

Using this for your reproduction

• The two smallest proteomes are the realistic ones to repeat: E. coli (UP000000625, 4,402 sequences, 39 min in the paper) and M. tuberculosis (UP000001584, 3,996 sequences, 44 min). Download them from UniProt using the exact IDs above.
• Your hardware will differ, so compare ratios (IPS 6 with and without match lookup) rather than raw minutes, and state your CPU count.
• Use the same InterPro release as the paper (108.0) when checking annotations, so database changes do not confuse the comparison.
• The paper also lists every individual benchmark run in its Supplementary Table 1 (an xlsx file on the journal page), which I could not download.

Machine-readable copies of these tables are in the zip under results/paper_*.csv.

Glossary

The terms used on this site, in plain words.

The biology

The software

The measurements

Your results

Fill in your real runs here. Entries are saved in this browser only, so export the CSV to keep a copy. The grey text in each box is an example of what goes there.

Run details

Runs

Compare with the paper

The paper reports 39 minutes for the E. coli proteome (4,402 sequences) with InterProScan 6 on 8 cores, 89 minutes with InterProScan 5, and 2 minutes with match lookup. Hardware differs, so read this as a ratio.

Wall time by run

Visualisations

A gallery of ~100, all drawn in your browser from the real files in this repository — the UniProt/InterPro annotation TSVs in annotations/, the real proteome FASTAs in data/, and the summaries, benchmarks and transcribed paper tables in results/. No synthetic values, no chart library, no network requests. Regenerate with python3 scripts/build_visualizations.py.