RustChinaConf 2026

10 月 15 日—17 日 · 深圳

Rust and AI

Rust for AI · AI for Rust · Rust in Production

如果你正在研究 GPU、Inference、Agent Runtime、Sandbox、Compiler、AI Coding、Static Analysis、Verification，或者任何处在 Rust 与 AI 交界处的问题：

欢迎来深圳。

我今年尤其想和大家讨论一句话：

当机器开始写代码，我们真正需要升级的，也许已经不是程序员，而是整个软件工厂。

—— 张汉东

RustChinaConf 2026 早鸟票开售｜10 月 15–17 日，深圳

最近 Rust 世界发生了几件看似独立、实际上很值得连起来看的事情。

2026 年 6 月，OpenAI 成为 Rust Foundation Platinum Member。

9 月，NVIDIA 也以最高等级 Platinum 加入 Rust Foundation。与此同时，NVIDIA 正式发布 CUDA Rust，开始把 Rust 从 Host 端真正推进到 GPU Kernel。Rust Foundation 对 NVIDIA 的加入给出的定位也很直接：这是 AI Infrastructure 领域的重要玩家以最高会员等级进入 Rust 生态。(The Rust Foundation^[1])

紧接着，Perplexity 今天宣布加入 Rust Foundation。它在公告里特意说了一句话：

希望改善 people and agents build with Rust 的方式。

而它的 Agent Sandbox 平台 SPACE，本身就是用 Rust 构建的，负责支撑 Perplexity Computer 和 Agent API 背后的执行环境。(LinkedIn^[2])

另一边，Coding Agent 公司 Cognition 刚刚把 Dioxus 整个团队收入麾下。

Dioxus 创始人 Jonathan Kelley 在解释这件事的来龙去脉时提到一个很有意思的变化：

2025 年末，他们明显感觉到 LLM 写 Rust 的能力突然好了起来。

随之而来的，是更多人开始用 Rust 和 Dioxus。而 Dioxus 团队后来做的事情，也逐渐从 UI Framework 延伸到了 SkyVM、虚拟化、跨平台测试和 Coding Agent Harness。(Dioxus Labs^[3])

如果把这些事情一件一件看，都可以找到各自的解释。

但如果把 OpenAI、NVIDIA、Perplexity、Cognition 放在一张图里，我觉得一个更大胆的问题开始出现了：

AI 时代，是不是正在重新选择自己的系统语言？

甚至再往前一步：

Rust 会不会成为未来“黑灯软件工厂”的重要基础材料？

这是我最近越来越强烈的一个判断。

一、NVIDIA 真正做的，并不是“支持一下 Rust”

先从 NVIDIA 说起。

如果只是加入 Rust Foundation，我不会写这么长一篇文章。

真正值得关注的是 NVIDIA 同时做的另一件事：

CUDA Rust。

过去 Rust 当然也可以调用 CUDA。

但一般路径是：

Rust Application
       ↓
CUDA Runtime / FFI
       ↓
CUDA C++ Kernel
       ↓
NVIDIA GPU

Rust 停留在 Host 一侧。

真正跑在 GPU 上的 Kernel，依然属于 CUDA C++ 的世界。

这次 NVIDIA 做的事情不同。

CUDA Rust 一次提供两条路线：

                  CUDA Rust
           ┌─────────┴─────────┐
           ↓                   ↓
         SIMT                 Tile
           ↓                   ↓
      cuda-oxide           cutile-rs
           ↓                   ↓
          PTX            CUDA Tile IR
           └─────────┬─────────┘
                     ↓
                 NVIDIA GPU

其中 cuda-oxide 甚至直接实现了一个 Rust compiler backend。

大致路径是：

Rust
 ↓
MIR
 ↓
Pliron IR
 ↓
LLVM IR
 ↓
PTX
 ↓
GPU

GPU Kernel 本身就是 Rust。

而 cutile-rs 则更进一步，把 Rust Ownership 与 Tile Programming Model 放到了一起，让编译器接管更多 Thread Mapping 和 Memory Layout。

NVIDIA 自己对这件事的解释非常值得注意。

它在 CUDA Rust 的官方公告里直接说：

AI systems layer，包括 inference engines、serving infrastructure、drivers 和 agent runtimes，越来越多正在使用 Rust。

