跳到正文
阿里雲開發者社區 AI·· 21 小時前AI 評分39

Mojo 編程實戰一:認識 Mojo

Mojo编程实战一:认识 Mojo

AI 導讀

Mojo 編程實戰第一篇以 Mojo 1.2.0 為基礎,介紹 Mojo 如何應對 Python 易用但執行較慢、C/C++ 和 Rust 性能高但較難編寫的落差。內容講解其 Python 風格語法、MLIR/LLVM 原生性能與編譯期元編程三大設計支柱,並説明 Mojo 的適用場景和目前限制。

正文

2026-11-21 6

版权

版权声明:

本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写 侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

简介: 本书基于 Mojo 1.2.0(2026年现行版本),直击Python慢、C/Rust难、胶水成本高的痛点,系统讲解其三大支柱:Python级易用性、MLIR驱动的原生性能、编译期元编程。内容全部适配最新语法与生态,助你高效开发AI高性能内核。(239字)

**第 1 章 认识 Mojo**

Python 好写但慢,C/Rust 快但难写,把两者粘起来的工程成本又极高——这道鸿沟是 Mojo 诞生的理由。本书基于 Mojo 1.2.0,带你从环境搭建一路走到能独立写出高性能数值内核。

2025 年你在中文社区能搜到的教程,到 2026 年中已经大半跑不起来了。函数关键字从 fn 变成只有 def,参数约定从 borrowed/inout/owned 换成 imm/mut/var,@property 和 @classmethod 整个没了,UnsafePointer 被合并进 Pointer,连安装命令都从 modular install mojo 改成了 uv pip install mojo,mojo test 命令直接删除。一个读者如果跟着 2025 年的文章敲代码,面对满屏编译错误,很容易得出"Mojo 文档烂、语言不成熟"的结论——但问题往往不在语言,在于他手里的资料已经是上一代的化石。

我写这本书,就是想把这件事一次性拉回到 1.2.0 的现行状态:所有代码用今天的语法重写,所有 API 对着官方文档和标准库源码核实,所有性能数字标注清楚对比对象。Mojo 值不值得学是一回事,但至少别让读者为过时的教程买单。

本章目标 - 说清楚 Mojo 解决的是什么问题、为什么会在 AI 时代出现。 - 理解 Mojo 的三大设计支柱:Python 的易用、原生级性能、编译期元编程。 - 搞懂 MLIR 是什么,以及它为什么能成为 Mojo 的地基。 - 知道 Mojo 适合做什么、不适合做什么,并能把它和 Python、Rust、C++、Julia、Numba 区分开。 - 对 Mojo 当前(1.2.0)的生态与发展现状有一个不被营销话术带偏的判断。

**1.1 先从一个老问题说起**

做过机器学习或者数值计算的人,大概都经历过这样的割裂:

  • 你用 Python 写原型,几十行代码,数据怎么切、模型怎么搭,半天就能跑通。Python 给你的是表达速度。
  • 但只要数据量一上来,或者那段逻辑没法用 NumPy、PyTorch 的向量化接口表达,你就得眼睁睁看着 CPU 一个核跑满、风扇狂转,一段循环跑一晚上。
  • 于是你开始找人用 C++ 或 CUDA 重写热路径,再用 pybind11、Cython、ctypes 把它包回 Python。系统一下子变成了"Python 外壳 + C++ 内核 + 一堆胶水代码",构建复杂、调试困难、跨平台还容易出问题。

这中间有一道很现实的鸿沟:最容易写的语言跑不快,跑得快的语言不好写,而把两者粘起来的工程成本极高。

过去几十年,业界用各种方式填这道沟——Cython、Numba、PyPy、Julia、TorchScript、C++ 扩展……它们各有斩获,但都没有同时做到三件事:

  1. 让绝大多数 Python 开发者几乎零学习成本上手;
  2. 拿到接近 C/C++/Rust 的性能,并且能用上现代 CPU 的 SIMD 和 GPU;
  3. 用一套统一的抽象,把"胶水"和"内核"放进同一种语言、同一个工具链里。

Mojo 就是冲着这三件事来的。

**1.2 Mojo 是谁做出来的**

