---
title: "Bun AOT"
author: "陈成"
author_url: "https://research.sorrycc.dev/@sorrycc"
question: "Bun 的 AOT 编译（bun build --compile --aot）是什么、进展和数据如何，对 qodercli 有什么收益？"
url: "https://research.sorrycc.dev/@sorrycc/bun-aot"
emoji: "⚡"
published: 2026-10-26T12:28:30Z
updated: 2026-11-10T07:50:02Z
version: 8
cite: "https://research.sorrycc.dev/@sorrycc/bun-aot.bib"
---

# Bun AOT 调研笔记（2026-10-24，10/26、10/29、11/04、11/05、11/10 更新）

By [陈成](https://research.sorrycc.dev/@sorrycc) · Published October 26, 2026 · Updated November 10, 2026

> Bun 的 AOT 编译（bun build --compile --aot）是什么、进展和数据如何，对 qodercli 有什么收益？

来源：X 书签（History → Bookmarks 搜 "bun aot"）、Jarred Sumner 相关推文串及评论、X 搜索、GitHub PR、Reddit。10/29 用 bird CLI 补读了 Jarred 10/24～10/29 的时间线和主要回复；11/04 补读了 10/29～11/04 的时间线、oven-sh/bun 的 AOT PR 和 `docs/compiler`；11/05 用 Tiller 浏览器补读了 Jarred 11/02～11/05 的时间线和回复、#47605 的新描述，以及 11/04 起新开的 AOT PR；11/10 用 Tiller 补读了 Jarred 11/05～11/10 的推文和回复，用 gh 查了重写版和后续 PR 的合并状态与描述，又拆了一次 Claude Code 2.1.322。

> **11/10 更新：重写版编译器已合进 main，v1.5 视频已拍，但还没发布**。
>
> - **重写版合并了**。引擎侧 oven-sh/WebKit#997 于 11/07 05:53 UTC 合并，Bun 侧 #47942 于 11/07 21:21 UTC 合并（56 个 commit，+53 万 / −176 万行，35,875 个文件，都由 Jarred 合并）。main 上的 AOT 编译器从此不再做全程序不动点分析，也不经过 B3/Air。#47605 和 #47957（MDWE 开关）当天被 Jarred 关掉，理由都是"重写后不再适用，问题还在就对新 main 重开 PR"。紧接着 #48120（"the next base"，+43 万 / −3.4 万行，31,061 个文件，几乎全是测试）11/10 00:48 UTC 合并，对应引擎侧 WebKit#1001、#1008、#1021 都已合并。[^62]
> - **重写版运行时还慢一点**。WebKit#997 合并时的最终数据换了基准设置，TS 编译器检查一个项目：构建指令数 543 G → 55 G，代码 19.7 → 13.3 MB，但运行指令数 26.0 G → 28.9 G（+11%），墙钟 4.39 → 5.11 s（+16%），峰值 RSS 939 → 923 MB。11/05 笔记里"慢约三分之一"的数字作废。Jarred 11/09 的说法是 TS6、Claude Code 和 HTTP 服务器的运行时性能和内存"基本一样"，这个基准慢是因为旧编译器有一些"reward hacky"的相同代码折叠，他故意没搬过来；还说有四天担心性能追不上要回滚，"后来就好了"。[^58][^63]
> - **新数据：OpenCode 和 OpenClaw**（11/09，基于 #48120，Linux x64 12 核，各跑 10 次以上取中位数，用项目自己的构建脚本、不改代码）。这是第一次公开 Claude Code 以外的 agent CLI 数据，和 qodercli 的形态很接近，详见下文数据一节。opencode 2.1.4：首帧 0.65 → 0.46 s（快 1.4 倍），20 轮峰值内存 712 → 421 MB（−41%）。OpenClaw：网关就绪 Bun JIT 6.66 s / AOT 2.75 s / Node 8.62 s，就绪时 RSS 882 / 732 / 1,181 MB。当晚又说 WebAssembly 编译改进让 OpenCode 的 CPU 比早上再少 13%。[^64]
> - **编译速度**：Jarred 11/09 说"又重写了一遍 AOT，这个基准（11/02 那张按行数生成程序的表）编译快了 4 倍"，代码少了约 25 万行；主要改动是去掉所有不动点、改成类似 ThinLTO 的函数摘要，以及不用 B3/Air、直接用 JSC 的 macroassembler。没贴新表。[^63]
> - **v1.5 视频 11/06 拍完**（推文时间 11/07 00:41 UTC），截至 11/10 最新稳定版仍是 v1.4.4，回复里已经有人抱怨"一直预告 1.5 却不发"。另有人调侃重写之后视频要重拍。v1.5 带的会是重写版编译器，11/05 笔记里的疑问可以关掉：旧编译器已经从 main 删除。[^65]
> - **还在继续大改**：11/10 Jarred 开了 #48436 和 WebKit#1025（WebAssembly 进优化层、arm64 分支岛、按新命名改名 1,253 处），还没合并。其中和 qodercli 有关的两条：以 base64 或 hex 写进源码的 WebAssembly 会在构建时编译；`Buffer.from("text")` 这类常量在构建时编码。#48436 同时把 `compatibility.mdx` 从 17,425 词砍到约 3,200 词。robobun 11/08～11/10 另开了约 30 个 AOT 小 PR，大多是测试和文档。[^66]
> - **类型错误规则变了**：现在只在 `tsc` 按项目自己的 `tsconfig.json` 也会报错的地方才中断构建，JS、`node_modules`、`.d.ts` 不检查（#47942）；#48120 的已知问题里还有"`bun check` 不报、构建却报"的情况。[^62]
> - **Jarred 的方向表态**（11/09～11/10）：现有设计下剩下的提升"小于 10%"，下一步要靠新关键字或语法（比如不在堆上分配的值类型），但不会是 drop-in；"TS/JS 要接近 Rust/C 而不是 Go 的性能，大概需要新语法"，会以不破坏兼容的方式提出来，不叫新语言。[^67]
> - **没变的**：交叉编译仍不支持（文档仍写 `--target` 指向其他平台时去那个平台构建或加 `--no-aot`）；MDWE 仍无条件开启，issue #47955 还开着，文档给的办法是先把 C 编译好再 `dlopen()`；`Bun.isAOT` 仍不存在。Claude Code 2.1.322（11/10）和 2.1.318 用的是同一个 Bun 运行时 `1.4.4+424a542a9`，应用仍是 JIT + bytecode（2,919 个 `// @bun @bytecode` chunk），二进制 324 MB。[^61][^68]

> **11/05 更新：Bun v1.5 会带 AOT，同时编译器中段在重写**。
>
> - **v1.5 会包含 AOT**。Jarred 11/04 22:39 UTC 发推："Filming Bun v1.5 video on Friday. Bun v1.5 will include the ahead of time compiler"，也就是 11/06（周五）拍发布视频。推文没说发布日期，也没说 v1.5 里是 main 上现在这版编译器还是下面的重写版。回复区多是欢呼，问题集中在二进制多大、冷启动、是不是走 `bun build --compile`、动态 import 和 native module、崩溃能不能指回 TS 源码，截至 11/05 Jarred 没回。最新稳定版仍是 v1.4.4。[^57]
> - **编译器中段重写**（11/04 开，都还 open）：引擎侧 oven-sh/WebKit#997 把全程序 flow 分析（跑到不动点）、每个函数几十遍优化 pass、B3/Air 后端，换成"每个函数扫一遍 → 全程序 Link 一次（多线程）→ 定布局和调用约定 → 每个函数走一遍（边定类型边折叠、内联、选指令）→ 自带寄存器分配和编码器的小后端"，**不再经过 B3 和 Air**。Bun 侧是 #47942（+42 万 / −176 万行，30,914 个文件），另外新增约 4 万个测试文件，`bun:ffi` 在编译产物里的回调数不再限 256 个。用 TypeScript 编译器（从带类型源码构建）检查一个项目做基准，单核指令数：[^58]
>
>   | | main | 重写版 |
>   |---|---:|---:|
>   | 构建 | 543 G | **55 G** |
>   | 代码体积 | 19.7 MB | **13.3 MB** |
>   | 运行 | **23.2 G** | 31.5 G |
>   | 运行峰值 RSS | 1,043 MB | 1,028 MB |
>
>   构建便宜了约 10 倍、代码小三分之一，但**产物在这个基准上慢了约三分之一**，PR 说正在追。另有约 125 个断言 `// STATISTIC:` 计数的测试失败，旧编译器的几项优化（拆分返回值、不传的参数等）在新的 `plan/` 里还没有生产者，"目前从不触发"；11/01 后合进 main 的 `aot/` 修复没有逐条搬过来。#47942 的 CI 12 项里 2 项失败（PR 说会卡在下载引擎预览构建那一步）。
> - **#47605 描述改写，新数据**（仍 open，最后一次推送 `22621ef9` 只是全平台编译检查）：1,255 个程序里 main 做对 930、分支 1,102，main 错、分支对的有 175 个；`bun test --aot` 的 89 个项目 main 对 17、分支对 59。56 个已知错误编译里 main 有 53 个，分支当时有 11 个，后续 commit 又修了 6 个。但分支新列出 **4 个 main 上对、分支上错的回归**（比如同一轮里两个 `import()` 的模块图执行顺序反了，有环时直接 `ReferenceError`），清单清空前不合并。作者还说 CI 里那份"只跑这些测试"的列表会删掉，"在 CI 里跳过测试就失去了意义"，合并的版本会跑分支里全部测试文件。上次笔记说"56 个错误编译，main 上有 53 个"，没写分支自己还剩多少，这次补上。[^51]
> - **MDWE 要开口子**：11/05 有人报 issue #47955，`--aot` 产物启动时无条件调 `prctl(PR_SET_MDWE)`，进程里自己生成机器码的原生库（Mesa lavapipe、LuaJIT、PCRE2 JIT）会失败或崩溃，而且报错是"Bun has crashed. This indicates a bug in Bun"。robobun 当天开了 #47957，加 `--aot-allow-executable-memory` / `compile.allowExecutableMemory`，未合并。[^59]
> - **Jarred 的几句相关回复**：11/01 有人问为什么不测 Elysia，他说"Elysia 目前在 AOT 下更慢"，估计发布前后他或 Elysia 作者会修，所以没放出来；11/02 有人问下一步是不是增量编译，他回"caching is cope for a slow design"，加上重写版构建快 10 倍，看起来方向是把冷编译做快，而不是加缓存。[^60]
> - **Claude Code 最新版还没用 AOT，但已经背上了编译器的体积**。拆了 npm 上的 2.1.318（11/03 发布）：应用仍是 JIT + bytecode，里面换上的 Bun 运行时已经带 AOT 编译器，二进制从 271 MB 涨到 320 MB。详见下文 [Claude Code 二进制实测](#claude-code-二进制实测1105)。[^61]
> - `Bun.isAOT` 仍未出现（代码里只有错误栈内部的 `m_isAOTCompiled` 字段）。

> **11/04 更新：还在 canary，主线在修正确性**。最新稳定版仍是 10/22 的 v1.4.4，AOT 没进正式版，也没看到 Claude Code 正式切换的消息。[^49] 这一周的变化：
>
> - **10/31 合入 #47316**（+91 万 / −45 万行，9,195 个文件）：重点是 `bun test --aot`（`spyOn`、`mock.module` 能作用于编译后的模块；大测试集分层构建，一个私有测试集的单个分片 3,052 个文件、16 核，AOT 458 s 对普通 `bun test` 937 s，最大构建进程内存从 10.6 GB 降到 4.7 GB），加上一批模块加载修复、fuzzer 和 CI 找到的错误结果和崩溃修复，Android 上编译产物能启动了。`Bun.build({ compile })` 新增隐藏选项 `aotValidate`、`aotCheck`、`aotTesting`。计算名的 `import(name)` / `require(name)` 按名字可能的取值收窄，一个大程序的分析时间从 138 s 降到 19 s，峰值内存从 11.2 GB 降到 5.1 GB。[^50]
> - **下一个大 PR #47605 还开着**（11/02 最后更新，75 个 commit，+83 万 / −19 万行，并入了已关闭的 #47571）。作者自己写"Not for merging yet"，PR 描述里的数据很说明成熟度：1,255 个小程序和测试项目里，main 的编译器做对 930 个，这个分支做对 1,102 个；56 个已知的**错误编译**（默认参数下产物给出错误结果或崩溃），main 上有 53 个。另外列了一批 main 上也存在的错误结果，例如 `structuredClone` 后改一行、所有行都变了。分支没人在 Windows 或 macOS 上本地构建过。[^51]
> - **main 的 CI 不全绿**：#47571 的描述说 #44833（`bun test` 的 Vitest 兼容，10/31 合并）之后，main 上 `test/aot` 有 39 个测试一直失败。[^52]
> - **Full types 改名为 `"aot"` 条件**，规则也变了（最晚在 10/29 的 #47129 里就改了，上次漏了）：包的 `exports` 里加 `"aot": "./dist/index.aot.ts"`，文件名从 `index.full.ts` 改为 `index.aot.ts`；不再校验"剥掉类型后逐字等于 `index.js`"，文档改成"没有东西比较这两个文件，请从同一份源码生成"。见下文 Full types 一节。[^53]
> - **Jarred 10/31 发了三组服务端图**：同一个 TS 文件的 Express / Fastify / Hono + SQLite REST API，Bun AOT 对比 Bun JIT 和 Node.js。Express 吞吐持平，内存少 41%，每请求 CPU 少 14%；Fastify 慢 4%，内存少 33%；Hono 快 2%，内存少 27%。他的结论是"大型应用和 Claude Code 这类 CLI 比小应用和 HTTP 服务收益更大"。[^54] 详见数据一节。
> - **11/02 构建速度**：Jarred 贴了一张编译速度表（"Our compiler"，按要求的行数生成程序来编译；推文没说明测试程序，从上下文看是 Bun 的 AOT 编译器），100 万行 18.15 s，`go build` 冷启动 21.31 s，`cargo build` 448.84 s；他自己的评价是"还是太慢，JS/TS 开发者比较的对象几乎是零编译时间"。同日说 `bun check` 还没有缓存。[^55]
> - `Bun.isAOT` 仍未出现。

> **10/29 更新：已合并**。PR #45631 于 **10/27 23:50 UTC** 由 Jarred 合并进 main（merge commit `8d5672c`），最终 347 个 commit，约 +232 万 / −2.6 万行，18,974 个文件。[^40] 合并时的 PR 描述和 10/24 重写版一致，下文的数据、规则和平台状态都不用改。Jarred 10/29 发推确认合并，原话是"Still more to fix/fuzz before its release-able"，也就是**合并了但还不能发布**；同日补充说 AOT 的设计目标是现有 Bun/Node 应用不改代码就能跑，并预期性能、内存和安全上的改进"最终会让 AOT 成为服务端 JS 的默认选项"。[^44] 现在的状态：
>
> - **还没进正式版**。最新稳定版仍是 10/22 的 v1.4.4；canary（构建自 main `da867c60b`）已经带 AOT，`bun upgrade --canary` 就能试，第三方预览构建不用再找了。[^41]
> - **官方文档已上线**，在 `docs/compiler/`（`aot`、`types`、`compatibility`、`libraries`、`size`、`debugging`、`troubleshooting` 等页），每页开头都标注 experimental。文档回答了 qodercli 一节里的两个开放问题：`Bun.build` 有 `compile: { aot: true }`；栈帧带源码的文件、行、列，不需要 source map。见下文更新。[^42]
> - **入口分成两个**：`bun compile` 默认就是 AOT，`--no-aot` 退回 JIT；`bun build --compile` 和 `Bun.build` 默认仍是 JIT（`aot` 默认 `false`）。[^42]
> - **10/29 合入后续 PR #47129**：升级 WebKit，修 module、class、Worker 相关的编译问题，`docs/compiler` 删减约 5,800 行；CI 里单独的 `test-aot` / `test-aot-drawn` 步骤并进普通 `test-bun` 分片；框架测试去掉了 Astro 和 React Router，只保留 Next、Angular、Nuxt、SvelteKit。合并后机器人记录了几处由此 PR 引起的 flaky 测试和 macOS CI 队列拥堵，都已在 #47129 处理。[^43]
> - `Bun.isAOT` 在 main 上仍不存在。
> - **bun 本体变大是 Jarred 自己点名的待办**：他 10/29 吐槽"bun 现在 138 MB，太离谱了"，提到可以出一个不带 AOT 编译器的 bun、需要时再懒下载编译器，但会增加很多复杂度。[^45] 这对不打算用 AOT 的 qodercli 也有影响，见下文风险 11。
>
> 下面 10/26 更新里"X 无法登录"那句已经过时：10/25～10/29 的推文这次用 bird 补读了。
>
> **10/26 更新**：PR #45631 的描述在 10/24 整体重写，数据全部按 10/24 重测，本文的数据、服务端结论和平台状态已按新版改写。截至 10/26 12:14 UTC，PR 仍是 open，已经不是 draft，还没合并：306 个 commit，约 +202 万 / −2.7 万行，14,645 个文件，CI 13 项里 3 项失败，10/26 当天还在高频提交修复。[^11][^38] 社区已有人放出基于该 PR 的非官方预览构建。[^39] 这次 X 无法登录访问，10/25 之后的推文没有逐条核对。另外新增了一节[对 qodercli 意味着什么](#对-qodercli-意味着什么1026-分析)，分析把这项技术用在 qodercli 上的收益和阻碍。

## 一句话

Bun 新增了 `bun build --compile --aot`（简写 `bun compile`，10/27 已合并进 main，11/07 换成重写版编译器，截至 11/10 仍只在 canary 里，Jarred 说会进 Bun v1.5）：在构建时把 TypeScript/JavaScript 直接编译成机器码，产物里不带 JIT，也不带 bytecode。Jarred 说下周合并，然后拿 Claude Code 实测，预期内存和 CPU 降到原来的 1/2～1/3，二进制略小。[^1] 10/24 版 PR 里的 Claude Code 数据和这个说法基本吻合：CPU 降到 1/3，私有内存降到 1/4，可执行文件小 37 MB。[^11] 10/24 他已在 AOT 版 Claude Code 上连续工作约 4 小时，macOS Activity Monitor 显示 267 MB；这只是单次观察，没有同负载对照，不能当成长会话收益的验证。[^33]

```mermaid
flowchart LR
  subgraph JIT["现在：bun build --compile（JIT）"]
    direction LR
    A1["TS 源码"] -->|"擦除类型"| A2["JS 源码 / bytecode<br/>+ 整个 bun"]
    A2 -->|"每次启动"| A3["解析 → 解释执行"]
    A3 --> A4["观察类型 → 热点编译"]
    A4 -->|"猜错"| A3
  end
  subgraph AOT["新：bun build --compile --aot"]
    direction LR
    B1["TS 源码"] -->|"保留类型<br/>全程序分析"| B2["机器码镜像<br/>（只读映射）"]
    B2 -->|"每次启动"| B3["直接执行"]
    B3 -->|"guard 失败"| B4["同函数的慢版本"]
  end
```

## AOT 是什么

AOT 是 Ahead-of-Time compilation（预先编译）的缩写，指在程序运行之前、构建阶段就把源码编译成目标机器的机器码。和它相对的是 JIT（Just-in-Time，即时编译）。

| | JIT（Node、Bun、浏览器现在的做法） | AOT（Bun 正在做的） |
|---|---|---|
| 什么时候编译 | 程序运行时，在用户机器上 | 构建时，在开发者机器上 |
| 启动过程 | 解析源码 → 解释执行 → 观察类型 → 热点函数再编译成机器码 | 直接运行已经编好的机器码 |
| 类型信息从哪来 | 运行时观察实际出现的值，猜测后编译，猜错就丢弃重来 | 读 TypeScript 类型注解，加上全程序分析 |
| 代价 | 每次启动都要预热；编译线程占 CPU 和内存；需要可写可执行内存 | 构建慢；拿不到运行时信息，峰值速度可能不如 JIT |
| 典型例子 | V8、JavaScriptCore、HotSpot JVM | C/C++、Rust、Go、GraalVM Native Image、.NET Native AOT |

Jarred 在 9/29 的说法：大多数 JS 都是 JIT 编译的，代码运行时会观察值的类型，函数跑得够频繁时再按需编译一个更快的专用版本；AOT 把这些工作提前烘焙进可执行文件。代价是可用的类型信息更少：Rust/Go 的数字会写明是整数还是浮点、有无符号、多少位，TypeScript 只有 `number`，优化更难。[^6]

所以 Bun AOT 的核心思路是：TypeScript 的类型以前在构建时被擦掉，运行时引擎再花力气重新猜一遍；现在构建时保留下来，直接用来决定对象布局和生成的指令。之前大家想让 JS 工具变快，通常是用 Rust/Go 重写（esbuild、SWC、Biome、TypeScript 7）；Bun AOT 提供另一种选择：代码不动，换一种编译方式。[^11]

> 注意别和 Bun 已有的 `bun build --compile` 混淆。后者只是把源码（或 bytecode）和 Bun 运行时打包成单个可执行文件，运行时仍然走 JIT。加上 `--aot` 才是真的编译成机器码。

## 书签里的那条

> Merging Bun AOT next week, then testing on Claude Code. Expecting 2-3x less memory + CPU & a slightly smaller binary. This is the future of server-side JavaScript. Instead of you rewriting in Rust, we rewrote JavaScript's compiler to emit native code ahead of time. [^1]

它引用的是 10/21 的"第 4 次尝试"[^2]。Jarred 在评论区补了两点，解释同一份代码为什么能省内存：

- JIT 运行时会开大约 3 个线程不停编译、丢弃代码，这本身就吃 CPU 和内存。AOT 用了 32 位对象引用、扁平对象布局、尽量不创建函数对象、thin closure 等一堆手段。[^3]
- 有些事只有 AOT 做得到，JIT 因为依赖惰性解析做不到。比如 JSC 和 V8 都有的经典泄漏：子函数把整个作用域留在内存里。AOT 下不会发生。[^4]
- 仍基于 JavaScriptCore。大多数 JS AOT 项目从零写引擎，Bun 选择复用 JSC 20 年的积累，团队也熟悉 JSC。[^5]

## 时间线

| 日期 | 事件 |
|---|---|
| 9/29 | 首次预览：Claude Code CLI 启动快 24%，内存降 48%，CPU 降 46%，二进制大了近 2 倍。[^6] |
| 10/4 | Claude Code 二进制从 430 MB 降到 304 MB；TypeScript 6 在 AOT 下比 JIT 快。[^7] |
| 10/10 | 用 AOT 编译的 TypeScript 6 单线程检查 Effect，比 TypeScript 7（Go）略快。[^8] 生态问题：只有 .d.ts 不够，要拿 .ts 源码编译才能吃满收益。[^9] |
| 10/16 | 公开当时的流水线：`bun check` 类型检查（允许无类型代码）→ Typed IR → 优化 pass → JSC 的 B3 后端 → ARM64/x64 机器码。[^10] |
| 10/18 | 发出大 draft PR #45631。[^11] |
| 10/19 | 承认这是第 3 次尝试。前两次在 `bun check` 之前，基于 bytecode 而不是 TS 类型，比 JIT 还慢，二进制有时到 1 GB。PR 内部也不够好：Claude Code 只有 38% 的类型是已知的，typed 操作的指令数有时比 untyped 还多，有六遍解析。决定重写。[^12] |
| 10/21 | 第 4 次尝试："It's just TypeScript"。上周说的 `as` 会改变运行时行为、函数参数类型不对会抛错，这些全部撤回。[^2] |
| 10/24 | 宣布下周合并，接着在 Claude Code 上测。[^1] 随后报告在 AOT 版 Claude Code 上工作约 4 小时、Activity Monitor 显示 267 MB；另指出 `new Function` 库在 AOT 下偏慢，考虑加 `Bun.isAOT`。[^33][^34] PR 描述整体重写，全部数据按 10/24 重测，新增服务端基准、Full types、`--trim` 和平台状态表。[^11] |
| 10/25 | 从 profile 观察到 schema 校验库仍是 AOT 的主要性能瓶颈，考虑把类型检查器与运行时结合。[^36] 第三方 aphrody-labs 放出基于 PR commit `5b598476c` 的 Linux/Windows x64 预览构建。[^39] |
| 10/26 | PR 仍未合并，当天持续提交修复（CommonJS 顺序、tail call、int32 字段、`--trim` 输出、stack frame 名称等）。[^38] |
| 10/26 晚 | 推文介绍 `--trim`：macOS 上一个用 `Bun.serve` 的二进制从 89 MB 降到 25 MB；并说 trim 同样能删原生库和 CLI 子命令，以后也许能出不带运行时的 bun。[^46] |
| 10/27 | steipete（Peter Steinberger）说周末试了 AOT，"性能提升 2～3 倍，内存不到一半"，没给测试对象和方法，Jarred 转推。[^47] Jarred 发视频介绍 AOT 怎么测试。[^48] 23:50 UTC PR 合并进 main：347 个 commit，+232 万 / −2.6 万行，18,974 个文件。[^40] |
| 10/29 | Jarred 发推"Bun AOT is merged"，同时说还要继续修和 fuzz 才能发布；吐槽 bun 本体 138 MB。[^44][^45] 后续 PR #47129 合并：WebKit 升级、module/class/Worker 修复、`docs/compiler` 精简、AOT 测试并入常规 CI。canary 已包含 AOT，正式版还没有。[^41][^43] |
| 10/31 | #47316 合并：`bun test --aot` 支持 mock、大测试集分层构建，模块加载和 fuzzer 修复。[^50] Jarred 发 Express / Fastify / Hono 三组 AOT vs JIT vs Node 对比图。[^54] |
| 11/01～11/02 | 后续 PR #47605 开出，作者标注暂不合并，列出已知错误编译清单。[^51] Jarred 贴编译速度表对比 `go build` / `cargo build`，自评"还是太慢"。[^55] |
| 11/04 | 稳定版仍是 v1.4.4，AOT 还在 canary。[^49] 编译器中段重写开 PR（WebKit#997 + bun #47942）：构建指令数降到约 1/10，产物在 TS 编译器基准上慢约 1/3。[^58] 晚上 Jarred 宣布周五拍 v1.5 视频，v1.5 会包含 AOT。[^57] |
| 11/05 | issue #47955：MDWE 让自带 JIT 的原生库崩溃；#47957 提出 `--aot-allow-executable-memory`。[^59] |
| 11/06～11/07 | 拍完 v1.5 视频。[^65] WebKit#997 和 #47942 合并，重写版编译器进 main；#47605、#47957 关闭。[^62] |
| 11/09 | Jarred："又重写了一遍，编译快 4 倍"。晚上发 OpenCode（内存 −41%）和 OpenClaw（启动快 3 倍）数据。[^63][^64] |
| 11/10 | #48120 合并；开 #48436 / WebKit#1025（Wasm 进优化层等）。稳定版仍是 v1.4.4。Jarred 说接近 Rust/C 的性能大概需要新语法。[^62][^66][^67] |

## 工作原理（以 PR #45631 合并时的描述为准）[^11]

**目标**：不是新语言也不是子集，现有入口文件直接编译，不需要新语法和额外标注。10/24 版 PR 把规则收成三条：

1. `bun run` 能跑的程序，编译后行为一致。
2. 不会因为类型在运行时抛错：`as`、`any`、`!` 从不转换值，也从不抛错。
3. 新的错误出现在构建期，并带说明。例外单独列在下面的"破坏性变更"里（旧版第 4 条"内置对象只读"并入了那里）。

**构建流水线**：`--aot` 下不打包，每个模块保持独立，CommonJS 模块体变成一个函数；Bun 自己的 `node:` / `bun:` 模块也从 TS 源码一起编译。

```mermaid
flowchart TD
  L["src/aot/load<br/>从入口沿 import 遍历<br/>（resolver / loader / macro / Bun.build 插件），每个文件只解析一次"]
  M["src/aot/modules<br/>模块图：ES 链接、CJS 导出名、求值顺序<br/>src/sema/fold 折叠 process.platform 等，删掉死分支"]
  S["src/sema（bun check 背后的检查器）逐文件类型检查<br/>src/aot/lower 把 AST + 类型降成 SSA IR，多线程"]
  K["src/aot/link 合并成一个程序<br/>src/aot/emit 按两仓共享的 AOTSchema 写出"]
  J["JavaScriptCore：全程序 flow 分析 → 优化 IR<br/>→ B3 生成机器码 → 写出镜像（代码 + 只读数据）"]
  E["src/bundler/aot + exe_format + trim<br/>把镜像塞进一份 bun 拷贝，带函数符号，去掉被 trim 的部分"]
  L --> M --> S --> K --> J --> E --> X(["单文件可执行程序"])
```

> **11/10 补充：图里的 J 这一步已经换掉。** 11/07 合并的 WebKit#997 把"全程序 flow 分析 → 优化 IR → B3"换成四段：`aot/facts`（每个函数扫一遍，再多线程 Link 一次全程序）→ `aot/plan`（定槽位、布局和调用约定）→ `aot/walk`（每个函数走一遍，边定类型边折叠、内联、选指令）→ `aot/machine`（自带寄存器分配和编码器的小后端）。程序自己的 WebAssembly 改走 BBQ 基线层，#1025 在把它加回优化层。前后两端（load、sema、lower、emit、trim）不变。[^58]

内置函数由一张表描述：每个 built-in 接收什么、返回什么、读写什么、会不会回调。这张表由 `src/codegen/builtins` 从引擎描述和 Bun 自己的类/模块定义生成，所以改 Bun 的原生类不需要重新构建 WebKit。[^11]

**类型怎么用**：TS 本身不 sound（`any`、`as`、`!`、`JSON.parse`、.d.ts 都能撒谎），所以编译器分两种情况读类型：

- **程序自己创建的值，类型当事实。** `new Vec(1, 2)` 或声明了类型的对象字面量直接拿到该类型的布局。`class Vec { x: number; y: number }` 是 16 字节头加两个裸 double，能证明只有 Vec 到达时，`a.x` 就是一次 load，没有 hidden class 检查、没有 inline cache、没有装箱。
- **从外部拿到的值，类型当预测。** 构建看不到的调用方传进来的参数、`JSON.parse` 的结果，在入口测一次，失败走慢路径。比如 `double(n: number)` 收到字符串 `"3"`，入口 guard 把这次调用转到慢版本，结果和普通 JS 一样是 6，字符串仍是字符串。回退按调用进行，下一次传数字又走快版本。

```mermaid
flowchart LR
  V["值到达属性访问 / 函数入口"] --> Q{"编译器能证明<br/>是哪种对象吗？"}
  Q -->|"能（类型 / 全程序跟踪 / 前面测过）"| F["free<br/>一次 load / store"]
  Q -->|"可能混进未检查的值"| T{"shape 测试"}
  T -->|"通过"| F2["load"]
  T -->|"失败"| SL["慢路径（行为同普通 JS）"]
  Q -->|"什么都不知道"| N["by name<br/>运行时按名查找（带缓存）"]
```

- JS 文件也一样编译：class 照样有固定布局，全程序 flow 分析会从对象创建处一路跟到使用处，有没有标注都行。
- 属性访问的三档分布在构建时打印出来，例如 `92.4% of property accesses are one load: 1,204 free, 61 tested, 38 by name`；`--explain` 按严重程度列出慢的地方和修法。（旧版 PR 给过 TS6 编译器的分布 25% / 66% / 9%，新版没再给。）
- 固定布局的对象仍是普通对象：`Object.keys`、`JSON.stringify`、spread、`for...in` 照常；可以加未声明的属性、删已声明的属性、通过 `any` 往 `number` 字段写字符串，代价只是变慢。
- `JSON.parse<T>(text)`（从 `"bun"` 导入 `JSON`）和 `validate<T>(value)`（从 `"bun:bundle"` 导入）按已有类型校验数据，并直接生成 `T` 布局的对象。这两个会抛错，本来就是干这个的。
- 新增 `import type { int32 } from "bun"`：4 字节整数字段，对 TS 和 `bun run` 来说就是 `number`；构建必须证明每次写入都合法，证明不了就报错。

**仍然支持**：npm 包（有无类型都行）、ESM/CJS/`require`/顶层 await、N-API、Workers、Proxy、getter/setter、生成器、decorator、`with`，以及 `eval` / `new Function` / `node:vm`（落到 JSC 解释器里，同进程、和编译代码共享对象）。注意：**解释器只跑运行时才出现的文本，构建时看得到的代码不会回退到解释器**，编不了的函数直接是构建错误。

**破坏性变更**（新版六条）：

| 变更 | 换来什么 |
|---|---|
| 类型错误会让构建失败（TS7 的错误，来自 `bun check` 背后的检查器） | 编译器拿到的类型彼此自洽 |
| 内置对象已有成员不可替换（`Array.prototype.push = fn` 抛 TypeError，sloppy mode 也一样；新增成员可以）；`Object.prototype`、`RegExp.prototype`、`Promise.prototype`、生成器原型完全不可改；`Request`、`Response` 等 7 个 Bun 类的原型只读 | `arr.push`、`map.get`、`Math.floor` 直接编成操作；顺带消灭原型污染 |
| 没有 `eval`/`new Function` 调用的程序是封闭世界。编译器把函数当值来追踪，`const run = eval` 也算；追踪不到的调用（如 `globalThis[name](https://research.sorrycc.dev/pub/g6rfntuvswrn/p/code)`）抛 `EvalError` | 所有调用方已知，直接调用，guard 消失，不可达代码不编译 |
| 可执行文件只包含可达代码；计算路径的 `import()`/`require()` 按常量部分匹配文件，其他代码像文件不存在一样抛错；数据文件照常加载 | 单文件，无需旁边带 node_modules |
| 模块最多执行一次，不进 `require.cache` | import 变成对变量/函数的直接引用 |
| 每个线程最多 32 GB 对象，`--aot-huge-heap` 可解除 | 对象之间的引用是 32 位 |

配套工具：`bun check --aot`（不运行，报告构建会报的所有问题；`--explain=guards` 列出每个可能失败的 guard）、`bun run --aot` / `bun test --aot`（按构建规则检查后从源码运行，内置对象只读）、`--aot-log-type-mismatches`（编译产物记录每个实际失败的 guard）。

**从磁盘加载代码默认关闭**：动态 `import()`/`require()` 默认只加载可执行文件里的代码。`--aot-allow-code-from-disk` 允许加载磁盘上的插件或配置（解释执行），`--external <package>` 针对单个包。这有代价：开启后 warm 状态的 Express RPS 再少 13%，Koa 少 16%，其余五个框架不受影响。

**安全**：没有 JIT 就不需要可写可执行内存。机器码像 C 程序的 `.text` 一样只读映射；Linux 6.7+ 在代码映射完后调用 `prctl(PR_SET_MDWE)`，内核从此拒绝新的可执行内存。`dlopen()`、`bun:ffi` 调用和最多 256 个 `JSCallback` 仍可用（11/05 补充：重写版 #47942 取消了 256 个的限制）；自己 JIT 的原生库（LuaJIT、PCRE2 JIT、Mesa lavapipe）会在 MDWE 下失败，#47957 曾想加关掉它的开关，11/07 随重写版合并被关闭，现在没有开关[^59][^62]；`bun:ffi` 的 `cc()` 和自己生成机器码的原生扩展不能用。运行时用字符串构造的 `RegExp` 不走 JIT；WebAssembly 只有程序 import 的 `.wasm` 文件会被编译，其他解释执行。`--disallow-code-generation-from-strings` 关掉 `eval`，和 Node 的同名 flag 一样。

**其他限制**：没有 profile 和 heap snapshot 参与编译，热点只能从循环和调用图估计；除 macro 外构建期不执行用户代码。不支持交叉编译（只能为当前平台出码）；用 `--compile-inspector` 构建时 console、heap snapshot、CPU profile 可用，断点和单步不可用。

**平台状态**（10/24 版 PR）：

| 平台 | 状态 |
|---|---|
| Linux x64, glibc | 已测试 |
| Linux arm64、Linux musl、macOS arm64、macOS x64 | 已测试，仍有部分测试失败 |
| Windows x64、Windows arm64 | 已测试，很多测试失败 |
| FreeBSD、Android | 能构建 bun，未测试 |

**Full types（新增）**：npm 发布时类型会被剥掉，.d.ts 只留导出签名，所以编译应用时自己的代码有类型、`node_modules` 没有，而很多程序的时间就花在依赖里。PR 提出在包里多放一个 `index.full.ts`（带全部类型的实现），挂在 `exports` 的新条件 `"full-types"` 下，其他工具不认这个条件，行为不变。唯一规则：剥掉类型必须**逐字**等于已安装的 `index.js`，每次构建都校验；不一致或有类型错误只给警告，该包按无类型编译，依赖的类型永远不会让你的构建失败。`bun compile --library` 可从 TS 一次产出 `index.js`、.d.ts、`index.full.ts` 和带条件的 `package.json`；`packages/full-types` 先给 react-dom、Express、Fastify、Koa 补了类型。这正是对 10/10 那条"只有 .d.ts 不够"的回应。[^9][^11]

> **11/04 补充：合并后的版本改了名字和规则。** 现在的文档里条件叫 `"aot"`，文件叫 `index.aot.ts`（也可以直接指向源码，如 `"aot": "./src/index.ts"`），要放在 `exports` 条件的第一位。`bun compile` 以及带 `--aot` 的 `bun run` / `bun test` / `bun check` 读它，其他工具读 `index.js`。逐字校验没了，文档原话是"Nothing compares the two files"，要求作者自己从同一份源码生成两份。包按自己 `package.json` 里的 `compilerOptions` 检查（没有就按 `strict`），安装方的 `tsconfig.json` 不生效；有类型错误时仍只警告、按无类型编译，语法错误或文件缺失会让构建失败。`bun compile --library` 产出 `index.aot.ts`。[^53]

**`--trim`（新增）**：`--compile` 产物是 bun 本体加你的程序，hello world 也带着包管理器、测试运行器、类型检查器和几个 JIT。`--aot` 总是去掉这些；`--trim` 进一步去掉程序没用到的 API（`bun:sqlite`、`Bun.Image`、`HTMLRewriter`、按 locale 的 `Intl` 数据、WebAssembly、bundler、debugger）。只删代码不删名字，`typeof` / `in` / `instanceof` 结果不变，调用被删功能时抛 `ERR_FEATURE_REMOVED` 并说明如何保留；`--explain=trim` 列出每项保留或删除的原因。Jarred 10/26 给了一个数：macOS 上用 `Bun.serve` 的二进制从 89 MB 降到 25 MB。剩下的 25 MB 他解释为 JSC 和 Bun 优先速度而不是体积，并发 GC 和对象模型都占代码；不开 AOT 也能 trim，但 JIT 本身约 20 MB，效果小一些。[^46]实现上是在链接 bun 本体时就把可删的 section 分组到页对齐区间，`bun build --compile` 只是不映射它们，所以用户不需要链接器或工具链。

## 数据（PR 中的测量，10/24 重测版）[^11]

以下数据均为 Linux x64、AMD EPYC 9R14、LTO 构建，2026-10-24 测量。都是 Bun 团队自测，没有第三方复现。

**TypeScript 6 编译器，检查 Effect 的 `packages/effect`（370,839 行，各行均 0 错误，16 核独占，5 次取中位数）**

| 方案 | wall | 峰值 RSS | CPU |
|---|---:|---:|---:|
| TypeScript 7 (Go) | 2.68 s | 1,256 MB | 10.8 s |
| **TS6 `v6.0.3`，`--aot`** | **4.25 s** | **963 MB** | **5.3 s** |
| TS7 `--singleThreaded` | 5.08 s | 933 MB | 6.2 s |
| TS6 on Bun 1.4.3 | 14.00 s | 2,581 MB | 29.2 s |

TypeScript 源码一行没改。同一份编译器，AOT 后比 Bun 1.4.3 快 3.3 倍，内存是 1/2.7，CPU 时间是 1/5.5。Go 版靠并行在墙钟上赢；去掉并行（`--singleThreaded`）后原版 TS6 先跑完，CPU 更少，内存差不多。PR 附了完整复现脚本。（旧版 PR 还有 `bun check` 和 Node 26.3 两行，新版删掉了。）

**Claude Code CLI（脚本化会话：启动、首个 prompt、5 轮，API 本地 stub，16 次交替取中位数）**

| 指标 | 现发布版 | `--aot` |
|---|---:|---:|
| 首个 prompt 可用 | 318 ms | **141 ms** |
| 峰值私有内存 | 185.4 MB | **44.7 MB** |
| 首个 prompt 时私有内存 | 112.0 MB | **28.7 MB** |
| 结束时私有内存 | 150.1 MB | **37.5 MB** |
| 峰值 RSS | 308.5 MB | **180.8 MB** |
| CPU 时间（全部线程） | 1,542 ms | **512 ms** |
| 指令数 | 5,530 M | **1,117 M** |
| 可执行文件 | 266.9 MB | **230.0 MB** |

首个 prompt 时间不到一半，CPU 是 1/3，私有内存是 1/4。**可执行文件小了 37 MB**，旧版 PR 里"大 29 MB"和推文"slightly smaller binary"对不上的问题已经解决。不过这仍是 5 轮的短会话，评论区关心的长会话、子 agent 稳态内存依然没有数据。

**服务端（新增）**：同一个小 API 写了 7 遍（手写 `Bun.serve`、`node:http`，以及 Hono、Elysia、Express、Fastify、Koa），三个中间件、路由参数、query、JSON 进出、错误处理和 404。每个都用同一个 bun 构建两次，一次 `--aot`，一次普通 `--compile`（JIT），只有编译器不同。每个服务器和压测器各绑一个核，64 连接，响应逐字节比对，7 次启动取中位数。

```mermaid
xychart-beta
  title "AOT / JIT 的 RPS 比值（1.0 = 持平）"
  x-axis ["Koa", "Express", "Fastify", "node:http", "Hono", "Bun.serve", "Elysia"]
  y-axis "AOT / JIT" 0 --> 2
  bar [1.93, 1.93, 1.53, 1.48, 1.23, 1.09, 1.03]
  line [0.77, 0.93, 0.83, 1.00, 1.03, 1.02, 0.87]
```

柱子是进程启动后第 1 秒的比值，折线是 JIT 预热后（第 100,001～400,000 个请求）的比值。

| 框架 | 第 1 秒 AOT / JIT | 预热后 AOT | 预热后 JIT | 预热后差异 |
|---|---:|---:|---:|---:|
| Hono | 1.23x | 59,737 | 58,151 | +2.7% |
| `Bun.serve` | 1.09x | 85,553 | 83,490 | +2.5% |
| `node:http` | 1.48x | 70,205 | 70,383 | −0.3% |
| Express | 1.93x | 47,935 | 51,587 | −7.1% |
| Elysia | 1.03x | 65,110 | 75,268 | −13.5% |
| Fastify | 1.53x | 59,656 | 71,796 | −16.9% |
| Koa | 1.93x | 34,194 | 44,362 | −22.9% |

同一程序构建两次的差异最多 1.9%，所以 3% 以内算持平：前三个持平，后四个输。从进程启动算累计请求数，JIT 在 Elysia 上 2 秒内追平，Fastify 和 Koa 5 秒内追平，Express 到第 5 秒 JIT 仍领先。

| 框架 | 首个响应 AOT | 首个响应 JIT | 峰值 RSS AOT | 峰值 RSS JIT |
|---|---:|---:|---:|---:|
| `Bun.serve` | 8.3 ms | 7.7 ms | 32.1 MB | 45.7 MB |
| Hono | 9.3 ms | 11.5 ms | 34.4 MB | 51.8 MB |
| Elysia | 11.5 ms | 27.5 ms | 40.8 MB | 56.6 MB |
| `node:http` | 11.5 ms | 21.4 ms | 43.8 MB | 61.8 MB |
| Fastify | 17.0 ms | 63.4 ms | 51.1 MB | 73.1 MB |
| Express | 18.3 ms | 50.4 ms | 54.4 MB | 85.9 MB |
| Koa | 20.1 ms | 66.7 ms | 57.2 MB | 85.3 MB |

- 机器码是可执行文件的 file-backed 页，内核可以在进程间共享。私有内存 AOT 13～25 MB，JIT 15～47 MB。
- 可执行文件 69～82 MB，普通 `--compile` 是 141～144 MB。
- 固定 5,000 RPS 时，p99 延迟 AOT 54～91 µs，JIT 77～477 µs；中位数 21～40 µs 对 21～34 µs。

**Jarred 10/31 的三组图（合并后，新增）**：同一个 TS 文件的 REST API，链路是 3 个中间件（Fastify 是 3 个 hook）→ bearer auth → 4 条 SQLite 查询 → 2.3 KB JSON；Bun AOT、Bun（JIT）、Node.js 各跑一次满载，各 4 核。图里没写硬件和重复次数，是单次运行，和上面 PR 那组 7 次取中位数的数据口径不同。[^54]

| 框架 | 稳态 RPS AOT / Bun / Node | 峰值内存 AOT / Bun / Node | 每请求 CPU AOT / Bun / Node | 达到 97% 终速所需请求数 AOT / Bun / Node |
|---|---|---|---|---|
| Express | 14,200 / 14,200 / 7,700 | 51 / 87 / 138 MB | 70 / 82 / 150 µs | 1,000 / 12,000 / 18,000 |
| Fastify | 17,000 / 17,700 / 10,500 | 54 / 82 / 157 MB | 59 / 64 / 110 µs | 2,000 / 12,000 / 17,000 |
| Hono | 18,300 / 17,900 / 6,600 | 35 / 48 / 168 MB | 55 / 58 / 182 µs | 2,000 / 2,000 / 17,000 |

- 对 Bun JIT：Express 持平、CPU −14%、内存 −41%；Fastify 慢 4%、CPU −8%、内存 −33%（Jarred 解释 Fastify 用 `new Function`，路由处理至少部分是解释执行）；Hono 快 2%、CPU −5%、内存 −27%（Hono 代码量小得多）。
- 和 PR 那组比，Express 从"预热后 −7.1%"变成持平，Fastify 从 −16.9% 变成 −4%。负载加了 SQLite 和 auth，口径也不同，不能直接说是合并后变快了，但方向是差距在缩小。
- Jarred 的总结："very large apps and CLIs like Claude Code will benefit more from AoT than small apps and HTTP servers"，Bun 自己的 HTTP 服务器本来就快。
- 回复里的追问：二进制多大、重建要多久（对每次小改都重建的 agent 是问题）、是不是 AOT + JIT 混合、什么时候发布、能不能用在 Cloudflare Workers。截至 11/04 Jarred 没在回复里作答。[^54]

**OpenCode 和 OpenClaw（11/09，重写版编译器，新增）**：Jarred 发的两张柱状图，基于 #48120，Linux x64 12 核，各跑 10 次以上取中位数，用每个项目自己的构建脚本、不改代码。opencode 的 Bun 一栏就是当天 npm 上的发布版。[^64]

| 项目 | 指标 | Bun AOT | Bun JIT | Node v26 |
|---|---|---:|---:|---:|
| opencode 2.1.4 | 首帧 | **0.46 s** | 0.65 s | – |
| opencode 2.1.4 | 20 轮峰值内存 | **421 MB** | 712 MB | – |
| OpenClaw | 网关就绪 | **2.75 s** | 6.66 s | 8.62 s |
| OpenClaw | 就绪时 RSS | **732 MB** | 882 MB | 1,181 MB |

- opencode 和 qodercli、Claude Code 是同一类东西：TS 写的终端 agent。"20 轮峰值"比 PR 里 Claude Code 那组 5 轮的数据更接近评论区一直在问的长会话。−41% 比 Claude Code 的私有内存 −76% 小，口径也不同（这里看的是峰值，没说是 RSS 还是私有内存）。
- 推文标题把 OpenClaw 的"启动快 3 倍"和 opencode 的"内存 −41%"放在一起，回复里有人指出两个数字来自不同程序。OpenClaw 对 Bun JIT 是快 2.4 倍、RSS −17%；3.1 倍是对 Node。Jarred 补充 OpenClaw 构建脚本的输入"100% 是无类型 JS"，还有提升空间。
- 当晚 Jarred 说 WebAssembly 编译的改进让 OpenCode 的 CPU 比早上再少 13%，没给绝对值。opencode 用 tree-sitter 的 wasm，这和 qodercli 风险 7 是同一件事。[^64]

旧版 PR 的"Koa 少 36%、Next.js route handler 少 39%、zod 4 路由少 26%～53%"已被这组新数据替换，Next.js 和 zod 路由的单独数字新版没再给。

**PR 自己写的短板（"Where it loses"）**

- **warm JIT 在无类型 npm 代码上仍然赢**，就是上面第二张表。Koa、Fastify、Express 是由许多小包组成的无类型 JS；JIT 靠运行时观察知道哪些对象到达属性访问，编译器必须在构建时证明，证明不了就是按名查找。PR 押注的出路是 Full types。
- **运行时生成的代码一直解释执行**：zod 4、ajv、fast-json-stringify、Elysia 用 `new Function` 生成热点代码，这是 Elysia 落后的主要原因。校验场景的替代方案是 `JSON.parse<T>` / `validate<T>`。
- **老式无类型 JS 更慢**：构造函数、class helper、asm.js 输出、对普通数组元素做算术。JIT 看到 `a + b | 0` 每次都是两个 int32 就编译一个加法；编译器要证明它们是 int32，证明不了就调用通用加法。JetStream2 大部分测试 AOT 更慢。
- **日常写法互有胜负**：`test/aot/perf` 有 1,814 个惯用写法，每个按"原样"和"擦掉类型"各编一次，取较慢者和同一 bun 的 warm JIT 按指令数比较：

  | 场景 | 领先 | 5% 以内 | 落后 | 中位比值 |
  |---|---:|---:|---:|---:|
  | 每个写法单独成程序 | 916 | 223 | 675 | 0.94 |
  | 模拟编进超大程序 | 467 | 118 | 1,229 | 1.44 |

  第一行已有三分之一以上落后（180 个落后超过 2 倍），而且这一行还偏袒编译器：单独成程序时循环被视为热点并内联。大程序不可能处处都热，没有 profile 只能从循环和调用图猜。第二行模拟这种情况，三分之二落后，687 个落后超过 2 倍。
- **构建慢**：整程序类型检查并编译所有可达函数，构建之间没有缓存，改一行就全部重来。大型应用要几十秒、几 GB 内存。（旧版写的 Claude Code 16 核 36 s / 笔记本 24 s / 目标 10 s，新版没再给具体数字。）11/02 Jarred 贴的速度表：生成 10 万 / 100 万 / 500 万行，"our compiler" 2.23 / 18.15 / 93.80 s，`go build` 冷启动 5.37 / 21.31 / 99.74 s，`cargo build` 38.71 / 448.84 s；他觉得仍然太慢，`bun check` 也还没缓存。[^55] 11/05 补充：重写版 #47942 / WebKit#997 在 TS 编译器上把构建从 543 G 指令降到 55 G。11/10 补充：两个 PR 已于 11/07 合并，最终数据里产物运行慢 16%（墙钟）；Jarred 11/09 说那张按行数生成程序的基准又快了 4 倍，没贴新表。[^58][^63]
- **可执行文件仍大**：小服务器 69 MB，是 `--compile` 的一半，但仍有 69 MB；`--trim` 有帮助。
- **bun 本体变大约 30 MB**（musl 约 23 MB），因为编译器就在 bun 里，不用 AOT 的人也要付这个体积，每个普通 `--compile` 产物也跟着变大。Jarred 10/29 自己也说"bun 138 MB 太离谱"，可选方案是 bun 默认不带编译器、按需下载，但复杂度很高，目前没有定论。[^45] PR 同时改了不走 `--aot` 时也会执行的代码（`src/js` 里的 `node:http`、streams、events、`process.nextTick`，`src/sema` 检查器，可执行文件格式，JSC 共享部分），作者说这部分最需要 review。
- **小程序仍输给 Go/Rust**：hello world 启动更晚、内存更多、文件更大，因为带着 Bun 运行时。
- **还有已知 bug**：fuzzer 仍能找到编译错误的程序，已知失败在 `test/aot` 里标成 `todo`。11/04 补充：#47605 统计 main 上有 53 个已知错误编译（产物给出错误结果或崩溃），1,255 个小程序和测试项目里 main 做对 930 个。11/05 补充：#47605 的分支剩 5 个左右，但自己又引入 4 个 main 上没有的回归。[^51]
- 10/17 Jarred 提到可能把 schema 校验库集成进 Bun，因为校验库是 AOT 在没有编译器配合时最差的场景。[^13] 10/25 他进一步说，正在看的 profile 里指令数和 RPS 主要输给校验库；这是定性观察，没有公开新的 benchmark 数值。[^36]

Jarred 10/24 明确补充：借 `new Function` 在运行时生成代码的库在 AOT 下会慢，需要构建期生成代码或让编译器能静态分析；受影响的例子包括 Fastify、Elysia、Koa、Zod、TypeBox。他说"可能"增加 `Bun.isAOT` 供库检测。第三方预览构建确认，在 10/24 的 commit `5b598476c` 上 `Bun.isAOT` 仍是 `undefined`。[^34][^35][^39]

**测试规模**：新增行数大部分是测试。每个测试程序要跑三遍并结果一致：普通 Bun、编译版、擦掉类型后的编译版；另有 test262、JSC 和 Node 的测试、Bun 自己的 `test/js`，以及 Next、Nuxt、Astro、SvelteKit、Angular、React Router 的构建和服务测试（#47129 去掉了 Astro 和 React Router，理由是它们从没抓到过编译器 bug，而构建站点又是测试的主要开销[^43]）。test262 的 47,536 个文件里 33,467 个能以模块方式运行，其中 31,231 个通过，失败的大多是在改 built-in。全部测试单核要跑 130 小时，所以每次 CI 按 commit hash 抽十分之一，`AOT_SHARE=all` 跑全量。

**第三方预览构建**：aphrody-labs 在 10/25 用上游脚本、不改源码构建了 PR commit `5b598476c` 的 Linux x64 和 Windows x64 版本（`bun --revision` 显示 `1.4.4-canary.1+5b598476c`），带安装脚本，装到 `~/.bun-aot/bin/bun`。他们测得 5 行程序的 AOT 可执行文件 Linux 68 MB、Windows 80 MB，普通 `--compile` 是 140 / 147 MB；`.bun` section 里是 640 KB 的编译镜像，不含源码。这是非官方、未签名的二进制。10/27 合并后官方 canary 已经带 AOT，直接用 canary 即可，这个预览构建没必要再用。[^39][^41]

所以目前的结论（按 10/24 新数据修正）：**AOT 在启动、内存、CPU 和尾延迟上收益明确；稳态峰值吞吐取决于代码有没有类型。** 有类型或手写的服务器（Hono、`Bun.serve`、`node:http`）预热后持平，无类型的中间件框架（Express、Fastify、Koa）和依赖 `new Function` 的库（Elysia、zod 4、ajv）预热后输 7%～23%。适合 CLI、serverless、多进程、冷启动敏感和对 p99 敏感的场景；长期运行、依赖无类型框架的高吞吐 HTTP 服务未必划算，要等 Full types 生态。

```mermaid
quadrantChart
  title "什么场景适合 --aot（定性，依据 10/24 PR 数据）"
  x-axis "进程短命" --> "长期运行"
  y-axis "依赖无类型 / new Function 代码" --> "代码有类型"
  quadrant-1 "持平或小赢，看重内存与 p99 可上"
  quadrant-2 "最适合"
  quadrant-3 "启动收益仍在"
  quadrant-4 "暂时不划算"
  "Claude Code CLI": [0.2, 0.75]
  "TS6 编译器": [0.3, 0.9]
  "Serverless 函数": [0.15, 0.5]
  "Hono / Bun.serve 服务": [0.8, 0.8]
  "Express / Koa 服务": [0.85, 0.2]
  "Elysia + zod 服务": [0.8, 0.1]
```

## Claude Code 二进制实测（11/05）

问题：Claude Code 最新版是不是已经用 AOT 编译了？做法是从 npm 下载 `@anthropic-ai/claude-code-darwin-arm64` 和 `-linux-x64` 的 2.1.318（11/03 发布的 `latest`；`stable` 还是 2.1.311），用 `otool` / `size -m` 看 Mach-O 段，把 `__BUN,__bun` 段导出来查内容，和本机装的 2.1.304（10/20）对比。只做了静态检查，没有运行。[^61]

| | 2.1.304 | 2.1.318 |
|---|---|---|
| Bun 版本串 | `1.4.4+de4bc695b` | `1.4.4+424a542a9` |
| 二进制（darwin-arm64） | 271 MB | 320 MB（linux-x64 338 MB） |
| Bun 运行时代码 `__TEXT,__text` | 79.5 MB | 108.8 MB（+29 MB） |
| 新段 | 无 | `__bun_aot`、`__bun_trim`、`__bun_features`、`__bun_build_id` |
| 运行时里的 AOT 字符串（`aot-allow-code-from-disk`、`aot-huge-heap`、`ERR_FEATURE_REMOVED`、`left out of the executable`） | 无 | 有 |
| 应用 payload `__BUN,__bun` | 178 MB | 192 MB |
| payload 内容 | 2,479 个 `// @bun @bytecode` chunk | 2,872 个 `// @bun @bytecode` chunk（linux-x64 2,859 个） |

结论：

- **应用还没用 AOT 编译**。payload 仍是 `$bunfs/root/chunk-*.js` 加 bytecode，也就是 `bun build --compile --bytecode --splitting` 的产物，运行时走 JIT。AOT 产物应该是机器码镜像，不带 JS 源码和 chunk。
- **运行时已经换成合并 AOT 之后的 Bun**。新段名和 PR #45631 描述的 `--trim` 分组、AOT 镜像对得上，AOT 相关的命令行字符串也在。两个版本串的 commit 在 oven-sh/bun 上查不到，大概是内部构建，版本号仍写 1.4.4。
- **体积代价已经落地**。运行时代码 +29 MB，和 PR 说的"bun 本体约 +30 MB"吻合；加上 payload 多出的 14 MB，二进制净增 48 MB（+18%），方向和 PR 里"AOT 版 Claude Code 小 37 MB"相反。也就是只换运行时、不开 AOT，就是先付体积、拿不到内存和 CPU 收益。这就是下文 qodercli 风险 11 的实例。
- 下一个值得查的点：Bun v1.5 发布后的 Claude Code 版本。判断方法同上：看 payload 里还有没有 `// @bun @bytecode` chunk。
- 11/10 复查 2.1.322（11/10 发布的 `latest`，`stable` 仍是 2.1.311）：Bun 版本串还是 `1.4.4+424a542a9`，`__text` 108.8 MB 不变，payload 196 MB，2,919 个 `// @bun @bytecode` chunk，二进制 324 MB。结论不变，仍未用 AOT，运行时也没换成重写版。[^68]

## 社区讨论

**评论区集中在问这几件事**

- 2～3 倍省内存是指启动、峰值 RSS 还是长时间稳态？Claude Code 一跑几个小时，还挂着子 agent，大头可能是会话堆，AOT 未必能压下去。[^14][^15][^16]
- 用户在等权限确认时 session 空闲，这个时段能省多少？[^17]
- AOT 放弃了 JIT 的什么？有没有变慢的负载？[^18]（PR 已回答：Koa/Next/zod 场景会慢）
- `eval`、动态 `import()`、source map、native module 怎么处理？[^19][^20]
- 锁定内置对象会伤到多少 polyfill（core-js 之类）？报错时能不能指出是哪个包干的？[^21][^22]
- Meteor 2013 年那篇闭包作用域泄漏的文章被翻出来，有人认为 thin closure 对长会话最有意义。[^23]

**专业意见**

- Filip Pizlo（JSC JIT 的主要作者之一）问"untyped JS 能否接近 JIT 性能有多重要""产物里留不留解释器"，最后说"你的路子和我会选的很不一样，期待你成功"。[^24]
- Emil Laine（做过 ts-llvm）：如果要支持全部 TS/JS 特性和现有库，AOT TS 很难比非 AOT 快。[^25]
- Jarred 的回应：应该在 `eval`/`new Function` 时回退解释器，检测到不可达就把解释器和依赖从二进制剥掉，并给用户显式删除的选项。[^26]

**同类项目对比**

- Malte Ubl（Vercel）的 **scriptc**：他自己测比 `bun --aot` 快 1.6 倍，但马上说这个 benchmark 就是 scriptc 优化时用的，别信。[^27] 他认为纯 AOT 有两件事做不到：`eval` 和计算路径的 `require`；主张干脆把 `eval` 从 JS/TS 里拿掉，因为在 AI 时代 RCE 太危险，并估计 `bun --aot` 为支持 eval 要多带 100 MB 左右依赖。[^28]
- amlug.eth 的长串把 Bun AOT 和 Perry 等原生 TS 项目做了对比：Bun 是自上而下，保留 JSC 只去掉 JIT，完整 JS 语义，代价是带一整个引擎；Perry 要么全编译，要么不运行，没有退路。[^29]
- Evan You 发了一句："把 TS 编成原生很酷，但如果普通 TS 本身就能和原生一样快呢？"[^30]

**情绪**

整体非常热，主流叙事是"Bun 自己改写成 Rust，好让其他人不用改写成 Rust"。反对意见主要是"还是有 GC""JS 单线程，CPU 密集型后端不行"。也有人调侃 4 次尝试是因为"只有 Fable 5.5 做得出来"。[^31]

**合并后的反馈（10/27～10/29）**

- 在 Jarred 时间线里能看到的公开试用反馈只有 steipete 一条："性能提升 2～3 倍，内存不到一半"，但没说测的是什么程序、怎么测。[^47]
- 合并推文下的问题集中在：Windows 是否已可用（有人说为 Windows 上跑 aot 和 trim 提了两个修复 PR）、产物最低 glibc 版本、`eval` 和动态 import 还能不能用、合并版本有没有 `--compile` 对比 AOT 的数据，以及 232 万行的 diff 谁来 review。截至抓取时 Jarred 没在这些回复里作答。[^44]
- 测试介绍视频的回复主要嫌剪辑太快看不清，内容上的追问是冷启动能快多少、哪类失败抓到的 bug 最多。[^48]

**10/30～11/04**

- 试用反馈多了几条，都是一句话、没有数据：有人说在内部 CLI 上试了 AOT"已经有可观的提升"，请求给一个示例仓库；nisten 说 canary 上 `bun build --compile --aot --trim` 是"最高效的"，但"长期不太信任 Anthropic 管 bun"。[^54][^56]
- 编译速度那条推文下，大家关心的是增量编译和 watch 模式：JS 开发者比较的对象是 esbuild/Vite 的增量重建，而不是一次冷编译；也有人提议只对部分代码做 AOT、其余走 JIT。[^55]
- 怀疑声音：有人问 AOT 是否真有必要、Bun 加 WebKit 靠 AI 怎么维护；amlug.eth（做 Perry）继续强调 `bun build --compile` 带着整个运行时，不算原生代码，体积、启动、内存敏感的场景还是他们那类全原生方案更合适。也有人第一次看到 Bun AOT，第一反应是"不能交叉编译"。[^56]

**11/05～11/10**

- 有人说 Bun AOT 是在劝人别用 JS，Jarred 回"你搞反了"，目标是让把 JS/TS 应用重写成别的语言不再划算，在内存和 CPU 上和 Go、Rust 竞争。[^67]
- OpenCode / OpenClaw 那条下面，大家最看重"20 轮峰值内存"：有人算 −41% 等于一台机器多跑约 1.7 倍的 agent。Filip Pizlo 回了一句"Incredible!"。也有人反问"这些东西一开始就要 1 GB 内存，没人在意吗"。[^64]
- "又重写一遍"那条下面，有人问函数摘要能不能按文件缓存来做增量构建，Jarred 没回；更多是调侃"rewrote it again 是最 Bun 的一句话"。[^63]
- 新语法那条下，有人问为什么不干脆叫一门新语言，Jarred 说和 clang、GCC 不把 C/C++ 扩展叫新语言是一个道理，那样更难推广。[^67]

**Reddit**

没有直接讨论 Bun AOT 的帖子（搜 "bun aot" 基本只有 Attack on Titan 的结果）。相关的只有 r/typescript 7 月的 scriptc 帖：有人让 agent 跑了 12 小时，试图用 scriptc 编译 TS6，最后放弃，编译出的 QR 码库比 Node 慢 21 倍；还有人提到 zod-compiler 和 Typia 这类构建期编译校验器的思路。[^32]

## 我的判断

1. **对 Claude Code 用户最直接**：首个 prompt 可用时间不到一半，私有内存降到 1/4，可执行文件还小了 37 MB，同时开多个 session 时最能感受到。前提是官方真的切换过去：PR 10/27 已合并，但还只在 canary 里，Jarred 说的是合并后"开始测"，截至 11/10 没看到 Claude Code 正式切换的消息；Jarred 10/29 的说法是合并了但还不能发布，11/04 改口说 v1.5 会带上，11/06 拍完了发布视频。[^44][^57][^65] v1.5 会带重写版编译器（旧的已从 main 删掉），PR 里的 Claude Code、服务端数据都是旧编译器测的；Jarred 说重写版在 Claude Code 上"基本一样"，但没贴新数。[^63] 11/05 和 11/10 两次实测 Claude Code（2.1.318、2.1.322）：应用仍是 JIT + bytecode，只是运行时换成了带 AOT 编译器的 Bun，二进制反而大了约 50 MB。[^61][^68] 他 10/31 也说大型应用和 Claude Code 这类 CLI 比 HTTP 服务收益更大，这和 qodercli 的情况一致。[^54]
2. **"It's just TypeScript" 是关键转折**。第 3 版要求 `as` 改变运行时语义，等于造了一门长得像 TS 的新语言；第 4 版改成类型只当预测、失败就回退，现有代码不用改就能编。剩下的真正破坏性变更是锁定内置对象、类型错误阻断构建，以及默认不能从磁盘加载代码。
3. **还不是通用的加速开关，但服务端比之前看起来好**。新数据里服务端第 1 秒全部更快、内存和 p99 全面更好；预热后有类型的服务持平，无类型框架输 7%～23%，而不是旧版说的 26%～53%。1,814 个惯用写法里，模拟大程序时三分之二落后于 warm JIT，说明不靠类型的通用代码仍是短板。构建仍要几十秒、几 GB 内存且没有增量缓存。平台方面只有 Linux x64 glibc 完全通过，macOS 仍有失败测试，Windows 失败很多。
4. **生态是下一阶段的关键**：Full types 想让 npm 包把带类型的实现一起发出来，这决定了 Express/Fastify 这类依赖重的应用能不能吃到收益。这需要库作者配合，短期内不会普及。
5. **值得关注的副作用**：类型第一次在运行时产生实际收益，`any` 从此会体现在 benchmark 上；无 JIT 的可执行内存和 MDWE 是实打实的安全收益。`JSON.parse<T>()` / `validate<T>()` 和 `int32` 已写进 PR 描述和文档，已随 PR 合并进 main，但还没进正式版，文档也标着 experimental；`Bun.isAOT` 在 main 上仍不存在。[^36][^37][^39]

## 对 qodercli 意味着什么（10/26 分析）

qodercli 和 Claude Code 的形态几乎一样：TS 写的 Ink/React TUI、MCP、作为 `bun build --compile` 单文件分发（Bun 1.4.x）。所以 PR 里的 Claude Code 数据是最接近的参照，但不能直接照搬。10/29 按合并后的官方文档修订了风险 1、6、7、9、10 和建议，新增风险 11；PR 已合并，canary 可以直接本地试。下面的"预期"都是推断，没有在 qodercli 上实测。

**现状基线**（darwin-arm64，hyperfine `--version`）：

| 项 | 数值 |
|---|---|
| 启动 | 约 126 ms（已开 bytecode + splitting；不开 bytecode 时约 390 ms） |
| 二进制 | 约 154 MB（bytecode 带来约 +50 MB） |
| 峰值 RSS（仅 `--version`） | 约 200 MB |
| 发布矩阵 | 10 个 target（macOS / Linux glibc 与 musl / Windows / HarmonyOS），用 `--target` 交叉编译 |

### 能拿到的收益

| 收益 | 预期 | 依据和不确定性 |
|---|---|---|
| **内存** | 最大的一项。私有内存可能降到 1/3～1/4；按长会话峰值算，更保守的估计是 −40% 左右 | Claude Code 185→45 MB。11/10 补充：opencode 20 轮峰值 712→421 MB（−41%），这是同类 agent CLI、多轮会话的数，比 Claude Code 的 5 轮数据更像 qodercli 的真实负载。[^64]qodercli 跑 `--version` 就有约 200 MB RSS，说明大头是加载的代码和 bytecode，正是 AOT 去掉的部分。机器码是 file-backed 页、进程间共享，同时开多个 session 和后台进程时收益叠加 |
| **CPU** | 会话 CPU 可能降到约 1/3，省电、风扇安静 | Claude Code 1,542→512 ms，但那是 5 轮短会话，JIT 还没热。长会话里 React 渲染这类无类型代码可能反而输给 warm JIT（见下面风险 5） |
| **启动** | 有收益，但比 Claude Code 小 | opencode 首帧 0.65→0.46 s（11/10 补充）。qodercli 已经用 bytecode 把启动压到约 126 ms。Claude Code 318→141 ms 的基线是否带 bytecode 不清楚。AOT 省掉的是解释执行和运行时编译，估计还能快一些，但很可能到不了 2 倍 |
| **二进制体积** | 可能变小，可以去掉 bytecode 那约 50 MB | Claude Code 小 37 MB；`--trim` 能再删没用到的 API。但嵌入的 native 模块和 wasm 体积不变 |
| **macOS 签名更干净** | 可以去掉 `allow-jit` 和 `allow-unsigned-executable-memory` 两个 entitlement | 这两项现在是为 JIT 开的。AOT 没有 JIT，hardened runtime 可以收紧；Linux 6.7+ 还有 MDWE |
| **源码保护** | 产物里没有源码文本，只有机器码镜像 | 现在二进制里是 bytecode，AOT 镜像比 bytecode 更难还原。这是推断，PR 没把它当卖点 |

### 阻碍和风险（按严重程度）

1. **不支持交叉编译，这是最大的阻碍。** PR 明确说只能为当前平台出码，合并后的文档也写明 `--target` 指向其他平台时要么去那个平台构建，要么加 `--no-aot`。qodercli 现在靠 `--target` 在少量 runner 上产出 10 个 target。改用 AOT 就要每个 target 一台原生 runner，darwin-x64、windows-arm64、linux-arm64-musl 都要单独准备。
2. **HarmonyOS 基本无解。** OHOS 构建用的是第三方提供的 Bun canary 运行时，连 bytecode 和 splitting 都关着。AOT 需要编译器和引擎同一版本，短期只能让 OHOS 留在 JIT 路径。
3. **平台成熟度和正确性。** 只有 Linux x64 glibc 全部通过；macOS arm64/x64 还有失败测试，Windows 失败很多。qodercli 的主力用户大概率在 macOS 和 Windows。11/04 补充：main 上还有 50 多个已知错误编译（静默给错结果的那种），下一批修复 #47605 没人在 macOS/Windows 本地构建过。canary 只适合摸底和 A/B，不能拿来出发布包。[^51]
4. **类型错误会阻断构建。** 好消息是仓库已经用 TypeScript 7，和 AOT 背后的检查器同代。但目前全仓 typecheck 还不是零错误（看起来多数是工作区之间的声明过期，还没确认）。AOT 从源码整体检查，可达图里任何一个真错误都会让发布失败。11/10 补充：重写版只在 `tsc` 按项目自己的 `tsconfig.json` 也会报错的地方中断构建，JS、`node_modules`、`.d.ts` 不检查，所以工作区声明过期这类问题要看是不是 `tsc` 也报；但"`bun check` 不报、构建却报"的已知问题还在。[^62]
5. **React/Ink 渲染是无类型 npm 代码。** PR 的 1,814 个写法测试里，模拟大程序时三分之二落后于 warm JIT。qodercli 长会话、流式输出时的每帧渲染 CPU 有可能比现在高。评估时应该把渲染基准当主要指标，而不是只看 `--version`。
6. **运行时生成代码会退回解释器，程序也失去"封闭世界"优化**（文档给的绕法：zod 4 在建 schema 前调 `z.config({ jitless: true })`；ajv 可以换成构建期生成好的 standalone 校验器）[^42]：
   - 启动路径上有一处 `new Function` 执行内置脚本，可以改成直接 import 一个函数，很好改；
   - 工具参数校验用 ajv 8，ajv 编译 schema 用的就是 `new Function`。频率不高，变慢可以接受，但只要它在，整个程序就不是封闭世界；
   - 部分依赖带着 zod 4，同样会在运行时生成代码；
   - 有一处用源码字符串起 `new Worker`，这段会被解释执行。
7. **wasm 可能被解释执行。** PR 说只有程序 import 的 `.wasm` 文件才编译，其他解释执行；文档补充说，下载、从字符串解码或自己拼出来的字节都会解释执行，紧循环会比 `bun run` 慢很多。内联字节加载的 wasm，以及用 web-tree-sitter 解析 shell 命令，都可能落到解释器。tree-sitter 每次检查命令都会跑，要单独测。11/10 补充：这条在变好。WebKit#1025（未合并）让以 base64 或 hex 写进源码的 wasm 在构建时编译，不管用哪个函数解码，也把 wasm 加回优化层；Jarred 说这让 OpenCode 的 CPU 再少 13%。[^64][^66]
8. **从磁盘加载的外部包。** 几个 native 相关的包（如 keytar、剪贴板）现在作为 external 从磁盘加载，AOT 默认不能从磁盘加载代码，需要逐个 `--external`；全局 `--aot-allow-code-from-disk` 会拖慢整体。
9. **构建和调试。** 代码量很大，AOT 每个 target 要几十秒、几 GB 内存，而且没有增量缓存。AOT 产物里断点不能用。（11/05 补充：重写版把 TS 编译器的构建指令数降到约 1/10。11/10 补充：已于 11/07 合并，产物在那个基准上慢 16%，Jarred 说 Claude Code 上基本持平。[^58][^63]）崩溃上报方面，文档说栈帧带源码的文件、行、列（路径形如 `/$bunfs/root/src/foo.ts:3:27`），不需要 source map；`--minify` 时可以用 `--sourcemap=external` 把名字和位置放到外部 map 文件。要注意的是 `error.message` 的措辞会变（如 `evaluating 'o.a.c'` 变成 `evaluating 'null.c'`），按 message 聚合的上报（Sentry 之类）会出现新分组。[^42]
10. **构建链路要改，但比预想的小。** 现在走 `Bun.build({ compile, bytecode, splitting, plugins })` 的 JS API，还依赖 `with { type: 'file' }` 嵌入和 `/$bunfs/` 路径。合并后的文档确认：`Bun.build` 支持 `compile: { aot: true }`，另有 `aotLogTypeMismatches`、`aotExplain`；`Bun.build` 插件在 AOT 下照常参与加载；`with { type: 'file' }` 仍可用，但 AOT 下额外入口一律当代码编译，图片、`.wasm`、`.node` 这类资源要改用 `--asset`。AOT 下不打包、产物里也没有 bytecode，所以 `splitting` 和 `bytecode` 选项大概率要去掉（推断，文档没直接写）。另外 AOT 不经过 `node:module` 的加载钩子，依赖 `require-in-the-middle` 一类的自动埋点（如 OpenTelemetry）看不到任何模块。[^42]
11. **不用 AOT 也要付体积。** 编译器就在 bun 里，PR 说 bun 本体大约 +30 MB（musl 约 +23 MB），普通 `bun build --compile` 产物是 bun 的拷贝，所以 qodercli 只要升级到带 AOT 的 Bun 版本，现有 10 个 target 的 JIT 二进制每个都会变大约 30 MB，在现在约 154 MB 的基础上大约 +20%（按 PR 数字推算，没实测）。Jarred 已经把 bun 体积当成问题，在考虑按需下载编译器，升级前值得看看正式版是怎么处理的。[^11][^45] 11/05 补充：Claude Code 2.1.318 已经是这个情况，运行时代码 79.5 → 108.8 MB，整个二进制 271 → 320 MB，应用本身还没用 AOT。[^61]

    另外，AOT 默认不从磁盘加载代码，靠 `BUN_OPTIONS="--preload=…"` 往编译产物里注入脚本的做法（比如给 Claude Code 挂 fetch 拦截的 hook）切到 AOT 后大概率失效，没实测。

```mermaid
flowchart TD
  A["PR #45631 合并（10/27 已完成）<br/>先用 canary 试，上线等正式版"] --> B["本地 darwin-arm64：bun check --aot<br/>修类型错误、清点 new Function / 外部包 / 内置对象修改"]
  B --> C{"能编过吗？"}
  C -->|"否"| B
  C -->|"是"| D["同机 A/B：JIT+bytecode vs --aot<br/>启动、峰值私有内存、渲染基准、<br/>长会话 CPU、wasm 耗时"]
  D --> E{"内存、CPU 明显好，<br/>渲染没退步？"}
  E -->|"否"| F["保持现状，等 Full types<br/>和平台成熟"]
  E -->|"是"| G["先在原生 runner 上出<br/>darwin-arm64 / linux-x64 的 AOT 灰度包"]
  G --> H["其余 target 和 OHOS<br/>继续走 JIT + bytecode"]
```

**建议**：值得做，但现在只做准备，不动发布。可以先做这几件零风险、对现状也有好处的事：把启动路径上的 `new Function` 改成直接调用；把全仓 typecheck 修到零错误；给渲染和长会话内存补一个可重复的基准，以后 A/B 时有现成的对照。PR 已经合并，canary 可用，现在就能在 darwin-arm64 上用 `bun check --aot` 摸底，并做一次同机 A/B（`bun compile` 对比 `bun compile --no-aot`）；真正发布要等 AOT 进正式版、macOS 的测试通过。（11/05：正式版就是 v1.5，Jarred 11/06 拍发布视频；v1.5 出来后先用它重做一次 A/B，别沿用 canary 的结果，因为编译器中段可能已经换了。[^57][^58]）（11/10：中段确实已经换了，11/07 之前的 canary 结果作废。opencode 的数据说明同类 agent CLI 不改代码就能编过、长会话峰值内存降约四成，这让 A/B 更值得做。现在的 canary 就是重写版，可以先在 darwin-arm64 上跑；但 main 每天还在大改，结论要以 v1.5 正式版为准。[^62][^64]）真正决定能不能上的，是内存和渲染 CPU 的实测数据，以及发布矩阵能不能接受按平台原生构建。

## 参考链接

[^1]: Jarred：下周合并 Bun AOT（书签）https://x.com/jarredsumner/status/2113633043483443463
[^2]: 第 4 次尝试，It's just TypeScript https://x.com/jarredsumner/status/2112859865974792451 ；锁定 Object.prototype 的说明 https://x.com/jarredsumner/status/2112866610516279564 ；为何改主意 https://x.com/jarredsumner/status/2112867012867502556
[^3]: 为什么同样的代码更省内存 https://x.com/jarredsumner/status/2113641821226299719
[^4]: 闭包作用域泄漏在 AOT 下不存在 https://x.com/jarredsumner/status/2113643169510551576
[^5]: 仍基于 JSC https://x.com/jarredsumner/status/2113637230870937773
[^6]: 9/29 首次预览串 https://x.com/jarredsumner/status/2104739495895781679 ；实现方式 https://x.com/jarredsumner/status/2104754521121653039
[^7]: 10/4 更多数字 https://x.com/jarredsumner/status/2106719577275302344 ；typed 部分还很粗糙 https://x.com/jarredsumner/status/2106720931754504480
[^8]: TS6 AOT 对比 TS7 https://x.com/jarredsumner/status/2108847656424583307
[^9]: 需要 .ts 源码而非 .d.ts https://x.com/jarredsumner/status/2108852056513810667
[^10]: 10/16 工作原理串 https://x.com/jarredsumner/status/2111024425386877437
[^11]: GitHub PR #45631：Compile TypeScript to machine code ahead of time https://github.com/oven-sh/bun/pull/45631 （引擎侧 oven-sh/WebKit#757：https://github.com/oven-sh/WebKit/pull/757 ）。本文按 10/26 读取的 PR 描述（10/24 重写版）更新。
[^12]: 第 3 次尝试与反思 https://x.com/jarredsumner/status/2112134334035681641 ；问题清单 https://x.com/jarredsumner/status/2112134336581624230
[^13]: 校验库集成 https://x.com/jarredsumner/status/2111179306127040747
[^14]: 测启动还是长会话峰值 https://x.com/NeuralAlphaAI/status/2113638659740385487
[^15]: 稳态还是峰值 RSS https://x.com/iamRushabhSheth/status/2113651193826197565
[^16]: 长会话 + 子 agent https://x.com/BitsandMettle/status/2113665402337378534
[^17]: 空闲等待场景 https://x.com/unwindstack/status/2113665156676739424
[^18]: AOT 放弃了什么 https://x.com/dhillonpost/status/2113646769708126643
[^19]: 动态 import https://x.com/proxy_vector/status/2113646019091234852
[^20]: source map https://x.com/proxy_vector/status/2112876436688449762
[^21]: 冻结原型影响多少库 https://x.com/Atlantisxd/status/2111039972329574582
[^22]: 报错能否指出包名 https://x.com/AxleMode/status/2112879324768440807
[^23]: thin closure 与 Meteor 2013 文章 https://x.com/semicolonwitch/status/2113649494667800721
[^24]: Filip Pizlo 的提问 https://x.com/filpizlo/status/2112209799974903835 ；https://x.com/filpizlo/status/2112276843349053802 ；https://x.com/filpizlo/status/2112389907788481016
[^25]: Emil Laine（ts-llvm）https://x.com/flogram_dev/status/2112160160248373351
[^26]: Jarred 关于解释器回退 https://x.com/jarredsumner/status/2112387607468659014
[^27]: Malte Ubl：scriptc vs bun --aot https://x.com/cramforce/status/2111575159501205822
[^28]: Malte Ubl：eval 与生态兼容 https://x.com/cramforce/status/2112177848425255044
[^29]: amlug.eth：Bun AOT vs Perry https://x.com/realamlug/status/2109148948602425582
[^30]: Evan You 的引用推 https://x.com/infinterenders/status/2112555932723134909
[^31]: "4th attempt" 调侃 https://x.com/grantjordan/status/2113638722885279969 ；"还是有 GC" https://x.com/humanHologram/status/2113634438479323448 ；单线程问题 https://x.com/Uwu123231634/status/2113661426061672479
[^32]: r/typescript：vercel-labs/scriptc https://www.reddit.com/r/typescript/comments/1v7nn20/vercellabsscriptc_typescripttonative_compiler/

[^33]: 10/24 AOT 版 Claude Code 连续使用约 4 小时，Activity Monitor 显示 267 MB（67 个活跃 subagent、66 个 shell、remote control 和较长会话记录）；没有对照组或峰值/采样口径 https://x.com/jarredsumner/status/2113933905300742383
[^34]: 10/24 `new Function` 在 AOT 下偏慢，考虑 `Bun.isAOT` https://x.com/jarredsumner/status/2113929078348915087
[^35]: Jarred 列出的受影响库及“不是灾难性变慢”的限定 https://x.com/jarredsumner/status/2113929082438385866
[^36]: 10/25 schema 校验库的 profile 观察与编译器集成设想 https://x.com/jarredsumner/status/2114311565432517068 ；补充说指令数和 RPS 主要输在校验库 https://x.com/jarredsumner/status/2114315583911256391
[^37]: 10/25 关于 `JSON.parse` 接受 TypeScript 类型并校验输入的提问 https://x.com/jarredsumner/status/2114102702468923773
[^38]: PR #45631 状态与 commit 列表（10/26 12:14 UTC 查看：open、非 draft、未合并、306 commits、CI 3 项失败）https://github.com/oven-sh/bun/pull/45631/commits
[^39]: aphrody-labs 的非官方预览构建（PR commit `5b598476c`，10/25 发布，含 Linux/Windows 数据与 `Bun.isAOT` 未定义的说明）https://github.com/aphrody-labs/bun/releases/tag/bun-aot-pr45631-5b598476cda
[^40]: PR #45631 合并信息（10/27 23:50:41 UTC 由 Jarred-Sumner 合并，merge commit `8d5672c5529049f1a9a3453d07e6cd6a1564abc7`，347 commits，+2,321,195 / −25,784，18,974 files）https://github.com/oven-sh/bun/pull/45631 ；https://github.com/oven-sh/bun/commit/8d5672c5529049f1a9a3453d07e6cd6a1564abc7
[^41]: Bun releases（10/29 查看：最新稳定版 v1.4.4，10/22；canary 对应 main `da867c60b`）https://github.com/oven-sh/bun/releases
[^42]: 合并后的官方文档 `docs/compiler/`：aot.mdx（`bun compile`、`--no-aot`、`Bun.build` 的 `aot` 选项）、compatibility.mdx（交叉编译、错误信息、加载钩子、wasm、zod/ajv 绕法）、debugging.mdx（栈帧与 source map）、libraries.mdx（不兼容的包）、executables.mdx（`--asset`）https://github.com/oven-sh/bun/tree/main/docs/compiler
[^43]: 后续 PR #47129：AOT: fixes for modules, classes and Workers, WebKit upgrade, shorter compiler docs（10/29 合并）https://github.com/oven-sh/bun/pull/47129 ；合并后 robobun 在 #45631 下关于 flaky 测试和 macOS 队列的评论 https://github.com/oven-sh/bun/pull/45631
[^44]: Jarred 10/29"Bun AOT is merged. Still more to fix/fuzz before its release-able" https://x.com/jarredsumner/status/2115677436574826641 ；同日"designed to run existing Bun & Node apps without code changes … eventually make AOT the default for server-side JS" https://x.com/jarredsumner/status/2115719048143249807
[^45]: Jarred 10/29"why tf is bun 138 MB now that's insane" https://x.com/jarredsumner/status/2115677807951159503 ；懒下载编译器的设想 https://x.com/jarredsumner/status/2115677981129752720
[^46]: Jarred 10/26 `--trim`：Bun.serve 二进制 89 MB → 25 MB https://x.com/jarredsumner/status/2114835395271901667 ；为何仍有 25 MB https://x.com/jarredsumner/status/2114835397528420493 ；安全收益 https://x.com/jarredsumner/status/2114835399650803824 ；也可用于原生库和 CLI 子命令 https://x.com/jarredsumner/status/2114835401424900200 ；不开 AOT 时 JIT 约 20 MB https://x.com/jarredsumner/status/2114836705715134672
[^47]: steipete 10/27 试用反馈 https://x.com/steipete/status/2114879798434758905 （Jarred 转推 https://x.com/jarredsumner/status/2114885734108995895 ）
[^48]: Jarred 10/27"how we're testing Bun AOT"视频 https://x.com/jarredsumner/status/2114930223024361680
[^49]: Bun releases（11/04 查看：最新稳定版仍是 v1.4.4，10/22）https://github.com/oven-sh/bun/releases
[^50]: PR #47316：AOT: bun test --aot on large suites, module loading fixes, fuzzer fixes（10/31 19:15 UTC 合并，+908,007 / −449,388，9,195 files）https://github.com/oven-sh/bun/pull/47316
[^51]: PR #47605：AOT: hangs, wrong answers, failed builds; `bun test --aot` follows #44833's mocks（11/01 开，11/05 查看仍 open，75 commits，最新推送 `22621ef9`，描述已改写，标注"Not for merging yet"并列出相对 main 的回归）https://github.com/oven-sh/bun/pull/47605
[^52]: PR #47571（已关闭，并入 #47605）描述中关于 main 上 `test/aot` 39 个失败测试的说明 https://github.com/oven-sh/bun/pull/47571 ；#44833 bun test: Vitest compatibility https://github.com/oven-sh/bun/pull/44833
[^53]: `docs/compiler/libraries.mdx`"Publish a package with its types"（11/04 查看）https://github.com/oven-sh/bun/blob/main/docs/compiler/libraries.mdx
[^54]: Jarred 10/31 Express + SQLite https://x.com/jarredsumner/status/2116679973448945762 ；Hono https://x.com/jarredsumner/status/2116679979950084304 ；Fastify https://x.com/jarredsumner/status/2116679986266660883 ；"large apps and CLIs like Claude Code will benefit more" https://x.com/jarredsumner/status/2116679989156606411 ；内部 CLI 试用回复 https://x.com/AlyahmedAli/status/2116904561961013364
[^55]: Jarred 11/02 编译速度表"I kind of think this is still too slow?" https://x.com/jarredsumner/status/2117088787025346666 ；`bun check` 没有缓存 https://x.com/jarredsumner/status/2117119801898451293 ；增量与 watch 的追问 https://x.com/sreecharantwts/status/2117100135792644500
[^56]: nisten https://x.com/nisten/status/2117443951841988857 ；"was bun AoT really necessary" https://x.com/exvillager/status/2117678331084919149 ；amlug.eth https://x.com/realamlug/status/2117909011341205599 ；"no cross-compiling though" https://x.com/retropragma/status/2117761233558311383
[^57]: Jarred 11/04 22:39 UTC"Filming Bun v1.5 video on Friday. Bun v1.5 will include the ahead of time compiler" https://x.com/jarredsumner/status/2118110874108105064 ；回复中的提问：二进制大小 https://x.com/iharsh02/status/2118208106392096991 ，是否走 `bun build --compile` https://x.com/threadlinesdev/status/2118180708644790646 ，冷启动和体积对比 https://x.com/i_mika_el/status/2118112017810960583 ，动态 import 与 native module https://x.com/itsmeandresito/status/2118150816368329134 ，崩溃指回 TS 源码 https://x.com/jatingargiitk/status/2118194761895157935 ；Bun releases（11/05 查看：最新稳定版仍是 v1.4.4）https://github.com/oven-sh/bun/releases
[^58]: oven-sh/WebKit#997：AOT: replace the flow passes and the B3 back end with a scan, a link and one walk（11/04 19:41 UTC 开，11/05 查看仍 open，+467,079 / −965,981）https://github.com/oven-sh/WebKit/pull/997 ；Bun 侧 PR #47942：AOT: front end, test runs and tests for the rewritten compiler（11/04 19:44 UTC 开，17 commits，+422,560 / −1,758,851，30,914 files）https://github.com/oven-sh/bun/pull/47942
[^59]: issue #47955（11/05）https://github.com/oven-sh/bun/issues/47955 ；PR #47957：bun compile: add --aot-allow-executable-memory（robobun，11/05 开）https://github.com/oven-sh/bun/pull/47957
[^60]: Jarred 11/01"Elysia is currently slower in AOT" https://x.com/jarredsumner/status/2116692754243936742 ；11/02"caching is cope for a slow design"（回复"Incremental compilation next?"）https://x.com/jarredsumner/status/2117111115813732818
[^61]: 11/05 本地检查：`npm pack @anthropic-ai/claude-code-darwin-arm64@2.1.318` 与 `@anthropic-ai/claude-code-linux-x64@2.1.318`（npm dist-tags：latest 2.1.318，stable 2.1.311），对比本机 2.1.304；`size -m` / `otool -l` 看段，导出 `__BUN,__bun` 统计 `// @bun @bytecode` 头和 `$bunfs/root/` 路径，`grep` 运行时里的 AOT 字符串。包页面 https://www.npmjs.com/package/@anthropic-ai/claude-code
[^62]: oven-sh/WebKit#997 于 2026-11-07 05:53 UTC 合并（`42067fce`）；oven-sh/bun#47942 于 11/07 21:21 UTC 由 Jarred-Sumner 合并（merge commit `2596ac5d`，56 commits，+532,291 / −1,761,476，35,875 files，描述含类型错误规则和"不加 `--aot` 时的行为变化"清单）https://github.com/oven-sh/bun/pull/47942 ；#47605 和 #47957 于 11/07 关闭的说明 https://github.com/oven-sh/bun/pull/47605 https://github.com/oven-sh/bun/pull/47957 ；#48120"AOT: the next base"（11/10 00:48 UTC 合并，+430,357 / −34,194，31,061 files）https://github.com/oven-sh/bun/pull/48120 ；引擎侧 WebKit#1001（11/07）、#1008（11/09）、#1021（11/09）均已合并 https://github.com/oven-sh/WebKit/pull/1021
[^63]: Jarred 11/09"rewrote AOT again and it compiles this benchmark 4x faster now" https://x.com/jarredsumner/status/2119721266961871275 ；"like 250,000 fewer LOC" https://x.com/jarredsumner/status/2119721762581881183 ；主要改动（ThinLTO 式函数摘要、直接用 macroassembler）https://x.com/jarredsumner/status/2119722888421106020 ；运行时性能"basically the same"、旧编译器的相同代码折叠 https://x.com/jarredsumner/status/2119726730604925165 ；担心回滚的四天 https://x.com/jarredsumner/status/2119737831031767235
[^64]: Jarred 11/09"OpenCode uses 41% less memory with Bun AoT and OpenClaw starts 3x faster"（图的 alt 文字含全部数值和测试条件）https://x.com/jarredsumner/status/2119878869092380859 ；OpenClaw 输入是无类型 JS https://x.com/jarredsumner/status/2119878943541232044 ；11/10 WebAssembly 改进让 OpenCode CPU 再少 13% https://x.com/jarredsumner/status/2119954306585743486 ；回复：两个数来自不同程序 https://x.com/dwkim601/status/2119906120794001761 ，约 1.7 倍 agent 密度 https://x.com/marchoeffl/status/2119895111559782500 ，Filip Pizlo https://x.com/filpizlo/status/2119880529424396486 ，"over a gigabyte" https://x.com/DarioGieselaar/status/2119942039999492287
[^65]: Jarred 11/07"we filmed the bun v1.5 video today" https://x.com/jarredsumner/status/2118866301351510307 ；催发布的回复 https://x.com/cognitivebrain2/status/2119937042725445845 ；Bun releases（11/10 查看：最新稳定版仍是 v1.4.4）https://github.com/oven-sh/bun/releases
[^66]: oven-sh/bun#48436：AOT: bun compile, build output, module mocks, fixes and new names（11/10 开，未合并）https://github.com/oven-sh/bun/pull/48436 ；oven-sh/WebKit#1025：AOT: WebAssembly in the optimizing tier, arm64 branch islands, fixes and new names（11/10 开）https://github.com/oven-sh/WebKit/pull/1025
[^67]: Jarred 11/09"remaining wins in the current design is < 10%" https://x.com/jarredsumner/status/2119741818451775769 ；11/10"will likely need new syntax" https://x.com/jarredsumner/status/2119963635367997471 ；不叫新语言的理由 https://x.com/jarredsumner/status/2120036460023992659 ；11/06 回复"You have it backwards" https://x.com/jarredsumner/status/2118466743559696442
[^68]: 11/10 本地检查：`npm pack @anthropic-ai/claude-code-darwin-arm64@2.1.322`（npm dist-tags：latest 2.1.322，stable 2.1.311），`size -m` 看段，统计 `// @bun @bytecode` 头；文档 `docs/compiler/compatibility.mdx`（交叉编译）和 `troubleshooting.mdx`（`PR_SET_MDWE`）11/10 查看 https://github.com/oven-sh/bun/tree/main/docs/compiler ；issue #47955 仍 open https://github.com/oven-sh/bun/issues/47955
