10 Key Insights into Go's Green Tea Garbage Collector

Go 1.25 introduces an exciting experimental feature: the Green Tea Garbage Collector (GC). Designed to significantly reduce garbage collection time while maintaining production stability, this new GC is already proving its worth at Google. Whether you're a Go developer curious about performance improvements or just want to understand the future of memory management in Go, these 10 points cover everything you need to know. From enabling the collector to interpreting its performance gains, this listicle breaks down the technical details in an engaging, accessible way.

1. What Is the Green Tea Garbage Collector?

The Green Tea GC is an experimental garbage collector available in Go 1.25, enabled by setting GOEXPERIMENT=greenteagc at build time. It aims to reduce the time programs spend in garbage collection, leading to smoother application performance. While many workloads see around a 10% reduction in GC time, some experience up to a 40% improvement. This collector is not a toy—it's production-ready and already used by Google internally. Based on strong performance data, the Go team plans to make it the default garbage collector in Go 1.26.

2. The Origins of the Name "Green Tea"

The name “Green Tea” comes from an internal Google tradition of giving garbage collectors fun, memorable codenames. It reflects the team's desire for a collector that is both efficient (like the metabolism-boosting properties of green tea) and refreshingly new. The name also aligns with Go's history of using drink-themed codenames for major runtime features, making it easy for developers to remember and discuss. But beyond the playful name, the real story lies in its technical innovations.

3. How Does Green Tea Differ from Go's Previous GC?

Go's existing GC is a concurrent, tri-color mark-sweep collector. Green Tea builds on this foundation but introduces optimizations that reduce stop-the-world pauses and improve concurrency. Specifically, it reworks how the collector handles pointer updates during concurrent marking, allowing it to finish marking phases faster. The result is less time spent in GC cycles, especially for applications with complex pointer graphs. The core algorithms remain similar, but Green Tea fine-tunes the interactions between mutator goroutines and the GC.

4. Performance Improvements: 10% to 40% Reduced GC Time

The most compelling reason to try Green Tea is its performance impact. For many workloads, GC time drops by about 10%. However, some applications with intricate pointer relationships see even greater gains—up to 40% less time in the garbage collector. This reduction directly translates to higher throughput and lower latency, particularly for latency-sensitive services. Early adopters at Google report noticeable improvements in production environments, though results vary depending on allocation patterns and heap sizes. The Go team encourages all developers to benchmark their own applications.

5. Production-Ready and Already in Use at Google

Green Tea isn't just an experimental prototype—it’s been battle-tested at Google. The collector has been running on production servers handling real user traffic, proving its stability and performance benefits. This gives the Go team confidence that it can serve as the default GC in the next release. Because it’s fully compatible with existing Go code (no source changes needed), developers can adopt it simply by rebuilding with the GOEXPERIMENT flag. Google’s internal experience shows that the collector handles diverse workloads without regressions.

6. How to Enable Green Tea in Your Go Build

Enabling Green Tea is straightforward: compile your Go program with the environment variable GOEXPERIMENT=greenteagc. For example, GOEXPERIMENT=greenteagc go build. This applies to all Go 1.25 builds. The flag instructs the compiler to link in the Green Tea GC runtime instead of the default one. No changes to your source code are required—just rebuild and deploy. However, since it's experimental, the Go team recommends testing thoroughly in a staging environment before rolling out to production.

7. The Plan: Default in Go 1.26

Based on the promising performance data and internal testing, the Go team plans to promote Green Tea to the default garbage collector in Go 1.26. This means that unless you opt out (via a new GOEXPERIMENT flag), all Go programs will automatically use Green Tea. The team is gathering feedback from the community to ensure a smooth transition. Reporting successes or issues helps refine the collector before it becomes the standard. The timeline aligns with Go's release cycle, giving developers a year to experiment and adapt.

8. Understanding Tracing Garbage Collection

To appreciate Green Tea, it helps to understand the basics of tracing garbage collection. A tracing GC identifies live objects by traversing the pointer graph starting from root references (e.g., stacks and global variables). It marks reachable objects, then sweeps unmarked (dead) ones to reclaim memory. Go's GC uses a concurrent mark-sweep algorithm: marking runs while the application executes, though it still requires short “stop-the-world” pauses for root scanning and synchronization. Green Tea improves this by reducing the duration of those pauses and the overhead of concurrent marking.

9. The Role of Objects and Pointers

At its core, the Go garbage collector deals with objects and pointers. Objects are heap-allocated values (e.g., structs, slices backing arrays). Pointers reference these objects. The collector finds live objects by following pointers from known roots. Green Tea introduces a more efficient way to track pointer modifications during concurrent marking, using a technique called “write barrier” improvements. By reducing the work needed to maintain consistency, the collector completes marking faster. This is especially beneficial for applications with many pointer writes.

10. How You Can Help: Provide Feedback

The Go team relies on community feedback to validate and improve Green Tea. If you encounter any problems—such as crashes, memory leaks, or performance regressions—file an issue on the Go issue tracker. Conversely, if you see great results, share your success story by replying to the existing Green Tea issue thread. Your input directly influences the decision to make Green Tea the default. The team is particularly interested in workloads that show neutral or negative impacts, as those cases help identify areas for further optimization.

The Green Tea Garbage Collector represents a significant step forward for Go's runtime performance. With double-digit reductions in GC time, production-proven reliability, and a clear upgrade path to default status in Go 1.26, now is the perfect time to start evaluating it. Whether you run microservices, CLI tools, or data pipelines, Green Tea promises to make your Go applications faster with minimal effort. Try it today and join the conversation shaping the future of Go memory management!