Go 1.26 Makes Green Tea Garbage Collector the Default, Cutting GC Overhead by Up to 40 Percent
Go 1.26 ships with the Green Tea garbage collector enabled by default, replacing the object-centric mark-sweep algorithm with a page-level scanner that reduces GC CPU costs by 10 to 40 percent in real-world workloads.
Overview
Go 1.26, released on February 10, 2026, promotes the experimental Green Tea garbage collector to the default runtime configuration. The new collector replaces Go’s long-standing object-centric concurrent mark-and-sweep algorithm with a page-level scanning architecture that reduces garbage collection CPU costs by 10 to 40 percent in programs that allocate heavily, according to the official release notes. The release also introduces two language changes, a 30 percent reduction in cgo call overhead, and experimental SIMD support.
Green Tea first shipped as an opt-in experiment in Go 1.25. Its graduation to the default marks the most significant change to Go’s memory management since the introduction of the concurrent garbage collector in Go 1.5 over a decade ago.
What We Know
The Green Tea Garbage Collector
The core innovation behind Green Tea is a shift from marking individual objects to scanning contiguous 8 KiB memory pages. Traditional mark-sweep collectors chase pointers scattered across the heap, incurring heavy CPU cache miss penalties. Green Tea instead tracks pages on the work list and scans objects within each page in memory order, dramatically improving spatial locality, as described in the Go team’s technical blog post.
The design uses two bits of metadata per object — a “seen” bit indicating whether a pointer to the object has been found, and a “scanned” bit tracking whether the object has been processed. Pages accumulate seen objects while queued, allowing multiple objects to be scanned in a single sequential pass through memory. The collector uses FIFO ordering rather than the traditional LIFO stack, which further improves cache behavior.
According to the release notes, the result is a 10 to 40 percent reduction in garbage collection overhead in real-world programs. For an application that spends 10 percent of its CPU time in the garbage collector, that translates to a 1 to 4 percent overall CPU reduction depending on workload characteristics.
On newer x86 hardware — specifically Intel Ice Lake and AMD Zen 4 and later — the collector uses AVX-512 vector instructions to scan small objects within pages in parallel, yielding an additional approximately 10 percent improvement in GC CPU costs, as detailed in the Green Tea blog post. The AVX-512 kernel processes 64 bytes of page metadata at a time using the VGF2P8AFFINEQB instruction for efficient bit-vector transformations.
The collector was prototyped by Austin Clements in 2024 and productionized by Michael Knyszek, with contributions from Michael Pratt, Cherry Mui, David Chase, and Keith Randall, according to the Go team’s blog post. Microarchitectural insights from Yves Vandriessche at Intel informed the vector acceleration work.
Developers who encounter regressions can disable Green Tea at build time by setting GOEXPERIMENT=nogreenteagc, though the Go team has indicated this opt-out will be removed in Go 1.27.
Language Changes
Go 1.26 introduces two syntax refinements. The built-in new function now accepts an expression specifying an initial value, allowing new(int64(300)) instead of the previous pattern of declaring a variable and taking its address. Generic types can now refer to themselves in their own type parameter lists, simplifying the implementation of self-referential data structures such as recursive tree types, as noted in the release announcement.
Runtime and Tooling Improvements
Beyond the garbage collector, the release reduces cgo call overhead by approximately 30 percent, according to the release notes. The compiler can now allocate slice backing stores on the stack in more situations, reducing heap pressure.
The go fix command has been rewritten to use the Go analysis framework and now includes roughly two dozen “modernizers” — analyzers that suggest safe refactorings to help codebases adopt newer language and library features. A new inline analyzer supports //go:fix inline directives for source-level function inlining.
Three new standard library packages ship in this release: crypto/hpke for Hybrid Public Key Encryption as specified in RFC 9180, crypto/mlkem/mlkemtest for ML-KEM testing utilities, and testing/cryptotest. An experimental simd/archsimd package provides access to architecture-specific SIMD operations on amd64 with 128-bit, 256-bit, and 512-bit vector types.
What We Don’t Know
While benchmarks show consistent improvements for workloads with heavy small-object allocation, the Go team has acknowledged that some workloads with irregular heap structures may see no benefit or potential regressions. InfoQ reported that some early adopters during the Go 1.25 experimental phase observed increased latency per GC cycle despite reduced overall GC frequency. Whether the Go 1.26 implementation fully addresses these edge cases remains to be seen as adoption scales beyond Google’s internal workloads.
The long-term impact on Go’s competitiveness in latency-sensitive domains — where languages like Rust and Java’s ZGC have set aggressive pause-time targets — is also uncertain. Green Tea optimizes throughput rather than pause times, and the Go team has not announced plans for a low-latency collector.
Analysis
Go’s garbage collector has been both a strength and a criticism since the language’s inception. The concurrent collector introduced in Go 1.5 eliminated the multi-millisecond stop-the-world pauses that plagued earlier versions, but the marking phase remained a significant CPU cost, with roughly 90 percent of GC time spent chasing pointers across the heap. Green Tea attacks this bottleneck at the architectural level, trading the conceptual simplicity of object-level marking for a page-level approach that aligns with how modern CPUs actually access memory.
The decision to make Green Tea the default in Go 1.26 — rather than leaving it as an opt-in experiment for another release — signals confidence from the Go team. The collector is already in production at Google, and the opt-out mechanism provides a safety valve for the transition period. Combined with the cgo overhead reduction and the new SIMD package, Go 1.26 represents the most performance-focused release in the language’s recent history.