// 2023 — 2026 · Modular · Chris Lattner · Python syntax / C speed / MLIR IR

Mojo:AIKernel

用 Python 的语法写, 用 C 的速度跑, 编译器底下接 MLIR——这是 Chris Lattner 2023 年立下的目标。三年后 Mojo 已在前沿 AI 实验室做生产推理, 一份内核 codegen 到 NVIDIA / AMD / Apple Silicon, 是OpenCL 之后第一个有可信进展的 CUDA 替代。

20235 月 2 日公开发布
Modular Keynote

35k×matmul vs Python
首场 demo · 同硬件

3 archNVIDIA / AMD / Apple
同源内核 · MLIR codegen

→1.0编译器开源前夜
magic · stable stdlib

fn matmulSIMD[f32, 8]@parameterborrow / inout@valuealias N = 1024MLIRdef vs fn@always_inlinestruct TensorPTX · ROCmfrom python import

scroll

何为 `Mojo`

Mojo 是 2023 年由 Modular (Chris Lattner) 发布的 AI 系统编程语言。设计目标干脆: 把 Python 的语法亲和度 和 C / Rust 级别的性能 焊在一起, 编译器底下走 MLIR——这是 Lattner 自己 2017 年在 Google 主导的 AI 编译器 IR。

Python 超集 (目标) syntax

语法层面 Mojo 朝 Python 超集靠: def、缩进、import 几乎一致。"超集"是路线目标, 不是当下完整状态——少数 Python 边角今天还跑不了。

MLIR 原生 compiler

编译器底层 IR 直接是 MLIR, 不是 LLVM IR。多层方言、可扩展, 同一份程序 lower 到 CPU / GPU / TPU。这是 Mojo 跟其它"加速 Python"项目最大的结构差。

所有权 + GC 缺席 memory

borrow / inout / owned 三种参数语义, 没有 GC, struct 默认走值类型。Rust 的内存模型, 但不要写生命周期标注——靠注解 + 推断。

SIMD / GPU 一等 parallel

SIMD 是类型而不是 intrinsic; GPU codegen 通过 MLIR → PTX (NVIDIA) / ROCm (AMD)。没有"用 Mojo 调 CUDA"——你写的就是内核。

matmul.pyPure Python

def matmul(a, b, c, n):
    for i in range(n):
        for j in range(n):
            for k in range(n):
                c[i][j] += a[i][k] * b[k][j]

# 1024×1024 矩阵 ≈ 几分钟级别
# 解释执行 + 引用计数 + 全部走对象路径

matmul.mojoMojo

fn matmul(inout c: Matrix,
           a: Matrix, b: Matrix):
    alias nelts = simdwidthof[DType.float32]()
    for i in range(c.rows):
        for k in range(a.cols):
            @parameter
            fn v[w: Int](j: Int):
                c.store[w](i, j,
                  c.load[w](i, j)
                  + a[i,k] * b.load[w](k, j))
            vectorize[v, nelts](c.cols)

# Modular 公布: 同硬件 ~35,000× Python 解释执行

来路 `: Timeline`

Mojo 不是 2023 年凭空冒出来的——它是 Lattner 从 2003 LLVM 论文一路走来的第三门语言。这条线穿过 LLVM、Clang、Swift (/code/swift)、Tesla、Google Brain 的 MLIR, 最后在 Modular 落地。

