Mojo 1.0 Is Here: The CUDA Rival Goes Stable

0:00 On the 11th of August, Modular shipped Mojo version 1.0. Three years after the language went public, it finally has a stability promise attached. And the most important sentence in that announcement

0:11 is not a benchmark. During the 1.x series, changes should primarily be additive. The ground stops moving. Now, set that against what Modular did not publish that day, a single new

0:22 performance number. A language sold as the escape route from CUDA hit stability and said nothing about speed. Either the most candid launch of the year or the loudest silence in it. Both readings

0:33 have evidence. So, three things. One, what that additive promise binds and what it leaves open. Two, somebody did measure Mojo against CUDA on real hardware and it was not Modular. Three,

0:45 the compiler you would bet on is still closed source on the day it calls itself stable because a promise like this only means something to the people that churn already hurt. And Modular says so

0:55 itself. Its own release admits that frequent changes have made it difficult for the community to maintain long-term projects. Mojo went public in May 2023 and it has been rebuilding itself in the

1:06 open ever since. Start with the keyword for declaring an immutable variable, which was deleted outright. Modular's own proposal argued that named immutable variables are not a

1:17 core programming concept and that the naming of that keyword had caused a lot of early heat. So, the deprecation warning landed first, the hard error about a month later, and then the

1:27 keyword was gone. That is a three-step demolition of something people had already typed into real code. Then in May of 2026, inside the 1.0 beta itself, the function keyword got deprecated. The

1:40 release notes say Mojo now emits a warning on uses of fn that it becomes a compilation error in the next release, and that you should use def instead. Three months before calling itself

1:50 stable, Mojo deprecated the keyword its own tutorials were written around. The same beta removed negative indexing from every standard library collection, switched bounds checking on by default,

2:01 and made unsafe pointers non-null by design. Every one of those is defensible engineering. Taken together, they are the reason an infrastructure team would not touch this language. You cannot

2:11 staff a 2-year GPU kernel project on something that renames its function keyword in a point release. That is the audience the 1.0 promise is aimed at, not hobbyists. Teams with a compiler

2:21 engineer, a hardware budget, and a plan that runs past next summer. So, what does 1.0 actually put in the box? Closures got unified, so a stateless closure lifts to a top-level function

2:33 and can be handed across to C as a callback. The pointer zoo collapses toward a single pointer type, and the compiler now diagnoses reference invalidation before it bites you. There

2:43 are where clauses across the standard library with descriptive failure messages, variables consistently declared with var, and a language server that stops falling over in your editor.

2:53 None of that is a headline. All of it is what a language does when it stops experimenting. So, read the promise carefully because the wording is doing less work than the headline. The full

3:02 sentence is, "Breaking changes may still be made, but will be managed with care following the standards of how mature languages evolve over time." The example Modular picks for a mature language is

3:13 C++, which is a striking thing to say to an audience that arrived from Python looking for something calmer. Then there is the default, and this is the part worth pausing on. Language features are

3:23 stable unless explicitly marked experimental. Standard library APIs are unstable unless explicitly marked stable. That inversion is the entire fine print. The language freezes. The

3:34 library you actually call every day does not, unless somebody has tagged that specific function as stable. Modular also said, back in December 2025, that a source-breaking Mojo 2.0 would be

3:46 developed during the 1.x series behind an experimental flag you opt into. So, the real road map reads stability now and opt-in break later on a date that has not been published. And phase two of

3:58 the road map is still open. First-class async, algebraic data types and pattern matching, existentials and dynamic traits, and a formal private modifier are all listed as unstarted or in

4:09 progress. Phase three, classes, inheritance, untyped variables, has not been started at all. The road map describes itself as directional guidance rather than an

4:18 engineering plan with no timeline for completion. Even the founding pitch has moved. The road map now says Mojo may or may not evolve into a full superset of Python and that it's okay if it doesn't.

4:29 So, what are you actually agreeing to build on if the library is unstable by default and the goal posts are optional. Which brings us to the number Modular did not give you. Somebody else ran it,

4:40 published it, and won an award for it. Researchers at Oak Ridge National Laboratory benchmarked Mojo GPU kernels against Nvidia's CUDA and AMD's HIP and took best paper at the WACCPD workshop

4:51 at Supercomputing 2025 for scientific workloads. BabelStream and a seven-point stencil, both memory bound. MiniBUDE and Hartree-Fock, both compute bound, with Hartree-Fock leaning hard on atomic

