Goose, a Heapless Systems Language, Claims 3.5x Over C++ and Lists Where It Loses

Wouter van Oortmerssen has published Goose, an experimental memory-safe systems language with no heap, and its README says the repository "was produced almost entirely with AI, from a human language design." The project reports a geometric mean of 3.51x the speed of idiomatic C++ across 16 benchmarks, a figure the project produced itself.

The code is on GitHub under Apache 2.0 and had 2.1k stars, 74 forks and 3 open issues when this was written. The project page credits van Oortmerssen with the language and compiler design, and Claude Fable with implementing the compiler, running the benchmarks and writing the samples and docs.

What no heap means in practice

Goose has no allocator, garbage collector, reference counting, destructors or lifetime annotations. Every dynamic value lives on compiler-managed data stacks that are freed when its scope ends. The compiler infers what each reference is rooted at and rejects any that could outlive its owner.

That is a different bargain from Rust's. The Rust book describes memory managed "through a system of ownership with a set of rules that the compiler checks," with one owner per value and a drop when the owner leaves scope. Goose asks the programmer to think about where data lives instead, and the page lists the cost: recursive functions cannot keep growable data across recursive calls, there are no escaping closures or function pointers, and only whole-program compilation is supported.

The compiler is about 30,000 lines of C++ and emits C. The repository holds a specification, a standard library, 31 samples and a test suite that CI runs on Windows, macOS and Linux.

The benchmark numbers, and what they average

The project's benchmark summary covers a run dated Oct. 16, 2026, with sixteen benchmarks at large sizes. All figures below are the project's own.

Comparison	MSVC	clang
Idiomatic C++	3.51x faster	3.54x faster
Expert C++	1.24x faster	1.26x faster
Best safe Rust	1.13x faster	1.19x faster

Peak memory favours Goose by 1.95x, 1.32x and 1.25x against the three tiers on the MSVC build. The summary says measurements are the best of three runs after two warm-ups, with cores not pinned, and it does not describe the hardware or give a clang version.

The aggregate takes the fastest Goose implementation per backend and tier. The summary says so itself: no single implementation produces all the headline results. The README gives 3.3x and 1.12x in one section and 3.51x and 1.13x in another, a mismatch the project has not reconciled on its pages.

Where it loses

The summary names its losses. On the calc benchmark Goose took 481 ms under MSVC and 491 ms under clang against 436 ms for a Rust arena version. On lru it took 2,760 ms under MSVC against 2,249 ms for Rust, and won under clang at 2,068 ms. The flat blur kernel runs 952 ms under MSVC against 266 ms under clang.

The project also warns that timing changes between report dates cannot be credited to compiler improvements alone, because the empty-process floor moved from about 8 ms on Oct. 10 to 13.1 ms for Goose and 13.8 ms for C++ on Oct. 16, and the MSVC version changed.

The memory figures are larger than the speed ones in places. On records Goose used 3.98x less memory than Rust, and on sexp it used 5.04x less than C++ with owning nodes.

The language sits beside a live argument about safe systems code: C++26 failed its ISO ballot with 9 of 22 national bodies voting no, and vendor speed claims in this space tend to arrive without methodology, as with TornadoVM's own numbers. Goose at least publishes its results file. The bench/ folder holds results.md, summary.md and design.md; an independent run on named hardware is the missing piece.