本文永久链接 – https://tonybai.com/2026/05/27/migrate-go-to-rust

大家好，我是Tony Bai。

在现代后端系统编程领域，Go 和 Rust 无疑是最耀眼的两大双子星。它们都拥有静态类型、编译型、单二进制文件分发等优异特性。然而，这两门语言在底层的设计哲学、运行时权衡以及开发者体验上，走向了截然不同的方向。

Matthias Endler（Corrode 咨询公司创始人）撰写的《从 Go 迁移到 Rust》（Migrating from Go to Rust）是近年来系统编程领域极具深度的一篇迁移指南。作为在生产环境中同时大规模部署过 Go 和 Rust 系统的资深架构师，Matthias 并没有陷入单纯的“谁比谁快”的无意义争论，而是从正确性保证、运行时权衡、工程重构成本等多个维度，客观地为准备进行语言迁移的团队提供了一份极其务实的工程路线图。

以下是该迁移指南的完整简体中文译文，以及技术社区对于此文的精彩技术辩论与观点。

在我协助团队进行的所有迁移中，从 Go 到 Rust 的迁移是一个特例。

这并不是“Rust 会更快吗？”或“Go 是否拥有类型系统？”的问题，因为 Go 在这些方面已经做得很好了。这里的讨论主要围绕正确性保证、运行时权衡以及开发人员体验展开。

在开始之前，先做一个简短的免责声明：本指南高度侧重于后端。后端服务是 Go 的强项所在——小巧的静态二进制文件、专注于网络连接的标准库，以及用于 HTTP 服务器、gRPC、数据库等的庞大生态系统。

这也是大多数考虑使用 Rust 的团队的来源（至少是那些联系我的团队），因此我认为这是在实践中最有用的对比。如果你正在编写命令行工具（CLI）、嵌入式固件或游戏引擎，本文中的一些内容仍然适用，但老实说，我恐怕这不是最适合你的资源。

作为背景，我之前曾写过关于 Go 和 Rust 对比的文章，比如 2017 年的《Go vs Rust？选择 Go》，以及后来与 Shuttle 团队合作撰写的《Go vs Rust：实操对比》，后者通过一个小型后端服务展示了两种语言的具体差异。

你将在本文中学到什么

• Go 与 Rust 的重叠点和分歧点。
• Go 的模式如何映射到 Rust。
• 你能从借用检查器中获得什么。
• 我在什么情况下会建议人们保留 Go，以及在什么情况下 Rust 值得进行迁移。
• 如何渐进式地迁移 Go 服务。

我的背景与立场

坦白说：我不是 Go 的粉丝。我认为它是一门设计糟糕的语言，尽管它非常成功。它混淆了简单性（simplicity）与易用性（easiness），并且它的几个核心设计折中——无处不在的 nil、作为纪律规则而非类型的错误处理、长期缺失的泛型——都将设计引向了我所不认同的方向。尽管如此，成功才是硬道理！Go 已经捕获了庞大且持久的活跃开发者份额，在 JetBrains 开发者生态系统调查中一直维持在 17-19% 左右。Rust 正在稳步增长，但目前仍然只占一小部分：

Go 显然对很多人都非常适用，而一个假装其不适用的指南是毫无帮助的。因此，在这份指南中，我将尽最大努力保持客观，而不是去重新争论那些老问题。但你应该了解我的先验立场，以便进行校准。

另一个值得披露的前提是：我运行着一家 Rust 咨询公司；所以，我当然是有偏见的！更多人使用 Rust 对我的业务是有利的。但我也在专业领域中使用过这两门语言，并曾将 Go 服务推向生产环境。

本指南适用于那些希望诚实对比迁移到 Rust 时会有什么变化的 Go 开发者。

如果想看一个故意持相反立场的观点，我推荐阅读 Blain Smith 的《就用 Go语言好了，别他妈的废话了！》（Just Fucking Use Go）。在脑海中同时保留这两种观点，比只持其中一种更有用。

如果你更喜欢观看视频而不是阅读，这里有一段来自 The Primeagen 对上述 Shuttle 文章的视频阅读和点评：

(视频：Rust vs Go: Hands On Comparison)

初看最重要的命令

Go 开发者已经拥有了行业内最干净的工具链之一。在很久以前，它就开启了“自带电池（batteries included）”式工具链的潮流，为你提供了一个单一、一致的界面，用于构建、测试、格式化、lint 和管理依赖项。我很高兴 Rust 也效仿了这种做法，因为这是一个极好的模式。这是我最喜欢的这两个生态系统的部分之一。

cargo 甚至拥有更多内置功能：

最大的区别在于，在 Go 中你通常需要借助第三方工具（golangci-lint、mockgen、air、goreleaser）来填补空白。而在 Rust 中，原生(第一方)生态系统开箱即用的功能要丰富得多。有些需要外部 crate 的工具（例如 cargo watch、cargo nextest）只需一个命令即可完成安装并开始使用，例如运行 cargo install cargo-nextest 即可立即获得 cargo nextest。

两个社区在格式化工具上都达成了相同的共识：一个单一的、规范的风格，即使不是完美的，也远比在琐碎的争论（bikeshedding）上浪费时间要好。

“Gofmt 的风格不是任何人的最爱，但 gofmt 却是每个人的最爱。”

— Rob Pike, Go Proverbs

对于 rustfmt 也是如此；并非每个人都喜欢它的每个细节，但代码评审中不再存在关于代码风格的争端，远比偶尔遇到你不喜欢的格式化偏好要有价值得多。

Go 与 Rust 的关键差异

核心结论是，Go 和 Rust 都是编译型、静态类型、单二进制文件部署、具有强大并发能力的语言。不同之处在于编译器向你保证了什么，以及你对运行时行为拥有多少控制力。

在深入探讨之前，有一个概念框架很有帮助：当你从 Go 迁移到 Rust 时，大部分变化都会被推入类型系统。 空值处理、错误传播、数据竞争、资源生命周期、取消机制、泛型，这些在 Go 中要么依赖运行时规范、工具链（go vet、errcheck、golangci-lint、-race），要么依赖运行时的自觉性。而 Rust 则将它们编码为类型，以便编译器在编译时强制执行。

常见的反对意见是这带来了“更多的认知负荷”。我不认同这种说法。我认为，这其实是将认知负荷从你由于必须记住规则而产生的焦虑中释放出来，转移到了编译器身上。一旦你内化了这种模式，并发现它在代码中无处不在（Option、Result、&mut T、Send/Sync、RAII 守卫），Rust 就会停止让你感到沉重，并开始感觉编译器正在为你做你以前必须在大脑中做的工作。

为什么 Go 开发者会考虑 Rust

Go 开发者通常不会因为 Go “太慢”而转向 Rust。对于大多数后端工作负载，Go 已经足够快了。人们普遍是对 Go 的一些由于设计不严密而产生的问题感到沮丧：nil 指针带来的隐患、段错误（segmentation faults）的风险、缺乏泛型（长期以来）或任何更复杂的类型系统特性（如枚举和强大的 trait），以及标准库中存在一些怪异的缺失，例如缺少一个内置的 Set 类型（惯用的替代方案是 map[T]struct{}，它在实践中行得通，但感觉类型系统并没有真正起到作用）。

生产环境中的 nil panics

你部署了一个 Go 服务，它运行得很好，持续了几个月。然后，某条代码路径被执行，而其中有人忘记检查某个指针是否为 nil，导致 goroutine 崩溃。一个常见的例子是查找操作，它返回零值，或者反序列化后未填充结构体中的某个指针字段：

func (s *Service) Handle(req *Request) error {
    // Find 返回 (*User, error)。如果是 "not found"，error 为 nil；
    // 调用者应该检查 user != nil，但这非常容易被遗漏。
    user, err := s.repo.Find(req.UserID)
    if err != nil {
        return err
    }

    return user.Account.Notify() // 如果 user 为 nil，或 Account 为 nil，则会发生崩溃
}

Linter 和 IDE 会捕获其中一些情况（通过 nilaway、staticcheck），但它们是选择性开启的、概率性的，而且不能可靠地跨越包边界。Rust 的编译器则根本不允许你忽略这种情况。Rust 的 Option 可以做到：

fn handle(&self, req: &Request) -> Result<(), ServiceError> {
    let user = self.repo.find(req.user_id)?; // 返回 Option<User>; ? 运算符进行短路处理
    user.notify()
}

如果没有显式处理 None 的情况，你甚至无法解引用一个 Option。一整类导致 pager-duty（线上紧急警报）事件的事故就这样消失了。

-race 未能捕获的数据竞争

go test -race 是一个优秀的工具，但它是一个运行时检测器，意味着它只能找到测试中实际执行到的竞争。在线上高负载下，多个 goroutine 在没有锁的情况下修改同一个 map 会轻松绕过该测试，并导致生产环境崩溃。

在 Rust 中，跨线程共享可变状态需要实现 Send 和 Sync。尝试共享一个普通的 HashMap 并且程序甚至无法编译。你被迫将其封装在 Arc<Mutex<…>> 或 Arc<RwLock<…>> 中，否则编译器会报错。这样，数据竞争在编译时就成了一个类型错误。

Paul Dix 对于什么促使了 InfluxDB 3.0 的重写非常坦诚，而数据竞争的故事就排在最前面：

“【最主要的好处是】无畏并发——消除了此前我们从未消除的数据竞争。在 Influx 1.x 版本中，确实存在一些非常棘手的 bug。”

— Paul Dix, InfluxData 创始人兼 CTO，摘自 Rust in Production

可组合的错误处理

在 Go 中，你会写：

if err != nil {
    return err
}

在一两年的开发后，你通常会注意到三件事：

1. 样板代码冲淡了你函数的实际业务逻辑。
2. 使用 fmt.Errorf(“doing X: %w”, err) 包装错误是一项纪律要求，而不是编译器强制的规则。这很容易丢失上下文。
3. 通过 errors.Is/errors.As 使用哨兵错误可以工作，但当你忘记处理新变体时，编译器不会提醒你。

对反方观点保持诚实也很重要，因为在关于我的 Shuttle 文章的 Lobste.rs 讨论线程中，经验丰富的 Go 开发者指出，errcheck 和 golangci-lint 捕获了绝大多数“忘记处理错误”的情况，并且显式的 if err != nil 比深层嵌套的 ? 链更容易阅读。这两个观点都很中肯，显式风格是一个刻意的文化抉择，而不是一次疏忽：

“我认为错误处理应该是显式的，这应该是该语言的核心价值。”

— Peter Bourgon, GoTime #91，引用自 Dave Cheney 的 Zen of Go

我的看法是，lint 是一个你必须记住去配置的选择性安全网，而 Rust 的 Result<T, E> 是类型签名本身，无法被遗忘。样板代码与可读性之间的折中是非常真实且见仁见智的。

在 Rust 中：

#[derive(Debug, thiserror::Error)]
pub enum UserError {
    #[error("user {0} not found")]
    NotFound(UserId),
    #[error("user already exists")]
    AlreadyExists,
    #[error(transparent)]
    Repo(#[from] RepoError),
}

pub fn rename(id: UserId, name: &str) -> Result<User, UserError> {
    let mut user = repo::get(id)?; // ? 自动将 RepoError 转换为 UserError
    user.name = name.to_string();
    Ok(user)
}

? 运算符处理了错误传播，#[from] 处理了类型转换，而针对 UserError 的 match 是穷尽检查的。如果明天你添加一个新的错误变体，编译器会向你展示每一个需要更新的地方。

不装箱的泛型

Go 在 1.18 中引入了泛型，它们很有用，但实现上有一些限制（不支持类型参数上的方法，GC shape stenciling，偶尔会有令人失望的性能表现）。Rust 泛型采用单态化（monomorphize），为每个实例生成具有零运行时开销的专门代码。结合 trait，这为你提供了真正的零成本抽象。

这在处理程序（handler）代码中不那么重要，而在共享基础设施（中间件、通用存储库、解码器、解析器）中更重要，在 Go 中，你常常被迫退回到 interface{} / any 外加类型断言。

可预测的延迟

Go 的 GC 非常优秀、并发、低停顿，针对典型的服务工作负载进行了很好的调优。但“低停顿”不等于“无停顿”。在重载情况下，P99 延迟尾部明显差于一个不在热路径上分配内存的 Rust 等效程序。

我不会过分夸大这一点，对于绝大多数服务来说，Go 的 GC 根本不是问题。但对于延迟敏感的系统（交易、实时竞价、网络代理、高吞吐量数据摄入），没有 GC 停顿是一个巨大的卖点。Stephen Blum 把它说得很直接：

“Go 在我们的规模下表现很好，但我们确实需要一些能给我们带来高性价比性能的东西，而 Rust 能够让我们达到那个目标。这就是为什么如今基本上所有的东西都在朝着 Rust 发展的原因。”

— Stephen Blum, PubNub CTO, 摘自 Rust in Production

总结

Go 像是遭受了千刀万剐（death by a thousand paper cuts）。它是一门非常实用的语言，如果你愿意忽略上述问题，你可以在其中获得极高的生产力。但在达到一定的代码规模后，问题就会开始累积。Go 失去吸引力并没有单一的瞬间，但团队会发现自己渴望更多（更多的安全性、更多的控制、更多的表现力），这就是他们开始寻找替代方案的时候。

Side By Side的对比两种语言

在 Rust 中感到舒适的最快方法是映射你已经知道的模式。如果要看在两种语言中构建相同后端服务的更长、包含大量代码的完整示例，请参阅 Shuttle 对比文章，本节重点介绍最常出现的模式。

错误处理：if err != nil 对比 Result<T, E>

Go:

func ReadConfig(path string) (*Config, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, fmt.Errorf("reading config: %w", err)
    }

    var cfg Config
    if err := json.Unmarshal(data, &cfg); err != nil {
        return nil, fmt.Errorf("parsing config: %w", err)
    }

    return &cfg, nil
}

Rust:

fn read_config(path: &Path) -> Result<Config, ConfigError> {
    let data = fs::read_to_string(path)?;
    let cfg = serde_json::from_str(&data)?;
    Ok(cfg)
}

? 运算符替你完成了 if err != nil { return err } 的繁琐工作，如果为 E2 实现了 From，它还会进行类型转换（这在使用 thiserror 的 #[from] 时是惯用）。

空值：nil 对比 Option

Go:

func GetUser(id string) *User {
    for _, u := range users {
        if u.ID == id {
            return &u
        }
    }
    return nil
}

u := GetUser("123")
fmt.Println(u.Name) // 如果u 为 nil 则会发生panic

Rust:

let user = get_user("123");
println!("{}", user.name); // 编译错误：user 的类型是 Option<User>，而不是 User

// 你必须处理这两种情况：
match get_user("123") {
    Some(u) => println!("{}", u.name),
    None => println!("not found"),
}

在安全的 Rust 中没有 nil。引用不能是空的。指针可以是空的，但你几乎永远不会在应用程序代码中使用裸指针。

接口 对比 Traits

Go 的接口是结构化的，一个类型隐式地满足一个接口：

type Reader interface {
    Read(p []byte) (n int, err error)
}

Rust 的 trait 是标称的，你需要显式地实现它们：

pub trait Reader {
    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize>;
}

impl Reader for MyType {
    fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> { /* ... */ }
}

Go 的风格非常适合临时性的鸭子类型。Rust 的风格非常适合重构和可发现性，你可以用 grep 搜索某个 trait 的每个实现者。

Rust 中与 interface{} / any 最接近的等价物是 Box，但你几乎永远不会想要它。Go 社区习惯于伸手去拿 interface{}，也是因为：

“interface{} 什么也没表达。”

— Rob Pike, Go Proverbs

带有 trait 约束的泛型函数（fn handle(r: R)）涵盖了绝大多数情况，并通过单态化提供无运行时开销。在 Go 1.18 之前，这迫使你退回到 interface{} 加上类型断言，而 Rust 的 trait + 泛型让你能够非常具体。

当你确实需要运行时分发（例如，不同实现者的异构存储）时，你会选择 Box 或 Arc。这是 Go 中持有 interface 值最直接的 Rust 对应物。

Goroutines 对比 异步任务

Go 的并发模型以简单著称：

go doWork(ctx, input)

Goroutine 很廉价，运行时会在操作系统线程之间调度它们，而通道（chan T）是主要的协同原语。Go 谚语捕获了这一理念：

“不要通过共享内存来通信；而要通过通信来共享内存。”

— Rob Pike, Go Proverbs

