35,000x—that was the headline performance number touted by the Mojo programming language when it debuted in 2023, comparing itself directly to Python, the world’s most popular programming language. Three years later, on August 11, 2026, this language that famously claimed to be “35,000 times faster” officially reached version 1.0. To non-programmers, this might sound like just another “new sports car hitting the market” announcement. But it provides a great opportunity to explore two fundamental questions worth discussing: why Python is slow in the first place, how Mojo achieves its speed, and how much truth actually lies behind that eye-popping 35,000x figure.
Image: Mojo 1.0 release announcement header. Source: modular.com
Why Python Is Slow: Translating Every Sentence Line by Line
First, a quick clarification: when people say “Python is slow,” they specifically mean slow at pure computation, not slow at opening software. For tasks like reading files from disk or handling network requests, Python is not noticeably slower than other languages, because the actual bottlenecks are disk I/O and network speed. The performance gap widens drastically when forcing the computer to run heavy math and algorithm workloads—such as image processing or complex calculations. Python’s slowness boils down to three widely acknowledged design choices.
First, Python is an interpreted language. Think of a programming language as a recipe and the computer as the chef. Compiled languages like C translate the entire recipe into machine code once. After that initial translation, the chef executes instructions directly every time. Python, on the other hand, acts like an interpreter translating line-by-line in real time: every line of code must be converted into machine instructions on the spot before execution, incurring a translation tax on every single run.
Second, Python variables are dynamically typed (“unlabeled”). In Python, when a variable holds a number or a string, the variable itself does not declare its data type. Every time the program accesses it, the runtime must first check what type of data it is before deciding how to handle it. Imagine a tool chest where none of the drawers have labels: you have to open and check each drawer every time you need something. Static typing, by contrast, acts like clearly labeled drawers, allowing the path to be optimized in advance.
Third, Python features the Global Interpreter Lock (GIL)—a single-lane bottleneck. Put simply, pure Python code allows only one thread to execute at any given moment. Even if your machine boasts 32 CPU cores, pure Python code can only process work sequentially—like a restaurant kitchen with dozens of stoves but only one chef working them one by one.
When combined, these three design factors make Python exceptionally sluggish in pure computational tasks. This explains why virtually all scientific computing and AI libraries in Python—including NumPy and PyTorch—are backed by native C/C++ code under the hood. Python acts as the high-level conductor, delegating the heavy lifting to C. In short, Python’s perceived slowness is the trade-off for its main virtue: prioritizing developer ergonomics and simplicity over raw runtime execution speed. That trade-off fueled Python’s rise over thirty years, but it remains an unavoidable bottleneck.
How Mojo Speeds Up: Switching to an Entirely New Track
Mojo was introduced by Modular in May 2023. The company was co-founded by Chris Lattner, creator of Apple’s Swift language and the LLVM compiler infrastructure. For compiler experts, building Mojo was home turf. Mojo’s speed comes from systematically dismantling Python’s three slow characteristics.
Mojo is a compiled language. The entire program is compiled into native machine code beforehand, so the translation cost is paid only once. Beyond compilation, Mojo relies on MLIR (Multi-Level Intermediate Representation) as its compiler foundation. MLIR enables a second layer of optimization: from a single codebase, the compiler generates tailor-made machine instructions optimized for different target architectures—whether standard CPUs, GPUs, or specialized AI accelerators. While traditional compilers required writing different recipes for different kitchens, MLIR allows one recipe to automatically adapt to every kitchen.
Furthermore, Mojo introduces static typing and Rust-like memory management semantics. Because the compiler knows data types before execution, it can perform extensive optimization ahead of time while catching common memory safety errors at compile time. For developers, the 1.0 release carries a practical milestone: syntax stability. Code written today won’t break tomorrow, making it viable for production projects—a commitment emphasized throughout the release announcement.
There is also a human factor: Mojo’s syntax closely mirrors Python, allowing Python developers to adopt it without learning an entirely foreign language. However, Modular’s roadmap has quietly evolved over time: while initially pitched as a “full superset of Python,” official documentation now states that becoming a complete superset is “not guaranteed.” In practice, Mojo is more like a new language that resembles Python, rather than just a faster Python.
Conceptually, Mojo achieves its speed by switching tracks entirely—overhauling compilation, the type system, and hardware targeting. High-speed rail doesn’t run on legacy tracks; once the infrastructure changes, the performance tier shifts dramatically. Mojo’s primary arena is AI chip programming. Today, writing GPU code typically requires NVIDIA’s proprietary CUDA language, locking developers into a single vendor ecosystem. Mojo aims to offer a vendor-agnostic alternative where a single codebase can run across all chips.
The 35,000x Figure Is Real—But Mind the Track
Now for the key question: how was that 35,000x speedup measured?
The number originated from Modular’s official demo during Mojo’s 2023 debut, benchmarked on Mandelbrot set fractal calculations—a dense mathematical loop.
Image: Mandelbrot set fractal—the type of intensive math calculation used in the 35,000x benchmark test. Source: Wikimedia Commons
The baseline for comparison was pure Python using handwritten nested loops—the exact scenario where Python performs worst due to cumulative interpreter overhead, dynamic type checking, and single-threaded execution. However, when Python leverages C-optimized libraries like NumPy, the performance gap shrinks from 35,000x to roughly 12x. While 12x remains impressive, it belongs to a completely different order of magnitude—a caveat highlighted by tech communities like Slashdot upon Mojo’s initial reveal.
What does this mean? The 35,000x number is real, but it serves as a specialized benchmark trophy rather than a universal promise for all applications. For most software, bottlenecks lie in disk I/O, network latency, or database queries, where changing programming languages yields minimal gains. Among the 108 comments on Hacker News regarding the 1.0 launch, many developers evaluated the release critically. Some noted the absence of direct, head-to-head performance benchmarks against PyTorch in the 1.0 announcement, remarking that “the lack of a PyTorch comparison speaks volumes.” Others poked fun at the 1.0 label, joking that it felt like “simply declaring that we’ve decided to call it 1.0 now.”
The Real Battle for a New Language: Ecosystem, Open Source, and $3.9 Billion
Raw execution speed is merely the admission ticket. Over thirty years, Python has built a massive ecosystem with hundreds of thousands of mature libraries spanning image processing, data analysis, web development, and AI. Porting or replacing an entire ecosystem presents an immense hurdle—one that forms Python’s deepest moat and Mojo’s steepest challenge.
Mojo’s community metrics show promising traction: since open-sourcing its standard library, nearly 200 contributors have submitted over 1,100 commits modifying more than 200,000 lines of code. However, the core compiler remains closed-source, though Modular promised an open-source release within 2026. This remains a primary point of skepticism in developer discussions, with comments repeating variations of “if the compiler isn’t open source, I won’t adopt it.” Others criticized the 1.0 announcement hero image for feeling “too AI-generated and marketing-heavy.” Developers are watching the upcoming ModCon conference hosted by Modular on August 18 in San Francisco for open-source updates.
Another major development cannot be ignored: on July 29, 2026, Qualcomm announced the completion of its $3.9 billion acquisition of Modular, with founder Chris Lattner joining Qualcomm’s executive team. Some observers viewed the deal as an “acqui-hire” where products might be sidelined, while others saw the high valuation as strong market validation. For general observers, the acquisition underscores a clear reality: delivering a unified programming model across diverse hardware carries immense commercial value.
Final Thoughts
Mojo 1.0 is a notable milestone, but it represents one leg of a long journey. Language shifts do not transform software overnight: Python will not disappear simply because a new language emerges, as it remains the foundation of modern AI and data science. Mojo’s long-term success will depend on how its ecosystem matures over the next two years and whether Modular fulfills its open-source commitments.
For non-technical readers, the broader takeaway lies in critical thinking: whenever an astounding number like “35,000x faster” is claimed, it is always worth asking—under what specific conditions, compared to what baseline, and measuring which workload? The context behind benchmark numbers is usually far more revealing than the headline figures themselves.
Reference links:
- Modular official blog: Modular 26.5: Mojo 1.0 is here!
- Hacker News discussion: Mojo 1.0 (item id 49261128)
- Wikipedia entry: Mojo (programming language)
- Slashdot early report: Community discussion on Mojo release and the 35,000x claim
- News reports on Qualcomm’s $3.9B acquisition of Modular
