Latest

Technology

It was born to dethrone Python and is now open source: this is Mojo 1.0

It was born to dethrone Python and is now open source: Mojo 1.0 is released to revolutionize AI with the speed of C++ and a familiar syntax.

Mojo, the language that wants to dethrone Python, is open source
Mojo, the language that wants to dethrone Python, is open source

The tech world is said to advance thanks to programming languages like Python, but a new language, Mojo, may be about to change this. And all because on August 18, 2026, during ModCon 2026 in San Francisco, Modular announced that Mojo, its high-performance programming language, is now fully open source under the Apache 2.0 license, including its compiler and its entire toolchain.

The decision comes seven days after Mojo reached version 1.0, and three weeks after Qualcomm, the well-known chip company, completed its acquisition of Modular for about 3.9 billion dollars. Thus, what looks like a minor and unimportant piece of news means a full-blown revolution. Especially for the artificial intelligence ecosystem, an ecosystem built on Python but increasingly colliding with its performance limits. At this point, Mojo presents itself as the perfect heir: a language that shares syntax with Python, compiles to native code with the speed of C or C++, and aims to run on any AI accelerator without rewriting the software.

But it is not a language only for AI; it is a language that can be used for general purposes, and that can completely change the Python ecosystem that has grown so much for one reason: the ease of accessing the language, porting it and using it on all kinds of devices.

Mojo, a supercharged Python

Mojo was born as an internal response from Modular to the problem of programming its own infrastructure: to do the same thing, you had to combine Python, C++, CUDA and kernel languages. Chris Lattner, co-founder and CEO of Modular (creator of the LLVM compiler, the Swift language and the Clang frontend), and Tim Davis designed a language that Modular describes as "Python++", highlighting Python's syntax and usability, with low-level control and the performance of C++, Rust or CUDA.

Technically, Mojo is a compiled (ahead-of-time) language built on the MLIR and LLVM compiler infrastructure. It supports zero-cost abstractions, optional static typing, compile-time metaprogramming, manual memory management and SIMD types. It includes keywords such as let/var or fn, alongside def, which preserves Python's dynamic behavior. The stated goal is to eventually become a superset of the language by making valid Python code valid Mojo code. With this in mind, the aim is to facilitate migrating code from Python to Mojo, with all the benefits that entails, especially in terms of performance.

WordPress bets on humans to compete with AI

The "N languages" problem and heterogeneous hardware

Modular's thesis for driving this is that AI has fragmented systems programming. Teams that train and deploy models now handle several languages at once: Python for the model, C++ for the runtime, CUDA or OpenCL for GPU kernels, and the proprietary stacks of each accelerator manufacturer. Mojo wants to unify that "N languages problem" into a single one, capable of targeting CPUs, GPUs, NPUs and ASICs from different manufacturers with the same source code.

That premise has become more urgent with the diversification of AI hardware. For years, NVIDIA's CUDA was de facto the only path for accelerated computing. But the inference market has fragmented: Google trains and serves with TPUs, Amazon with Trainium, and Qualcomm, AMD and Intel compete for data centers. At ModCon 2026, Modular announced support for AWS Trainium, Google TPUs, the Qualcomm Cloud AI 100 and Qualcomm Dragonfly accelerators, in addition to the NVIDIA and AMD GPUs it already supported. This means that every time a new accelerator enters the market, developers must rewrite part of their technology stack, but now with Mojo, that problem disappears.

Faster than Python

Mojo's commercial promise rests on aggressive performance figures. Modular claims that, in compute-intensive workloads, Mojo can be up to 68,000 times faster than pure Python and reach the level of C++ or CUDA. An example of Mojo's potential is a canonical test that consists of calculating the Euclidean distance between vectors of 10 million elements. The problem solved using Python takes about 790 ms to complete, but with Mojo, it takes only 13 ms. That is, about 60 times faster than Python and twice as fast as the same operation with NumPy.