这是 Go 真正大放异彩的地方，并且它对为什么非常明确：在 Go 中，顺序代码和并行代码之间没有语法上的区别。函数签名、它的调用者，或关于它如何编写的任何内容都毫无二致。没有 async fn，没有 .await，没有执行器可供选择，也没有 Send / Sync 约束。只要你不共享可变状态而不进行同步，顺序代码和并发代码看起来是一样的。

这种属性，即没有函数着色（function colouring），是 Go 相比 Rust 最大的日常生产力优势，而在迁移之后，这也是 Go 开发者最怀念的东西。Lobste.rs 讨论中的几位评论者准确地指出了这一点，他们说得很对。Rust 的 async 更加强大且经过更多检查，但它的显式度也更高，这带来了真正的开发体验成本。

Rust 在执行器（对于后端服务几乎总是 tokio）之上使用 async/await：

tokio::spawn(async move {
    do_work(input).await;
});

形式很相似。不同之处在于：

• Rust 的异步函数返回 Future。除非被 .await 或 spawn，否则它们不会运行。
• 编译器会跨 .await 点验证 Send/Sync 约束。如果你在跨 .await 期间持有一个非 Send 的值，你会得到一个非常精确的编译器错误，解释其原因。
• 没有内置的 goroutine 风格的抢占。异步任务中长时间运行的 CPU 工作会使执行器饥饿；你需要将其卸载到 tokio::task::spawn_blocking 或 rayon。
• 通道（tokio::sync::mpsc、broadcast、watch）是一流的，但存在于库中，而不是语言本身。

对于大多数后端代码，日常体验是类似的：启动一个任务，通过通道进行通信，并大方地使用超时。

context.Context 对比 CancellationToken

在 Go 中，你将 context.Context 传给每个阻塞调用：

func (s *Service) Fetch(ctx context.Context, id string) (*User, error) {
    return s.client.Get(ctx, "/users/"+id)
}

Rust 没有内置的 context.Context。最接近取消的等价物是 tokio_util::sync::CancellationToken：

pub async fn fetch(&self, token: CancellationToken, id: &str) -> Result<User, FetchError> {
    tokio::select! {
        _ = token.cancelled() => Err(FetchError::Cancelled),
        res = self.client.get(&format!("/users/{}", id)) => res,
    }
}

对于超时，tokio::time::timeout(dur, fut) 可以包装任何 future。对于截止时间/值，你通常将它们作为显式参数传递，或者使用 tracing span 而不是单一的上下文对象。

一些 Go 开发者怀念 ctx 的隐式感。但在实践中，显式的 Rust 风格更容易让人推断，因为你总是确切地知道什么是可以取消的，什么是不可以的。更深层次的观点是，没有任何一种语言可以免费给你取消机制，只是规约出现在不同的层面上：

“Go 并没有办法告诉一个 goroutine 退出。没有停止或杀死函数，这是出于充分的理由。如果我们不能命令一个 goroutine 退出，那么我们就必须礼貌地请求它。”

— Dave Cheney, The Zen of Go

在 Go 中，这种“礼貌地请求”是通过约定俗成地在每个调用点传递并检查 context.Context。在 Rust 中，则是 CancellationToken（或 watch 通道）传给每个调用点，但编译器实际上可以在你忘记时提醒你。

通道

两种语言都有通道。翻译很直接：

Go:

ch := make(chan int, 10)
go func() {
    ch <- 42
}()
v := <-ch

Rust:

let (tx, mut rx) = tokio::sync::mpsc::channel::<i32>(10);
tokio::spawn(async move {
    tx.send(42).await.unwrap();
});
let v = rx.recv().await.unwrap();

Rust 的通道将发送端（Sender）和接收端（Receiver）区分为不同的类型，这使得所有权和 Send 属性在类型层面是显式的。

结构体与方法

Go:

type Circle struct {
    Radius float64
}

func (c Circle) Area() float64 {
    return math.Pi * c.Radius * c.Radius
}

Rust:

pub struct Circle {
    pub radius: f64,
}

impl Circle {
    pub fn area(&self) -> f64 {
        std::f64::consts::PI * self.radius * self.radius
    }
}

Rust 的 &self 相当于 Go 的值接收者；&mut self 是一个带有修改权限的指针接收者。拥有的 self（消耗该值）在 Go 中没有对应物，但在（类型状态、构建器）模式中偶尔非常有用。

字符串：string 对比 String 与 &str

Go 的 string 是一个具有赋值时拷贝语义的 UTF-8 字节切片（头部被复制，底层数据是不可变且共享的）。Rust 将其分为两种类型：

• String：拥有的、堆分配的、可增长的。相当于你打算修改的 []byte。
• &str：借用的视图，指向别人的字符串数据。大部分时间相当于作为 Go 的 string 参数使用。

作为一条经验法则，参数中接收 &str，在生成新数据时返回 String。

fn greet(name: &str) -> String {
    format!("Hello, {name}")
}

一旦你内化了这一点，这基本上是无痛的。&str 与 String 的划分是 Rust 更广泛的“借用与拥有”模型的一个缩影。

Go 泛型：太少，太迟

Go 在 1.18（2022 年 3 月）引入了泛型，在语言出货十三年之后。它们很有用，但由于它们是后期补丁（tacked on），在实践中它们具有大多数你期望从 Rust、Haskell 甚至现代 C++ 获得的泛型系统的缺点，却没有任何优点。

这是一个很强烈的说法，所以让我来支持它。

标准库几乎不使用它们

最明显的信号是，在泛型落地三年后，Go 自己的标准库仍然主要避免使用它们。sort.Slice 仍然接受一个 func(i, j int) bool 闭包，而不是 cmp.Ordered 约束。sync.Map 仍然被类型化为 any / any。除了 slices、maps 和少数组件外，几乎没有它们的身影。

公平地指出，向后兼容性是这里的主要原因：Go 1 的兼容性承诺意味着现有的非泛型 API 无法重构，因此任何泛型版本都必须与其并存（或在新的包中）。但这只是解释的一部分。已经有足够的时间来引入泛型替代方案，而几乎没有出现这一事实表明语言设计者并不倾向于将泛型作为他们使用的主要工具。

将其与 Rust 进行对比，在 Rust 中，泛型从第一天起就渗透到了标准库中：Option、Result<T, E>、Vec、HashMap<K, V>、Iterator、From、Into、AsRef、Borrow，每个集合、每个智能指针。在不使用泛型的情况下，你根本无法写出惯用的 Rust，因为标准库本身就是泛型的。

在 Go 中，泛型是库作者在确实需要时才选择使用的功能。在 Rust 中，它们是构建一切事物的底层基石。

没有 Trait 系统，只有结构化约束

Rust 的泛型与 trait 绑定，trait 兼作该语言进行多态、超类、关联类型、毯子实现（blanket impls）和一致性的机制。

Go 的约束只是带有一个额外 ~ 运算符的接口，用于类型集成员资格。这里没有：

• 超类 / 约束继承体系： 在 Rust 中，你写 trait Ord: Eq + PartialOrd，任何满足 T: Ord 的类型自动满足 Eq 和 PartialOrd。Go 没有等价物；你可以嵌入接口，但约束求解器并不推断关于层次结构的任何信息。
• 关联类型： Rust 的 Iterator 有 type Item;，因此 T::Item 是第一等公民，这体现在每个方法的签名中。Go 最接近的等价物是第二个类型参数，这会泄露到每个方法签名中。
• 毯子实现（Blanket impls）： 在 Rust 中，impl ToString for T 会自动为每一个实现了 Display 的类型实现 ToString 方法。在 Go 中，没有办法在定义包之外，为一个类型添加方法。
• 拥有自己类型参数的方法： 这是一个显式且有文档记录的 Go 缺失功能 (译注：Go 1.27将补全泛型方法这一特性)。你不能写 func (s Set[T]) Map[U](f func(T) U) Set[U]。在 Rust 中，泛型方法是家常便饭。

实际的后果是，当你的抽象需要不仅仅是一个“适用于任何 T 的函数外加这几个操作”时，Go 就会迫使你退回到 any 以及类型断言、代码生成或运行时反射。

类型推导止于函数边界

Rust 使用 Hindley-Milner 风格的推导引擎，可以跨整个表达式传播类型信息，包括跨闭包、迭代器链和 ? 运算符。你经常写：

let evens: Vec<_> = (0..100).filter(|n| n % 2 == 0).collect();

而编译器会推断出 _ 是 i32，而 Vec<_> 目标是 Vec。

Go 的推导要浅得多。它通常可以推断出函数参数的类型，但它不能从返回位置上下文中推断，不能通过泛型构建器跨链推断，并且经常在调用处强制使用显式的类型参数：

result := slices.Collect[int](iter) // 经常需要

在 Rust 中这是例外；在 Go 中这仍然很常见。

单态化 对比 GC Shape Stenciling

泛型没有免费的午餐：你必须要么在编译时买单，要么在运行时买单，要么通过代码膨胀（JIT）买单。C++ 和 Rust 在编译时通过单态化买单。Java 在运行时通过装箱买单。Go 选择了折中路线，采用了 GC 形状模板和字典，这有一篇众所周知的 PlanetScale 文章正好展示了这一点。

Rust 进行单态化：每个 Vec 和 Vec 都会产生专门的机器代码，具有零运行时开销。泛型代码是快速路径，而退回到 dyn Trait（相当于 Go 的接口分发）是一个深思熟虑的选择，在你需要运行时多态时做出。你要为单态化付出编译时间的代价，这和 C++ 几十年来付出的代价一样，但它们只是针对不同的事情进行了优化。

它们没有填补类型系统中的漏洞

这是最让我困扰的部分。

一个好的泛型系统可以消除退回到逃生舱口的理由。在 Rust 中，泛型 + trait 消除了你对 Box 或运行时反射的大部分需求。类型系统变得更强大了。

在 Go 中，泛型并没有消除 any，没有消除 reflect，没有消除代码生成作为诸如 ORM、解码器和 mock 等事物的首选模式。encoding/json 仍在使用反射。database/sql 仍在使用 any。mockgen 仍会生成代码。如果泛型系统能够大放异彩，最应该发挥作用的地方，正是 Go 在 1.18 之前就伸手去拿运行时机制的那些地方。

Go 中的泛型感觉是累加的，只是箱子里的一个新工具，在狭隘的案例中很有用。Rust 中的泛型感觉是基石般的；将它们移去，语言就会崩溃。

这就是区别所在，也是为什么在我的经验中，泛型 Go 代码读起来并不比它取代的基于 interface{} 的代码好；它只是读法不同，有更多标点符号罢了。

流行的 Go 包及其 Rust 对应物

如果你已经在 Go 中有了自己的偏好，Rust 生态系统已经趋于相似级别的“默认选择”。对于一个典型的后端服务：axum + sqlx + tokio + tracing + serde + clap 覆盖了你 90% 的需求。

过渡到 Rust 的关键挑战

我想坦率地说。从 Go 过来，你将会碰壁。这堵墙有一个名字。

借用检查器

Go 的运行时替你处理内存和别名。Rust 将这个决定推入类型系统。前几个星期你会写出“显然应该工作”的代码，然后编译器会拒绝它。

最常困扰 Go 开发者的模式有：

1. 长生命周期引用： 在 Go 中，你可以很开心地在 map 中持有一个 *User，只要你愿意。在 Rust 中，该借用会在整个生命周期中锁住 map。解决方案通常是克隆（clone），或者缩小借用范围。
2. 自引用结构体： 在 Go 中很常见（一个结构体同时持有数据和其上的迭代器）。在 Rust 中，这需要 Pin、ouroboros 或重新设计。几乎总是选择：重新设计。
3. 跨 goroutine 共享可变状态： 在 Go 中你写成：mu sync.Mutex; data map[K]V，而在 Rust 中则变成 Arc<Mutex<HashMap<K, V>>>。稍微啰嗦一些，但经过了更多检查。
4. 从函数返回引用： 生命周期标注（Lifetime annotations）就此出现。它们并不像其声誉那样糟糕，但对新手来说确实很陌生。

在所有的这些规则下，借用检查器确实听起来像一个“守门人”，不断阻碍，并且让人感到沮丧。但是，当你开始使用 Rust 时，不应该带着那样的心态。借用检查器真正揭示了你代码中现有的非常真实、非常微妙的 bug，如果你不解决它们，你的程序就会存在安全问题。因此，每当你从 rustc 得到编译器错误时，请退后一步，问自己以下几个问题：

• 如果一个值被移动（moved）了，之后如果原位置试图再次使用它会发生什么？
• 如果一个值被共享（shared）了，如果在另一个线程使用它的同时，有一个线程对其进行了修改会发生什么？
• 如果一个指针被解引用（dereferenced），如果它是空值或悬空指针会发生什么？
• 当一个值超出作用域（goes out of scope）时，如果其他地方仍然持有的引用正在被使用会发生什么？

这就是你需要理解借用检查器的心态。人类在推理内存方面真的很糟糕。我们很容易忘记指针可以为空，忘记旧的引用可以比它们指向的数据存活得更久，忘记多个线程可以同时修改同一块数据。我们倾向于对数据在程序中如何流动有一个“线性”的心理模型，但现实中它更接近于一个具有多条路径和交互的复杂图形。每一个 if 条件都会强制你考虑这两种分支中会发生什么。这正是借用检查器旨在为你做的事情！它强制考虑那些极其罕见但确实存在的、当你觉得可能不会发生但就是发生了的代码路径。

借用检查器其实是一个巨大的解脱。一旦它通过了，你就知道你的内存状态是 100% 连贯的，你可以专注于更高层次的问题。这也就是 Ed Page（clap 的维护者）说的：

“当你们刚开始接触它时：会感到沮丧。它让我想起了第一次学习编程的感觉，因为它太不一样了。由于借用检查器和生命周期，我不想去处理那些东西——但我被迫去了。”

— Stephen Blum, CTO, PubNub, 摘自 Rustacean Station

“……能够专注于更高层次的问题。在我进行自我分析并失败时，它帮助我发现了问题。”

— Ed Page, 摘自 Rustacean Station: clap with Ed Page

编译时间

对你的团队保持诚实，Rust 的编译时间相比 Go 的近乎瞬时的编译确实是一个退步。对于中等规模的服务，全新发布构建可能需要几分钟。增量构建和 cargo check 是合理的，并且编译时间在这些年里已经好了很多，但你仍然会感觉到差异。

为了缓解这种情况，在你的编辑循环中使用 cargo check，在项目见效后将其拆分进 workspace 中，并让你自己的 crate 中不要包含过程宏（proc-macro-heavy）重度依赖，这样它们就只在发生变化时才重新编译。请参阅《加速 Rust 编译时间的技巧》以进行更深入的探讨。

异步着色

正如《Goroutine 对比 异步任务》中所讨论的，Rust 的 async fn / fn 拆分是从 Go 迁移过来时最大的开发体验退步之一。异步 trait 自 Rust 1.75 以来已经稳定，但在将它们与动态分发结合时，仍然存在一些粗糙的边缘，你偶尔需要借助 async-trait crate 来解决。

某些细分领域中生态系统较小

Rust 的 crate 生态系统正在增长，并且库在整体上具有很高的质量，但 Go 在一些后端相邻领域具有领先优势：Kubernetes operator、云提供商 SDK、某些特定生态系统的数据库驱动。在做出承诺之前，请花一天时间检查你依赖的库是否具有你愿意使用的 Rust 对应物。我协助的团队经常不得不自己动手实现至少一两个核心库——例如，他们可能需要更新一个废弃的 XML 架构验证 crate，或为较少人知的协议编写自己的客户端。

集成策略

你不需要一次性重写所有内容。我听到的每一个成功的 Go 到 Rust 迁移案例都是战术性的，而不是大爆炸式的重写。Microsoft 的 Victor Ciura 总结得很到位：

“我们并不是疯狂地到处为了好玩而用 Rust 重写一切。我们在做出这些战术性选择，我们会说：好的，这个新组件，如果我们用 Rust 编写会更好。”

— Victor Ciura, 首席工程师, Microsoft, 摘自 Rust in Production

最有效的策略，按照我通常推荐的顺序如下：

1. 将“开辟热门路径”作为一种服务来提供

