How to Install Mojo 1.0 on Linux, Mac and Windows WSL

You can install Mojo 1.0 as a normal project dependency with uv or pixi. It runs on supported Linux systems, Apple-silicon Macs and Windows through WSL. A GPU is optional for learning the language.

Mojo reached version 1.0 on 11 August 2026. One week later, Modular released the compiler, tooling and remaining language source under the Apache 2.0 licence with LLVM exceptions. This guide uses the stable 1.0.0 package for a first CPU program; building the compiler is optional.

What changed with Mojo 1.0 and the open-source release?

Mojo 1.0 is the first stable language release. Modular says changes during the 1.x series should mainly be additive, although carefully managed breaking changes can still occur. Version 1.0 also standardises declarations around var, unifies closures and the Pointer type, adds Python-style lambda syntax, improves the language server and adds more memory-safety diagnostics.

On 18 August, Modular open-sourced the complete Mojo compiler and toolchain. The compiler source is now in the KGEN directory of the official modular repository. The repository licence is Apache 2.0 with LLVM exceptions.

There is one important distinction:

• Install the stable package when you want to learn Mojo or start an application.
• Build the repository’s main branch when you want to inspect the compiler or experiment with its current source. The repository documents main as tracking nightly development, so this source build can be ahead of stable Mojo 1.0.

For most readers, the package installation is the right starting point. Cloning and building the compiler is optional.

Mojo 1.0 system requirements

The official system-requirements page is the source of truth for specific GPUs and drivers. Do not buy hardware from a general claim that Mojo supports a vendor; check the exact architecture and driver combination first.

Step 1: prepare Windows with WSL, if needed

Linux and macOS users can continue to the next step. On Windows, open PowerShell as an administrator and install WSL:

wsl --install

Restart Windows if prompted, finish the Ubuntu setup and run the remaining commands inside the Ubuntu terminal. Mojo does not currently run as a native PowerShell application.

If WSL is already installed, check its distributions from PowerShell:

wsl --list --verbose

Use a maintained Ubuntu release that meets Mojo’s glibc requirement. The Microsoft WSL installation guide covers repair and distribution-selection steps.

Step 2: install uv

Mojo installs like a Python package. The official quickstart recommends either uv or pixi. This guide uses uv because it creates an isolated project and lock file without changing the system Python environment.

Run the official uv installer in Linux, WSL or macOS:

curl -LsSf https://astral.sh/uv/install.sh | sh

Close and reopen the terminal, then verify the command:

uv --version

Review any shell installation command before running it. The URL above is the one used in Mojo’s official quickstart; avoid similarly named third-party installers.

Step 3: create a Mojo 1.0 project

Create a small project and add the stable mojo package:

uv init mojo-hello
cd mojo-hello
uv add "mojo==1.0.0"

Using uv add records Mojo as a project dependency and creates the local environment. Confirm which compiler the project resolves:

uv run mojo --version

Check that the output begins with the stable 1.0 version before following version-sensitive examples. If it reports a nightly or beta build, inspect the project’s dependency constraint and selected package index rather than assuming every 1.x command behaves identically.

Step 4: create your first Mojo program

Open the project in your editor and create a file named hello.mojo with this code:

def main():
    var tools: List[String] = ["CPU", "GPU", "AI accelerator"]
    print("Hello from Mojo 1.0")
    for tool in tools:
        print("Target:", tool)

The example uses a main() entry point, an explicitly typed collection, a var declaration and a loop. It does not perform GPU work; the text simply confirms that the basic language and standard library are available.

Step 5: run the program

Run it through the project’s uv environment:

uv run mojo hello.mojo

You should see the greeting followed by the three target labels. That verifies the package and compiler can run a simple CPU program. It does not validate optional GPU support.

If you prefer activating the environment, use this on Linux, WSL or macOS:

source .venv/bin/activate
mojo --version
mojo hello.mojo

Run deactivate when finished.

Step 6: add the Mojo editor extension

Install the Mojo extension published by Modular from the VS Code Marketplace or Open VSX. It adds syntax highlighting, completion and debugging support. Open the mojo-hello directory rather than an unrelated parent folder so the editor can discover the project’s environment.

If the extension cannot find Mojo, first confirm uv run mojo --version works in the project. Then consult the installed extension’s environment-selection instructions and point it at that project’s .venv; command labels can vary with extension version.

Optional: install Mojo’s AI coding skills

Modular publishes agent skills intended to keep AI coding tools aligned with current Mojo syntax. If you already use a compatible coding agent and have Node.js available, the official command is:

npx skills add modular/skills

Inspect the skill contents and requested location before approving installation. A skill can improve an agent’s language guidance, but it does not validate generated code. Compile, test and review every change.

Mojo is a programming language, not a local model runner. If your actual goal is to choose a model that fits your computer, use the site’s llmfit hardware-matching guide. For an OpenAI-compatible local endpoint, see the LocalAI Windows guide. Those tasks are distinct from writing accelerated code in Mojo.

Optional: build the open-source Mojo compiler

Only do this if you want to read or experiment with the compiler source. A normal Mojo project does not need a source build.

