A Rust implementation of FastQC, a quality control tool for high throughput sequence data. This is a 1:1 rewrite of FastQC v0.12.1 with identical output format and analysis algorithms.

• Built-in Trim Galore support — adapter/quality trimming via fastqc-rs trim-galore, a Rust reimplementation wrapping Cutadapt

• 12 analysis modules with identical algorithms and pass/warn/fail thresholds:

  1. Basic Statistics
  2. Per Base Sequence Quality
  3. Per Tile Sequence Quality
  4. Per Sequence Quality Scores
  5. Per Base Sequence Content
  6. Per Sequence GC Content
  7. Per Base N Content
  8. Sequence Length Distribution
  9. Sequence Duplication Levels
  10. Overrepresented Sequences
  11. Adapter Content
  12. Kmer Content

• Input formats: FASTQ (plain, gzip, bzip2), BAM, SAM

• Output: HTML report with SVG graphs, ZIP archive, fastqc_data.txt, summary.txt

• Output compatibility: Text reports match Java FastQC output (identical PASS/WARN/FAIL, near-identical data values)

• Multi-file parallel processing via rayon

• Single binary with embedded configuration files

cargo install --path .

Or build from source:

cargo build --release

# Basic usage
fastqc-rs input.fastq

# Multiple files with parallel processing
fastqc-rs -t 4 sample1.fastq.gz sample2.fastq.gz

# Specify output directory
fastqc-rs -o results/ input.fastq

# BAM/SAM files
fastqc-rs input.bam
fastqc-rs -f sam_mapped input.sam   # Only mapped reads, with soft-clip removal

# Extract results from ZIP
fastqc-rs --extract input.fastq

# Quiet mode (suppress progress)
fastqc-rs -q input.fastq

For each input file sample.fastq.gz, produces:

• sample_fastqc.html — Interactive HTML report
• sample_fastqc.zip — Archive containing:
  • fastqc_report.html
  • fastqc_data.txt — Tab-delimited analysis data
  • summary.txt — PASS/WARN/FAIL per module
  • Icons/ — Status icons
  • Images/ — SVG graphs

A built-in Rust reimplementation of Trim Galore (by Felix Krueger), wrapping Cutadapt for adapter and quality trimming. Requires Cutadapt to be installed separately.

# Single-end with adapter auto-detection
fastqc-rs trim-galore reads.fq.gz

# Paired-end with custom cutadapt path
fastqc-rs trim-galore --paired --path-to-cutadapt /opt/bin/cutadapt \
  R1.fq.gz R2.fq.gz

# Illumina adapter, quality 30, min length 50, 4 cores
fastqc-rs trim-galore --illumina -q 30 --length 50 -j 4 -o trimmed/ reads.fq.gz

# Hard-trim to first 75bp
fastqc-rs trim-galore --hardtrim5 75 reads.fq.gz

# See all options
fastqc-rs trim-galore --help

Key options:

Benchmarked on a paired-end Illumina dataset (~1.15 GB / ~1.20 GB gzipped FASTQ, ~9.9M reads x 150bp):

Optimizations applied: zlib-rs decompression backend, reader/processor pipeline (overlapping I/O with compute), AHashMap for hot-path modules, in-place ASCII uppercase, 256KB I/O buffer, LTO + codegen-units=1.

Tested on Linux 6.6 (WSL2). Pipeline uses 2 threads (reader + processor). CPU utilization ~117%. Bottleneck is module processing (~85% of wall time).

Added data-parallel architecture: 1 reader thread + 4 worker threads, each with independent module copies. Workers process sequence subsets in parallel, results merged after completion.

This version was fast, but not output-compatible. Multi-threaded duplication tracking changed the original FastQC semantics, and per-sequence quality bucketing still used Rust-side rounding instead of Java truncation.

Keeps the 1 reader + 4 worker architecture, but moves duplication tracking back to the reader thread so it preserves original file order. Also restores Java-compatible per-sequence quality bucketing and more closely matches Java number formatting.

Tested on Linux 6.6 (WSL2). Uses 5 threads total (1 reader + 4 workers). summary.txt matches Java FastQC exactly, Per sequence quality scores matches exactly, and Sequence Duplication Levels now differs only in floating-point tail digits.

Tested on Intel i9-13900K (8C/16T), Linux 6.6 (WSL2), all runs with cold disk cache (echo 3 > /proc/sys/vm/drop_caches).

Illumina short reads (~9.9M reads x 150bp per file):

ONT long reads (500K reads, variable length 200bp–150kbp, 3.99 GB gz):

Note on Java memory: FastQC (Java) defaults to 512 MB heap and will OOM on large ONT datasets. The benchmark used --memory 5120 (5 GB) for the ONT test. fastqc-rs has no such limitation — memory usage scales automatically.

Output format is compatible with Java FastQC v0.12.1:

• summary.txt — identical (PASS/WARN/FAIL per module match exactly)
• fastqc_data.txt — nearly identical with minor differences:
  • Per sequence quality scores: Matches Java FastQC exactly after restoring Java-style truncation for per-read mean quality.
  • Sequence Duplication Levels: PASS/WARN/FAIL status matches exactly; remaining differences are limited to floating-point tail digits in the deduplicated percentage and related percentages.
  • Number formatting: Small and large values are formatted closer to Java style, including scientific notation where applicable.
  • Floating-point precision: Some modules still differ only in the last 1-2 digits due to f64 vs Java double rounding.
• Modules with identical or effectively identical data: Basic Statistics, Per Base Sequence Quality, Per Sequence Quality Scores, Per Sequence GC Content, Sequence Length Distribution, Overrepresented Sequences, Sequence Duplication Levels
• Same module ordering and threshold logic
• Same CLI flags (with minor naming convention differences for multi-word flags)

If you use this project in academic work, please cite the original FastQC release/publication.

This project is licensed under the GNU General Public License v3.0 (GPL-3.0), consistent with the original FastQC project it rewrites.

• FastQC by Simon Andrews at the Babraham Institute
• Trim Galore by Felix Krueger