Skip to content
Tutorial Reference

How to Resolve Python "Failed building wheel for X" Pip Install Errors

How to diagnose and fix 'Failed building wheel for X' errors during pip install by upgrading tools, installing compilers, checking Python compatibility, and using pre-built wheels.

The Failed building wheel for <package-name> error during a pip install command is a common frustration for Python developers. It typically means pip couldn't find a pre-compiled "wheel" (.whl) file for your specific system and Python version, and therefore attempted to build the package from its source code. This build process then failed, often due to missing system dependencies, compiler issues, or Python version incompatibilities.

This guide provides a comprehensive set of troubleshooting steps to diagnose and resolve these "Failed building wheel" errors for various packages.

Understanding the "Failed building wheel" Error

When you run pip install <package-name>, pip first looks for a pre-compiled binary distribution called a "wheel" (.whl file) on PyPI that matches your operating system, architecture (32-bit/64-bit), and Python version. If a suitable wheel is found, installation is usually quick and easy.

If no wheel is available, pip attempts to download the package's source distribution (e.g., a .tar.gz file) and build it locally. This "building from source" often involves compiling C, C++, or Fortran code, which requires specific compilers and development libraries (headers) to be installed on your system. The "Failed building wheel" error means this local build process encountered an error.

The error message usually looks like this:

ERROR: Failed building wheel for <package-name>
... (often more detailed compiler errors here) ...
ERROR: Could not build wheels for <package-name>, which is required to install pyproject.toml-based projects

General Troubleshooting Steps (Apply These First)

These steps are applicable to most "Failed building wheel" errors.

Upgrade pip, setuptools, and wheel

Outdated packaging tools can cause various issues. Ensure they are up to date:

python3 -m pip install --upgrade pip setuptools wheel

Virtual environments isolate project dependencies and prevent conflicts with system-wide Python packages. Always work within an activated virtual environment:

python3 -m venv myenv  # Or .venv, venv, etc.

source myenv/bin/activate   # Linux/macOS
myenv\Scripts\activate.bat  # Windows (cmd.exe)
myenv\Scripts\Activate.ps1  # Windows (PowerShell)

pip install --upgrade pip
pip install <package-name>

Check for Missing Compilers and Development Headers

This is the most common cause of build failures.

  • Windows: Microsoft C++ Build Tools Many packages require a C/C++ compiler. The error message often explicitly states: "Microsoft Visual C++ 14.0 or greater is required."

    1. Download "Build Tools for Visual Studio" from the Visual Studio Downloads page (under "Tools for Visual Studio").
    2. Run the installer and select the "Desktop development with C++" workload.
    3. Restart your terminal/IDE after installation.

  • Linux: build-essential, python3-dev

    • Debian/Ubuntu: 
      sudo apt update
sudo apt install build-essential python3-dev
    • Fedora/CentOS/RHEL: 
      sudo dnf groupinstall "Development Tools" # Or 'yum' for older versions
sudo dnf install python3-devel

  • macOS: Xcode Command Line Tools

    xcode-select --install

    If already installed, you might need to accept a new license agreement or update them.

Verify Python Version Compatibility

Some packages don't support the very latest Python versions immediately, or they might have dropped support for older versions.

  1. Check your Python version: python --version or python3 --version.
  2. Go to the package's page on PyPI (pypi.org).
  3. Look for "Requires-Python" under "Meta" or "Programming Language" classifiers.
  4. Check the "Download files" section for available wheel files (e.g., cp39 means CPython 3.9, cp310 for 3.10, etc.). If there's no wheel for your OS/Python combo, a source build is attempted. If your Python version isn't supported, you may need to use an older Python version (via a virtual environment) or wait for the package to be updated.

Use pip install in Verbose Mode (-vvv)

This provides much more detailed output, which can help pinpoint where the build process is failing:

pip install <package-name> -vvv

Carefully examine the output for specific error messages from the compiler or build scripts.

Consider --no-cache-dir or --pre

  • --no-cache-dir: Disables pip's cache, which can sometimes help if a cached (and possibly corrupted) build is causing issues. 
    pip install <package-name> --no-cache-dir
  • --pre: Includes pre-release and development versions. A pre-release might have wheels for your system when the stable version doesn't. 
    pip install <package-name> --pre

Troubleshooting for Specific Common Packages

Many "Failed building wheel" errors for specific packages are due to missing system-level dependencies required by their C/C++ extensions.

psycopg2 (PostgreSQL Adapter)**

  • Common Issue: Missing PostgreSQL client development headers and libraries.
  • Solution:
    • Debian/Ubuntu: sudo apt-get install gcc libpq-dev python3-dev
    • Fedora/CentOS/RHEL: sudo dnf install gcc postgresql-devel python3-devel
    • macOS: brew install postgresql (often includes headers). If issues persist, you might need to set LDFLAGS and CPPFLAGS to point to your PostgreSQL installation, or try psycopg2-binary.
    • Often Easier: Install the binary version if building from source is problematic: 
      pip uninstall psycopg2 # If a partial install exists
pip install psycopg2-binary

