What Is New in Go 1.23
Go 1.23 brings enhancements across the language, standard library, and tooling, focusing on developer productivity and performance. This release continues to refine the generics implementation and introduces new capabilities for structured logging and concurrency.
| Category | Key Changes |
|---|---|
| Language | New range-over-function experiment, enhancements to type inference for generic functions. |
| Standard Library | New log/slog package for structured logging, math/rand/v2 becomes permanent, net/http improvements. |
| Tooling | Go command support for vendoring when using the workspace mode, coverage improvements. |
| Performance | Compiler optimizations, including better inlining and escape analysis for generics. |
| Ports | New support for linux/loong64, updates to existing platforms. |
How does the new range-over-function experiment work?
The new range-over-function experiment allows iterating over functions that yield values. This is a significant step toward supporting custom iterators in Go, similar to generators in other languages. You enable it with a GOEXPERIMENT=rangefunc flag when building your code.
In practice, this means you can write a function that returns a coroutine to produce a sequence of values. The compiler then lets you loop over those values directly with a for range loop. This is a cleaner pattern for lazy evaluation and streaming data compared to using channels and goroutines manually.
Example
// Example of a function that can be ranged over (experimental)
for x := range myIteratorFunc {
// process x
}
What are the key improvements to the standard library?
The standout addition is the new log/slog package for structured logging, which has graduated from the exp directory. It provides leveled logging with key-value attributes, making it easier to integrate with modern logging systems. The math/rand/v2 package is now permanent, offering a cleaner, more consistent API and faster algorithms.
The net/http package sees refinements, including better handling of request and response patterns. Other packages like cmp, slices, and maps also receive minor API tweaks and performance optimizations based on community usage.
What tooling changes should I be aware of?
The Go command now fully supports vendoring when working inside a Go workspace. This resolves a previous pain point where module vendoring and multi-module workspaces didn't play nicely together. The coverage tooling has also been improved to provide more accurate reports for larger codebases.
For most developers, the day-to-day experience with go build, go test, and go run remains stable and fast. The underlying compiler and linker continue to see incremental performance gains, which can lead to slightly faster build times for some projects.
How does Go 1.23 affect generics?
Go 1.23 includes under-the-hood improvements to the generics implementation, primarily around type inference and compiler optimizations. The compiler does a better job at inlining generic functions and performing escape analysis on generic code, which can lead to performance benefits.
While there are no new syntax changes to generics, these optimizations make existing generic code more efficient. This matters because it solidifies the performance story for using generics in performance-sensitive paths of an application.
FAQ
Is the range-over-function feature stable?
No, it is currently an experiment enabled by the GOEXPERIMENT=rangefunc build flag. Its design may change based on user feedback before it becomes a permanent part of the language.
Should I migrate from log to log/slog?
If you need structured logging for systems like JSON-formatted logs or logging services, yes. For simple stdout logging, the traditional log package is still sufficient.
What's the difference between math/rand and math/rand/v2?
The v2 package has a cleaner, more consistent API and uses faster random number generation algorithms. New projects should use v2, but existing code can continue using the original.
Does vendoring work with workspaces now?
Yes, this was a key fix in 1.23. The go command now correctly handles the vendor directory when used within a multi-module workspace defined by a go.work file.
Are there any breaking changes?
As with most Go releases, the focus is on compatibility. The spec change to range loops is the most notable potential break, but it only affects a specific edge case with predeclared identifiers and is unlikely to impact most codebases.