# How to Install Miniconda and Set Up Bioconda for Bioinformatics

Bioconda is a community channel that packages bioinformatics software for the Conda package manager. It currently provides over 12,000 bioinformatics packages for Conda and Pixi [1]. If you have ever lost an afternoon to compiling samtools from source or chasing down a missing htslib, Bioconda is the fix: one command installs the tool and its compiled dependencies, on Linux or macOS, without administrator privileges.

By the end of this guide you will have a working conda installation, the Bioconda channels configured in the documented order, a dedicated environment containing samtools, and an exported environment file you can use to rebuild the same setup on another machine. The commands below are the ones Bioconda and the conda documentation actually recommend, in the order they recommend running them.

## Quick Answer

- Install a conda distribution. Miniforge is the simplest choice because it ships with conda-forge preconfigured and includes mamba [3].
- Run the three Bioconda setup commands exactly once, in this order: `conda config --add channels bioconda`, then `conda config --add channels conda-forge`, then `conda config --set channel_priority strict` [1].
- Create one environment per project or per tool set: `conda create -n samtools-env samtools` [6].
- Activate it with `conda activate samtools-env`, then check the tool with `samtools --version` [6].
- Record the environment with `conda env export --no-builds > environment.yml` so it can be rebuilt later [2].
- Windows is not supported by Bioconda [2]. The usual workaround, common practice that the Bioconda docs do not cover, is to use WSL and install Miniforge inside the Linux distribution.

## Step 1: Choose an Installer (Miniconda vs Anaconda vs Miniforge)

Conda is the package manager. Everything else is a distribution that bundles conda with different defaults. The Bioconda FAQ draws the lines clearly: Miniconda "just has conda and its dependencies," while Anaconda is "a large installation including Python, conda, and a large number of packages" [2]. Miniforge "is like miniconda, but with the conda-forge channel preconfigured and all packages coming from the conda-forge and not the defaults channel" [2].

For bioinformatics work, Miniforge is usually the right starting point. It installs mamba by default (since Miniforge 23.3.1) and includes conda's libmamba solver [3]. Mamba is "a drop-in replacement for conda" [2], though current conda releases already use the fast libmamba dependency solver, so installing mamba purely for solve speed is no longer necessary [2].

Two notes before you download anything. Mambaforge is deprecated: it was announced in July 2024 and retired after January 2025, and users should switch to Miniforge3 [3]. And if you are on an Intel Mac, be aware that Anaconda stopped building packages for osx-64 on August 15, 2025, with 25.7.x as the final release line [5]. That applies to Anaconda's own channel, not to Bioconda or conda-forge.

If your institution requires Miniconda specifically, that works too. Miniconda contains "only conda, Python, and their dependencies" [4]. Just remember that Miniconda's use is governed by the separate Miniconda End User License Agreement, and Anaconda's Terms of Service (dated July 15, 2025) allow free use of Anaconda's platform and repository for individuals using it for personal, non-commercial purposes, eligible academic institutions, eligible non-profit and research organizations, and for-profit organizations with 200 or fewer employees; larger for-profit organizations need a paid plan [7]. Read the current terms yourself if you are installing on a work machine.

## Step 2: Install Miniforge or Miniconda

### Miniforge on Linux, macOS or WSL

The Miniforge README gives a two-line install that works on both Linux and macOS:

```bash
curl -L -O "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
bash Miniforge3-$(uname)-$(uname -m).sh
```

Answer the prompts and allow shell initialization. Then close and reopen the terminal. If you see `conda: command not found` afterward, run conda init with the full path and restart the shell [3]:

```bash
~/miniforge3/bin/conda init
```

### Miniconda on Linux

The Anaconda documentation uses this sequence. Download the installer, optionally verify the checksum, then run it [4]:

```bash
curl -O https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
sha256sum Miniconda3-latest-Linux-x86_64.sh
bash ~/Miniconda3-latest-Linux-x86_64.sh
```

During the installer you press Return to review the EULA and type `yes` to agree. Afterwards, refresh the shell with `source ~/.bashrc` (or `source ~/.zshrc`), or close and reopen the terminal. You should see `(base)` in your prompt [4]. Verify the install with `conda list`, which prints the installed packages [4].

