By ByteBot
Mojo 1.1 shipped on September 17, and the version number is almost beside the point. The real news is that Modular is now accepting external contributions to the Mojo compiler — the first time this has been true since the language was created. Open-sourcing code and accepting contributions are different things. Open-source-but-read-only is a window into a room you cannot enter. Mojo 1.1 opens the door.
The Qualcomm Context You Need
Modular did not open its compiler in a vacuum. Qualcomm closed a roughly $3.9 billion all-stock acquisition of Modular on July 29, 2026. Chris Lattner, Modular’s founder and the creator of LLVM and Swift, moved to Qualcomm as EVP of Advanced AI Software and Platforms. Mojo 1.0 hit GA in August under Qualcomm ownership. The entire compiler stack went Apache 2.0 on August 18. And now, just over a month later, external contributions are being accepted.
The timing is not coincidental. Developers were openly skeptical that a chip company with its own NPU products would maintain a genuinely hardware-agnostic language. Qualcomm’s answer has been to make it harder to quietly deprioritize NVIDIA or AMD support — you cannot easily do that when the community owns pieces of the compiler. Opening contributions is partly a governance move, not just an engineering one.
What Actually Changed in Mojo 1.1
Modular migrated its internal compiler issues to public GitHub, reorganized the codebase around a unified top-level Mojo directory containing both the compiler and standard library, and published a contribution guide. One honest caveat from early coverage: the contribution review policy and CLA process were not fully documented at launch. The door opened before all the paperwork was finished. Expect some process friction if you submit a PR in the next few weeks.
On the language side, the headline change is contextual type inference in more places. You can now write SIMD[.float64, 4] instead of SIMD[DType.float64, 4] — a small thing, but a sign of the language maturing toward less boilerplate. The String, SIMD, and List standard library APIs are now marked stable, which is the signal you need if you are evaluating Mojo for production kernel work. Stability means you can write code today without expecting it to break next quarter.
Mojo 1.1 also completes cleanup from the 1.0 migration: the fn keyword, alias, __comptime_assert, and the @parameter if/for syntax are removed. If you are picking up Mojo now, you are starting with a cleaner surface. One migration note worth flagging: GPU kernel code using std.gpu needs to move to max.gpu — same APIs, different import path.
MAX 26.6 Performance Numbers
Released alongside Mojo 1.1, MAX 26.6 posts some aggressive hardware numbers. NVIDIA B200 gets up to 4.8x faster Gemma 4 decode attention and 16x faster low-batch NVFP4 quantization. AMD MI355 sees up to 6.6x faster decode attention projections. MoE routing improved 7.9x. These are hardware improvements in the inference serving layer — not synthetic Python comparisons. If you run inference at scale, these numbers are worth benchmarking in your stack.
Who This Is Actually For
Mojo is not coming for Python’s position in data science notebooks. That framing — “Mojo will replace Python” — is marketing noise. Python still has an overwhelming library and tooling advantage at the framework level. Mojo’s value is one layer down: writing custom GPU and CPU kernels, building inference infrastructure, and targeting heterogeneous hardware without rewriting code for every accelerator. If you are a data scientist, PyTorch is still your default. If you are an ML infrastructure engineer writing the layer that PyTorch runs on, Mojo now has a stable API surface, an open compiler, and Qualcomm hardware integration backing it.
Realistic speedup expectations: early adopters report around 12x improvements running existing code through Mojo without deep optimization. The “35,000x faster than Python” benchmark compared fully vectorized Mojo against single-threaded naive Python — a number designed to appear in headlines, not production benchmarks.
The Inflection Point
Language communities reach meaningful inflection points when the compiler becomes genuinely open to external shaping. Rust’s error messages became exceptional when contributors could improve them directly. TypeScript’s velocity increased when the community could patch the compiler without waiting on Microsoft’s internal queue. Mojo is at the same point now. The language will evolve faster because the people using it can change it. Whether Qualcomm’s governance will actually allow that at scale is still an open question — but the architecture for it is in place.
The Mojo compiler and Modular platform are on GitHub at github.com/modular/modular. The contribution guide is in the repo. Public issues are now the actual internal issues — which means you can see exactly what the team is working on and weigh in before features ship.
