Goose 编程语言:无堆、无 GC 的内存安全系统级语言
Goose 是一门内存安全的系统级语言,无需堆分配器、垃圾回收器,也没有生命周期标注。在本仓库的基准测试中,Goose 比 C++ 和 Rust 跑得更快,内存占用也更少。
教程 · 参考手册 · 语言规范 · 包管理 · 示例 · 基准测试 · 标准库
熟悉 C 和 Rust 的开发者会对 Goose 的语法感到亲切,但这里没有堆。所有动态值都以内联方式存放在由编译器管理的数据栈上。扩容只需移动指针,作用域结束时内存自动释放。这门语言的类型规则和生命周期规则保证了这种内存模型的安全性。
为什么选择 Goose
- 比 C++ 和安全 Rust 更快,同时保持内存安全。在十六个基准测试中,Goose 达到惯用 C++ 的 3.3 倍速度、手工优化 C++ 的 1.16 倍、最优安全 Rust 的 1.12 倍,内存占用分别少 1.9 倍、1.3 倍和 1.2 倍(测试结果)。这些优势来自 Goose 的数据布局和内存模型。
- 没有分配器、没有 GC、没有引用计数、没有析构函数。内存就是几条由编译器静态分配的数据栈。释放一个包含百万元素的嵌套结构,只需一次写入操作,无论嵌套多深。
- 扩容后引用依然有效。指向数组的引用在数组存续期间始终有效。在对应的基准测试中,C++ 需要
reserve,安全 Rust 得改用u32索引,而 Goose 可以直接保留类型化的引用。 - 零标注实现内存安全。没有生命周期语法,没有别名或独占规则,也没有
unsafe。编译器会推断每个引用的根源,并拒绝可能比其所有者存活更久的引用。 - 嵌套数据保持内联。字符串、字符串数组、含变长字段的记录以及该记录的数组,在内存中均表现为无指针的单一连续块。一个 160 字节的记录,在 C++ 中涉及 29 字节的外部分配开销,而在 Goose 中为零。
- 枚举的内存开销仅取决于其自身。变长模式下的代数数据类型(ADT)会让每个值占用其特定变体的大小,而非所有变体中最大者的大小:相比 Rust 的
enum,相关基准测试显示其内存占用减少 4 倍,速度提升 2 倍。 - 比指针更窄的引用。相对引用以 1、2 或 4 字节的偏移量形式存储带类型且已校验的链接。由这类引用构建的数据结构具备位置无关性,因此数据结构本身即为其文件格式:保存即写入,加载则是读取加上一轮校验,后者用于拒绝恶意字节。
- 所有数据原地构建,且有保证。值会在调用栈的任意深度下,直接在其最终目的地完成构造。
items.push(parse(line))会将解析后的记录直接写入数组;按值返回可增长数组也零成本。 - 跨多次调用返回。
return err from load允许从当前函数栈的任意帧位置直接返回。这一过程经过静态检查,无需展开器(unwinder),无需Result类型,也不需要在每个调用点使用?操作符。 - 线程之间互不共享。工作线程被编译为独立程序,拥有独立内存;扁平值通过类型安全的队列以
memcpy的方式跨线程传输。语言中不存在数据竞争、锁、原子操作或内存序概念。 - 泛型与高阶函数零开销。无类型参数即为泛型。函数值是编译期实体,因此
xs.filter() { it > 0 }会被编译为直观对应的循环,并将结果直接构建到其最终目的地。 - 原生 C 语言输入,原生 C 语言输出。Goose 编译后生成一个 C 文件,因此在任何支持 C 编译器的环境均可运行,并通过
extern fn直接调用 C 函数。内置的 TinyCC 后端支持进程内直接编译并运行程序,无需构建步骤。
教程通过示例逐步讲解以上内容,参考手册按主题涵盖整个语言,规范文档列出了精确规则,基准测试则展示了具体数据,包括性能损耗在内。
特性
本节聚焦于 Goose 的独特之处。教程会更详细地解释这些特性,示例则在三十一个完整程序中展示了它们的应用。
单一内存模型:栈,且作用域退出是免费的
程序拥有原生调用栈、静态数据以及 N 个数据栈,其中 N 由编译器决定。数据栈是一个大的地址空间预留区,带有一个 bump pointer,除此之外没有其他内存。每个栈上最多只有一个可调整大小的值处于活跃状态,且它始终位于栈顶。因此,内存增长不会移动任何数据,也无需检查容量。这一切在编译时即可证明;运行时仅追踪 bump pointer。
for round in 3 {
var scratch: u8[>..] = []; // 仅增长:增长即是指针递增
for i in 100000 { scratch.push((i % 256) as! u8); }
print("round ", round, ": ", scratch.len, " bytes");
} // 免费:只需向栈顶写入一次
对象不移动,因此引用可跨越增长
struct Item { id: i32, weight: f32 }
var items: Item[>..] = [];
let first .= items.push(Item { 1, 0.5 }); // 指向第 0 个元素的引用
for i: i32 in 2..1000001 { items.push(Item { i, 0.0 }); }
first.weight = 99.5; // 即使在百万次 push 之后依然有效
push 返回指向新元素的引用,因此程序可以在构建数组的同时建立元素间的链接。vector<T> 或 Vec<T> 可能会重新分配内存,无法提供这种保证。稳定的引用带来了多项基准测试的性能提升。
安全引用,无需注解
每个引用和切片都有一个静态的根(root):即约束其目标生命周期的变量。引用的生命周期不能超过拥有其目标的变量,也不能通过不兼容的类型访问该目标。编译器会自动推断根并据此特化函数,因此无需任何注解。这里没有别名或独占规则。当生命周期检查失败时,错误信息会指出引用的根及其目标:
fn longest(a: u8[:], b: u8[:]) -> u8[:] { if a.len >= b.len { a } else { b } }
var outer: u8[>..] = [];
var w = outer[..];
{
var inner: u8[>..] = [];
format(inner, "inner text");
w = longest(outer, inner); // 错误:存入的引用以 inner 为根,
} // 而 inner 不比目标活得久(§9.2)
切片类型 T[:] 让函数无需复制元素就能接受来自任意数组类型的区间。例如,split 返回指向输入内容的切片,以 u8[:] 为键的字典存储的也是字符串的视图而非副本。
嵌套数据保持内联
这里没有单一的数组类型,而是一族仅在尺寸处理方式上有所不同的类型。每个成员的布局都是 [metadata][elements...],内联且紧密排列,绝不是指向元素块的指针:
| 写法 | 含义 |
|---|---|
T[k] |
固定大小,编译期已知 |
T[]、T[varint] |
构造时确定大小,之后不可变;长度为定宽或变宽 |
T[..k]、T[..] |
容量内联存储;可在容量范围内伸缩 |
T[>..] |
只增型(grow-only):最常用的主力类型;指向其中的引用始终有效 |
T[>..<] |
可增可缩型:适用于栈、队列、堆 |
字符串就是 u8 数组:u8[>..] 是构建器,u8[] 是内联存储在持有者中的完整字符串,u8[..16] 是结构体内的小字符串,u8[:] 是视图。结构体可以包含变长的部分,它们按声明顺序内联排列,因此一条记录就是一段连续字节,其中没有任何间接引用:
struct Item { sku: u8[varint], qty: varint, cents: varint }
struct Order { id: varint, customer: u8[varint], items: Item[varint] }
var book: Order[>..] = [];
book.push(Order { id: 1001, customer: "alice",
items: [Item { sku: "SKU-441", qty: 2, cents: 1999 },
Item { sku: "SKU-7", qty: 1, cents: 500 }] });
该订单仅占 29 字节且零分配。使用 C++ 的
std::string 加 std::vector<Item> 需 160 字节和 1 次分配,Rust 的 String 加 Vec<Item> 则需 153 字节和 4 次分配。整个订单簿就是一个数组,可顺流通过缓存。代价在于变长元素数组是顺序访问的:你可以迭代,但无法索引(除非维护第二个引用数组作为索引)。
两种尺寸的枚举
代数数据类型(ADT)是唯一支持动态多态的机制:无继承,无虚表。每个 ADT 都有两种存储方式,由使用点决定。固定模式(Shape)为标签加上最大负载空间,支持索引和覆写。可变模式(Shape..)让每个值仅占对应变体所需的精确大小;数组变为顺序结构,值一旦创建其变体类型不可更改,但作为交换,你可以获取指向负载内部内部的引用:
enum Shape { Circle { r: f64 }, Rect { w: f64, h: f64 }, Dot }
var packed: Shape..[>..] = []; // 分别为 9、17 和 1 字节,而非每个都是 17 字节
packed.push(Shape.Circle { r: 1.0 });
packed.push(Shape.Rect { w: 2.0, h: 3.0 });
packed.push(Shape.Dot);
for s in packed {
match s { Rect &r => { r.w += 1.0; }, _ => {} } // 在数组内部原地编辑负载
}
Case 函数提供了另一种针对变体进行分发的方式:为每个变体定义一个重载。调用通过跳转表按标签分发,编译器会检查重载是否覆盖所有变体:
fn area(s: Shape.Circle) -> f64 { 3.14159 * s.r * s.r }
fn area(s: Shape.Rect) -> f64 { s.w * s.h }
fn area(s: Shape.Dot) -> f64 { 0.0 }
for s in packed { print(s, " area ", area(s)); }
比指针更窄的链接
T& 是一个机器地址:8 字节,永不悬垂。而相对引用则是把同样的链接存成一个窄偏移量:T&<u32> 从字段自身量到同一数组内的目标,因此结构是位置无关的;T&<u32 in pool> 则从具名 pool 的基址量起,让其他数组也能链接进这个 pool。T&<u32>? 用偏移量 0 表示 null。下面是在一个只增数组里实现的二叉搜索树,每个节点 12 字节:
struct Node { key: i32, left: Node&<u32>?, right: Node&<u32>? } // 12 bytes, links included
fn insert(pool: Node[>..]&, key: i32) {
if pool.len == 0 { pool.push(Node { key: key }); return; }
var cur .= pool[0]; // .= binds a reference; = would copy the node
loop {
if key == cur.key { return; }
let next = if key < cur.key { cur.left } else { cur.right };
if next { cur .= next; continue; } // narrowed by `if`: next is a Node&
if key < cur.key { cur.left .= pool.push(Node { key: key }); }
else { cur.right .= pool.push(Node { key: key }); }
return;
}
}
引用是透明的(不需要 * 和 ->),.= 用来绑定或重定向一个引用,Node? 是可空引用,能被 if、guard 和 assert 收窄类型。这里的 insert 只需一次 push 加一次写入,而且 push 不会让 cur 失效。当生命周期不是嵌套关系时,可以用 reusable pool,在只增数组背后藏一个空闲链表:alloc_ref 复用空槽或追加新槽,free 归还槽位。由于内存从不真正释放,访问过期槽位读到的只是类型正确的另一个值,而不是内存损坏。
你的数据天然就是文件格式
var image: u8[>..] = tree.to_bytes(); // a framed byte image of the whole array
var loaded, ok = from_bytes<Node[>..]>(image); // verified before it becomes a value
image[image.len - 3] = 200; // tamper with a link ...
var bad, bok = from_bytes<Node[>..]>(image); // ... and it is false and an empty array
树的链接都是相对自身的,所以无论它处在什么位置含义都相同:保存就是把字节写出去,加载就是读回来,不需要序列化器、schema,也不用修补指针。from_bytes 会在字节变成值之前检查帧结构、每个标签、每个长度和每个链接,因此损坏或恶意构造的文件只会得到一个 false,绝不会产生野引用。
始终原地构建
无拷贝构建保证(spec §4.3)规定:构造出来的值总是直接建在它的最终位置上,并自顶向下在调用链中传递。按值返回只增数组的函数会把元素直接写进调用者的变量,或者写进另一个数组内正在构建的记录的字段,因此基本不需要出参。
words.push(str("word", i)); // 直接格式化写入新元素
let evens = xs.filter() { it % 2 == 0 }; // 直接构建进 `evens`:没有临时对象
book.push(Order { id: 1001, customer: "alice", items: parse_items("SKU-441:2:1999;SKU-7:1:500") });
跨调用返回错误
struct User { name: u8[..16], age: i32 }
fn load(text: u8[:]) -> User[>..], u8[] {
var users: User[>..] = [];
each_split(text, '\n') { users.push(parse_user(it)); };
return users, "";
}
fn parse_user(line: u8[:]) -> User { // 返回 User:不用 Result,也没有错误参数
let comma = find(line, ",");
guard comma >= 0 else { return [], str("expected name,age: ", line) from load; }
let age, ok = parse_int(line[comma + 1..]);
guard ok else { return [], str("bad age: ", line) from load; }
let name = trim(line[..comma]);
return User { name: name, age: age as i32 };
}
return E from f 会把 E 作为 f 最内层活跃调用的结果返回,无论隔着多少层栈帧,中间的每个函数都保持原本的普通签名。它在静态阶段检查,所以 parse_user 的每次调用必须位于 load 调用之内,运行时不会有未捕获的错误。它不是栈展开器,而是每帧检查的隐藏判别标记,并且消息直接构建在 load 调用方需要它的地方。示例中的解析器把所有语法错误都用它来处理。
泛型与函数块
fn twice(x) { x + x } // 未标注类型的参数是泛型参数
fn each_pair<T, F>(xs: T[:]) { // F 是函数值:一个编译期实体
for i in 0..xs.len - 1 { F(xs[i], xs[i + 1]); }
}
fn first_gap(xs: i64[:]) -> i64 {
each_pair(xs) { a, b => if b - a > 1 { return a; } }; // 从 first_gap 返回,而非 each_pair
return -1;
}
let evens = xs.filter() { it % 2 == 0 };
let total = fold(xs, 0) { acc, x => acc + x };
sort(xs) { a, b => a > b };
所有内容均经过单态化。类型参数由实参类型推断得出;若类型中缺少某些参数,则可显式提供。函数值作为泛型参数传递:每次调用都是直接的且可内联,它们无法逃逸,也不存在闭包对象或函数指针,因此高阶函数最终编译为与其外观完全一致的循环。代码块可从其词法外层函数中 return,嵌套函数能看到外层函数的局部变量。
互不共享的线程
thread_fn worker() { // 拥有独立内存的独立程序
loop {
let job = qget<Job>(); // 在类型化 Job 队列上阻塞
guard job.n >= 0 else { break; } // -1 表示停止
qput(Result { n: job.n, digits: count_digits(job.n) });
}
}
for i in n { ids.push(thread_spawn(worker)); }
不存在共享可变内存。thread_fn 及其调用的所有内容都会被编译为独立程序,拥有自己的数据栈和全局变量的独立副本。值通过类型化队列跨线程传递,每种类型一个队列,且必须是扁平的,任何深度都不能包含引用。这种方式开销极低,因为扁平的 Goose 值是连续的:一个 job 或 result 携带的是真实数据(包括像素),跨线程传递就是一次 memcpy。
由 thread_spawn_contained 启动的 worker 中发生的检查失败或 abort 只会终止该 worker。其消息会发送给等待它的调用方,而非输出到 stderr,因此监督者可以记录日志并启动新的 worker:
var why: u8[>..] = [];
while !thread_wait(thread_spawn_contained(serve, attempt), why) {
log(why); // "assert failed (serve.goose:12)"
why.clear();
attempt++;
}
worker 第一次调用 thread_wait(id, msg) 就会取走消息;调用方如果不来取,消息就丢了。
纯 C 进,纯 C 出
extern fn hypot(x: f64, y: f64) -> f64; // 直接来自 libm
extern fn crc32_bytes(s: const u8[:]) -> u32; // slice 以 { data, len } 形式传递
extern fn stats_of(xs: i32[:], out: Stats&); // 通过指针填充结构体
extern fn 把 Goose 签名绑定到 C 符号上,math 和 os 模块就是通过这个接口实现的。只有具备受支持 C 表示形式的类型才能跨过边界;不支持的签名会在声明处被直接拒绝。编译器为整个程序生成一个 C 文件,内置的 TinyCC 后端可以在 Goose 编译器进程内直接编译并运行这个 C 文件。
速度从哪里来
速度主要来自内存模型:没有堆分配、没有逐对象的销毁开销,数据连续存储,链接宽度紧凑,enum 的大小只取决于它实际承载的变体。每个索引都会做边界检查,但编译器会剔除能证明不必要的检查。对 slice 长度加一个 assert,往往能让内核去掉剩余的检查并进行向量化。--bce-lines 会报告还剩下哪些检查。checkfree fn 则在仍有边界检查残留时直接拒绝该内核;索引类型可以让图结构保留构建阶段完成的验证。基准测试的测量采用整个进程的 wall-clock 时间,包括销毁阶段。
| 16 个基准测试的几何平均 | 对比惯用 C++ | 对比手工优化的 C++ | 对比最优的安全 Rust |
|---|---|---|---|
| 速度(MSVC 后端) | 3.51x | 1.24x | 1.13x |
| 速度(clang 后端) | 3.54x | 1.26x | 1.19x |
| 峰值内存 | 少 1.95x | 少 1.32x | 少 1.25x |
summary 解释了这些得失;results.md 包含所有测量数据,design.md 则说明测试套件考察的内容。
你需要付出什么
- 你需要思考数据放在哪里:谁拥有它,作用域持续多久。通常答案是"构建它的那个函数",这没有任何成本;如果答案不是它,那就得用
reusable池。 - 递归函数无法在递归调用间保留可增长的数据;scratch 区域在调用前结束,只有池(pool)中的数据能在调用后存活。
- 变长元素数组支持遍历但不支持索引(除非在旁侧维护引用索引);固定模式枚举不能取地址,可变模式枚举不能覆盖写入。你在容器层面选择行为。
- 无逃逸闭包、无函数指针、无超越 ADT 标签的动态分派,且仅支持全程序编译。
- 交还给
reusable池且仍被引用的槽位,读取内容时获得的是下一个所有者的写入值:这是逻辑错误,而非内存破坏。
教程 §18 列出了完整限制清单。
安装发行版
预编译编译器支持 Windows(x64)、Linux(x64)和 macOS(Apple Silicon 及 Intel 架构),已内置图形、音频、UI 和物理包,位于发行版页面。将压缩包解压至任意位置并加入 PATH 即可:编译器会自动定位同目录下的标准库、TinyCC 运行时及依赖包,并将构建产物保存至 ~/.goose
(即 GOOSE_HOME)。压缩包内还包含本文档、示例及 VS Code 扩展。
在进程内运行程序(goose file.goose)在 Windows 上无需额外依赖。Linux 需安装 C 库头文件(libc6-dev 或 glibc-devel);macOS 需安装 Xcode 命令行工具 SDK(xcode-select --install)。
goose build 还需 C 编译器:Windows 上需 Visual Studio 2022 或更高版本,或 clang;其他系统需 gcc 或 clang。Linux 编译器要求 glibc 2.35 或更高(Ubuntu 22.04、Debian 12);macOS 编译器要求 macOS 13.3 或更高版本。macOS 默认阻止运行下载目录中的文件,需对解压目录执行 xattr -dr com.apple.quarantine 解除隔离。
构建与运行
你需要 CMake 3.27 或更高版本、一个支持 C++20 的编译器(MSVC、clang 或 gcc),以及用于测试和示例运行脚本的 Python 3。进程内后端所基于的 TinyCC 已包含在源码树中。graphics、audio、ui 和 physics 模块是独立仓库中的包(goose_gfx 和 goose_physics,详见 docs/design/packages.md)。配置时加上 -DGOOSE_BUILTIN_LIBS=all,会在构建阶段用 git 拉取这些包的固定版本并编译进编译器,这样运行程序时无需额外安装任何东西。不加这个选项的话,编译器会单独构建;程序导入这些包时,第一次会把包构建到 ~/.goose 目录下,这需要 git、cmake 和一个 C 编译器。
git clone https://github.com/aardappel/goose
cd goose
cmake -B build -DCMAKE_BUILD_TYPE=Release -DGOOSE_BUILTIN_LIBS=all
cmake --build build --config Release
GOOSE_BUILTIN_LIBS 也可以只指定部分包(如 physics,或 gfx——它同时包含 audio 和 ui)。在 Linux 上,SDL 需要 X11 或 Wayland 的开发包(见 third_party/SDL/docs/README-linux.md);缺少时构建会跳过 gfx 模块,并提示需要安装什么。
运行脚本会依次查找 build/Release、build/RelWithDebInfo、build 和 build/Debug。可以用 --exe 指定具体的编译器;要开启编译器断言做测试时,请显式使用 Debug 版可执行文件。编译器位于 build/goose(使用 Visual Studio 生成器时为 build/Release/goose.exe),它会在构建时所用的源码树中查找标准库。在 Windows 10 1903 及更高版本上,编译器内嵌的 manifest 会选用 UTF-8 进程代码页,因此编译器路径不依赖系统区域设置;更早的 Windows 版本仍使用传统代码页。生成的原生可执行文件则保留各自的进程设置。
可以直接从源码以进程内方式运行程序(goose run 效果相同但显式声明,goose check 则只做类型检查):
build/goose samples/01_tour.goose
也可以构建可执行文件,产物默认生成在源文件旁边(用 -o 可指定其他位置)。编译器会在机器上查找 C 编译器(goose toolchain 可查看具体是哪个:Windows 上是 MSVC 或 clang,其他平台是 cc、gcc 或 clang;也可用 --cc 手动指定),然后把生成的 C 代码与运行时以及程序用到的原生模块(包括图形模块)链接起来。使用线程的程序必须走这条路径,因为 TinyCC 无法放置线程局部存储。
build/goose build samples/01_tour.goose && samples/01_tour
build/goose build samples/27_gfx_cube.goose && samples/27_gfx_cube
--debug 会在生成的 C 代码中开启溢出、越界和标签检查,每次中断都会指明源码行号(溢出或类型转换还会给出相关数值),并以调试信息构建 C 代码;--dry-run 只打印构建将要执行的命令,方便接入你自己的构建系统;-v 则在命令执行时逐条打印。中间产物存放在 ~/.goose(可用 GOOSE_HOME 修改),运行时目标文件按 C 编译器各编译一次。两种形式的常用参数:-O0/-O1/-O2 设置内联级别(build 默认 -O2,run 默认 -O1);--bce-lines 报告每行保留的边界检查数量;-DGS_DEBUG=1 就是 --debug 实际定义的宏。每个可变长度的值都存放在一块预留了 2 GB 地址空间的数据栈上,按需提交内存:--stack-reserve 16G 可以调整程序的这个预留量;--stacks 报告程序及其各 worker 能创建多少数据栈,以及由此给 hardware_threads() 带来的上限;-DGS_STACK_STATS=1 则让程序在结束时报告实际使用情况。
程序自带 C 时,会在源码旁放置一个伴随文件指定名称,例如 foo.goose 旁边放 foo.build:
c_sources = ["impl.c"];,以及 c_include、
c_defines、c_libs,还有各配置项的 _windows、
_linux 或 _macos 变体,用于处理特定平台的部分。两种形式都能构建 C 代码:
goose build 会将其链接进去,而 goose run 会把它构建成库,供进程内运行时加载,
这样 extern fn 无论哪种方式都能访问到。库的操作方式相同,在入口处放置伴随文件(或指定其自身 CMake 项目的静态库目标,
cmake_target = "x";,编译器会通过 cmake 进行构建)。程序通过根文件中的
import name from "source"; 引入库:可以是目录("./lib"),
或者是位于某个 tag 或 commit 的 git 仓库(GitHub 上是 "owner/repo@v1",
通用格式为 "host/owner/repo@ref"),这些内容会被获取到 ~/.goose
并为每个 C 编译器构建一次(docs/design/packages.md)。
底层实现上,goose -o tour.c tour.goose 会写出 C 代码,
其中包含程序本体以及内联进其中的运行时部分;运行时其余部分(OS 层、数据栈预留、
线程、打印)是另一个 C 文件,由 goose --emit-runtime goose_runtime.c 生成,
编译一次后即可与所有程序链接(cc -O2 tour.c goose_runtime.o -o tour -lm -pthread;
在 Windows 上是 cl /O2 tour.c goose_runtime.obj)。请用程序所用的编译器和标志构建运行时;
运行时本身不需要任何 -D 定义,来自其他版本编译器的程序无法与之链接。
--standalone 会写出一个包含完整运行时的 C 文件,使其可独立构建。
使用 audio、gfx、physics 或 ui 的程序
还需要链接对应模块的层,可通过 goose --audio-link msvc|cc、
--gfx-link、--physics-link 和 --ui-link
在响应文件中指定(cc cube.c goose_runtime.o -o cube @$(goose --gfx-link cc),
对于 ui 程序,需先于其调用的 gfx 层进行链接)。
goose build --dry-run 会打印出当前程序的上述所有构建细节。
使用 audio 的程序可以通过 SDL3 播放程序化生成的单声道/立体声 PCM,无需打开图形窗口。详见 audio 参考文档。
测试套件和示例可以在 Windows、macOS 和 Linux 上运行:
python test/run_tests.py
python samples/run_samples.py
编辑器方面,VS Code 扩展提供语法高亮、编译器自带的 language server(goose lsp:输入时即时报错、悬停提示、跳转定义、代码补全、重命名、符号列表),还支持一键通过 JIT 运行代码:
code --install-extension vscode/goose-language.vsix
其他编辑器也可以直接运行 goose lsp;Neovim、Helix 和 Emacs 的配置方法见 编辑器文档。
文档
- 文档索引:以下所有内容的导航地图,也是由这些文件构建的文档站点的根目录(构建方法)。
- 教程:通过示例进行的友好入门介绍,建议首先阅读。
- 语言参考:按主题介绍每一个语言特性,每个特性都配有可编译的示例——整门语言,专为阅读而写。
- 语言规范:精确的规则定义,当你想知道某段代码为什么编译不过时看这里。
- 示例:按阅读顺序排列的三十一个完整程序,从语言速览到 JSON 解析器、多线程 Mandelbrot、用两个内存池构建的文件树、GPU 上的旋转立方体、成千上万落成堆的小盒子,以及用窗口和控件实现的待办事项列表。
- 标准库:十四个模块,全部是存放在
stdlib/下可直接阅读的 Goose 代码,包括gfx(基于 SDL3 GPU API 的图形库,构建原理)、physics(基于 Box3D 的刚体物理,构建原理),以及ui(字体、文本渲染与游戏 HUD、基于 Nuklear 并通过 gfx 绘制的窗口与控件,构建原理)。 - 构建程序与使用包:
goose build、来自 git 仓库或目录的库、程序自带的 C 代码,以及如何制作自己的包。 - 基准测试:测试数据,包括完整结果和背后的设计思路。
- 实现笔记:编译器逐阶段的工作原理,以及测试方式。
现状
Goose 还很年轻。目前已有的内容包括:一个约三万行 C++ 代码的全程序编译器、语言规范、标准库、示例代码,以及一套在 Windows、macOS 和 Linux 上由 CI 运行并附带 sanitizer 任务。目前有意不做的东西包括:可变大小值的 move 语义、每个 struct 多个可变大小成员、带标签的 break、命名空间私有性,以及更多操作系统/库访问。待办事项记录在规范的附录 B 中。
许可证
Goose 采用 Apache License, Version 2.0 许可证。
作者
Wouter van Oortmerssen:语言设计、编译器设计、编码规范。个人主页、twitter。
Claude Fable:编译器实现、基准测试、示例与文档编写。
历史与 AI 的使用
这个仓库几乎完全由 AI 编写完成,起点是人类的语言设计。我几年前就设计好了 Goose,也开始动手实现,但当时在经营一家游戏创业公司(其产品基于我设计的另一门编程语言 Lobster),没有时间把它做完。这挺遗憾的,因为我知道 Goose 能做到其他语言做不到的事情,它理应存在。
在 Fable 出现之前,我没想过 AI 能帮上这个忙。我觉得它的能力或许足以做好这件事。我让它基本上照搬了我另一个较新的编译器(Lobster)的风格和结构,所以如果你看代码,会发现两者颇为相似。我最初的设计留下了许多未明确的细节,与 Fable 反复讨论后我把这些一一敲定,这也让这门语言变得更完善。
翻译后的文本:同时,这也是一次利用 AI 实现新语言,而非复刻现有语言的实验。
你可能会疑惑,既然 Rust、我自家的 Lobster 甚至 Goose 本身(未来说不定也会用)都能胜任,我为什么选择用 C++ 来实现?在我看来,Fable 在任何语言上能力几乎旗鼓相当,而 Rust 等语言那些严苛的护栏早已不像从前那样必要。由于编译器输出的是 C 代码,你手头本来就得备着一套 C/C++ 编译器,顺藤摸瓜留在同一套生态里,部署和推广似乎能简单不少。我已经集成了 libtcc,未来可能还会接入更多 C 库。另外,正如我提到的,让编译器代码仿照我现有的 Lobster 编译器风格来写也挺有意思,起码看代码时就像看自己写的,读起来不费眼。