But the technical nuance here is important. Python "is not slow" in itself for computation, but because it delegates to libraries written in C. NumPy, for example, is fast because its core is in C/C++. Mojo's advantage is making that external layer unnecessary. To do so, Mojo allows writing the entire algorithm in a single language that compiles to machine code. Thus there is no conversion; Mojo allows speaking directly to the machine and its hardware, eliminating layers of abstraction that Python does have.

An almost 1:1 migration

On the other hand, Modular presents Mojo as a Python replacement with a migration close to 1:1. However, Mojo does not today run arbitrary Python code unchanged; in reality, standard library functions are missing (for example, shutil), it does not support module-level expressions and, until recently, lacked f-strings and named format arguments. The documentation itself warns that the superset goal will be reached "over time" and that the current focus is high-performance computing, not surface-level compatibility.

However, where migration does come close to 1:1 is in the pragmatic workflow that Modular promotes. Mojo can import Python libraries directly using the CPython runtime without modification, and with 100% compatibility for existing libraries. And, in the reverse direction, it can expose modules compiled in Mojo as native Python extensions. The recommended pattern is incremental porting, that is, leaving the Python code intact and rewriting in Mojo only the critical loops and hot paths. That strategy, rather than a universal copy-and-paste, is what makes a migrated Python project "look like" a Mojo project with minimal effort.

Basically, Modular tells you to use Python for the things that are not critical, and leave the critical performance points in the hands of Mojo and its advantages. A win-win relationship, for large projects, because the performance gain is not insignificant.

Europe builds the AI highways and lets China manufacture the cars

Same code, new silicon

But perhaps the most relevant point of Modular's presentation is the documentation of the Qualcomm Cloud AI 100, an inference NPU, from zero to serving Gemma 4 31B in less than six months. The language compiles to Qualcomm's LLVM Hexagon backend, and the kernels are written with the same DeviceContext abstraction that already targets NVIDIA and AMD GPUs. Thus the team went from a "hello world" with GPT-2 to serving the full Google Gemma 4 model with speculative decoding and a MoE variant, reusing the existing infrastructure. The company claims that enabling each new platform required a more than 10x reduction in engineering effort compared with traditional stacks.

What does all this mean? Mojo is capable of enabling native, local, high-performance AI on devices such as smartphones, without having to rewrite entire projects to achieve it. Lower cost for companies, greater availability of code to design platforms that can go anywhere. From personal computers, through supercomputers, to embedded devices and smartphones.

A threat to the Python ecosystem?

The most immediate impact is for AI developers who work with Python. Mojo does not eliminate the Python ecosystem; in fact, it depends on it for interoperability, but it attacks exactly the bottleneck most felt in production: slow hot paths, manual kernel management and dependence on proprietary per-accelerator stacks. For teams that want to squeeze non-NVIDIA hardware, or that need a single end-to-end language (model, kernels, serving), Mojo offers a real alternative to the Python + C++ + CUDA combination.

The compiler's open source nature also reduces the risk for those who adopt the language: it no longer depends on a company's binary releases to inspect, debug or modify the compiler. And the stability of 1.0 sets a contract that allows building long-term products. In exchange, those who migrate must assume that 1:1 compatibility with Python is still a goal under construction, not an achieved state: real migration involves incremental porting and interoperability with CPython.

The underlying challenge remains cultural. Python dominates AI not only because of its syntax, but because of its community, its libraries and its tooling ecosystem. Mojo has in its favor an unusual technical pedigree, financial backing and now the weight of Qualcomm; it has against it the need to prove that it can build its own ecosystem without replacing Python's, and to sustain its promise of neutrality under a chip owner. Its path to 1.0 and open source has been executed with discipline; what remains to be proven is whether that discipline turns Python's "heir" into its real replacement.

AI changes the rules of development, warns the World Bank

José Maldonado

Author

José Maldonado

Activist and blogger on technology, free software and blockchain.

The latest
From Huang to Botín, from Zara to Byron: corporate responsibility in global capitalism

Keep reading