DOCSEARCHbyAlgolia
Submit Docs

Mamba Package Manager

repository·main·Indexed 27 days ago

https://github.com/mamba-org/mamba

A fast, cross-platform package manager implemented in C++ as a high-performance alternative to conda. It features parallel downloading and dependency solving via libsolv. The project includes the full mamba installation, a lightweight standalone executable called micromamba, and the libmambapy Python library. Key capabilities include repoquery for dependency querying, conda-lock file installation, and a multi-layered artifact verification system.

Tokens
18.3K
Snippets
47
Records
110
Agent score
93%

What's inside Mamba

  1. Overview of Mamba components

    main

    Mamba is a fast, robust, and cross-platform package manager compatible with conda packages. It consists of several distinct components depending on your use case:

    • libmamba: A C++ library providing low-level and high-level APIs.
    • mamba: An ELF executable designed as a drop-in replacement for conda, built on top of libmamba.
    • micromamba: A statically linked version of mamba, optimized for CI (Continuous Integration) use cases.
    • libmambapy: Python bindings for libmamba.

    Mamba supports Windows, OS X, and Linux (including ARM64 and PPC64LE).

  2. Understand Mamba artifact verification layers

    main

    Mamba implements three layers of security verification to ensure the integrity of packages:

    1. Repodata verification (Experimental): Based on The Update Framework (TUF) specification. It uses asymmetric cryptographic keys to ensure that package tarball metadata (including size and checksums) in the repodata files is correct and trusted.
    2. Package tarball verification: Uses the metadata from a valid repodata to verify the integrity of the tarball after it is fetched from a repository.
    3. Package files verification: Verifies the individual files extracted from the tarball using the paths.json index. It checks file sizes and can perform SHA-256 checksum verification to prevent manual alteration or corruption of package contents.

  3. Understand Mamba Prefixes and Environments

    main

    In Mamba, a prefix (also called a target prefix) is a fully self-contained and portable installation directory. All files for a piece of software are placed within this prefix, and dependencies must be installed in the same prefix (or standard system prefixes with lower precedence).

    An environment is simply another name for a target prefix. Mamba environments function similarly to Python's virtualenv but are more powerful as they manage native dependencies across many programming languages.

  4. Understand Mamba's Core Architecture

    main

    Mamba is built with a high-performance C++ core and a Python API. The core relies on three primary libraries for its operations:

    • libsolv: Used for dependency solving (the same engine used by RedHat dnf).
    • curl: Used for fast and reliable downloads.
    • libarchive: Used to extract packages.

    This architecture allows Mamba to provide the speed of C++ while maintaining the ease of use of a Python-based interface.

  5. Understand Mamba repository and channel structures

    main

    Mamba uses a hierarchical structure to manage software packages:

    • Packages repository (repo): A generic storage location for software packages (e.g., a package server, a channel, or a subdir).
    • Channel: An independent and isolated repository structure used to classify and administrate a packages server.
    • Subdir: A channel subdirectory specific to a given operating system/platform pair (e.g., linux-64, osx-arm64, or win-64). Subdirs provide package tarballs and a packages index.
    • Packages index (repodata): A file (typically repodata.json) specific to a channel subdirectory that contains metadata about all package tarballs, such as licenses, file sizes, and checksums.

  6. Understand Mamba package formats and linking

    main

    Package Tarballs

    Mamba uses two conda formats for package tarballs:

    • tar.bz2: The historical format (a tar file compressed with bzip2).
    • conda: The more recent format that allows faster access to package metadata.

    Linking

    Linking is the process of creating a connection between the package cache (where tarballs are expanded) and the installation target prefix. Mamba supports three types of links:

    1. Hard-link: The most efficient method. It does not duplicate the underlying file and remains valid even if other links are moved/deleted. However, it requires filesystem support and cannot work across different partitions.
    2. Soft-link (symlink): A redirection/shortcut. It works across filesystem boundaries but becomes invalid if the target file is deleted or moved.
    3. Copy: A simple duplication of the file. It is the least resource-efficient but ensures the file is preserved regardless of the original reference.

  7. Use micromamba for lightweight package management

    main
    micromamba is a tiny, statically linked C++ executable version of the mamba package manager. Unlike the full mamba package, it does not require a base environment and does not include a default version of Python. It is particularly useful in CI and Docker environments because it can be used with subcommands like shell and run to avoid the complexities of shell activation hooks.

  8. Understand Mamba configuration precedence

    main

    Mamba configuration is derived from four primary sources. When multiple sources define the same configuration value, the precedence order determines the final value:

    1. CLI: Arguments or options passed via the command line (Highest precedence).
    2. API: Values set programmatically via an API.
    3. Environment Variables: Key/value pairs set in the environment (e.g., MAMBA_ALWAYS_YES).
    4. RC Files: YAML files stored on the filesystem (Lowest precedence).

    Resolution Rules:

    • Scalars (boolean, string): The value from the source with the highest precedence wins.
    • Sequences (lists): Values are appended from the highest precedence source to the lowest.

  9. Manage the Base Environment

    main

    The base environment is the environment located at the root prefix.

    • It contains the mamba and conda installations, along with a Python installation required to run them.
    • Because mamba and conda are installed in the base environment, their CLIs are available in all environments activated from this base.
    • Note: You cannot create the base environment as it is part of the root prefix structure; you must use install to add packages to it.

  10. Understand the Root Prefix and Package Cache

    main

    The root prefix serves as the central directory for shared resources. It contains:

    • Package Cache: Located at $root_prefix/pkgs/. This cache stores package indices and the packages themselves (often via hard-links) to speed up operations. The cache is shared across all environments based on the same root prefix.
    • Environments Directory: A standard location to store environments at $root_prefix/envs/, though environments can be created elsewhere.