Python Developer Tooling Handbook – Scientific Python

Anaconda: Python and R Data Science Platform

Tim Hopper — Tue, 28 Apr 2026 21:54:51 -0400

Anaconda Distribution is a pre-packaged Python and R data science platform maintained by Anaconda, Inc. It bundles the conda package manager, a Python interpreter, and over 1,500 scientific computing libraries into a single installer. The current release, Anaconda Distribution 2025.12, ships with Python 3.13.9 and conda 25.11.0.

Warning

Conda

Tim Hopper — Tue, 28 Apr 2026 21:54:51 -0400

Conda is a language-agnostic, cross-platform package and environment manager. Where pip installs Python packages from PyPI, conda resolves dependencies across Python, R, C/C++, Fortran, and other languages in a single dependency graph. The current stable release is 26.3.1 (March 2026).

Note

Conda Package

Tim Hopper — Tue, 28 Apr 2026 21:54:51 -0400

A conda package is a compressed archive containing pre-built binaries, library code, metadata, and dependency information for installation through conda channels. It serves the same role in the conda ecosystem that a wheel serves on PyPI, with one critical difference: conda packages can bundle software from any language (Python, R, C++, Fortran, Julia), not just Python.

Package Formats

The conda ecosystem recognizes two archive formats, referred to as v1 and v2.

conda-forge: Community Conda Package Channel

Tim Hopper — Tue, 28 Apr 2026 21:54:51 -0400

conda-forge is a community-maintained collection of conda packages distributed through a public channel on anaconda.org. Over 25,000 feedstocks (package repositories) produce builds for Linux, macOS, and Windows across multiple CPU architectures. Each feedstock contains a build recipe in its own GitHub repository, and automated infrastructure rebuilds packages when dependencies change or new platforms appear.

Note

Create your first Python project with pixi

Tim Hopper — Fri, 08 May 2026 18:28:25 -0400

This tutorial builds a weather data analysis tool that reads CSV data, computes statistics with pandas, and produces a chart with matplotlib. Every dependency comes from conda-forge and is managed by pixi.

Prerequisites

Install pixi following the official installation instructions. No separate Python install is required.

Create the project

$ pixi init weather_analysis
✔ Created /path/to/weather_analysis/pixi.toml
$ cd weather_analysis

If you see pixi: command not found, restart your shell so the installer’s PATH update takes effect, or follow the official installation instructions again.

How to Fix ModuleNotFoundError: No module named 'numpy' During pip Install

Tim Hopper — Wed, 13 May 2026 06:43:22 -0400

This guide helps resolve an issue where a Python package fails to install because it cannot find numpy, even though it is already installed in your virtual environment.

Problem

You’re trying to install a Python package using:

uv pip install git+https://github.com/example/examplepkg.git
# or
pip install .

Even though numpy is installed in your environment, the install fails with:

How to Install bitsandbytes

Tim Hopper — Wed, 13 May 2026 06:43:22 -0400

bitsandbytes provides 4-bit and 8-bit quantization for large language models, cutting GPU memory usage enough to run models that would otherwise not fit. Unlike PyTorch (see Why Installing GPU Python Packages Is So Complicated), bitsandbytes publishes platform-specific wheels to PyPI that bundle precompiled CUDA libraries for multiple toolkit versions. A plain pip install works on Linux, Windows, and macOS without extra index URLs.

Requirements

Python >= 3.10
PyTorch >= 2.3 (see How to Install PyTorch with uv)
NVIDIA GPU with compute capability 6.0+ for GPU quantization (Pascal or newer)
NVIDIA driver that supports CUDA 11.8 or later

bitsandbytes also supports CPU-only, AMD ROCm (preview), Intel XPU, and Apple Silicon. GPU quantization requires an NVIDIA GPU.

How to Install DeepSpeed

Tim Hopper — Wed, 13 May 2026 06:43:22 -0400

DeepSpeed publishes only a source distribution on PyPI, with no prebuilt wheels. The setup.py requires both PyTorch and a CUDA toolkit to generate metadata, so even a basic install needs CUDA_HOME set and nvcc on PATH. Once installed, individual ops (fused Adam, CPU offloading, transformer kernels) are compiled on first use through PyTorch’s JIT C++ extension system. See Why Installing GPU Python Packages Is So Complicated for background.

Requirements

Platform: Linux (x86_64). Windows has partial support through WSL2. No macOS GPU support.
Software: PyTorch already installed, a C++ compiler (gcc or g++), the CUDA toolkit with nvcc on PATH, and CUDA_HOME set to the toolkit root (e.g. /usr/local/cuda).
System libraries: libaio-dev is required for the async I/O op used by ZeRO-Infinity and NVMe offloading. Install it with apt install libaio-dev on Debian/Ubuntu.

