The AI Programming Language Shift: Why Mojo and Rust Are Challenging Python’s Dominance

In December 2025, Modular published “The Path to Mojo 1.0,” targeting a release sometime in 2026. For a programming language, a 1.0 release is the equivalent of an IPO — a declaration that the language is production-ready and here to stay. Chris Lattner, the creator of Swift and LLVM, has spent three years building a language that promises something the AI community had given up hoping for: Python’s readability with C’s speed. The benchmarks backing that promise are not modest. In specific computational workloads, Mojo has demonstrated 35,000x speedups over Python. On more powerful hardware, that number climbs past 68,000x.

En bref : Python’s dominance in AI is being challenged from two directions: Mojo offers Python-compatible syntax with performance rivaling C++, while Rust is quietly becoming the language of production ML infrastructure. Meanwhile, Python itself is evolving — the GIL became optional in 3.13 and officially supported in 3.14 — but the ecosystem may be fracturing faster than it can adapt.

Those numbers sound absurd until you understand where they come from. Python is a dynamically typed, interpreted language. It was never designed for the kind of tight-loop numerical computation that defines modern AI workloads. The Global Interpreter Lock (GIL) prevented true multithreading. The interpreter overhead added latency to every operation. For decades, the AI community worked around these limitations by writing the performance-critical code in C, C++, or Fortran, then wrapping it in Python bindings. NumPy, PyTorch, TensorFlow — they are all Python on the surface and C/C++ underneath.

Mojo asks a simple question: what if you did not need the workaround?

Mojo: Python Syntax, Systems Performance

Mojo is not a Python replacement. It is a Python superset — or aims to be. Code written in Python should, in theory, run in Mojo. But Mojo adds features that Python deliberately excluded: static typing, manual memory management, SIMD (Single Instruction Multiple Data) operations, and direct hardware access. These additions let Mojo compile down to machine code that runs on CPUs and GPUs with the same efficiency as hand-tuned C++.

Lattner’s pedigree gives the project credibility that a typical startup language would never have. He created LLVM, the compiler infrastructure that underpins nearly every modern programming language toolchain. He created Swift, which replaced Objective-C as the primary language for Apple development. He understands, perhaps better than anyone alive, what it takes to build a language that developers actually adopt.

The performance claims, while headline-grabbing, require context. The 68,000x speedup comes from running the Mandelbrot algorithm on an h3-standard-88 Intel Xeon instance with hardware-level parallelism and SIMD optimizations — features that pure Python cannot access but that any compiled language can exploit. A straightforward port of Python code to Mojo achieved an 89x speedup; employing problem-specific optimizations pushed that to 26,000x. A more realistic expectation for typical workloads is a 10x to 1,000x improvement for computationally heavy tasks, which is still transformative for AI workloads where training runs can take days or weeks.

Running unchanged Python code in Mojo — without any Mojo-specific optimizations — achieves roughly a 12x speed improvement. That free performance gain comes from compilation alone, before the developer writes a single line of Mojo-specific code. Adding Mojo-specific features like SIMD vectorization can push that to 900x over Python and 9x faster than NumPy.

The challenge Mojo faces is not technical. It is ecological. Python’s dominance in AI rests not on the language itself but on its library ecosystem. PyTorch, TensorFlow, Hugging Face Transformers, scikit-learn, pandas, NumPy — these libraries represent decades of accumulated work by thousands of contributors.

Modular is addressing this through Python interoperability, allowing Mojo programs to call Python libraries directly. In February 2026, Modular acquired BentoML, a model serving framework used by over 10,000 organizations including 50+ Fortune 500 companies. The acquisition signals that the ecosystem is beginning to coalesce around Mojo’s vision. But building a library ecosystem is measured in years, not months.

The Mojo standard library has been open-sourced under the Apache 2 license, with more than 750,000 lines of open-source code and a community of over 50,000 members. Lattner has committed to open-sourcing the Mojo compiler by the end of 2026.

Rust: The Infrastructure Language

While Mojo targets the researcher and data scientist — the people writing model architectures and training loops — Rust is conquering a different layer of the AI stack. It is becoming the language of ML infrastructure: the inference engines, model serving systems, data pipelines, and hardware abstraction layers that sit between the researcher’s Python code and the actual hardware.

This is not accidental. AI inference at scale is fundamentally a systems programming problem. You need memory safety (a single buffer overflow in a serving system can crash the entire service), predictable performance (latency spikes in inference pipelines cost money), and efficient concurrency (serving thousands of inference requests simultaneously requires threading models that Python simply cannot provide).

Hugging Face built Candle, a minimalist ML framework for Rust optimized for inference rather than training. Candle supports transformer-based models and is designed for serverless and edge environments where small binaries and low latency matter. It removes Python from production workloads entirely, eliminating interpreter overhead and GIL-related bottlenecks. Candle is not trying to replace PyTorch for research. It is replacing Python-based inference stacks in production.

The Burn framework takes a broader approach. Built entirely in Rust by the Tracel AI team, Burn functions as both a tensor library and a deep learning framework. Its JIT compiler, now powered by MLIR and LLVM through the CubeCL integration, supports both CPU and GPU backends with automatic kernel fusion, autotuning, and cross-platform GPU programming via CUDA and WebGPU. Burn can import ONNX models through its burn-onnx crate, meaning researchers can train in PyTorch and deploy in Burn without rewriting their models.