然后 NVIDIA 紧接着说：

他们自己也是这一趋势的一部分。

Nova Linux Driver 是 Rust；

NVIDIA Dynamo 建立在 Rust Core 上；

现在唯一还明显缺失的一块，就是 GPU Kernel。

CUDA Rust，就是来补这最后一个缺口的。(NVIDIA Developer^[4])

所以这不是：

NVIDIA 给 CUDA 加了一种新语言。

更像是：

NVIDIA 发现 Rust 已经从 AI Infrastructure 外围一路长到了 GPU 门口，于是决定把最后一道门打开。

二、真正重要的不是 Rust 语法，而是 Ownership 开始进入 GPU

为什么这件事值得注意？

因为 GPU Programming 恰恰是最不应该只相信程序员的地方之一。

GPU 世界充满：

Pointer
Aliasing
Thread
Warp
Shared Memory
Synchronization
Async Execution
Memory Lifetime

真正困难的问题经常不是：

“怎么算？”

而是：

谁拥有这块 Memory？谁可以修改？什么时候可以访问？两个并行执行单元会不会碰到同一份状态？

这不就是 Rust 十几年来一直在解决的问题吗？

所以 CUDA Rust 真正有意思的地方，不是：

终于可以用 Rust 语法写 Kernel。

而是：

Ownership 开始从 CPU 世界进入 GPU 世界。

cuda-oxide 使用 DisjointSlice 等抽象来表达线程之间不重叠的 Mutable Memory。

Kernel Launch 也可以带有 Contract。

如果同一块 Buffer 以冲突的方式进入 Kernel，编译器可以直接拒绝。

NVIDIA 官方展示的两个 CUDA Rust 路线都试图在编译期捕获典型 aliasing 错误。Tile 路线甚至让编译器拥有更多 Mapping 与 Memory Placement 的决策权。(NVIDIA Developer^[5])

这背后其实是 Rust 一个非常古老、但到了 AI 时代越来越重要的哲学：

能交给机器检查的东西，就不要永远只放在人脑里。

三、然后我看到了 NVIDIA 的招聘

这才是让我真正觉得 NVIDIA 在“重仓” Rust 的地方。

它正在招聘一名：

Principal Systems Software Engineer, LPU

这个岗位属于 LPX System Software Team。

招聘信息里有一句非常简单粗暴的话：

We build this stack in Rust.

这个 Stack 是什么？

不是 Web Service。

不是 CLI。

不是辅助工具。

而是类似这样的东西：

AI Workload
     ↓
Runtime Interface
     ↓
Runtime
     ↓
Data Movement
     ↓
Driver
     ↓
Core System Libraries
     ↓
HAL
     ↓
Hardware

HAL、Driver、Runtime、System Library。

从 Hardware Boundary 往上构建整套系统软件。

而且 NVIDIA 还明确说：

We work in Rust from day one.

这和我们过去常见的大公司采用 Rust 的方式不太一样。

以前通常是：

几百万行 C/C++
       ↓
Memory Safety 问题
       ↓
Security Pressure
       ↓
逐渐引入 Rust

Rust 是一种 Legacy Modernization Language。

但 NVIDIA 这里表现出来的是：

New Hardware
     ↓
New Architecture
     ↓
New System Stack
     ↓
Rust from Day One

这完全是另一回事。

这意味着 Rust 已经开始从：

“修复旧的 C/C++ 世界”

走向：

“如果今天重新设计一套系统，我们为什么不直接用 Rust？”

与此同时，NVIDIA 还在招聘 CUDA Rust Core Libraries 工程师，工作内容包括在 CUDA/C/C++ 之上构建 Safe Rust Abstraction、处理 Rust/C++ Interop，以及连接 Python 生态。

所以 NVIDIA 其实在同时做两件事：

旧世界                      新世界
CUDA / C++                New Hardware
    ↓                         ↓
Introduce Rust            Rust from Day One
    ↓                         ↓
Safe Boundary          HAL / Driver / Runtime

一边进入几十年的 CUDA C++ 遗产。

一边直接用 Rust 建新世界。

这才叫真正的战略下注。

四、但最让我感兴趣的，还不是 NVIDIA 用 Rust

而是 NVIDIA 在同一个招聘岗位里，还写了另一件事：

