Install Mojo

You can install Mojo as a Python or Conda package. This page shows you how to install using pixi, uv, pip, and conda, but you can use other tools.

Start coding

For a beginner's guide to Mojo, instead see the get started tutorial, which includes installation steps.

System requirements:

Mac

Linux

WSL

Install

To get the latest version, we recommend installing our nightly build. If you want a better tested but older version, install the stable build. Both options are shown below.

For the most reliable experience, we recommend using Pixi. It's both a package manager and virtual environment manager—which alone makes development a lot easier—but it's also fast, language agnostic, and provides lock files for package dependencies. For more help with it, see our Pixi basics guide.

pixi

1. If you don't have it, install pixi:

   curl -fsSL https://pixi.sh/install.sh | sh

2. Navigate to the directory where you want to create a project and run this:

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

   This creates a project directory named hello-world, adds the channel for Modular conda packages, and enters the directory.

   Tip: You can remove the -c options if you specify default channels.

3. Install Mojo:

   Nightly

   pixi add mojo

   Stable

   pixi add "mojo==0.25.7"

4. Enter the virtual environment so you can access the mojo CLI:

   pixi shell

uv

1. 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.

2. Create a project:

   uv init hello-world && cd hello-world

3. Create and start a virtual environment:

   uv venv && source .venv/bin/activate

4. Install Mojo:

   Nightly

   uv pip install mojo \
     --index-url https://dl.modular.com/public/nightly/python/simple/ \
     --prerelease allow

   Stable

   uv pip install mojo \
     --extra-index-url https://modular.gateway.scarf.sh/simple/

pip

1. Create a project folder:

   mkdir hello-world && cd hello-world

2. Create and activate a virtual environment:

   python3 -m venv .venv/hello-world \
     && source .venv/hello-world/bin/activate

3. Install Mojo:

   Nightly

   pip install --pre mojo \
     --index-url https://dl.modular.com/public/nightly/python/simple/

   Stable

   pip install mojo \
     --extra-index-url https://modular.gateway.scarf.sh/simple/

conda

1. If you don't have it, install conda. A common choice is to use Homebrew:

   brew install miniconda

2. Initialize conda for shell interaction:

   conda init

   If you're on a Mac, instead use:

   conda init zsh

   Then restart your terminal for the changes to take effect.

3. Create a project:

   conda create -n hello-world

4. Start the virtual environment:

   conda activate hello-world

5. Install Mojo:

   Nightly

   conda install -c conda-forge \
     -c https://conda.modular.com/max-nightly/ mojo

   Stable

   conda install -c conda-forge \
     -c https://conda.modular.com/max/ "mojo==0.25.7"

Verify your installation by printing the Mojo version:

mojo --version

Add the VS Code extension

If you're using Visual Studio Code or another IDE derived from it (such as Cursor), we recommend installing the Mojo extension, which provides features like syntax highlighting, code completion, and debugging support. You can install it from either:

• The Visual Studio Code Marketplace, for VS Code users
• The Open VSX Registry, for users of Cursor and other editors that support VS Code extensions

Or, open the Extensions view in your IDE and search for "Mojo"—make sure you install the extension from Modular.

Prior to the 0.25.6 Mojo release, there were two versions of the Mojo extension: a stable version for working with the stable build of Mojo and a nightly version for working with the nightly build of Mojo. Concurrent with the 0.25.6 Mojo release, we've consolidated the two versions into a single extension that works for both stable and nightly builds.

The new extension replaces the old stable version, so if you have the stable version installed, you can simply update it to receive the new version. If you have the nightly version of the extension installed, you should uninstall it and install the regular (non-nightly) version.

Print "Hello world"

If you followed the installation steps above, your terminal should be in an environment with mojo installed. To run some code, you just need a .mojo file with a main() function:

1. Create a file named hello.mojo with this code:

   hello.mojo

   def main():
       print("Hello, World!")

2. Run it with the mojo CLI:

   mojo hello.mojo

   Hello, World!

Try some examples

The examples/mojo/ directory of our public GitHub repository contains several examples of Mojo code that you can use to learn more about the language and its standard library. Here's how to download and use them.

1. Clone the repository:

   git clone https://github.com/modular/modular.git

2. Navigate to one of the Mojo example subdirectories, such as the subdirectory containing the reference solution for the Get started with Mojo tutorial project, which is an implementation of Conway's Game of Life cellular automation:

   cd modular/examples/mojo/life

3. Use pixi to download and install the dependencies for the project and to build and run the examples. For example, to run the reference solution for the Game of Life tutorial project, use the following command:

   pixi run lifev1

   This displays a window that shows an initial random state for the grid and then automatically updates it with subsequent generations. Quit the program by pressing the q or <Escape> key or by closing the window.

   If you're using a package manager other than pixi, make sure mojo is installed and accessible in your current shell environment. Consult the README.md file in the example project subdirectory for information about any other dependencies that need to be installed for that particular example project. (The Game of Life example requires a compatible Python runtime and the pygame library.) Then run the example with the mojo CLI. For example, to run the reference solution for the Game of Life tutorial project, use the following command:

   mojo lifev1.mojo

Update

The following commands should update your local mojo package if a new version is available that's compatible with the version you specified when you installed it or added it as a package dependency. For more information about updating packages, see the docs for your package manager.