5:03 operations. Two accelerators from two competing vendors, an Nvidia H100 and an AMD MI300A. The same Mojo source targeting both. On the memory bound kernels, Mojo came out

5:16 competitive with CUDA and with HIP. Same code, two vendors, no rewrite. That one sentence is the entire rival claim measured by people with no commercial reason to flatter it. The gaps are real

5:27 and the paper names them precisely. Atomic operations on AMD and fast math compute bound kernels on both AMD and Nvidia. The authors add that the learning curve and the programming

5:38 requirements are still fairly low-level, but that Mojo can close significant gaps in a fragmented Python ecosystem. That is a more useful paragraph than any launch day bar chart. When the vendor

5:49 skips the benchmark, the independent one is the only one that counts, and the hardware reach is the real product here. As of the 26.2 platform release, the same Mojo source targets Apple silicon

6:00 GPUs, Nvidia Blackwell parts, AMD's MI355X, Jetson Thor, and DGX Spark. The language is how you reach them. The reach is what you are buying. Now the part the release

6:13 thread mostly skipped. Modular is not an independent company anymore. On the 24th of June 2026, Qualcomm announced it was acquiring Modular in an all-stock deal reported at $3.9 billion. Chris Lattner,

6:26 who built LLVM, Clang, Swift, and MLIR, is now Qualcomm's executive vice president for advanced AI software. So the vendor-neutral compute layer now has an owner that sells silicon. Nothing

6:38 about that is disqualifying, but it is a fact you price into a five-year decision. Qualcomm's own release describes what it bought as a silicon-agnostic layer across devices,

6:48 edge, and data centers. One analyst put the logic plainly, "Nvidia's real moat has never been the GPUs. It's CUDA and the rewrite cost that keeps workloads pinned to their hardware. And Nvidia

6:59 still holds something like 85% of the AI accelerator market, so that rewrite cost is doing enormous work every quarter." Which is why a company with its own silicon paid billions for the language

7:10 whose whole purpose is making the rewrite unnecessary. The acquisition and the stability promise sits seven weeks apart. Though the 1.0 commitment was published in December 2025, months

7:21 before the acquisition was announced, Qualcomm inherited that promise. It did not invent it. There is one thing still standing between this and adoption, and it was the loudest complaint in the

7:30 launch thread. The Mojo compiler is closed source. The standard library is Apache 2.0 with LLM exceptions. The thing that compiles it is not. That library is where the community actually

7:42 lives. Since it opened in March 2024, nearly 200 contributors have landed more than 1,100 pull requests, changing over 200,000 lines of code, and more than 1,000 other people filed the issues that

7:53 shaped it. On Hacker News, the release cleared 340 points, and the top comment was somebody saying they still don't have a good grasp of what problem this language aims to solve. Another was

8:03 blunter. No value in a language with a closed-source compiler. Modular's answer is a promise to open source the compiler and in 2026, with the language site hinting it happens at ModCon on the 18th

8:16 of August in San Francisco, which lands 1 week after the stability announcement, so the biggest objection has a deadline on it. The licensing is friendlier than its reputation, too. Self-hosted

8:27 production is free on CPUs and Nvidia GPUs, and free on other accelerators up to eight devices. Past that, you talk to Modular about enterprise terms. So, here is the verdict. Mojo 1.0 is worth

8:39 adopting right now for exactly one job, writing GPU kernels that have to run on more than one vendor silicon, inside a team that already employs somebody who enjoys compilers. For that team, the

8:50 additive promise plus Oak Ridge's memory-bound parity is enough to start a project you will still be maintaining in 2028. For everyone else, and that is most of you, this changes nothing this

9:01 quarter. If your fleet is all Nvidia and CUDA is working, keep going. Mojo is not a drop-in replacement for Python. Crossing the Python boundary still cost you, and a closed compiler is a real

9:12 reason to wait 1 week and see what ModCon actually ships. If nothing opens on the 18th, that tells you more than the version number did. But, the signal worth trusting is not the number one. A

9:22 vendor wrote down a constraint on its own future freedom, and skipped the free marketing win of a bar chart. Announcements are cheap, constraints cost something, which is worth weighing

9:32 against the last time this designer shipped a 1.0. Swift reached 1.0 in September 2014. Two years later, Swift 3 renamed almost everything and shipped with an official migration guide. That

9:44 is not an accusation. It is the reason the word to watch in modular sentence is primarily not additive, which leaves a question that outlives this release. What happens to a vendor neutral compute

9:55 layer the first time its owners own silicon is the slowest thing it targets.