Mojo 由 Modular 公司推出,背后的灵魂人物是 Chris Lattner。如果你写过 Swift、用过 LLVM,对这个名字不会陌生:

  • LLVM 编译器基础设施的主要作者;
  • Swift 语言的缔造者;
  • 还主导过 Clang、MLIR 等项目,后来在 Google、Tesla、SiFive 做过编译器与芯片相关的工作。

一个设计过 LLVM 和 Swift 的人来做新语言,意味着 Mojo 不是又一个"给 Python 加个 JIT"的脚本,而是从编译器最底层重新设计的。

公司层面有一个必须更新的事实:2026 年 7 月 29 日,高通(Qualcomm)以约 39 亿美元的全股票交易完成了对 Modular 的收购,Chris Lattner 出任高通负责先进 AI 软件与平台的执行副总裁(EVP),Mojo、MAX 以及 Modular Cloud 作为产品与品牌继续保留。这对 Mojo 是双刃剑:一方面有了芯片大厂的资源和落地场景,另一方面语言的长期走向也会更深地绑定到高通的硬件战略上。我们会在第 20 章再谈这里面的风险。

**1.3 Mojo 的设计哲学**

Mojo 官网早期有一句话很能概括它的野心:"The programming language for AI developers"(面向 AI 开发者的编程语言)。拆开来看,它的设计建立在三根支柱上。

**支柱一:Python 的易用与生态**

Mojo 在语法和体感上刻意贴近 Python——缩进、def、常见的控制流、集合字面量,Python 开发者看 Mojo 代码会觉得"这我也能读"。它还能直接调用整个 Python 生态(NumPy、Pandas、PyTorch 等),这点我们在第 14 章会详细讲。

需要先纠正一个常见误解:Mojo 的长期愿景是成为 Python 的超集,但截至 1.2.0 它并不是 Python 超集,不能直接把任意 .py 文件改名 .mojo 就指望能跑。它是一门独立的、静态编译的语言,只是在语法上和 Python 高度相似。

**支柱二:原生级性能**

Mojo 是一门提前编译(AOT)的编译型语言,基于 MLIR/LLVM 生成高度优化的机器码。它没有 Python 那样的解释器开销和全局解释器锁(GIL),并且把这些性能能力直接暴露给开发者:

  • 显式的 SIMD 向量类型,一条指令算多个数;
  • 编译期就能确定的参数化类型和函数,可以为不同数据类型、不同向量宽度生成专门的代码;
  • 一套类似 Rust 的所有权与生命周期系统,在没有垃圾回收(GC)的前提下保证内存安全;
  • 多核并行、GPU 编程的一等支持(GPU 部分现在归到 MAX 平台)。

**支柱三:编译期元编程**

很多性能优化的关键,在于"能不能在编译期就把事情算清楚、把代码特化好"。Mojo 提供了 comptime(编译期求值)、参数化泛型、trait 静态派发和编译期反射,让你能在编译期完成循环展开、类型选择、形状推导等工作。这部分是 Mojo 最有特色、也最容易和其他 Python 加速方案拉开差距的地方,第 8 章会专门讲。

一句话总结这三根支柱的关系:

graph TD
A[Mojo] --> B[Python 般的语法与互操作]
A --> C[MLIR/LLVM 原生级性能]
A --> D[编译期元编程]
B --> E[低学习成本 / 复用生态]
C --> F[SIMD · 多核 · GPU]
D --> G[特化 · 零成本抽象]
E --> H[一套语言同时承担
原型、胶水与高性能内核]
F --> H
G --> H

**1.4 地基:MLIR 到底是什么**

要理解 Mojo 为什么快、为什么能同时驾驭 CPU 和 GPU,绕不开 MLIR(Multi-Level Intermediate Representation,多层中间表示)。它也是 Chris Lattner 在 Google 时主导发起的项目。

传统编译器(比如经典 LLVM)的中间表示,抽象层次比较接近"底层机器指令",擅长做寄存器分配、指令调度这些事。但现代 AI 计算里有大量更高层的概念——张量、计算图、算子、内存布局、不同的硬件(CPU、GPU、NPU)——这些东西如果一上来就被拍平成底层指令,很多优化机会就丢了。

