Goose Programming Language Introduced: Memory-Safe Systems Language Without Heap or GC

Introduction to Goose

The Goose programming language has been released, presenting itself as a memory-safe systems language. It distinguishes itself by not incorporating a heap allocator, garbage collector, or requiring explicit lifetime annotations from developers.

Memory Model and Performance Claims

Goose utilizes a memory model where all dynamic values reside inline on a data stack managed by the compiler. Memory is allocated by advancing a pointer and freed when its scope concludes. This approach, combined with its type and lifetime rules, aims to provide memory safety.

According to benchmarks provided by the project, Goose runs faster than C++ and Rust while consuming less memory. Specific claims include being 3.3x faster than idiomatic C++ and 1.12x faster than safe Rust, with corresponding memory reductions.

Key Design Principles

The language's design eliminates the need for allocators, garbage collection, reference counting, and destructors. Memory management is handled through data stacks assigned statically by the compiler. This design allows for operations like freeing large structures with a single store.

Goose also features growth-preserving references, meaning references into a growing array remain valid. It avoids lifetime syntax, aliasing rules, and the `unsafe` keyword, with the compiler inferring reference roots and rejecting invalid references.

Data Structures and Efficiency

Nested data in Goose remains inline, meaning structures like strings, arrays of strings, and records with variable-size fields are stored as contiguous blocks without pointers. This contrasts with C++ where such structures might involve multiple allocations.

The language also implements enums that only cost what they hold, providing memory and speed advantages over traditional enum implementations in other languages. Additionally, it uses narrower links than pointers, storing typed, checked links as small offsets, which supports position-independent data structures.