Enterprise adoption of Rust for AI infrastructure is accelerating. Commercial Rust usage grew 68.75% between 2021 and 2024, with Fortune 500 companies betting their infrastructure on memory safety. Microsoft has accelerated its migration from C/C++ to Rust for security-critical systems after data showed 70% of security vulnerabilities originated from unsafe memory usage. Cloudflare built Infire, a custom LLM inference engine written in Rust, in 2025. In benchmarks, the Burn framework with CUDA achieved 97% of PyTorch+CUDA performance on the Phi-3 model with 30% lower memory overhead.

Python Fights Back: The GIL Is Finally Dead

Python’s maintainers have not been idle while competitors circled. Python 3.13, released in October 2024, made the GIL optional for the first time in the language’s history through an experimental free-threaded build. Python 3.14, released on October 7, 2025, moved free-threaded Python from experimental to officially supported, with the PEP 703 implementation fully completed.

The impact is substantial. Custom multi-threaded matrix multiplication code runs nearly 10 times faster with the GIL disabled — 4.56 seconds versus 43.95 seconds. I/O-bound tasks using thread pools are over 3 times faster in the free-threaded build. PyTorch DataLoader threads can now operate in true parallel. NumPy and pandas can process data chunks concurrently. Feature engineering pipelines that were previously bottlenecked by the GIL can scale across available CPU cores.

But the GIL removal is not a magic bullet. The overhead of the free-threaded runtime, while dramatically reduced from roughly 40% in 3.13 to 5-10% in 3.14, is still nonzero. Regular Python 3.14 still runs with the GIL enabled by default; you must download or build a separate free-threaded version. And the ecosystem migration will take years. Libraries need to be tested and validated for thread safety. C extensions need to be audited. Behavior that was accidentally safe under the GIL may become unsafe without it.

The GIL removal addresses Python’s most fundamental performance limitation, but it does not close the gap with compiled languages. A free-threaded Python program is still an interpreted, dynamically typed program. It is faster than before, but it is not fast in the way that Mojo, Rust, or C++ are fast.

Julia: The Scientific Computing Contender

Julia deserves mention as the fourth player in this landscape, though its trajectory is different from the others. Designed from the ground up for scientific computing, Julia offers Python-like syntax, MATLAB-like mathematical notation, and performance approaching C when JIT-compiled. Julia 1.12 was released on October 7, 2025, and since 2025, Google Colab officially supports Julia natively.

Julia has found its niche in domains where computational performance and mathematical expressiveness intersect: climate modeling, bioinformatics, drug discovery, financial engineering, and physics simulation. Its multiple dispatch system — where the same function name can behave differently based on the types of all its arguments — is unusually well-suited to scientific computing where operations on matrices, vectors, and tensors need to be both expressive and efficient.

But Julia has struggled to break out of academia into mainstream AI/ML development. Its package ecosystem, while growing, remains a fraction of Python’s. The JIT compilation introduces a latency penalty on first execution (the “time to first plot” problem) that frustrates interactive workflows. And the machine learning libraries, while technically impressive, lack the community momentum and corporate backing that PyTorch and TensorFlow enjoy.

The Ecosystem Argument

The most important lesson from programming language history is that raw performance rarely determines which language wins. FORTRAN is faster than Python for numerical computing. C++ is faster for everything. They lost to Python in the AI space not because they were inferior languages but because Python had better libraries, better documentation, better community support, and a lower barrier to entry.

This ecosystem argument cuts multiple ways. It protects Python’s current position: no one is going to rewrite PyTorch in Mojo next year. But it also constrains Python’s future: the workarounds that made Python viable for AI — writing performance-critical code in C/C++ and wrapping it — create a fragile architecture where the actual computation happens in a language most data scientists cannot read or modify.

Mojo’s Python compatibility strategy is the smartest response to this problem. If Mojo can run existing Python code while offering a smooth gradient toward higher performance — write it in Python, then optimize the hot loops in Mojo without leaving the same file — it could capture the ecosystem without requiring a wholesale migration. That is, roughly, how Swift captured Objective-C’s ecosystem. Lattner is running the same playbook.

Rust’s approach is different and equally valid. Rather than competing with Python at the researcher level, it is replacing C/C++ at the infrastructure level. This is arguably the more consequential shift. The code that runs in production — serving millions of inference requests, processing training data at scale, managing GPU clusters — has always been written in systems languages. If that code migrates from C/C++ to Rust, the AI community gains memory safety and concurrency guarantees without sacrificing performance.

What This Means for Developers

The practical recommendation in 2026 is straightforward: learn Python deeply, because it is not going anywhere as the lingua franca of AI research and prototyping. But also learn one systems language. If you want to optimize AI models and stay in the Python ecosystem, watch Mojo closely as it approaches 1.0. If you want to build production infrastructure, learn Rust.

The era of Python being the only language that matters for AI is ending. What is replacing it is not another single language but a polyglot stack where different languages serve different layers. Python for research and prototyping. Mojo for performance-critical model code. Rust for infrastructure. The developers who thrive in this environment will be the ones who can work across these layers rather than specializing in just one.

Sources & Further Reading

• The Path to Mojo 1.0 — Modular Blog
• BentoML Is Joining Modular — BentoML Blog
• What’s New in Python 3.14 — Python Official Documentation
• Candle: A New Machine Learning Framework for Rust — Hugging Face GitHub
• Burn: A Next-Generation Deep Learning Framework for Rust — Tracel AI
• Rust’s Enterprise Breakthrough Year — Rust Trends
• From Swift to Mojo and High-Performance AI Engineering with Chris Lattner — The Pragmatic Engineer
• Rust for AI and Machine Learning in 2025 — Andrew Odendaal