Install Taichi Python: Quick Guide

Taichi is a high-performance parallel programming language embedded in Python. It lets you write fast, readable code for graphics, physics simulation, and machine learning. This guide shows you how to install Taichi on Windows, macOS, and Linux.

We cover the simplest method with pip, the Conda alternative, and a source build for advanced users. Each section includes code examples and common fixes.

Prerequisites

Before you start, you need Python 3.7 to 3.11. Taichi does not support Python 3.12 yet. Check your Python version with this command:

python --version

If your version is too new, create a virtual environment with Python 3.10. Use venv or Conda to isolate your project. This avoids dependency conflicts.

You also need a modern GPU for best performance. Taichi works with NVIDIA, AMD, and Intel GPUs. CPUs work too, but slower.

Method 1: Install Taichi with pip

The fastest way is using pip, Python's package manager. Open your terminal and run this:

pip install taichi

This downloads the latest stable version. Wait for the process to finish. You should see output like this:

Successfully installed taichi-1.7.0

If you get a permission error, use --user or run the terminal as administrator. For example:

pip install --user taichi

To install a specific version, add the version number. Use pip install taichi==1.6.0 for an older release. Check the Taichi release page for version details.

After installation, verify it works with a simple test:

import taichi as ti
print(ti.__version__)

Expected output:

1.7.0

If you see an error about missing Vulkan or CUDA, install the backend drivers. Taichi uses Vulkan on Linux and macOS, and CUDA on NVIDIA GPUs.

Method 2: Install Taichi with Conda

Conda users can install Taichi from the conda-forge channel. This works well if you manage environments with Anaconda or Miniconda. Run these commands:

conda install -c conda-forge taichi

This installs Taichi and all required dependencies. Conda handles CUDA and Vulkan libraries automatically on many systems. It is a good choice for beginners.

To create a fresh environment for Taichi, use:

conda create -n taichi-env python=3.10
conda activate taichi-env
conda install -c conda-forge taichi

Test the installation with the same import code as above. Conda builds are slightly behind pip releases, but they are stable.

Method 3: Install from Source

Building from source gives you the latest features and custom optimizations. This method requires C++ and CUDA toolkits. Only do this if you need bleeding-edge changes.

First, clone the Taichi repository:

git clone https://github.com/taichi-dev/taichi.git
cd taichi

Then install build dependencies:

pip install -r requirements_dev.txt

Finally, build and install Taichi:

python setup.py install

This process takes several minutes. You need CMake, a C++ compiler, and CUDA if using NVIDIA GPUs. After completion, test with the import code.

Source builds let you enable custom backends like AMD ROCm. Read the Taichi documentation for advanced flags.

Common Installation Errors and Fixes

Many users face errors during installation. Here are the most common ones and how to solve them.

Error: "No module named 'taichi'". This means the package did not install. Run pip list | grep taichi to check. If missing, reinstall with pip install taichi --force-reinstall.

Error: "Cannot find Vulkan SDK". Taichi needs Vulkan on Linux and macOS. Install the Vulkan SDK from the LunarG website. On Ubuntu, use sudo apt install vulkan-sdk.

Error: "CUDA driver version is insufficient". Update your NVIDIA driver to version 450.80.02 or later. Check with nvidia-smi. If you have no GPU, use the CPU backend by setting ti.init(arch=ti.cpu).

Error: "Permission denied". Use a virtual environment or the --user flag. Never use sudo pip as it breaks your system Python.

Running Your First Taichi Program

After installation, write a simple kernel to test performance. Here is a classic fractal generator:

import taichi as ti

ti.init(arch=ti.gpu)  # Use GPU if available

@ti.kernel
def fractal(t: ti.f32) -> ti.f32:
    # Simple Julia set calculation
    c = ti.Vector([-0.8, 0.156])
    z = ti.Vector([ti.random(), ti.random()])
    for i in range(100):
        if z.norm() > 2.0:
            break
        z = ti.Vector([z[0]**2 - z[1]**2 + c[0], 2*z[0]*z[1] + c[1]])
    return z.norm()

# Run the kernel 1000 times for timing
import time
start = time.time()
for _ in range(1000):
    fractal(0.0)
print("Time:", time.time() - start)

This code runs a Julia set computation on your GPU. It prints the execution time. If it runs without error, your installation is correct.

Taichi compiles the kernel once, then runs it at near-native speed. The @ti.kernel decorator marks a function for parallel execution.

Conclusion

Installing Taichi in Python is straightforward with pip or Conda. Choose pip for the latest version, Conda for stability, or source for custom builds. Always use a virtual environment to avoid conflicts.

After installation, test with a simple kernel to confirm everything works. If you hit errors, check your GPU drivers and Python version. Taichi unlocks fast parallel computing for Python developers. Start building your first simulation today.