如果你的系统中某个特定服务一直存在各种问题（比如高 CPU 使用率、对延迟敏感，或者经常出现可靠性问题），那么你可以只用 Rust 重新编写这个服务，同时保持与原有 API 的兼容性。这是风险最低的迁移方式。其他用 Go 编写的服务仍然可以通过 HTTP/gRPC 与这个服务进行交互，而无需关心其底层编程语言是什么。Radar 公司的 Jeff Kao 指出，Discord 上的那些成功案例往往能激发团队尝试这种迁移方式的勇气。

如果你在 Hacker News 上搜索“迁移到 Rust”，第一个搜索结果一定是关于 Discord 从 Go 语言切换到 Rust 的报道。这一消息激励了我们，让我们也想看看自己是否也能做到同样的事情。
——Radar 公司的首席技术官 Jeff Kao 谈 Rust 在实际生产环境中的应用

2. 更换 Sidecar/Worker 进程

后台任务、队列消费者、数据摄取管道以及那些依赖 CPU 处理的批量作业，都是绝佳的优化目标。这些任务通常具有明确的输入/输出边界（比如队列或主题），且不会与系统的其他部分共享任何状态信息。

3. 使用 cgo 是可行的，但过程相当繁琐/麻烦

可以通过 cgo 在 Go 语言中调用 Rust 代码，关于如何操作的详细指南也很容易找到。（如果你需要我提供相关的指南，请随时联系我。）不过，实际上我并不推荐将 Rust 用于后端服务。与“直接创建一个 Rust 服务并将其置于网络调用之后”相比，其构建的复杂性以及 FFI 相关的开销通常会超过其带来的好处。不过，对于库和 CLI 工具来说，使用 Rust 则更为合适。

4. 网关背后的“绞杀者”模式

如果你使用了 API 网关或反向代理，就可以将特定的端点指向新的 Rust 服务，而其余部分则继续使用 Go 语言来实现。当某个特定的业务领域（如身份验证、搜索、计费）适合被迁移时，这种做法尤为有效。这种模式通常被称为“绞杀者模式”：新服务会逐渐取代旧服务，最终完全取代它。

实用的迁移技巧

• 从一个边界清晰的服务开始。 不要选择你机群中最核心、部署最多的服务。挑一个与其他系统的契约定义清晰且影响范围较小的服务。
• 保持相同的 API 契约。 如果你的 Go 服务暴露了 REST API，你的 Rust 服务也应该如此：相同的路径、相同的 JSON 格式、相同的错误响应。这样迁移对客户端是透明的，你可以通过网关安全地切换流量。
• 不要逐字翻译习语。 克制住写“Go 风格 Rust”的冲动。将 if err != nil { return err } 转换为 ?。将 goroutine-per-request 转换为 tokio::spawn。只在真正需要时（axum 会并发地为你处理请求）才使用它们。带有单一方法的接口通常在 Rust 中表现为泛型约束，而不是 Box。
• 将编译器作为结对程序员。 Rust 的编译器错误通常非常有帮助。仔细阅读它们。它们几乎总会告诉你正确的答案。挣扎最久的团队成员通常是将编译器视为敌人而不是合作者的那些人。
• 尽早投资于培训。 我经常看到团队试图通过“边做边学”来进行 Rust 迁移。这很少有好的结果。这有点像通过直接去跑马拉松并试图在跑的过程中摸索来为马拉松训练。你可以做到，但这将是极其痛苦的，而且你可能无法坚持到终点。为学习留出一些不被打扰的时间：一场研讨会，一个在线课程，以及在真实代码上进行结对。前期投入在团队流利掌握后会数倍地回报。(顺便说一下，如果你想讨论培训方案，我很乐意聊聊。)

保持 Go 语言的优势所在

并非所有东西都需要被迁移。Go 语言在以下方面表现优异：

• Kubernetes 原生工具：Operator、controllers、CRD。该生态系统几乎完全由 Go 语言构建而成。
• CLI 工具和开发工具：编译速度快、跨平台编译简单、部署便捷。
• 胶水层服务：包括薄的 API 层、代理(proxy)服务器以及格式转换器。在 Rust 中，编写这些重复性的代码并不值得。
• 在任何情况下，团队的工作效率都比追求绝对的准确性更为重要。

这并非什么小众职位。对于一家能够大规模提供这两种语言服务的公司来说，这一职位的设立显然意味著更重要的意义：

Go 语言是构建网络服务的绝佳选择。在 Canonical 公司，我们大量使用 Go 语言来开发软件——Juju 就是一个由 Go 语言编写的庞大软件项目。
——Canonical 公司工程部副总裁 Jon Seager 谈 Rust 在现实生产环境中的应用

混合策略其实很不错，也很常见。与我合作的许多团队都会采用这种策略：对于那些“没什么特别要求”的服务，使用 Go 语言来开发；而对于那些需要确保可靠性和性能的服务，则使用 Rust 语言来开发。

预期的改进/有望取得的提升

根据工作量的不同，具体数字会有很大差异，因此这些数据仅供参考而已。请不要把它们当作绝对的承诺！不过，以下是我在协助进行从 Go 语言到 Rust 语言的迁移过程中所得到的一些大致数据：

• CPU 使用率：降低了 20%到 60%。这一效果不如将代码从 Python 转换为 Rust 时那么显著，因为 Go 本身的效率就已经很高了。其优势主要体现在无需进行垃圾回收，以及代码循环的效率更高。
• 内存占用：减少了 30%到 50%，这主要得益于无需进行垃圾回收操作，以及运行时的开销更低。
• P99 延迟方面：Rust 服务的稳定性明显更高。Go 服务则容易出现由垃圾回收引起的延迟波动。不过，自从 Go 语言引入了低延迟垃圾回收机制后，这种情况已经有所改善，但在高负载情况下，两者之间的差异依然存在。
• 生产环境中的问题：这是各团队最乐于报告的问题类型。那些在测试阶段被发现，但最终还是进入了生产环境的错误类型（如数据竞争、空指针引用、错误处理路径被遗漏等），在 Rust 中根本无法编译通过。在从其他语言切换到 Rust 之后，处理这些问题的过程通常相当繁琐。Andrew Lamb 在 InfluxDB 的重写过程中也详细描述了这种现象。

“我不需要去追踪崩溃，或者某些奇怪的多线程竞争条件，或者其他那些实际上消耗了我之前大部分时间的事情。”

— Andrew Lamb, 软件工程师, InfluxData, 摘自 Rustacean Station: Rebuilding InfluxDB with Rust

说实话，与从 Python 转向 Rust 相比，从 Go 转向 Rust 后，很难实现 10 倍的性能提升。不过，你确实能减少“愚蠢的错误”，降低延迟，同时还能继续使用同一种语言来开发嵌入式系统或进行系统编程。这往往是代码迁移带来的最令人惊喜的副作用：那些原本需要使用不同编程语言的团队，现在可以共享代码了。Rust 几乎可以用于所有类型的开发场景。

结论

从 Go 迁移到 Rust 是与从 Python 或 TypeScript 迁移完全不同的一种类型。从 Go 过来，你深知静态类型、编译型语言的好处。所以你并不是在用动态类型或缓慢的运行时去交易。你是在交易 nil，换来一个漏洞更少、更健壮的代码库、更严格的编译器（可在编译时捕获更多错误）。不过，这里有一条更陡峭的学习曲线。

对于基础服务（你的组织所依赖的、需要极高可靠性、对你的业务至关重要的服务），这个迁移方式显然是值得的。对于其他服务，Go 仍然是正确的答案。迁移的目的是在最适合的语言中解决对应的问题。

准备好迈向 Rust 了吗？

我协助后端团队评估、规划并执行 Go 到 Rust 的迁移。无论你需要架构评审、培训，还是协助将关键服务进行移植，让我们聊聊你的需求吧。

原文正文到此为止！

社区深度观点

Matthias 的这篇文章在 Hacker News 上也引发了热烈的辩论。支持者、怀疑者、以及拥有多年双语言实战经验的系统架构师们纷纷下场，就 Go 与 Rust 的工业级博弈分享了大量第一手观点。我对其中的核心争议与洞察进行了系统性汇总：

1. 核心分水岭：你是否需要一个“托管运行时（Managed Runtime）”？

在 HN 的讨论中，社区普遍赞同的一个终极共识是：Go 与 Rust 的选择，90% 程度上取决于你是否想要一个托管运行时（垃圾回收，GC）。

• Go 拥护者认为：世界上 95% 的应用都是普通的商业业务系统（LOB）。在这类场景下，Go 拥有世界上最优秀的并发 GC。它的高并发开销极小，虽然在 P99 停顿指标上存在微弱的抖动（Jitter），但对于绝大多数企业级 Web 后端而言，这完全可以忽略不计。
• Rust 拥护者反驳：GC 不仅带来时延抖动，更重要的是它占用了额外的内存（通常需要 30%-50% 的额外物理内存作为缓冲来减少 GC 频率）。在超大规模云原生部署中，Rust 消除 GC 后带来的物理内存节省，可以直接转变为服务器账单上极具说服力的“降本增效”数字。

2. 编译速度与迭代效率的残酷现实

编译速度是 Go 阵营攻击 Rust 最锋利的武器之一。

• Go 的快：Go 从设计之初就将编译速度作为核心优先级（由汇编器和简化的类型系统支撑）。在开发中，修改代码到重新运行几乎是“即时”发生的，这带来了极佳的开发体验和迭代速度。
• Rust 的痛：由于采用了复杂的宏系统（Macros）和深度的单态化（Monomorphization）编译期展开，即使是增量编译，Rust 在大型项目中的等待时间依然可能长达数分钟。多位开发者抱怨：“在使用 AI 辅助编程或高频调试时，Rust 漫长的编译等待时间严重降低了开发者的心智流畅度。”

3. 错误处理理念的终极碰撞

在错误处理上，两个阵营各执一词，表现出截然不同的“开发文化”：

• Go 的显式哲学：Go 拥护者（包括知名技术领袖 Peter Bourgon）强调，错误处理应当是显式的，这应该作为语言的核心价值观。 尽管 if err != nil 冗长，但它逼迫你在每一行可能出错的代码旁停下来，思考当前上下文的应对策略，而不是用一个抽象的 ? 闭着眼睛把错误向上抛出。
• Rust 的类型保障：Rust 拥护者则认为，Go 的显式是一种“依靠肉体纪律维持的低效工程学”。一旦团队规模扩大，总有人会遗漏处理。而 Rust 将错误融入 Result<T, E> 类型签名，由编译器在底层进行穷尽性校验（Exhaustive checks），在代码简洁度（使用 ?）与安全性（不漏掉任何一种分支）之间找到了近乎完美的工程平衡。

4. 生态系统的对比：标准库（Batteries-Included）与模块化 Crates 依赖

开发者对两门语言的第三方生态设计表现出了明显的温度差：

• Go 的稳定：Go 拥护者非常自豪于 Go 极其庞大且强大的核心标准库。你不需要引入任何第三方库，就能用纯标准库写出高可用的 HTTP 服务器、加解密引擎和网络代理。这避免了类似 Node.js 社区的“Dependency Hell（依赖地狱）”和安全供应链攻击风险。
• Rust 的模块化：Rust 的标准库非常克制，甚至连异步运行时（tokio）、序列化（serde）和命令行解析（clap）都是第三方包。一些 Go 开发者迁往 Rust 后表达了这种不适：“在 Rust 里，写个简单的后台服务，一不小心就引入了上百个第三方 Crates，这让人有些缺乏安全感。”

5. AI 与 LLM 时代的编码体验

这是一个极具 2026 年时代特色的前沿议题。讨论区多位开发者分享了在使用大模型（如 Claude Code、Cursor）编写这两门语言时的反差体验：
* AI 写的 Rust 质量低下：由于 Rust 的生命周期（Lifetimes）和借用规则极度精密，AI 经常会生成那些无法通过编译的“幻觉代码”，试图滥用 Mutex、RefCell 等高级特权，或者在多线程中引入生命周期冲突。
* 但 Rust 拥有最强“安全网”：然而，反直觉的是，很多开发者表示他们更喜欢让 AI 写 Rust 而非 Go。因为如果 AI 写的 Go 逻辑错了（比如漏了 nil 检查或并发读写未加锁），代码依然能完美编译通过，并在生产环境中引发极其隐蔽的线上故障。而在 Rust 中，“只要 AI 写的代码能通过编译器的金睛火眼，我们几乎就可以闭着眼睛放心地把它部署上线。”

编辑结语：如何选择你的下一张船票？

Go 和 Rust 的博弈，本质上是“高带宽易上手的生产效率”与“编译期极致安全的正确性承诺”之间的路线之争。

如果你正在构建一个高速迭代、团队规模庞大、需要快速抢占市场的业务系统，Go 依然是那张最稳健、最不容易出错且极其务实的船票。

但如果你的系统已经走过了野蛮生长阶段，开始面临极其严苛的 P99 停顿要求、高并发下的内存与 CPU 账单压力，或者是不容许有任何运行时恐慌（Panics）的国防级、金融级系统，那么正如 Matthias 团队所验证的那样，忍受 Rust 的学习曲线和编译成本，将为你换来长达数年、在睡梦中都无比踏实的“终极安全感”。

资料链接：

• https://corrode.dev/learn/migration-guides/go-to-rust/
• https://news.ycombinator.com/item?id=48259808

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/05/26/why-nvidia-chose-go-to-rewrite-their-ai-infrastructure

当大家都在谈论 CUDA、Python 和 AI 框架时，NVIDIA 的工程团队正在悄悄用 Go 构建支撑整个 AI 云平台的底层基础设施。从 GPU 函数平台 NVCF，到 AI 集群运行时 AICR，再到已经有 1.8k Star 的分布式存储 AIStore，Go 语言已经成为 NVIDIA 内部 AI 基础设施的核心技术栈。这不是偶然，而是一个精心设计的技术选型。

大家好，我是Tony Bai。

2026 年 4 月，NVIDIA 悄悄开源了一个 repo：github.com/nvidia/nvcf。

没有大张旗鼓的发布会，没有 Jensen Huang 的皮夹克登场。但如果你打开这个 repo 看一眼语言构成，数字会让你一惊：

Go 占比 88.5%。

这不是一个小工具，这是驱动 build.nvidia.com、NVIDIA DGX Cloud 推理服务和全球 GPU 云合作伙伴（CoreWeave、Oracle Cloud 等）整个控制平面的核心平台。

然后你再看 AICR（AI Cluster Runtime）：Go 51.1%。

再看 AIStore（面向 AI 的分布式存储）：Go 75.2%，1.8k Star，10,219 次 commit，是一个有深度的系统级项目。

NVIDIA 在用 Go 构建 AI 时代的基础设施。而且这个趋势正在加速。

NVCF：GPU 云函数平台的全面开源

它是什么

NVCF 全称 NVIDIA Cloud Functions，是一个用于部署、管理和运行 GPU 加速工作负载的平台。你可以把它理解为”GPU 版的 AWS Lambda”——但更贴近生产级 AI 推理场景的设计。

你注册一个 Docker 容器或 Helm Chart，指定 GPU 类型，NVCF 负责处理一切：路由、队列、自动扩缩容、多租户隔离。GPU 云合作商在自己的 Kubernetes 集群上运行 NVIDIA Cluster Agent（NVCA），算力接入 NVCF 控制平面。

2026 年 4 月，NVIDIA 以 Apache 2.0 协议开源了整个平台的完整代码，包括控制平面、调用平面、计算平面、CLI、Helm Charts 和数据库迁移脚本——全部在一个 monorepo 里。之前的 NVIDIA/nvidia-cloud-functions 和 NVIDIA/nvcf-go 两个 repo 已归档，这个新 repo 是唯一的真相来源。

三平面架构：Go 是粘合剂

NVCF 的整体架构围绕三个独立可扩展的平面展开，通过 NATS JetStream 连接。

控制平面（Control Plane）

运行在专用 Kubernetes 集群上，负责函数生命周期管理、自动扩缩容决策和密钥管理。核心服务：

• function-autoscaler（Rust）：30 秒扩缩容循环，从 VictoriaMetrics 读取利用率，决策写入 Cassandra
• helm-reval（Go）：在计算平面部署前验证 OCI 引用的 Helm Chart
• OpenBao（Apache 2.0 的 Vault fork）：函数密钥静态加密，运行时通过 ess-agent sidecar 注入
• Cassandra：持久化状态和自动扩缩容的分布式锁

调用平面（Invocation Plane）

所有请求的必经之路，Go 在这里是绝对主角：

