For the complete documentation index, see llms.txt. Markdown versions of all pages are available by appending .md to any URL (e.g. /get-started.md).

Packages

You can install all the MAX API libraries and tools, including Mojo and all optional dependencies, with max[all] (pip/uv) or max-all (conda/pixi). Alternatively, you can install just a subset of the tools using one of the other max package options as described below.

If you just want to get started, instead see the quickstart guide.

Install

To get the latest improvements and new features, we recommend installing our nightly build, which we release several times a week. If you want a better tested but older version, you can install a stable build. For version details, see the release notes.

System requirements:

Mac

Linux

WSL

We recommend installing with pixi for the most reliable experience.

pixi
uv

If you don't have it, install pixi:
```
curl -fsSL https://pixi.sh/install.sh | sh
```
Then restart your terminal for the changes to take effect.

Create a project:

pixi init example-project \
  -c https://conda.modular.com/max-nightly/ -c conda-forge \
  && cd example-project

Tip: You can skip the -c options if you add these channels as defaults.

Install max with all dependencies (nightlyTo get the stable build, change the version in the website header.):
```
pixi add max-all
```
Start the virtual environment:
```
pixi shell
```

If you don't have it, install uv:
```
curl -LsSf https://astral.sh/uv/install.sh | sh
```
Then restart your terminal to make uv accessible.

Create a project:

uv init example-project && cd example-project

Create and start a virtual environment:
```
uv venv && source .venv/bin/activate
```
Install max with all dependencies (nightlyTo get the stable build, change the version in the website header.):
```
uv add "max[all]" \
    --index https://whl.modular.com/nightly/simple/ \
    --prerelease allow
```

See the following section for more details about what's included in max[all] (and max-all).

GitHub stable branch

If you're using a stable build and want to clone the Modular repo, make sure you checkout the stable branch (because the main branch includes the latest nightly code). For example:

git clone -b stable https://github.com/modular/modular.git

What's included

The max[all] (or max-all) package includes all optional dependencies so you can do everything, including serve models, benchmark endpoints, and program with Mojo.

If you're concerned about bloat in your dependencies, you can chose a smaller package that includes only what you need. For example, if you only need to benchmark an endpoint, you can install just max[benchmark].

`max[all]`

pip/uv: max[all]
conda/pixi: max-all

This is the "all extras" package. It includes everything MAX has to offer.

It's just a convenient way to get all these packages at once:

max[benchmark]
max[serve]
mojo

`max[benchmark]`

pip/uv: max[benchmark]
conda/pixi: max-benchmark

This is required to use the max benchmark command.

It depends on max and other third-party packages.

`max[serve]`

pip/uv: max[serve]
conda/pixi: max-serve

This is required to create an endpoint with the max serve command.

It depends on max and other third-party packages.

`max`

This is the main package you need to do anything with MAX. It includes:

max CLI: Mostly used to create and benchmark endpoints, but the serve and benchmark commands require max[serve] and max[benchmark], respectively.
MAX Python library: Used to build models.
MAX accelerator library: Used to accelerate inference with GPUs.
MAX Engine C API: Used to run inference without an endpoint.

max depends on mojo-compiler and minimal third-party packages.

If you want all Mojo developer tools, you must install the larger mojo package, which is included in the max[all] package. To see what's in the mojo and mojo-compiler packages, see what's include in the Mojo SDK.

Technically, there are other packages you'll see in your dependency tree (such as max-core) but they're implementation detail and you should generally ignore them—don't set them as explicit dependencies in your project because they won't work on their own.

System requirements

Your system must meet these specifications.

Mac
Linux
Windows

macOS Sequoia (15) or later.
Apple silicon (M1–M5 processor).
Python 3.10–3.14.
Xcode or Xcode Command Line Tools 16 or later.
Apple silicon GPU support is available for Mojo GPU programming. See GPU compatibility for details. You may need to run xcodebuild -downloadComponent MetalToolchain to install the Metal utilities required for GPU programming.