### Miniconda on Apple Silicon

The macOS command line instructions use the arm64 installer and zsh [5]:

```bash
curl -O https://repo.anaconda.com/miniconda/Miniconda3-latest-MacOSX-arm64.sh
bash ~/Miniconda3-latest-MacOSX-arm64.sh
source ~/.zshrc
```

Apple M1, M2 and M3 chips are treated as aarch64 or arm64, which conda calls the osx-arm64 platform [2].

### Windows

Bioconda states plainly that Windows is not supported [2]. The standard workaround is to install WSL (`wsl --install`) and then install Miniforge inside the Linux distribution. That is general practice, not a Bioconda-documented instruction, so treat it as a community convention. If you do install Miniforge natively on Windows, the README says to download and run `Miniforge3-Windows-x86_64.exe` and use the "Miniforge Prompt" from the Start menu [3]. That native install will not give you Bioconda packages.

## Step 3: Run the One-Time Bioconda Channel Setup

This is the part people get wrong. Bioconda's documented setup is three commands, run in this order [1]:

```bash
conda config --add channels bioconda
conda config --add channels conda-forge
conda config --set channel_priority strict
```

Why this order? Each `--add` puts the channel at the top of the list. Running bioconda first and conda-forge second leaves conda-forge as the highest priority channel, with bioconda next. That is the intended arrangement, because conda-forge supplies the shared dependencies and Bioconda supplies the biology-specific packages. These commands modify your `~/.condarc` file [1].

One historical detail matters here. Bioconda notes that "In August 2024, the defaults channel was removed from the recommended set of channels" [1]. Older tutorials that tell you to add `defaults` are out of date, and the old page at `bioconda.github.io/user/install.html` still shows it. Do not use that page.

If you would rather not change global settings at all, Bioconda documents a per-command form that passes channels explicitly [1]:

```bash
conda create -n qc fastqc multiqc --channel conda-forge --channel bioconda --strict-channel-priority
```

This is a good option on shared servers where you do not want to touch a global configuration.

## Step 4: Create an Environment and Install a Tool

Install the programs you need together, not one at a time. The conda documentation warns that "Installing one program at a time can lead to dependency conflicts" and recommends installing the programs you need together [6]. A dedicated environment per project also keeps the solver fast: fewer packages means less work for the solver [2].

```bash
conda create -n samtools-env samtools
conda activate samtools-env
samtools --version
conda list samtools
```

The `conda create -n myenv python=3.9 scipy` pattern from the conda docs shows the general form: name the environment with `-n`, then list the packages [6]. Activate with `conda activate myenv` and leave with `conda deactivate` [6].

Bioconda currently supports Python 3.10, 3.11, 3.12 and 3.13 [2]. If a tool needs a specific Python version, pin it at creation time, not after the fact.

You can also keep an environment inside a project folder, which is useful when you want the environment to travel with the code [2]:

```bash
conda create -p ./env --file requirements.txt
conda activate ./env
```

Listing environments works with either `conda env list` or `conda info --envs`, and you can inspect packages in a named environment with `conda list -n myenv` [6].

## Step 5: Record and Rebuild the Environment

An environment you cannot rebuild is not reproducible. Wilson et al. (2017) recommend making dependencies and requirements explicit, for example with a requirements file in the project root [9]. Bioconda recommends `conda env export --no-builds` because build numbers can change independently of package versions [2]:

```bash
conda env export --no-builds > environment.yml
```

On another machine, current conda docs show this form [6]:

```bash
conda create --file environment.yml
```

Older conda releases still use `conda env create -f environment.yml`, which the current docs describe as the previous way to do it [6]. Check `conda --version` if you are unsure which applies. Newer conda also offers `conda export --name myenv --format=environment-yaml`, and `--from-history` exports only the packages you explicitly installed [6].

A minimal environment file looks like this [6]:

```text
name: myenv
channels:
  - conda-forge
dependencies:
  - python
  - numpy
```

When you combine conda and pip, use an isolated conda environment, install the conda packages first, then pip [6]. Mixing the two in the base environment is a common source of broken solves.