MLIR 的思路是:允许存在多层"方言"(dialect),每一层用最适合自己的抽象来表示程序,再逐层下降(lowering)到更底层。

graph TD
L1["Mojo 源码
(struct / trait / 参数化)"] --> L2["高层方言
(张量、算子、形状)"]
L2 --> L3["中层优化
(循环、向量化、分块)"]
L3 --> L4["LLVM / GPU 方言"]
L4 --> L5["x86 · ARM · RISC-V · NVIDIA/AMD GPU 机器码"]

对应用开发者来说,你不必直接写 MLIR,但要知道:Mojo 之所以能在编译期做跨层次的优化、能把同一份代码下降到 CPU 或 GPU,正是因为它站在 MLIR 这套可扩展的多层表示之上。 这也是它和"在 Python 外面套一个 JIT"的本质区别。

**1.5 先看一眼 Mojo 长什么样**

光说不练有点抽象,我们看一段最简单的代码。下面是全书的第一个程序:

# 用 def 定义函数;main 是程序入口
def main():
var name: String = "Mojo"

# t"..." 是 Mojo 的字符串插值语法  
print(t"Hello, {name}!")  

var total: Int = 0  
for i in range(1, 5):        # 1,2,3,4  
    total += i  
print("1 到 4 的和 =", total)

运行结果:

Hello, Mojo!
1 到 4 的和 = 10

如果你有 Python 基础,这段代码几乎不用解释。但请注意几个和 Python 不一样、却很关键的细节:

  • 变量前面有 var。在 Mojo 1.2.0 里,声明变量必须显式写 var,裸写 name = "Mojo" 是编译错误。
  • 类型是显式标注的(String、Int),虽然很多时候编译器能推断,但 Mojo 是静态类型语言。
  • 字符串插值用的是 t"..." 前缀,不是 Python 的 f-string。

这几处"小不同"背后,正是 Mojo 从动态解释语言转向静态编译语言的关键。别急,第 3、4 章会把它们讲透。

**1.6 Mojo 适合做什么,不适合做什么**

学一门新语言,先搞清楚它的边界,比记住语法更重要。

它擅长的:

  • 数值计算、张量运算、仿真、蒙特卡洛这类计算密集型工作;
  • 给现有 Python 项目写被反复调用的高性能内核,替代部分 C++/CUDA/Cython;
  • 需要显式 SIMD、多核并行、或要在 GPU 上写自定义算子的场景(GPU 走 MAX);
  • AI 模型的构建、编译与高性能推理服务(MAX 平台)。

它目前不擅长、或者你要谨慎的:

  • 想要一个成熟的通用脚本/后端开发生态(Web 框架、ORM、海量第三方库)——这方面 Python 差着几十年的积累;
  • Windows 原生开发——Mojo 在 Windows 上只支持 WSL2;
  • 指望一门"稳定到几年不用改代码"的语言——它很年轻,标准库里不少 API 仍标注为 unstable,1.0 到 1.1 之间都还在批量改名;
  • 分布式执行——Mojo 本身不做分布式,这部分由 MAX 提供。

踩坑提示:如果你是抱着"用 Mojo 把所有 Python 代码都重写一遍"的想法来的,建议先收一收。更现实、回报也更高的用法是:Python 继续做编排、I/O 和数据清洗,只把真正的性能瓶颈用 Mojo 重写,边界上用数组视图而不是逐元素传参。第 14、17 章会反复强调这个模式。

**1.7 和几门主流语言摆在一起看**

下面这张表帮你快速建立定位(数据基于 2026 年 10 月的现状,生态对比部分会随时间变化):

|
维度
|
Mojo
|
Python
|
C/C++
|
Rust
|
Julia
|
Numba/Cython

|
| --- | --- | --- | --- | --- | --- | --- |
|
定位
|
AI 系统 / 异构内核语言
|
通用胶水语言
|
系统 / 极致性能
|
内存安全的系统语言
|
科学计算
|
Python 加速外挂
|
|
执行方式
|
AOT 编译
|
解释执行
|
AOT 编译
|
AOT 编译
|
JIT
|
JIT / C 扩展
|
|
性能量级
|
接近原生
|
慢(热循环)
|
极致
|
接近原生
|
接近原生
|
视代码而定
|
|
内存管理
|
所有权 + 生命周期,无 GC
|
GC / 引用计数
|
手动
|
所有权,无 GC
|
GC
|
无 / 手动
|
|
GPU / 异构
|
一等支持(MAX)
|
靠外部库
|
靠 CUDA 等
|
生态较弱
|
CUDA.jl
|
有限
|
|
与 Python 互操作
|
双向(Python→Mojo 仍 Beta)
|
—
|
C 扩展
|
FFI
|
PyCall
|
原生同生态
|
|
生态成熟度
|
年轻(2023 首发,2026 编译器开源)
|
最庞大
|
最庞大
|
大且增长快
|
中等
|
偏小、在萎缩
|

几点值得说的判断:

  • 对 Rust:Mojo 借用了所有权的思想,但没有 Rust 那么严格的 Send/Sync 线程安全体系;Rust 面向通用系统编程,Mojo 更聚焦 AI 与数值。
  • 对 Julia:两者都瞄准"科学计算要又好用又快",Julia 走 JIT、生态更成熟,Mojo 走 AOT + MLIR、编译期与异构能力更强。社区实测里,两者在精心优化后的 Mandelbrot 等基准上基本是同一档。
  • 对 Numba/Cython:它们是"给 Python 打补丁",Mojo 是一门有完整类型系统和工具链的独立语言,能表达的优化更系统,但迁移成本也更高。

**1.8 关于性能数字,先打个预防针**

你可能在各种宣传里看到过 Mojo "比 Python 快 35000 倍""68000 倍"甚至"9 万倍"的说法。这些数字不是假的,但口径极其重要:

  • 它们对比的是未优化的、纯 CPython 解释执行的循环;
  • 一旦对手换成已经调用 BLAS 的 NumPy、或者 C / Rust / Julia,优势通常会迅速回落到 1–5 倍,甚至打平。

设计权衡:Mojo 真正的卖点从来不是"碾压 C",而是"Python 级别的开发体验 + 接近原生的性能 + 编译期驾驭异构硬件的能力",并且把这三者放进同一门语言。理解了这一点,你就不会在看到万倍宣传时盲目乐观,也不会在看到它和 NumPy 打平时觉得它被高估。第 17 章会教你怎么自己动手做公平的基准测试。

**本章小结**

  • Mojo 针对的是"Python 好写但慢、C/Rust 快但难写、胶水工程成本高"这道长期存在的鸿沟。
  • 它由 Modular(Chris Lattner 主导)推出,2026 年 7 月 Modular 被高通收购;Mojo 基于 MLIR,是 AOT 编译语言。
  • 三大支柱:Python 般的语法与互操作、原生级性能(SIMD/多核/GPU)、编译期元编程。
  • MLIR 用多层方言实现跨抽象层次的优化,是 Mojo 能驾驭 CPU/GPU 的地基。
  • Mojo 目前不是 Python 超集;变量必须 var、函数只有 def、常量用 comptime。
  • 万倍性能数字是"vs 未优化 CPython"的口径,对 NumPy/C/Rust/Julia 通常只有 1–5 倍。
  • 最现实的用法是 Python 编排 + Mojo 写热内核,而不是整体重写。

**练习与思考**

  1. 在你的机器上(或按第 2 章装好环境后)运行本章的 hello.mojo,把 name 改成你自己的名字,观察输出。
  2. 试着删掉 var name 里的 var,或者把 t"..." 改成普通字符串,看看编译器报什么错——这些报错信息本身就是很好的学习材料。
  3. 用你熟悉的 Python 写一个 1 到 100 万的累加循环,先不查资料,猜一猜:如果换成 Mojo,量级上可能快多少?读完第 17 章后回来验证你的猜测。
  4. 结合你自己的工作,列出 2–3 个"如果用 Mojo 重写可能划算"的模块,以及 2–3 个"明显不划算"的模块,并说明理由。
  5. (开放题)有人说"既然有了 NumPy 和 PyTorch,就不需要 Mojo 这样的语言了",你怎么看?试着从"哪些代码无法被向量化接口覆盖"的角度反驳或支持这个观点。

來源:阿里雲開發者社區 AI · developer.aliyun.com