Go 1.25 Introduces Experimental Green Tea Garbage Collector: Performance Gains and Future Plans

Introduction

The Go programming language continues to evolve, and with version 1.25, a groundbreaking experimental garbage collector—dubbed Green Tea—has arrived. Available by setting GOEXPERIMENT=greenteagc at build time, this new collector is already in production use at Google and promises significant reductions in GC overhead. Early benchmarks show that many workloads spend around 10% less time in garbage collection, with some experiencing reductions of up to 40%. While not every workload benefits equally, the team behind Go encourages developers to test Green Tea and share their results. Based on current data, the plan is to make Green Tea the default GC in Go 1.26.

This article explores the principles behind Green Tea, how it differs from the existing GC, and what you can expect when trying it out. We’ll also cover how to report feedback—both positive and negative—to help shape the future of Go’s memory management.

Understanding Tracing Garbage Collection

Before diving into Green Tea, it helps to revisit the basics of garbage collection in Go. The Go runtime uses a tracing garbage collector, which means it periodically traces through the program’s object graph to find which objects are still reachable (live) and which are not (dead). Unreachable objects are then collected, and their memory is reclaimed for reuse.

Objects and Pointers

In Go, the garbage collector focuses on heap-allocated objects and the pointers that reference them. Heap objects are created when the Go compiler cannot determine at compile time how to allocate memory for a value—for example, when a local variable escapes to the heap. The GC must accurately identify all pointers within an object to traverse the graph correctly. Go’s type-safe design helps here: the runtime knows where pointers are located in each struct, which enables efficient and precise scanning.

Traditional tracing collectors (like the one used in Go before 1.25) can introduce pause times or significant CPU overhead during the tracing phase. Over the years, Go has moved toward concurrent garbage collection to minimize pauses, but the tracing itself still consumes CPU cycles that could otherwise be used by the application.

What Makes Green Tea Different?

The Green Tea garbage collector builds on these foundations but introduces a novel approach to reduce tracing overhead. Instead of scanning all live objects from a global root set during every GC cycle, Green Tea employs a generational hypothesis: most objects die young, and older objects are less likely to become garbage. By focusing on the youngest generation (the “nursery”) and only occasionally scanning older generations, Green Tea can dramatically cut down the amount of work performed per cycle.

This design is reminiscent of generational garbage collectors used in languages like Java and C#, but tailored to Go’s concurrency model and the specific patterns of Go programs. The result is lower GC CPU usage and, for many applications, a smoother performance profile.

Production‑Ready at Google

Google has been running Green Tea internally on a wide range of services before releasing it publicly. According to the Go team, the collector is production‑ready and has already delivered measurable improvements in latency and throughput. This real‑world validation gives confidence that Green Tea is not just an academic exercise—it’s a practical upgrade for many Go developers.

Performance Impact: What to Expect

When you enable Green Tea with GOEXPERIMENT=greenteagc, the most noticeable effect is a reduction in the time Go spends inside the garbage collector. The team reports:

• Typical workloads see a 10 % reduction in GC CPU time.
• Some workloads experience reductions of up to 40 %.
• Certain patterns (e.g., those that allocate many short‑lived objects) benefit the most.

However, not every program will see improvements. Workloads that allocate very few young objects, or that have unusual pointer graphs, may see little or no benefit. The Go team emphasizes that your mileage may vary, which is exactly why they are asking for community feedback.

How to Try Green Tea

To test the Green Tea garbage collector in your own projects:

1. Build your Go program with the environment variable GOEXPERIMENT=greenteagc. For example: GOEXPERIMENT=greenteagc go build.
2. Run your usual benchmarks or production tests.
3. Compare GC metrics (e.g., pause times, GC CPU usage, allocation rates) with the default collector.

The Go team has set up dedicated channels for feedback:

• To report problems: file a new issue on the Go issue tracker.
• To share successes: reply to the existing Green Tea issue (issue number to be provided).

Your input will directly influence whether Green Tea becomes the default in Go 1.26.

What’s Next for Green Tea?

The Go team is committed to making garbage collection as efficient as possible. Based on the data collected so far, the plan is to make Green Tea the default garbage collector in Go 1.26. However, this decision hinges on broader community validation. If you encounter regressions or other issues, reporting them now gives the team time to address them before the default switch.

In the long term, concepts pioneered in Green Tea may lead to further optimizations—perhaps even a fully concurrent generational collector that pushes GC overhead even lower. For now, Green Tea represents a significant step forward for Go’s memory management.

Conclusion

The Green Tea garbage collector is a promising addition to Go 1.25. It offers reduced GC CPU usage for many workloads, is already battle‑tested at Google, and is easy to try in your own projects. While not a universal silver bullet, its potential to improve performance is substantial. The Go team relies on your feedback to validate and refine this new design. Whether you see a 10 % or 40 % improvement—or none at all—your experience matters. Give Green Tea a try, and help shape the future of Go’s garbage collection.