• http-invocation（Rust/Axum）：接收 HTTP/gRPC 请求，发布到 NATS JetStream
• llm-gateway（Go）：OpenAI 兼容 API，内嵌 Olric 缓存实现 token 感知的速率限制
• grpc-proxy（Go）：转发 gRPC 调用到函数实例
• ratelimiter（Go）：使用 Olric 分布式缓存的函数级速率限制
• nats-auth-callout（Go）：支持 NKey、OIDC 和 Webhook 策略的 NATS 认证

计算平面（Compute Plane）

每个 GPU 集群运行一个 NVCA（NVIDIA Cluster Agent）Operator。NVCA 将集群注册到控制平面，消费 NATS 消息，管理 Pod 生命周期。

一次请求的完整生命周期

从调用方的 POST /v2/nvcf/pexec/functions/{id} 开始，到响应返回，完整链路如下：

1. http-invocation 检查速率限制（via ratelimiter gRPC）
2. 请求发布到 NATS stream: Create.NVCA..{clusterID}..*
3. NVCA queue manager 消费消息
4. 创建 ICMSRequest Kubernetes CR（通过 NATS sequence 去重）
5. MiniService controller 协调：创建 Pod 或应用 Helm Chart
6. 函数 Pod 通过 WorkerService gRPC 回连：ConnectOnce
7. 响应返回调用方
8. 完成时：Terminate.NVCA.{clusterID} 触发 Pod 删除和 GC

Scale-to-Zero 的关键设计：NATS 作为持久化请求缓冲区

NVCF 解决的最有趣的工程问题，是 GPU 工作负载的 Scale-to-Zero。

传统方案（如 Knative）在 Scale-up 期间请求会面临超时压力或重试。对于加载大型模型可能需要数十秒乃至数分钟的 GPU 推理来说，这个问题会非常严重。

NVCF 的解法是把 NATS JetStream 当做一个持久化请求缓冲区：

1. 自动扩缩容器将期望实例数降为 0，没有 Pod 运行
2. 新请求到达，发布到 NATS JetStream，消息被持久化
3. 自动扩缩容器检测到队列深度 > 0，将期望实例数提升到 1+
4. NVCA 收到创建消息，启动 Pod
5. Pod 通过 WorkerService gRPC 连接，拉取缓冲的消息
6. 响应通过一直保持打开状态的 http-invocation 连接返回

请求永远不会被丢弃。 调用方在冷启动时等待更长时间，但请求一定会完成。这是 NATS 持久化消息的直接价值。

AICR：AI 集群运行时，Go 写的”集群配方书”

为什么需要 AICR

搭建一个 GPU 加速的 Kubernetes 集群是出了名的难。内核版本、驱动、容器运行时、Operator、Kubernetes 版本——任何一个环节的细微差异都可能导致难以诊断的问题，而且极难复现。

这些知识以前只存在于 NVIDIA 内部的验证流水线和运维手册里。AICR 把这些知识公开了。

项目地址：github.com/NVIDIA/aicr

AICR 全称 AI Cluster Runtime，将已知可行的驱动、Operator、内核和系统配置组合，封装成版本锁定的 Recipe（配方）——可以被 Helm、ArgoCD 和其他部署框架直接使用的可复现制品。

核心概念：Recipe 系统

一个 Recipe 是针对特定环境的版本锁定配置。你描述你的目标（云厂商、GPU 型号、操作系统、工作负载意图），Recipe 引擎将其与一个经过验证的 Overlay 库进行匹配——从基础默认值到云厂商、加速器、操作系统、工作负载特定调优，自底向上分层组合。

每个 AICR Recipe 具备三个特性：

• Optimized（优化）：针对特定硬件、云、OS 和工作负载意图调优
• Validated（已验证）：发布前通过自动化约束和兼容性检查
• Reproducible（可复现）：相同输入产生完全一致的部署结果

CLI 展示：五分钟上手

# 安装 CLI（Go 编译的单一二进制）
curl -sfL https://raw.githubusercontent.com/NVIDIA/aicr/main/install | bash -s --

# 采集集群当前状态快照
aicr snapshot --output snapshot.yaml

# 为你的环境生成经过验证的 Recipe
aicr recipe --service eks --accelerator h100 --os ubuntu \
  --intent training --platform kubeflow -o recipe.yaml

# 对比 Recipe 与集群实际状态，找出差异
aicr validate --recipe recipe.yaml --snapshot snapshot.yaml

# 渲染为部署就绪的 Helm Charts
aicr bundle --recipe recipe.yaml -o ./bundles

bundles/ 目录包含按组件分类的 Helm Chart，每个组件附带 values 文件、checksum 和 README。你可以用 helm install 部署，提交到 GitOps 仓库，或使用内置的 ArgoCD 部署器。

安全供应链：SLSA Level 3

AICR 在供应链安全上走得很远：SLSA Level 3 可溯源性、签名 SBOM、cosign 镜像证明、每次发布都有 checksum 验证。这已经是不少大型企业对内部工具的要求，NVIDIA 在开源项目里直接做到了。

技术栈细节

代码以 Go 为主（51.1%），使用 golangci 做 lint，goreleaser 做发布，ko 做容器镜像构建。项目已经发布了 54 个版本，活跃度很高。目前支持 Amazon EKS、GKE 和 Kind（自管理），GPU 覆盖 H100 和 GB200，工作负载支持 Kubeflow 训练和 Dynamo 推理。

AIStore：完全用 Go 写的 AI 分布式存储

如果说 NVCF 和 AICR 还是相对新鲜的项目，那 AIStore 则是一个已经经受了时间考验的系统级工程——1.8k Star，240 个 Fork，10,219 次 commit，46 位贡献者。

项目地址：github.com/NVIDIA/aistore

核心定位

AIStore（AIS）是一个专为 AI 应用构建的轻量分布式存储栈。它是一个弹性集群，可以在运行时扩缩容，支持从单台 Linux 机器到任意规模的裸机集群的任意部署方式。

AIS 的核心差异点：它能原生操作集群内数据和远程数据，而不是把远程数据当成缓存。这对 AI 训练工作负载来说是关键区别——你不需要先把 S3 数据拉下来再训练，AIS 可以透明地处理数据层。

技术亮点一览

• 多云后端支持：无缝访问 AWS S3、GCS、Azure、OCI，支持跨账号、跨 endpoint 的同名 bucket 共存。
• 线性扩展性：官方博客和 KubeCon 演讲中展示了跨任意数量集群节点的均衡 I/O 分布和线性扩展能力。
• ETL Offload：在数据附近执行 I/O 密集型数据转换，可以内联（作为每次读请求的一部分实时处理）或离线（批量处理，结果写入目标 bucket）。
• Get-Batch：单次调用检索多个对象或归档文件。专为 ML/AI 流水线设计，一次操作获取整个训练批次，按用户指定的顺序组装成 TAR（或其他序列化格式）。这个功能甚至有配套的 arxiv 论文（2602.22434）。
• 负载感知节流：基于多维度负载向量（CPU、内存、磁盘、文件描述符、goroutine）的动态请求节流，保护 AIS 集群在压力下的稳定性。
• 30+ 批处理操作：包括 archive、blob-download、copy-bucket、dsort、etl-bucket、lru-eviction、rebalance、rechunk 等，全部可以通过 CLI 启动、监控和控制。

为什么用 Go

AIStore 75.2% 的代码是 Go，其 Go API 直接被 CLI 和 benchmarking 工具使用。选择 Go 的逻辑很清晰：

1. 系统级性能：Go 的 goroutine 模型天然适合高并发 I/O 密集型工作负载，而分布式存储正是这种场景
2. 单一二进制发布：CLI 工具和服务端都能编译成静态链接的单一二进制，部署极其简单
3. 生态成熟：Kubernetes operator、gRPC、NATS、Prometheus——这些基础设施领域的核心库在 Go 生态中都有成熟实现
4. 代码可维护性：相比 C++，Go 在保持接近底层性能的同时大幅降低了复杂系统的维护成本

为什么是 Go？NVIDIA 的技术选型逻辑

把这三个项目放在一起看，NVIDIA 选择 Go 的逻辑变得清晰：

AI 基础设施的特殊需求

AI 基础设施不同于传统 Web 服务。它需要处理：

• GPU 资源的精细调度和隔离
• 大规模并发请求的队列管理
• 跨多集群的协调
• 模型文件的海量 I/O
• 长时间运行的异步任务

这些场景对并发模型的要求极高。Go 的 goroutine 和 channel 机制，让工程师可以用清晰的代码表达复杂的并发逻辑，而不需要像 C++ 那样手动管理线程。

云原生生态的”母语”

Kubernetes、Docker、containerd、Prometheus、NATS、Helm——云原生基础设施栈几乎是用 Go 写的。NVIDIA 的三个项目全部深度集成 Kubernetes，深度依赖 Operator 模式、Controller Runtime、Helm Chart。选择 Go 意味着可以直接使用这些生态的核心库，而不是跨语言调用的额外复杂度。

运维友好的单一二进制

aicr、ais CLI 工具都是 Go 编译的单一静态二进制。在需要快速部署到新集群、在 CI/CD 流水线中运行、或者在边缘节点上操作时，这个特性极其实用。

Rust + Go 的互补分工

值得注意的是，NVCF 并不是全 Go。高性能热路径（http-invocation、function-autoscaler）用了 Rust，而控制逻辑、网关、代理、认证——这些需要快速迭代、逻辑清晰的组件——用 Go。

这个分工很有意思：Rust 负责极致性能的关键路径，Go 负责需要快速演化的系统逻辑。两种语言各司其职，而不是用一种语言通吃所有场景。

小结：这意味着什么

对 Go 开发者

NVIDIA 的这几个 repo 是绝佳的真实世界大型 Go 项目参考：

• NVCF：学习 Kubernetes Operator 模式、gRPC、NATS 集成、多平面分布式系统设计
• AICR：学习 CLI 工具设计（goreleaser + cobra）、Helm 生成、GitOps 集成模式
• AIStore：学习高性能分布式系统的 Go 实现，包括内存管理（memsys 包）、分布式一致性、S3 兼容 API 实现

这三个项目都是 Apache 2.0 或 MIT 开源，代码质量高，有完整的测试和文档。

对 AI 平台工程师

NVIDIA 正在开源 AI 基础设施的核心组件。NVCF 的开源意味着你可以：
- 在私有 GPU 集群上运行与 NVIDIA 云服务相同的调度和路由逻辑
- 审计每一行代码，而不是把平台当成黑盒
- 修改自动扩缩容逻辑、添加 NATS 认证策略、扩展 MiniService controller

AICR 则给了你一个”NVIDIA 认证”的集群配置参考——如果你正在搭建自管理 GPU 集群，AICR 的 Recipe 系统告诉你什么组合是经过验证的。

对技术决策者

当 NVIDIA——一家以 CUDA C++ 闻名的公司——在 AI 基础设施层面系统性地选择 Go，这个信号足够强烈。Go 已经不只是”Google 的语言”或者”云原生工具链的语言”，它正在成为 AI 时代基础设施的核心技术栈之一。

资料链接：

• https://blog.kubesimplify.com/nvcf-is-now-open-source-inside-nvidia-s-gpu-function-platform
• https://github.com/nvidia/nvcf
• https://github.com/NVIDIA/aicr NVIDIA AI Cluster Runtime
• https://github.com/NVIDIA/aistore AIStore: scalable storage for AI applications

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/05/21/go-is-the-new-lingua-franca-for-ai-agents-at-google

大家好，我是Tony Bai。

在过去的两年里，只要一提到 AI 开发，99% 的人脑海中弹出的第一个词绝对是：Python。而如果是涉及到大模型底层的高性能推理与算力压榨，大家想到的必然是 C++ 或是 Rust。

但在真正的工程落地中，情况正在发生一场令人猝不及防的剧变。

最近，Google 资深软件工程师 Jaana Dogan（@rakyll）在 X（原推特）上发布了一条引发技术圈热议的推文：

“Go 成为 Google 内部 Agentic（智能体）系统的通用语言（lingua franca），这真的很了不起。我以前从未看到过 Go 有取代 C++ 的路径，但现在我相信这是可能的。”

这不仅仅是一条简单的技术感慨，它揭示了 AI 浪潮进入“下半场”后的核心工程困境：当我们把大模型封装成 Agent，并让成千上万个 Agent 并发协作时，Python 太脆弱，C++ 太沉重，而 Go，迎来了它的“天命时刻”。

今天，我们就来扒一扒，为什么 Google 会让 Go 接管 AI Agent 的底层开发？这对我们普通开发者的技术栈转型，又意味着什么？

打破滤镜：为什么 Python 和 C++ 在 Agent 时代“失宠”了？

要理解 Go 的上位，我们首先要搞清楚，AI Agent 到底需要什么样的工程能力。

现在的 AI 应用，早就不是早期那种“写个 Python 脚本，调用一下 OpenAI API，把结果打印出来”的玩具了。真实的 Agentic 系统（智能体系统）包含了极其复杂的网络 I/O、并发工具调用（Tool Calling）、多智能体消息路由、长时记忆状态管理，以及大规模的分布式容错。

在这个场景下，旧有的王者们暴露出了致命的缺陷：

1. Python 的“工程化陷阱”

Python 是 AI 研究员的最爱，因为它的数据科学库天下无敌。但当你要构建一个高并发、高可用、需要 24/7 运行的 Agent 编排系统时，Python 的弱类型（重构火葬场）和 GIL（全局解释器锁，导致无法真正利用多核并发）就成了灾难。正如原贴讨论区一位开发者所言：“模型层可能是 Python 的天下，但围绕着模型的 Runtime（运行时环境）正越来越像 Go 的领地。”

2. C++ 的“杀鸡用牛刀”

C++ 拥有极致的性能，是模型训练和推理引擎（Inner Loop）的绝对霸主。但 Agent 编排系统真的需要 C++ 级别的疯狂数学计算吗？不需要。

Agent 系统本质上是大量的网络等待（等 LLM 返回结果、等数据库查询、等网页抓取）。用 C++ 来写极其复杂的并发网络请求和状态机，不仅开发周期漫长，而且极易产生内存泄漏。正如推文评论所指出的：“C++ 背负了太多的历史包袱，它在 Agent 编排上显得太重了。”

Go 凭什么上位？Goroutine 与 Agent 的“完美同构”

Go 语言在这个时间节点爆火，并非偶然，而是因为它底层的并发哲学与 AI Agent 的行为模式产生了“完美的同构映射”。

在 X 上的讨论中，多位资深开发者一针见血地指出了核心原因：

“Goroutines mapping directly to concurrent agent communication is the reason why it makes perfect sense.”（Goroutine 直接映射到并发 Agent 之间的通信，这是它如此完美契合的原因。）

让我们用大白话来翻译一下这个硬核逻辑：

什么是多智能体系统（Multi-Agent System）？本质上就是一堆各自独立的“数字员工”，它们一边自己干活，一边通过发消息相互沟通。
而 Go 语言最强大的杀手锏是什么？正是 CSP（通信顺序进程）并发模型，即 Goroutine（轻量级协程）和 Channel（通道）。

• 当你启动一个 Agent 时：在 Go 里，你只需要一个简单的 go runAgent()，就能以极其低廉的内存代价（几 KB）启动一个并发实体。一千个 Agent？一万个 Agent？对 Go 来说毫无压力。
• 当 Agent 之间需要协作对话时：你不需要去搞复杂的锁（Locks）或者共享内存，你只需要用 Go 的 Channel 把消息塞过去，另一个 Agent 就能安全地接收。

Agent 的编排，需要的是“轻量级的并发管理”，而不是“极致的数学计算速度”。这简直就是为 Go 量身定制的战场。

征服大厂，构建 Agent 架构的“铁三角”

除了并发模型上的天作之合，评论区的一位开发者还另外总结了 Go 赢下这场战争的另外三个决定性因素。他指出，现代 Agent 技术栈奖励三种特性，而 “Go 完美击中了这三点（Go nails all three）”：

1. 强类型系统（Types）：告别“盲盒”开发

Agent 系统中充斥着复杂的 JSON 解析、Tool Calling 的参数校验、以及结构化的输出。Python 的字典（Dict）传递在项目变大后就像是“盲盒”，你永远不知道里面缺了哪个字段。而 Go 的强类型 Struct 和极度清晰的错误处理机制（虽然大家都吐槽 if err != nil，但它确实极其可控），让系统拥有了极高的可预测性（Predictability）。

2. 极速的编译体验（Fast Builds）