2003
Chris Lattner 提交 LLVM 论文
UIUC 硕士论文 "LLVM: A Compilation Framework for Lifelong Program Analysis & Transformation"。这套基础设施定下了 Lattner 之后 20 年所有大动作的底——Clang、Swift、MLIR，最后都是 Mojo。整条线的源头。
2014·06
WWDC: Swift 上线
Lattner 在 Apple 主导的"现代替代 ObjC"项目终于公开 (/code/swift)。Swift 后来成了 Apple 全栈语言。Lattner 留到 2017。这是他第二门让世界改观的语言, 第三门是 Mojo。
2017·01
Lattner → Tesla → Google Brain
1 月去 Tesla 任 Autopilot VP，半年后辞职。秋天加入 Google Brain 做 TPU 编译器基础设施——MLIR 在这里诞生。MLIR 是 Mojo 的直接技术种子: 多层 IR、可扩展方言、为异构硬件而生。
2022·01
Modular 成立
Lattner 与前 Google ML 编译器组 Tim Davis 共同创立 Modular。目标朴素到挑衅: "AI 不应该被 CUDA + Python 锁死"。第一批工程师全部从 Google / Apple / SiFive 编译器圈过来。
2023·05·02
Mojo 在 Modular Keynote 上首次公开
定位三句话讲完: Python 的语法 / C 的速度 / MLIR 作 IR。首场公开 demo 把朴素 Python 矩阵乘法在同一台机器上跑出 35,000× 加速 — 数字震到全场。AI 圈一夜知道这个名字。
2023·09
Mojo SDK 0.1 — 第一次能下载
9 月放出 0.1 SDK, 仅 Linux, 注册排队拿 license。语言 surface 还在乱跳, 但第一次可以本机跑。早期玩家以 ML 工程师 + 编译器 hobbyist 为主。
2024·01
macOS 支持
Mojo 落地 Apple Silicon。M 系列芯片是 LLVM/MLIR codegen 的甜蜜点; 苹果机器上能跑意味着开发者电脑数量瞬间翻倍。社区开始有非 Linux 的 issue 涌入。
2024·03·29
标准库开源 (Apache 2.0)
3 月 29 日, Modular 把 stdlib 开源到 modularml/mojo。编译器仍然闭源——这条策略和早期 Swift 一样: 先把库交给社区改, 再考虑工具链。一周内 GitHub 有 ~100 个外部 PR。
2024·08
Mojo 24.4 — ownership 大改版
把 Rust 风的所有权语义重做了一遍: borrow / inout / owned 作为参数注解, 显式标注、不靠推断。同时 Reference[T] 类型整齐化。社区第一次感到"语言开始定型"。
2024·09
GPU kernels 上线 — H100 / A100
Mojo 第一次给 NVIDIA H100 / A100 出 codegen, 路径是 MLIR → PTX。这是"不依赖 CUDA C++ 也能写 GPU 内核"的第一次真兑现; 此前的 Triton (OpenAI) 走 Python AST, 路线不同。
2025·02
MAX 24.6 — 上生产推理
Modular 自家推理引擎 MAX 把 Mojo 内核接进生产, 跑在多家 AI 创业公司的服务上 (Replit / Together AI 公开提到过)。"研究阶段语言"的标签开始撕掉。
2025·09
AMD GPU — ROCm/MLIR 后端
Mojo 加 AMD GPU 支持, 直接走 ROCm/MLIR codegen。意义重大: 这是自 OpenCL 以来第一次有可信的 CUDA 替代方案。同一份内核源, 跑到 NVIDIA / AMD 两家 GPU——CUDA 垄断的第一道真裂缝。
2025·11
逼近 1.0 — package manager + stdlib 稳态
新包管理器 magic、stdlib API 进入 "破坏性变更需要 RFC" 阶段、文档生成器站起。"还在剧烈翻修"的早期感淡去, 1.0 已经在视野里。
2026
3 岁, 已在前沿实验室生产推理
2026 年 Mojo 的现状: 前沿 AI 实验室在用 MAX + Mojo 做生产推理; "Python 慢"那道墙立得住——Mojo 的官方矩阵乘法 / softmax 数据可重现; 生态规模仍远小于 PyTorch 原生。异构硬件 AI 内核是 2026 年真正的战场, Mojo / Triton / CUDA / JAX-XLA 同台竞争。

语言精要 `: MojoAlphabet`

下面 8 张卡是 Mojo 跟其它 11 门语言最不一样的地方: def vs fn、ownership 注解、@parameter、SIMD 类型、@value、struct vs class、alias、perf 注解。第 9 张是 Python 超集的现状。

`def` vs `fn`

Mojo 同时有 Python 风的 def 和严格类型的 fn。同一个文件可以混: 原型用 def 像 Python, 热路径切 fn 拿编译期检查。

def loose(x):
    return x * 2

fn strict(x: Int) -> Int:
    return x * 2

`borrow` / `inout` / `owned`

Rust 风所有权, 但显式注解: 默认 borrow (只读引用), inout 可变借, owned 转移所有权。无生命周期标注的痛, 但语义清楚。

fn peek(borrow s: String):
    print(s)

fn grow(inout s: String):
    s += "!"

fn eat(owned s: String): ...

