By ByteBot
A systems language called Goose just posted benchmarks showing it outperforms both C++ and Rust on speed and memory — without a single lifetime annotation. The Goose programming language landed on Hacker News this week with 224 points and 152 comments, and the thread is exactly what you would expect: half the developers are fascinated and the other half are sharpening their knives.
What Goose Does Differently
Rust solved memory safety by making you prove, at compile time, that your references are valid. That proof lives in lifetime annotations, borrow checker rules, and a mental model that takes most developers months to internalize. Goose takes a different approach: eliminate the heap entirely.
Every dynamic value in Goose lives on a compiler-managed data stack. Growth advances a bump pointer. Memory frees when the scope ends — even deeply nested structures, in a single operation. The compiler infers each reference’s root (the owning variable bounding its lifetime) and rejects any reference that could outlive it. No aliasing rules. No unsafe blocks. No annotations.
The result is a language that achieves memory safety through a fundamentally different mechanism: constrain what programs can do, then guarantee safety within those constraints. It is not Rust’s approach. It is not wrong.
The Benchmarks: Real, But Narrow
Goose’s performance numbers across 16 workloads are striking. According to the v2026.3 release benchmarks:
- 3.3x faster than idiomatic C++, using 1.9x less memory
- 1.16x faster than hand-optimized C++, using 1.3x less memory
- 1.12x faster than best safe Rust, using 1.25x less memory
However, the skeptics on the Hacker News thread are right to question these. Sixteen microbenchmarks are sixteen microbenchmarks. The gains come from contiguous data layouts, eliminated allocator overhead, and narrow relative references — all of which are maximally advantageous in workloads that fit Goose’s flat-data model. That is not fraud; it is a design choice.
What the benchmarks actually tell you: in the specific domains where Goose is designed to operate, it is faster than everything else. Those domains include game engines, embedded systems, compilers, and data pipelines — anywhere that flat, cache-friendly data layouts and deterministic performance matter more than general-purpose flexibility. To illustrate the layout advantage, the same order structure that occupies 160 bytes in C++ and 153 bytes in Rust takes just 29 bytes in Goose.
What Goose Cannot Do
The constraints are real and deliberate. Recursive functions cannot retain growable data across calls. There are no escaping closures. Dynamic dispatch is limited to ADT tags. The number of growable stacks must be known at compile time.
This means Goose is not a general-purpose Rust replacement. If your code needs dynamic dispatch, complex callback patterns, or data structures whose shape genuinely cannot be determined until runtime, Goose will fight you. For the portion of systems code where flat data and allocation-free performance matter most, however, it will not.
The Creator and the AI Angle
Wouter van Oortmerssen is not a random developer posting benchmark flamebait. He designed Lobster, Amiga E, and FALSE — the language that launched the esolang movement. He spent years at Google working on Wasm, FlatBuffers, and VR. The Goose design is credible because the person who designed it has shipped real language tooling at scale.
What is new here: the Goose compiler was implemented with heavy AI assistance. Van Oortmerssen had the design for years but no time to build it while running a game startup. AI closed that gap. Expert language designers can now actually ship languages. The bottleneck was never the ideas — it was the tens of thousands of hours required to implement a production compiler. That bottleneck is narrowing fast.
John Carmack weighed in positively, citing Goose’s automatic multi-stack analysis and resizable fields. Furthermore, a community fork called Gust already exists, aiming for “Rust-grade safety, Goose-grade speed.” The Lobste.rs discussion is also worth reading for the more technically focused reaction. ByteIota has also covered the adjacent push against memory-unsafe alternatives in our piece on NetWasm and the push for Rust-grade safety in WebAssembly.
Is Rust’s Complexity Actually Necessary?
Rust’s lifetime annotations are learnable. The borrow checker catches real bugs. The ecosystem is mature. None of that is in question.
What Goose asks is different: is the complexity Rust requires actually necessary? Rust’s answer is “yes, for full generality.” Goose’s answer is “no, not if you are willing to scope your problem.” Both answers can be right simultaneously. Goose is not here to replace Rust. Instead, it is here to demonstrate that memory safety does not require a PhD in type theory — it requires a different set of trade-offs.
Whether a language with no package manager, a minimal standard library, and v2026.3 on its release counter can survive long enough to prove that point is the actual open question. The design is interesting enough that it deserves the chance.