AI Coding Agents。

不是“会用 Copilot 加分”。

而是希望 Principal Engineer 已经习惯：

用 Coding Agent 真正 Shipping Software。

甚至需要去设计：

Agent-assisted Engineering Practice；

Reusable Abstraction；

Diagnostics；

Documentation；

以及：

什么工作应该设计成 Agent-amenable？

换句话说，同一个岗位同时出现了两件事情：

Rust from Day One
        +
AI Coding Agents

这就开始有趣了。

为什么？

因为这两个东西可能不是偶然同时出现的。

五、Rust 未必是 AI 最容易写的语言

这里我反而想先说一个我一直秉持的结论：

Rust 未必是 AI 最容易写的语言，但它是最 AI Friendly 的编程语言。

如果评价指标是：

LLM 第一次生成的代码能不能跑？

Python、JavaScript、TypeScript 很可能都比 Rust 友好。

Rust 会不断给 Agent 找麻烦：

borrow checker error
trait bound not satisfied
cannot borrow as mutable
lifetime mismatch
Send / Sync violation
type mismatch

所以如果只看：

Generate

Rust 未必是最好的语言。

但问题是：

未来 AI Coding 真正重要的单位，也许根本不是一次 Generate。

而是一个 Loop：

Generate
   ↓
Compile
   ↓
Diagnose
   ↓
Repair
   ↓
Test
   ↓
Verify
   ↓
Evidence

如果评价标准变成：

一个 Agent 能不能在没有人持续盯着它的情况下不断修正自己，最后收敛到一个可信结果？

Rust 的价值就完全变了。我说 Rust 是 AI 最友好语言的理由正是这个。

六、Borrow Checker 可能从“阻力”变成生产设备

过去二十年，人写代码。

编译器最主要的任务是：

把人的 Source Code 变成 Machine Code。

但 Agent Coding 出现以后，编译器可能开始承担另一个越来越重要的角色：

自动化质量控制。

Agent 很容易告诉你：

Implementation completed successfully.

甚至：

All edge cases have been handled.

但是 Agent 对自己的判断，本身不是 Evidence。

rustc 不一样。

借用关系不成立：

No。

Trait Constraint 不成立：

No。

类型不成立：

No。

Send / Sync 不满足：

No。

这里有一个特别有意思的角色转换。

过去人类学习 Rust 的时候，经常抱怨：

为什么编译器管这么多？

到了 Agent 时代，我们的想法可能会逐渐变成：

幸亏编译器管这么多。

因为未来真正昂贵的，可能不再是：

生产代码。

而是：

证明代码。

七、代码正在从稀缺品变成工业耗材

这是我认为整个变化最重要的地方。

过去几十年，软件行业有一个默认前提：

代码很贵。

一个高级工程师一天只能写有限的代码。

所以我们不断发明：

Framework；

Library；

DSL；

Low-code；

Code Generation。

本质目的都是：

少写代码。

但 Coding Agent 正在破坏这个前提。

今天你可以让机器：

写 2000 行；

删掉 1200 行；

重构；

测试；

失败；

全部推翻；

再生成三个方案。

过去我们会心疼这些代码。

以后可能不会了。

代码正在慢慢从：

软件工程的核心资产

变成：

软件生产过程中可以反复消耗的中间材料。

如果是这样，整个软件工程的经济学都会变化。

过去最贵的是：

Production

未来最贵的可能是：

Specification
Constraint
Verification
Evidence

这才是为什么我认为 Rust 会在 AI 时代变得越来越有意思。

八、Rust 的真正价值可能是“约束密度”

Rust 最重要的事情，也许并不是 Memory Safety 这四个字。

更深一层，是：

它把大量原本存在于高级工程师脑中的隐性知识，强制编码进程序。

比如：

这个对象属于谁？
谁可以修改它？
这里允许 alias 吗？
这个对象还能活多久？
它能不能跨线程？
这个 API 失败意味着什么？
这个状态是否合法？

Rust 尽可能把它们表达成：

Ownership
Borrowing
Lifetime
Type
Trait
Send / Sync
Enum
Result
Newtype
unsafe boundary

这意味着 Rust Program 里面天然包含更多：

Machine-readable Constraints。

以前这些约束主要是给人服务的。