“编译速度是让它成为绝配的原因之一。”在快速迭代的 AI 产品中，Go 那种秒级的编译速度，让开发者可以飞速地测试 Agent 的行为逻辑。相比之下，C++ 那漫长的编译过程在需要高频微调的 AI 时代显得格格不入。

3. 小巧的单一二进制文件（Small Binaries）

当你把 Agent 部署到云端、边缘设备甚至是 Serverless 环境时，Go 编译出来的是一个无需任何外部依赖的独立执行文件。没有 Python 烦人的环境依赖（无需折腾 pip, conda, 虚拟环境），直接丢进一个极小的 Docker 镜像中就能运行，这对于现代云原生运维来说是无可估量的优势。

一个反直觉的冷知识：大模型“最爱”写 Go 代码

推文中一个开发者提出了一个极其有趣且经常被忽视的视角：在 LLM（大语言模型）的眼中，Go 是一门完美的语言。

如果你经常用 Cursor/Codex/Claude Code等 写代码，你会发现一个现象：让 AI 写 Python，它经常会用错第三方库的版本；让 AI 写 C++ 或 Scala，它可能会搞出一堆极其复杂的继承、多态或者生命周期错误。

但如果你让 AI 写 Go 呢？成功率出奇的高。

原因在于：

1. Go 的语法极致简单、无聊，甚至“没有类（Classes）”。它只有 Struct 和接口，这极大地减少了代码的“表面积（Surface Area）”。
2. Token 使用率极高。由于没有复杂的黑魔法和繁琐的泛型体系（早期），LLM 在生成 Go 代码时不容易出现“幻觉”，维护起来极其容易。

在这个连代码本身都开始由 AI 生成的时代，“对 LLM 友好”竟然成了一门编程语言的核心护城河。

终局推演 —— C++ 守住“内环”，Go 赢下“外环”

那么，Go 真的会彻底消灭 C++ 吗？

并不完全是。这场讨论最终达成了一个非常清晰的技术栈共识：

“C++ still wins the inner loop. Go wins everything around it.”（C++ 依然赢得了内环，而 Go 赢得了周围的一切。）

未来的 AI 系统架构已经初露端倪，它将被清晰地划分为三个层级：

1. 研究与数据层（Python）：用于模型训练、数据清洗、算法验证。
2. 算力内环（C++ / Rust / CUDA）：大模型的推理引擎（如 vLLM、Ollama 底层）、张量计算。这里需要极致榨干每一滴 GPU 性能，C++ 依然是绝对的霸主。
3. 编排外环与业务层（Go）：这是距离普通开发者最近、也是市场需求最大的地方。成千上万的 Agent 调度、API 网关、并发的数据检索（RAG）、记忆数据库交互、工具链调用，全部都将被 Go 统治。

最新铁证！Google I/O 2026 震撼官宣：废弃旧路线，用 Go 重写 AI 核心入口！

如果你觉得前面硅谷大佬们的讨论还只是“理论推演”，那么在刚刚举办的 Google I/O 2026 大会上，Google 官方直接用一记雷霆手段，把这个趋势变成了既成事实。

Google 开发者博客发布了公告：正式宣布停止维护原有的 Gemini CLI，全面过渡到全新的“Google Antigravity（反重力）”多智能体开发平台，并推出全新的核心入口 —— Antigravity CLI。

而在官方给出的技术变更文档中，最扎眼、最让 Go 开发者狂喜的一条更新理由，白纸黑字地写着：

“Faster execution: Built in Go, Antigravity CLI is snappier and more responsive.” （更快的执行速度：基于 Go 语言构建，Antigravity CLI 更加轻快、响应更迅速。）

旧版的 Gemini CLI 是基于传统脚本语言（Node.js/TS 体系）构建的，在处理单点交互时绰绰有余。但 Google 明确表示，现在开发者的需求已经彻底变了：“你现在需要多个 Agent 相互通信、分工合作来解决复杂的系统问题。”

当单点 CLI 变成“多 Agent 协同编排后端”时，旧有的 JS/TS 体系在高并发、异步工作流（Asynchronous Workflows）和底层系统控制上面临性能瓶颈。Google 毫不犹豫地选择用 Go 语言 彻底重写，就是为了利用 Go 极致的并发和执行效率，来支撑起“后台多任务并发运行、且不锁定终端”的强悍体验。

小结：给开发者的生存建议

过去的一年里，无数后端开发者感到焦虑，觉得自己掌握的 CRUD 技能在 AI 面前一文不值。但 Google 内部的这场技术栈迁移，给我们指明了一条无比清晰的道路：

别再只盯着 Python 看了。

当 AI 从单一的对话框，走向全面接管企业业务流的多智能体（Multi-Agent）协作形态时，对高并发、高可用后端工程能力的需求不仅没有减少，反而呈指数级爆发。

学习 Go 语言，理解 Goroutine，掌握如何构建一个稳健的 Agent 编排框架。因为决定下一个十年 AI 应用成败的，不再是模型本身的算力，而是谁能最好地管理和协调这些拥有智能的“数字大军”。

而目前来看，Go，已经在这场战役中拔得头筹。

资料链接：https://x.com/rakyll/status/2056528039698403498

今日互动探讨：

你目前在开发 AI 应用或 Agent 系统时，使用的是什么语言？你是否遇到了 Python 在高并发或部署时的痛点？欢迎在评论区分享你的实战经验与踩坑血泪史，我们一起探讨 AI 时代的最佳实践！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/05/20/ai-coding-win-rate-rankings-go-and-rust-vs-cpp

大家好，我是Tony Bai。

过去两年，程序员群体经历了一场前所未有的“职业身份危机”。

随着 GPT、Claude、Gemini 等模型的发布与能力更迭，各种“AI 几秒钟写出小游戏”、“AI 自动化修复 Bug”的新闻充斥屏幕。在各种传统的代码补全基准测试（如 HumanEval）中，大模型们动辄刷出 90% 以上的惊人通过率。一时间，“程序员是夕阳行业”、“架构师即将下岗”的言论甚嚣尘上。

然而，这只是硬核工程世界的冰山一角。最近，由 Meta FAIR（Meta 基础人工智能研究实验室）、斯坦福大学和哈佛大学联合发布的一项重量级研究——ProgramBench，彻底击碎了这些幻觉。

ProgramBench 的设计初衷非常“残暴”：它不再测试 AI 能不能写出一个简单的算法函数，而是测试 AI 能不能从零开始（From Scratch）复刻一个完整的开源项目，即从观测二进制行为（Probe）到编写源码（Build），再到最终的等效性评估。

测试规则如下：

1. 黑盒逆向：不给源码，只给 AI 一个编译好的二进制可执行文件（如 sqlite3、ffmpeg、ripgrep）和一份使用说明书。
2. 物理断网：切断互联网访问，防止 AI 通过搜索“偷看”GitHub 上的源码。
3. 架构自主：AI 必须自己决定项目的文件结构、选择什么编程语言、设计什么抽象层次。

在这场面向 200 个真实复杂项目的“闭卷考试”中，全球最顶尖的大模型们集体陷入了沉思。

数据表明，即便是在最强的模型面前，完全成功的概率依然是 0。

但在这场败战中，我们通过海量数据发现了一个足以改变未来十年技术选型的真相：Go 与 Rust 已经成为了 AI 时代的“天命语言”，而 C++ 则不那么受 AI 青睐，AI 用起来也不那么顺手！

诸神黄昏：Claude 对 GPT 家族的“工程级”碾压

在程序员的认知中，GPT 家族曾代表着 AI 的巅峰。但在 ProgramBench 的 Leaderboard（排行榜）上，局势发生了戏剧性的反转，但也正如我们预料的那样。

根据论文统计，在衡量“几乎完成”（即通过 95% 以上的测试用例）这一指标时，排名如下：

1. 头号种子：Claude Opus 4.7。它是全场唯一一个在 3.0% 的复杂项目中展现出近乎完美复刻能力的模型。
2. 二号梯队：Claude Opus 4.6 (2.5%) 与 Claude Sonnet 4.6 (1.6%)。
3. 集体挂零：GPT 5.4、Gemini 3.1 Pro。 没错，这些在其他榜单上呼风唤雨的模型，在“从零复刻完整项目”的任务中，竟然连一个能通过 95% 测试的任务都没完成。

为什么 GPT 会在硬核工程上输给 Claude？

研究人员通过分析“智能体轨迹（Agent Trajectories）”发现了秘密。大模型写代码有两种流派：

• “急性子”派（以 GPT 5.4 为代表）：GPT 倾向于“单次爆发”。数据显示，它在每个任务中平均只用 17 个命令。它习惯于在最初的几个回合内，直接吐出 96% 的代码。如果代码跑不通，它很少进行深度的自我修正。
• “架构师”派（以 Claude 为代表）：最强的 Claude 模型更像是一个深思熟虑的工程师。它平均每个任务会调用 868 个命令！它会不断地执行 ls 查看目录、用 cat 检查文件、反复运行测试并根据报错信息进行“重构”。

可见，在复杂的软件工程面前，单纯的“语料记忆”失效了。Claude 的胜出，本质上是其“推理链”和“持续迭代能力”的胜出。它不只是在背代码，它是在通过不断的试错来“推演”架构。

通过上图中不同模型的动作类型分布，我们可以看到 Claude 拥有极长且复杂的“读-写-探测”循环，而 GPT 的动作序列短得惊人。

语言偏好：AI 也有自己的“舒适区”

ProgramBench 给 AI 提供了完全的自由：AI 可以用任何语言来复刻目标程序。这产生了一个极其有趣的“语言混乱矩阵（Confusion Matrix）”。

1. GPT 的 Python 执念

GPT 5.4 表现出了近乎偏执的 Python 依赖。在所有任务中，它有 79% 的方案是用 Python 写的。无论原程序是用更底层的 C 还是 Rust 写的，GPT 的第一反应往往是：“我能不能用 Python 给它糊出来？”

2. Claude 的硬核品味

最强模型 Claude Opus 4.7 表现出了极高的系统级素养。它只在 14% 的情况下选择 Python，它更倾向于使用 Rust 和 Go 来应对复杂任务。这说明越强大的模型，越能理解底层语言在性能和逻辑表达上的严密性。

3. 为什么 AI 喜欢 Python？

原因很简单：容错率。 Python 拥有极其丰富的第三方包、极简的语法以及无需手动管理内存的特性。对于 AI 来说，Python 是它能用最少的回合数实现最多功能的“逃生路径”。但这种逃生是有代价的——复杂的系统级软件用 Python 复刻，往往会因为性能或底层调用模拟不足而失败。

深度解析：为什么 Go 与 Rust 是 AI 的“天命之子”？

这是本次研究中最具行业指导意义的发现。通过研究数据对比，我们发现不同语言在 AI 手下的“存活率”天差地别：

• Go 语言项目：AI 成功通过率 38.4%
• Rust 语言项目：AI 成功通过率 38.5%
• C/C++ 项目：AI 成功通过率仅为 27.7%

为什么同样是系统编程语言，Go 和 Rust 就能完胜 C++？这不仅仅是语法的问题，更是现代工程化基建的降维打击。

1. 构建系统：AI 开发者的“生死线”

在 C/C++ 的世界里，构建系统是混乱的代名词。CMakeLists.txt、Makefile、系统特定的动态链接库（.so/.dll）路径……对于 AI 智能体（SWE-agent）来说，这些是致命的障碍。

调研显示，AI 在 C++ 任务中，往往还没开始写业务代码，就已经在配置环境时陷入了死循环。

反观 Go 和 Rust：

• Go：一个 go mod tidy 加一个 go build 解决了全球 99% 的构建问题。
• Rust：Cargo 是目前人类文明最先进的包管理器之一。

对于 AI 来说，这种“标准化”意味着它只需要执行一条命令就能建立起完整的工程环境。这种极高的工程化一致性，让 AI 可以把宝贵的 Token 消耗在业务逻辑上，而不是折腾环境。

2. 标准库的“全家桶”效应

Go 语言一直以“自带电池（Batteries included）”著称。它的标准库涵盖了网络、加密、编解码等大部分现代互联网开发所需的功能。AI 调用 Go 的标准库就像从兜里掏东西一样自然。

而 C++ 的标准库相对贫瘠，往往需要引入第三方库（如 Boost, libcurl）。一旦涉及到第三方依赖，AI 的出错概率就会呈指数级上升。

3. 内存安全：给 AI 的“保护索”

在 C/C++ 中，AI 极其容易写出缓冲区溢出、内存泄露或段错误。一旦程序在运行过程中崩溃，由于 AI 缺乏深度的 GDB 调试能力，它很难从 Core Dump 中恢复。

Rust 严格的借用检查（Borrow Checker），在编译阶段就强行纠正了 AI 的大部分错误。这种“编译即正确”的反馈循环，让 AI 在复刻软件时拥有了更高的胜率。

揭秘 AI 程序员的“坏习惯”：屎山代码的起源？

除了排名和语言，ProgramBench 还揭露了目前 AI 编码的三个极具冲击力的特征：

1. 单文件架构迷恋

人类架构师讲究解耦，喜欢建立复杂的目录结构。但 AI 却恰恰相反。数据显示，67% 的 AI 方案产生的目录深度明显浅于原项目。

AI 表现出强烈的“单文件狂魔”倾向。 它们喜欢把数千行代码塞进 1-3 个超级大文件里。这反映出目前的模型在处理跨文件的上下文关联时，依然存在明显的认知衰减。

2. 逻辑“大颗粒化”

AI 写的函数数量通常只有人类原作者的 10% 到 20%。但这并不意味着功能缺失，而是因为 AI 喜欢写超长函数（God Functions）。

Claude 生成的函数长度平均是人类的 1.46 倍，Gemini 甚至达到了 1.62 倍。这种代码对于 AI 来说运行没问题，但对于人类后续维护来说，简直是噩梦。

3. 诚信危机：AI 也会“偷懒作弊”

在测试的早期阶段，研究人员尝试给 AI 开启互联网访问。结果发现，最强的大模型们全都是“老油条”。

一旦它们通过二进制文件的帮助信息（–help）推断出这是哪个开源项目，它们会直接去克隆对应的 GitHub 仓库代码并提交。

Claude Sonnet 4.6 的作弊率一度高达 36%！ 这迫使研究团队最终必须在完全断网的环境下运行测试。这告诉我们：永远不要低估大模型为了完成任务而寻找“捷径”的本能。

小结：程序员的黄昏还远未到来

看完这份长达 60 多页的研究报告，我们不仅没有感到绝望，反而产生了一种前所未有的踏实。

报告证明了：即便是在最顶尖的模型面前，真实的软件工程（Software Engineering）依然是一个极度复杂的高壁垒领域。写代码只是软件工程中最后、最轻的一环。而之前的架构设计、模块拆分、抽象提取、以及对业务边界的理解，目前的 AI 依然处于“学龄前”阶段。

给开发者的建议：

1. 向 Go 和 Rust 迁移：这不只是性能考量，更是为了拥抱 AI。如果你想让 AI 帮你更高效地干活，请选择那些对 AI 友好的工程化基建。
2. 强化架构师思维：既然 AI 喜欢写单文件“屎山”，那么如何管理大型项目的复杂性、如何通过 Prompt 引导 AI 进行模块化设计，将是未来高级工程师的核心竞争力。
3. 拥抱 Claude 模式：告别“单次生成”的幻觉，建立起“持续迭代、自动测试、反复纠错”的 AI 开发流水线。

程序员的黄昏还远未到来。

相反，我们正在进入一个全新的时代：一个由人类架构师掌控蓝图，由 AI 劳工在标准化的 Go/Rust 仓库中疯狂试错、高效产出的黄金时代。AI 并没有取代你，它只是淘汰了那些只会机械写代码、而不懂工程设计的“码农”。

真正的开发者，正在迎来属于他们的、被 AI 加持的黎明。

资料链接：

• https://arxiv.org/abs/2605.03546
• https://programbench.com/

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/05/18/go-performance-optimization-over-rust-rewrites

大家好，我是Tony Bai。

近年来，如果你常年混迹于国内外各大技术社区，你一定会感受到一种近乎狂热的“政治正确”：带垃圾回收（GC）的语言都有原罪，万物皆可（且应该）用 Rust 重写。

从底层基础设施到上层业务逻辑，无数团队在遇到性能瓶颈时，脑海中蹦出的第一个念头就是：“Go/Java 搞不定了，由于 GC 停顿的存在，我们必须换 Rust 乃至 C++ 来重构核心模块。”