## Worked Example

Goal: a dedicated environment with samtools on Linux, macOS or WSL.

**1. Install Miniforge.**

```bash
curl -L -O "https://github.com/conda-forge/miniforge/releases/latest/download/Miniforge3-$(uname)-$(uname -m).sh"
bash Miniforge3-$(uname)-$(uname -m).sh
```

Answer the prompts, allow shell initialization, then close and reopen the terminal. If the shell then reports `conda: command not found`, run `~/miniforge3/bin/conda init` and restart the shell.

**2. One-time Bioconda channel setup, in the exact order from bioconda.github.io.**

```bash
conda config --add channels bioconda
conda config --add channels conda-forge
conda config --set channel_priority strict
```

**3. Create and use an environment per tool.**

```bash
conda create -n samtools-env samtools
conda activate samtools-env
samtools --version
conda list samtools
```

Or without changing global settings, using Bioconda's documented form:

```bash
conda create -n qc fastqc multiqc --channel conda-forge --channel bioconda --strict-channel-priority
```

**4. Record and rebuild.**

```bash
conda env export --no-builds > environment.yml
```

On the other machine, current conda docs rebuild the environment with:

```bash
conda create --file environment.yml
```

Older conda releases use `conda env create -f environment.yml` instead.

Expected result: the samtools recipe page on Bioconda listed samtools 1.24 (build 1) on 2026-10-01, available for linux-64, linux-aarch64, osx-64 and osx-arm64. So `samtools --version` should print a first line beginning `samtools 1.24`, or whatever newer version the solver picks, followed by lines naming the htslib version and copyright.

Once you have a reference FASTA file in hand, the [FASTA Parser](/tools/fasta-parser) on this site is a quick way to sanity-check reference sequences before you index them.

## Common Mistakes and How to Fix Them

- **`PackagesNotFoundError`.** The solver cannot find the package. The usual causes are missing channels (you skipped the Bioconda setup) or an unsupported platform, such as Windows or an architecture the recipe was never built for. Run the three setup commands, confirm you are on Linux or macOS, and check the recipe page for your platform.
- **`conda: command not found` after installing Miniforge.** Shell initialization did not run. On Windows, run `conda init` from the Miniforge Prompt. On Unix, run `~/miniforge3/bin/conda init` and restart the shell [3].
- **Slow solves.** The base environment has grown large, or you are installing packages one at a time. Keep base small, use smaller environments, and set `conda config --set channel_priority strict` [2].
- **Dependency conflicts.** Installing tools sequentially lets the solver make choices it later has to undo. Install the programs you need together in one `conda create` command [6].
- **Using the old install page.** The page at `bioconda.github.io/user/install.html` still lists the defaults channel, which Bioconda removed from its recommended set in August 2024 [1]. Use the current Bioconda documentation instead.
- **Mixing pip and conda carelessly.** Install conda packages first, then pip, and keep the whole thing inside an isolated environment [6].
- **Assuming `conda env create -f` is universal.** Current conda docs show `conda create --file environment.yml`; older releases use the `conda env create` form [6]. Check your conda version.

## Limitations

Bioconda does not support Windows [2]. WSL is the practical route, but the Bioconda docs do not cover it. On Apple silicon, Bioconda lists osx-arm64 as supported, yet some older recipes may only exist for osx-64. A `CONDA_SUBDIR=osx-64` workaround under Rosetta is widely discussed in community forums, but it does not appear in the Bioconda documentation, so treat it as unverified and check the recipe page first.

Version numbers move. Bioconda's samtools recipe showed 1.24 (build 1) and the conda documentation showed 26.7.4.dev161 when checked on 2026-10-01, and the solver will install the newest compatible version, which may differ from the one named here. Check the download page for the current release. Anaconda's decision to stop building Intel Mac packages after August 15, 2025 concerns Anaconda's own channel, not Bioconda or conda-forge [5].

Licensing is a separate question from technical setup. Anaconda's Terms of Service govern Anaconda's platform and repository, and the page does not mention conda-forge [7]. Organizations should read the current terms themselves. Nothing here is legal advice.

