erkamyaman/rust-anything:3321 star 的 Rust 迁移工具箱,把 Node/Python/Go 应用逐块改写成 Rust 并逐步验证行为一致
erkamyaman/rust-anything:3321 star 的 Rust 迁移工具箱,把 Node/Python/Go 应用逐块改写成 Rust 并逐步验证行为一致
一、先说个让我脸红的场景
去年我接了一个活:把公司一个跑了七八年的 Node.js 后端服务” 现代化”。老板的原话是” 用 Rust 重写一下,性能好”。我当时觉得这活儿挺简单 ——AI 都能写 Rust,我让它写不就行了?
于是我打开 Claude Code,说:” 把 src/ 目录重写成 Rust。” 一小时后它给了我一个 Cargo.toml、一堆 .rs 文件,和一句” 完成了”。
我跑了一下 npm test。138 个用例,挂了 71 个。
挂得五花八门:JS 的 slice 按 UTF-16 码元切,Rust 的 str 按字节切,一个 emoji 就切出乱码;JS 的 Math.round(-2.5) 是 -2,Rust 的 f64::round 是 -3(远离零);JSON 序列化以后 key 顺序不一样;有几处异常类型都变了。
最难受的是我没法判断哪些是” 实现得不好”,哪些是” 本来就该不一样”。这才是真正的痛点:Rust 重写最大的成本不是写 Rust,而是证明它跟原来那个一模一样。
我后来自己写了一堆测试兜底,但写测试的过程比重写业务代码还长,而且测试永远只能覆盖我想到的情况。
所以当我看到 erkamyaman/rust-anything 这个项目时,我的感觉是:它把我那三个月手搓的活儿,做成了一个工具。
2026 年 11 月 16 日它发布了 1.0.0,三天后就到了 3321 个 star。仓库在 erkamyaman/rust-anything,MIT 许可证,主语言 Rust。
它的一句话定位是:
Rewrite your whole app in Rust, one piece at a time, checked against the original at every step.
翻译过来就是:把整个应用一块一块改写成 Rust,每一步都跟原版对照检查。
下面我们拆开看它到底怎么做到的。
二、它是什么:一句话加上几个关键数字
rust-anything 不是代码翻译器。它不生成 Rust 代码。
它提供的是一套” 工作流 + 脚手架 + 验证机制”,Rust 代码由你或者你的 coding agent 写在一份叫 port.rs 的文件里。它负责的是 agent 干不好的那部分:
- 哪段代码值得迁移(
profile) - 按什么顺序迁移(
analyze) - 怎么让 Rust 代码能被原来的调用方调用(
bridge) - 原来的行为到底是什么(
record) - Rust 写得对不对(
diff) - 迁移完到底快不快(
bench) - 上线时怎么保证不出事(
shadow、gate) - 怎么从” 一半 Rust 一半 Node” 变成” 纯 Rust”(
app record到app lift)
几个关键数字(数据来自 GitHub API 与仓库文档,2026 年 11 月 19 日查证):
| 项目 | 数值 |
|---|---|
| Star | 3321 |
| Fork | 262 |
| Open issues | 7 |
| 许可证 | MIT |
| 主语言 | Rust |
| 当前 crate 版本 | 1.5.1(crates.io / npm) |
| 首次发布 | 2026-11-16 12:46 UTC(v1.0.0) |
| 贡献者 | 9 人(作者 erkamyaman 156 次提交,第二名 rudycelekli 46 次) |
| 仓库创建时间 | 2026-11-16 12:10 UTC |
| 支持语言 | TS/JS、Python、C、Go、Ruby、Java(已验证);PHP、C#(preview) |
| 支持的 Agent | Claude Code、Codex、Cursor、Gemini CLI、任意 MCP 客户端 |
| Rust 最低版本 | 1.97 |
仓库规模不算大:src/ 下面 65 个 Rust 文件,最大的几个是 src/app.rs(81 KB)、src/harness.rs(71 KB)、src/codegen_java.rs(71 KB)、src/bridge.rs(65 KB)。作者用的是 Rust 2024 edition,解析器用 oxc(JS/TS)和 tree-sitter(其余语言),并且在 Cargo.toml 里直接写了:
1 | [lints.rust] |
整个 crate 本身不允许出现 unsafe。
有个细节挺有意思:README 里有 19 种语言的翻译版本(简中、繁中、日文、韩文、土耳其文、乌克兰文……),但只有英文版是作者自己写的,翻译大概率是 AI 批量生成的 —— 不过我读简体中文版时发现质量还不错。
三、核心机制一:先测,后改
rust-anything 的整个设计,源自一个想法:别让 AI 去猜” 原来那个函数的行为是什么”,让它去录。
这就是 record(rust-anything record rust/fuzzy-rs),这条命令做三件事。
一、生成边界用例。 从函数签名推断参数类型,然后生成一堆” 语义陷阱”:非 ASCII 字符、emoji、-0、NaN、Infinity、本该是浮点却传了整数、字符串长度和大小写边界、有符号除法、溢出边界、浮点打印格式、Map 和 Set 的遍历顺序。README 里提到的具体陷阱包括土耳其语的点 less i(ı)、Kelvin 符号(K)、长 s(ſ)、阿拉伯 - 印度数字、行分隔符、final sigma。
二、跑你自己的输入。 --inputs cases.jsonl 可以喂自己的 JSONL 文件。
三、跑原版自己的测试。 这个是杀手锏:
1 | rust-anything record rust/fuzzy-rs --from-tests -- npx jest |
它在测试跑的时候” 偷看” 原函数的每一次调用,把调用参数和返回值都录下来。官方案例 vercel/ms 从它自己的 167 个 Jest 测试里抓到了 340 次真实调用。作者在文档里说,第一次移植时是手工从测试里抄了 149 个输入,后来才有了 --from-tests。
录下来的东西存成 cases.jsonl,每个用例是一次函数调用加上它的返回值或者抛出的异常。然后 diff 把这些用例全部回放给 Rust 版(rust-anything diff rust/fuzzy-rs),有任何一条对不上它就列出来。
两个容易被忽略的细节
第一,两边都抛异常算” 一致”。 DECISIONS.md 里记着:
L7 | Both sides throwing counts as agreement; messages are not compared.
原版抛 TypeError,Rust 版抛 ValueError—— 只要两边都是” 抛了” 就算一致,错误消息文本不算契约。理由很实在:错误文本很少是真正的契约,如果要比,很多移植会卡在措辞上而不是逻辑上。Go 是例外,它的 error 值按消息比较,因为 Go 的调用方经常直接比错误字符串。
第二,录的时候跑两遍。 record 把每个用例跑两遍,比对差异:值变了(时间戳、随机 ID)→ 变成 [..] 通配符;同样的行但顺序不同(哈希表遍历、并发)→ 按任意顺序比较;行数不同 → 变成 ...,匹配任何东西。这些都会列在 noise 报告里要求你逐条看。文档说得很直白:”look at every one, since a hash-order or concurrency difference is exactly what can change for real in a port.”(app record 这一层同样跑两遍。)
四、核心机制二:挡住” 原来那版变了”
如果原版代码后来被改了,之前录的行为还有效吗?
rust-anything 的做法是:record 保存被录单元文件的指纹,写进 recorded-from.json。以后原版变了,diff 会警告,gate 直接失败,直到你重新录一遍。
An original that moved on.
recordsaves a fingerprint of the unit’s files (recorded-from.json); when the original changes later,diffwarns andgatefails until you record again, instead of passing against what the original used to do.
这条我觉得是整套东西里最被低估的设计。因为真实项目里最常见的事故不是” 移植写错了”,而是” 移植写对了,但原版早就变了,测试用例还是三个月前的”。有了指纹,这个问题至少不会静默通过。
五、核心机制三:bridge 生成桥接,但把 Rust 代码留给你
bridge 做的是生成脚手架:
1 | rust-anything bridge . src/fuzzy.ts --batch fuzzyScore:text |
生成的东西是一个 crate:Cargo.toml、src/lib.rs(napi-rs 或 wasm-bindgen 绑定)、src/port.rs(你或你的 agent 在这里写 Rust,初始是空桩)、src/js.rs(JS 语义的忠实模拟辅助函数),以及 rust-anything.json。
DECISIONS.md 里解释了这个拆分:
L1 |
bridgesplitslib.rs(bindings) fromport.rs(plain Rust,#![forbid(unsafe_code)]). | Binding macros expand to unsafe code; the port itself never needs it, and it stays testable without a JS runtime.
翻译一下:绑定宏会展开成 unsafe 代码,但你的移植逻辑本身不需要 unsafe。而且这样 port.rs 不用挂着一个 JS 运行时也能测。
各语言用什么桥
| 语言 | 桥接方式 |
|---|---|
| TypeScript/JavaScript | napi-rs 或 wasm-bindgen,生成二进制 wire 格式;类和 async 都支持 |
| Python | PyO3(abi3),直接类型转换,带类型的异常 |
| C | extern "C" 函数,保留原函数名 + 头文件 |
| Go | 类型化的 cgo 调用 + 生成的二进制 wire,放在一个保留原 API 的包里 |
| Ruby | magnus 扩展,放在原模块下 |
| Java | 类型化 JNI + 生成的二进制 wire,放在保留原方法的包装类里 |
| PHP(preview) | 待做:PHP FFI over C ABI |
| C#(preview) | 待做:P/Invoke over C ABI |
Rust 那边的 src/lang/ 目录,每个语言一个文件,最大的是 src/lang/python.rs(45 KB)和 src/lang/php.rs(34 KB)。
哪些东西不能跨桥
这是最实用的一段。bridge 会自动把” 跨不过去” 的导出留在原语言里,并说明理由。TypeScript 的话:接收或返回函数的、生成器和迭代器、RegExp、instanceof 检查、泛型(可以用 --as-json T 桥接一个只填数据的类型参数)、以及类型里(跟着 import、re-export、extends 一路追下去)藏了函数的。
作者在 x18n 项目上发现:55 个导出里有 26 个属于这一类。这些如果硬移植,会改掉公开 API 或者悄悄坏掉。剩下的放进 Rust 的 API 和原来完全一样,调用方一行都不用改。
JSON 表达不了的东西怎么办
这是我写 Rust 迁移时踩过最多次的坑。JSON 表达不了 undefined、NaN、Infinity、-0、孤立代理对(lone surrogate)。rust-anything 的做法是给结构化值带标记({"$undefined": true}、{"$num": "NaN"}、{"$utf16": [...]}),生成的 index.cjs 负责翻译。
X2 这条决策记录了这些标记每一个的真实来源:
Each one produced real mismatches:
splitKey‘snamespace: undefined,toWireRangewith NaN,diffTextsplitting an emoji,isOutdated(change)with one argument.
每一个标记背后都是一个真实的 bug。孤立代理对那个,是被 fixture 测试发现的 ——JS 的 slice 能把一个 emoji 切成两半。
六、核心机制四:--batch 才是真正快的地方
这是我读完全部文档后觉得最有价值、也最反直觉的一节。
README 里有一句警告:
Calling Rust once per small function is usually slower than a JIT; rust-anything finds the loop worth moving, and moves it.
翻译:小函数每次调用都跨一次桥,通常比 JIT 还慢。rust-anything 帮你找到那个值得搬的循环,然后把整个循环搬走。
为什么会慢
因为跨桥有成本。DECISIONS.md 里的实测:
S1 | … JSON cost 10-50x the work: the colorsys port took 11.7 µs per call, CPython 0.5 µs.
Python 的 colorsys 移植一次调用 11.7 微秒,CPython 原生 0.5 微秒,差 23 倍 —— 跨桥的开销比业务逻辑本身还大一个数量级。所以关键不是” 把函数写快”,而是” 别每次都跨”。
--batch 做什么
1 | rust-anything bridge . src/fuzzy.ts --batch fuzzyScore:text |
生成的类接收一批 item,item 一次性进 Rust 之后就留在 Rust 里,然后在所有核上并行跑完这一批。JavaScript 侧变成这样:
1 | const search = new FuzzyScoreBatch(keys) // 一次 |
注意返回的是索引而不是字符串 —— 调用方本来就持有那批 item,没必要再传一遍。
实测数字
demo/ 目录里每个都有可复现的 benchmark。x18n 的侧边栏搜索,5 万个 key,4 核:
| 每次查询 | 对比 TS | |
|---|---|---|
TS: map(fuzzyScore) + filter + sort |
10 ms | 1x |
| TS 用同样的收窄逻辑 | 4.1-5.4 ms | 2x |
| 同样的移植,逐个 key 调用 | - | 0.2-0.4x(更慢!) |
FuzzyScoreBatch,默认索引(4 核) |
5.1 ms | 1.7x |
FuzzyScoreBatch + FuzzyScoreIndex(napi,4 核) |
0.45-0.56 ms | 18-22x |
| 同样但用 wasm(单线程) | 0.95 ms | 11.5x |
看清楚第 3 行:同一个移植,逐个调用反而比原版慢。这就是为什么 profile 必须先跑。
FuzzyScoreIndex 是什么
这是 port.rs 里的一个 struct,作者手写的,设计很讲究:每个 key 预先转小写并附带字符掩码;建一张表记录每个常见字符在每个 key 里第一次出现的位置(一个字母的查询就是一列);缓存上一次查询的匹配结果,接着输 se 的时候只重算 s 匹配过的那部分。
DECISIONS.md 里有一句:
S15 | An index in
port.rsmay define its ownrank(<fixed>, min); the generatedrankof every language then calls it instead of rankingrun‘s results.
排序可以比全部打分便宜:x18n 的 index 收窄到上次查询的匹配项,单字母查询直接查表,wasm 上从 1.7x 提到 11.5x。而 S10 说明了为什么这个设计能成立:
Preparing items once (lowercasing, masks) was the second 4x on x18n search; one
port.rsthen builds for napi and wasm.
也就是一份 port.rs,同时编译成 napi 版本和 wasm 版本。桥接方式可以换,算法代码不用动。
各语言批量对比
| 语言 | 工作负载 | 原版 | 逐个调用 | 批量 |
|---|---|---|---|---|
| TS | x18n 搜索,5 万 key | 10 ms | 0.2-0.4x | 20x |
| Python | slugify,2 万字符串 |
98 ms | - | 17x |
| Ruby | slugify,2 万字符串 |
110 ms | - | 12.7x |
| Ruby | shellescape(标准库),5 万值 |
88 ms | - | 11.8x |
| Go | Slugify,5 万字符串 |
49 ms | 0.93x | 4x |
| Java | slugify,5 万字符串 |
43 ms | 0.68x | 3x |
Go 和 Java 只快 3-4 倍,因为它们原本就是编译型语言,逐项调用本来就已经很快,批量的收益主要来自多核。文档里那句总结很实在:
Compiled originals gain less: the per-item work is already fast, so the batch wins by the number of cores.
一个小坑:mimalloc
DECISIONS.md 的 S12 记着,带批量的 crate 用 mimalloc 作全局分配器:系统分配器会把线程串行化(纯 Rust 4 核只有 1.6x,在 Go 进程里甚至比单线程还慢),换 mimalloc 后是 3.2x。
七、核心机制五:profile —— 迁移顺序也是数据决定的
移植顺序不是拍脑袋定的。
1 | rust-anything profile . -- node bench.mjs |
它用目标语言自己的 profiler 跑一个真实负载:Node.js 用 node --cpu-prof,Python 用 cProfile,Go 用 go test -cpuprofile 加 go tool pprof -raw(保留内联帧),Java 用 JFR 执行采样,Ruby 用通过 RUBYOPT 加载的 TracePoint 调用追踪器。
Ruby 那条在 DECISIONS.md 里有解释:
Ruby has none built in that samples, and stackprof is a gem the repository may not have.
所以用 TracePoint 自己写了一个。文档也承认代价:”The Ruby tracer slows the program several times; shares stay comparable.”
输出的不只是” 哪些函数热”,还有谁在调用它、哪些循环值得批量。S8 这条决策说得最清楚:
Which code to port is a property of how it is called, not of the code: x18n’s
fuzzyScoreis a leaf (slower in Rust per call) but a quarter of a search, called 50,000 times by one loop.
fuzzyScore 单独看是个叶子函数,移植过去一定更慢。但它是整个搜索的四分之一时间,被一个循环调用了 5 万次。
只看代码你永远看不出来这件事,只有 profile 能看出来。
analyze 排顺序
rust-anything analyze . 输出:单元划分、迁移顺序(wave)、风险带 file:line、每个单元用什么桥、依赖到 crate 的映射,以及 start_here(最值得先动的几个)。
单元的 wave 来自单元图的强连通分量:
A5 | Waves come from strongly connected components of the unit graph. | Leaves first means a Rust unit never calls back into JS; cycles must move together.
叶子先动,意味着 Rust 单元永远不会回调 JS;有循环依赖的必须一起搬。
风险打分
| 风险 | 严重度 | 例子 |
|---|---|---|
| 字符串偏移 | high | slice、indexOf、matchAll、d flag:UTF-16 vs UTF-8 |
| 正则语法 | high | lookaround、反向引用、y:Rust 的 regex crate 没有 |
| 动态正则 | high | new RegExp(userPattern) |
| 动态代码 | high | eval、new Function、动态 import() |
| 动态类型 | medium | any、'key' in value |
| 有序集合 | medium | Map、Set、Object.keys:插入顺序 |
| 异步、生成器 | medium | promise 和 generator 边界 |
| 类继承、反射 | medium | extends、Proxy、Reflect、Symbol |
| 回调形状的 API | medium | 函数类型的参数和方法:桥会很啰嗦 |
| 异常、数字、JSON | low | throw、位运算、JSON.stringify 顺序 |
A6 这条决策解释了为什么用启发式:
False positives cost a look; false negatives cost silent bugs.
误报只是多看一眼,漏报是静默的 bug。所以宁可多报。
就绪度与优先级的公式
A7 规定就绪度 = 100 − 加权风险(取对数)− 规模 − fan-in − 依赖惩罚 + 测试加分。A8 规定优先级 = 一半就绪度 + 一半价值(每行的循环和字符串工作量、有没有测试、规模是否在 80 到 600 行之间)。
就绪度算的是” 安不安全”,优先级是” 安不安全 + 值不值得”,对半分。为什么对半?A8 的理由:
Readiness alone picks trivial declaration files.
只按就绪度排,你会先挑到一堆只有类型声明的空文件。
八、核心机制六:shadow 和 gate —— 上线前的两道闸
shadow:新旧并行跑
1 | rust-anything shadow rust/fuzzy-rs |
生成一个 drop-in 替换模块,它同时跑原版和 Rust 版,返回原版的结果,同时把不一致的地方报出来。
L9 这条决策说得很清楚:
Shadow mode returns the original’s result, runs Rust second, and never lets Rust errors reach callers. | Shipping shadow code must not change behavior; only the report sees Rust.
为什么要这个模式?D5 引了 Cloudflare FL2 的做法:
Cloudflare FL2 ran old and new side by side in one process and moved traffic gradually. Tests prove a port; production traffic confirms it.
测试证明移植是对的,生产流量才能最终确认。 而且这个需求不是 Rust 独有的,所以每种语言都有 shadow 模式 ——Ruby 用 prepend,Java 用 <Class>Shadow 类,C 用 -D 重命名加一个 shadow crate feature,Go 就是一个包。
gate:一整套” 做完了” 的定义
1 | rust-anything gate rust/fuzzy-rs |
gate 一次性检查:
cargo fmtcargo clippy -- -D warningscargo testunsafe审计:只允许有// SAFETY:注释的- 没有未实现的函数
- 构建通过
- API 存在
- 行为一致(录的用例全部匹配)
- 错误路径全覆盖:原版的每条错误路径都要有一个录下来的失败用例
- 原始版没报错的地方,Rust 不能
unwrap/expect/panic!(除非标了// INFALLIBLE: <why>) - 代码规模:Rust 版行数不能超过原版的 3 倍(外加 50 行给 import 和签名)
规模这条在 FAQ 里有解释:
gatecompares the port’s lines with the original’s and fails above 3x (plus 50 lines for imports and signatures): that usually means hand-writing what a crate already does, or handling cases one by one. |analyzelists the crates to use.
意思就是:如果你 Rust 写了三倍多的行数,通常说明你在手写一个现成的 crate 该干的事。
bench 单独存在,不并进 gate
X5:
benchis a separate step, not part ofgate. | Speed is not correctness, but it decides whether a port should ship: every x18n core port was correct and slower.
x18n core 的每一个移植都是正确的,但是更慢的。如果 bench 在 gate 里,这些移植根本过不了门。
S4 记录了 bench 的结论逻辑:
benchends with a verdict: ship, keep the slower functions, port a bigger unit, or (for C) optimize the port. Faster is 1.1x or more, slower under 0.9x.
四个结论:可以上线 / 保留原版(更慢的那些函数) / 换一个更大的单元来移植 / (C 的话)优化这个移植。
注意阈值是不对称的:1.1 倍算快,0.9 倍以下算慢。中间地带算” 持平”。
九、核心机制七:整个应用的迁移 —— app 系列
前面都是单个函数或模块。但真实需求是” 把整个应用变成 Rust”。
这是 v1.1.0 引入的,也是我认为这个项目最有野心的部分。
五个命令
1 | rust-anything app record . -- python3 cli.py # 把整个应用的行为录下来 |
app record:黑盒录整个应用
应用是黑盒。app record 会跑三组用例:应用文档里的例子(README 和 shell 文件里的 $ mytool ... 行,还有那些例子提到的文件)、--inputs 提供的 JSONL({"name", "args", "stdin", "env", "files"})、以及语义陷阱(非 ASCII 和 emoji 字符串、负除数和负取模、溢出、极大和极小的浮点、map 顺序、文件不存在)。每个用例跑两遍,差异变成通配符。
用例存成 trycmd 格式的文件(hello.toml 存 argv/env/exit code,.stdin、.stdout、.stderr、.in/ 输入文件、.out/ 写出的文件),可以直接手工编辑,Rust 侧有现成的测试跑它们。
app replay:一个数字加一份报告
rust-anything app replay . 输出 passed/total,写一份 rust/app-cases/replay-report.md,每个失败的用例带 diff,任何不匹配就非零退出。
报告里没有时间戳,也没有临时路径 —— 同一个 build 跑两次 replay,写出来的文件一模一样。这是为了能进 CI:
Commit it and run
app replaythengit diff --exit-code rust/app-cases/replay-report.mdin CI, and a half-ported app fails CI on any change in what passes, better or worse, until the report is updated with it.
半迁移状态的应用,只要通过率有变化(不管是变好还是变坏)CI 就会红,直到有人更新报告。这个设计把” 迁移进度” 变成了一个可版本控制的、CI 可校验的东西。
app front-door:Rust 前门
rust-anything app front-door . 生成 rust/app,一个以应用命名的 Rust 二进制:clap 解析器负责命令和参数,每个命令转发给原版,原版输出和退出码原样透传,每次 fallback 都计数。所以一上来 replay 是 100% 通过、100% fallback—— 它构建并回放来证明这一点。
它从不覆盖 rust/app:一旦生成,代码就是你的了。
app wire:一块一块把命令交给 Rust
rust-anything app wire . textkit --command upper 会在单元 crate 上跑 gate、把它作为库加进 rust/app、写一个胶水桩(src/units/textkit.rs)、重新生成路由,然后构建并回放。胶水桩留给你写:
writes a glue stub (src/units/
.rs, yours to write: parse args, call ::port, print what the original prints)
还有一个 kill switch:RUST_ANYTHING_UNIT_TEXTKIT=original 设了这个环境变量,wired 单元就退回原版。这是生产环境出问题时最快的回滚方式。
app lift:变成纯 Rust
rust-anything app lift . 会先检查并拒绝,列出所有阻塞项:还有用例在 fallback、胶水还是桩、有单元没过 gate。
都过了之后,它先在副本上操作:移除 fallback 路径和 kill switch,把每个单元 crate 变成 rust/app 的普通库(不再有 cdylib、绑定和生成的包装),加上 rust/app/tests/app_cases.rs,让 cargo test 就能跑 app-cases。
然后跑一遍 lift 清单:fmt、clippy、测试、rust/DECISIONS.md 里提到的每个 target、运行时读取的文件和没被嵌入的资源、纯二进制上的 replay。
全部通过之后才写回。原版永远不动。
HTTP 服务器
同一套命令证明 HTTP 服务器:
1 | rust-anything app record . --http -- node server.js |
--http 表示命令会启动一个服务器,端口从 PORT 环境变量或命令里的 {port} 取。请求来源是应用文档里的 curl 行、--inputs({"name", "method", "path", "headers", "body"})和陷阱 —— 路径段与查询值换成跟 CLI 参数一样的陷阱,body 用文本和 JSON 陷阱,再加一个未知路由。
每次运行都重新启动服务器,按名字顺序发请求,所以请求之间的状态是保留的。还有两个服务器专属选项:--fresh db.json(服务器读写状态文件时,每次启动都从快照复制一份到新的工作目录)和 --pace 50(每个响应后等 50 毫秒)。
--pace 是被 json-server 的真实 bug 逼出来的:
Found in json-server: after each of its own writes, its file watcher reloads the file. When the next request writes before that reload ends, the reload can wipe that write out: the first recording, sent as fast as the server answered, had a POST answered 201 that later reads did not show.
json-server 每次写完文件,文件监视器会重新加载文件。如果下一个请求在重载完成前就写,重载会把那次写覆盖掉。第一次录制时(请求发得跟服务器回的一样快),有个 POST 返回了 201,但后来读的时候看不到那条数据。所以录制时必须加 --pace 50。
前门是 axum 服务器,在另一个端口上启动原版,把没有单元应答的路由全部代理过去。
十、三个真实案例:它到底行不行
案例一:vercel/ms —— 结论是” 是个好移植,坏的提速目标”
vercel/ms 5.5k star,把 "2 days" 转成毫秒又能转回来。
| 步骤 | 结果 |
|---|---|
analyze |
1 个单元(src/index.ts),就绪度 96 |
bridge --kind napi |
ms、parse、parseStrict、format 都桥接了,没有留在 TS 的 |
record --from-tests -- jest |
975 个用例:生成的、陷阱的,加上从 167 个 Jest 测试里抓到的 340 次真实调用 |
| 移植 | 184 行 TS 换成 200 行 Rust,含一个每批只读一次 options 的 FormatIndex |
diff |
第一次构建 784/784 匹配;加上抓到的调用后 975/975 |
gate |
通过 |
bench 逐次调用 |
0.56x(比原版慢) |
批量 parse × 10 万 |
JS 11.8 ms,Rust 0.65 ms:18x |
批量 format × 10 万 |
JS 2.1 ms,Rust 2.5 ms(算交接):0.8x |
最后一行是全篇最重要的一行:format 批量化之后还是比 JS 慢。作者的结论:
The verdict:
msis a good port and a bad speed target. Correct on every recorded case, faster only when a program parses many durations in one go.
翻译:ms 是个好移植,但不是好的提速目标。每一个录制的用例都正确,只有当程序一次性解析很多时长时才更快。这个案例的价值恰恰在于它没有把话说得漂亮。
这个移植还暴露了一堆 JS 语义细节,每一个都被录制的用例抓住了:/.../i 不带 u flag 时只折叠 ASCII 字母,而 Rust 的 regex 折叠 Unicode,所以 "1 ſ"(长 s)和 Kelvin 符号会被错误地解析成秒,移植里改成手工按 ASCII 单位匹配;Math.round 是” 半数进位”(-2.5 得 -2),Rust 的 round 是远离零;${n} 会把 -0 打印成 0,把 1e+21、5e-324 这么打,移植里复刻了 JS 的数字转字符串(第一版还有个平局 bug,25.728225708007812 打成 ...813,只是 ms 的整数输出碰不到);str.length 数的是 UTF-16 单元,所以 100 字符的限制里一个 emoji 算两个。
案例二:Fuse.js —— 32 倍
Fuse.js 20k star,每周五大约 2000 万次 npm 下载,是无数搜索框背后的模糊搜索库。
有意思的是,它不能按文件逐个移植:
analyzeput every folder ofsrc/in one import cycle, so Fuse cannot be ported file by file.
src/ 下每个文件夹都在同一个 import 环里。作者换了个思路:走搜索真正花时间的那条路径 —— 一个 54 行的适配器(adapter/relevance.ts)导出 Fuse 自己给一个字符串列表里某个字符串的分数,基于 Fuse 的 BitapSearch、字段范数和 computeScoreSingle。这个函数就是”5 万个字符串的搜索” 会跑 5 万次的东西。
| 步骤 | 结果 |
|---|---|
| 适配器 | 在任何 Rust 代码之前,适配器的排序结果就等于 new Fuse(list).search(q),在 81 个查询和选项集上验证过 |
record --inputs |
3,414 个用例 |
| 移植 | 673 行 Rust 顶替 839 行 Fuse |
diff |
3,414/3,414 第一次构建就匹配 |
gate |
通过 |
| drop-in | withRust(Fuse) 在 Rust 里答字符串列表搜索,其他全部交给 Fuse;360 次搜索返回逐字节相同的结果 |
搜索耗时(Apple M4,10 核,Node 24):
| 列表 | Fuse.js | Rust | 加速 |
|---|---|---|---|
| 1,000 字符串 | 1.9 ms | 0.1 ms | 18x |
| 10,000 字符串 | 19.1 ms | 0.7 ms | 27-30x |
| 50,000 字符串 | 91.2 ms | 2.8 ms | 32x |
| 50,000 字符串,单核 | 92.0 ms | 17.5 ms | 5.3x |
这个案例里也有一堆 JS 语义坑:
- Bitap 跑在 32 位 JS 整数上:
1 << 31是负数,(1 << 31) - 1是双精度数,下一次移位又变成2147483647。移植保留了这些值。 - 文本按 UTF-16 码元索引,所以一个 emoji 占两个位置,跟 Fuse 一致。
ignoreDiacritics是 NFD 加一份组合记号范围表,加几个单独列出的字母(ł、ß、ı)。移植用了同一份表。String.prototype.trim决定哪些字符串被 Fuse 跳过:JS 的空白集,不是 Rust 的char::is_whitespace(后者包含 U+0085 而漏掉 U+FEFF)。
作者也诚实写了它不覆盖什么:
What it does not cover: object lists with
keys, extended and token search, logical queries,includeMatches, a customsortFnorgetFn.
案例三:json-server —— 完整走完全应用流程
json-server 75k star,用一个 JSON 文件提供 REST API。这是第一个用 whole-app 流程完整移植的应用。
| 步骤 | 结果 |
|---|---|
analyze --whole-app |
一个服务器,9 个单元(7 个 ready,2 个 caution),13 个要替换的依赖(tinyhttp、lowdb、sirv、eta、milliparsec、dot-prop、sort-on、inflection……) |
app record --http |
514 个用例:268 个 --inputs 给的请求(每条路由和方法、where 操作符、sort、分页、embeds、CORS 预检、静态文件和范围、29 个畸形 JSON body、/__proto__ 等原型名、坏转义)+ 245 个陷阱;每个录两遍,随机 ID 留成 [..] |
front-door |
513/514,99.8% fallback。漏的那条是 URL 里的裸 ü,Node 回 400 而代理重新编码了 |
| 单元 | where-operators 207、parse-where 289、matches-where 1,346、paginate 853(含 json-server 自己测试里的调用);service 461 和 app 243 通过两个小适配器;六个单元全部 gate 通过 |
wire |
先接读操作:514/514,22.6% fallback,Node 负责写、Rust 重载 Node 写的文件;然后接全部路由:514/514,0% |
lift |
一个纯 Rust 二进制(5.3 MB),514/514;bin.ts 的命令行部分手工移植(help、version、文件检查、启动横幅) |
性能对比(Apple M4,10 核,16 GB,macOS 27.3,Node 24.15.0,ab -k 压测):
| 请求 | Node 单连接 | Rust 单连接 | Node 50 连接 | Rust 50 连接 |
|---|---|---|---|---|
GET /posts |
11.1k / 10.8k | 27.3k / 23.9k | 19.7k / 20.4k | 115.0k / 110.7k |
GET /posts/1 |
11.0k / 11.3k | 27.7k / 25.4k | 21.9k / 22.6k | 119.9k / 99.0k |
| filter + sort + page | 10.5k / 10.0k | 25.2k / 21.5k | 18.3k / 16.4k | 107.5k / 96.3k |
?_embed=comments |
8.7k / 6.6k | 22.5k / 21.8k | 13.8k / 11.0k | 98.3k / 100.6k |
GET /(首页) |
7.3k / 6.3k | 27.6k / 21.7k | 10.2k / 9.5k | 135.1k / 119.3k |
内存对比:
| Node | Rust | |
|---|---|---|
| 空闲 RSS,小库 | 74 MB | 3.5 MB |
| 峰值 RSS,小库 | 424 / 390 MB | 18 MB |
| 峰值 RSS,1 万 posts | 462 / 485 MB | 289 / 291 MB |
作者也诚实指出差距小的地方:
Where the gap is small: one connection reading the whole 10,000-post list (1.2x: both spend the time printing 1.5 MB of JSON), writes on the big database (1.1 to 1.2x…), and the sorted title search on one connection (1.4x). | The large gains come from concurrency, which a Node process does not have
大头的收益来自并发,而 Node 单进程给不了。
还有一段我觉得特别精彩的调试记录。第一次 lift 出来的二进制比 Node 还慢(整个列表 33 vs 298 req/s),profile 出来五个原因,按顺序:没设 TCP_NODELAY(每个大响应要等大约 40 毫秒的延迟 ACK)、每次写之前整个数据库克隆一遍加 $schema、每个列出的项打印前克隆一遍、所有请求共用一把锁、1 万个 item 的 item.id 各用 SipHash 哈希一遍。全修完,而且每次修改后 3,399 个单元用例和 514 个 HTTP 用例都还是通过。这就是” 先有可验证的基准,再优化” 的典型案例。
十一、它是怎么做 Agent 集成的
这是我觉得设计上最聪明的一块。
D1 这条决策是整个项目的定调:
A toolkit your agent drives, not a translator that calls a model itself. | No model cost or vendor lock-in; works with any agent. | The checks are the part an agent cannot do reliably.
翻译:这是个你的 Agent 驱动的工具箱,不是个自己调用模型的翻译器。没有模型成本,没有厂商锁定,跟任何 Agent 都能配合。检查这件事,Agent 自己做不可靠。
所以它同时提供两种形态:
CLI(人可以自己跑)和 MCP server(Agent 调工具)。
rust-anything setup 一条命令,把 MCP server 和工作流 skill 都注册到你找到的每个 Agent 里:Claude Code 写 ~/.claude.json 和 ~/.claude/skills/,Codex 写 ~/.codex/config.toml 和 ~/.codex/skills/,Cursor 写 ~/.cursor/mcp.json,Gemini CLI 写 ~/.gemini/settings.json;其他 MCP 客户端可以手动加 rust-anything mcp 作为 stdio server。
S16 这条决策专门讲了怎么不弄坏你的配置:
setupwrites each agent’s own config … adding only therust-anythingentries, keeping key order, writing through a temporary file, and refusing files that do not parse. | A tool that rewrites someone’s settings must never lose them.
只加 rust-anything 相关的条目,保留 key 顺序,通过临时文件写入,遇到解析不了的文件直接拒绝。 改别人配置的工具绝不能把别人配置搞丢。改文件之前还会备份(<file>.rust-anything.bak),--remove 可以撤销。
MCP 工具就是 CLI 命令的一一对应(docs/tools.md 明确说了 “Every tool is also a CLI command with the same options”),所以 Agent 可以调 analyze、bridge、record、diff、bench、shadow、gate、app_record、app_replay、app_front_door、app_wire、app_lift 这些。
README 里给了几个问法:” 用 rust-anything 把这个 CLI 端到端重写成 Rust,并证明行为一致。”” 这个搜索感觉很慢,用 rust-anything profile 一下,把热循环搬到 Rust。”” 在 rust/text-rs 上 bench 一下 Rust 移植版,告诉我该不该上线。”
安装
1 | cargo install rust-anything # 从 crates.io |
没有 Rust 工具链?每个 GitHub release 都附带 macOS、Linux、Windows 的预编译二进制。JavaScript 项目可以直接:
1 | npm install -g rust-anything |
Claude Code 里还能当插件装:
1 | /plugin install rust-anything --marketplace erkamyaman/rust-anything |
十二、它做对的几个设计决定
我想单独拎出几条 DECISIONS.md 里我认为最有价值的。
1. 保守优先
A6 | False positives cost a look; false negatives cost silent bugs.
误报只是多看一眼,漏报是静默的 bug。整个工具的设计基调是” 宁可吵,不可漏”。
2. 不猜
A9 | The library-to-crate table (
src/crates.toml, every language) is hand-curated; unknown packages are reported asunknown, never guessed. | The prompt: flag missing equivalents instead of hand-rolling silently.
crate 映射表是手工维护的(src/crates.toml,19 KB)。找不到对应 crate 的包,一律报 unknown,绝不猜。 如果它猜错了,你会得到一个能编译但行为完全不同的实现 —— 而这正是这个项目要消灭的东西。
3. JSON 输出带版本
A10 | JSON output carries
schema: rust-anything/analyze@1. | Agents read it; it is a wire contract and gets versioned.
因为 Agent 要读这个 JSON,所以它是一份 wire contract,得有版本号。
4. 只在端点检查行为,不检查内部
The recordings check behavior at the app’s edges (a CLI’s output, a server’s responses, a module’s exported functions), not its internals. | Mirror the old structure while units still cross the bridge; once
app lifthas removed the original, restructure the Rust freely, andapp replaystill proves the behavior.
意思是:录制只检查边界行为(CLI 输出、服务器响应、模块导出),不检查内部实现。过渡期你可以照着老结构写,等 lift 做完把原版拿掉了,Rust 内部就可以随便重构,app replay 依然能证明行为。这解决了我一开始担心的那个问题 ——“会不会被老代码的设计锁死”。
5. 方向是单向的
Nothing calls back into the original either: the front door runs it as a separate process (or forwards HTTP to it), bridged units are called by the original and never the other way round, and callbacks stay in the source language.
原版永远不会被 Rust 回调。前门把它当独立进程跑(或者把 HTTP 转发过去),被桥接的单元是原版调 Rust,反过来不行。这保证了不会有” 互相调用” 导致的死锁或无限递归。
6. 你的代码不出本机
Does my code leave my machine? No: rust-anything runs locally and sends none of your code anywhere. | Cargo downloads crates as usual, and your agent’s model provider sees what your agent sends it, under its own policy.
十三、诚实的局限
这一节我尽量写全,因为对判断” 该不该用” 最重要。
录不到的就查不出来
文档里有一节叫 “What it can’t catch”,写得非常诚实。
没录过的输入。 生成的用例、语义陷阱、原版的测试套件(record --from-tests)和你自己的 --inputs,就是天花板。而文档说得很直接:
Add real inputs (production samples, bug reports); the user input that breaks prod is rarely one a generator thinks of.
会破坏生产的那个用户输入,生成器基本想不到。 这一条我认为是最要命的。
正则。 Rust 的 regex crate 没有 lookaround 和反向引用,而且就算能编译的 pattern,\w、\b、\d 和非 ASCII 上的大小写不敏感匹配,在 JS、Python、Java 之间都不一样。换 fancy-regex 或重写 pattern,可能通过所有录制的用例,但在土耳其语的点 less i 或者零宽连接符上还是不一样。record 会给每个用到正则的文件的每个函数加正则陷阱,但文档还是建议你拿真实 pattern 对真实文本 fuzz 一遍。
运行时会变的东西。 时间、内存、负载下的并发行为、以及 stdout/stderr/ 退出码 / 写出的文件 / HTTP 响应之外的副作用(网络调用、数据库、信号)都不比较。
浮点数。 数字转文本的格式在不同语言里不一样(1e21、-0、位数)。--float-tolerance 只宽容舍入,永远不宽容格式。
其他平台。 录制只能证明录制那台机器上的行为。依赖类型大小、字节序或编译器的 C 代码在目标平台上可能完全不同 —— 所以 analyze 会把面向硬件的 C 留在 C 里。
profile 只是”Tested” 状态
STATUS.md 里,命令的状态是分级的:Verified(端到端跑过真实代码)、Tested(有 fixture 测试但没跑过真实项目)、Preview。
而 profile 是 Tested,不是 Verified:
| 命令 | 状态 |
|---|---|
analyze |
Verified(x18n 的 142 个单元) |
bridge、record、diff、gate、build |
Verified |
bench |
Verified |
record --from-tests |
Verified (TS/JS),Tested (Python) |
--batch |
Verified |
| wasm bridge | Verified |
shadow |
Verified |
profile |
Tested |
app record、app replay |
Verified (servers),Tested (CLIs) |
front-door、wire |
Verified (TS server) |
lift |
Verified (TS server),Tested (CLIs) |
| MCP server | Tested |
所以这个工作流里,最前端的那一环(profile)反而是最没被真实项目检验过的。这是个有点尴尬的事实,值得知道。
各语言的支持程度差别很大
从 DECISIONS.md 的 “Known limits”:
- C:只有标量和
const char *的 API 能跨桥。输出缓冲区(char *out, size_t *len)和状态结构留在 C,通过宏定义的函数看不到。 - Go:方法、泛型、可变参数、指针、接口和 channel 留在 Go。结构体参数以 JSON 跨(用导出字段)。
- Ruby:只支持模块函数(
def self.x、module_function)。类和接受 block 的方法留在 Ruby。 - Java:只支持 public 类的
public static方法。重载、泛型、char和对象类型留在 Java。而且record只用javac单独编译模块源码,所以依赖 Maven classpath 的代码现在还录不了。 - Shadow 模式只比对同步结果:会改参数的函数,第二个实现拿到的是已经被改过的输入。
C 还有一条特殊情况:
M5 | C records each case in a forked child; a crash is recorded as
crash: <signal>and accepts any port behavior. | Inputs outside a C function’s contract are undefined behavior: real glibc segfaults onisalpha(INT_MAX).
C 的每个用例都在 fork 出的子进程里跑,崩溃记成 crash: <signal> 并接受任何移植行为。因为超出 C 函数契约的输入就是未定义行为 —— 真实的 glibc 在 isalpha(INT_MAX) 上就会 segfault。
浮点数基本匹配不了
FAQ 里说得很直接:
Often not: operation order, fused multiply-add and the math library differ between compilers.
如果你的代码是数值计算,--float-tolerance 1e-9 能宽容舍入,但整数、文本和结构必须完全一致。
它不翻译代码,也不认识二进制
It ports source code: it parses the functions, records what each one does, and checks the Rust against the running original. | A compiled app has none of that to work with, and
analyzesays so.
APK、JAR、exe 这种编译产物是搞不定的。” 根据二进制的可见行为重写一个 Rust 应用” 是另一个项目。
Kodebase 结构上的限制
- Fuse.js 那种” 整个
src/在一个 import 环里” 的项目,不能按文件逐个移植。作者得绕路走适配器。 - Go 的 profile 必须来自
go test跑,因为 Go 的 pprof 只能在进程内用。 - Ruby 的追踪器会让程序慢好几倍。
- Ruby 用
alias建的别名会复制原方法,所以 shadow 模式看不到通过别名的调用。
项目非常新
仓库 2026 年 11 月 16 日创建,今天是 19 日。三天。
v1.0.0 到 v1.5.1 一共 9 个 release,全在 11 月 16 日到 18 日之间。这三天里作者自己也在疯狂修 bug(v1.5.1 修的就是 recorder 卡死的问题 —— 某个生成的输入让原版跑飞了,比如 [w] * n 分配几个 GB)。
虽然作者很勤快(156 次提交,第二名贡献者 46 次),但任何 3 天大的项目都不该直接用在生产环境。
十四、跟同类项目比
vs. 用 AI 直接重写
这是最直接的对比,也是最有价值的对比。
AI 直接重写的流程是:给上下文 → 生成代码 → 跑测试 → 修。问题在于:AI 猜语义(UTF-16 vs UTF-8、Math.round 的方向、-0 的打印、正则语义 —— 这些 AI 经常知道,但不知道的更多);没有基线(AI 写完你怎么知道它对?你得自己写测试,那比重写还累);“跑通测试” 不等于” 行为一致”(你现有的测试只覆盖你写过的路径)。
rust-anything 的价值在于:它把” 行为一致” 这个模糊目标变成了一个机械的、可重复的、可进 CI 的检查。AI 依然要写 Rust,但写的是算法,而不是语义 —— 语义由录制固定。
DECISIONS.md 那句话说得最好:
The checks are the part an agent cannot do reliably.
vs. C2Rust / TRACTOR / Depyler
C2Rust 是最著名的 C 到 Rust 翻译器,但它只能处理 C(rust-anything 支持 6 种语言),而且是翻译(transpile),产出” 能编译的等价物”,不保证行为一致,也没有录制 / 回放机制。
DARPA 的 TRACTOR 项目(2025 年)是 C 到 Rust 的转换研究项目,目标是全程序转换加形式化验证。rust-anything 的路子不一样:它不追求全程序转换,追求增量、可验证、可回滚。TRACTOR 那套更适合一次性转换,而真实项目里几乎没人能接受” 整个仓库冻结几个月”。
Depyler 尝试用 AI 把 Python 转成 Rust,有意思的实验,但产出质量不稳定。
rust-anything 选了 TS/JS 作为第一语言(D2),理由是:
No existing tool covers TS/JS to Rust. C/C++ and Python are crowded (DARPA TRACTOR, C2rust, Depyler).
它的立场正好相反:不让 AI 写转换逻辑,只让 AI 写算法。
vs. wasm-pack / PyO3 等桥接库
这些是底层工具,rust-anything 是上层工作流。
wasm-pack 帮你把 Rust 编译成浏览器能用的 wasm,但它不告诉你该编译什么、不保证行为一致、也不管迁移顺序。
rust-anything 在这些之上加了:选谁、什么顺序、怎么验、什么时候能上线。
vs. 手工做 differential testing
最像的对比对象。手写 fixture、手写对照测试,跟 rust-anything 的 record/diff 思路一致。
差别在于覆盖面和自动化程度。rust-anything 的优势是自动生成边界值和语义陷阱,而且陷阱清单是踩过坑积累出来的(UTF-16、孤立代理对、-0、final sigma……)。人写测试很难想到孤立代理对这种。
劣势是:它只能发现你想到的陷阱。你自己的领域知识(比如” 这个函数在负数上语义特殊”)还是得靠你自己喂 --inputs。
独特的位置
综合看,rust-anything 在工具链里的位置是:
1 | Claude Code / Codex / Cursor |
它填补的位置是:AI 编码工具和语言迁移工具之间的那一层。
十五、适合谁,不适合谁
适合
1. 你的项目有明确的性能瓶颈,而且瓶颈是” 热循环”。 最理想的场景,整套 --batch 机制就是为它设计的,profile 会告诉你哪里是。
2. 你在做增量迁移,不想冻结整个仓库。 app front-door → app wire → app lift 这条路就是为增量设计的,每一块都可以单独上线、单独回滚(RUST_ANYTHING_UNIT_<NAME>=original)。
3. 你想用 AI 写 Rust,但担心它会悄悄改变行为。 这正是 D1 那条决策的定位。
4. 你的代码库有测试套件。 record --from-tests 能从测试里抓到真实调用,录制质量会高很多,vercel/ms 的例子就是这么做的。
5. 你在做 CLI 或 HTTP 服务。 app 系列对 CLI 和服务器有一等公民支持,json-server 那套流程可以直接抄。
6. 你想给开源项目做性能 PR。 Fuse.js 那个案例就是模板:写一个适配器,录 3000 多个用例,diff 全过,然后提 PR。
不适合
1. 你的项目本身就是 Python/Go/Java,而且没到性能瓶颈。 从 vercel/ms 的结论看:0.56x,慢了快一倍。
2. 你的代码大量依赖正则、反射、动态特性。 analyze 会把这些标成 high 风险,你要么留在原语言,要么接受大量手工工作。
3. 数值计算代码。 浮点匹配基本做不到,容差机制只是缓解。
4. 你想要一个” 一键全量翻译” 的东西。 它明确不是这个。D2 说得很清楚:TS/JS 优先,因为 C/C++ 和 Python 那块已经挤满了。
5. 你的项目没有行为可录。 比如根本没有可运行的原版,或者原版已经跑不起来。没有基线,一切免谈。
6. 你在生产环境里,需要今天就用。 三天大的项目,三天里发了 9 个 release。作者显然在高强度迭代,但这意味着 API 还会变,文档可能跟实现不同步。
7. 你想要的是”AI 帮我把代码全翻译一遍”。 它是工作流,不是翻译器,而且这个定位是有意的。
十六、我的实际使用建议
如果你要用,我建议这个顺序:
第一步,先跑 analyze 看看它怎么说。 rust-anything analyze . 是只读的,零风险,它会告诉你单元划分、风险点、start_here(最值得先动的)。如果它的 start_here 让你认同,再往下走;不认同就别勉强。
第二步,选一个小单元试水。 不要一上来就 app record --whole-app。先挑一个 analyze 推荐的小单元走完 bridge → record → diff → gate,体会一下录制的质量 —— 看 cases.jsonl 里生成的用例有没有覆盖你真正在意的那些边界,覆盖得不好就先用 --inputs 喂自己的真实输入。
第三步,跑 profile。 注意这是我前面提到的唯一一个 “Tested” 而不是 “Verified” 的命令。你可以拿它当参考,别完全信。
第四步,才是 app record。 这一步最耗时(json-server 录了 514 个 HTTP 用例),而且会真的运行你的原版。README 里有很严肃的警告:
recordandapp recordrun your original code, calling each function (or the whole app) on many generated inputs, andapp recordruns every case twice. | Code that writes files, talks to a database or calls the network does that once per case. | Run them on a copy of the project, with a test database and no production credentials in the environment.
写文件的、连数据库的、调网络的代码,每个用例都会真的执行一次。 在副本上跑,用测试数据库,环境变量里别放生产凭证。
这句话我要再强调一遍,因为这是最容易出事的地方。我的第一反应肯定是” 在仓库目录里直接录一下”,但如果那个仓库连着生产库……
第五步,lift 之前把所有 app record 的用例跑通。
lift 会拒绝并列出阻塞项,这是好事。但你要确保 514 个用例全绿,而不是”99.8% 通过”(json-server 的 front-door 阶段就是 513/514)。
十七、最后
回到我开头那个丢人的场景:Claude Code 一小时给我 900 行 Rust,138 个用例挂了 71 个。
如果当时有 rust-anything,流程会是:
analyze告诉我src/parser/有 14 个单元,3 个有 high 风险bridge生成 crate 和空桩record录下 200 个边界用例,其中包括 UTF-16 偏移、-0、正则陷阱- Claude Code 在
port.rs里写实现 diff告诉我哪几条对不上,并且是具体哪条输入- Claude Code 修,直到 200/200
gate确认 fmt、clippy、测试、错误路径、代码规模bench说” 可以上线” 或者” 别动它”shadow在生产灰度,新旧并行- 下一个单元
同一件事,可能从两周变成一天。
我想强调的不是它有多强,而是它选了一个正确的战场。
“用 AI 重写代码” 这个叙事里,AI 写代码已经够好了,好到瓶颈不在那里。瓶颈在验证。而验证是机械的、可重复的、适合用程序做的。
rust-anything 的作者显然想明白了这件事 ——D1 那句 “The checks are the part an agent cannot do reliably” 是整个项目的题眼。
它不聪明,也不试图聪明。它只是把” 证明这两个实现行为一致” 这件苦活,做成了一条命令。
项目:erkamyaman/rust-anything(3321 star / 262 fork / MIT / Rust / crates.io 1.5.1)
支持语言:TypeScript/JavaScript、Python、C、Go、Ruby、Java(已验证);PHP、C#(preview)
验证状态:7 种语言在真实项目上跑通(json-server 514/514、Fuse.js 3414/3414、vercel/ms 975/975)
安装:cargo install rust-anything && rust-anything setup
注意:项目创建仅 3 天,README 有 19 种语言翻译但只有英文版是作者自己写的,翻译质量需自行核对