Install from PyPI

DeepSpeed’s setup.py imports torch at the top level, so PyTorch must be present before installation. The --no-build-isolation flag tells the installer to use the current environment’s torch instead of creating a clean build environment:

How to Install Flash-Attention

Tim Hopper — Wed, 13 May 2026 06:43:22 -0400

PyPI has no wheels for flash-attn. Every pip install flash-attn triggers a from-source CUDA compilation that can take over two hours (see Why Installing GPU Python Packages Is So Complicated for background). Prebuilt wheels do exist on GitHub Releases, and the package’s setup.py can fetch them automatically if your environment matches.

Requirements

Platform: Linux on NVIDIA Ampere (A100, RTX 3090), Ada Lovelace (RTX 4090), or Hopper (H100). Windows has experimental support since v2.3.2. No macOS support.
Software: CUDA toolkit >=12.0 with nvcc on PATH, PyTorch >=2.2 already installed in the target environment.

Install with prebuilt wheels (recommended)

The flash-attn package includes a CachedWheelsCommand in its setup.py that tries to download a matching prebuilt wheel from GitHub Releases before falling back to compilation. The --no-build-isolation flag is required because setup.py imports torch and packaging at the top level. Both must be installed in the environment before running the install:

How to Install llama-cpp-python

Tim Hopper — Wed, 13 May 2026 06:43:22 -0400

PyPI has no prebuilt wheels for llama-cpp-python. A bare pip install downloads a source distribution and compiles it without GPU support, which means inference runs entirely on CPU. To get CUDA or Metal acceleration, the build needs specific CMake flags passed through environment variables, or the install must pull from a separate wheel index that the maintainer publishes.

Requirements

A C/C++ compiler and CMake are required for building from source. The project’s build system expects clang; on systems where only gcc is available, install clang as well (e.g., apt install clang). On macOS, Xcode command-line tools provide both. On Windows, Visual Studio Build Tools with the “Desktop development with C++” workload are needed.

How to Install PyTorch with uv

Tim Hopper — Wed, 13 May 2026 06:43:22 -0400

PyTorch publishes different wheel builds for CPU, CUDA, ROCm, and XPU on separate package indexes (see Why Installing GPU Python Packages Is So Complicated for background). Getting the right build requires telling uv which index to use.

Default behavior without configuration

Running uv add torch torchvision with no extra configuration installs from PyPI. PyPI carries CPU-only wheels for Windows and macOS, and CUDA 12.8 wheels for Linux (as of PyTorch 2.9.1). For projects that only need CPU support on Windows/macOS and GPU support on Linux, this default works without any additional setup.

How to Install RAPIDS with uv

Tim Hopper — Wed, 13 May 2026 06:43:22 -0400

RAPIDS packages live on NVIDIA’s own package index, not PyPI (see Why Installing GPU Python Packages Is So Complicated for background). Getting uv to find them requires registering that index.

Prerequisites

RAPIDS requires:

Linux with glibc >= 2.28 (Ubuntu 20.04+, Debian 10+, Fedora 29+). On Windows, use WSL2 on Windows 11. macOS is not supported.
NVIDIA GPU with compute capability 7.0+ (Volta architecture or newer).
NVIDIA driver version 525.60.13+ for CUDA 12, or 580.65.06+ for CUDA 13.
Python 3.10, 3.11, 3.12, or 3.13.

Check the installed driver version with:

How to Install Triton

Tim Hopper — Wed, 13 May 2026 06:43:22 -0400

Triton is OpenAI’s open-source compiler for writing GPU kernels in Python. Most users encounter it as a transitive dependency of PyTorch, but it can also be installed standalone for custom kernel development. Triton only ships wheels for Linux (x86_64 and aarch64). There are no macOS or Windows builds.

Requirements

Linux (x86_64 or aarch64). Triton has no wheels for macOS or Windows.
Python 3.10 or later (up to 3.14).
glibc 2.27 or later (Ubuntu 18.04+, Debian 10+, RHEL 8+).
An NVIDIA or AMD GPU with appropriate drivers for running compiled kernels. Triton itself installs without a GPU, but kernels cannot execute without one.

Install as a PyTorch dependency (automatic)

PyTorch declares Triton as a dependency on Linux x86_64. Installing PyTorch pulls in the matching Triton version automatically:

How to Install xformers

Tim Hopper — Wed, 13 May 2026 06:43:22 -0400

xformers ships prebuilt wheels through the PyTorch package index, not PyPI. Like PyTorch itself, the correct binary depends on the CUDA version of the target machine (see Why Installing GPU Python Packages Is So Complicated for background). Each xformers release is pinned to a specific PyTorch version, so a version mismatch between the two is the most common source of installation failures.