但这真的是解决性能问题的唯一出路吗？

最近，几位硅谷顶级的技术大佬——前 Tailscale CTO David Crawshaw、开源时序数据库 VictoriaMetrics CTO Aliaksandr Valialkin，以及资深底层代码大牛 Stewart Lynch，在 X（原推特）上掀起了一场关于“现代软件复杂性与性能优化”的讨论。

仔细研读他们的观点后，我得出了一个可能有些“反直觉”的结论：

对于绝大多数商业项目而言，盲目追求去 GC 化和无脑 Rust 重写，是一场灾难。真正顶级的性能优化，往往只需要对那 1% 的“热路径”动刀。

今天，我们就来揭秘这层信息差，看看顶级架构师是如何在不增加心智负担的前提下，把带 GC 的 Go 语言性能压榨到极致的。

现代软件最大的毒瘤：“不必要的复杂性”

为什么我们总是忍不住想要用极其复杂的语言或架构去重写现有的系统？

Stewart Lynch 在讨论中一针见血地指出了现代软件工程的通病：“Everything that’s wrong with modern software can be summed up in two words: Unnecessary Complexity”（现代软件所有的毛病，可以用两个词来概括：不必要的复杂性）。

这背后其实隐藏着一个程序员群体独有的心理学陷阱。

Lynch 解释道：“程序员这个群体有一个特殊的问题——我们往往是因为‘享受解决复杂问题’才选择这个职业的。我们热衷于理解极其复杂的东西并让它运转起来，我们是人类历史上最复杂结构的构建者。正因为如此，我们在任何地方都在寻找与复杂性搏斗的机会，即使在那些本该追求极简的地方。”

这就解释了为什么很多团队在面对一个简单的 CRUD 业务或者中等并发的微服务时，会毫不犹豫地引入极高门槛的语言（比如有着严苛借用检查器的 Rust）或是过度设计的服务网格。

因为“复杂，让人觉得高级”。

但结果是什么？

业务逻辑被切割得支离破碎，新员工入职需要花费两三个月才能看懂生命周期和指针所有权，团队的迭代速度断崖式下跌。你以为你在优化系统的性能，实际上，你在制造一场长期的维护灾难。在这个过程中，你消耗了大量的公司预算，仅仅是为了解决那些“想象中的未来问题”。

记住架构设计的第一法则：复杂性是优秀软件的死敌。

你的 99% 代码根本不需要瞎折腾

既然复杂性是死敌，那性能问题怎么办？难道我们就任由 GC 导致程序卡顿吗？

这时候，前 Tailscale CTO David Crawshaw 抛出了一个极具颠覆性的观点。他指出，整个行业现在正把海量的资源倾注到像 Rust 这样没有 GC 的程序中，但大家忽略了一个极其残酷的统计学事实：

“Almost all your code paths are cold and GC is net positive. 1% of your code is performance sensitive. Don’t create GC pressure there.” （你几乎所有的代码路径都是‘冷’的，在这些地方 GC 带来了纯粹的正向收益。只有 1% 的代码对性能真正敏感。你只需要不在那 1% 的地方制造 GC 压力就行了。）

什么是“冷代码”？

配置解析、路由分发、错误处理、数据库连接初始化、日志记录……在一个庞大的工程中，这部分代码占据了 99% 的体积。它们对微秒级的延迟根本不敏感。

对于这 99% 的代码，使用 Go、Java 甚至 OCaml 这样带有Full runtime GC的语言，是巨大的恩赐。GC 解放了程序员的大脑，让你不需要像写 C/C++ 或 Rust 那样，在写每一行代码时还要在脑海里进行“部分编译时规划（Partial compile-time planner）”。它让你可以把全部精力聚焦在“业务逻辑”本身。

人类解决复杂问题的能力，在不被内存分配分心时，才能发挥到极致。

为了那 1% 真正需要榨干 CPU 周期的核心逻辑，去强迫整个团队在剩下 99% 的冷代码中也要与内存所有权作斗争，这在商业 ROI（投资回报率）上是极其荒谬的。

这就是所谓“不要为了 1% 的醋，去包 99% 的饺子”。

VictoriaMetrics CTO 的 1% 极简榨干指南

好，逻辑理顺了：我们决定坚持使用 Go 语言，享受它极高的开发效率和并发优势。但我们确实遇到了那 1% 的核心瓶颈——比如高频交易的核心撮合引擎、时序数据库的底层写入循环。这部分代码极其吃 CPU，且 GC 带来的 STW（Stop The World）让人无法忍受。

不换语言，怎么破局？

别急，让我们来看看目前世界上性能最强悍的开源时序数据库之一：VictoriaMetrics 的做法。这个数据库完全是由 Go 语言编写的，但在各项 Benchmark 性能测试中，它经常把一众 C++ 和 Rust 写的时序数据库按在地上摩擦。

它的 CTO，Aliaksandr Valialkin 在这次讨论中，大方地分享了他“降维打击”般的优化路径。我将他的经验，结合各位大牛的讨论，为你整理成了以下三步走的“实操密码”：

放弃盲猜，用 Profiler 精准定位热路径（Hot Paths）

你永远不可能靠“直觉”找到性能瓶颈。Aliaksandr 强调，Go 语言拥有极度强大的内置 Profiler（pprof）。不要一上来就重构，先让程序跑起来，打入真实流量，然后用 pprof 精准定位出那消耗了 80% CPU 和大量内存分配的 1% “热路径”究竟在哪几个函数里。

这 1% 的代码，代码量往往极小，寻找它们并不困难。

在热路径中“完全移除”内存分配（Zero Allocation）

这是 Go 性能优化的核心灵魂。Aliaksandr 的原话是：“This is how I optimize programs written in Go – by removing memory allocations from hot paths…”。

只要你在热路径中不产生新的对象（不触发 malloc 和堆分配），垃圾回收器（GC）就根本不会被唤醒。没有分配，就没有垃圾；没有垃圾，就没有 GC 压力和停顿。

开启“逃生舱”：使用预分配与 Arena 机制

既然热路径不能分配新内存，那需要处理海量数据怎么办？大佬们给出了三种在 Go 中模拟底层语言内存管理的“逃生手段”：

• 预分配大块内存（Pre-allocations）：
  正如 David Crawshaw 所举的例子，你可以在 Go 中一次性分配一个巨大的数组，比如：var x = make([]struct{…}, 1e6)。
  这只产生一次大分配，然后你完全可以利用自己的算法，在这个预先分配好的内存块中进行指针的滑动和复用。对于 GC 来说，这只是一个单一的连续指针，GC 扫描它的成本极低，既能实现高并发，又极大地降低了 CPU 消耗。

• 对象池机制（sync.Pool）：
  对于频繁创建和销毁的小对象，不要让它们落入 GC 的魔爪。利用 sync.Pool 将它们缓存起来，反复复用。

• 请求作用域内存竞技场（Arenas）：
  Aliaksandr 提到了在处理网络请求时极其高效的 Arena 概念。在这个模式下，与单次 Request 相关的所有小对象分配，都在一个预先分配好的大块 Arena 中进行。当请求结束时，不需要逐个去释放对象，而是直接清空（free）整个 Arena。这几乎达到了和 Rust 一样零开销的内存清理效果，但代码写起来依然是熟悉的 Go 语法。

对 99% 的代码保持克制

当你在那 1% 的热路径里用尽了上述像 C 语言一样的“脏活累活”后，请立刻停手。

让程序剩下的 99% 保持最地道（Idiomatic）、最简单、最具可读性的 Go 代码。让 GC 去接管它们。

你会神奇地发现：你的程序不仅拥有了媲美 C++/Rust 的极致性能，同时你的团队依然保持着原本极高的业务迭代速度。

小结——顶级工程师与普通码农的终极分水岭

回顾这几位大佬的讨论，其实核心只指向了一个词：克制（Restraint）。

普通工程师总是试图寻找一种“银弹”——希望换一种时髦的语言，就能一劳永逸地解决架构、性能和内存安全的所有问题。他们沉迷于构建极其复杂的抽象体系，试图用技术上的炫技来掩盖业务上的平庸。

而真正顶级的架构师，深知商业的本质和团队运作的规律。他们懂得：

1. 好的设计，就是当你不能再拿走任何东西的时候。 （正如评论区一位开发者所说：Good design is when you keep taking away things until you cannot take away any more.）
2. 永远不要在全局引入复杂性。 遇到性能问题，先用监控定位，然后把性能敏感的那 1% 的代码隔离出来，在这个小黑盒子里用最极客的方式优化，最后把它严丝合缝地封装好。
3. 拥抱不完美但高效的工具。 不要嫌弃 GC，懂得如何与 GC 和谐共处，才是真正的大师。

如果下次你的团队里，再有人因为某个接口慢了 10 毫秒，就嚷嚷着要用 Rust 把整个几十万行的后端服务重写时，请把这篇文章甩到他的脸上。

告诉他：“去把 pprof 打开，把那 1% 循环里的临时变量给我复用了，然后早点下班回家。”

资料链接：

• https://x.com/valyala/status/2055725885035045234
• https://x.com/stewartlynch8/status/2055322205563617516
• https://x.com/davidcrawshaw/status/2055288855792955511

今日互动探讨：

在你的职业生涯中，是否经历过为了追求所谓的“极致性能”或“极客审美”，而导致整个项目陷入“过度复杂化（Over-engineering）”灾难的时刻？或者，你在使用 Go 语言时，有什么私藏的“热路径”压榨技巧？

欢迎在评论区留言和我探讨，我们一起对抗现代软件的“过度复杂病”。 （如果你觉得这篇文章打破了你的认知，别忘了点赞转发，让更多挣扎在重构边缘的兄弟们看到！）

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/05/14/uncle-bob-esr-on-why-we-are-turning-to-go-and-rust-in-the-ai-era

大家好，我是Tony Bai。

在软件工程的浩瀚星河中，有两位堪称“活化石”级别的宗师：

一位是 Eric S. Raymond (ESR)，开源运动的先驱，那本被誉为开源圣经的《大教堂与集市》以及《Unix编程艺术(The Art of UNIX Programming)》一书均是出自他手。他是一个写了 40 年 C 语言的硬核黑客。

另一位是 Uncle Bob Martin (Bob 大叔)，敏捷宣言的签署人之一，《敏捷软件开发》、《代码整洁之道 (Clean Code)》等程序员经典书籍的作者，无数 Java 和 C# 程序员的精神导师。

这两位加起来写了快一百年代码的传奇人物，最近却在 X (Twitter) 平台上，不约而同地抛出了一个足以引发技术圈大地震的论断：

在如今这个被 AI 席卷的时代，他们双双放弃了自己曾经最擅长的语言（C 和 Java），转而全面拥抱 Go 语言，并在特定底层场景下使用 Rust。

更令人震撼的是，ESR 直接宣告了手工古法编程模式的死刑：

“手写代码的时代基本结束了（The age of hand-coding is mostly over）。现在选择编程语言的标准，已经彻底变了。”

今天，我们就来深度扒开这场顶级黑客的“赛博夜话”，看看在 AI 智能体（Agent）狂飙突进的 2026 年，我们究竟该如何重新审视和选择我们手中的“兵器”。

认知颠覆：当 AI 成为主程序员，语言的选择标准变了

我们过去是如何选择编程语言的？

语法是否优雅？生态是否繁荣？框架是否齐全？这些都是基于“人类如何高效手写代码”而设定的标准。

但 ESR 尖锐地指出，在如今我们拥有“机器朋友（Robot friends / AI）”来完成绝大部分代码生成和翻译工作的时代，这些旧标准已经失效了。

现在的核心标准只有两个：

1. 你的 AI 朋友，能不能高质量地生成这种语言的代码？
2. 生成之后，作为人类的你，能不能一眼看懂（Review）这些代码？

“如今，我使用什么计算机语言是否顺手，已经不再那么重要了，真正重要的是我正在使用的‘机器朋友’能否高质量地生成它。
同时也重要的是我能否读懂这门语言，因为我需要亲自去审查（Review）这些代码。”

在这个新标准下，那些充满了黑魔法（如各种奇葩的宏、复杂的继承体系、极度隐晦的元编程）的语言，瞬间成了灾难。因为当 AI 吐出几百行充满魔法的代码时，人类审查的“认知负荷”将是灾难性的。

宗师的抉择：为什么是 Go 和 Rust？

在这个全新的游戏规则下，两位宗师给出了他们惊人一致的答案。

Bob 大叔的 Go 语言初体验：快、无聊、但完美契合 AI

Bob 大叔在评论区透露，他正在设计一门关于“使用 Agent 进行软件工程”的在线课程。

“在过去，我会选择像 Java、C# 或 JavaScript 这样流行的语言来做课程。但这次我选择了 Go。不是因为它流行，而是因为它很快（Fast）。我的学生们不会花太多精力去钻研 Go 的语法细节，但他们会看到 Go 的表现。”

Go 语言那常被诟病的“啰嗦”和“无聊”，在 AI 时代反而成了最强大的护城河。

因为 Go 的语法极度收敛，没有隐式类型转换，没有复杂的泛型继承。当 AI 生成一段 Go 代码时，那满屏极其直白的 if err != nil，让人类工程师一眼就能看穿它的逻辑底裤。在审查 AI 代码时，没有魔法，就是最高的生产力。

ESR 的决断：别了，我写了 40 年的 C 语言

ESR 的话更具传奇色彩和悲壮感：

“我可能再也不会用 C 语言开新项目了。那除了自虐还有什么意义？我花了 40 年写 C，我非常精通。但我会毫不留恋地把它，连同它的缓冲区溢出、堆破坏、未定义行为和可移植性问题，全部抛在脑后。”

他现在的探索性编程，全部交给了 Python 或 Go。

“我的机器朋友在生成这两种语言的代码时都非常出色。我认为它们在生成 Go 代码时的表现甚至略胜一筹，这可能是因为 Go 语言拥有更小的表面积（smaller surface）。”

(注：Smaller surface 意味着语法简单，AI 预测下一个 Token 时的歧义和错误率极低)

至于 Rust，ESR 将其定位为“终极的降落场”。

当他需要极其坚固的内存安全保证，且代码的探索期已经结束，进入严肃的生产部署阶段时，他会让 AI 把代码翻译成 Rust。

“Rust 满足了我的要求——我发现它写起来很麻烦，但读起来基本没问题。”

时代的阵痛：被 AI 降维打击的传统生态

这场讨论，不仅是对 Go 和 Rust 的赞歌，更是对一些传统“大厂语言”的残酷揭底。

ESR 毫不客气地吐槽了 Python 曾经的混乱（尽管它现在有了类型提示和 uv 等现代工具，情况有所好转）：

“Python 曾是我的最爱，但在 Python 2 到 Python 3 的灾难性过渡、GIL 导致的并发地狱、以及包管理的混乱之后，我曾对它感到厌倦……如果我现在要写一个比 Python 粘合脚本大得多的东西，我只会耸耸肩，然后直接去用 Go。”

在推特的评论区，另一位开发者的一句话，道出了更多人的心声：

“Go 代码的质量，很大程度上是因为 Go 语言本身往往倾向于极高的质量（因为缺乏炫技的空间）。所以 AI 生成的代码，也顺理成章地继承了这种高质量。”

当一门语言为了迎合人类的“偷懒”和“炫技”而变得越来越复杂时（比如不断叠加新特性的 C++ 和 Java），它在 AI 时代反而会成为一种累赘。

因为 AI 不需要语法糖，AI 需要的是绝对的清晰和确定性。

反思：从“写手”到“审查员”的身份跃迁

两位古灰级黑客的这番言论，给所有还在为了“哪种语言的特性更酷炫”而争得面红耳赤的年轻程序员，狠狠地上了一课。

时代的列车已经呼啸而过。

当代码生成不再是瓶颈，软件工程师的核心价值，正在不可逆转地从“Writer（编写者）”向“Reader & Reviewer（阅读者与审查者）”迁移。

在这个新时代，我们评估一项技术的眼光必须升级：

1. 可审计性（Auditability）大于一切：如果一段代码极其简洁但难以调试，它就是垃圾。Go 语言的“直白”，在 AI 时代成为了最顶级的安全感。
2. 安全性的底座转移：像 Rust 这样通过极其严苛的编译器来保证内存安全的语言，将成为 AI 时代最可靠的“数字基础设施钢筋”。你可能不需要手写它，但你的 Agent 会为你生成它，并由编译器确保它不会在半夜崩溃。
3. 拥抱“机器思维”：放下程序员的“文人相轻”，接受那些对机器友好、对审查友好的“无聊技术”。