今天突然多了一个新的读者：

Agent。

这就是为什么我越来越倾向于说：

Rust 未必最适合 AI 生成，但它可能特别适合 AI 收敛。

九、Cargo 甚至可能和 Borrow Checker 一样重要

谈 Rust + AI Coding 时，大家很容易只想到 Ownership。

但如果真从 Agent 的视角看一个 Rust Repository，Cargo 可能同样重要。

一个 Agent 进入 Rust Project 后，很容易知道应该怎么办：

cargo check
cargo build
cargo test
cargo fmt
cargo clippy
cargo doc

这是一个非常标准化的软件工程反馈面。

Agent 不喜欢什么？

它最怕：

build-new.sh
build-final.sh
test-v3.sh
某个 Wiki 里的神秘命令
某个前员工电脑上的环境变量
三年前 README 里的过期说明

Agent 越自主，工程环境的标准化程度就越重要。

所以 Rust 对 Agent 的优势不仅是：

Type System。

而是整个：

Language
   +
Compiler
   +
Cargo
   +
Test
   +
Lint
   +
Formatting
   +
Docs

形成了一套高度机器可操作的软件工程协议。

十、然后 Perplexity 出现了

如果 Rust 只是适合 Agent 写代码，这个故事其实还没有那么大。

真正有意思的是：

运行 Agent 的基础设施也开始 Rust 化。

Perplexity 刚刚宣布加入 Rust Foundation。

而它给出的例子不是搜索服务。

不是某个 Backend。

而是：

SPACE。

SPACE 是 Perplexity Computer 和 Agent API 背后的 Sandbox Platform，本身使用 Rust 构建。Perplexity 在宣布加入时直接说，希望改善 people and agents build with Rust 的方式。(LinkedIn^[6])

为什么 Agent 需要 Sandbox？

因为今天 Agent 已经不只是回答问题。

它会：

write file
execute shell
install package
run server
access network
use credentials
launch browser
modify system state

于是我们必须默认：

Agent 运行的代码是不可信的。

甚至：

Agent 本身也不应该被完全信任。

所以需要：

Agent
  ↓
Untrusted Code
  ↓
Sandbox
  ↓
VM / Isolation
  ↓
Host Infrastructure

Rust 在这里的角色突然发生了变化。

以前我们说：

Rust 帮助人安全地写软件。

现在可以说：

Rust 帮助我们构建一个安全边界，让 AI 可以在里面放心地写那些暂时还不能完全相信的软件。

这是完全不同的价值。

十一、Cognition 又把故事推进了一步

然后是 Devin。

Cognition 目前并没有公开成为 Rust Foundation Member。

但 Rust 已经出现在 Devin 周围很多非常关键的位置。

Devin CLI 的终端渲染使用 Rust / Dioxus；

Devin Outposts Kubernetes Operator 使用 Rust；

Cognition 自己做的 VM 磁盘增量快照工具 blockdiff 也使用 Rust。

Dioxus 整个团队现在又加入 Cognition，参与 Devin 的：

VM、Computer Use、Testing。

而 Dioxus 自己此前还做了 SkyVM，涉及 Snapshot、Restore、跨平台环境和 Coding Agent 集成。

这件事揭示了 Coding Agent 演进中的一个规律：

刚开始：

模型帮你写一个函数

再往后：

模型帮你改一个 Repository

继续往前：

Agent 拥有一台 Computer

它需要：

VM；

Filesystem；

Network；

Terminal；

Browser；

Snapshot；

Rollback；

Fork；

Computer Use；

Testing；

Verification。

到这里，Coding Agent 的竞争就不再只是模型能力。

它重新变成了一个：

Systems Engineering 问题。

而这恰好又进入 Rust 的传统势力范围。

十二、Cognition 还碰到了另一个更根本的问题：你怎么知道 Agent 真的完成了？

Devin 可以告诉你：

Done.

但 Done 不是 Evidence。

Cognition 在 Agentic Development Verification 上做的一件事情很值得关注：

让 Agent 先形成 Testing Plan 和 Expected Behavior，再留下截图、Assertion、录像等实际验证证据。

他们自己也公开承认：

Agent 的测试可能截图时机错误；

可能偏离测试目标；

甚至可能用脚本绕过原本应该真实操作的流程。