Finally, an environment file records software, not data or analysis code. It will not capture the reference genome version, the sample sheet or the parameters you passed to a tool. Those belong in your project repository alongside the environment file.

## Frequently Asked Questions

### What is the difference between Miniconda and Anaconda?

Miniconda contains only conda, Python and their dependencies, while Anaconda Distribution bundles the conda package manager and 600+ packages [4]. For bioinformatics, the extra packages in Anaconda are mostly irrelevant and make the base environment slower to solve. Miniconda or Miniforge keeps things lean.

### Should I use Miniforge instead of Miniconda?

Miniforge is a minimal installer for Conda and Mamba specific to conda-forge, with conda-forge as the default channel, and it supports x86_64, ppc64le, aarch64 and Apple silicon [3]. It installs mamba by default since version 23.3.1 and includes conda's libmamba solver [3]. Since Bioconda depends on conda-forge for shared dependencies, Miniforge aligns with that setup out of the box.

### Do I still need mamba?

Not for solve speed. Current conda releases use the fast libmamba dependency solver, which can be set with `conda config --set solver libmamba`, and installing mamba is no longer necessary merely to improve solve speed [2]. Mamba remains a drop-in replacement for conda [2], and some people prefer its output formatting.

### How do I install Bioconda packages without changing my global config?

Pass the channels on the command line instead. Bioconda's documented example is `conda create -n myenv samtools bwa --channel conda-forge --channel bioconda --strict-channel-priority` [1]. This leaves `~/.condarc` untouched, which matters on shared servers where other users depend on the existing configuration.

### Which platforms and Python versions does Bioconda support?

Bioconda supports Linux on x86_64 and aarch64/arm64, and macOS on x86_64 and arm64. Windows is not supported [2]. Python 3.10, 3.11, 3.12 and 3.13 are currently supported [2]. If you need an older Python, check whether the specific recipe still builds for it.

## References

1. [Bioconda documentation: Usage and channel setup](https://bioconda.github.io/)
2. [Bioconda FAQs](https://bioconda.github.io/faqs.html)
3. [conda-forge/miniforge README (GitHub)](https://github.com/conda-forge/miniforge)
4. [Anaconda Docs: Installing Miniconda on Linux](https://www.anaconda.com/docs/getting-started/miniconda/install/linux-install)
5. [Anaconda Docs: Installing Miniconda on macOS (command line)](https://www.anaconda.com/docs/getting-started/miniconda/install/mac-cli-install)
6. [conda docs: Managing environments](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html)
7. [Anaconda Terms of Service](https://www.anaconda.com/pricing/terms-of-service-faqs)
8. [Grüning B et al. Bioconda: sustainable and comprehensive software distribution for the life sciences. Nat Methods. 2018;15(7):475-476](https://doi.org/10.1038/s41592-018-0046-7)
9. [Wilson G et al. Good enough practices in scientific computing. PLOS Comput Biol. 2017;13(6):e1005510](https://doi.org/10.1371/journal.pcbi.1005510)

## Related Articles

- [Conda Environments for Bioinformatics: Managing Tools Without Version Drift](/blog/guides/conda-environments-for-bioinformatics-managing-tools-without-version-drift)
- [From Reads to Reproducible Assembly: A Complete Workflow with Snakemake, Conda, and Git](/knowledge/bioinformatics/from-reads-to-reproducible-assembly-a-complete-workflow-with-snakemake-conda-and-git)
- [Snakemake vs. Nextflow for Genome Assembly Pipelines: A Comparative Guide to Workflow Managers](/knowledge/bioinformatics/snakemake-vs-nextflow-for-genome-assembly-pipelines-a-comparative-guide-to-workflow-managers)
- [Docker and Containerization in Reproducible Research](/knowledge/bioinformatics/docker-and-containerization-in-reproducible-research)
- [How to Use Google Colab for Bioinformatics: Python, Shell Commands and Google Drive](/blog/research-skills/how-to-use-google-colab-for-bioinformatics)
- [How to Install R Packages from CRAN, Bioconductor and GitHub (and Fix Install Errors)](/blog/research-skills/how-to-install-r-packages-cran-bioconductor-github)