A new language front page went live at mojolang.org, and the pitch is precise: Python’s syntax, Rust’s memory safety, Zig’s compile-time metaprogramming, and GPU kernels written in the same file as your CPU code. Modular, the company behind Mojo, calls it “AI native” — a compiled, statically-typed language built to move performance-critical Python out of the interpreter without a full rewrite. That is a real problem for anyone who runs numerical or generative code, so it is worth an afternoon. But read to the bottom of the page first. One sentence there is the whole story.

Why this is possible now

Mojo is not a fresh idea dropped from nowhere. It sits on MLIR, the compiler infrastructure that grew out of the LLVM project and Chris Lattner’s work on Swift — the same lineage that now targets heterogeneous hardware, CPUs and GPUs and accelerators, from one intermediate representation. That is the frontier shift: compiler research reached the point where one language can lower to many chips without vendor-specific libraries or separately compiled kernels. Five years ago you wrote CUDA in one dialect and Python in another and glued them with hope. Mojo’s claim is that the glue is gone.

The Tool: Mojo, from Modular. It reads like typed Python, compiles ahead of time, exposes SIMD and GPU primitives as first-class syntax, and interoperates with the CPython ecosystem — you can import NumPy into Mojo and import Mojo back into Python. The front page proves the claim with two runnable kernels: a GPU vector_add over a TileTensor, and a SIMD mojo_square_array that squares an int64 array in place through simd_width_of[DType.int64]() — GPU and CPU work written in one syntax. For a computational designer who profiles a Grasshopper-adjacent mesh routine and finds Python is the bottleneck, that incremental path — rewrite one function, keep the rest — is the honest selling point.

Setup

curl -fsSL https://pixi.sh/install.sh | bash
# restart your shell, then:
pixi init hello-mojo && cd hello-mojo
pixi add mojo
pixi run mojo --version
echo 'def main(): print("Kaffi")' > hello.mojo
pixi run mojo hello.mojo   # prints: Kaffi

First steps:

1. Confirm the toolchain: pixi run mojo --version should print a build. If it does not, your shell has not picked up pixi — reopen the terminal.
2. Open hello.mojo and add a typed function: a def square(x: Float64) -> Float64: return x * x, call it in main, re-run. You now have a compiled, statically-typed function.
3. Replace the scalar loop with the SIMD form from the docs (append .md to any mojolang.org page to read it as Markdown) and re-run. Same result, different throughput — that gap is the point.

←TODAY: Mojo’s standard library is fully open-source on GitHub; the compiler is not — Modular says it plans to open-source it in 2026. →3012: the workflows that survive are the ones whose foundations you were allowed to fork. Fulcrum: a language is only as portable as its least-open layer, and today that layer is the compiler.

The control mechanism, named

Here is the sentence. Modular writes that it is committed to open-sourcing all of Mojo, “but the language is still very young and we believe a tight-knit group of engineers with a common vision moves faster than a community-driven effort.” That is a defensible engineering call. It is also, precisely, the shape of open-core lock-in: the parts you can inspect are open, the part that decides your build is not. So the question is not whether Mojo is good. It clearly is. The question is what you owe a compiler you cannot yet fork, and what it can charge you later.

Atelier: A Swiss computational-design studio evaluating Mojo should treat it as a dependency, not a religion. The office move: before any Mojo code touches a billable pipeline, write the exit clause — a one-page note listing which functions were ported, what the pure-Python fallback is, and the trigger (a licence change, a pricing move, a stalled 2026 open-source date) that sends you back to it. Trial Mojo on one non-critical kernel; keep the CPython version in the repo, not in memory.

Hack: Time one hot loop in Mojo, then time the identical loop in stock CPython, before you migrate a single line of production code. Migration decisions made on a vendor’s benchmark are decisions made by the vendor.

def main():
    var total: Float64 = 0.0
    for i in range(10_000_000):
        total += Float64(i) * Float64(i)
    print(total)

Wrap it as pixi run bash -c 'time mojo hello.mojo', then run time python -c "print(sum(i*i for i in range(10_000_000)))" and read the wall-clock gap. The number you get is yours, measured on your own hardware — the only benchmark a procurement note should quote.

Learn-it:

• Language home: mojolang.org
• Docs (append .md to any page for Markdown): mojolang.org/docs/manual/basics
• Full documentation index for tooling and agents: mojolang.org/llms.txt
• PAZ note: pair this with our Creative Coding concept panel — the same “expose three parameters, get a family of outcomes” instinct that p5.js teaches in the browser is what makes a fast kernel worth writing at all.

The move

Clone the setup, port exactly one function you already trust, and benchmark it against its Python twin on your own machine. Then write the exit clause in the same commit. Adopt Mojo for the speed; keep the fallback for the day the compiler’s licence, not its performance, becomes the story.