Requirements

Linux (manylinux_2_28, e.g. Ubuntu 20.04+) or Windows. macOS is not supported.
NVIDIA GPU with compute capability 8.0+ (Ampere or newer). V100 support was dropped in xformers 0.0.30.
NVIDIA driver compatible with the target CUDA version.
Python 3.9 or later.

Version compatibility

Each xformers release requires a specific PyTorch version. Installing the wrong combination produces import errors or silent correctness bugs.

How to Run a Jupyter Notebook with uv

Tim Hopper — Wed, 13 May 2026 06:43:22 -0400

When working with Jupyter notebooks, you should run them in isolated environments to prevent dependency conflicts. uv provides several streamlined ways to do this.

Using Jupyter with uv’s Isolated Environments

To launch a Jupyter notebook with specific dependencies using uv:

uv run --with jupyter --with pandas --with matplotlib jupyter lab

This single command:

How to Serve LLMs Locally with vLLM and uv

Tim Hopper — Sat, 16 May 2026 06:59:40 -0400

vLLM is a high-throughput inference engine for large language models. GPU inference runs on Linux with NVIDIA CUDA. vLLM also supports AMD ROCm and Intel XPU backends, and ships experimental CPU builds for x86, ARM, and Apple Silicon. Windows users run vLLM under WSL 2. This guide covers the most common path: NVIDIA GPUs on Linux, where vLLM depends on PyTorch with CUDA support. uv’s --torch-backend flag ensures PyTorch pulls from the correct CUDA index to match your driver.

Is Conda actually free?

Tim Hopper — Tue, 28 Apr 2026 21:54:51 -0400

The conda package manager is open source and always free. The Anaconda repository that ships as the default package source for Anaconda Distribution and Miniconda is not. Confusing “conda” with “Anaconda” causes organizations to either pay for licenses they don’t need or violate terms they didn’t know existed.

What costs money

Anaconda, Inc. operates a curated package repository at repo.anaconda.com. Accessing that repository requires a paid license for any organization (for-profit, nonprofit, or government) with more than 200 employees or contractors. The threshold counts all employees across the entire organization, including affiliates.

marimo: Reactive Python Notebook

Tim Hopper — Sat, 02 May 2026 08:49:34 -0400

marimo is an open-source Python notebook in which cells re-execute automatically when the variables they read change. Notebooks are stored as plain .py files rather than JSON and are parsed by static analysis to derive a deterministic execution order. The same file can be run as a standalone script or inside a sandboxed environment managed by uv. It is licensed under Apache-2.0 and requires Python 3.10 or newer.

Reactive Notebook Model

The traditional notebook model decouples cell ordering from execution. A Jupyter cell runs only when the user runs it, so the in-memory kernel state can drift from the visible code. Variables outlive the cells that defined them, and re-running cells out of order produces results that a fresh kernel restart cannot reproduce. This is the hidden state problem.

Migrate a conda project to pixi

Tim Hopper — Wed, 29 Apr 2026 13:11:49 -0400

This tutorial converts a conda project (defined by an environment.yml) into a pixi project. The result: project-local environments, an automatic lockfile, a built-in task runner, and access to the same conda-forge packages.

Prerequisites

pixi installed (installation instructions)
An environment.yml file from an existing conda project
Familiarity with conda workflows (see Take Over an Existing Conda Environment if you’re new to conda)

Why migrate

Conda works, but pixi solves several friction points:

Pixi: Multi-Language Package and Workflow Manager

Tim Hopper — Sat, 25 Apr 2026 06:42:19 -0400

Pixi is a cross-platform package manager and workflow tool that manages both conda-forge packages and PyPI packages from a single project manifest. It replaces conda’s global environment model with project-local environments and automatic lock files.

Note

Set up a data science project with uv

Tim Hopper — Tue, 05 May 2026 06:58:20 -0400

This tutorial sets up a data analysis project with uv so that every dependency is pinned, notebooks run in the right environment, and a collaborator can reproduce your setup with a single command.

Prerequisites

Install uv following the installation guide. No separate Python install is required.

Create the project

$ uv init weather_analysis
Initialized project `weather-analysis` at `/path/to/weather_analysis`
$ cd weather_analysis

This creates a project directory with a pyproject.toml, a main.py, and a README.md. The pyproject.toml stores all project metadata and dependencies:

Set up a GPU data science project with pixi

Tim Hopper — Fri, 10 Apr 2026 12:46:15 -0400

This tutorial builds a PyTorch image classification project managed by pixi. It loads a pretrained ResNet model, classifies a sample image, and prints the top-5 predictions. The project uses pixi’s multi-environment feature to support both GPU (CUDA) and CPU-only machines from a single pixi.toml.