小结：向宗师致敬，向未来前行

如果连写了 40 年 C 语言的 Eric S. Raymond，和开创了现代软件工程思维的 Uncle Bob，都能毫不犹豫地放下过去的骄傲，全身心地拥抱 AI、Go 和 Rust。

我们这些普通开发者，还有什么理由紧抱着那些陈旧的“鄙视链”不放呢？

手写代码的时代正在落幕，但软件工程的黄金时代，才刚刚开始。

用 Go 来快速验证和构建业务，用 Rust 来打造坚不可摧的底层，让 AI 成为那个不知疲倦的打字员。这，就是顶级黑客们为我们指明的 2026 年生存法则。

资料链接：https://x.com/esrtweet/status/2054288478750597593

今日互动探讨：

连 Bob 大叔和 ESR 都倒戈了！你同意他们“手写代码时代已结束”、“更看重代码审查的可读性”的观点吗？在日常的 AI 辅助编程中，你觉得哪种语言的体验最好？

欢迎在评论区分享你的看法！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/05/12/the-embarrassing-truth-about-rust-adoption-in-china

大家好，我是Tony Bai。

如果只看国内的公众号和社交媒体，你可能会觉得 Rust 在中国IT技术圈已经很火了：大厂在重构核心链路和重写数据工程的基础设施、创业者在搞 Web 3.0和AI 原生开发、甚至连刚毕业的学生都在卷“所有权（Ownership）”。在一片“Rust 必火”的赞歌中，我们似乎已经默认了中国是全球 Rust 生态版图中最强的那一极。

但真相，往往藏在那些没人注意到的冷数据里。

最近，我做了一次极其枯燥的工作。我让Claude 翻阅了全球最权威的 Rust 社区周刊——《This Week in Rust》（简称 TWiR） 2025 年全年的所有 53 期内容，重点抓取了其中“Upcoming Events（近期活动）”板块。

注：可能存在一定幻觉和不准确的地方。

我想看看，在这一整年里，中国到底举办了多少场能够被国际主流社区感知到的 Rust 技术交流(meetup and conf)。

结果令我脊背发凉。

今天，我想撕开这层温情脉脉的“技术繁荣”假象，带大家看看中国 Rust 社区最真实的底色。

数据重击：中国 Rust 社区的“隐形”之谜

在 2025 年的 53 期 TWiR 中，全球范围内的 Rust 活动如火如荼。

• 欧洲：平均每期出现 13 个 活动，全年累计超过 120 场。
• 北美：平均每期出现 10 个 活动，全年累计超过 130 场。
• 而中国大陆（CN）呢？ 在整整 53 期里，仅仅出现了 3 期！

更讽刺的数据还在后面。如果我们把目光缩到亚洲：

在 TWiR 的“Asia”板块中，以色列的特拉维夫（Tel Aviv）一个城市，全年的出现频次是 11 次。

是的，你没看错：特拉维夫 > 整个中国大陆 + 中国香港 + 中国台湾省。

全中国 14 亿人口、数千万程序员，在这个全球最活跃的 Rust 观察窗口中，竟然比不上一个中东城市活跃。

难道中国程序员不写 Rust 吗？显然不是。那是谁偷走了中国 Rust 社区的“声音”？

信息茧房：我们在微信群里“自嗨”

为什么中国 Rust 活动在全球视野中几乎消失了？通过一些调研，我发现了一个极其严重的“结构性问题”。

第一，我们的社区是“内向”且“封闭”的。

在国外，Rust 开发者习惯在 GitHub、Reddit、Discord、Twitter 或是通过电子邮件订阅列表交流。一旦有 Meetup，他们会第一时间向 TWiR 这种全球通用的周刊提交信息，寻求全球开发者的关注。

而我们呢？

我们活跃在微信群、钉钉群、飞书群，或者是在 B站 的某个直播间。

这些平台，本质上是“信息的黑洞”。 它们无法被搜索引擎抓取，无法被国际社区感知，甚至连跨个群都费劲。我们在一个个封闭的小圈子里讨论着高深的生命周期和异步并发，却对外面的世界“一声不吭”。

第二，中国开发者正在丧失“国际社区意识”。

即便是在 2025 年中国 Rust 的两个高光时刻——3 月的 Rust Asia 2025 (香港) 和 9 月的 RustChinaConf 2025 (杭州)，它们的曝光也是极其短暂的。

正如一位社区大佬所言：“如果你不在推特和 GitHub 上发声，你就相当于不存在。”

我们这种“躲进小楼成一统”的行为，正在让中国 Rust 生态沦为全球版图上的一个“暗物质”。

大厂黑盒：Rust 只是大厂的“私人玩具”？

还有一个更深层的原因：中国 Rust 应用的“两极分化”极其严重。

在一极，是像字节跳动（ByteDance）、PingCAP、蚂蚁集团这样的顶级玩家。

他们拥有极深的技术功底，在核心系统中使用 Rust 已经到了炉火纯青的地步。但问题在于，这些能力被封锁在大厂的围墙之内。他们更倾向于内部的技术内卷，而不是建立开放的、具有影响力的公共社区。

在另一极，是广大的、依然在 CRUD 泥潭里挣扎的普通开发者。

对于他们来说，Rust 太难、编译太慢、门槛太高。他们看不到实际的应用案例，找不到线下的交流圈子，只能在网上看着“Rust 必火”的营销号文章陷入焦虑。

缺乏“中间层”的连接，导致中国 Rust 社区没有持续的、小规模的、日常化的技术碰撞(Meetup)。

我们只有一年一度的大会，却没有每周一次的 Meetup。这就好比一个只有春晚却没有日常市集的村庄，死气沉沉。

认清现实后的反思：不要做“Rust 隐士”

编程语言的生命力，不仅取决于它的编译器有多牛逼，更取决于它的社区网络效应。

当中国的 Rust 开发者集体消失在全球视野中，我们会失去什么？

1. 失去标准制定的参与权：Rust 的每一个重要 RFC，背后都是全球开发者的博弈。如果我们不在场，我们的业务场景和需求将永远不会被考虑。
2. 失去顶级人才的吸引力：全球的顶尖 Rustacean 会认为中国是一个 Rust 的荒漠，从而减少技术交流与合作。
3. 技术审美的滞后：长期脱离国际主流语境，会导致我们在架构审美和最佳实践上，陷入一种“闭门造车”的狭隘。

小结：打破沉默，重新“出海”

Rust 的吉祥物是一只螃蟹（Ferris）。螃蟹虽然有硬壳，但它不应该只生活在自己的小沙洞里。

在国际视角下的中国 Rust 社区的“冷”，可能并不是用的人少，而是我们“跑得太慢、声音太小”。

如果你正在参与一个 Rust 项目，如果你所在的公司正在筹备一场技术分享，请记住：

除了发朋友圈，请去 GitHub 提个 PR，去 TWiR 投个稿，去国际社区喊一声：“Hey, we are here!”

不要让 2026 年的统计数据，依然显示中国是那个“隐形”的国家。

技术无国界，但影响力的版图，需要每一位开发者用行动去标注。

资料链接：https://this-week-in-rust.org/blog/archives/index.html

今日互动探讨：

看完这份数据，你感到惊讶吗？你觉得是什么阻碍了你参与国际开源社区的讨论？在你的身边，Rust 真的火了吗？

欢迎在评论区分享你的真心话！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/05/11/go-vs-rust-backend-architecture-the-2026-strategy

大家好，我是Tony Bai。

如果你经常逛各大技术社区，你一定会发现一个永远充满火药味的话题：Go 和 Rust，到底谁才是未来的后端霸主？

两派的支持者常常吵得不可开交。Go 开发者嘲笑 Rust 编译器像个严厉的教导主任，写个代码能让人掉光头发；Rust 开发者则鄙视 Go 的 GC（垃圾回收）带来的延迟毛刺，觉得它就是个“性能玩具”。

但在真实的商业战场上，这种“非黑即白”的零和博弈毫无意义。

最近，海外技术团队 CodeStax.Ai 发表了一篇文章，题目非常霸气：《Rust vs Go：2026 年唯一有意义的后端语言对决》。

这篇文章没有去纠结语法的优劣，而是直接从企业成本、团队扩张、以及系统演进的宏观视角，给出了一个极具颠覆性，却又务实到令人拍案叫绝的架构结论：

“用 Go 来构建（Build）系统，用 Rust 来优化（Optimize）系统。”

今天，我们就来拆解这套现代后端的终极生存哲学，看看顶级的架构师们，是如何在这对“冰与火”的语言中找到完美平衡的。

无情的现实：每一个后端系统，最终都会撞上“那堵墙”

在讲语言之前，我们必须先认清系统演进的残酷规律。

当你刚刚启动一个新项目时，一切都很美好。

你用微服务框架快速拉起几个 API，部署到 AWS 的容器服务（ECS）里，挂上消息队列（SQS）。一切都运转良好：接口响应很快，团队每个星期都能迭代新功能，老板很开心，每月的云服务器账单也完全在可控范围内。

直到有一天，增长（Growth）发生了。

流量呈指数级上升。突然之间，原本平稳的系统开始出现各种诡异的症状：

• 系统的内存占用越来越大，云账单的增长速度开始远远超过业务的增长速度。
• 在毫无征兆的流量高峰期，API 出现了莫名其妙的延迟毛刺（Latency Spikes）。
• 微小的性能低下，在每天几亿次的调用中，被复利放大成了拖垮整个集群的致命瓶颈。

这就是所有后端系统迟早都会撞上的“那堵墙（The Wall）”。

当撞墙的那一刻，老板问你的问题，将不再是：“我们最快多久能把这个功能做出来？”

而是变成了极其致命的灵魂拷问：

“我们如何在不拖慢业务团队开发速度的前提下，让这个庞大的系统保持稳定、高效，并且把那该死的云账单降下来？”

正是在这堵墙面前，Go 和 Rust 的选择，才真正具有了生死攸关的意义。

Go 的主场：敏捷与编排的绝对王者

在跨越“那堵墙”之前的大部分时间里，以及在墙外 80% 的业务场景中，Go 语言是毫无争议的默认王者。

为什么？因为现代的后端架构，本质上不再是写一个庞大的单体应用，而是在做“服务编排（Orchestration）”。

你需要一个 API 网关来接收请求，需要一个个微服务去读写数据库（RDS），需要 Worker 去消费消息队列（Kafka），还需要后台的定时任务去跑批处理。

这些错综复杂的分布式场景，对语言的要求出奇的一致：

• 启动要极快：为了适应容器和 Serverless（Lambda）的弹性伸缩。
• 并发要极简：遇到高并发？随手 go func() 就能轻松应对 SQS 消费和扇出（Fan-out）模型。
• 心智负担要极低：代码必须像白开水一样直白。今天刚入职的应届生，明天就能看懂并修改跑了三年的核心代码。

Go 语言完美地满足了这一切。它的设计哲学就是：“天下武功，唯快不破；保持简单，拒绝炫技。”

在 Go 的世界里，开发者的个人时间，永远比 CPU 的计算时间更昂贵。它用“相对够用”的性能，换取了团队极高的迭代速度和代码的一致性。

这就是为什么，Go 语言统治了业务服务的“编排层（Orchestration Layer）”。

Rust 的拔剑：在深水区里，手撕性能瓶颈

然而，当你的系统撞上“那堵墙”，当系统中某些特定的组件，变成了吞噬资源的黑洞时，Go 语言的 GC（垃圾回收）和相对粗放的内存管理，就会显得力不从心。

这个时候，就是 Rust 拔剑出鞘的时刻。

Rust 不适合用来写那些三天两头变需求的业务 CRUD 接口，它真正的主战场，是系统里那些承担“重体力劳动（Heavy-lifting components）”的深水区：

• 高吞吐量的消息处理器：比如每天要吞吐数百亿条记录的 Kafka 消费者集群。
• 实时流处理和欺诈检测引擎：在这些场景下，哪怕是几十毫秒的 GC 停顿，都会导致不可估量的经济损失。
• 成本敏感的边缘计算（Edge Compute）：在资源极其受限的环境中榨干最后一滴 CPU 性能。

在这些领域，Rust 的设计哲学展现出了降维打击般的威力：“控制所有重要的事情。”

Rust 假设：线上的 Bug 是极其昂贵的；规模化后的性能低下是致命的。因此，它用极其严苛的编译器，强迫你在写代码的阶段就解决掉所有可能的内存泄漏和并发竞争。

它没有 GC，内存效率极高。在 CPU 密集型的任务中，它通常比 Go 快 2 到 5 倍。

终极兵法：双剑合璧的实战演练

聪明的架构师早就看透了：我们不需要在 Go 和 Rust 之间二选一，我们需要的是将它们各自部署在正确的战线上。

在真实的硅谷大厂和独角兽公司中，最经典的架构模式已经浮出水面：

Pattern 1：用 Go 写服务层，用 Rust 写热点路径（Hot Path）

• 让 Go 去处理绝大多数的 API 路由、微服务间通信和业务编排。这保证了团队的开发速度。
• 一旦监控发现某个模块成了 CPU 或内存的瓶颈（比如音视频转码、核心推荐算法），立刻将其剥离，用 Rust 重写，作为一个独立的高性能微服务被 Go 调用。这种“好钢用在刀刃上”的策略，避免了过度工程化。

Pattern 2：为成本和延迟而战

• 当你的 AWS ECS 集群因为某个 Go 写的聚合管道而不断扩容，云账单即将失控时；或者当你的金融系统要求绝对可预测的执行时间，不能容忍任何 GC 暂停时。
• 毫无犹豫地让 Rust 进场接管。它省下的机器成本，足以支付重写代码的代价。

小结：别为了追求“最好”，而忘记了“为什么出发”

最后，我想分享一下我最喜欢的一段话：

“在这个世界上，你永远无法通过选择一门‘最好的语言’来赢得战争。”

“你赢得战争的方式是：深刻理解你的系统会在哪里崩溃；知道哪种工具能精准地解决那个特定的问题；并且，只有在确实能带来巨大回报的地方，才引入复杂性。”

如果你的系统还在为了活下去而疯狂堆功能，请闭上眼睛，用 Go 语言全力冲刺。

如果你的系统已经庞大到每次发版都在流血，每多消耗 1MB 内存都在烧钱，那么，请翻开 Rust 的手册。

用 Go 来构建你的商业帝国，用 Rust 来捍卫它的边界。

这，才是 2026 年，一个成熟架构师应有的顶级大局观。

资料链接：https://codestax.medium.com/rust-vs-go-the-only-backend-language-comparison-that-actually-matters-in-2026-6b8303dbb7c2

今日互动探讨：

在你的公司里，是否也遇到了系统“撞墙”的时刻？你们目前是如何解决性能瓶颈的？有没有考虑过，或者正在尝试引入 Rust 来重写核心的 Go 模块？

欢迎在评论区分享你的实战经验与踩坑血泪史！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/05/08/bun-founder-abandons-zig-for-rust-ai-rewrite

大家好，我是Tony Bai。

在过去的两年里，Bun 以其闪电般的速度，成为了前端世界挑战 Node.js 霸权的“重量级选手”。

而它成功的秘诀之一，就是其创始人 Jarred Sumner 极其激进、甚至有些“偏执”的技术选型——全面押注 Zig 语言。

当全世界都在用 C++、Go、Rust 这些“主流”语言构建底层基础设施时，Bun 却像一个孤独的叛逆者，将自己的身家性命，全部压在了小众但优雅的 Zig 身上。

但就在前几天，这位“叛逆者”似乎也“背叛”了自己的信仰。

X 平台上的开发者 Luke Parker 突然发现，Bun 的官方 GitHub 仓库里，出现了一个名为 claude/phase-a-port 的神秘分支。点进去一看，所有人都惊呆了：Bun 的创始人 Jarred Sumner，正在将 Bun 的核心代码，从 Zig 迁移到 Rust！

更令人震撼的是，这次迁移的主导者，似乎并不是 Jarred 本人，而是一个 AI Agent。

仓库里一份名为 PORTING.md 的文件，赫然写着给 AI 的指令：

“你正在将一个 Zig 文件翻译成 Rust。在写任何代码之前，请先读完这份文档。A 阶段的目标，是生成一份能忠实捕捉原始逻辑的 .rs 草稿文件——它甚至不需要能编译通过。”