mysqlclient (MySQL/MariaDB Adapter)**

  • Common Issue: Missing MySQL/MariaDB client development headers.
  • Solution:
    • Debian/Ubuntu: sudo apt-get install python3-dev default-libmysqlclient-dev build-essential
    • Fedora/CentOS/RHEL: sudo dnf install python3-devel mysql-devel gcc
    • macOS: brew install mysql (then ensure mysql_config is in your PATH, or set environment variables).

Pillow (PIL Fork for Image Processing)

  • Common Issue: Missing development libraries for image formats like JPEG and PNG (zlib).
  • Solution:
    • Debian/Ubuntu: sudo apt-get install libjpeg-dev zlib1g-dev python3-dev
    • Fedora/CentOS/RHEL: sudo dnf install libjpeg-turbo-devel zlib-devel python3-devel gcc
    • macOS: Often works with Xcode tools. If specific formats fail, brew install libjpeg zlib might help.

lxml (XML and HTML Processing)

  • Common Issue: Missing libxml2 and libxslt development headers.
  • Solution:
    • Debian/Ubuntu: sudo apt-get install libxml2-dev libxslt1-dev python3-dev
    • Fedora/CentOS/RHEL: sudo dnf install libxml2-devel libxslt-devel python3-devel
    • macOS: Usually handled by Xcode tools. If not, brew install libxml2 libxslt might be needed.

uWSGI (Web Server Gateway Interface)

  • Common Issue: Missing C compiler and Python development headers.
  • Solution:
    • Debian/Ubuntu: sudo apt-get install gcc python3-dev build-essential
    • Fedora/CentOS/RHEL: sudo dnf install gcc python3-devel
    • Alpine Linux: apk add gcc libc-dev python3-dev (or py3-setuptools-scm if error mentions it)

grpcio (gRPC framework)

  • Common Issue: Build system complexities, especially on macOS related to OpenSSL or zlib provided by the system vs. Homebrew.
  • Solution:
    • Ensure general build tools are present.
    • Upgrade pip, setuptools, wheel.
    • On macOS, sometimes setting environment variables helps pip find the correct libraries (if using Homebrew's OpenSSL/zlib): 
      export GRPC_PYTHON_BUILD_SYSTEM_OPENSSL=true
export GRPC_PYTHON_BUILD_SYSTEM_ZLIB=true
pip install grpcio
    • Consider installing from a pre-compiled wheel if available for your platform (check PyPI "Download files").

h5py (HDF5 Binary Data Format)

  • Common Issue: Missing HDF5 library and its development headers.
  • Solution:
    • Debian/Ubuntu: sudo apt-get install libhdf5-dev python3-dev
    • Fedora/CentOS/RHEL: sudo dnf install hdf5-devel python3-devel
    • Anaconda/Miniconda often provides a smoother installation: conda install h5py

wordcloud

llvmlite (LLVM for Numba/Compilers)

  • Common Issue: Complex build, requires a C++ compiler and sometimes specific LLVM versions.
  • Solution:
    • Ensure general build tools are present.
    • Often best installed via conda if using Anaconda/Miniconda: conda install llvmlite
    • Windows: Consider wheels from Gohlke's site.
    • If building from source, ensure you have a compatible llvm-config in your PATH or set LLVM_CONFIG environment variable.

torch (PyTorch)

  • Common Issue: pip install torch might try to build from source if it can't find a wheel matching your CUDA version (if GPU enabled) or system.
  • Solution:
    • Highly Recommended: Install PyTorch using the command provided on the official PyTorch website (pytorch.org). Select your OS, package manager (pip or conda), Python version, and CUDA version (if applicable) to get the correct installation command. This command usually points pip to specific wheel URLs.
    • Example for pip with CPU only: pip3 install torch torchvision torchaudio
    • Example for pip with CUDA 11.8: pip3 install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

Installing from a Pre-compiled Wheel File (.whl)

If official PyPI doesn't have a wheel for your platform/Python version, but you can find one elsewhere (e.g., Christoph Gohlke's site for Windows, or a project's GitHub releases):

  1. Download the .whl file. Make sure it matches your Python version (e.g., cp39 for Python 3.9) and system architecture (e.g., win_amd64 for 64-bit Windows).
  2. Open your terminal in the directory where you downloaded the file.
  3. Install it using pip: 
    pip install some_package-1.2.3-cp39-cp39-win_amd64.whl
    Replace the filename with the actual name of your downloaded wheel.

Conclusion

The "Failed building wheel for X" error signals a problem during the local compilation of a Python package from its source code. The most effective approach to solving it involves:

  1. Reading the full error output to identify specific compiler errors or missing dependencies.
  2. Ensuring your packaging tools (pip, setuptools, wheel) are up-to-date.
  3. Installing the necessary system-level compilers and development libraries (C++ build tools on Windows, build-essential/python3-dev on Linux, Xcode tools on macOS).
  4. Verifying Python version compatibility with the package.
  5. Using virtual environments to isolate dependencies. For certain complex packages or specific operating systems, consulting the package's official installation documentation or looking for pre-compiled binaries can save significant time.
Navigation