附录7 Rust 重写浪潮
「把已经能跑的软件推倒重来,是软件史上最糟糕的战略错误。」—— Joel Spolsky,《Things You Should Never Do》,2000
二十五年后,一群人带着借用检查器、GNU 测试套件和 AI 智能体,决定再试一次。
一、为什么是现在
重写这件事,从来不是因为「新语言更酷」。2020 年代这波 Rust 重写,是三件事同时成熟的结果。
| 条件 | 具体表现 |
|---|---|
| 语言 | 所有权 + 生命周期在不引入 GC 的前提下保证内存安全;零成本抽象;extern "C" / repr(C) 让它能嵌进任何旧生态 |
| 生态 | cargo + crates.io 提供了可用的积木:clap(命令行)、tokio(异步)、rayon(数据并行)、serde(序列化)、rustix/nix(系统调用)、rustls(TLS) |
| 工程方法 | 「兼容性测试套件」变成了可执行的合同;「双实现共存」让切换可回退;AI 把逐行移植的成本压到了人力无法竞争的量级(见第八节) |
1.1 内存安全的账单
这不是审美问题,是账本问题。微软安全响应中心与 Chromium 团队多年前就给出过同一个结论:约 70% 的严重安全漏洞,根因是内存安全问题(缓冲区溢出、释放后使用、双重释放)。
Google 在 Android 上做了一次对照实验:
- 新增加的原生代码里,Rust 占比约 21%;
- 同期内存安全类漏洞的占比,从 76% 降到 24%。
一个语言能把一整类漏洞变成编译错误,这件事的说服力,比任何基准测试都大。于是 Linux 6.1 开始接受 Rust 代码,Windows 组件、Android、AWS 的 Firecracker、Cloudflare 的边缘代理,都陆续把关键路径换成了 Rust。
1.2 收益真正来自哪里
先泼一盆冷水:「Rust 重写后快了 N 倍」的新闻,收益大多不来自 Rust。
| 来源 | 例子 | 说明 |
|---|---|---|
| 架构红利 | Pingora 用线程 + 工作窃取 + 共享连接池,替代 NGINX 的进程模型 | 省下的是 TCP/TLS 握手,不是几条指令 |
| 算法与缓存红利 | uv 的全局缓存、并行下载、冷启动优化 | Python 侧原本每次都要重新解依赖 |
| 并行红利 | SWC / Oxc / Rspack 把单线程 JS 解析摊到多核 | Rust 让「放心并行」变得便宜 |
| 语言红利 | 消除 UAF/越界,把运行时崩溃变成编译错误 | 这是稳定性收益,不是速度收益 |
| AI 红利 | Bun 用 11 天完成 53 万行 Zig 到 Rust 的移植 | 降低的是重写成本,不是运行成本 |
认清这一点,才不会把「重写」当成万能药,也才不会在重写后发现「怎么没变快」而怀疑人生。
二、两种重写姿势
同样是重写,风险差了一个数量级,区别在于旧接口是不是合同。
| 维度 | 原地替换(drop-in) | 新物种(greenfield) |
|---|---|---|
| 接口 | 命令行参数、输出格式、退出码、配置文件全部保持一致 | 可以重新设计,用户主动选择 |
| 兼容性验证 | 有现成的测试套件可以「抄」(GNU test suite、webpack 测试集) | 只能自己定义「对」的标准 |
| 替换方式 | 与旧实现共存,包管理器级切换,随时回退 | 淡入,旧工具继续存在 |
| 主要风险 | 长尾兼容性(脚本、locale、ACL、SELinux 标签) | 用户不买账 |
| 代表 | uutils/coreutils、sudo-rs、ntpd-rs、zlib-rs、Rspack、Biome | uv、Pingora、Bun、Zed、Deno |
一个粗略的判据:
如果它藏在脚本、CI、发行版和别人的 Makefile 里,就必须是 drop-in;如果它是用户主动敲下的新命令,才有资格重新设计。
uv 敢重新设计,是因为没人会写脚本去 pip install 一个不存在的接口;coreutils 不敢,因为 ls -l | awk 已经写进了半个世纪的 shell 脚本。
三、系统工具:uutils/coreutils
coreutils 是 Linux 的「水电煤」:ls、cp、mv、rm、cat、sort、head、tail、wc……一百多个小工具,每个都简单到没人愿意重写,也重要到没人敢重写。
uutils/coreutils 花了十多年做这件事。
3.1 把 GNU 测试套件当合同
重写 ls 不难,难的是 ls 在四十年里积累的边界行为:--color 的转义序列、-l 的对齐、符号链接的引用、LC_ALL 下的排序、SELinux 标签、ACL、稀疏文件……
uutils 的做法是把 GNU coreutils 自带的测试套件直接跑在自己的实现上,并把通过率当作唯一的进度条:
| 版本 | 通过 | 失败 | 错误 | 跳过 | 可运行测试的通过率 |
|---|---|---|---|---|---|
| 0.5.0 | 566 | 55 | 1 | 23 | 87.75%(按全部 645 个用例) |
| 0.12.0 | 653 | 21 | 0 | 18 | 96.9%(653/674) |
0.12.0 的发布说明写得很实在:这一轮的工作重点就是修 Ubuntu 用户报的 bug——并行 install -D 丢数据、32 位平台上 du 溢出、ls 的 ACL 解引用、cp -R 的名字冲突、chmod -R 穿过符号链接。同时把「明显比 GNU 慢」正式列为 bug,而不是愿望清单。
3.2 一个二进制,一百个面孔
coreutils 在打包上是「多调用二进制」(multicall binary),和 busybox 一个思路:编一个可执行文件,靠 argv[0] 判断自己该扮演谁,再用符号链接铺开。
use std::env;
use std::ffi::OsString;
use std::fs::File;
use std::io::{BufRead, BufReader, Read};
use std::path::{Path, PathBuf};
use std::process::ExitCode;
fn main() -> ExitCode {
let mut args = env::args_os();
let argv0 = args.next().unwrap_or_default();
// 多调用二进制:按「自己被叫什么名字」决定行为(busybox / uutils 的做法)
// 用 file_stem 顺带剥掉 Windows 的 .exe
let tool = Path::new(&argv0)
.file_stem()
.and_then(|s| s.to_str())
.unwrap_or("wc")
.to_string();
let rest: Vec<OsString> = args.collect();
match tool.as_str() {
"wc" => wc(rest),
"head" => head(rest),
other => {
eprintln!("{other}: 未知的工具名;本程序内置 wc 与 head。");
eprintln!("试试:ln -s \"$(command -v minicoreutils)\" /tmp/wc");
ExitCode::FAILURE
}
}
}
#[derive(Default)]
struct Count {
lines: u64,
words: u64,
bytes: u64,
}
/// 流式统计:无论文件多大,内存里只有一个 64 KiB 的缓冲
fn count(mut reader: impl Read) -> std::io::Result<Count> {
let mut buf = Vec::with_capacity(64 * 1024);
let mut c = Count::default();
let mut r = BufReader::with_capacity(64 * 1024, &mut reader);
loop {
buf.clear();
if r.read_until(b'\n', &mut buf)? == 0 {
break;
}
c.lines += 1;
c.bytes += buf.len() as u64;
// 因为按行切分,词不可能跨块,这里的计数是安全的
c.words += buf
.split(|b| b.is_ascii_whitespace())
.filter(|w| !w.is_empty())
.count() as u64;
}
Ok(c)
}
fn wc(paths: Vec<OsString>) -> ExitCode {
if paths.is_empty() {
return match count(std::io::stdin()) {
Ok(c) => {
println!("{:8} {:8} {:8}", c.lines, c.words, c.bytes);
ExitCode::SUCCESS
}
Err(e) => {
eprintln!("wc: {e}");
ExitCode::FAILURE
}
};
}
let mut total = Count::default();
let mut failed = false;
for p in &paths {
let path = PathBuf::from(p);
let file = match File::open(&path) {
Ok(f) => f,
Err(e) => {
eprintln!("wc: {}: {e}", path.display());
failed = true;
continue;
}
};
match count(file) {
Ok(c) => {
println!("{:8} {:8} {:8} {}", c.lines, c.words, c.bytes, path.display());
total.lines += c.lines;
total.words += c.words;
total.bytes += c.bytes;
}
Err(e) => {
eprintln!("wc: {}: {e}", path.display());
failed = true;
}
}
}
if paths.len() > 1 {
println!(
"{:8} {:8} {:8} total",
total.lines, total.words, total.bytes
);
}
if failed {
ExitCode::FAILURE
} else {
ExitCode::SUCCESS
}
}
fn head(paths: Vec<OsString>) -> ExitCode {
let n: usize = env::var("LINES")
.ok()
.and_then(|v| v.parse().ok())
.unwrap_or(10);
let mut r: Box<dyn BufRead> = match paths.first() {
None => Box::new(BufReader::new(std::io::stdin())),
Some(p) => {
let path = PathBuf::from(p);
match File::open(&path) {
Ok(f) => Box::new(BufReader::new(f)),
Err(e) => {
eprintln!("head: {}: {e}", path.display());
return ExitCode::FAILURE;
}
}
}
};
let mut line = String::new();
for _ in 0..n {
line.clear();
match r.read_line(&mut line) {
Ok(0) => break, // EOF
Ok(_) => print!("{line}"),
Err(e) => {
eprintln!("head: {e}");
return ExitCode::FAILURE;
}
}
}
ExitCode::SUCCESS
}
# 试试多调用二进制的味道(Windows 上用 Copy-Item 代替 cp,名字用 wc.exe / head.exe)
cargo build --release
cp target/release/minicoreutils /tmp/wc
cp target/release/minicoreutils /tmp/head
/tmp/wc src/chapter_80_RustRewrite.md
/tmp/head Cargo.toml
# 另一种方式
rustc -C opt-level=3 wc_head.rs
ln -s "$PWD/wc_head.exe" /tmp/wc
ln -s "$PWD/wc_head.exe" /tmp/head
/tmp/wc wc_head.rs
/tmp/head wc_head.rs
几个真实项目里绕不开的细节,这段代码已经踩到了:
argv[0]是接口的一部分:符号链接叫什么,程序就扮演谁。Windows 上还得先剥掉.exe,所以这里用file_stem而不是file_name。- 按行切分让「词」不会跨越缓冲区,省掉了状态机;代价是超长单行(比如压缩成一行的 JSON)会把
buf撑大,GNU 的wc也要面对同样的问题。 - Rust 启动时把
SIGPIPE设成了忽略,所以head | head -1这种场景下写入会返回EPIPE,而不是像 C 程序那样被内核杀掉。print!遇到EPIPE会 panic,真正的实现要么恢复默认信号处理,要么显式处理错误。 - 输出格式必须逐字节对齐:列宽、
total行、文件名里的空格、-表示标准输入的约定。兼容性就藏在这些「无关紧要」的地方。
3.3 Ubuntu 的「氧化」
2025 年 10 月发布的 Ubuntu 25.10 做了一个标志性决定:默认的 coreutils 与 sudo 换成 Rust 实现。Canonical 自己把这个过程叫作 carefully but purposefully oxidising Ubuntu。
切换不是一刀切的,因为有些工具的差异足够致命:
| 发行版 | 仍然使用 GNU coreutils 的命令 |
|---|---|
| Ubuntu 24.04 LTS 及更早 | 全部 |
| Ubuntu 25.10 | chmod、chown、cp、df、mv、rm、true |
| Ubuntu 26.04 LTS | cp、df、mv、rm、true |
| Ubuntu 26.10 及以后 | 无 |
注意 cp、mv、rm 这三个名字——动数据的命令排在最后。这是发行版在替用户承担风险:先换只读的、观察类工具,再换会写盘的工具。切换方式也不是 update-alternatives(对 Essential 包不安全),而是 coreutils-from-<provider> 这样的 provider 包。
四、提权:sudo-rs
如果要在 Linux 上挑一个「最不该用 C 写」的程序,sudo 排第一:它带着 setuid root 运行,解析一个由管理员手写的配置文件,然后把任意命令以 root 身份执行。
sudo-rs 由 Trifecta Tech Foundation(前身 Tweede Golf)主导,与 ISRG 的 Prossimo 计划合作,现已是 Ubuntu 25.10 与 26.04 LTS 的默认 sudo。
4.1 先砍功能,再谈安全
sudo-rs 的取舍很值得学:攻击面也是功能。它主动放弃了一批原版功能:
| 差异 | 说明 |
|---|---|
| 密码提示 | 原版 [sudo] password for <USER>,sudo-rs 是 [sudo: authenticate] <METHOD>:,Expect 脚本会超时,可用 --prompt "" 规避 |
| I/O 日志 | 不支持 sudoreplay、sudo_logsrvd、sudo_sendlog |
| LDAP | 没有 sudoers.ldap,改用 PAM 做 LDAP 认证 |
| 命令行选项 | 维护一份与原版逐项的 parity 清单,没对齐的就不宣称支持 |
「少支持一个功能,就少一条能被利用的路径」——这个判断在提权程序上是成立的。
4.2 规则匹配的关键是「默认拒绝」
sudoers 的语义极其微妙:主机、用户、Runas、命令、标签(NOPASSWD、SETENV)、别名、! 取反、最后一个匹配生效……简化成玩具版本,核心是这个形状:
#[derive(Debug)]
struct Rule<'a> {
user: &'a str,
host: &'a str,
runas: &'a str,
command: &'a str,
nopasswd: bool,
}
/// 极简版:真正的 sudoers 还有别名、取反、通配、参数匹配和「最后匹配生效」
fn allows<'a>(rules: &'a [Rule<'a>], user: &str, host: &str, cmd: &str) -> Option<&'a Rule<'a>> {
rules.iter().rev().find(|r| {
let user_ok = r.user == "ALL" || r.user == user;
let host_ok = r.host == "ALL" || r.host == host;
let cmd_ok = r.command == "ALL" || cmd.starts_with(r.command);
user_ok && host_ok && cmd_ok
})
}
fn main() {
let rules = [Rule {
user: "alice",
host: "ALL",
runas: "root",
command: "/usr/bin/systemctl",
nopasswd: false,
}];
for (user, cmd) in [
("alice", "/usr/bin/systemctl restart nginx"),
("bob", "/usr/bin/systemctl"),
("alice", "/bin/sh"),
] {
match allows(&rules, user, "web-01", cmd) {
Some(r) if r.nopasswd => println!("允许(免密):{user} -> {} as {}", r.command, r.runas),
Some(r) => println!("允许(需密码):{user} -> {} as {}", r.command, r.runas),
None => println!("拒绝:{user} -> {cmd}"),
}
}
}
ALL 与路径前缀匹配看起来无害,实际是最容易出事的地方:/usr/bin/systemctl 的前缀匹配会让 /usr/bin/systemctl.bak 也被放行。这就是为什么 sudo-rs 的 sudoers 解析器要逐条对照语义,而不是「差不多就行」。
五、时间、压缩与 DNS:最无聊的库最值得重写
有些软件没人会主动打开,但每个程序都链接它。它们出一次 CVE,半个互联网陪着打补丁。
| 领域 | 旧实现 | Rust 重写 | 进展 |
|---|---|---|---|
| 时间同步 | ntpd / chrony | ntpd-rs | Let’s Encrypt 自 2024 年 6 月起生产使用;计划随 Ubuntu 26.10 进 archive,27.04 成为默认 |
| PTP 精密时间 | linuxptp | Statime | 与 ntpd-rs 同源,能力将并入 ntpd-rs |
| 压缩 | zlib | zlib-rs | 已宣布稳定且完整的 API,逐步被上游采用 |
| DNS | BIND / Unbound | Hickory DNS | 库形态被大量项目内嵌使用 |
| TLS | OpenSSL | rustls | 默认只开安全协议与套件,已成为 Rust 生态事实标准 |
Canonical 在 2026 年成为 Trifecta Tech Foundation 的 Gold Sponsor,每年 4 万欧元,明确说钱要花在 ntpd-rs 上——「这个每个 Ubuntu 安装都依赖、用来让时钟和 TLS 证书保持同步的东西」。
为什么先重写这些?因为它们的正确性可以被测试穷举:NTP 有 RFC 5905,zlib 有压缩格式规范,算法有标准测试向量。反过来说,凡是「行为只能靠用户抱怨来发现」的软件,重写风险就高得多。
顺带一句:2024 年的 xz 后门事件提醒我们,供应链安全不只有内存安全这一个维度。Rust 解决不了「维护者被社工」的问题——但它确实能解决「一个越界写,让全世界 RCE」。
六、网络代理:Pingora
2022 年 9 月,Cloudflare 公开了 Pingora:一个用 Rust 写的 HTTP 代理,用来替换他们跑了很多年的 NGINX。2024 年 2 月,Pingora 以 Apache-2.0 开源。
6.1 数字
| 指标 | 数值 |
|---|---|
| 日请求量 | 超过 1 万亿 |
| CPU 消耗 | 比旧服务低约 70% |
| 内存消耗 | 比旧服务低约 67% |
| 首字节时间 | 中位数降低 5 ms,P95 降低 80 ms |
| 新建连接 | 全站每秒新建连接数只有旧服务的约 1/3 |
| 连接复用 | 某大客户从 87.1% 提升到 99.92%,回源新建连接减少约 160 倍 |
| 稳定性 | 累计数百 T 请求,没有一次崩溃是服务代码引起的 |
最后一行是重点。不是「慢一点但更安全」,而是「更快,同时不再崩」。
6.2 真正被换掉的是架构,不是语言
NGINX 的 worker 是进程模型:一个请求绑死在一个 worker 上,连接池也按 worker 隔离。在 Cloudflare 的规模下,这带来三个结构性麻烦:
- CPU 负载不均——有的 worker 闲死,有的忙死;
- 一个请求的阻塞 I/O 会拖慢同 worker 上的其他请求;
- 连接复用率低——加 worker 反而让连接池更分散,回源握手更多。
Pingora 改成多线程 + 工作窃取(Tokio 调度),连接池全局共享。省下来的 70% CPU,大部分来自「少握手」,而不是「指令更快」。
还有一个细节很能说明问题:Pingora 没有用现成的 hyper,而是自己写了 HTTP 库。原因是真实世界的 HTTP 不合规——很多服务器返回 599 到 999 之间的状态码,hyper 早期会直接拒绝。在边缘节点上,「宽容」是功能需求,不是代码洁癖能解决的。
七、Python 生态:把热路径换成 Rust,用户无感
Python 社区对 Rust 的接受度最高,因为它不要求任何人换语言——外壳还是 Python,内核换成 Rust。
| 工具 | 取代 | 收益 |
|---|---|---|
| uv | pip、pip-tools、pipx、poetry、pyenv、twine、virtualenv | 官方基准 10–100 倍;全局缓存去重;跨平台 universal lockfile;单二进制,不需要预装 Python |
| Ruff | flake8、isort、pyupgrade、部分 black | 毫秒级,一次跑完几百条规则 |
| Polars | pandas | 惰性执行、多线程、Arrow 列存 |
| pydantic-core | Pydantic v1 的纯 Python 校验 | v2 的校验核心,官方称 5–50 倍 |
7.1 为什么 uv 能快两个数量级
不是因为「Rust 比 Python 快」,而是因为它把三件事同时改了:
- 冷启动:单二进制,没有解释器启动、没有导入一堆包;
- 解析:一次解析出全局最优解,缓存下来,第二次几乎零成本;
- I/O:并行下载、并行解包、硬链接复用已下载的 wheel。
同样的思路在 PyO3 里可以小规模复现——把最热的那一个函数搬到 Rust:
#![allow(unused)]
fn main() {
use pyo3::prelude::*;
/// 统计词数:Python 里一行 split() 也能做,但数据量大时差一个数量级
#[pyfunction]
fn word_count(text: &str) -> usize {
text.split_whitespace().count()
}
#[pymodule]
fn fastwc(m: &Bound<'_, PyModule>) -> PyResult<()> {
m.add_function(wrap_pyfunction!(word_count, m)?)?;
Ok(())
}
}
# maturin develop 之后
from fastwc import word_count
print(word_count("hello rust world")) # 3
三个工程要点:
- 边界要粗:一次传一大块数据,而不是每个元素过一次 FFI。
- 该放 GIL 就放:CPU 密集的纯 Rust 计算用
py.allow_threads(|| ...)包起来,别把 Python 的其他线程一起锁死。 - 别重写整个库:
uv的野心是罕见的;多数项目只需要把 5% 的热路径搬过去。
八、JavaScript 生态:Bun 的 11 天
8.1 一次教科书级的「重写」
Bun 的故事值得单独讲,因为它在 2026 年同时刷新了三件事:重写的成本、重写的组织方式,以及「什么叫重写完了」。
时间线:
| 时间 | 事件 |
|---|---|
| 2021-04 | Jarred Sumner 写下第一行 Zig,一年后做出 Bun 的第一个版本 |
| 2025-12 | Anthropic 收购 Bun |
| 2026-05 | Bun 团队尝试把 Zig 移植到 Rust,合并速度「像 AI 一样」 |
| 2026-07-08 | 官方博客《Rewriting Bun in Rust》:11 天,约 16.5 万美元 API 成本,+100 万行 Rust |
| 2026-07-13 | Zig 创始人 Andrew Kelley 发文,称之为「未经审查的 slop」 |
8.2 动机不是「Zig 不好」
Bun 的代码库是 53.5 万行 Zig(不含注释)加约 20% 的 C++(JavaScriptCore、uWebSockets、BoringSSL、SQLite)。它的问题不是「Zig 写得慢」,而是:
JavaScript 是带 GC 的语言,Zig 是手动管理内存的语言。Bun 同时持有 GC 值和非 GC 值,每次分配都要人工回答:这块内存在哪里释放?会不会释放两次?GC 的保守扫描器看得见这个指针吗?
发布说明里列出的 v1.3.14 修复清单,几乎全是折磨人的同类问题:node:zlib 的 UAF、node:http2 的 UAF、UDPSocket.send() 的 UAF、fs.watch() 的引用计数下溢导致 watcher 永不回收、tlsSocket.setSession() 每次泄漏约 6.5 KB……
Rust 的 Drop 和借用检查把这些运行时崩溃变成了编译错误。这是重写的核心理由,也是最容易被「可是 Zig 更快」的争论掩盖的部分。
8.3 方法:把重写变成一个可并行的流水线
Sumner 没有「让 Claude 把 Bun 重写成 Rust」这么一句 prompt 了事。他搭的是一条产线:
- 先花 3 小时讨论 Zig 模式到 Rust 模式的映射,产出
PORTING.md; - 再让 Claude 遍历所有结构体字段,推断生命周期,产出
LIFETIMES.tsv; - 先拿 3 个文件做试点:1 个实现者 + 2 个对抗式审查者(审查者只看 diff,被要求「假定这段代码是错的」);
- 然后拆成 4 个 worktree 分片,各跑 16 个 Claude,峰值约每分钟 1300 行,11 天 6502 次提交;
- 最后用 Bun 自己的 TypeScript 测试套件验证——测试套件与运行时语言无关,这是整件事能成立的前提。
结果:100 万条以上断言全部通过,没有跳过,没有删除。
8.4 争议,以及它值得被认真对待
Andrew Kelley 的质疑只有一句话,但很难反驳:
如果 Bun 的测试套件在 Zig 代码没能抓住这些 bug,凭什么认为它能抓住一百万行未经审查的 Rust 代码里的 bug?
他还指出,Zig 项目明确不接受 AI 生成的贡献——不是因为「AI 写的不好」,而是因为「没有工程审查的代码,问题会在几年后集中爆发」。
双方都没有错,只是衡量的东西不同:
| 立场 | 关心的问题 |
|---|---|
| Sumner | 用户今天还在崩,11 天后可以不崩,为什么不做? |
| Kelley | 百万行没人读过的代码,三年后谁来维护?谁来背锅? |
一个折中的判断:大规模 AI 移植改变的是「重写的成本」,不是「重写的风险」。 成本降了 100 倍,风险只降了一点点——测试套件能覆盖行为,覆盖不了可维护性。所以真正该学的不是「11 天」,而是那条产线:可执行的移植规范、对抗式审查、语言无关的测试、分片并行、失败后改流程而不是手改代码。
8.5 JavaScript 工具链早就「Rust 化」了
在 Bun 之前,JS 生态的底层已经换过一轮血:
| Rust 项目 | 取代 | 现状 |
|---|---|---|
| SWC | Babel 的转译与压缩 | Next.js 等大量项目在用 |
| Rspack | webpack | 兼容 webpack 配置与插件生态 |
| Rolldown | Rollup | Vite 的新打包内核 |
| Oxc | ESLint / Babel 的解析与 lint | oxlint 已可用 |
| Biome | ESLint + Prettier | 格式化 + lint 一体 |
| Turbopack | webpack(Next.js 场景) | Next.js 的增量打包器 |
| Deno | Node.js(另一种选择) | Rust + V8 + Tokio |
它们快的共同原因不是「Rust 快」,而是能放心并行:
#![allow(unused)]
fn main() {
use rayon::prelude::*;
/// 并行数换行符:把大文件切片,各核各数各的
fn count_newlines(data: &[u8]) -> usize {
data.par_chunks(1 << 20)
.map(|chunk| chunk.iter().filter(|&&b| b == b'\n').count())
.sum()
}
}
单线程的 JS 做不到这件事,不是因为语法,而是因为没有「编译期保证无数据竞争」这层底气。
九、一张地图
把散落的项目按领域摆在一起,能看出这波浪潮的形状:从最底层、最无聊、最危险的地方开始,向上蔓延。
| 领域 | 旧实现 | Rust 重写 | 状态 |
|---|---|---|---|
| 基础命令 | GNU coreutils | uutils/coreutils | Ubuntu 25.10+ 默认 |
| 提权 | sudo.ws | sudo-rs | Ubuntu 25.10+ 默认 |
| 时间同步 | ntpd / chrony | ntpd-rs | 生产在用,发行版默认在推进 |
| 压缩 | zlib | zlib-rs | 稳定 API,逐步采用 |
| TLS | OpenSSL | rustls | 生态事实标准 |
| DNS | BIND / Unbound | Hickory DNS | 大量内嵌使用 |
| 搜索 | GNU grep | ripgrep(rg) | 事实标准 |
| 查找 | GNU find | fd | 广泛使用 |
| 查看 | GNU cat | bat | 广泛使用 |
| 列表 | GNU ls | eza | 广泛使用 |
| 目录跳转 | cd + 手打 | zoxide | 广泛使用 |
| 提示符 | bash PS1 | starship | 广泛使用 |
| 基准测试 | time | hyperfine | 事实标准 |
| 代理 | NGINX / Envoy | Pingora | Cloudflare 生产 |
| 包管理 | pip / poetry | uv | Python 生态事实标准 |
| Lint/格式化 | flake8 / black | Ruff | 事实标准 |
| 数据框 | pandas | Polars | 广泛使用 |
| 校验 | Pydantic v1 | pydantic-core | Pydantic v2 内置 |
| JS 转译 | Babel | SWC | 广泛使用 |
| JS 打包 | webpack / Rollup | Rspack / Rolldown | 大面积替换中 |
| JS 运行时 | Node.js | Bun(Rust 化)/ Deno | 2026 年剧变 |
| 版本控制 | git | gitoxide(gix)、jj | 库形态使用 / 新物种 |
| 容器运行时 | runc | youki | 可用 |
| 虚拟化 | QEMU(通用 VMM) | Firecracker(microVM) | AWS 生产 |
| 嵌入式数据库 | SQLite | Turso(原 limbo) | 实验阶段 |
| 搜索引擎 | Elasticsearch | Meilisearch / Quickwit | 生产使用 |
| 编辑器 | VS Code / vim | Zed / Helix | 生产使用 |
| 桌面环境 | GNOME / KDE | COSMIC | 生产使用 |
| 浏览器内核 | Gecko / Blink | Servo | 组件化复用 |
十、重写的经济学
回到 Spolsky。他 2000 年那篇文章的核心论点今天依然成立:
重写丢掉的是「知识」,不是「代码」。那些看起来丑陋的分支,是十年 bug 报告凝结成的化石。
但他没预料到 2026 年的三件事,恰好把重写的成本结构改了:
- 兼容性可以度量:GNU test suite、webpack 测试集、Bun 的百万断言——「像不像」从主观判断变成了 CI 数字。
- 双实现可以共存:
coreutils-from-<provider>、Cargo feature、FFI 桥、灰度开关,让「切换」可以随时回退。 - 移植成本骤降:AI 把 53 万行 Zig 的移植压到 11 天、16.5 万美元。
10.1 重写前的五问
| 问题 | 不合格的信号 |
|---|---|
| 有没有一份可执行的合同?(测试套件 / 规范 / 参考实现) | 「我们照着文档写就行」 |
| 能不能双轨共存、随时回退? | 必须一次性替换,没有回退路径 |
| 收益来自语言,还是来自架构? | 说不清为什么要换语言,只说「Rust 更安全」 |
| 长尾兼容性谁买单? | 没有人为「用户脚本跑不通」负责 |
| 重写后谁来维护十年? | 原作者都走了,新人只会改 prompt |
10.2 三种常见的翻车方式
- 大爆炸式重写:分支开发两年,合并那天发现需求全变了。Bun 敢一次做完,是因为它有语言无关的测试套件兜底,且窗口只有 11 天。
- 先追性能,后补兼容:基准测试赢了,但
ls -l的列宽差一个空格,下游脚本全挂。 - 把
unsafe当逃生舱:为了「和 C 一样快」,把 C 的逻辑逐行翻成unsafeRust,等于换了个语法的 C。
一个判断 unsafe 是否失控的土办法:cargo geiger 看一眼比例。安全关键组件里,unsafe 应该集中在极少数有注释、有测试、有审查的边界上。
十一、动手:和 GNU 对一对
写完了 wc,别急着宣布「我也行」。真正的验收是这四步:
# 0. 先给自己起个名字:多调用二进制靠 argv[0] 认亲
cp target/release/minicoreutils /tmp/wc
# 1. 正确性:和 GNU 输出逐字节对比(bash 的进程替换)
for f in src/*.md; do
diff <(/tmp/wc "$f") <(wc "$f") || echo "MISMATCH: $f"
done
# 2. 边界:空文件、没有结尾换行、超长单行、二进制文件
: > empty.txt
printf 'no trailing newline' > nonl.txt
diff <(/tmp/wc empty.txt) <(wc empty.txt)
diff <(/tmp/wc nonl.txt) <(wc nonl.txt)
# 3. 性能:至少三次,取中位数
hyperfine --warmup 3 '/tmp/wc big.log' 'wc big.log'
# 4. 退出码:脚本世界里,退出码比输出更重要
/tmp/wc /nonexistent; echo "exit=$?" # GNU 返回 1
这四步分别对应四类 bug:语义、边界、性能、契约。uutils 的 GNU 测试套件干的就是第 1 和第 4 步,Cloudflare 的压测干的是第 3 步,而第 2 步通常要靠 fuzzing——Bun 用 Fuzzilli 全天候跑运行时 API,就是在补这一类。
十二、结语
这波 Rust 重写,表面上是语言之争,实质上是三笔账同时被算清了:
- 安全的账:把一整类漏洞变成编译错误,比事后打补丁便宜;
- 成本的账:测试套件让「兼容」可度量,AI 让「移植」可负担;
- 架构的账:很多系统不是被语言拖慢的,是被进程模型、连接池、单线程设计拖慢的——重写给了重新设计的机会。
用一句话概括这份附录想说的:
重写的理由,最好不是「我想用 Rust」,而是「我知道旧的那个东西,哪里错了,并且我能证明新的那个东西,哪里对了」。
至于语言——Rust 只是目前最合适的那个工具。二十年后,它也会变成需要被重写的那一个。
十三、延伸阅读
- uutils/coreutils——Rust 版 coreutils,GNU 测试套件通过率公开可查
- uutils 0.12.0 发布说明——96.9% 与「Ubuntu 报的 bug 全修了」
- Ubuntu:System utility replacements——coreutils 与 sudo 的兼容性差异清单
- sudo-rs——内存安全的 sudo
- Trifecta Tech Foundation——sudo-rs、ntpd-rs、zlib-rs 背后的非营利组织
- Pingora——Cloudflare 的 Rust 代理框架
- How we built Pingora——1 万亿请求、70% CPU、零崩溃
- uv——极快的 Python 包与项目管理器
- Ruff——极快的 Python linter 与格式化器
- Polars——Rust 实现的数据框
- Bun:Rewriting Bun in Rust——11 天、100 万行、16.5 万美元
- Andrew Kelley:My Thoughts on the Bun Rust Rewrite——来自 Zig 创始人的反面意见
- Joel Spolsky:Things You Should Never Do——重写的经典劝退文
- ripgrep、fd、bat、eza——日常命令的 Rust 替代
- rustls——Rust 的 TLS 实现