Goose versus Rust and C++: the case for keeping data in place

New Programming Languages versus Rust / C++

A game can know exactly when a level ends. What if its programming language could use that fact to free an entire level’s worth of objects in one operation? Goose gives the compiler that opportunity. Its designer, Wouter van Oortmerssen, has spent much of his career deciding how games store, move and discard data. His new language makes an unusually good case for reading a benchmark twice: once for the headline and once to see what happens when the other programmers organise their data just as carefully.

The designer behind the compiler

Van Oortmerssen wrote his first compiler for the Commodore 16. On the Amiga he took two strikingly different routes. Amiga E became a commercial language he sold for several years. FALSE explored how little machinery a working language could get away with. At the University of Amsterdam his master’s project, Bla, treated the environment that holds names and values as something a program could manipulate. His doctoral work at Southampton became Aardappel, a language for rewriting trees and distributing computation. These projects trace an enduring interest in finding a representation that makes a difficult operation simple. Language history · Doctoral project and thesis.

At Amiga Inc. he worked on system scripting. At Crytek he contributed to the first CryEngine and Far Cry, covering multiplayer, core systems and scripting. He helped create the Guildhall graduate programme at Southern Methodist University, where teaching included animation systems, shader systems and compilers. His independent work included the Cube engines, TreeSheets and consulting for Maxis and Gearbox. At Google he created FlatBuffers and worked on WebAssembly and game technology. FlatBuffers lets a program read structured data in place. Goose asks a related question much earlier, while the data is being built. He went on to run VoxRay Games, where the studio’s game uses his earlier language, Lobster. Professional biography · Google’s FlatBuffers announcement · His 2023 conference account.

How Goose keeps a reference valid

Imagine reading a file of records, saving a reference to the first one and then appending a million more. A growing C++ vector can move its elements into a larger allocation and invalidate the reference. A Rust vector can also relocate, but safe Rust’s borrowing rules prevent an outstanding reference from being used across an incompatible mutation. A program can reserve space or remember an index, depending on the language and the problem. Goose offers a grow-only array whose existing elements stay in place. The compiler assigns data to stacks with stable addresses and checks that a reference does not survive its owner. A scope can reclaim a whole group by moving the stack’s end marker. Goose specification · Rust ownership · C++ resource-management guidelines.

This arrangement rewards records created and consumed together. Strings and other variable-size fields can sit next to the record they belong to. Links can be stored as small relative offsets. An alternative that keeps a pointer per object can occupy more space and send the processor to more addresses for the same answer. Goose also gives up some freedom. A collection of variable-size elements needs an extra index for random access. Recursive code must organise scratch storage around recursive calls. Workers exchange data through queues and have separate memory. Code with independently owned objects or shared mutable state may require a different design. C libraries called from Goose retain their own responsibilities for memory. Design and limitations · Language tutorial.

What actually runs

The compiler considers the whole program, checks its types and lifetimes, and writes C. For deployment, goose build hello.goose passes that C to an installed compiler and links the runtime and required native libraries. The result is hello.exe on Windows or hello on Unix-like systems. The shared-library option produces a DLL, a dylib or a so file for the target platform. There is also a quick route for experimentation: bundled TinyCC compiles and runs the code in the compiler’s own process. It does little optimisation and cannot run Goose’s threaded programs in that mode. Those two routes answer different questions about the same source. Compiler and executable reference.

How much faster, and against which program?

The project’s dated run of 16 October 2026 used a Ryzen 9 9950X3D on Windows 11. For each large workload it compared whole-process elapsed time, keeping the fastest of three measured runs after two warm-ups. Checksums had to agree. Both columns below use the same Rust binary built with rustc 1.98.0. The choice of C compiler changes Goose and C++ in the two columns. These are project measurements. The table reports the geometric mean across sixteen workloads.

In the Clang comparison, the other programs took 3.54 times as long as Goose for idiomatic C++, 1.26 for optimised C++ and 1.19 for safe Rust.
Changing how C++ stores the same data narrows its measured gap with Goose. Each bar summarises the sixteen large inputs on one Windows machine. The table below adds the results for Microsoft’s compiler. Graphic by The Bible of AI. Project measurements, 16 October 2026 · Enlarge figure.
Comparator time divided by Goose time. A ratio above 1 favours Goose.
ComparatorMSVCClang
Idiomatic C++3.51×3.54×
Hand-optimised C++1.24×1.26×
Best safe Rust variant tested1.13×1.19×

The difference is tangible in a tree of nodes. With Clang, C++ took about 2,881 milliseconds when each node owned a separately allocated child, and 737 milliseconds with an arena and indices. Goose took 658 milliseconds. The arena version of Rust took 676 milliseconds. The three compact versions peaked near 392 MB. Elsewhere the result went the other way. On the calculator workload safe Rust finished sooner than either Goose build. Across the suite the reported ratios for peak memory were 1.95, 1.32 and 1.25 respectively, each comparator divided by Goose. A single machine and best-of-three times leave variation across runs and machines unresolved. Dated results and workload tables · Readable results.

Who backs it, who uses it, and where AI entered

The public record identifies an author-led project with outside contributors. Its November release names contributors and ships binaries. On 15 November the repository showed 3,559 stars and 168 forks. Those are signs of attention. A more concrete trace of use is the accepted Goose contribution to the separate LangArena benchmark project, submitted by van Oortmerssen himself. Another developer published a Goose port of Campfire. These are inspectable uses. Neither supplies a count of organisations running Goose in production. The materials reviewed identify no corporate sponsor or audited deployment figure. Google’s role in FlatBuffers and VoxRay’s use of Lobster establish parts of the designer’s career. They do not establish sponsorship or deployment of Goose. Repository · LangArena contribution · Campfire port.

Van Oortmerssen says he designed Goose years before the public implementation. He credits himself with the language, compiler design and coding standards, and credits Claude Fable with implementing the compiler, benchmarking, examples and documentation. He describes repeated exchanges that settled open design questions. This disclosure matters for interpreting the measurements: much of the implementation and the project’s own comparison came through the same development process. The sources, comparison programs and expected outputs give others a way to examine the result. Author’s account of AI use.

Where the evidence points

Goose’s clearest contribution is a useful default for a particular kind of work. If a parser, a game level or a stream of records can give its data a common lifetime, stable addresses and cheap group disposal can save both memory and time. The tree experiment also shows how much of that advantage an experienced Rust or C++ team can recover. The next persuasive evidence would be a maintained application with representative inputs, more than one hardware platform and published costs for integration and maintenance. For now, Goose gives such a team a concrete design to try and a particularly good question to ask of the program it already has: which allocations does it really need?

Liked this post? Follow this blog to get more.