Memory management

The default mode: every heap allocation the compiler emits (arrays, object literals, closure environments, string concatenation/slicing/templates, Map/Set backing tables, JSON/Date scratch buffers, boxed any payloads) goes through a plain malloc/realloc and is only released by an explicit Memory.free(x). That call resolves the value's underlying heap pointer — array data pointer, object struct, closure header plus environment, Map/Set backing buffers — and frees it shallowly, never anything reachable through it.

void — Memory.free(x) releases x's own top-level allocation(s).

let big: string = "hello " + "world"   // concatenation result -> malloc'd
console.log(big.length)   // 11
Memory.free(big)
console.log(big === null)  // true — the variable's own storage was nulled

Opt-in Boehm-Demers-Weiser collector (libgc): it swaps the declared @malloc/@realloc for @GC_malloc/@GC_realloc and links -lgc, with no per-feature codegen change beyond the allocation call sites, since the collector conservatively scans the native stack, registers, and managed heap for live pointers. Program output is identical to manual mode — gc only changes when memory is reclaimed. Memory.free(x) stays legal and lowers to GC_free, an always-safe early-release hint.

void — Same Memory.free(x) surface; here it hints the collector rather than calling libc free().

let s: string = "abcdefghijklmnopqrstuvwxyz0123456789" + "abcdefghijklmnopqrstuvwxyz0123456789";
total = total + s.length;

Compiler-inserted frees at compile-time-proven-safe points, with no runtime collector. /** @free */ frees a binding at every exit of its declaring block; /** @owned */ frees right after the statically-determined last use (on locals, and on parameters via a function-level '@owned name' tag — the callee frees its argument, and every call site must pass a value the caller provably no longer uses). Every unannotated local that passes the same conservative escape check is freed at block exit automatically. The annotations are honored in all three modes — they are compiler-checked, compiler-placed Memory.free — and an annotation the analysis cannot prove safe is a compile error, never a silent no-op. Memory.free(x) itself is a compile error in this mode: the compiler owns every free.

Allocation optimizations with no semantic change. Stack allocation: object literals, (non-async) closure headers/environments, tuple-annotated literals, and this-clean class instances the escape analysis proves never outlive their block become entry-block allocas instead of heap allocations — less allocator pressure and better cache locality, measured as exactly the object allocations disappearing from peak RSS on allocation-churn loops clang cannot elide itself. By-value tuple returns: an eligible small-tuple-returning function returns a register-passable struct aggregate, so return [a, b] and the Go-style const [v, err] = f() consumer are allocation-free end to end. Composes with every -mm mode; a stack value is never auto-freed and a registered FinalizationRegistry target stays heap so its free death-signal keeps firing.

Opts one array binding into a flat value-type layout: elements are packed inline in a single contiguous buffer (array of structs, stride = the element's struct size) instead of the default array-of-pointers — one allocation, cache-friendly traversal, vectorizable loops. This is a per-binding annotation, not a compiler flag, because it deliberately changes aliasing semantics: writing a value into a slot copies its fields (later mutation of the source object is invisible through the array), while reading arr[i] yields an interior-pointer view, so arr[i].x = 1, a taken const v = arr[i], and for...of bindings all mutate the array in place.