`@parameter` — 编译期编程

泛型、条件编译、循环展开共用一套 @parameter 标记。运行期与编译期写起来语法一致, IR 由 MLIR 决定何时具化。

fn repeat[@parameter n: Int]()
    @parameter
    for i in range(n):
        print(i)  # unrolled at compile time

`SIMD[T, n]` — 一等公民

SIMD 是类型, 不是 intrinsic。SIMD[DType.float32, 8] 是参数化向量, 算术运算自动并行——写起来像标量, 跑起来是 AVX/NEON。

var a = SIMD[DType.float32, 8](1.0)
var b = SIMD[DType.float32, 8](2.0)
var c = a * b + a   # 8-wide FMA

`@value` — 自动派生

给 struct 加 @value, copy / move / init / del 自动生成。等价于 Rust 的 derive(Copy, Clone), 一行省 30 行样板。

@value
struct Point:
    var x: Float64
    var y: Float64

# __init__ / __copyinit__ / __moveinit__ all derived

`struct` vs `class`

Mojo 偏向 struct (值类型): 栈上、有 ownership。class (引用类型, GC 语义) 暂未稳定——这是有意识的取舍, 先把数值/系统编程做稳。

struct Vec3:
    var x: Float32
    var y: Float32
    var z: Float32

# class { ... }  # not stable yet, on roadmap

`alias` — 编译期常量

一个关键字管所有编译期定值。C++ 里 #define / const / constexpr 三件事在 Mojo 里全是 alias。

alias WIDTH: Int = 8
alias F32x8 = SIMD[DType.float32, WIDTH]

var v: F32x8 = 0

`@always_inline` 与 perf 注解

Mojo 不靠 LLVM 启发式赌, 而是给程序员显式的旋钮: @always_inline、@noinline、@register_passable。性能可预测, 不再"换编译器版本性能掉了"。

@always_inline
fn dot(a: F32x8, b: F32x8) -> Float32:
    return (a * b).reduce_add()

∞

Python 超集 — 当下做到了多少

"Python 超集"是 Modular 公开口号, 但2026 年的现状是: 大部分 Python 跑得动, 角落跑不动。能跑: def、列表 / 字典字面量、缩进、import 第三方包 (跨 GIL)。不能跑: 元类全套、exec / eval 动态字节码、部分 dunder 协议。"用 Mojo 当 Python 用"基本可行, 但别期望 100%。

"Python 兼容是路线, 不是当下的完整状态——Modular 自己也说得很清楚。"

为何要用 `: WhyMojo`

Mojo 不试图替代 Python 写脚本, 也不试图替代 Rust 写 OS——它瞄准的是过去 15 年没人正面解决的那个空隙: AI 内核要又快又便携, 又不想让算法工程师下沉到 CUDA C++。

⊹

不再需要 pybind11

过去把 Python 提速要写 C/C++ 扩展、绑 pybind11、算 GIL——三种语言、三套构建。Mojo 直接 import 任意 Python 包, 同一文件里写 fn 加速热路径。FFI 礼仪一笔勾销。

from python import Python
var np = Python.import_module("numpy")
var arr = np.array([1,2,3])

⌬

MLIR 是地基, 不是补丁

多数语言把"AI 加速"补在工具链上 (TorchScript、JAX trace、TF graph)。Mojo 反过来——MLIR 是 IR 本身。多层方言、可扩展, 同一份程序能 lower 到 CPU / GPU / TPU 任何后端而不动语言层。

# Mojo source → MLIR → LLVM IR → CPU
#                  → PTX     → NVIDIA
#                  → ROCm    → AMD

⌖

硬件可移植 — 一份内核, 多家芯片

同一份 Mojo 内核, codegen 到 CPU / NVIDIA / AMD GPU / Apple Silicon。CUDA 那种"内核绑死一家"的世界正在松动。这是 2026 年 AI 基础设施最大的争夺点。

# mojo build matmul.mojo --target=cuda
# mojo build matmul.mojo --target=rocm
# mojo build matmul.mojo --target=cpu

⌘

Lattner 履历 — 每一步都进基础设施

2003 LLVM → 2007 Clang → 2014 Swift → 2017 MLIR → 2023 Mojo。Lattner 拿出来过的每一项都成了行业基础设施。Mojo 是不是, 时间会答; 但履历是开发者愿意下注的最强信号。

