Install Snakemake with Conda for Workflow Management (Apple Silicon)

Snakemake is a workflow management system: instead of running each analysis step by hand, you describe your pipeline as a set of rules in a plain-text file called a Snakefile, and Snakemake figures out the order, reruns only what changed, and can scale the same workflow from your laptop to a cluster. It is written in Python, and the rule syntax is basically Python with a Make-like flavor.

Because Snakemake ties together many other tools (aligners, callers, counters), you want it in its own tidy environment where its exact version and dependency stack are pinned and independent of your system Python. That is the whole philosophy of this series: the build you need lives inside the env, not scattered across your machine. In this guide we install it into a dedicated conda env on an Apple Silicon Mac and prove it works with a tiny one-rule workflow.

Prerequisites

You need a working conda first. If you have not set that up yet, follow the companion guide: Install Miniconda on Apple Silicon. This walkthrough was run on an Apple Silicon Mac (arm64), macOS 26.5.2, with conda 25.5.1 using the fast libmamba solver.

We install from the conda-forge and bioconda channels and deliberately pass --override-channels so conda never touches Anaconda's defaults channels — that sidesteps the Terms-of-Service prompt that otherwise blocks fresh installs.

TL;DR: copy-paste install

# one isolated env for Snakemake, conda-forge + bioconda only
conda create -y -n bu-snakemake \
  --override-channels -c conda-forge -c bioconda \
  snakemake-minimal

conda activate bu-snakemake
snakemake --version

That is it. Everything below explains what each piece does and shows the real output from this machine.

snakemake-minimal vs. the full snakemake

There are two packages on bioconda:

• snakemake-minimal — the core engine: rule parsing, the DAG scheduler, and job execution. Fewer dependencies, smaller env. This is what we install here, and it is all you need to author and run workflows.
• snakemake — the same core plus optional extras (report generation, remote-storage and cloud executor plugins). Pick this if you know you need HTML reports or built-in cloud/remote backends.

Start with snakemake-minimal. You can always add the extras later, or swap snakemake-minimal for snakemake in the command above.

Step-by-step: create the environment

Run the create command. Snakemake is a pure-Python noarch package, so the engine itself is architecture-independent; its compiled dependencies (the COIN-OR solver, pulp, pydantic-core, and so on) all resolve to native osx-arm64 builds:

conda create -y -n bu-snakemake \
  --override-channels -c conda-forge -c bioconda \
  snakemake-minimal

The solver reports the platform, plans the transaction, and installs. Trimmed real output from this machine:

Channels:
 - conda-forge
 - bioconda
Platform: osx-arm64
Collecting package metadata (repodata.json): done
Solving environment: done

The following NEW packages will be INSTALLED:
  ...
  pulp               conda-forge/osx-arm64::pulp-2.8.0-py314h676fd1f_3
  python             conda-forge/osx-arm64::python-3.14.6-h156bc91_100_cp314
  snakemake-interfa~ bioconda/noarch::snakemake-interface-common-1.23.0-pyhdfd78af_1
  snakemake-minimal  bioconda/noarch::snakemake-minimal-9.23.1-pyhdfd78af_1
  ...
                                           Total:         7.4 MB
Preparing transaction: done
Verifying transaction: done
Executing transaction: done
#
# To activate this environment, use
#
#     $ conda activate bu-snakemake
#
real 22.83

A few things to read off that log:

• Platform: osx-arm64 confirms we are solving natively for Apple Silicon.
• snakemake-minimal-9.23.1 from bioconda is the engine version we now have pinned in this env.
• The download was 7.4 MB; the installed env is about 216 MB on disk (measured with du -sh; because conda hardlinks shared packages, the incremental cost of an extra env is usually less).
• The whole create took 22.83 seconds of wall-clock time here, thanks to the libmamba solver.

Apple Silicon / architecture note

You do not need Rosetta 2 for Snakemake. The engine is noarch (the same file installs on osx-arm64, osx-64, and linux-64), and every compiled dependency in this env ships a native osx-arm64 build — you can see conda-forge/osx-arm64::... on lines like pulp and python above. So Snakemake runs at full native speed on M-series chips.

The one place osx-64 / Rosetta can still come up is inside a workflow: if you run with --sw-deployment-method conda (older Snakemake: --use-conda) and one downstream bioinformatics tool has no arm64 build, create just that tool's env under emulation with CONDA_SUBDIR=osx-64 conda create .... Snakemake itself stays native either way.

Verify the install

Activate the env and check the version:

conda activate bu-snakemake
snakemake --version

This reports 9.23.1 — the exact snakemake-minimal build the install log pinned into the env.

Now a real smoke test: a one-rule workflow. Create a folder, drop in a Snakefile with a single rule named hello whose output is hi.txt, and run it. In Snakemake 8 and 9 the --cores flag is mandatory:

mkdir -p ~/sm-smoke && cd ~/sm-smoke
cat > Snakefile <<'EOF'
rule hello:
    output:
        "hi.txt"
    shell:
        "echo hello world > {output}"
EOF

snakemake --cores 1

Snakemake builds the dependency graph, sees hi.txt is missing, and runs the rule. Trimmed real output:

    jobid: 0
    reason: Missing output files: hi.txt
[Mon Jul 20 06:35:55 2026]
Finished jobid: 0 (Rule: hello)
1 of 1 steps (100%) done

1 of 1 steps (100%) done is exactly what you want to see. Confirm the file was created:

cat hi.txt

You will get hello world. Run snakemake --cores 1 again and Snakemake will report there is nothing to do — because hi.txt already exists and nothing it depends on changed. That "only rerun what changed" behavior is the entire point of a workflow manager.

Common errors and fixes

Managing the environment

Update Snakemake later, within the same isolated env:

conda update -n bu-snakemake \
  --override-channels -c conda-forge -c bioconda \
  snakemake-minimal

Snapshot the exact env so a collaborator (or future you) can reproduce it:

conda env export -n bu-snakemake > snakemake-env.yaml

And if you ever want to start clean, remove the whole env in one go:

conda remove -n bu-snakemake --all

Because everything lives inside bu-snakemake, removing it leaves the rest of your system untouched — no dangling binaries, no polluted system Python.

Next steps

With the engine installed, the natural next move is to give your workflow real tools to orchestrate. Point Snakemake rules at aligners and callers you install the same isolated way:

• Install samtools and bcftools
• Install Nextflow — the other major workflow manager, if you want to compare approaches