Prerequisites

pixi installed (installation instructions)
Familiarity with pixi basics (see Create Your First Python Project with pixi)
For GPU: an NVIDIA GPU with a recent driver. For CPU-only: everything works, just slower.

Why conda-forge for PyTorch

PyTorch on conda-forge shares the CUDA runtime with other packages. When you install PyTorch and cuDNN from conda-forge, they use the same cuda-toolkit package rather than each bundling its own copy. This produces smaller environments and avoids version conflicts between CUDA-dependent libraries.

Set up a multi-GPU training environment with uv

Tim Hopper — Fri, 15 May 2026 07:11:00 -0400

This tutorial builds a PyTorch training project managed by uv that runs identically on one GPU or eight. You will install PyTorch with CUDA support, add Hugging Face Accelerate for distributed training, write a CIFAR-10 classifier, and launch it across multiple GPUs.

Important

Take over an existing conda environment

Tim Hopper — Mon, 04 May 2026 08:00:31 -0400

You just joined a team or lab that uses conda. Someone handed you an environment.yml and told you to conda activate. This tutorial walks through the day-to-day operations: creating an environment from a file, exploring what’s installed, adding packages, handling the conda+pip boundary, and exporting a reproducible environment for teammates.

Prerequisites

Install Miniforge following the Miniforge installation instructions.

Important

Understanding the Conda/Anaconda Ecosystem

Tim Hopper — Fri, 10 Apr 2026 11:13:55 -0400

Conda is not Anaconda. Conda is a package manager; Anaconda is a distribution that bundles conda with over 1,500 pre-installed packages. Confusing the two is common, and it leads to choosing the wrong installer or paying for a commercial license you don’t need.

The conda ecosystem operates as a parallel system to Python’s standard packaging tools like PyPI, pip, and virtual environments. Conda uses its own package format, repository structure, and environment management. The two ecosystems can coexist, but they work independently.

uv vs pixi vs conda for Scientific Python

Tim Hopper — Tue, 28 Apr 2026 21:54:51 -0400

Your scientific Python project needs CUDA, GDAL, or HDF5, and pip install cannot help. Which tool should manage those native dependencies alongside your Python code? The answer depends on where your packages live: PyPI, conda-forge, or both.

Three tools cover the spectrum. uv installs from PyPI. pixi installs from conda-forge and PyPI together. conda installs from conda channels.

What each tool can install

uv resolves packages from PyPI, plus Git URLs, local paths, and private indexes. It cannot install non-Python dependencies like the CUDA toolkit, GDAL, or HDF5.

What Are Wheel Variants?

Tim Hopper — Tue, 28 Apr 2026 21:54:51 -0400

A default NumPy wheel for x86_64 has to run on every x86-64 CPU that has ever shipped, with the baseline instruction set fixed when AMD64 was defined in 2003. Every SIMD instruction Intel and AMD have added since then is off-limits to the installer, because a wheel filename has no place to declare “needs AVX2” or “needs SSE4”. On scientific workloads, Ralf Gommers of Quansight put the performance left on the table at 10x to 20x.

When should I choose pixi over uv?

Tim Hopper — Tue, 28 Apr 2026 21:54:51 -0400

uv and pixi solve overlapping problems with different scope. Both create project-local environments and generate lockfiles. The difference is what they can install. uv pulls from PyPI (plus Git, URL, and path sources). Pixi pulls from conda channels (typically conda-forge) and PyPI, which means it can install system-level dependencies and non-Python software that PyPI does not distribute.

The short version: if you need conda packages, pixi is the better fit. If you don’t, uv is simpler.

Why Installing GPU Python Packages Is So Complicated

Tim Hopper — Wed, 15 Apr 2026 11:17:37 -0400

Python wheels have no way to express GPU hardware requirements. A wheel’s three metadata tags (Python version, ABI, and platform) tell an installer everything about the CPU environment, but nothing about the GPU or which CUDA version is available.

PyTorch ships different binaries for CUDA 12.6, 12.8, 13.0, and CPU-only builds. Without GPU metadata in wheels, it has no standard way to publish all four variants to PyPI and let installers pick the right one. Every CUDA-dependent project has had to invent its own distribution workaround.

Why should I choose Conda?

Tim Hopper — Tue, 28 Apr 2026 21:54:51 -0400

Conda installs software, not just Python packages. That distinction matters when your project depends on CUDA toolkit versions, R statistical libraries, or C++ numerical frameworks that exist outside the Python packaging ecosystem.

When Conda solves problems other tools cannot

Tools like pip and uv can install many compiled packages through binary wheels, including OpenCV and CUDA-specific PyTorch builds. But conda goes further by solving Python and non-Python dependencies together. Consider a machine learning project that requires: