Goose language beats Rust by 12%. AI wrote it, in C++

Short answer: Goose is a new memory-safe systems language from Wouter van Oortmerssen, the creator of Lobster and Amiga E, and its compiler was written "almost entirely" by Claude Fable. In its own 16-benchmark suite it runs 1.19x the speed of the best safe Rust under clang. In a third-party arena of 27 languages it finished all 50 programs in 38.1 seconds against Rust's 54.8. The language that was supposed to make Rust's borrow checker look old just shipped, and a human barely typed it.

TL;DR: Goose beat the best safe Rust row on 14 of its own 16 benchmarks (geometric mean 1.13x under MSVC, 1.19x under clang) while using 1.25x less memory. On kostya's LangArena it was faster than Rust on 38 of 50 tests, won 24 tests outright against Rust's 2, and needed 4,542 lines of code where Rust needed 6,303. The repo went from a spec commit to a codegen commit in under three days and to 915 commits in 59, and its 2,060 GitHub stars in 56 days work out to 36.8 a day, almost double Rust's lifetime average of 20.2. The Hacker News crowd spent its energy on the README's prose: 8 of 56 top-level comments attacked the AI writing, and only 2 ran the thing. Both of those beat their own Rust.

Key numbers

What	Number	Source, checked Oct 25 2026
Goose speed vs best safe Rust, own suite, geometric mean of 16	1.13x (MSVC) / 1.19x (clang)	Goose benchmark results, Oct 16 2026 run
Goose memory vs best safe Rust, same suite	1.25x less	Goose benchmark results
LangArena total runtime, 50 programs	Goose 38.1 s, C 54.2 s, Rust 54.8 s, C++ 58.8 s, Zig 64.1 s	LangArena, run dated Oct 21 2026
LangArena tests where Goose beat Rust by 3%+	38 of 50 (Rust won 5, 7 within 3%)	LangArena data.js, our count
Lines of code for the 50 LangArena programs	Goose 4,542 vs Rust 6,303	LangArena data.js
Commits to aardappel/goose, Aug 28 to Oct 25	915 (875 under the author's name, 0 with an AI co-author line)	GitHub API, our pull
GitHub stars per day since repo creation	Goose 36.8, Rust 20.2, Zig 10.6, Lobster 0.57	GitHub API, our pull
Top-level HN comments attacking the AI prose vs running the code	8 vs 2 (of 56)	HN thread 50224100, our labels

An AI-built language just topped a benchmark Rust has owned

LangArena is Konstantin Makarchev's (kostya) long-running comparison of 27 languages on 50 programs, from JSON parsing to A* search. His Oct 21 run ranks Goose first on total runtime, first on runtime score (96.8 vs Rust's 90.1) and first on wins, with zero last-place finishes.

Goose has existed in public for about eight weeks. Rust has had a decade of compiler work, LLVM tuning and benchmark-game polish. On this table that decade bought Rust third place, 0.6 seconds behind C.

The biggest gaps are exactly where Goose's design says they should be. Json::ParseDom ran 12.4x faster than Rust (0.136 s vs 1.68 s) and Binarytrees::Obj 11.9x faster (0.219 s vs 2.61 s), both workloads full of small, nested, variable-sized data that Rust boxes and Goose stores inline.

How it is faster: no heap, and no lifetimes either

Goose has no heap allocator, no garbage collector, no reference counting and no destructors. Every dynamic value lives on a handful of "data stacks" the compiler assigns at compile time, so growing an array is a pointer bump and freeing a million-element structure is one store.

The part that should sting Rust fans: it is memory safe with zero annotations. There is no lifetime syntax, no aliasing rules to satisfy and no unsafe. The compiler works out what every reference is rooted at and rejects any that could outlive its owner. Van Oortmerssen put it bluntly on HN: "There is no borrow checker to fight. Algorithms that need indices in Rust are strongly typed references in Goose."

Variable-size enums store each value at the size of its own variant instead of the largest one. On the benchmark built to test that (records), Goose runs 2.02x to 2.26x faster than Rust on 3.98x less memory.

Rust lost 2 of 16 in Goose's own suite, and the suite was graded by an AI

Under clang, the backend most comparable to rustc, Goose beats the best safe Rust row on 14 of 16 tests. It loses sum (0.98x) and calc (0.89x, 491 ms against the Rust arena's 436). Under MSVC it loses three: lru, scene and calc.

Now the fine print, because the slop police missed it while complaining about adjectives. The README credits "Claude Fable" with "Compiler implementation, Benchmarking, Sample & Doc writing." The headline aggregate picks the fastest Goose implementation for each speed number and a different, lowest-memory implementation for each memory number. The Goose docs say so themselves: "No single implementation has all of these results."

So yes, the AI graded its own homework. Our read: that is the least interesting fact here, because the third-party arena gave the same answer. The Goose entry in LangArena came in as a pull request from van Oortmerssen (first commit "Add Goose" on Oct 10, merged Oct 20), so the author wrote both sides of his own suite and one side of kostya's. A Rust partisan can hang their hat on that. We searched all 348 comments and found none reporting a Goose program that loses badly, and the author says he hasn't found one either: "'substantially' slower I haven't found yet."

Spec to working compiler in under three days

The git log is the scarier receipt. The first commit, "Spec," landed Aug 28. "Lex + Parser" followed the same day. "Typecheck," "Optimizer" and "Codegen" all landed Aug 30. That is a language spec to a code-generating compiler in under 63 hours.

From there: 915 commits in 59 days, about 15.5 a day, with 92 on Oct 21 alone. The README puts the compiler at about 30,000 lines of C++, plus a spec, a standard library, 31 sample programs and CI on Windows, macOS and Linux with a sanitizer job.

Of those 915 commits, 875 carry van Oortmerssen's name and none carry an AI co-author line. The README is honest that the repo "was produced almost entirely with AI, from a human language design." Git just doesn't have a field for that yet.

"Rust's guardrails are not as pressing": the line that started the fight

Why C++ and not Rust for the compiler? Van Oortmerssen's answer in the README: "With Fable, it was my observation that it is almost equally capable in any language, and the strong guardrails of Rust or other languages are not as pressing as they once were."

That is the sentence Rust people should argue with, and we will. We are a Rust studio, and here is our bet: he is half right in a way that is worse for Rust than if he were fully right.

He did not throw guardrails away. Goose has no unsafe, no undefined behavior, bounds checks the compiler can prove away (checkfree) and threads that cannot share memory. It is more locked down than Rust. What he threw away is the tax: lifetime annotations, the borrow checker fight, Rc<RefCell<T>> and u32 indices standing in for pointers.

Rust's pitch was always "safety is worth the learning curve." An AI writing the compiler and the user code makes the learning curve someone else's problem. That leaves Rust competing on speed, and on two leaderboards this week a two-month-old language won.

Follow the money: adoption just stopped needing humans to learn

A new language used to die on one number: how many humans would spend months learning it. That is why Lobster, the same author's earlier language, has 2,801 stars after 13 years on GitHub (0.57 a day). Goose did 2,060 in 56 days, faster per day than Rust, Carbon, V, Zig, Gleam and Odin over their lifetimes.

Van Oortmerssen said the quiet part on HN: "In some weird way it is a great time to make new languages, because the downside of convincing humans to learn it is gone. Anyone that has a project that needs to be fast can decide to use Goose for it at very little cost."

Who wins: anyone with one hot path and an LLM. Who loses: every incumbent whose moat is "millions of people already learned this." That includes Rust, C++ and Zig, and it includes the consulting and training economy built on top of them.

The one HN commenter who actually tested it at work, jeff_ciesielski, ported algorithms from "my quite large commercial rust codebase" and found them "significantly faster in goose." The twist: the LLM writing Goose picked better data structures, and porting those back into Rust "kept nearly all of the gain." sergiotapia rewrote a pet project and went from 17 MB of RAM to 6 MB.

The slop police aimed at the wrong target

We read and labelled all 56 top-level comments on the 563-point Hacker News thread. 23 were technical questions or critiques (LRU caches, JSON of unknown size, wasm, embedded). 10 were excited. 8 attacked the README for sounding like Claude: "AI slop again," "I can't trust this at all," "a DONTREADME.md." Two ran it.

Across all 348 comments, 76 mention AI, LLMs, Claude, Fable or slop, against 36 that mention Rust. The thread about a language that beats Rust spent more than twice as much time on who typed the README.

That is the same instinct behind r/opensource banning AI-built projects: judge the provenance, skip the benchmark. The fairest criticism in the thread came from jcmoyer, who pointed out the tutorial's first C++ comparison ignores small-string optimization. That is a real fix to a real claim. "It hurts my brain to read this" is not.

Where Goose still loses

To its credit, Goose lists its own limits. No escaping closures, no function pointers, no dynamic dispatch beyond enum tags, whole-program compilation only, and recursive functions cannot keep growable data across a recursive call. Returning a slot to a pool while something still points at it is "a logic bug, but never memory corruption."

On LangArena, Rust still won 5 tests, including Base64::Decode (Goose 2.4x slower) and Etc::CacheSimulation (1.7x slower). And these are single-machine, whole-process timings: Goose's own docs warn to "treat small differences cautiously." Our bet anyway: within a year another one-author, AI-built language tops a third-party benchmark, and "who typed it" stops being a review comment.

What this means for you

If you write Rust for a living, do what jeff_ciesielski did instead of what the README critics did. Take your hottest loop, have an LLM port it to Goose, measure, then port the data layout back into Rust. The win is often the layout, not the language. Our full data (both benchmark tables, the LangArena per-test times, the commit log and our HN labels) is in the download below.

If porting that layout back breaks your Rust build, we will fix it: Fix my Rust build, $99, fixed within 24 hours or a full refund.

More from us: why we think Rust is the language AI will be written in (Goose is the strongest counterargument yet), what Fable 5 costs against open models, our Rust crate data, the Rust hub, LLM prices, and everything in Rust and coding agents.

Sources

• Wouter van Oortmerssen, The Goose Programming Language (README, Status, History & Use of AI), checked Oct 25 2026
• Goose benchmark results and summary, generated Oct 16 2026
• Konstantin Makarchev, LangArena (data.js), run dated Oct 21 2026, checked Oct 25 2026
• kostya/LangArena commit history (Goose entry by aardappel, Oct 10 to Oct 20 2026), our pull Oct 25 2026
• GitHub API: aardappel/goose commits and repo stats, plus rust-lang/rust, ziglang/zig, vlang/v, carbon-language/carbon-lang, gleam-lang/gleam, odin-lang/Odin, c3lang/c3c, aardappel/lobster, our pull Oct 25 2026
• Hacker News, The Goose Programming Language (563 points, 348 comments across two threads), via the HN Algolia API, our pull and labels Oct 25 2026