The Go programming language's core development team has announced a significant performance improvement aimed at slashing heap allocations and reducing garbage collector (GC) overhead. The new optimization, detailed in a blog post by engineer Keith Randall, focuses on moving more memory allocations from the heap to the stack, dramatically accelerating critical code paths.
'Stack allocations are considerably cheaper to perform—sometimes completely free—and they present no load to the garbage collector,' Randall explained. 'This change can make hot loops run much faster, especially in data-intensive applications.'
The improvement is part of ongoing work in recent Go releases, building on prior GC enhancements like the Green Tea garbage collector. The team aims to reduce the overhead of heap allocation, which currently requires significant runtime code and generates garbage that the collector must later scan and reclaim.
Background: The Heap Allocation Problem
Heap allocations occur whenever a Go program requests memory that cannot be placed on the stack—for example, when the size of a slice is unknown at compile time or when an object escapes a function's scope. Each heap allocation triggers a memory allocation routine and adds work for the garbage collector, even with the Green Tea collector's improvements.
Randall illustrated the issue with a common pattern: building a slice by repeatedly appending from a channel. In the original code, the slice's backing store starts at size 1 and doubles each time it fills up, causing repeated heap allocations and generating garbage during the startup phase. 'During this startup phase we spend a lot of time in the allocator, and produce a bunch of garbage, which seems pretty wasteful,' he wrote.
The problem is particularly acute for small slices that never grow large—common in many real-world workloads. The new optimization aims to allocate such temporary backing arrays on the stack instead, eliminating both allocation cost and GC pressure.
What This Means for Developers
For Go developers, the stack-allocation shift translates to faster, more predictable performance in performance-sensitive code, especially when working with slices of unknown but bounded size. The change reduces time spent in the memory allocator and lowers GC pause times, making Go more attractive for low-latency and high-throughput systems.
Developers can expect immediate benefits in existing code: no code changes are required. The Go compiler and runtime automatically decide which allocations can be promoted to the stack. However, the team cautions that the optimization is most effective for constant-sized slices—those whose maximum size is known or bounded by the compiler.
Randall noted that stack allocations also enable 'prompt reuse, which is very cache friendly,' further boosting performance. Early benchmarks indicate speedups of 10-30% in typical slice-building loops, with even larger gains in microbenchmarks.
The improvement is available in the latest Go release candidate. The Go team encourages developers to test their applications and provide feedback.