Mojo: Modular AI’s New High‑Performance Programming Language for AI Research and Production

Mojo is a new programming language developed by Modular AI, a company founded in 2022 by Chris Lattner and Tim Davis with the goal of rebuilding global machine‑learning infrastructure from the ground up.

Combining Python’s usability with C‑level portability and performance, Mojo targets AI research and production, leveraging MLIR to exploit vector, threading, and AI‑hardware units.

Modular AI announced Mojo in May, reporting over 120 000 developers registering on the Mojo Playground and 190 000 participating in Discord and GitHub discussions, and secured a $100 million funding round.

On September 7, Mojo was officially released for download, initially supporting only Linux, with plans for macOS and Windows. The release includes a compiler and the Mojo SDK, which bundles a full set of developer tools and IDE extensions.

The SDK tools include:

mojo driver : a REPL shell for building, running, packaging Mojo modules, generating documentation, and formatting code.

VS Code extension : syntax highlighting, auto‑completion, and other productivity features.

Jupyter kernel : enables Mojo notebooks that can intermix Python code.

Debugger (coming soon) : allows stepping through running Mojo programs, even mixed C++/Mojo code.

Official benchmarks claim Mojo is 35 000× faster than Python, while the development team later reported performance up to 68 000× faster, highlighting its ability to combine dynamic and static language advantages.

Example code demonstrates calculating Euclidean distance using Mojo’s tensor library, showing both a naïve implementation and a more optimized function:

$ mojo
Welcome to Mojo! 🔥
Expressions are delimited by a blank line.
Type `:mojo help` for further assistance.
1> %%python
import numpy as np
n = 10000000
anp = np.random.rand(n)
bnp = np.random.rand(n)
6> from tensor import Tensor
let n: Int = 10000000
var a = Tensor[DType.float64](n)
var b = Tensor[DType.float64](n)
for i in range(n):
a[i] = anp[i].to_float64()
b[i] = bnp[i].to_float64()
13> from math import sqrt
def mojo_naive_dist(a: Tensor[DType.float64], b: Tensor[DType.float64]) -> Float64:
var s: Float64 = 0.0
n = a.num_elements()
for i in range(n):
dist = a[i] - b[i]
s += dist*dist
return sqrt(s)
23> fn mojo_fn_dist(a: Tensor[DType.float64], b: Tensor[DType.float64]) -> Float64:
var s: Float64 = 0.0
let n = a.num_elements()
for i in range(n):
let dist = a[i] - b[i]
s += dist*dist
return sqrt(s)
31> let naive_dist = mojo_naive_dist(a, b)
let fn_dist = mojo_fn_dist(a, b)
print(fn_dist)
print(naive_dist)

Mojo also supports building static, dependency‑free executables. The following commands compile and run a simple "Hello Mojo" program:

$ mojo build hello.🔥
$ ./hello
Hello Mojo !
$ ls -lGtranh hello*
-rw-r--r-- 1 0 817 Sep 3 23:59 hello.🔥

For more information, see the official Mojo blog post and the Modular AI Twitter announcement.