Tov 发布：面向编码智能体、可编译为原生二进制的 TypeScript 风格语言

跟着 Tov 的歌一起唱

一种为编码智能体打造的编程语言。你的智能体已经会写 TypeScript，所以它已经会写 Tov，而当它出错时，编译器会返回修复该错误的修改。它交付的是一个原生二进制文件，比 Rust 还快。

$ curl -fsSL https://tov.sh/install.sh | sh

每秒请求数，单核上的 JSON API

Tov242k/s最快
Rust (axum)216k/s慢 12%
Bun111k/s慢 2.2×

fetch()，一次 64 个请求

Tov177k/s最快
Rust (reqwest)162k/s慢 9%
Bun129k/s慢 37%
Node30k/s慢 5.8×

binary_trees：创建并释放数百万个小对象

Tov260 ms最快
Bun376 ms慢 45%
Node449 ms慢 1.7×
C688 ms慢 2.6×
Rust791 ms慢 3.0×

将程序编译为原生二进制文件

Tov42 ms最快
C (clang)49 ms慢 17%
Rust (rustc)98 ms慢 2.3×

内存，运行该 JSON API 时

Tov1.6 MB最少
Rust (axum)4.4 MB多 2.8×
Bun17 MB多 10.4×

Tov 构建程序时会发生什么

Tov 是一个编译器。它检查你的智能体编写的 TypeScript，将其写出为 C 并交给 clang，因此你交付的是一个原生二进制文件，旁边无需安装任何东西。

你的智能体编写 TypeScript

Tov 读取 TypeScript 的语法和类型，数字使用 int 和 f64，并使用 Bun 和 Node 的 API。它省略了那些让程序难以理解的内容：any、null 和 ==。

type Shape =
  | { kind: "circle", r: f64 }
  | { kind: "rect", w: f64, h: f64 }

function area(s: Shape): f64 {
  switch (s.kind) {
    case "circle":
      return Math.PI * s.r * s.r
    case "rect":
      return s.w * s.h
  }
}

Tov 检查每一行

这个用 Rust 编写的检查器能捕获 TypeScript 放过的错误：一个可能失败却没有 try 的调用、一个本应复制却被共享的值、一个漏掉某个分支的 switch。每个错误都有一个代码，并且在修复方案明确时，还会给出相应的修改，由 tov check --json 交给你的智能体。

