Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

附录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、Biomeuv、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.05665512387.75%(按全部 645 个用例)
0.12.06532101896.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.10chmod、chown、cp、df、mv、rm、true
Ubuntu 26.04 LTScp、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 / chronyntpd-rsLet’s Encrypt 自 2024 年 6 月起生产使用;计划随 Ubuntu 26.10 进 archive,27.04 成为默认
PTP 精密时间linuxptpStatime与 ntpd-rs 同源,能力将并入 ntpd-rs
压缩zlibzlib-rs已宣布稳定且完整的 API,逐步被上游采用
DNSBIND / UnboundHickory DNS库形态被大量项目内嵌使用
TLSOpenSSLrustls默认只开安全协议与套件,已成为 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 的规模下,这带来三个结构性麻烦:

  1. CPU 负载不均——有的 worker 闲死,有的忙死;
  2. 一个请求的阻塞 I/O 会拖慢同 worker 上的其他请求;
  3. 连接复用率低——加 worker 反而让连接池更分散,回源握手更多。

Pingora 改成多线程 + 工作窃取(Tokio 调度),连接池全局共享。省下来的 70% CPU,大部分来自「少握手」,而不是「指令更快」。

还有一个细节很能说明问题:Pingora 没有用现成的 hyper,而是自己写了 HTTP 库。原因是真实世界的 HTTP 不合规——很多服务器返回 599 到 999 之间的状态码,hyper 早期会直接拒绝。在边缘节点上,「宽容」是功能需求,不是代码洁癖能解决的。


七、Python 生态:把热路径换成 Rust,用户无感

Python 社区对 Rust 的接受度最高,因为它不要求任何人换语言——外壳还是 Python,内核换成 Rust。

工具取代收益
uvpip、pip-tools、pipx、poetry、pyenv、twine、virtualenv官方基准 10–100 倍;全局缓存去重;跨平台 universal lockfile;单二进制,不需要预装 Python
Ruffflake8、isort、pyupgrade、部分 black毫秒级,一次跑完几百条规则
Polarspandas惰性执行、多线程、Arrow 列存
pydantic-corePydantic 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

三个工程要点:

  1. 边界要粗:一次传一大块数据,而不是每个元素过一次 FFI。
  2. 该放 GIL 就放:CPU 密集的纯 Rust 计算用 py.allow_threads(|| ...) 包起来,别把 Python 的其他线程一起锁死。
  3. 别重写整个库:uv 的野心是罕见的;多数项目只需要把 5% 的热路径搬过去。

八、JavaScript 生态:Bun 的 11 天

8.1 一次教科书级的「重写」

Bun 的故事值得单独讲,因为它在 2026 年同时刷新了三件事:重写的成本、重写的组织方式,以及「什么叫重写完了」。

时间线:

时间事件
2021-04Jarred Sumner 写下第一行 Zig,一年后做出 Bun 的第一个版本
2025-12Anthropic 收购 Bun
2026-05Bun 团队尝试把 Zig 移植到 Rust,合并速度「像 AI 一样」
2026-07-08官方博客《Rewriting Bun in Rust》:11 天,约 16.5 万美元 API 成本,+100 万行 Rust
2026-07-13Zig 创始人 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 项目取代现状
SWCBabel 的转译与压缩Next.js 等大量项目在用
Rspackwebpack兼容 webpack 配置与插件生态
RolldownRollupVite 的新打包内核
OxcESLint / Babel 的解析与 lintoxlint 已可用
BiomeESLint + Prettier格式化 + lint 一体
Turbopackwebpack(Next.js 场景)Next.js 的增量打包器
DenoNode.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 coreutilsuutils/coreutilsUbuntu 25.10+ 默认
提权sudo.wssudo-rsUbuntu 25.10+ 默认
时间同步ntpd / chronyntpd-rs生产在用,发行版默认在推进
压缩zlibzlib-rs稳定 API,逐步采用
TLSOpenSSLrustls生态事实标准
DNSBIND / UnboundHickory DNS大量内嵌使用
搜索GNU grepripgrep(rg)事实标准
查找GNU findfd广泛使用
查看GNU catbat广泛使用
列表GNU lseza广泛使用
目录跳转cd + 手打zoxide广泛使用
提示符bash PS1starship广泛使用
基准测试timehyperfine事实标准
代理NGINX / EnvoyPingoraCloudflare 生产
包管理pip / poetryuvPython 生态事实标准
Lint/格式化flake8 / blackRuff事实标准
数据框pandasPolars广泛使用
校验Pydantic v1pydantic-corePydantic v2 内置
JS 转译BabelSWC广泛使用
JS 打包webpack / RollupRspack / Rolldown大面积替换中
JS 运行时Node.jsBun(Rust 化)/ Deno2026 年剧变
版本控制gitgitoxide(gix)、jj库形态使用 / 新物种
容器运行时runcyouki可用
虚拟化QEMU(通用 VMM)Firecracker(microVM)AWS 生产
嵌入式数据库SQLiteTurso(原 limbo)实验阶段
搜索引擎ElasticsearchMeilisearch / Quickwit生产使用
编辑器VS Code / vimZed / Helix生产使用
桌面环境GNOME / KDECOSMIC生产使用
浏览器内核Gecko / BlinkServo组件化复用

十、重写的经济学

回到 Spolsky。他 2000 年那篇文章的核心论点今天依然成立:

重写丢掉的是「知识」,不是「代码」。那些看起来丑陋的分支,是十年 bug 报告凝结成的化石。

但他没预料到 2026 年的三件事,恰好把重写的成本结构改了:

  1. 兼容性可以度量:GNU test suite、webpack 测试集、Bun 的百万断言——「像不像」从主观判断变成了 CI 数字。
  2. 双实现可以共存:coreutils-from-<provider>、Cargo feature、FFI 桥、灰度开关,让「切换」可以随时回退。
  3. 移植成本骤降:AI 把 53 万行 Zig 的移植压到 11 天、16.5 万美元。

10.1 重写前的五问

问题不合格的信号
有没有一份可执行的合同?(测试套件 / 规范 / 参考实现)「我们照着文档写就行」
能不能双轨共存、随时回退?必须一次性替换,没有回退路径
收益来自语言,还是来自架构?说不清为什么要换语言,只说「Rust 更安全」
长尾兼容性谁买单?没有人为「用户脚本跑不通」负责
重写后谁来维护十年?原作者都走了,新人只会改 prompt

10.2 三种常见的翻车方式

  • 大爆炸式重写:分支开发两年,合并那天发现需求全变了。Bun 敢一次做完,是因为它有语言无关的测试套件兜底,且窗口只有 11 天。
  • 先追性能,后补兼容:基准测试赢了,但 ls -l 的列宽差一个空格,下游脚本全挂。
  • 把 unsafe 当逃生舱:为了「和 C 一样快」,把 C 的逻辑逐行翻成 unsafe Rust,等于换了个语法的 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 只是目前最合适的那个工具。二十年后,它也会变成需要被重写的那一个。


十三、延伸阅读