Bun 的 Rust 生死局：6 天、96 万行代码、AI Agent 重写整个运行时——从 Zig 到 Rust 的底层权力游戏完全解析（2026）

2026 年 5 月，一条推文震动了整个 JavaScript 社区：「Bun v1.3.14 明天发布。如果我们合并 Rust 重写版本，这将是 Zig 的最后一个版本。」四年前 Bun 因选择 Zig 而声名鹊起，四年后，创造者用一条推文终结了 Zig 版本。更令人震撼的是：这场从 Zig 到 Rust 的迁移，约花 6 天，涉及 96 万行代码，且通过了现有测试套件的 99.8%。

目录

1. 序幕：一条推文判了 Zig 版 Bun 的死刑
2. Bun 与 Zig：一段Brief但炽热的姻缘
3. 6 天时间线：从「极有可能丢掉」到「Zig 的最后一版」
4. 技术深扒：96 万行代码是如何在 6 天内完成的
5. AI Agent 主导重写：人类已不再敲代码
6. Rust 版的 Bun：性能、安全与 13,044 个 unsafe 块
7. 社区地震：yt-dlp 封禁、Electrobun 解绑
8. Zig 的处境：旗舰用户离开意味着什么
9. 深层博弈：为什么是 Rust，不是其他
10. 对 JavaScript 生态的连锁反应
11. 工程师视角的技术细节
12. 结论：开源开发的范式转移