# LLVM     · 2003 — every modern compiler
# Clang    · 2007 — C/C++/ObjC frontend
# Swift    · 2014 — Apple full stack
# MLIR     · 2017 — AI compiler IR
# Mojo     · 2023 — ?

⚛

CUDA 垄断的第一道裂缝

过去 15 年 GPU 编程 = CUDA C++。Mojo + ROCm 后端是 OpenCL 之后第一个有可信进展的 CUDA 替代: 开源内核、开源 IR、开放竞争。不是"打败 CUDA", 而是"给替代者一个真路径"。

# single kernel source · NVIDIA + AMD
# open IR · open stdlib · Apache 2.0

谁在用 `: ProductionUsers`

Mojo 还年轻, 名单远比 Python 短——但每一个都是真用户, 没编。Modular 自家 MAX 是最大用户; Replit、Together AI 是公开点过名的 AI 平台; 剩下是 Modular 博客提到的机器人、量化金融、药物发现领域的几家。

matmul / softmax / attention

AI 时代 `: 为 AI 而生`

这是这一页的核心: Mojo 是少数从第一天就为 AI 时代设计的语言, 不是把 AI 塞进既有语言。PyTorch / vLLM / TensorRT-LLM 是上层框架, Mojo 站在它们旁边 (内核层), 不是替代它们。

"
过去 15 年, AI 整个堆栈被 "Python 调 CUDA C++" 这一根线绑死。算法工程师写 Python, 性能工程师写 CUDA, 中间隔一道墙。我们做 Mojo 不是要让 Python 变快——是想让同一个人, 同一份语言, 把算法和内核都写完。
— Chris LattnerModular CEO · LLVM / Swift / MLIR / Mojo · 多次访谈与 keynote

35k×

matmul vs Python · 同硬件

Modular 首场 demo 公布的数字: 1024×1024 float32 矩阵乘法, Mojo SIMD + tile + parallelize 写的内核 vs 朴素 Python 三层 for, 跑在同一台 Intel Xeon 上 ~35,000×。narrowly defined: 单个内核 / 同硬件 / 解释 Python 基线——这是它真实的范围。

~7×

softmax vs PyTorch CUDA

更接近真实生产的对比: Modular 公布的 fused softmax 在 H100 上比 PyTorch eager 快约 7×, 跟 Triton (OpenAI) 同档。换 kernel 换 hardware 数字会变, 但"跟手写 CUDA 同档"这条结论稳定。

3 targets

同源内核, 多家芯片

同一份 .mojo: NVIDIA (PTX)、AMD (ROCm)、Apple Silicon。OpenCL 之后第一次有可信路径。CUDA 垄断不是被打破, 是第一次被开口子——从这里开始的事情值得长期关注。

SPOTLIGHT

SIMD + GPU — 一份内核跑在每片硅上

Mojo 的内核长什么样: SIMD 是类型, GPU 是后端。代码里你写 SIMD[DType.float32, 8], 编译器对着目标平台决定具化成 AVX-512 / NEON / PTX 还是 ROCm。同源, 不抽象, 不丢性能。

SIMD type — 参数化向量, 算术自动并行
GPU codegen — MLIR → PTX (NVIDIA) / ROCm (AMD)
Apple Silicon — M 系列 NEON + Metal compute
No CUDA C++ — 不写第三种语言, 不切 build system

对比 Triton (OpenAI): Triton 走 Python AST + JIT, 受限在 GPU; Mojo 是独立语言, 同时覆盖 CPU / GPU / 边缘。两者并存, 不是替代关系。

# 一份内核 · 编译到 NVIDIA / AMD / CPU
from tensor import Tensor
from algorithm import vectorize, parallelize

fn softmax(inout x: Tensor[DType.float32]):
    alias nelts = simdwidthof[DType.float32]()

    @parameter
    fn row(i: Int):
        var m = x.row_max(i)
        var s: Float32 = 0
        @parameter
        fn v[w: Int](j: Int):
            var e = exp(x.load[w](i,j) - m)
            x.store[w](i, j, e)
            s += e.reduce_add()
        vectorize[v, nelts](x.cols)
        scale_row(x, i, 1/s)

    parallelize[row](x.rows)

# 编译: mojo build softmax.mojo --target=cuda
#       mojo build softmax.mojo --target=rocm

