For three years, the biggest complaint about Mojo was not the syntax, the performance claims, or the missing ecosystem. It was that the compiler was closed. You could read the standard library, you could file issues, but the thing that turned your code into GPU machine instructions was a binary you had to download on faith. For a language whose creator, Chris Lattner, built his reputation on LLVM and Swift, two of the most open projects in compiler history, that sat badly with a lot of developers.
Then came the strangest possible sequence. Qualcomm announced an all-stock acquisition of Modular on June 24, 2026, valued around $3.92 billion at announcement. The deal closed at the end of July. Mojo hit version 1.0 the following week. And on August 18 at ModCon, Modular open sourced the entire compiler and toolchain under Apache 2.0 with LLVM exceptions. A chip company bought the language, and only then did the source drop.
The Hacker News thread reached 409 points, and the reaction splits into two camps that basically never overlap: people who say "finally, I can try this," and people who say "too late, the window closed." Both are worth listening to, because the honest answer to whether Mojo matters now depends on what you actually do with Python.
What Actually Got Released
The whole toolchain, not a teaser. The modular repository on GitHub now contains the Mojo compiler, the tooling, and everything needed to build the language from source. One command builds the compiler and runs a Mojo file against it:
./bazelw run --config=build-mojo KGEN:mojo -- run hello.mojo
That is a real bar to clear. This is not "source available with a look-but-do-not-touch license." Apache 2.0 is the same license family as the rest of the LLVM world, and the LLVM exceptions expand what you can do with distributed binaries. You can fork it today if you want.
But not contributions, yet. The announcement is explicit: Modular is not accepting contributions to the compiler and tooling right now, and aims to start "by the end of this year." Their stated reasoning is unusual and oddly timely: in an era of AI-generated code, they want to be deliberate about how contributions are handled. The standard library has accepted outside contributions since 2024, and Modular says it has drawn over 1,100 outside pull requests. This split, open code plus closed commit rights, kicked off the liveliest argument in the thread.
A bigger platform story landed the same day. At ModCon, Modular and Qualcomm also announced that Modular Cloud went generally available, that the MAX runtime expanded beyond Nvidia, AMD, and Apple Silicon to AWS Trainium, Google TPUs, and Qualcomm's own datacenter accelerators, and that Mojo is coming to Windows with Microsoft's help, per Forbes coverage of the event. Six chip vendors under one programming model is the actual product. Mojo the language is the on-ramp to it.
The Community Split, in Their Own Words
The license debate resolved fast. The top comment argued this is technically source-available until contributions open, but got corrected quickly. As one commenter put it: "It's open source under the Apache 2 license, not source available. Accepting contributions is not required to be open source." SQLite, the most deployed database in the world, does not accept outside contributions either. Open source has never meant open commit access.
The skeptics are not short on arguments. Platform reach is one. One developer's view: Mojo's potential "would be constrained to relatively niche and senior dev circles until they get a Windows release, which probably won't happen anytime soon. Python keeps the throne for now." The Windows port is announced but not shipped, and Mojo has been Linux-first (with macOS support) its entire life. Others went straight at the acquisition. "Can acqui-death be far behind...?" is one representative reply, and another prediction holds that Chris Lattner will move on within a year and the language will be subsumed into Qualcomm's internal stack.
The converted are genuinely converted, though. A financial engineer described his experience: "I didn't know anything about GPU programming and it almost felt dirty how easy it was to get some performant kernels running. Even I could do it." A developer who tried building the compiler reported the build pinned every core of a Threadripper 9970X for about 15 minutes, which tells you this is a serious compiler codebase, not a weekend project. And one of the more honest takes: "As long as it was proprietary, I could ignore it. Now, I guess I have to learn a little something about it."
The oldest wound is still open. When Mojo launched in 2023, the pitch was a Python superset: your existing Python code would bootstrap the ecosystem. That promise was quietly dropped in 2025. As Simon Willison notes, the team shifted to saying Mojo "may or may not evolve into a full superset of Python, and it's okay if it doesn't," betting on AI migration tooling instead of syntax compatibility. Today Mojo is its own language with Python-inspired syntax, not Python with a turbo button. "I wish they never abandoned the goal of being a true Python superset" is a sentiment you will find in every Mojo thread since.
Why a Chip Company Wants Your Language Open
This is the part I find most interesting as an engineer, because it explains the timing.
When Qualcomm buys a programming language, the obvious fear is that a hardware vendor will steer the software toward its own silicon. But the more useful lens is an old one: Joel Spolsky's Strategy Letter V, the commoditize-your-complement argument. A commenter in the thread raised exactly this: is Qualcomm commoditizing its complement?
Nvidia's moat was never just silicon. It is CUDA, the software layer that seventeen years of ML code is written against. Modular's MAX runtime is designed to be the neutral replacement: write your inference code once, run it on Nvidia, AMD, Apple Silicon, Trainium, TPU, or Qualcomm accelerators without a rewrite. For that pitch to work, the layer has to be trusted as neutral, and a proprietary compiler owned by a chip maker is the opposite of neutral. Open sourcing Mojo under Apache 2.0 is not charity. It is trust infrastructure for a business whose entire value proposition is hardware portability. Qualcomm wins if the software layer stops being a differentiator, because silicon then becomes the deciding factor, and silicon is the thing Qualcomm sells.
That is also the risk. Vendor-neutral foundations have a habit of developing hardware preferences once their owner needs to differentiate silicon. If Mojo and MAX run 10 percent better on Qualcomm chips in two years, the neutrality story gets complicated. The Apache 2.0 license is your insurance policy: the worst case is a fork, not a graveyard.
Mojo vs Python vs Rust for Numerical Work
If you write Python today, here is the comparison that actually matters. No table, just the axes:
- What you write: Mojo gives you Python-inspired syntax with an ownership system adjacent to Rust, compile-time metaprogramming similar to Zig, and first-class GPU programming without leaving the language. Python gives you Python, and you drop to C extensions, Numba decorators, or CUDA C when you need speed. Rust gives you maximum control with maximum ceremony, and GPU work means wading into ecosystem crates.
- Compatibility: Python wins by default because it is Python. Mojo abandoned the superset goal in 2025, so your existing code does not just run; AI-assisted migration is the officially suggested path. Treat Mojo as a new language you can read on day one, not one you already know.
- Ecosystem: Python's package universe is unmatched. Mojo's is young but real: the standard library is open and actively contributed to, and the closest thing to NumPy today is the community-built NuMojo project. If your workload needs an obscure SciPy function, you are still writing Python.
- Performance model: Mojo's pitch is a single language across CPU and accelerators, with manual memory management made safer through linear types. Numba gets you JIT-compiled CPU code with a decorator. Rust gets you predictable, safe systems performance. For GPU kernels specifically, Mojo users consistently report the lowest barrier to entry.
- Platform support: Python runs everywhere, including Windows. Rust runs everywhere. Mojo runs on Linux and macOS, with the Windows port announced at ModCon but not shipped.
- Governance: Python has the PSF, Rust has the Foundation, Mojo has Qualcomm. The license protects you, but the roadmap belongs to a company whose CEO keynoted the launch conference.
Who should use which: stay on Python with Numba if your bottleneck is a few hot loops inside a mature codebase, the migration cost will never justify a rewrite. Look hard at Mojo if you are writing GPU kernels or inference infrastructure from scratch, especially if hardware portability across vendors matters to you. Choose Rust when you need systems-level guarantees and your team already knows it. And if you are a Java developer like me whose "numerical work" is mostly calling inference APIs from Spring Boot services, none of this changes your week, but the MAX runtime's hardware neutrality might eventually change your inference bill.
Full Disclosure and How I'd Evaluate It
I have not written production Mojo. This piece is a reading of the public record: the announcement, the HN discussion, and coverage from The Register, Forbes, and Simon Willison, all linked above. My interest is professional curiosity from the inference-consumer side of the fence, not hands-on experience. With that said, here is the checklist I would run before betting a project on Mojo, and the checklist I'd suggest you run:
- Build the compiler yourself. It is one command now. If the build fails on your machine, you have learned something important for free.
- Port one real kernel, not a toy. Take the smallest performance-sensitive function you own in Python or CUDA, port it, and benchmark on your actual hardware. Vendor benchmarks are marketing.
- Check the platform box. No Windows support shipped means no Windows support, regardless of what was announced.
- Stress-test the interop story. Your legacy Python is not going anywhere. Verify the boundary between Mojo and Python code on your workload before committing.
- Watch the contribution policy. Compiler contributions are promised by end of 2026. Whether that lands on time tells you how the Qualcomm era will actually go.
The Verdict
The "too late" crowd has a point: the 2023 hype window is gone, the Python superset promise is dead, and a language owned by a chip maker will always carry governance questions. But the "finally" crowd has the stronger case. A 1.0 language with source stability, an Apache 2.0 compiler you can build with one command, a standard library with 1,100+ outside pull requests, and a runtime that targets six silicon vendors is a categorically different thing than the closed curiosity of 2024. Mojo will not replace Python, and it was never going to. It is a specialized bet that GPU programming should not require learning three languages, and that bet is now testable by anyone with a Linux box and an afternoon.
I write about Java, Spring Boot, and AI every week. Subscribe, it's free.
Have you tried Mojo since the open source release, or did the closed compiler years put you off permanently? What was your experience?
Top comments (0)