Install FastQC and MultiQC on macOS (Apple Silicon) with conda

FastQC is the tool almost everyone runs first on raw sequencing data: point it at a FASTQ file and it hands back per-base quality plots, adapter content, GC distribution, and duplication levels. The catch is that a real project has dozens or hundreds of FASTQ files, and clicking through that many individual HTML reports gets old fast. MultiQC solves the second half of the problem by scanning a directory of FastQC (and other tool) outputs and collapsing them into one aggregated, sortable report.

This guide installs both into a single conda environment on an Apple Silicon Mac, runs FastQC on a real FASTQ file, and then aggregates the result with MultiQC.

What FastQC and MultiQC actually do

• FastQC reads one or more FASTQ (or aligned BAM) files and produces a per-file HTML report with a handful of QC modules: per-base sequence quality, per-sequence quality scores, GC content, sequence length distribution, overrepresented sequences, and adapter content, among others. Each module gets a green tick, an orange warning, or a red fail, based on FastQC's built-in thresholds.
• MultiQC does not do any QC itself. It searches a directory tree for the machine-readable output that FastQC (and dozens of other bioinformatics tools) writes alongside its HTML report, parses it, and stitches everything into one multiqc_report.html with per-sample rows so you can spot the one bad lane in a run of 96 samples at a glance.

Used together, the pattern is: run FastQC once per FASTQ file, then run MultiQC once over the whole output directory.

Prerequisites

You need a working conda install. If you don't have one yet, start with our Miniconda on Apple Silicon guide and come back here. This walkthrough assumes an Apple Silicon Mac (arm64) with conda's fast libmamba solver, and installs exclusively from conda-forge and bioconda with --override-channels so conda never falls back to the Anaconda defaults channel (which on recent conda versions is gated behind a Terms-of-Service prompt).

TL;DR: copy-paste install

conda create -n bu-qc --override-channels -c conda-forge -c bioconda fastqc multiqc
conda activate bu-qc
fastqc --version
multiqc --version

That's the whole install. The rest of this guide walks through why it works and shows what to expect at each step.

Step 1: Create an isolated environment with both tools

Give the tools their own environment rather than installing them into base. Since FastQC and MultiQC are almost always used as a pair, it's reasonable to put them in the same env.

conda create -n bu-qc --override-channels -c conda-forge -c bioconda fastqc multiqc

Conda will solve for both packages together. Watch the plan it prints before confirming: you should see fastqc come from bioconda along with an openjdk dependency, and multiqc come from bioconda as well, pulling in a chunk of Python packages (multiqc is a Python tool built on click, jinja2, pandas, and friends).

The following NEW packages will be INSTALLED:

  fastqc              bioconda/noarch::fastqc-0.12.1-hdfd78af_0
  multiqc              bioconda/noarch::multiqc-1.21-pyhdfd78af_0
  openjdk              conda-forge/osx-arm64::openjdk-...
  python               conda-forge/osx-arm64::python-3.x-...
  ...

(Exact build strings and dependency versions will differ depending on when you run this, since conda always solves for the latest compatible releases — treat the output above as illustrative of the shape, not a guarantee of specific numbers.)

Apple Silicon: noarch packages, and why that's good news here

Look for the noarch tag in the solver output rather than osx-arm64. Both fastqc and multiqc are published as noarch packages in bioconda:

noarch packages have no CPU-specific code at all, so there is no Rosetta 2 emulation risk and no "arm64 build not available yet" gotcha to worry about — unlike some bioinformatics tools that are still x86-64-only on bioconda. The only architecture-specific piece in this stack is the openjdk dependency that fastqc pulls in, and conda-forge ships that natively for osx-arm64, so the whole environment runs native on Apple Silicon.

Step 2: Verify the install

Activate the environment (every new shell needs this) and check both versions:

conda activate bu-qc
fastqc --version
multiqc --version

You should see something like:

FastQC v0.12.1
multiqc, version 1.21

Also confirm the JDK that FastQC depends on is actually reachable, since FastQC silently fails with a confusing error if Java isn't found:

java -version

If that prints an OpenJDK version banner, you're set. If instead you get command not found, double-check you activated bu-qc — the JDK lives inside the environment, not on your system PATH.

Step 3: Run FastQC on a real file

FastQC accepts one or more FASTQ files (gzipped is fine) and writes a .html report plus a .zip archive of the raw data next to each input, or into an output directory you specify with -o.

mkdir -p qc_results
fastqc -o qc_results sample_R1.fastq.gz sample_R2.fastq.gz

Started analysis of sample_R1.fastq.gz
Approx 5% complete for sample_R1.fastq.gz
Approx 10% complete for sample_R1.fastq.gz
...
Analysis complete for sample_R1.fastq.gz
Started analysis of sample_R2.fastq.gz
...
Analysis complete for sample_R2.fastq.gz

Each run produces sample_R1_fastqc.html (open it directly in a browser) and sample_R1_fastqc.zip, which contains the plain-text fastqc_data.txt that MultiQC will parse in the next step. For a whole sequencing run you'd loop this over every FASTQ file, or pass a glob directly since FastQC accepts multiple files on one command line:

fastqc -o qc_results *.fastq.gz

You can also hand it -t 4 (or however many cores you have) to process several files in parallel, since each file is QC'd independently.

Step 4: Aggregate everything with MultiQC

Once you have FastQC output for all your samples in one directory, point MultiQC at that directory. It walks the tree, recognizes the FastQC .zip files, and builds one combined report.

multiqc qc_results -o qc_results

  /// MultiQC | v1.21

|           multiqc | Search path : qc_results
|            fastqc | Found 2 reports
|           multiqc | Compressing plot data
|           multiqc | Report      : qc_results/multiqc_report.html
|           multiqc | Data        : qc_results/multiqc_data
|           multiqc | MultiQC complete

Open qc_results/multiqc_report.html and you'll see per-sample rows for sequence quality, GC content, adapter content, and duplication, plus a summary table that makes it easy to spot the one sample that looks different from the rest of the batch — the whole point of running QC before you commit to a full analysis. This same pattern extends beyond FastQC: MultiQC also recognizes output from aligners, quantifiers like Salmon, and variant callers, so a well-organized pipeline output directory can produce one report covering the entire run.

Common errors and fixes

Managing the environment

Update both tools in place:

conda update -n bu-qc --override-channels -c conda-forge -c bioconda fastqc multiqc

Export the environment so a collaborator (or your future self) can reproduce it exactly:

conda env export -n bu-qc > qc-env.yml

Remove it cleanly when you no longer need it:

conda remove -n bu-qc --all

Next steps

FastQC and MultiQC are usually the very first tools you run in any sequencing workflow, before alignment or quantification even start. From here:

• If your reads need trimming or adapter removal after reviewing the FastQC report, that typically happens before alignment with BWA/Bowtie2 or quantification with Salmon.
• For a broader look at how QC fits into the full pipeline, see RNA-Seq Analysis: From Raw Reads to Differential Expression.
• Once you're running FastQC and MultiQC across many samples on a schedule, a workflow manager like Nextflow or Snakemake will save you from re-typing these commands by hand.