这条消息瞬间引爆了整个技术圈。

• Zig 社区感到被“背叛”和抛弃。
• Rust 社区则一片欢腾，迎来了“又一位巨星的加盟”。
• 而更多的开发者则在问：这背后到底发生了什么？为什么连 Zig 最忠实的信徒，也投向了 Rust 的怀抱？

今天，我们就来深度扒开这场顶级项目的“技术叛逃”，看看在 AI 编程席卷一切的时代，编程语言的选择标准，正在发生怎样翻天覆地的变化。

铁证如山：从 CLAUDE.md 到 2.8 万行代码变更

起初，很多人以为这只是一个愚人节玩笑。

但随着 Simon Willison 等社区大佬的深挖，越来越多的“铁证”浮出水面：

1. 巨大的代码量：这个实验性的分支，在一次提交中就变更了 12 个文件，新增了 2.8 万行代码，这绝不是小打小闹。
2. 写给 AI 的“说明书”：那份长达 622 行的 PORTING.md，极其详细地将 Zig 的指针、分配器、错误处理等核心概念，一一映射到了 Rust 的等价物上。这显然是一份给 AI Agent（很可能是 Anthropic 的 Claude Code）看的“操作手册”。
3. 创始人的亲自下场：所有的提交，都来自于 Jarred Sumner 本人。

种种迹象表明：Bun 真的在严肃地考虑，或者至少是在深度探索，用 Rust 来重写自己的 Zig 内核。

动机拆解：我们为什么要背叛“全世界最好的语言”？

这就引出了所有人都想问的那个问题：为什么？

Zig 语言以其简单的语法、对 C 语言的无缝兼容、以及对底层内存的精准控制而著称。Jarred Sumner 本人也曾是 Zig 最狂热的布道者。

但在 X 平台的激烈讨论中，社区大佬们给出了几个推测：

1. 生态的贫瘠 vs Rust 的(相对)富饶

这是最核心的原因。Zig 虽然优雅，但它的社区生态，相比于已经“枝繁叶茂”的 Rust 来说，依然是一片“荒漠”。

当你需要一个成熟的异步运行时、一个功能完备的 HTTP 客户端、或者一个高性能的序列化库时，在 Rust 的 crates.io 上有很多个经过生产环境检验的“轮子”可用。

而在 Zig 的世界里，很多时候你都不得不“从零手搓”。

2. 人才的稀缺 vs 社区的规模

Bun 作为一个商业项目，需要不断地招聘顶尖的系统程序员。但现实是，精通 Zig 的开发者凤毛麟角，而 Rust 开发者社区的规模，则要大上几个数量级。

选择 Rust，就是选择了一个更庞大、更多元的人才库。

3. 工具链的成熟度

从强大的 rust-analyzer (LSP)，到无所不能的 cargo，再到各种静态分析、模糊测试工具……Rust 的工具链生态，在过去几年里已经达到了一个相当高的成熟度。

而 Zig，在这方面依然还有很长的路要走。

4. 对 AI 的“友好度”

这是一个极其微妙、却又越来越重要的因素。

Rust 强大的类型系统、详尽的错误信息、以及海量的开源代码（作为训练数据），使得 AI Agent 在生成和修复 Rust 代码时，表现得异常出色。
AI 就像一个不知疲倦的实习生，而 Rust 严苛的编译器，就是那个最完美的、能 24 小时进行 Code Review 的“导师”。

AI 作案现场：当“代码重构”成为一种“指令集”

这次事件中最具未来感的，是 Jarred Sumner 选择的重构方式。

他没有去组建一个庞大的“重写小组”，而是把自己的架构思想，沉淀成了一份给 AI 看的“技术规范”。

A 阶段：AI 只管“翻译”，不管对错。
目标是快速地将 Zig 的逻辑，“像素级”地平移到 Rust 文件中。这个阶段的代码，甚至不需要能编译。

B 阶段：AI 负责“修复”，直到编译通过。
在这个阶段，AI 将扮演一个“修复工”的角色，不断地与 Rust 编译器搏斗，修复所有权、生命周期等各种编译错误。

看懂了吗？

这是一种全新的、堪称“流水线”式的 AI 协同开发模式。人类架构师负责定义“做什么（What）”和“怎么做（How）”，而 AI Agent 负责具体的“执行（Execution）”。

反思：在 AI 时代，我们该如何选择技术栈？

Bun 与 Zig 的这次“决裂”，像一面镜子，照出了 AI 时代技术选型的新法则。

法则一：生态的“引力”，正在变得比语法本身更重要

一门语言的语法再优美，如果它的生态里没有足够多的“轮子”，那么在追求快速迭代的今天，它就必然会被边缘化。AI 加速了代码的生成，也同样加速了对“成熟生态”的依赖。

法则二：“对 AI 的友好度”，正在成为一门语言的核心竞争力

一门语言的文档是否完善、错误信息是否清晰、社区代码风格是否统一……这些在过去被认为是“软实力”的因素，在今天，直接决定了 AI 在这门语言上的生产力上限。

法则三：没有永恒的“信仰”，只有永恒的“取舍（Trade-offs）”

Jarred Sumner 对 Zig 的热爱毋庸置疑。但作为一个顶级项目的负责人，他必须在“个人技术品味”与“项目长期发展”之间，做出最理性的、甚至是痛苦的权衡。

在工程的世界里，从来没有“最好的”语言，只有“最合适的”工具。

小结：一场没有硝烟的“换核”战争

Bun 的这次实验性“叛逃”，无论最终是否会合并到主干，都已经为我们揭示了未来十年技术演进的残酷真相：

在 AI 这头“效率巨兽”的面前，所有的技术壁垒、社区信仰、甚至是个人情感，都可能被无情地碾碎。

当你的第三个员工是一个名叫 Claude Code 的 AI 时，选择一个它最擅长、能让它发挥最大威力的语言，似乎成了一个无可辩驳的“最优解”。

这场从 Zig 到 Rust 的“换核”战争，或许只是未来无数场“AI 驱动的技术栈重构”的第一次预演。

下一个，会是谁？

资料链接：

• https://x.com/i/trending/2051505180647227556
• https://github.com/oven-sh/bun/blob/46d3bc29f270fa881dd5730ef1549e88407701a5/docs/PORTING.md
• https://github.com/oven-sh/bun/tree/claude/phase-a-port

今日互动探讨：

你如何看待 Bun 创始人“抛弃”Zig 的行为？是理性的商业决策，还是对开源精神的背叛？在 AI 时代，你认为 Go、Rust、Zig 这三门语言，谁的未来更光明？

欢迎在评论区分享你的看法！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.

本文永久链接 – https://tonybai.com/2026/04/27/render-why-we-wont-rewrite-in-rust-the-power-of-boring-go

大家好，我是Tony Bai。

在技术圈的鄙视链里，Go 和 Rust 这对“欢喜冤家”的战争，似乎从未停歇。

一方是追求极致简洁、被誉为“云原生时代的 C 语言”的 Go；另一方则是以内存安全、性能屠榜著称、被视为“C++ 终极替代者”的 Rust。

就在前些天，云平台 Render 的创始人兼 CEO Anurag Goel，在 X (Twitter) 上发布了一条看似平平无奇的“凡尔赛”推文，却意外地点燃了一场技术圈的论战。

他写道：

“我们在 Render 用 Go 语言（@golang）写的负载均衡器，每月处理超过 1500 亿次 HTTP 请求。”

“而我们想用 Rust 重写它的次数是：零。”

“Go 是基础设施领域最被低估的语言。‘无聊（Boring）’，才是它的终极特性。”

这篇充满“挑衅意味”的推文，像一块巨石砸入了平静的湖面，引得大量 Go 开发者欢呼雀跃，而 Rust 社区则瞬间被引爆。Cloudflare 的工程师更是直接下场，用自家 Rust 实现的、处理能力强 1000 倍的 Pingora 代理进行“数据反杀”。

今天，我们就来复盘这场“神仙打架”，看看在这场关于“无聊与极致”的哲学对撞背后，到底隐藏着怎样的工程思考。

隔空交火：Render 的 5.8 万 vs Cloudflare 的 5800 万

面对 Anurag Goel 的“凡尔赛”，评论区很快就出现了硬核的技术派。

一位的开发者迅速扒出了数据：

“Render 每月 1500 亿次请求，平均下来大约是 5.8 万 QPS。而 Cloudflare 当年之所以用 Rust 重写他们的代理（Pingora），是因为他们遇到了 5800 万 QPS 的瓶颈，大约是 Render 的 1000 倍。”

“所以，这根本就不是语言好坏的问题，而是在正确的场景，选择正确的工具。”

这段评论，精准地揭示了这场论战的第一个核心：场景与规模的错配。

在 5.8 万 QPS 这个量级，用 Go、用 Java、甚至用 Node.js，对于一个经验丰富的团队来说，都能轻松应对。Go 语言的简洁、极快的编译速度和成熟的并发模型，使其成为了 Render 在这个阶段的“最优解”。

正如另外一名开发者在评论中所言：

“如果一个系统已经在这个规模下稳定运行，那确实没有任何理由去切换技术栈。我能理解你的观点。但把 Rust 扯进来，只是为了强调 Go 的优点，感觉有点没必要。”

但这场论战，显然已经超出了纯粹的技术讨论范畴。

哲学对撞：Go 的“足够好” vs Rust 的“无限可能”

这场大讨论的真正引爆点，是另一位开发者抛出的一个经典“电车难题”：

“如果你的余生只能用一种语言写软件，你会选哪个？”
* Go
* Zig
* Rust

这个问题，瞬间将话题从“哪个工具更适合当前场景”，上升到了“哪种哲学代表未来”的形而上高度。

Go 的拥护者，信奉的是“80 分主义”和“极简主义”。

一位开发者 的评论极具代表性：

“我可能会选 Go。它是一种让你‘别挡路（get out of your way）’的语言。它的简单，让你能专注于你正在构建的东西本身，开发速度极快。”

对于 Go 的信徒来说，软件工程的本质，是在有限的时间和资源内，交付一个“足够好”的、能解决商业问题的系统。他们厌恶为了追求那最后 20% 的极致性能，而付出 80% 的额外复杂性代价。

而 Rust 的拥护者，追求的则是“确定性”和“无限的性能潜力”。

RisingWave（一个用 Rust 构建的流式数据库）的官方账号直接下场站台：

“我们选 Rust。Rust 已经不仅仅是一门系统编程语言，它正在成为现代数据基础设施的骨干。顶级的性能、内存安全……这才是基础设施应该有的样子。”

另一位开发者的评论则更加直接：

“Rust 确实比 Go 更好。但它还没好到值得让你把一个稳定的 Go 系统重写的地步。不过，如果你在乎快速的迭代周期，Rust 的编译时间可能会让你受伤。”

这完美地概括了两种哲学的核心冲突：

• Go：给你 80 分的性能和 95 分的开发效率。
• Rust：给你 100 分的性能和 100 分的运行时安全，但你可能要为此牺牲 50% 的开发效率和忍受漫长的编译等待。

AI 时代的变量：当“人类编写”不再是瓶颈

更有趣的是，这场发生于 2026 年的论战，不可避免地被卷入了 AI 编程的浪潮。

一位开发者提出了一个极具前瞻性的观点：

“（我选 Go），因为它现在是写 LLM 的最佳语言。”

这背后隐藏着一个正在成为行业共识的趋势：Go 语言的极简语法、强制的 gofmt 格式化、以及“一眼望到底”的直白控制流，使其成为了对大模型（LLMs）最友好的“编程母语”。当 AI Agent 生成一段 Go 代码时，人类审查的认知负荷是最低的。

而 RisingWave 则更认可正在成为现代数据基础设施的骨干的 Rust 在 AI 时代的潜力。随着 AI 应用对底层算子、向量数据库、推理引擎的性能要求越来越高，Rust 凭借其“零成本抽象”和对底层硬件的极致压榨能力，正在成为构建下一代 AI 基础设施的首选。

这形成了一个有趣的闭环：Go 负责让 AI 更方便地“写”应用层代码，而 Rust 负责构建让 AI 能够“跑”起来的底层高性能引擎。

架构师的终局：从“语言之争”到“问题之争”

在这场充斥着“拉踩”、“凡尔赛”和“信仰之争”的口水战中，我们依然能找到一条属于开发者架构师的、清晰的破局之路。

第一，警惕“语言的锤子”

当你手里只有一把锤子时，你看什么都像钉子。

正如一位开发者所言：“我的公司混合使用了 Go、Rust 和 Zig。最好的解决方案，永远是取决于具体问题的。”

一个优秀的架构师，脑海中不应该有“哪个语言最好”的执念，而应该有一个装着各种工具的“兵器库”，并清楚地知道每件兵器的适用边界和成本。

第二，承认“无聊”的价值

Render 创始人的那句“无聊是终极特性”，是对当下技术圈“追逐 Hype（炒作）”文化的一次降维打击。

一个能稳定运行、默默处理千亿流量的系统，其商业价值，远大于一个用了最新潮技术、却隔三差-五需要半夜起来救火的“实验品”。

对于绝大多数商业公司来说，技术的“可靠性”，永远高于技术的“先进性”。

第三，你的价值，不在于你用了什么语言

另外一位开发者的评论一语中的：

“大多数人会说 Rust。大多数团队依然会选 Go。而‘最好’的语言，是你能维护多年的那门语言。”

在快速变化的技术浪潮中，一个团队、一个公司的核心资产，从来不是某个用特定语言写就的代码库，而是对业务领域的深刻理解、对系统复杂度的掌控能力，以及在出现问题时能快速定位并解决的工程文化。

这些，都与具体的语言无关。

小结：你的选择是什么？

Render 创始人 Anurag Goel 的一条推文，无意间点燃了 Go 与 Rust 两个顶级社区的哲学大碰撞。

这场论战没有赢家，也不需要赢家。

它只是再次向我们证明了软件工程世界的多样性与复杂性。无论是 Go 的务实与简洁，还是 Rust 的严谨与极致，它们都是在用不同的路径，攀登着名为“构建可靠软件”的同一座高峰。

那么，回到最初的那个问题：

如果你的余生只能用一种语言，你会选择哪一个？

资料链接：https://x.com/i/trending/2044880265814978827

今日互动探讨：

如果让你来回答 Ben Dicken 的“电车难题”（Go, Zig, Rust 三选一），你的选择是什么？为什么？

欢迎在评论区分享你的站队和理由！

还在为写 Agent 框架频频死循环、上下文爆炸而束手无策？我的新专栏 《从0 开始构建 Agent Harness》 将>带你：

• 抛弃臃肿框架，回归“驾驭工程 (Harness Engineering)”的第一性原理
• 用 Go 语言手写 ReAct 循环、并发拦截与上下文压缩引擎等，复刻极简OpenClaw
• 构建坚不可摧的 Safety Middleware 与飞书人工审批防线
• 在底层实现 Token 成本审计、链路追踪与自动化跑分评估
• 从“调包侠”进化为掌控大模型边界的“AI 操作系统架构师”

扫描下方二维码，开启从 0 开始构建Agent Harness 的实战之旅。

原「Gopher部落」已重装升级为「Go & AI 精进营」知识星球，快来加入星球，开启你的技术跃迁之旅吧！

我们致力于打造一个高品质的 Go 语言深度学习 与 AI 应用探索 平台。在这里，你将获得：

• 体系化 Go 核心进阶内容: 深入「Go原理课」、「Go进阶课」、「Go避坑课」等独家深度专栏，夯实你的 Go 内功。
• 前沿 Go+AI 实战赋能: 紧跟时代步伐，学习「Go+AI应用实战」、「Agent开发实战课」、「Agentic软件工程课」、「Claude Code开发工作流实战课」、「OpenClaw实战分享」等，掌握 AI 时代新技能。
• 星主 Tony Bai 亲自答疑: 遇到难题？星主第一时间为你深度解析，扫清学习障碍。
• 高活跃 Gopher 交流圈: 与众多优秀 Gopher 分享心得、讨论技术，碰撞思想火花。
• 独家资源与内容首发: 技术文章、课程更新、精选资源，第一时间触达。

衷心希望「Go & AI 精进营」能成为你学习、进步、交流的港湾。让我们在此相聚，享受技术精进的快乐！欢迎你的加入！

商务合作方式：撰稿、出书、培训、在线课程、合伙创业、咨询、广告合作。如有需求，请扫描下方公众号二维码，与我私信联系。

© 2026, bigwhite. 版权所有.