pixi

pixi update mojo

uv

uv sync --upgrade-package mojo

pip

pip install --upgrade mojo

conda

conda update mojo

Uninstall

Mojo is installed as a Python or Conda package, so the normal package removal process applies.

pixi

This removes the package from your local project:

pixi remove mojo

This deactivates your virtual environment:

exit

uv

This removes the package from your local environment:

uv pip uninstall mojo && uv sync

This deactivates your virtual environment:

deactivate

pip

This removes the package from your local environment:

pip uninstall mojo

However, this won't uninstall mojo dependencies, so some "sub packages" remain installed. Consider using pip-autoremove or switch to a better package manager like Pixi.

This deactivates your virtual environment:

deactivate

conda

This removes the package from your local project:

conda remove mojo

This deactivates your virtual environment:

conda deactivate

What's included

We actually offer two Mojo packages: mojo and mojo-compiler.

For most situation, you want mojo because it includes all the developer tools (it's a superset of the mojo-compiler package).

mojo

This gives you everything you need for Mojo development.

Includes:

• mojo CLI (includes the Mojo compiler)
• Mojo standard library
• mojo Python package
• Mojo language server (LSP) for IDE/editor integration
• Mojo debugger (includes LLDB)
• Mojo code formatter
• Mojo REPL

mojo-compiler

This package is smaller and is useful for environments where you only need to call or build existing Mojo code. For example, this is good if you're running Mojo in a production environment or when you're programming in Python and calling a Mojo package—situations where you don't need the LSP and debugger tools.

Includes:

• mojo CLI (includes the Mojo compiler)
• Mojo standard library
• mojo Python package

System requirements

To install mojo or mojo-compiler, your system must meet these specifications.

Mac

• macOS Sequoia (15) or later
• Apple silicon (M1/M2/M3/M4 processor)
• Python 3.10 - 3.14
• Xcode or Xcode Command Line Tools 16 or later
• We have limited compatibility for Apple Silicon GPUs. You may need to run xcodebuild -downloadComponent MetalToolchain, which downloads the Metal utilities required for GPU programming in later versions of Xcode.

Linux

• Ubuntu 22.04 LTS
• x86-64 CPU (with SSE4.2 or newer) or AWS Graviton2/3 CPU
• Minimum 8 GiB RAM
• Python 3.10 - 3.14
• g++ or clang++ C++ compiler
• To use GPUs, see the GPU compatibility

Windows

Windows is not officially supported at this time.

In the meantime, you can try Mojo on Windows with WSL, using a compatible version of Ubuntu (see our requirements for Linux).

GPU compatibility

Mojo supports both CPUs and GPUs, so you don't need a GPU to program with Mojo. But if you do want to program for GPUs with Mojo, we recommend the following GPUs.

Because we don't test every variant of a GPU architecture, and support for new architectures will improve incrementally, we've divided our list of compatible GPUs into 3 tiers:

Tier 1: Fully supported

We provide full support and testing for the following data center GPUs:

• NVIDIA B200 (Blackwell)
• NVIDIA H100 and H200 (Hopper)
• AMD Instinct MI355X (CDNA4)
• AMD Instinct MI300X and MI325X (CDNA3)

Tier 2: Confirmed compatibility

We've confirmed full compatibility with the following GPUs but we don't maintain tests for them:

• NVIDIA A100 and A10 (Ampere)
• NVIDIA L4 and L40 (Ada Lovelace)
• NVIDIA RTX 50XX series (Blackwell)
• NVIDIA RTX 40XX series (Ada Lovelace)
• NVIDIA RTX 30XX series (Ampere)
• NVIDIA Jetson Orin and Orin Nano (Ampere)

Tier 3: Limited compatibility

We've either confirmed or received reports that the following GPUs work for GPU programming with Mojo. Some can also execute basic graphs with MAX APIs. However, none of these currently run major GenAI models with MAX:

• Apple Silicon GPUs (M1 - M4)
• NVIDIA RTX 20XX series (Turing)
• NVIDIA T4 (Turing)
• NVIDIA GTX 10XX series (Pascal)
• NVIDIA Tesla P100 (Pascal)
• AMD Radeon RX 9000 series (RDNA4)
• AMD Radeon 800M series (RDNA3.5)
• AMD Radeon 8050S / 8060S (RDNA3.5)
• AMD Radeon 700M series (RDNA3)
• AMD Radeon RX 7000 series (RDNA3)

If you've had success with any GPUs not listed here, please let us know on Discord.

GPU software requirements

Make sure you have the corresponding GPU software:

• If you're on an NVIDIA GPU:

  • NVIDIA GPU driver version 580 or higher

    • Check your NVIDIA GPU driver version using nvidia-smi
    • To update, see the NVIDIA driver docs

• If you're on an AMD GPU:

  • AMD GPU driver version 6.3.3 or higher

    • For datacenter GPUs (MI300X/MI325X), see the Ubuntu native install guide
    • For Radeon GPUs on Ubuntu, see the Linux install guide for Radeon software
    • For Radeon GPUs on WSL, see the WSL install guide for Radeon software

Was this page helpful?

Thank you! We'll create more content like this.

Thank you for helping us improve!

😔 What went wrong?

Some code doesn’t work

It includes inaccurate information

It's missing information I need

It was difficult to understand

Other

Submit