2026 工具链 / 后端 / 周边

MAX Engine

Modular 推理 runtime

Mojo stdlib

开源 Apache 2.0

magic

官方包管理器

MLIR

底层 IR · LLVM 生态

Mojo Playground

浏览器内试用

CUDA backend

NVIDIA H100 / A100

ROCm backend

AMD GPU · 2025-09

Apple Silicon

M 系列 codegen

Python interop

import 任意 PyPI 包

PyTorch bridge

tensor 互操作

NumPy bridge

array buffer 共享

Triton (cmp)

OpenAI · GPU 内核竞品

AI ERA

反直觉: AI 写 Mojo 会更难

这是 Mojo 一个有趣的悖论: 它是一门 AI 时代的语言, 但 AI 写它出错率高于 Python / Java / Rust。原因简单——训练语料少。GitHub 公开 Mojo 代码 2026 年量级仍是几千个仓库, 比 Java 少 4 个数量级。

实际工作流: "AI 写 Python 原型 → 人手翻译成 Mojo 内核"仍然是主流。Modular 自家也在做"AI 辅助 Mojo 写作"工具, 把官方 stdlib + 文档喂给模型, 但2026 年还远没到"让 AI 自动写内核"的程度。

讽刺但合理: 所有新语言都要付一次"AI 训练数据冷启动"的税。Rust 早期遭过, Zig 现在还在遭, Mojo 也躲不过。每个早期 PR / blog / 公开内核都在帮模型学这门语言。

# AI 现状: Python prototype → 人手翻 Mojo

# Python (AI 友好)
def attention(q, k, v):
    scores = q @ k.T / sqrt(dim)
    return softmax(scores) @ v

# Mojo (人手翻 · 拿到内核级速度)
fn attention(borrow q: Tensor,
              borrow k: Tensor,
              borrow v: Tensor) -> Tensor:
    # SIMD-packed matmul + fused softmax
    # vectorize / parallelize / tile
    ...

一句话总结: Mojo 不是"加速 Python"的胶水, 也不是"替代 CUDA"的口号——它是第一门把算法和 GPU 内核放在同一个语言里的真语言。2026 年还年轻、生态还小、AI 还不熟, 但架构是对的: MLIR + Lattner 履历 + 真生产用户。

对比 `: Mojo vs Python vs Swift`

跟 Python 比: Mojo 是 Python 的"加速出口", 不是替代。跨链 /code/python。跟 Swift 比 (/code/swift): 同一个设计师 Chris Lattner, 但 Swift 给 app 开发者、Mojo 给 ML 编译器工程师——同人, 两个完全不同的受众。

	Python	Mojo	Swift
出身	Guido · 1991	Modular · 2023	Apple · 2014
设计师	Guido van Rossum	Chris Lattner	Chris Lattner
主要受众	脚本 / 数据 / AI 算法	AI 内核 / 编译器工程师	iOS/macOS app 开发者
语法	Python 本尊	Python 超集 (路线)	独立语法 · ML 风
性能	解释执行 (CPython)	C / Rust 级 · MLIR codegen	C 级 · LLVM
内存模型	GC + 引用计数	borrow / inout / owned	ARC + value 类型
GPU	调 CUDA C++ 走 PyTorch	原生 · NVIDIA + AMD + Apple	Metal · 仅 Apple GPU
SIMD	NumPy 抽象, 不在语言层	`SIMD[T, n]` 一等类型	`SIMD[N]` · 标准库
编译期编程	无 (动态语言)	`@parameter` · 泛型与条件编译共用	有 (associated types / macros)
互操作	万物 · pip 生态	原生 import Python · GIL 跨界	C 直接 · ObjC 桥
生态成熟度	35 年 · 全语言最大	3 年 · 早期 (~10³ 仓库)	11 年 · 苹果生态饱和
开源	完全 · PSF	stdlib 是 · 编译器闭源 (1.0 前开)	完全 · Apache 2.0

前景 `: TheRoadAhead`

2026 年的 Mojo 在 1.0 前夜——编译器开源是最后一道大门。NumPy / PyTorch ABI 深度互操作在路上, Apple 自家 MLX 是同生态位的对手。能不能跳出 AI 当通用系统语言, 是开放问题。

HOT · 2026+