glibc 2.34 or later (for example, Ubuntu 22.04 LTS or later).

Officially supported distribution
We test MAX on Ubuntu 22.04 LTS or later. Other Linux distributions that meet the glibc 2.34+ requirement are expected to work but aren't continuously tested.
x86-64-v3 (Haswell-class or newer; CPUs from approximately 2013 onward) or ARM64 Neoverse N1 or newer (for example, AWS Graviton2 and later).

x86-64-v3 CPU instruction sets
The x86-64-v3 microarchitecture level requires AVX, AVX2, BMI1, BMI2, F16C, FMA, LZCNT, MOVBE, and XSAVE instructions. To verify your x86-64 CPU on Linux, run cat /proc/cpuinfo | grep flags and confirm those flags are present. This requirement doesn't apply to ARM64 hosts.
8 GiB RAM minimum for Mojo development. MAX inference and model serving require significantly more memory, with the exact amount varying by model. For the catalog of supported models, see the supported models page; for a specific model, check its Hugging Face page for memory details.
Python 3.10–3.14.
A C compiler (such as cc, gcc, or clang)—used as a linker.
To use GPUs, see the GPU compatibility.

GPU compatibility

MAX supports both CPUs and GPUs, so you don't always need a GPU to serve a model. But if you want to accelerate inference with GPUs or program for GPUs with Mojo, the following GPUs are compatible.

NVIDIA GPUs

GPU	Architecture
Tested for serving
B200	Blackwell
Known compatible for development
B300	Blackwell
B100	Blackwell
DGX Spark	Blackwell
H200	Hopper
H100	Hopper
L4	Ada Lovelace
L40	Ada Lovelace
A100	Ampere
A10	Ampere
A1000	Ampere
RTX 50XX series	Blackwell
RTX 40XX series	Ada Lovelace
RTX 30XX series	Ampere
Jetson Orin / Orin Nano	Ampere
Jetson Thor	Blackwell
T4	Turing
RTX 20XX series	Turing

Software requirement: NVIDIA GPU driver 580 or later. Check your version with nvidia-smi. To update, see the NVIDIA driver docs. If your driver is older than 580, set the MODULAR_NVPTX_COMPILER_PATH environment variable to a system ptxas binary (for example, export MODULAR_NVPTX_COMPILER_PATH=/usr/local/cuda/bin/ptxas).

AMD GPUs

GPU	Architecture
Tested for serving
MI355X	CDNA4
MI300X	CDNA3
MI325X	CDNA3
Known compatible for development
MI250X	CDNA2
Radeon RX 9070	RDNA4
Radeon RX 9060	RDNA4
Radeon 880M / 890M	RDNA3.5
Radeon 860M	RDNA3.5
Radeon 8060S	RDNA3.5
Radeon RX 7900	RDNA3
Radeon RX 7800 / 7700	RDNA3
Radeon RX 7600	RDNA3
Radeon 780M	RDNA3
Radeon RX 6900	RDNA2

Software requirement: AMD GPU driver 6.3.3 or later (MI355X requires ROCm 7.0 or later). For installation, see the Ubuntu native install guide.

Apple silicon GPUs

Apple silicon GPU support (M1–M5) is functional for GPU programming with Mojo. Large GenAI model inference via MAX isn't yet available on Apple silicon. For details, see the Mojo system requirements.

Notes

Many GPUs are available in variants with different amounts of memory, and each AI model has different memory requirements. Even if your GPU architecture is listed as compatible, confirm that the available memory is sufficient for the model you're using.
MAX can serve models on either CPU or GPU, but some models require one or more GPUs. When you browse our supported models, you can check for multi-GPU support.
For comprehensive GPU hardware tables, arch targets, and troubleshooting, see the Mojo system requirements page.
To deploy MAX in containers, see the deployment guide.

Install​

What's included​

max[all]​

max[benchmark]​

max[serve]​

max​

System requirements​

GPU compatibility​

NVIDIA GPUs​

AMD GPUs​

Apple silicon GPUs​