An Overview of Mojo: A New High‑Performance Language for AI Development

Mojo is a new programming language announced by Modular, positioned as a high‑performance superset of Python aimed at AI developers.

It uses the file extensions .mojo and .🔥 . The language is designed to be fully compatible with Python while offering significant speed improvements and modern language features.

Key language features include:

Progressive types : optional type annotations that enable better performance and static checking.

Zero‑cost abstractions : C++‑style abstractions that do not sacrifice performance.

Ownership and borrow checker : inspired by Rust, providing compile‑time safety.

Full MLIR power : direct access to the Multi‑Level Intermediate Representation for low‑level optimizations.

Mojo can call Python libraries directly, allowing developers to leverage the existing Python ecosystem without rewriting code.

Example “Hello World”:

print("Hello World")  #> Hello World

Function definition uses fn instead of Python’s def and supports var and let for mutable and immutable variables:

fn foo():
var x: Int = 1
x += 1
let y: Int = 1
print(x, y)  #> 2 1
foo()

Mojo’s struct provides a static, memory‑compact alternative to Python classes, supporting custom constructors and operator overloading:

struct MyIntPair:
var first: Int
var second: Int
fn __init__(inout self, first: Int, second: Int):
self.first = first
self.second = second
fn __lt__(self, rhs: MyIntPair) -> Bool:
return self.first < rhs.first or (self.first == rhs.first and self.second < rhs.second)
let p1 = MyIntPair(1, 2)
let p2 = MyIntPair(2, 1)
if p1 < p2: print("p1 < p2")  #> p1 < p2

Parameter passing differs from Python: functions defined with def copy arguments by value, while fn passes immutable references by default. To modify arguments, the inout keyword is required.

def foo(lst):
lst[0] = 5
print(lst)
x = [1, 2, 3]
foo(x)
print(x)  # Python prints [5, 2, 3] twice

In Mojo, the same code prints [5, 2, 3] inside the function and [1, 2, 3] outside because the argument is copied.

Ownership semantics are expressed with owned and borrowed keywords. Transferring ownership uses the ^ suffix:

fn use_ptr(borrowed p: UniquePtr):
print(p.ptr)
fn take_ptr(owned p: UniquePtr):
print(p.ptr)
fn test_ownership():
let p = UniquePtr(100)
use_ptr(p)      #> 100
take_ptr(p^)    #> 100

Attempting to use p after ownership has been moved results in a compile‑time error.

Mojo also exposes MLIR directly. A custom boolean type can be built on top of the MLIR i1 type:

alias OurTrue: OurBool = __mlir_attr.`true`
alias OurFalse: OurBool = __mlir_attr.`false`
@register_passable("trivial")
struct OurBool:
var value: __mlir_type.i1
fn __init__() -> Self:
return OurFalse
fn __init__(value: __mlir_type.i1) -> Self:
return Self {value: value}
fn __bool__(self) -> Bool:
return Bool(self.value)

With this definition, the ~ operator can be implemented via __invert__ and used like a regular boolean.

let f = OurFalse
if ~f: print("false")  #> false

Mojo is still in early development: many Python features such as class are not yet supported, and the tooling is limited. Nevertheless, its design—combining Python compatibility, modern type and ownership systems, and direct MLIR access—makes it a promising candidate for performance‑critical AI workloads and potentially broader applications.