Installing and Managing Global Tools

Learn how to install and manage command-line tools globally with pixi global, making them available system-wide.

Learn how to install and manage command-line tools globally with pixi global, making development tools available system-wide without environment conflicts.

What are Global Tools?

Global tools are command-line applications installed system-wide, available from any directory. With pixi global, you can:

• Install tools in isolated environments
• Avoid dependency conflicts between tools
• Share tools across all your projects
• Install GUI applications with start menu entries

pixi global is similar to pipx for Python tools, but works with any conda package.

Basic Installation

1. Install a Single Tool
2. Install a tool with a single command:
3. pixi global install rattler-build
   

4. This installs rattler-build in an isolated environment and exposes its executable to your system PATH.
5. Verify the installation:
6. rattler-build --version
   

7. Check Installed Tools
8. List all globally installed tools:
9. pixi global list
   

10. Example Output:
11. Environment: rattler-build
      Package         Version    Channel
      rattler-build   0.18.0     conda-forge
      Exposed:
        - rattler-build
    

12. Uninstall a Tool
13. Remove a tool when no longer needed:
14. pixi global remove rattler-build
    

Isolated Environments

By default, each tool gets its own environment, preventing dependency conflicts:

# Each tool in its own environment
pixi global install git
pixi global install vim
pixi global install ripgrep

This creates separate environments:

~/.pixi/envs/
├── git/
├── vim/
└── ripgrep/

Isolation means removing one tool never breaks another, unlike traditional package managers.

Installing Tools Together

Tools with Dependencies

Sometimes tools work better together. Install multiple tools in one environment:

pixi global install ipython --with numpy --with matplotlib

This installs:

• ipython (exposed to PATH)
• numpy (available in ipython, not exposed)
• matplotlib (available in ipython, not exposed)

Test it works:

ipython -c 'import numpy; import matplotlib; print("Success!")'

Expected Output:

Success!

Data Science Environment

Create a complete data science environment:

pixi global install --environment data-science \
  --expose jupyter \
  --expose ipython \
  jupyter numpy pandas matplotlib ipython scikit-learn

This creates one environment with multiple exposed tools:

jupyter lab
ipython

Managing Multiple Versions

Install Different Versions

Install multiple versions of the same tool:

# Python 3.11
pixi global install --expose py311=python "python=3.11"

# Python 3.12
pixi global install --expose py312=python "python=3.12"

# Python 3.13
pixi global install --expose py313=python "python=3.13"

Now you can use any version:

py311 --version  # Python 3.11.x
py312 --version  # Python 3.12.x
py313 --version  # Python 3.13.x

Custom Executable Names

Expose tools under custom names:

pixi global install --expose bird=bat bat

Now run bat as bird:

bird --version

Installing from Source

From Local Directory

Install a package from local source:

pixi global install --path /path/to/my-tool

The directory must contain a pixi.toml or pyproject.toml with package metadata:

[package]
name = "my-tool"
version = "0.1.0"

[package.build]
backend = { name = "pixi-build-cmake", version = "*" }

From Git Repository

Install directly from a Git repository:

pixi global install --git https://github.com/org/tool.git

Install from a specific branch:

pixi global install --git https://github.com/org/tool.git --branch develop

Multi-Output Packages

If a source has multiple outputs, specify which one:

pixi global install --path /path/to/package foobar

Installing Multiple Tools

Install Several Tools at Once

Install multiple independent tools:

pixi global install pixi-pack rattler-build ruff

This creates separate environments for each:

[envs.pixi-pack]
channels = ["conda-forge"]
dependencies = { pixi-pack = "*" }
exposed = { pixi-pack = "pixi-pack" }

[envs.rattler-build]
channels = ["conda-forge"]
dependencies = { rattler-build = "*" }
exposed = { rattler-build = "rattler-build" }

[envs.ruff]
channels = ["conda-forge"]
dependencies = { ruff = "*" }
exposed = { ruff = "ruff" }

Create a Development Environment

Install all your development tools together:

pixi global install --environment dev \
  --expose git \
  --expose vim \
  --expose code \
  git vim vscode ripgrep fd

Platform-Specific Installation

Cross-Platform Tools

Install tools for a different platform:

# On ARM Mac, install x86_64 version
pixi global install --platform osx-64 python

The manifest shows the platform:

[envs.python]
channels = ["conda-forge"]
platforms = ["osx-64"]
dependencies = { python = "*" }

Shell Completions

Enable Completions

When you install tools via pixi global, completions are automatically installed to $PIXI_HOME/completions.

Bash

Add to ~/.bashrc:

for file in ~/.pixi/completions/bash/*; do
    [ -e "$file" ] && source "$file"
done

Zsh

Add to ~/.zshrc:

fpath+=(~/.pixi/completions/zsh)
autoload -Uz compinit
compinit

Fish

Add to ~/.config/fish/config.fish:

for file in ~/.pixi/completions/fish/*
    source $file
end

Restart your shell or source the config file:

source ~/.bashrc  # or ~/.zshrc or ~/.config/fish/config.fish

Completions are only installed for tools whose binaries are exposed under their original names.

Managing Environments

Add Dependencies to Environment

Add packages to an existing environment:

pixi global add --environment data-science seaborn plotly

This adds dependencies without auto-exposing their executables.

Remove Dependencies

Remove packages from an environment:

pixi global remove --environment data-science plotly

View Environment Details

See what’s in an environment:

pixi global list

The Global Manifest

Manifest Location

The global manifest stores all your installed tools:

• Linux/macOS: ~/.pixi/manifests/pixi-global.toml
• Windows: %USERPROFILE%\.pixi\manifests\pixi-global.toml

Find your manifest location:

pixi info

Manifest Structure

Example manifest:

version = 1

[envs.rattler-build]
channels = ["conda-forge"]
dependencies = { rattler-build = "*" }
exposed = { rattler-build = "rattler-build" }

[envs.ipython]
channels = ["conda-forge"]
dependencies = { ipython = "*", numpy = "*", matplotlib = "*" }
exposed = { ipython = "ipython", ipython3 = "ipython3" }

[envs.python]
channels = ["conda-forge"]
dependencies = { python = "3.12.*" }
exposed = { py3 = "python" }

Share Your Manifest

You can:

• Check the manifest into version control
• Share it with team members
• Edit it directly (then run pixi global sync)

# After editing the manifest
pixi global sync

GUI Applications

Install Applications with GUIs

Some packages include GUI applications:

pixi global install mss

This:

• Installs the application
• Creates start menu entries (Windows/Linux)
• Adds to Launchpad (macOS)

The manifest includes:

[envs.mss]
channels = ["conda-forge"]
dependencies = { mss = "*" }
shortcuts = ["mss"]

Advanced Usage

Custom Channels

Install from specific channels:

pixi global install --channel conda-forge --channel bioconda snakemake

Version Constraints

Specify exact versions:

pixi global install "python<3.12"
pixi global install "nodejs=20"
pixi global install "gcc=12.3.0"

Nested Executables

Some tools have executables in subdirectories:

pixi global install dotnet --expose dotnet=dotnet\\dotnet

Common Use Cases

Development Tools

Install your essential development tools:

pixi global install git gh ripgrep fd bat exa
pixi global install --environment python-tools ruff mypy black isort

Build Tools

Install build and packaging tools:

pixi global install cmake ninja meson
pixi global install rattler-build pixi-pack

Data Science Tools

Install data science environments:

pixi global install --environment jupyter \
  --expose jupyter \
  --expose ipython \
  jupyter ipython numpy pandas matplotlib scikit-learn

Language Servers

Install language servers for your editor:

pixi global install pyright
pixi global install rust-analyzer
pixi global install typescript-language-server

Complete Example

Here’s a complete setup for a Python developer:

# Version control
pixi global install git gh

# Python tools
pixi global install --environment python-tools \
  --expose ruff \
  --expose black \
  --expose mypy \
  ruff black mypy isort

# Multiple Python versions
pixi global install --expose py311=python "python=3.11"
pixi global install --expose py312=python "python=3.12"
pixi global install --expose py313=python "python=3.13"

# Data science environment
pixi global install --environment jupyter \
  --expose jupyter \
  --expose ipython \
  jupyter ipython numpy pandas matplotlib scikit-learn

# Modern CLI tools
pixi global install ripgrep fd bat exa

# Build tools
pixi global install rattler-build pixi-pack

Best Practices

Use environments for related tools: Group tools that work together (like jupyter + numpy) in one environment.

Keep unrelated tools separate: Tools that don’t interact should be in separate environments to avoid conflicts.

Version your manifest: Commit your global manifest to a dotfiles repository for easy setup on new machines.

Use expose for multiple versions: Install different versions of tools using custom exposed names.

Troubleshooting

Tool Not Found

If a tool isn’t found after installation:

1. Check if it was exposed:

   pixi global list
   

2. Verify your PATH includes Pixi’s bin directory:

   echo $PATH | grep pixi
   

3. Restart your shell

Dependency Conflicts

If tools have conflicting dependencies, install them in separate environments:

# Instead of this (might conflict)
pixi global install tool-a tool-b

# Do this
pixi global install tool-a
pixi global install tool-b

Update All Tools

Update all globally installed tools:

pixi global update

Update a specific environment:

pixi global update --environment python-tools

Next Steps

• Learn about Python development with Pixi
• Set up multi-environment workspaces
• Explore pyproject.toml integration