Mojo is a modern programming language designed for high-performance computing, AI, machine learning, CPU programming, GPU programming, and systems-level development.
If you want to start learning Mojo, the first step is setting up the language correctly on your computer.
The current stable version of Mojo is 1.0.0, and the official installation process supports:
- Linux
- macOS
- Windows through WSL
Mojo can currently be installed using Python or Conda-compatible package management tools, with uv and Pixi being the recommended options.
This complete guide explains how to install Mojo, configure your development environment, verify the installation, create your first Mojo project, run a Mojo program, and solve common installation problems.
Mojo Installation Overview
The basic installation process looks like this:
Check System Requirements
↓
Install uv or Pixi
↓
Install Mojo
↓
Verify Installation
↓
Create Project
↓
Create .mojo File
↓
Run First Program
For most beginners, installing Mojo through either uv or Pixi is the easiest approach.
Mojo System Requirements
Before installing Mojo, make sure your system is supported.
The current Mojo 1.0 system requirements include support for:
- Linux
- macOS
- Windows through WSL
A GPU is not required to learn or run normal Mojo programs. GPU support is optional and only needed when you want to work with GPU-specific programming.
Mojo Requirements for Linux
Mojo currently supports Linux systems with:
glibc 2.34 or later
Ubuntu 22.04 LTS or later is officially tested.
Other Linux distributions may also work if they meet the required system libraries and hardware requirements.
Examples include:
- Ubuntu
- Debian-based distributions
- Fedora
- Other compatible Linux distributions
However, Ubuntu is usually the simplest option for beginners.
Mojo Requirements for macOS
For macOS, the current stable Mojo requirements include:
- macOS Sequoia 15 or later
- Apple Silicon
Supported Apple chips include current Apple Silicon systems such as:
- M1
- M2
- M3
- M4
- M5
Intel-based Macs are not listed as supported for the current Mojo 1.0 release.
Mojo Requirements for Windows
Mojo does not currently run as a native Windows application.
Instead, Windows users can install Mojo through:
Windows Subsystem for Linux — WSL
The normal setup looks like:
Windows
↓
WSL
↓
Ubuntu
↓
Mojo
The Mojo documentation recommends using a compatible Ubuntu environment inside WSL.
Hardware Requirements
For normal Mojo development, the official system requirements currently specify at least:
8 GB RAM
Supported CPU requirements differ by system.
Linux supports suitable modern x86-64 or ARM64 processors, while macOS requires Apple Silicon.
Again, a dedicated GPU is not required for basic Mojo development.
Method 1: Install Mojo Using uv
One of the simplest ways to install Mojo is using uv.
uv is a fast Python package and project management tool.
The process is:
Install uv
↓
Install Mojo
↓
Verify
Step 1: Install uv
On macOS or Linux, open your terminal and run:
curl -LsSf https://astral.sh/uv/install.sh | sh
This installs uv on your machine.
After installation, you may need to restart your terminal.
Then check whether uv is available:
uv --version
If a version number appears, uv is installed correctly.
Step 2: Install Mojo Using uv
Once uv is available, run:
uv pip install mojo
This installs the stable Mojo package.
After installation, check Mojo:
mojo --version
You should see the installed Mojo version.
Create a Mojo Project Using uv
Instead of installing Mojo globally into an existing environment, you can create a dedicated project.
Run:
uv init hello-world
Move inside the project:
cd hello-world
Then add Mojo:
uv add mojo
The official Mojo install guide supports this project-based workflow.
A project-based setup is useful because dependencies remain organized.
Example uv Workflow
Your complete setup may look like:
curl -LsSf https://astral.sh/uv/install.sh | sh
uv init hello-world
cd hello-world
uv add mojo
Then create:
main.mojo
and start programming.
Method 2: Install Mojo Using Pixi
Pixi is another officially recommended way to install Mojo.
It manages:
- Dependencies
- Environments
- Packages
- Project configuration
Pixi is particularly useful when you want isolated and reproducible development environments.
Step 1: Install Pixi
Open a terminal and run:
curl -fsSL https://pixi.sh/install.sh | sh
Then restart your terminal so that the command becomes available.
Check the installation:
pixi --version
Step 2: Create a Mojo Project
Create a new project with the required package channels:
pixi init hello-world \
-c https://conda.modular.com/max/ \
-c conda-forge
Then move into the project directory:
cd hello-world
Step 3: Add Mojo
Run:
pixi add mojo
Mojo will now be installed inside the Pixi project environment.
Step 4: Enter the Pixi Environment
You can enter the project environment using:
pixi shell
After that, check:
mojo --version
You can also run Mojo through Pixi without opening a shell:
pixi run mojo --version
uv vs Pixi for Installing Mojo
Both methods work well.
| Feature | uv | Pixi |
|---|---|---|
| Installation | Simple | Simple |
| Python-style workflow | Excellent | Good |
| Conda-style packages | Limited | Excellent |
| Project environments | Yes | Yes |
| Beginner friendly | Yes | Yes |
| Recommended by Mojo | Yes | Yes |
If you already use Python tooling, uv may feel easier.
If you prefer Conda-style environments and reproducible package management, Pixi is a strong option.
How to Verify Mojo Installation
After installing Mojo, run:
mojo --version
If the installation is successful, you should see the installed Mojo version.
For example:
Mojo 1.0.0
The exact output may contain additional compiler information.
Create Your First Mojo File
Once Mojo is installed, create a new file:
hello.mojo
Add:
def main():
print("Hello, Mojo!")
This is a complete basic Mojo program.
Run Your First Mojo Program
Open the terminal inside the folder containing hello.mojo.
Run:
mojo hello.mojo
You should see:
Hello, Mojo!
If you see the output, your Mojo setup is working correctly.
The official Mojo quickstart uses the same main() entry-point pattern and runs source files directly with the mojo command.
Understanding the Project Structure
A simple Mojo project may look like:
hello-world/
│
├── main.mojo
├── README.md
└── project configuration
As your project grows, you might use:
hello-world/
│
├── main.mojo
├── utils.mojo
├── models/
├── tests/
└── configuration files
You do not need a complicated folder structure when learning Mojo.
Start with one or two files.
How to Build a Mojo Program
Running:
mojo hello.mojo
executes your program.
You can also compile Mojo code into an executable.
For example:
mojo build hello.mojo
This creates a compiled application that you can execute separately.
Mojo Development Environment
You can write Mojo code in any normal text editor.
However, a proper code editor provides a much better experience.
A popular option is:
Visual Studio Code
Mojo currently provides editor extensions that offer functionality such as:
- Syntax highlighting
- Code completion
- Debugging support
The official installation documentation links to extensions through both the VS Code Marketplace and Open VSX Registry.
Install the Mojo VS Code Extension
Open Visual Studio Code.
Go to:
Extensions
Search for:
Mojo
Install the official Mojo extension.
After installation, open your .mojo file.
You should receive better language support than with a plain text editor.
Recommended Mojo Development Setup
A beginner-friendly setup can be:
Operating System
↓
Terminal
↓
uv or Pixi
↓
Mojo
↓
VS Code
↓
Mojo Extension
This provides everything needed for basic Mojo development.
Installing Mojo on macOS
On a supported Apple Silicon Mac, you can use uv.
Open Terminal and run:
curl -LsSf https://astral.sh/uv/install.sh | sh
Restart the terminal.
Then install Mojo:
uv pip install mojo
Verify:
mojo --version
Create:
hello.mojo
Add:
def main():
print("Hello from macOS!")
Run:
mojo hello.mojo
Installing Mojo on Linux
For Linux, first make sure your operating system meets Mojo’s requirements.
Ubuntu 22.04 LTS or newer is the safest supported option.
Install uv:
curl -LsSf https://astral.sh/uv/install.sh | sh
Restart the terminal.
Install Mojo:
uv pip install mojo
Verify:
mojo --version
Then create and run your first program.
Installing Mojo on Windows Using WSL
Windows currently requires WSL.
A simplified process is:
Windows
↓
Install WSL
↓
Install Ubuntu
↓
Open Ubuntu Terminal
↓
Install Mojo
Step 1: Install WSL
Open PowerShell as Administrator and run:
wsl --install
Windows may ask you to restart your computer.
Step 2: Launch Ubuntu
After installation, open Ubuntu through WSL.
You will be asked to create a Linux username and password.
Now you are working inside Linux.
Step 3: Update Ubuntu
Run:
sudo apt update
Then:
sudo apt upgrade
Step 4: Install uv
Inside WSL Ubuntu, run:
curl -LsSf https://astral.sh/uv/install.sh | sh
Restart the WSL terminal if required.
Step 5: Install Mojo
Run:
uv pip install mojo
Step 6: Verify
Run:
mojo --version
If the version appears, Mojo is ready.
Remember that Mojo currently relies on WSL rather than native Windows support.
Do You Need Python to Install Mojo?
Mojo can be installed through Python-compatible package managers such as uv.
However, that does not mean Mojo is simply a Python package or Python interpreter.
Mojo is its own programming language.
The packaging system is simply one method used for installation and dependency management.
Do You Need a GPU?
No.
A GPU is not required to:
- Learn Mojo
- Write basic programs
- Compile Mojo code
- Work with CPU-based applications
The official system requirements explicitly list GPU support as optional.
You only need suitable GPU hardware and drivers if you want to experiment with GPU programming.
Mojo GPU Setup
Advanced Mojo users can program supported GPUs from:
- NVIDIA
- AMD
- Apple Silicon
However, GPU configuration depends heavily on hardware and operating system.
For beginners, it is better to complete your basic Mojo setup first.
Start with:
CPU Programs
↓
Learn Mojo
↓
Understand Memory
↓
Learn Parallelism
↓
GPU Programming
Apple Silicon GPU Setup
For supported Apple Silicon GPU development, current requirements include:
- macOS Sequoia 15 or later
- Xcode 16 or later
The Mojo documentation notes that some setups may also require downloading Apple’s Metal toolchain with:
xcodebuild -downloadComponent MetalToolchain
and installing Xcode Command Line Tools if necessary:
xcode-select --install
You do not need these additional GPU tools for basic CPU-only Mojo learning.
Stable Mojo vs Nightly Mojo
Mojo provides both stable and nightly builds.
For beginners, use:
Stable Mojo
The current stable documentation is for:
Mojo 1.0.0
Nightly builds contain newer changes but may also contain unfinished functionality or new bugs.
Installing Mojo Nightly With uv
If you specifically need the nightly version, the current official installation command is:
uv pip install mojo \
--index https://whl.modular.com/nightly/simple/ \
--prerelease allow
Beginners generally should not use nightly builds unless they need a feature unavailable in stable Mojo.
Installing Mojo Nightly With Pixi
For Pixi, create a project using the nightly channel:
pixi init hello-world \
-c https://conda.modular.com/max-nightly/ \
-c conda-forge
Then:
cd hello-world
and:
pixi add mojo
How to Check Which Mojo Version You Installed
Run:
mojo --version
With Pixi, you can also run:
pixi run mojo --version
Knowing your version is useful because Mojo syntax and APIs can differ between releases.
How to Update Mojo
If your project uses Pixi, Mojo packages can be updated using package management commands.
For example:
pixi update mojo
Pixi updates Mojo according to the version constraints configured in your project.
For other package managers, use their normal package update workflow.
How to Create a New Mojo Project
Using uv:
uv init my-mojo-project
Then:
cd my-mojo-project
Add Mojo:
uv add mojo
Now create:
main.mojo
Add:
def main():
print("My first Mojo project")
Run:
mojo main.mojo
Mojo Hello World Example
The simplest program is:
def main():
print("Hello, World!")
Save it as:
hello.mojo
Then run:
mojo hello.mojo
Output:
Hello, World!
This is the easiest way to confirm that the installation works.
Mojo Command Not Found Error
You may encounter:
mojo: command not found
This usually means:
- Mojo is not installed
- Your environment is not active
- The executable is not in your PATH
- Your terminal needs to be restarted
First try restarting the terminal.
Then check:
mojo --version
If using Pixi, try:
pixi run mojo --version
or enter the environment:
pixi shell
uv Command Not Found
If:
uv --version
does not work after installation, restart the terminal.
You may also need to ensure that uv’s installation directory has been added to your shell PATH.
Pixi Command Not Found
If Pixi is installed but the terminal cannot find it, restart your terminal.
Then try:
pixi --version
If the command still fails, review the installation output because it normally indicates where Pixi was installed.
Unsupported Operating System Error
Check the current Mojo system requirements.
Current Mojo 1.0 supports:
- Compatible Linux
- Apple Silicon macOS
- Windows through WSL
Native Windows and unsupported older systems may not work.
Mojo Installation on Intel Mac
The current Mojo 1.0 system requirements list Apple Silicon for macOS support.
That means Macs using older Intel processors are not part of the current supported macOS configuration.
macOS Version Problems
Check your macOS version with:
sw_vers
Current Mojo 1.0 documentation requires macOS Sequoia 15 or later on supported Apple Silicon Macs.
Linux glibc Error
If Mojo reports compatibility problems on Linux, check your glibc version:
ldd --version
Mojo currently requires:
glibc 2.34+
Ubuntu 22.04 LTS and newer are officially tested environments.
How to Uninstall Mojo
The exact uninstall command depends on the package manager you used.
If you created Mojo inside a project environment, removing the dependency or deleting the environment may be enough.
With Pixi, for example:
pixi remove mojo
Recommended Setup for Beginners
For someone learning Mojo for the first time, a simple setup is:
Linux
Ubuntu
+
uv
+
Mojo
+
VS Code
macOS
Apple Silicon Mac
+
uv
+
Mojo
+
VS Code
Windows
Windows
+
WSL Ubuntu
+
uv
+
Mojo
+
VS Code
You do not need complicated GPU drivers or AI frameworks when starting.
What to Learn After Installing Mojo
Once installation is complete, start learning:
Hello World
↓
Variables
↓
Data Types
↓
Conditions
↓
Loops
↓
Functions
↓
Structs
↓
Collections
↓
Modules
↓
Ownership
↓
Memory
↓
Performance
Do not jump directly into advanced GPU kernels.
Build your Mojo fundamentals first.
Common Mojo Installation Mistakes
Using an Unsupported Operating System
Always check current system requirements.
Installing Nightly Instead of Stable
Beginners should normally use stable Mojo.
Forgetting to Restart the Terminal
Tools such as uv or Pixi may not become available until a new terminal session starts.
Forgetting to Activate the Environment
Pixi users may need:
pixi shell
or:
pixi run
Testing Only the Version Command
Always create and run an actual .mojo program after installation.
Starting With GPU Configuration
You do not need GPU setup to begin learning Mojo.
Complete Mojo Installation Checklist
Before you start programming, confirm that:
- Your operating system is supported
- uv or Pixi is installed
- Mojo installation completed successfully
mojo --versionworks- Your editor is installed
- Mojo editor support is configured
- You created a
.mojofile - Your Hello World program runs successfully
Once all of these work, your Mojo development environment is ready.
Frequently Asked Questions
How do I install Mojo?
The current stable Mojo release can be installed using tools such as uv or Pixi. With uv, the basic command is:
uv pip install mojo
What is the current stable version of Mojo?
The current stable Mojo documentation is version 1.0.0.
Can I install Mojo on Windows?
Yes, but Mojo currently uses Windows Subsystem for Linux rather than native Windows execution.
Can I install Mojo on macOS?
Yes, on currently supported Apple Silicon Macs running macOS Sequoia 15 or later.
Can I install Mojo on Linux?
Yes. Mojo officially tests Ubuntu 22.04 LTS and later and requires a compatible system with glibc 2.34 or newer.
Do I need a GPU to install Mojo?
No. GPU support is optional.
Should I use uv or Pixi?
Both are officially supported recommendations. uv can be convenient for developers familiar with Python package workflows, while Pixi provides strong environment and Conda-style dependency management.
How do I check whether Mojo is installed?
Run:
mojo --version
What extension does a Mojo file use?
Mojo source files use:
.mojo
How do I run a Mojo file?
Run:
mojo filename.mojo
For example:
mojo hello.mojo
Should beginners install Mojo nightly?
Usually no. Use the stable release unless you specifically need experimental or upcoming functionality.
Final Thoughts
Installing Mojo is now relatively straightforward.
The easiest setup process is:
Supported Computer
↓
Install uv or Pixi
↓
Install Mojo
↓
Check mojo --version
↓
Create hello.mojo
↓
Run Your First Program
For uv users:
uv pip install mojo
For a Pixi project:
pixi init hello-world \
-c https://conda.modular.com/max/ \
-c conda-forge
cd hello-world
pixi add mojo
After installation, create:
def main():
print("Hello, Mojo!")
and run:
mojo hello.mojo
If you see the expected output, your Mojo development environment is ready.
From there, you can begin learning Mojo syntax, types, functions, structs, memory concepts, performance programming, and eventually CPU and GPU development.