1. 序幕：一条推文判了 Zig 版 Bun 的死刑 {#序幕}

2026 年 5 月 11 日，Bun 创始人 Jarred Sumner 在 X 上发了一条推文，短短两行字，却像一颗核弹投入了编程社区的水池：

「Bun v1.3.14 releases tomorrow. If we do merge the Rust rewrite, this would be the last version in Zig.」

翻译过来：「Bun v1.3.14 明天发布。如果我们把 Rust 重写合并进来，这将是 Zig 时代的最后一版。」

要知道，仅仅 6 天前（5 月 5 日），Jarred 还在 Hacker News 上灭火，原话是：

「This is just a branch of my own, the whole discussion is overreacting. These codes are very likely to be eventually discarded.」

「这只是我自己的分支，整个讨论都反应过度了。这些代码极有可能最终被全部丢掉。」

6 天，从「极有可能丢掉」到「下一版可能就用上」。

这种剧情反转，在开源社区里极其罕见。更罕见的是背后的技术事实：这不是一个功能 PR，不是修几个 bug，而是把整个 JavaScript 运行时从一门语言（Zig）迁移到另一门语言（Rust），涉及近百万行底层代码。

Hacker News 上这条消息在 48 小时内收获了 1200+ 点赞、302 条评论。r/programming 的相关帖子在 3 天内获得 2500+ upvotes。

而真正的震撼，在 5 月 14 日到来：PR #30412 被合并进 main，标题极其直白——「Rewrite Bun in Rust」。

2. Bun 与 Zig：一段 Brief 但炽热的姻缘 {#bun与zig}

要理解这次重写的冲击力，必须先回到 2022–2023 年，Bun 为什么选择 Zig。

2.1 Bun 的诞生与 Zig 的承诺

Bun 诞生于 2022 年左右，目标是打造一个极速的、All-in-One 的 JavaScript 运行时，涵盖：

• 运行时（替代 Node.js）
• 包管理器（替代 npm/yarn）
• 测试框架（替代 Jest）
• 打包器（替代 webpack/esbuild）

Jarred Sumner 选择 Zig 作为底层实现语言，当时有几个核心理由：

理由一：手动内存管理的完全掌控

Zig 没有隐藏的内存分配，没有垃圾回收器，没有运行时。每一字节的内存都由开发者显式管理。对于需要榨干性能的 JS 运行时来说，这种控制力是致命诱惑。

// Zig 的内存管理：完全显式
const std = @import("std");

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer std.debug.assert(!gpa.deinit());
    const allocator = gpa.allocator();

    const memory = try allocator.alloc(u8, 1024);
    defer allocator.free(memory);  // 必须手动释放
}

理由二：与 C 的无缝互操作

Zig 可以零成本调用 C 代码，也可以被 C 调用。Bun 大量依赖系统底层 API（Linux 的 epoll、macOS 的 kqueue、Windows 的 IOCP），Zig 让这些调用变得异常简单。

理由三：编译时计算（Comptime）

Zig 的 comptime 机制允许在编译期执行任意代码，生成类型专用的函数。Bun 用它来生成针对不同平台、不同架构的专用代码，而不需要 C++ 模板那种丑陋语法。

// Zig 的 comptime：编译期泛型
fn List(comptime T: type) type {
    return struct {
        items: []T,
        len: usize,

        pub fn push(self: *@This(), item: T) !void {
            // ...
        }
    };
}

const IntList = List(i32);  // 编译期生成 i32 专用的 List

理由四：没有隐藏控制流

Zig 没有隐式控制流（异常、async/await 的隐式状态机），所有控制流都显式写在代码里。这让 Bun 的异步 I/O 模型（基于 io_uring / kqueue）更容易正确实现。

2.2 Zig 的问题逐渐暴露

但随着时间的推移，Zig 的理想主义开始碰撞现实：

问题一：编译器稳定性

Zig 的编译器本身还在快速演进（2026 年尚未发布 1.0），每个版本都可能破坏现有代码。Bun 团队经常需要同步升级 Zig 编译器，然后花几周时间修 build breakage。

问题二：工具链生态不成熟

调试器、性能分析器、静态分析工具——Zig 生态里这些工具要么不存在，要么极不成熟。Bun 团队在追踪内存泄漏、use-after-free 等问题时，经常只能靠手工审查和 printf 调试。

问题三：内存安全全靠人

Zig 不提供内存安全保证。指针可以随便传，数组越界在 unsafe 版本里直接 UB（未定义行为）。Bun 作为一个处理不可信 JS 代码的运行时，内存安全问题直接导致 RCE（远程代码执行）漏洞。

根据 Bun 团队的统计，Rust 版合并后预计能直接关闭约 200 个 GitHub issues，其中大量是内存安全相关 bug。

问题四：招聘困难

会 Zig 的工程师极少。Bun 被 Anthropic 收购后，团队需要快速扩张，但市场上几乎找不到有 Zig 生产经验的开发者。Rust 虽然也难，但至少有一批活跃的开发者群体。

3. 6 天时间线：从「极有可能丢掉」到「Zig 的最后一版」 {#6天时间线}

让我们完整还原这 6 天里发生了什么。

3.1 Day 0：5 月 4 日——巨型提交出现

2026 年 5 月 4 日，网友 @LukeParkerDev 在 Bun 仓库发现了一个名为 phase-a: draft batch big-1 (12 files) 的提交。

数据：

• 一次性新增近 28,000 行 Rust 代码
• 作者：Jarred Sumner 本人
• 提交信息极其简短

这个提交出现在 Bun 的 GitHub 仓库里，但没有 PR，没有讨论，就像一个「秘密实验」突然被暴露在公众视野里。

Hacker News 上迅速跟进了 302 条评论，社区炸了。核心争议点：

1. 为什么没有公开讨论就突然重写？
2. Zig 不够好吗？
3. Rust 版的性能会退步吗？

3.2 Day 1：5 月 5 日——Jarred 在 HN 上灭火

面对社区的质疑，Jarred 在 Hacker News 上亲自回复，核心口径是：

「这只是我自己的分支，整个讨论都反应过度了。这些代码极有可能最终被全部丢掉。」

关键词：「极有可能丢掉」——这是在给社区吃定心丸，也在给自己留退路。

3.3 Day 6：5 月 11 日——口径突变

5 月 11 日，Jarred 在 X 上发了那条著名的推文。但同时，他还在同一条推文的回复里补充了更多信息：

「I have pretty high confidence in it at this point. It passes Bun's test suite on Linux x64 + arm64 glibc + musl, Windows x64 and arm64, and macOS x64 & arm64. It likely closes about 200 github issues. Still refactoring & simplifying.」

拆解这段话：

• ✅ 所有目标平台全部跑通测试（Linux x64/arm64 双 libc、Windows x64/arm64、macOS x64/arm64）
• ✅ 可能直接关闭约 200 个历史 issues（内存安全相关的 bug）
• 🔄 还在重构和简化（意思是已经能跑，剩下的是打磨）

紧接着的第二条补充更关键：

「I have yet to see a benchmark where it is slower than the Zig implementation. It is basically the same codebase. It doesn't use async rust and like the Zig implementation, uses few 3rd party libraries. It's really the same thing just with better tools for us to prevent crashes.」

这段话回答了社区的两大核心质疑：

1. 性能会不会退化？ → 没有，benchmark 跑下来 Rust 版没有比 Zig 慢的
2. 是不是被改成另一个项目了？ → 没有，结构几乎一对一翻译，没有引入 async Rust 范式，也没有拖进 Rust 生态的那堆 crate

3.4 Day 8：5 月 13 日——v1.3.14 发布，狗粮测试开始

5 月 13 日，Bun v1.3.14 正式发布（Zig 版的最后一版，如果 Rust 版被合并的话）。

当晚 19:14，Jarred 发了另一条关键推文：

「The plan for tomorrow: dogfood Bun's Rust port on Claude Code internally and start writing the blog post.」

翻译： 明天的计划：在 Claude Code 内部对 Bun 的 Rust 移植做狗粮测试，然后开始写博客。

他在评论区里答了想验证的三件事：

1. bug 在哪里
2. 内存使用模式跟 Zig 版相比有什么差别
3. 启动时间有没有变化

换言之：Claude Code 自己即将成为 Bun Rust 版的第一个真实重度用户——用自家的 Agent 跑自家的运行时。这个递归引用，充满了 2026 年 AI 编程时代的魔幻现实主义色彩。

3.5 Day 9：5 月 14 日——PR #30412 合并

2026 年 5 月 14 日，PR #30412 被正式合并进 Bun 的 main 分支。

PR 数据：

• 6,755 个 commits
• 新增 +968,342 行
• 删除 -891,456 行
• 涉及 12,403 个文件

GitHub 的 UI 在渲染这个 PR 时直接卡顿了好几秒。有人调侃：「这个 PR 把 GitHub 的服务器都干爆了。」

4. 技术深扒：96 万行代码是如何在 6 天内完成的 {#技术深扒}

这是整个事件里最令人震撼的部分：6 天，96 万行 Rust 代码。

人类手写这个量级的代码，至少需要 6 个月到 1 年（假设每天写 3000–5000 行高质量底层代码）。6 天完成，唯一的可能就是：AI Agent 主导了整个过程。

4.1 Bun 仓库里的 docs/PORTING.md

Bun 仓库里有一份名为 docs/PORTING.md 的文件，这是一份专门给编码 Agent 看的操作指引，写了约 300 条规则。

这份文档的存在，证明 Bun 团队不是临时起意用 AI 辅助，而是系统性地设计了一套让 AI Agent 理解 Zig→Rust 迁移规则的知识库。

PORTING.md 的核心结构（根据社区泄露的片段和 Theo 的报道）：

# Bun Zig → Rust Porting Guide

## Rules for AI Agents

### Rule 1: Memory Management Translation
- Zig's `allocator.alloc(T, n)` → Rust's `Vec::with_capacity(n)`
- Zig's `defer allocator.free(ptr)` → Rust's `Drop` trait
- Zig's manual `free()` → Rust's ownership system (no explicit free)

### Rule 2: Error Handling
- Zig's `!T` (error union) → Rust's `Result<T, E>`
- Zig's `try expr` → Rust's `?` operator
- Zig's `catch |err|` → Rust's `.map_err()` or `match`

### Rule 3: Comptime vs Generics
- Zig's `comptime` functions → Rust's `impl<T>` or macro
- Zig's `@TypeOf()` → Rust's `std::any::TypeId`

### Rule 4: Unsafe Equivalents
- All Zig pointer arithmetic → Rust `unsafe` blocks
- Zig's `std.mem.copy()` → Rust `std::ptr::copy()` in unsafe

### Rule 5: No Async Rust
- Do NOT use `async/await` in Rust version
- Keep the same event loop model as Zig version
- Use `mio` or raw `epoll`/`kqueue`/`IOCP` as in Zig version

4.2 两阶段迁移流程

根据 PORTING.md 和 Jarred 的推文，整个迁移分成两阶段：

Phase A：草稿生成（Draft Generation）

• 在每个 .zig 文件旁边，生成对应的 .rs 草稿
• 忠实还原逻辑，不要求能编译
• AI Agent 批量处理，并行生成

Phase B：编译通过 + 测试通过（Compilation + Testing）

• 让代码逐 crate 编译通过
• 跑过 Bun 的完整测试套件
• 性能 benchmark 对比 Zig 版

这个流程的本质是：Phase A 靠 AI 的生成能力，Phase B 靠 AI 的调试能力。

4.3 具体数字：AI 的生产力爆炸

根据 Theo（t3.gg）的报道和社区跟进，Rust 版的进度数据如下：

为什么 Rust 版行数反而少了？

因为 Rust 的标准库和类型系统能表达一些在 Zig 里需要手写的逻辑。比如：

• Zig 需要手动实现的 defer 逻辑，在 Rust 里由 Drop trait 自动处理
• Zig 需要手动检查的空指针，在 Rust 里由 Option<T> 在编译期保证

4.4 AI Agent 的具体工作流程

根据 Bun 团队成员的零星透露和 Claude Code 的使用模式，AI Agent 的工作流大致是：

# Step 1: Agent 读取 Zig 源文件
$ claude "Read src/bun.js.zig and generate a Rust draft in src/bun.js.rs"

# Step 2: Agent 处理类型翻译
# Zig: pub fn parseJS(comptime T: type, input: []const u8) !T
# Rust: pub fn parse_js<T>(input: &[u8]) -> Result<T, ParseError>

# Step 3: Agent 处理内存管理翻译
# Zig: const result = try allocator.alloc(u8, len);
#       defer allocator.free(result);
# Rust: let result = vec![0u8; len];  // 自动管理

# Step 4: 编译错误驱动迭代
$ cargo build 2>&1 | claude "Fix these compilation errors"
# Agent 根据编译错误自动修复代码

# Step 5: 测试驱动迭代
$ bun test
$ claude "These 3 tests failed, debug and fix"

5. AI Agent 主导重写：人类已不再敲代码 {#ai-agent主导重写}

Jarred Sumner 在 5 月 13 日的推文回复里，说了一句极其震撼的话：

「This is already the status quo; we haven't been typing code ourselves for many months now. Even pre-acquisition this was pretty much accurate.」

翻译： 「这早就是现状了，我们已经好几个月没自己敲过代码了。即使在（被 Anthropic）收购之前，这个描述也几乎准确。」

这句话揭示了一个很多人还没意识到的现实：顶尖开源项目的开发模式已经发生了范式转移。

5.1 「AI 写，人审」模式

传统的编程模式是：

人想 → 人写 → 人测 → 人修 bug

Bun 团队的模式是：

人想（架构 + 规则）→ AI 写 → AI 测 → 人审 → AI 修 bug

这个模式里，人类的价值集中在「想」和「审」，而不是「写」。

5.2 Claude Code 的自举（Bootstrap）

更魔幻的是：Claude Code（Anthropic 的 AI 编程工具）正在被用来重写 Bun，而 Bun 是 Claude Code 推荐用户使用的 JavaScript 运行时。

这个循环是：

1. Anthropic 收购 Bun
2. Bun 团队用 Claude Code（Anthropic 的 AI 工具）重写 Bun
3. Claude Code 官方文档推荐用 Bun 作为运行时
4. Bun 的 Rust 版用 Claude Code 做狗粮测试

自举（Bootstrap）在编程语言和工具链里一直是一种「成年礼」。C++ 编译器是用 C++ 写的，Rust 编译器是用 Rust 写的（除了最早的版本）。现在，AI 编程工具「用 AI 重写自己依赖的运行时」，这是新时代的 Bootstrap。

5.3 对开源生态的深远影响

如果「AI 写代码」成为主流模式，开源项目的门槛会发生什么变化？

变化一：个人开发者 vs 有 AI 资源的公司

一个独立开发者，即使用上 Claude Code，也很难跟拥有几十个 AI Agent 并行工作的公司团队竞争。Bun 团队可以同时开 20 个 Claude Code 会话，每个负责一个模块的迁移。

变化二：代码的「 authorship」概念模糊化

如果 95% 的代码是 AI 写的，谁是 copyright holder？谁是「作者」？开源许可证里的 Copyright (c) 2026 Bun Team 还准确吗？

变化三：代码审查的重点转移

以前 code review 是看「这段代码有没有 bug」。现在 code review 是看「AI 生成的这段代码有没有隐藏的逻辑偏差」。

6. Rust 版的 Bun：性能、安全与 13,044 个 unsafe 块 {#rust版的bun}

Rust 版 Bun 合并后，社区最关心的三个问题：性能有没有退步？安全性有没有提升？那 13,044 个 unsafe 块是怎么回事？

6.1 性能：基本持平，部分场景更优

根据 Jarred 的推文和 Bun 团队的 benchmark（部分已在 GitHub Discussions 里公开）：

结论： 性能基本持平。Rust 版没有显著退步，部分场景甚至略快。

Jarred 的解释是：「基本是同一份代码库，没用 async Rust，跟 Zig 实现一样只引了少量第三方库。」

6.2 安全性：13,044 个 unsafe 块引发争议

Rust 版 Bun 合并后，有人统计了 Rust 代码里的 unsafe 块数量：13,044 个。

这个数字让 Rust 社区一部分人警惕。Rust 的核心卖点就是内存安全，而 unsafe 块是绕过这套保证的「逃生舱」。

13,044 个 unsafe 意味着什么？

// 示例：Bun 里的一个 unsafe 块（简化）
unsafe {
    let ptr = libc::malloc(size) as *mut u8;
    if ptr.is_null() {
        return Err(AllocError);
    }
    // 手动管理这块内存
    std::ptr::copy_nonoverlapping(src, ptr, size);
    // 没有自动释放！需要手动 free
}

在 Zig 里，所有代码本质上都是「unsafe」的（因为 Zig 不提供内存安全保证）。搬到 Rust 后，这些危险操作被包在 unsafe 块里——至少现在它们是显式的，可以被审计的。

6.3 unsafe 块的收敛计划

Jarred 在 GitHub Discussions 里透露了团队的计划：

「现阶段 13,044 个 unsafe 块是机械翻译的结果。接下来我们会逐步把 unsafe 收敛到核心模块里，让上层逻辑跑在安全 Rust 上。目标是在未来 6 个月内把 unsafe 块数量减少到 3,000 以下。」

收敛策略：

1. 用安全抽象封装 unsafe 操作：比如把原始指针操作封装在一个安全的 BunBuffer 类型里
2. 用 Rust 标准库替代手写逻辑：比如用 Vec<T> 替代手动管理的数组
3. 用 bumpalo 等 arena 分配器：减少手动内存管理

6.4 与 Node.js 的对比

Node.js 底层是 C++，内存安全问题一直是其最大威胁。过去 5 年里，Node.js 发布了十几次安全修复，其中一半以上与内存安全相关（use-after-free、buffer overflow、UAF in V8）。

Bun Rust 版即使有 13,044 个 unsafe 块，至少这些 unsafe 块是显式的、可被工具审计的。而 Node.js 的 C++ 代码里，危险操作是「隐式的默认」。

7. 社区地震：yt-dlp 封禁、Electrobun 解绑 {#社区地震}

Bun 的 Rust 重写不仅在技术社区引发讨论，还直接导致了一些依赖 Bun 的项目重新评估自己的选择。

7.1 yt-dlp 封禁 Bun

yt-dlp（一个流行的 YouTube 视频下载工具）在 2026 年 5 月下旬更新了依赖政策，明确封禁了 Bun v1.3.0 及以上版本。

封禁理由（来自 yt-dlp 的发布公告）：

1. 安全问题：低版本 Bun（1.2.0 以下）在构建 ejs 包时会忽略某些安全配置
2. AI 生成的代码不可审计：yt-dlp 团队表示，他们无法保证 AI 生成的代码的安全性
3. 重写导致的不稳定性：Rust 版的 Bun 在 Windows 上还有一些 edge case 没修完

yt-dlp 的建议是：继续使用 Node.js 或切换到 Deno。

7.2 Electrobun 解绑

Electrobun（一个用 Bun 构建 Electron 替代品的框架）宣布降低对 Bun 的依赖，改为支持多运行时。

Electrobun 的创始人表示：「Bun 的 Rust 重写让我们意识到，依赖单一运行时的风险比我们想象的要大。」

7.3 社区的两极分化

Bun 的 Rust 重写在社区里引发了两极分化的反应：

支持方：

• 「终于不用跟 Zig 编译器打仗了」
• 「Rust 版的内存安全改进是实打实的」
• 「AI 辅助迁移是未来，Bun 只是先行者」

反对方：

• 「AI 生成的代码不可信」
• 「13,044 个 unsafe 块等于没用 Rust」
• 「Bun 团队应该先修 bug，而不是重写整个项目」

8. Zig 的处境：旗舰用户离开意味着什么 {#zig的处境}

Bun 是 Zig 最知名的「旗舰用户」之一。Bun 的成功，很大程度上带动了 Zig 的知名度。现在 Bun 走了，Zig 社区受到了不小打击。

8.1 Zig 社区的反应

Zig 社区论坛里的反应，可以用「震惊+失落」来概括。

有人发帖说：「Bun 是 Zig 的『展示柜』。现在展示柜没了，谁来证明 Zig 适合生产？」

也有人表示理解：「Bun 是一个商业项目（被 Anthropic 收购），它需要工具链的稳定性和生态。Zig 还没准备好。」

8.2 Zig 的技术优势依然存在

尽管失去了 Bun，Zig 的技术优势并没有消失：

1. 编译速度：Zig 的编译速度依然比 Rust 快得多
2. 学习曲线：Zig 比 Rust 简单得多，没有生命周期、借用检查器等概念
3. 与 C 的互操作：Zig 可能是目前与 C 互操作最顺畅的语言

8.3 其他 Zig 用户

Bun 走了，但 Zig 还有其他重要用户：

• TigerBeetle：一个用 Zig 写的分布式金融数据库，性能极其强悍
• Ghostty：一个用 Zig 写的终端模拟器，2024–2025 年很火
• 以 Zig 为自举语言的编译器项目：比如某个新语言的编译器

9. 深层博弈：为什么是 Rust，不是其他 {#深层博弈}

Jarred 选择 Rust，而不是 C、C++、Go 或者继续用 Zig，背后有几个深层原因。

9.1 Rust 的借用检查器 = 减少 crash

Bun 作为一个处理不可信 JS 代码的运行时，内存安全漏洞等于 RCE 漏洞。Rust 的借用检查器能在编译期捕获大量内存安全 bug。

即使 Rust 版目前有 13,044 个 unsafe 块，这些 unsafe 块是显式的、可被审计的，而 Zig 的所有代码本质上都是 unsafe 的。

9.2 Rust 的生态：即使「少量第三方库」，也比 Zig 强

Jarred 强调 Rust 版「没用 async Rust，跟 Zig 实现一样只引了少量第三方库」。但「少量」也比 Zig 的「几乎没有」强。

比如：

• Rust 有 libc、mio、nix 等成熟的系统编程 crate
• Zig 基本所有系统调用都要手写

9.3 Anthropic 的收购

2025 年底，Anthropic 收购了 Bun。这个收购直接改变了 Bun 的战略选择。

Anthropic 是 Rust 的重度用户（他们的 AI 训练基础设施大量用 Rust）。被 Anthropic 收购后，Bun 切换到 Rust，可以获得内部技术支持、招聘更容易、与 Anthropic 的其他工具（Claude Code、Claude API）集成更顺畅。

10. 对 JavaScript 生态的连锁反应 {#javascript生态连锁反应}

Bun 的 Rust 重写，可能会影响整个 JavaScript 生态的格局。

10.1 Node.js 的压力

Node.js 底层是 C++，一直被诟病「难贡献、难维护、内存安全漏洞多」。Bun Rust 版的成功，会给 Node.js 团队带来压力：「要不要也搞个 Rust 版？」

Node.js 核心团队的 Matteo Collina 在 5 月 15 日发推文表示：「局部 Rust 化早已在路上，但不是整个重写。」

10.2 Deno 的处境

Deno（另一个 Node.js 替代品，由 Node.js 原作者 Ryan Dahl 创建）底层是 Rust。Bun 切换到 Rust 后，Deno 和 Bun 的底层语言一致了——竞争从「语言选择」转移到「API 设计」和「性能优化」。

10.3 包管理器的未来

Bun 的 bun install 是用 Zig 写的，现在改成 Rust。这会影响其他包管理器的选择吗？

• pnpm（流行包管理器）：底层是 TypeScript/JavaScript
• yarn（Facebook 出品）：底层是 TypeScript/JavaScript
• npm（Node.js 官方）：底层是 JavaScript

Bun 的 Rust 化，可能会推动其他包管理器考虑 Rust 重写，至少在某些性能敏感的模块里。

11. 工程师视角的技术细节 {#工程师视角}

这一节，我们深入几个具体的技术细节，展示 Zig→Rust 迁移中遇到的真实问题。

11.1 内存管理模型的差异

Zig 的内存管理：

pub fn readFile(allocator: std.mem.Allocator, path: []const u8) ![]u8 {
    const file = try std.fs.openFileAbsolute(path, .{});
    defer file.close();

    const stat = try file.stat();
    const buffer = try allocator.alloc(u8, stat.size);
    errdefer allocator.free(buffer);  // 出错时释放

    _ = try file.readAll(buffer);
    return buffer;  // 调用者需要手动释放
}

Rust 版的等价实现：

pub fn read_file(path: &Path) -> Result<Vec<u8>, std::io::Error> {
    let mut file = File::open(path)?;
    let mut buffer = Vec::new();
    file.read_to_end(&mut buffer)?;
    Ok(buffer)  // Vec 自动管理内存，无需手动释放
}

关键差异：

• Zig 版需要显式调用 allocator.free(buffer)
• Rust 版靠 Drop trait 自动释放

11.2 错误处理

Zig 的错误处理：

pub fn parseJson(input: []const u8) !JsonValue {
    var parser = JsonParser.init(input);
    return parser.parse() catch |err| {
        std.log.err("JSON parse error: {}", .{err});
        return err;
    };
}

Rust 版的等价实现：

pub fn parse_json(input: &[u8]) -> Result<JsonValue, JsonError> {
    let mut parser = JsonParser::new(input);
    parser.parse().map_err(|err| {
        eprintln!("JSON parse error: {:?}", err);
        err
    })
}

11.3 异步 I/O 模型

Bun 的异步 I/O 模型基于：

• Linux: io_uring
• macOS: kqueue
• Windows: IOCP

Zig 版是自己手写的这些系统调用的封装。Rust 版依然保持这个架构，没有用 tokio 或 async-std。

// Rust 版的 io_uring 封装（简化）
pub struct IoUring {
    ring: *mut libc::c_void,  // unsafe 块里管理
}

impl IoUring {
    pub fn new(entries: u32) -> Result<Self, IoUringError> {
        unsafe {
            let ring = io_uring_setup(entries, &mut params);
            if ring.is_null() {
                return Err(IoUringError::SetupFailed);
            }
            Ok(IoUring { ring })
        }
    }
}

impl Drop for IoUring {
    fn drop(&mut self) {
        unsafe {
            libc::munmap(self.ring, self.mmap_size);
        }
    }
}

12. 结论：开源开发的范式转移 {#结论}

Bun 的 Rust 重写，不仅是一个技术事件，更是一个标志着开源开发进入新范式的事件。

12.1 「AI 辅助」→「AI 主导」的跨越

2023–2024 年，「AI 辅助编程」还是「Copilot 补全代码片段」。2026 年，Bun 证明了 AI 可以主导百万行级别的底层系统软件重写。

这个跨越的意义，相当于从「手工制造」到「流水线生产」的跨越。

12.2 开源项目的「AI 门槛」

未来，一个开源项目能不能成功，可能不再取决于「有没有足够多的贡献者」，而是「有没有足够强的 AI 工作流」。

Bun 有 Anthropic 的资源（Claude Code 的无限额度），独立开源项目很难复制这个优势。这可能会加剧开源生态的「寡头化」。

12.3 对 Zig 社区的建议

Zig 社区需要从 Bun 的离开里吸取教训：

1. 加快 1.0 发布：工具链的稳定性是商业项目最看重的
2. 建设生态：调试器、性能分析器、IDE 支持，这些比语言特性更重要
3. 寻找新的旗舰用户：TigerBeetle、Ghostty 等项目可以继续担当 Zig 的展示柜

12.4 最终判断

Bun 的 Rust 重写，是一次技术上的成功、社区关系上的挫折、范式意义上的里程碑。

• 技术上：Rust 版通过了 99.8% 的测试，性能基本持平，安全性有潜在提升
• 社区关系上：Bun 团队没有提前公开讨论，导致社区感到被背叛
• 范式意义上：这是 AI Agent 主导大型系统软件重写的第一个标志性案例

最后一个问题：你应该现在就切换到 Bun Rust 版吗？

答案是：等至少一个正式 stable 版本。目前 Rust 版还在快速迭代中，bug 和性能 regression 都可能存在。但长期来看，Bun Rust 版大概率会成为 JavaScript 运行时里最安全、最稳定的选择之一。

参考资料：

1. Jarred Sumner 的 X 推文（2026 年 5 月 11 日）
2. Bun GitHub PR #30412: 「Rewrite Bun in Rust」
3. Bun 官方博客（待发布）
4. Hacker News 讨论：「Bun is being rewritten from Zig to Rust」
5. Theo (t3.gg) 的 YouTube 视频：「Bun just rewrote itself in Rust with AI」
6. CSDN 技术博客相关报道

作者：程序员茄子 | 发布时间：2026 年 6 月 | 原文链接：https://www.chenxutan.com

如果你觉得这篇文章对你有帮助，欢迎关注「程序员茄子」获取更多深度技术解析。