Clone the official repository:

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

Create a small hello.mojo file in the repository root. Then use the Bazel wrapper and the configuration that builds Mojo from local source:

./bazelw run --config=build-mojo KGEN:mojo -- run hello.mojo

According to Modular’s open-source announcement, that command downloads or builds the required components, builds the compiler and standard library, and runs the file. The first build is substantially more work than installing the package, so allow it to finish rather than repeatedly restarting it.

Version warning: the repository’s main branch follows nightly development. This is the branch containing the newly published compiler source, and it can be newer than the stable 1.0 package installed earlier. Do not compare their output as though they are guaranteed to be the same build.

The August 18 source-release announcement says Modular was not yet accepting compiler or toolchain contributions. The standard library, documentation, kernels and several other areas do accept contributions under their documented process. Open an issue before planning a large change.

How to update or remove Mojo

From the project directory, restore the locked environment:

uv sync
uv run mojo --version

This guide pins Mojo to 1.0.0. To upgrade deliberately, review the target release notes, change the dependency constraint with uv add "mojo==TARGET_VERSION" using a verified release number, and rerun the CPU example. Keep the previous lockfile in version control. Stable does not mean frozen forever.

To remove Mojo from this project:

uv remove mojo

Delete the project directory only if it contains nothing you need. Removing a dependency is safer than deleting a working directory to fix an environment problem.

Troubleshooting Mojo 1.0

mojo: command not found

Run the compiler through the project environment with uv run mojo --version. If that works, the package is installed and only the shell environment was inactive. Otherwise run uv sync in the project and check that mojo remains listed in pyproject.toml.

Mojo will not install in Windows PowerShell

Use Ubuntu inside WSL. The current requirements explicitly say that Mojo does not support native Windows. Installing more Python packages in PowerShell does not change that platform requirement.

Linux reports a glibc or CPU instruction error

Check ldd --version and compare the result with the glibc 2.34 minimum. On x86-64, Mojo currently requires the x86-64-v3 instruction set. Older systems may need a supported machine or a compatible container rather than a flag that bypasses the check.

The linker is missing

Install a supported C toolchain on Linux, such as GCC or Clang. On macOS, install Xcode or Xcode Command Line Tools 16 or later. Reopen the terminal and rerun the simple CPU program before attempting a GPU example.

The VS Code extension cannot find the SDK

Open the project folder, verify uv run mojo --version in its terminal, and follow the installed extension’s environment-selection instructions for that .venv. Avoid pointing it at a different global environment.

The source build fails but the packaged compiler works

Treat these as separate environments. The package is the supported way to start programming, while the repository build follows current source and a more complex dependency graph. Save the first Bazel error, confirm you are in the official repository and consult the official source-build instructions before changing build flags.

GPU code does not run

First confirm the CPU example works. Then compare the exact GPU and driver with Modular’s compatibility table. General CUDA, ROCm or Metal support does not mean every GPU generation is supported. Do not use a performance tutorial written for a different architecture as proof that your system is configured correctly.

Frequently asked questions

Is Mojo 1.0 completely open source?

Modular says the language compiler, tooling and everything needed to build the language are now available in the public repository under Apache 2.0 with LLVM exceptions. Other Modular products and downloaded third-party components can have different terms, so check the relevant licence rather than applying the Mojo compiler’s licence to the entire platform.

Can I install Mojo natively on Windows?

No. The supported Windows path is WSL with a compatible Linux distribution. Native Windows support is not currently listed.

Do I need an NVIDIA GPU?

No. A GPU is optional for learning Mojo and running CPU programs. GPU programming has hardware- and driver-specific requirements for NVIDIA, AMD and Apple silicon.

Should I build the compiler from source?

Most users should not. Install the stable package for ordinary development. Build from source when you specifically want to inspect the compiler, reproduce current source behaviour or work on an accepted part of the repository.

Does Mojo replace Python?

Mojo uses Python-like syntax and supports Python interoperability, but that does not make every Python project a drop-in Mojo project. Treat porting as engineering work: identify the performance-sensitive part, preserve tests and measure the result on your own workload.

Can I submit compiler changes now?

The August 18 announcement said compiler and tooling contributions were not yet accepted, with an aim to open that process by the end of 2026. Check the current contribution policy before proposing compiler work; other documented areas already accept contributions.

Bottom line

Install Mojo 1.0 with a project manager such as uv, run a small CPU program and keep the environment isolated. That gives you the stable language without the cost and complexity of a source build.

The open-source compiler matters because the implementation can now be inspected and built publicly. Use the optional Bazel workflow only when you need that source, remember that main follows nightly development, and avoid performance claims until you have measured your own code and hardware.

Official sources

• Modular: Mojo is now open source
• Modular 26.5: Mojo 1.0 is here
• Official Mojo 1.0.0 release
• Mojo 1.0 quickstart
• Mojo system requirements and GPU compatibility
• Modular repository and licence
• Mojo compiler source and architecture notes
• Mojo first program and editor extension guide
• Microsoft WSL installation guide

Sources reviewed 10 September 2026 against the official documentation linked above. Record versions and validate the workflow in your own environment.