// without the "rect" case
$ tov check shapes.tov
error[F0301] shapes.tov:6:11: `switch` is not
  exhaustive: missing "rect"
    6 |   switch (s.kind) {
  fix: add case "rect"

它把程序写成 C

整个程序变成一个 C 文件。记录变成结构体，联合体变成带标签的联合体，因此 switch (s.kind) 就是对整数进行 switch。值采用引用计数，计数逻辑写入 C 中，因此没有垃圾回收器来暂停程序。

struct Shape {
    uint32_t tag;
    union { Circle m0; Rect m1; } u;
};

static double area(Shape s) {
    switch (s.tag) {
    case 0: return 3.141592653589793 * s.u.m0.r * s.u.m0.r;
    case 1: return s.u.m1.w * s.u.m1.h;
    }
}

clang 生成一个二进制文件

clang 将那个 C 与 Tov 的运行时一起编译，运行时是一个 C 库，包含事件循环、HTTP 服务器和客户端，以及 Tov 的字符串、数组和映射。运行时只编译一次并缓存，因此构建的大部分时间都花在 clang 上。导入 npm 包的程序还会携带该包和 JavaScriptCore（Bun 使用的引擎）来运行它。

$ tov build shapes.tov --time
check 0.3 ms, generate 0.2 ms, C compile 55 ms
build: shapes
$ ls -lh shapes
34K shapes
$ ./shapes
circle: 3.14
rect: 6.00

智能体如何编写 Tov

1你的智能体编写 TypeScript

// hello.tov
Bun.serve({
  port: 3000,
  fetch(req) {
    const url = new URL(req.url)
    return new Response(`Hello from ${url.pathname}`)
  },
})

2Tov 返回修复方案

$ tov check --json
{
  "code": "T0831",
  "message": "`new URL` can throw `TypeError`; mark the call `try` to pass the error on, or catch it",
  "fixes": [{
    "applicability": "safe",
    "edits": [{ "line": 4, "col": 17, "text": "try " }]
  }]
}

3你发布的是原生二进制文件

// the agent applies the fix
const url = try new URL(req.url)

$ tov build hello.tov
build: hello
$ ls -lh hello
152K hello
$ ./hello & curl :3000/agents
Hello from /agents

它是 TypeScript

使用你的 agent 从 Bun 和 Node 中熟知的 API。Bun.serve、fetch、node:fs、async/await 和 npm 包都能如预期般工作。

更少出错

没有 any、null 或 ==，可能失败的调用会标记为 try。如果代码看起来像 TypeScript，它的行为就像 TypeScript；如果做不到，就无法编译。

42 毫秒编译

--watch 在保存时重启程序，tov test 运行紧挨着代码的测试。

对比 Rust、C、Bun 和 Node

Tov 编译为 C 并采用引用计数而非垃圾回收，因此没有回收器暂停，二进制文件也保持小巧。

程序

服务器与构建

比 Rust 快 3.0 倍binary_trees：数百万个小对象

Tov260 毫秒
Bun376 毫秒
Node449 毫秒
C688 毫秒
Rust791 毫秒

越短越好。

比 Rust 快 1.6 倍sort：300 万个浮点数，带比较器

Tov45 毫秒
Rust74 毫秒
C275 毫秒
Bun696 毫秒
Node1175 毫秒

越短越好。

比 Rust 快 1.7 倍map_insert：200 万个字符串键

Tov284 毫秒
C476 毫秒
Rust490 毫秒
Bun823 毫秒
Node1178 毫秒

越短越好。

比 Rust 快 2.1 倍dispatch：5000 万次虚调用

Tov36 毫秒
C76 毫秒
Rust77 毫秒
Bun109 毫秒
Node191 毫秒

越短越好。

比 Rust 快 1.6 倍strings：格式化、拼接、拆分

Tov143 毫秒
Bun203 毫秒
Rust224 毫秒
C253 毫秒
Node519 毫秒

越短越好。

比 Rust 快 7%fib：递归调用，带溢出检查

Tov416 毫秒
Rust444 毫秒
C490 毫秒
Bun942 毫秒
Node1485 毫秒

越短越好。

比 Rust 快 7%nbody：浮点运算

Tov210 毫秒
Rust224 毫秒
C312 毫秒
Bun512 毫秒
Node554 毫秒

越短越好。

比 Rust 快 12%web 服务器：JSON API，单核

Tov242k req/s
Rust216k req/s
Bun111k req/s

越长越好。

比 Rust 少 2.8×服务器内存：提供该 API 时

Tov1.6 MB
Rust4.4 MB
Bun16.6 MB

越短越好。

比 Rust 快 9%fetch()：一次 64 个请求

Tov177k req/s
Rust162k req/s
Bun129k req/s
Node30k req/s

越长越好。

比 Rust 快 2.3×编译：将程序编译为二进制文件

Tov42 ms
C49 ms
Rust98 ms

越短越好。

比 Rust 小 10.5×二进制大小：一个程序，已剥离符号

Tov33 KB
C33 KB
Rust351 KB

越短越好。

在 Apple M4 Max 上测量，且每个程序在每种语言中输出相同。Tov 默认检查整数溢出；Rust 的 release 构建不检查。方法与所有结果。

在 Cap 上试用 Tov

Cap 是我们的开源屏幕录制器。我们在 Tov 上试用了其视频管线的两个部分：一个用 Tov 编写的新编码器，以及 Cap 已有的媒体服务器，按原样由 Tov 编译。两者都尚未在 Cap 的生产环境中运行。

一个用 Tov 编写的屏幕编码器

每个 Cap 录制最终都是 H.264 视频。我们用 Tov 为它编写了一个编码器，针对屏幕上的内容进行调优，并在相同画质下与 x264 进行比较。该编码器在 GitHub 上。

5.2×平均比 x264 更快

空闲屏幕8.1×
代码，4K8.0×
繁忙 UI，60 fps7.2×
慢速打字6.9×
繁忙 UI6.5×
深色模式6.5×
代码编辑器6.5×
幻灯片4.6×
滚动文本4.4×
摄像头叠加4.2×
仪表盘3.5×
全动态视频1.5×

46 MB: 峰值内存（x264：377）
561 KB: 整个编码器（x264：1.3 MB）

12 个 1080p 屏幕录制，单线程，对比 x264 的 veryfast 预设。所有结果。

媒体服务器，未做改动

Cap 的媒体服务器是一个 Bun 应用（Hono、zod 和 FFmpeg），用于探测上传的视频并提取其音频。Tov 无需改动一行即可运行它；下面的文件就是整个移植版本。Cap 仍用 Bun 提供该服务。

// main.tov
import server from "cap-media-server"
import { serve } from "bun"

function main() {
  try serve(server)
}

105 ms启动（Bun：120）
少 27%每读取一个视频的 CPU 占用
129 MB负载下峰值内存（Bun：143）

对比 Apple M4 Max 上的 Bun 1.4。方法与全部结果。

从你的 agent 开始

把这段粘贴到你的 agent 中。它会安装 Tov，读取 llms.txt，此后便用 tov check --json 检查自己的工作。

Use Tov (https://tov.sh) for this: a programming language with TypeScript's syntax that compiles to native binaries faster than Rust's.

1. Install it: curl -fsSL https://tov.sh/install.sh | sh
2. Read https://tov.sh/llms.txt. Tov is TypeScript without a few things (no any, null or ==; int and f64 are separate types; a call that can fail is marked try).
3. Write .tov files. After every edit, run `tov check --json <files>` and apply each fix marked "safe".
4. Run with `tov run main.tov`; ship with `tov build main.tov -o app`, one binary.

目前可用的功能

可用

命令行程序和 Web 服务器
记录、联合、泛型、类、接口和受检错误
async/await、定时器、基于 HTTP 和 HTTPS 的 fetch()
Bun 的服务器 API 和 Node 风格的标准库
npm 包，包括原生插件
macOS 和 Linux

尚不可用

Windows
自有的包管理器（用 npm 或 Bun 安装）
npm 包的 TLS 套接字和工作线程
元组、枚举及其他一些 TypeScript 特性（见规范）