这正好说明：

AI Coding 的真正终局，不会是生成。

而是：

Intent
 ↓
Generate
 ↓
Compile
 ↓
Run
 ↓
Observe
 ↓
Test
 ↓
Verify
 ↓
Evidence
 ↓
Accept

未来最重要的软件工程问题，也许不是：

怎么让 AI 写更多代码？

而是：

怎么让机器证明机器写出来的代码真的满足了人的意图？

十三、现在把 OpenAI、NVIDIA、Perplexity、Cognition 放在一起

这时候就能看到一个很有意思的完整结构。

             THE AI SOFTWARE FACTORY
                    Human
                      │
             Intent / Spec
                      │
                      ▼
               Model / Agent
                 OpenAI etc.
                      │
                      ▼
              Coding Harness
                 Cognition
             VM / Test / Verify
                      │
                      ▼
              Agent Runtime
                Perplexity
           Sandbox / Isolation
                      │
                      ▼
             Compute Platform
                 NVIDIA
         Runtime / Driver / GPU
                      │
                      ▼
                  Hardware

现实当然不会分得这么整齐。

这些公司彼此都有跨层业务。

但这张图帮助我们看到了一件很重要的事：

Rust 正在沿着 AI 软件生产链，从底向上渗透。

NVIDIA：

GPU、Driver、Runtime、新硬件平台。

Perplexity：

Agent Sandbox。

Cognition：

VM、Snapshot、Computer Use、Deployment。

OpenAI：

作为最典型的 AI Native 公司之一，直接进入 Rust Foundation 最高会员层，并投入长期生态资源。(The Rust Foundation^[7])

单独任何一个案例都不能证明未来。

但四件事情一起出现，就已经值得形成一个假设。

十四、Rust 可能同时成为“生产语言”和“生产线语言”

这是我最近特别喜欢的一个区别。

什么叫 生产语言？

Agent
  ↓
Generate Rust
  ↓
Software

也就是 AI 直接生产 Rust Code。

但什么叫 生产线语言？

Coding Agent
    ↓
Agent Runtime
    ↓
Sandbox
    ↓
VM
    ↓
Storage / Network
    ↓
Driver
    ↓
GPU / Accelerator

这些负责“生产软件的软件”，自身也越来越多使用 Rust。

所以一个很有意思的递归正在出现：

AI 开始用 Rust 生产软件，而生产这些软件的 AI 基础设施本身，也开始用 Rust 构建。

如果这个趋势继续下去，那么 Rust 的地位可能和我们过去想象的不太一样。

它未必成为世界上代码量最大的语言。

甚至可能永远不是。

但它可能成为：

生产软件的机器内部非常重要的一种材料。

十五、这就是我所说的“黑灯软件工厂”

制造业有一个概念：

Lights-out Factory。

黑灯工厂。

工厂里并不是真的必须关灯。

它真正表达的是：

生产线上不再需要人类站在每一个工位。

人负责：

设计产品；

设计生产线；

定义工艺；

制定质量标准；

处理异常。

机器负责生产。

那么软件行业会不会也走到这一步？

我认为我们已经开始看到最早期的雏形。

                 Human
                   │
       Intent / Specification
       Constraint / Acceptance
                   │
                   ▼
          ┌────────────────┐
          │    AI Agent    │
          │                │
          │ Plan           │
          │ Code           │
          │ Run            │
          │ Repair         │
          └───────┬────────┘
                  │
                  ▼
              Compiler
                  │
          Static Analysis
                  │
                Test
                  │
              Verify
                  │
              Evidence
                  │
                  ▼
             Production

这就是我理解的：

黑灯软件工厂

人并没有消失。

只是人的位置发生了变化。

以前人站在生产线上：

一行一行写代码。

未来人可能站在控制室里：

定义软件应该是什么，以及什么证据足以证明它完成了。

十六、所以 AI Coding 最终改变的可能不是“程序员效率”

今天大家还在讨论：

Copilot 能提高多少百分比效率？

Claude Code 一个人能顶几个工程师？

Agent 一天能写多少 PR？

我觉得这些问题几年以后可能都会显得很初级。

工业革命真正改变的从来不是：

一个工人一分钟可以多拧几个螺丝。

而是：

