How to Install Miniconda on macOS (Apple Silicon): A Beginner's Guide

If you are starting out in bioinformatics on a Mac, the single most useful thing you can do is install conda and learn to create one isolated environment per tool. Almost every guide in this series builds on that idea, so this is the foundation post: we install Miniconda, wire up the free community channels, and set up the habit that keeps your projects from breaking each other.

Miniconda is a minimal, free installer that gives you two things: the conda package-and-environment manager, and a small base Python. From that base you spin up self-contained environments. That matters because bioinformatics tools are famously picky about versions -- samtools 1.21 here, an older Python there, a C library pinned somewhere else. Instead of fighting those conflicts on one shared system, you put each tool in its own environment. The exact build you need lives inside the environment, independent of your system. That isolation is the whole philosophy this series runs on.

Why isolate everything?

Imagine installing five tools system-wide and having tool #3 quietly downgrade a library that tool #1 depended on. Now tool #1 is broken and you have no idea why. Conda environments make that impossible: each environment is a separate folder with its own copies of everything. Break one, delete it, rebuild it in a minute -- nothing else notices.

The rule we follow throughout the series is simple: one tool, one environment. It costs a little disk space and pays you back in reproducibility and peace of mind.

Prerequisites

• An Apple Silicon Mac (M1/M2/M3/M4). This guide targets arm64.
• macOS 12.1 or newer (Miniconda's Apple Silicon build requires it).
• A terminal. macOS ships with zsh as the default shell, which matters when we run conda init.
• Roughly 5 minutes and a few hundred MB of disk.

TL;DR: copy-paste install

If you just want conda working, run this block in Terminal. Explanations follow below.

# 1. Download the native Apple Silicon (arm64) installer
mkdir -p ~/miniconda3
curl -fL https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh -o ~/miniconda3/miniconda.sh

# 2. Install silently (-b no prompts, -p prefix, -u update if re-running)
bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3

# 3. Remove the installer
rm ~/miniconda3/miniconda.sh

# 4. Wire conda into your shell (macOS default is zsh)
source ~/miniconda3/bin/activate
conda init --all

# 5. Open a NEW terminal so the (base) prompt appears, then set up free channels:
conda config --add channels bioconda
conda config --add channels conda-forge
conda config --set channel_priority strict

Now open a fresh terminal window and jump to Verify the install.

Step 1: Download the native arm64 installer

Always grab the arm64 installer on an Apple Silicon Mac -- not the Intel (x86_64) one. The -latest- in the filename always pulls the current release, so you never hardcode a version:

mkdir -p ~/miniconda3
curl -fL https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh -o ~/miniconda3/miniconda.sh

Prefer a graphical installer? Download the "Miniconda3 macOS Apple Silicon pkg" from the Anaconda download page and double-click it. As of 2026 the .pkg installers are signed and notarized, so macOS Gatekeeper will let them through.

Step 2: Run the installer

bash ~/miniconda3/miniconda.sh -b -u -p ~/miniconda3
rm ~/miniconda3/miniconda.sh

• -b runs in batch mode (no interactive prompts, auto-accepts the license).
• -p ~/miniconda3 sets the install location.
• -u updates an existing install if you re-run it, which makes the command safe to repeat.

Step 3: Wire conda into your shell

The installer copied files onto disk, but your shell does not know about conda yet. Activate the base environment once, then let conda init write the startup block into your shell config:

source ~/miniconda3/bin/activate
conda init --all

On macOS this writes an init block to ~/.zshrc (and ~/.bashrc if present). Open a new terminal -- or run exec zsh -- and you should see a (base) prefix on your prompt. That prefix is conda telling you which environment is active.

The Anaconda "defaults" Terms of Service gate (important)

Here is the one gotcha that trips up newcomers in 2026. Miniconda ships preconfigured to use Anaconda's defaults channels (pkgs/main, pkgs/r). Since July 15, 2025, those channels require you to accept Anaconda's Terms of Service. If you try to create an environment without accepting, conda stops you:

CondaToSNonInteractiveError: Terms of Service have not been accepted for channel
https://repo.anaconda.com/pkgs/main (and .../pkgs/r)

The clean, free way around this is to not use the defaults channels at all. The bioinformatics world lives on two community channels that have no such gate:

• conda-forge -- the huge community channel for general scientific software.
• bioconda -- thousands of bioinformatics tools, built on top of conda-forge.

Point conda at those and set strict priority so it resolves cleanly:

conda config --add channels bioconda
conda config --add channels conda-forge
conda config --set channel_priority strict
# Optional: drop the ToS-gated defaults entirely
conda config --remove channels defaults 2>/dev/null || true

Even better, throughout this series we create every environment with an explicit channel list plus --override-channels. That flag tells conda to use only the channels you name and ignore whatever is in your config -- so it never touches defaults, and the ToS prompt never appears:

conda create -y -n mytool --override-channels -c conda-forge -c bioconda sometool

Verify the install

Now the real, captured output from this machine. First, the version -- this is the exact conda we use for the entire series:

conda --version

conda 25.5.1

Next, conda info gives you the important internals. These are the key lines from our test machine:

          conda version : 25.5.1
         python version : 3.13.5.final.0
                 solver : libmamba (default)
       virtual packages : __archspec=1=x86_64
       base environment : /opt/homebrew/Caskroom/miniconda/base  (writable)
           channel URLs : https://repo.anaconda.com/pkgs/main/osx-64
               platform : osx-64
             user-agent : conda/25.5.1 requests/2.32.4 CPython/3.13.5 Darwin/25.5.0 OSX/26.5.2 solver/libmamba conda-libmamba-solver/25.4.0 libmambapy/2.0.5 aau/0.7.1 c/. s/. e/.

A few things worth reading here:

• solver : libmamba (default) -- since conda 23.10, conda uses the fast libmamba solver automatically. That is why environment solving is quick. You do not need to install anything extra.
• base environment : /opt/homebrew/Caskroom/miniconda/base -- on this machine conda was originally installed through a Homebrew cask, so it lives under /opt/homebrew. If you followed the official installer above, yours will be at ~/miniconda3 instead. The location does not change how conda behaves.
• platform : osx-64 and __archspec=1=x86_64 -- read the note just below.

Apple Silicon / architecture note

Notice this particular base reports platform : osx-64, not osx-arm64. That is because it was installed from an Intel build and runs under Apple's Rosetta 2 translation. It works fine, but it is not the recommended setup for a fresh install.

For a new Apple Silicon Mac you want a native arm64 base -- that is exactly why Step 1 downloads Miniconda3-latest-MacOSX-arm64.sh. A native install reports platform : osx-arm64, and native builds are faster and easier on the battery than emulated ones. Both conda-forge and bioconda publish osx-arm64 packages, and most mainstream bioinformatics tools now have native arm64 builds.

You can always check which architecture an environment is using:

conda info | grep platform
conda run -n myenv python -c "import platform; print(platform.machine())"

A native environment prints arm64. If a specific tool has no arm64 build on bioconda, the fix is not to switch your whole base -- it is to build just that one environment under emulation, which we cover in the errors table below.

Environment demo: create, inspect, export

Let's prove the isolation model with real output. We create a throwaway environment named demoenv with Python 3.12, pulling only from conda-forge:

conda create -y -n demoenv --override-channels -c conda-forge python=3.12

Check the Python inside it:

conda run -n demoenv python -V

Python 3.12.13

That 3.12.13 lives entirely inside demoenv. Your base Python (3.13.5 here) is untouched -- this is the isolation guarantee in action. List what conda actually installed:

conda list -n demoenv

bzip2                      1.0.8            hd037594_9          conda-forge
ca-certificates            2026.6.17        hbd8a1cb_0          conda-forge
libexpat                   2.8.1            hf6b4638_1          conda-forge
libffi                     3.5.2            hcf2aa1b_0          conda-forge
liblzma                    5.8.3            h8088a28_0          conda-forge
libsqlite                  3.53.3           h1b79a29_0          conda-forge

Notice every package's channel column reads conda-forge -- no defaults, exactly as intended. To share or reproduce an environment, export just the packages you explicitly asked for with --from-history:

conda env export -n demoenv --from-history

name: demoenv
channels:
  - defaults
dependencies:
  - python=3.12
prefix: /opt/homebrew/Caskroom/miniconda/base/envs/demoenv

Do not be thrown by that channels: - defaults line. --from-history records the packages you explicitly asked for but does not track which channels they actually came from, so it always prints the literal placeholder defaults regardless of where the packages were built. Our demoenv was created purely from conda-forge (see the channel column above), so when you recreate this file, add -c conda-forge (or edit the channels: list) rather than trusting that stray defaults entry.

To use this environment interactively in your own terminal, you activate it (rather than prefixing every command with conda run):

conda activate demoenv
# ... work ...
conda deactivate

You can see all your environments at any time:

conda env list

# conda environments:
#
base                   /opt/homebrew/Caskroom/miniconda/base
bu-aligners            /opt/homebrew/Caskroom/miniconda/base/envs/bu-aligners
bu-bedtools            /opt/homebrew/Caskroom/miniconda/base/envs/bu-bedtools
bu-blast               /opt/homebrew/Caskroom/miniconda/base/envs/bu-blast
bu-gatk4               /opt/homebrew/Caskroom/miniconda/base/envs/bu-gatk4
bu-nextflow            /opt/homebrew/Caskroom/miniconda/base/envs/bu-nextflow
bu-pymol               /opt/homebrew/Caskroom/miniconda/base/envs/bu-pymol
bu-rdkit               /opt/homebrew/Caskroom/miniconda/base/envs/bu-rdkit
bu-salmon              /opt/homebrew/Caskroom/miniconda/base/envs/bu-salmon
bu-samtools            /opt/homebrew/Caskroom/miniconda/base/envs/bu-samtools
bu-scanpy              /opt/homebrew/Caskroom/miniconda/base/envs/bu-scanpy
bu-snakemake           /opt/homebrew/Caskroom/miniconda/base/envs/bu-snakemake
bu-vina                /opt/homebrew/Caskroom/miniconda/base/envs/bu-vina
demoenv                /opt/homebrew/Caskroom/miniconda/base/envs/demoenv
mirna                  /opt/homebrew/Caskroom/miniconda/base/envs/mirna
mirnap                 /opt/homebrew/Caskroom/miniconda/base/envs/mirnap
pymol                  /opt/homebrew/Caskroom/miniconda/base/envs/pymol
rtest                  /opt/homebrew/Caskroom/miniconda/base/envs/rtest

Those bu-* environments are the per-tool environments built across this series -- one tool each, exactly the pattern you are learning here.

Common errors and fixes

Managing your environments

A quick reference for the everyday commands:

# Update conda itself (in base)
conda update -n base conda

# Update everything in an environment
conda update -n demoenv --all

# Save an environment to a shareable file
conda env export -n demoenv --from-history > demoenv.yml

# Recreate it elsewhere from that file
conda env create -f demoenv.yml

# Delete an environment completely when you are done
conda remove -n demoenv --all

# Free up disk from caches and unused tarballs
conda clean --all -y

Because each tool lives in its own environment, conda remove -n myenv --all is a safe undo button: it deletes that one environment and nothing else. When something breaks, delete and rebuild -- it takes a minute and never touches your other work.

Next steps

You now have a working, native conda on Apple Silicon and the isolation habit that the rest of this series depends on. From here:

• Go deeper on environments and channels in Conda environments and the bioconda channel explained.
• Install your first real tools with samtools and bcftools.

Prefer the full Anaconda distribution over Miniconda? See Installing Anaconda on macOS -- though for bioinformatics, the minimal Miniconda base plus per-tool environments you set up here is all you need.