编译器开源 — 1.0 路上的最后一道门

2024 年标准库已开源, 编译器仍闭源。社区给的压力一直在: 想 fork、想嵌、想审 codegen。Modular 公开承诺"在 1.0 之前完成开源", 节奏跟早年 Swift 几乎一致。

意义: 这是 Mojo 从"有趣的 Modular 产品"变成"真正的工业语言"的最后一关。开源后才会有第三方编译器、教学发行版、跨厂商 RFC 体系——Rust 那种。

编译器闭源 (2026 当下)~1%

编译器开源 (1.0 后)100%

INTEROP

NumPy / PyTorch ABI 深度

当前 Mojo 与 Python 互通靠Python.import_module跨 GIL, 数据要 round-trip。下一步是共享 buffer / 零拷贝 tensor——把 PyTorch Tensor 直接当 Mojo struct 操作, 数据不动。这是从"快但隔" 走向"快且无缝"的一步。

MLX

Apple MLX — 同生态位的对手

Apple 自己 2023 年放出 MLX: 也是 NumPy 风、也针对 Apple Silicon、也 LLVM/MLIR 风格。Mojo 在 macOS 上等于和"亲生的"竞争。Lattner 当年走的, 苹果用 MLX 接上了——这条线他比谁都清楚。

GENERAL

通用系统语言 ?

2026 的 Mojo 定位是 AI, 但语言本身够通用——struct + ownership + SIMD + MLIR 没有什么"AI-only"的设计。它能不能跳出 AI、和 Rust 抢通用系统编程的地盘? 取决于 1.0 后社区把它推向哪里。这是开放问题, 不是路线图。

Mojo:AIKernel

20235 月 2 日公开发布
Modular Keynote

35k×matmul vs Python
首场 demo · 同硬件

3 archNVIDIA / AMD / Apple
同源内核 · MLIR codegen

→1.0编译器开源前夜
magic · stable stdlib

fn matmulSIMD[f32, 8]@parameterborrow / inout@valuealias N = 1024MLIRdef vs fn@always_inlinestruct TensorPTX · ROCmfrom python import

scroll

def matmul(a, b, c, n): for i in range(n): for j in range(n): for k in range(n): c[i][j] += a[i][k] * b[k][j] # 1024×1024 矩阵 ≈ 几分钟级别 # 解释执行 + 引用计数 + 全部走对象路径

fn matmul(inout c: Matrix, a: Matrix, b: Matrix): alias nelts = simdwidthof[DType.float32]() for i in range(c.rows): for k in range(a.cols): @parameter fn v[w: Int](j: Int): c.store[w](i, j, c.load[w](i, j) + a[i,k] * b.load[w](k, j)) vectorize[v, nelts](c.cols) # Modular 公布: 同硬件 ~35,000× Python 解释执行

# 一份内核 · 编译到 NVIDIA / AMD / CPU from tensor import Tensor from algorithm import vectorize, parallelize fn softmax(inout x: Tensor[DType.float32]): alias nelts = simdwidthof[DType.float32]() @parameter fn row(i: Int): var m = x.row_max(i) var s: Float32 = 0 @parameter fn v[w: Int](j: Int): var e = exp(x.load[w](i,j) - m) x.store[w](i, j, e) s += e.reduce_add() vectorize[v, nelts](x.cols) scale_row(x, i, 1/s) parallelize[row](x.rows) # 编译: mojo build softmax.mojo --target=cuda # mojo build softmax.mojo --target=rocm

# AI 现状: Python prototype → 人手翻 Mojo # Python (AI 友好) def attention(q, k, v): scores = q @ k.T / sqrt(dim) return softmax(scores) @ v # Mojo (人手翻 · 拿到内核级速度) fn attention(borrow q: Tensor, borrow k: Tensor, borrow v: Tensor) -> Tensor: # SIMD-packed matmul + fused softmax # vectorize / parallelize / tile ...

Python

Mojo

Swift

出身

Guido · 1991

Modular · 2023

Apple · 2014

设计师

Guido van Rossum

Chris Lattner

主要受众

脚本 / 数据 / AI 算法

AI 内核 / 编译器工程师

iOS/macOS app 开发者

语法

Python 本尊

Python 超集 (路线)

独立语法 · ML 风

性能

解释执行 (CPython)

