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

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