生产组织形式发生了变化。

AI Coding 真正可能带来的，也不是：

程序员 × 2。

而是：

Human Coding
      ↓
Human + Agent
      ↓
Agentic Engineering
      ↓
Autonomous Software Production

真正的变化是：

软件生产开始工业化。

十七、而 Rust 的历史恰好让它非常适合进入这个时代

Rust 从一开始就带着一种非常奇怪的“不信任哲学”。

它不完全相信程序员。

所以它要求：

Ownership。

Borrowing。

Lifetime。

Type。

Trait。

Send / Sync。

Unsafe Boundary。

过去这造成了 Rust 最大的学习门槛。

但 AI 时代之后，同样一套设计产生了完全相反的意义。

因为现在我们又多了一个更不应该完全相信的代码生产者：

AI Agent。

于是 Rust 十年前的那个问题：

怎么避免一个人类程序员犯低级但致命的系统错误？

可能逐渐变成：

怎么避免一个一天生成几十万行代码的机器大规模生产错误？

这两个问题竟然开始汇合了。

十八、AI 时代可能会重新定义“好语言”

过去评价语言，经常看：

表达力；

开发效率；

运行性能；

生态；

学习曲线。

未来可能还要增加一个指标：

Machine Verifiability

也就是：

这门语言允许机器自动验证多少东西？

还有另一个指标：

Agent Feedback Quality

Agent 写错以后：

编译器能不能明确告诉它哪里错了？

反馈是否结构化？

修复路径是否局部？

测试入口是否统一？

Build System 是否标准？

Package Manager 是否统一？

如果这些变成语言的重要竞争力，那么 Rust 的很多传统特点都会获得新的解释。

甚至可以说：

AI 时代，编程语言不仅是给人写的，也开始是给 Agent 读、给 Compiler 判、给 Machine 执行的一份协议。

编程语言过去主要连接：

Human → Computer

未来可能连接：

Human
  ↓
Agent
  ↓
Language
  ↓
Compiler
  ↓
Machine

Rust 恰好是一份条款写得非常详细的合同。

十九、这也解释了 NVIDIA 为什么值得特别关注

所以现在回到文章开头：

为什么 NVIDIA 重仓 Rust？

当然有 Memory Safety。

当然有 Performance。

当然有 C++ Interop。

但如果把 NVIDIA 的另一句话：

AI Coding Agent 已经成为工程 Workflow 的重要组成部分

也放进去，我觉得可以提出一个更大胆的解释：

NVIDIA 真正下注的，也许不仅是 Rust 这门语言，而是一种新的软件生产关系。

未来可能是：

AI
负责生产
Rust
负责表达更多约束
Compiler / Static Analysis / Test
负责自动验收
Human
负责意图、标准与责任

如果这个模型成立：

那么 Rust 就不再只是一门 Systems Programming Language。

它开始承担一部分：

自动化软件工厂质量控制系统

的角色。

二十、软件工业可能正在重演制造业发生过的事情

制造业工业化以后，并不是产品变得不重要。

恰恰相反。

产品越来越复杂。

只是人不再手工制造每一个零件。

软件可能也会经历类似过程。

未来软件越来越复杂。

代码量甚至可能爆炸。

但是人类直接写下的代码比例反而不断下降。

于是产业的核心能力会从：

Who can write more code?

逐渐迁移到：

Who can build a better software factory?

什么叫好的软件工厂？

它需要：

Agent；

Compiler；

Sandbox；

VM；

Runtime；

Observability；

Test；

Verification；

Snapshot；

Rollback；

Evidence；

Deployment Infrastructure。

注意这些东西。

几乎全部都是：

Systems Software。

所以 AI 越发展，Systems Programming 反而可能越重要。

这是一个很反直觉的结果。

很多年前我们曾经以为：

AI 会让底层语言变得不重要。

现在看可能恰恰相反：

AI 越能写代码，我们越需要可靠的系统来承载这些代码。

这可能就是 Rust 真正的机会。

二十一、Rust 的第二个十年，也许真正开始了

Rust 第一个十年的主题大概可以总结为：

Memory Safety。

Rust 证明了：

不用 GC，也可以构建安全、高性能的 Systems Software。

于是它进入：

Browser；

Cloud；

Database；

Networking；