C / Rust 级 · MLIR codegen

C 级 · LLVM

内存模型

GC + 引用计数

borrow / inout / owned

ARC + value 类型

GPU

调 CUDA C++ 走 PyTorch

原生 · NVIDIA + AMD + Apple

Metal · 仅 Apple GPU

SIMD

NumPy 抽象, 不在语言层

SIMD[T, n] 一等类型

SIMD[N] · 标准库

编译期编程

无 (动态语言)

@parameter · 泛型与条件编译共用

有 (associated types / macros)

互操作

万物 · pip 生态

原生 import Python · GIL 跨界

C 直接 · ObjC 桥

生态成熟度

35 年 · 全语言最大

3 年 · 早期 (~10³ 仓库)

11 年 · 苹果生态饱和

开源

完全 · PSF

stdlib 是 · 编译器闭源 (1.0 前开)

完全 · Apache 2.0

Mojo:AIKernel

Chris Lattner 提交 LLVM 论文

WWDC: Swift 上线

Lattner → Tesla → Google Brain

Modular 成立

Mojo 在 Modular Keynote 上首次公开

Mojo SDK 0.1 — 第一次能下载

macOS 支持

标准库开源 (Apache 2.0)

Mojo 24.4 — ownership 大改版

GPU kernels 上线 — H100 / A100

MAX 24.6 — 上生产推理

AMD GPU — ROCm/MLIR 后端

逼近 1.0 — package manager + stdlib 稳态

3 岁, 已在前沿实验室生产推理

def vs fn

borrow / inout / owned

@parameter — 编译期编程

SIMD[T, n] — 一等公民

@value — 自动派生

struct vs class

alias — 编译期常量

@always_inline 与 perf 注解

Python 超集 — 当下做到了多少

不再需要 pybind11

MLIR 是地基, 不是补丁

硬件可移植 — 一份内核, 多家芯片

Lattner 履历 — 每一步都进基础设施

CUDA 垄断的第一道裂缝

SIMD + GPU — 一份内核 跑在每片硅上

2026 工具链 / 后端 / 周边

反直觉: AI 写 Mojo 会更难

编译器开源 — 1.0 路上的最后一道门

NumPy / PyTorch ABI 深度

Apple MLX — 同生态位的对手

通用系统语言 ?

Mojo:AIKernel

Chris Lattner 提交 LLVM 论文

WWDC: Swift 上线

Lattner → Tesla → Google Brain

Modular 成立

Mojo 在 Modular Keynote 上首次公开

Mojo SDK 0.1 — 第一次能下载

macOS 支持

标准库开源 (Apache 2.0)

Mojo 24.4 — ownership 大改版

GPU kernels 上线 — H100 / A100

MAX 24.6 — 上生产推理

AMD GPU — ROCm/MLIR 后端

逼近 1.0 — package manager + stdlib 稳态

3 岁, 已在前沿实验室生产推理

def vs fn

borrow / inout / owned

@parameter — 编译期编程

SIMD[T, n] — 一等公民

@value — 自动派生

struct vs class

alias — 编译期常量

@always_inline 与 perf 注解

Python 超集 — 当下做到了多少

不再需要 pybind11

MLIR 是地基, 不是补丁

硬件可移植 — 一份内核, 多家芯片

Lattner 履历 — 每一步都进基础设施

CUDA 垄断的第一道裂缝

SIMD + GPU — 一份内核 跑在每片硅上

2026 工具链 / 后端 / 周边

反直觉: AI 写 Mojo 会更难

编译器开源 — 1.0 路上的最后一道门

NumPy / PyTorch ABI 深度

Apple MLX — 同生态位的对手

通用系统语言 ?

`def` vs `fn`

`borrow` / `inout` / `owned`

`@parameter` — 编译期编程

`SIMD[T, n]` — 一等公民

`@value` — 自动派生

`struct` vs `class`

`alias` — 编译期常量

`@always_inline` 与 perf 注解

SIMD + GPU — 一份内核跑在每片硅上

`def` vs `fn`

`borrow` / `inout` / `owned`

`@parameter` — 编译期编程

`SIMD[T, n]` — 一等公民

`@value` — 自动派生

`struct` vs `class`

`alias` — 编译期常量

`@always_inline` 与 perf 注解

SIMD + GPU — 一份内核跑在每片硅上