Embedded；

Operating System。

但第二个十年，我觉得 Rust 的核心问题可能发生变化。

它开始面对：

Machine-generated Software。

于是 Rust 的故事可能从：

Safe Systems Programming

继续向前变成：

Safe
   +
Machine-checkable
   +
Agent-friendly
   +
Systems Programming

最终：

Intent
  ↓
Constraint
  ↓
Type
  ↓
Compiler
  ↓
Evidence
  ↓
Autonomous Production

如果说 Rust 的第一个十年解决的是：

如何让人更安全地写系统软件。

那么第二个十年，也许会开始解决：

如何让机器更安全地生产系统软件。

二十二、这也是为什么今年 RustChinaConf，我们把主题定成 Rust and AI

今年我正在组织的 RustChinaConf 2026，将在：

10 月 15 日—17 日 · 深圳

举行。

今年整个大会的主题就是：

Rust and AI

我们把讨论分成三个方向：

Rust for AI

Rust 如何进入 Inference、GPU、Database、Agent Runtime、Storage、Networking 以及真正的 AI Infrastructure。

AI for Rust

Coding Agent、Migration、Code Intelligence、Static Analysis、Testing、Verification，以及 AI 如何反过来改变 Rust Engineering。

Rust in Production

真正大规模部署 Rust 以后，Architecture、Reliability、Observability、Interop 以及长期维护的问题。

现在回头看 NVIDIA、OpenAI、Perplexity、Cognition 这几个月发生的事情：

这三个 Track 几乎已经自己长出来了。

CUDA Rust 是 Rust for AI。

Perplexity SPACE 是 Rust for AI。

NVIDIA 的 AI Coding Agent 是 AI for Rust。

Devin 是 AI for Rust。

LPX 的 Rust from Day One 是 Rust in Production。

Rust / C++ Interop 也是 Rust in Production。

所以今年我真正希望大家来到深圳讨论的，已经不是：

Rust 有没有未来？

而是一个更大的问题：

当机器开始成为代码的主要生产者以后，我们应该设计怎样的语言、工具和软件工程体系，才能让这些代码值得相信？

二十三、从 NVIDIA 重仓 Rust，到黑灯软件工厂

所以最后再把所有事情连起来。

NVIDIA 加入 Rust Foundation。

CUDA Rust。

Rust from Day One。

OpenAI 加入 Rust Foundation。

Perplexity 用 Rust 构建 Agent Sandbox。

Cognition 把 Rust 带进 Coding Agent 的 VM、Snapshot、Computer Use 和 Verification。

如果只是分别看：

都是技术新闻。

但是把它们连接起来，我看到的是一幅更大的图。

代码越来越容易生成
        ↓
代码不再稀缺
        ↓
验证成为瓶颈
        ↓
Compiler / Type / Test 升值
        ↓
Agent 需要 Sandbox / VM / Runtime
        ↓
AI 需要更强的 Systems Infrastructure
        ↓
Rust 的价值被重新放大
        ↓
Autonomous Software Production
        ↓
Lights-out Software Factory

这就是我为什么认为：

NVIDIA 重仓 Rust，并不仅仅是 Rust 社区又拿下了一个大客户。

它可能只是一个更大时代变化最容易看见的信号。

未来真正有价值的问题不是：

AI 能写多少代码？

而是：

我们能不能建立一座几乎不需要人类站在生产线上的软件工厂，并且依然知道里面生产出来的软件是可信的？

在这样的工厂里：

Agent 是工人。

Compiler 是质检员。

Sandbox、VM、Runtime 和 GPU 是生产设备。

Specification 是图纸。

Evidence 是质检报告。

而人类最终负责的，是：

决定什么值得生产，以及什么才算真正完成。

Rust 不一定会成为这座工厂里唯一的语言。

但现在看来，它越来越像一种非常重要的：

工业材料。

甚至可能是一部分：

生产线本身。

这才是我认为 Rust 在 AI 时代真正值得期待的地方。

参考资料

[1] 

Rust Foundation Welcomes OpenAI As Platinum Member, Announces Donation to Rust Project - The Rust Foundation: https://rustfoundation.org/media/rust-foundation-welcomes-openai-as-platinum-member-announces-donation-to-rust-project/?utm_source=chatgpt.com