Golang Releases 1.25 and Beyond

Golang 1.25 was released in July 2023, marking a significant milestone in the language's development.

The release brought numerous improvements, including better support for Go modules and improved performance.

Go 1.25 also introduced several new features, such as improved error handling and better support for concurrent programming.

One notable change was the introduction of the "go get" command, which simplified the process of acquiring and installing packages.

Golang 1.26, released in November 2023, continued this trend, with a focus on performance and stability.

The release included several performance optimizations, including improved garbage collection and better use of CPU resources.

Go 1.26 also introduced several new features, such as improved support for WebAssembly and better integration with other languages.

Developers can expect to see continued improvements in future releases, with a focus on making Golang an even more powerful and efficient tool for building applications.

For more insights, see: Golang Go

Go has been around for a while, and its release history is quite extensive. The first major release was Go 1.0, but it's the subsequent releases that are really interesting.

See what others are reading: Go vs Golang

Go 1.1 was released in 2013, and it was a major release that included a security fix to the compiler, as well as several bug fixes to the compiler and runtime. This release also fixed issues with the gc compiler and cgo.

The next major release was Go 1.2, which came out in 2013 as well. This release included bug fixes to the runtime, net, and database/sql packages, and it also fixed a security issue that affected the tour binary.

Go 1.3 was released in 2014, and it included bug fixes to the compiler and runtime, net, and crypto/rsa packages. This release also fixed security issues in the crypto/tls package and cgo.

In 2014, Go 1.4 was released, which included bug fixes to the linker and the log, syscall, and runtime packages. This release also fixed security issues in the compiler and bug fixes to the go command, compiler, and linker.

Go 1.5 was released in 2015, and it included bug fixes to the compiler, assembler, and the fmt, net/textproto, net/http, and runtime packages. This release also included a security fix to the math/big package that affected the crypto/tls package.

Go 1.6 was released in 2016, and it included two security fixes. This release also fixed issues with the compiler, runtime, tools, documentation, and the mime/multipart, net/http, and sort packages.

Take a look at this: Golang Security

Go 1.7 was released in 2016, but the development window was shorter than usual. The development window was expanded for Go 1.20, which included a late freeze and early thaw.

Go 1.8 was released in 2017, and it included fixes to the compiler, linker, runtime, documentation, go command, and the crypto/tls, encoding/xml, image/png, net, net/http, reflect, text/template, and time packages. This release also included a security fix to the crypto/elliptic package.

Go 1.10 was released in 2018, and it included security fixes to the go command, as well as bug fixes to the compiler, runtime, and various packages. This release also included fixes to the go command, linker, and various packages in subsequent point releases.

Related reading: Golang Test Command

Go releases are supported until there are two newer major releases. For instance, Go 1.5 was supported until Go 1.7 was released, and Go 1.6 was supported until Go 1.8 was released.

We fix critical problems, including critical security problems, in supported releases as needed by issuing minor revisions. These revisions are denoted by a number after the major release number, such as Go 1.6.1 or Go 1.6.2.

The freeze policy allows fixes intended for the current release to be cherry-picked onto the release branch during a specific time period. This period starts in July or January, week three, and is known as the time when work on the next release begins.

Fixes that are permitted by the freeze policy do not need a freeze exception. However, any exceptions to the freeze must be communicated to and explicitly approved by the Go Release Team before the freeze.

Go releases are supported until there are two newer major releases. For example, Go 1.5 was supported until the Go 1.7 release, and Go 1.6 was supported until the Go 1.8 release.

Each major release is supported for a significant period, allowing developers to work with confidence. Critical problems, including security issues, are fixed in supported releases through minor revisions, such as Go 1.6.1, Go 1.6.2, and so on.

A release candidate is issued in August or February week 2, indicating that release testing has confirmed the high confidence that the tree is free of critical bugs.

A unique perspective: Css 2 Release Date

January Week 1 marks the beginning of planning for the upcoming release cycle.

Planning for major work is announced on golang-dev, a platform used by the Go team to discuss and share information about upcoming releases.

As an example, the Go 1.20 release cycle planning was announced during this week, signaling the start of preparations for the new version.

The Go team uses this week to lay the groundwork for the upcoming release, setting the stage for a successful launch.

August Week 2 Release is a significant milestone in the Go release cycle. A release should not contain significant changes since the last release candidate, and it's essential that all code in the release has been well tested.

Issuing a release is an indication that release testing has confirmed the release candidate's high confidence that the tree is free of critical bugs. Extra testing can only improve the stability of a release, and it also gives developers working on the Go release more time to think about and plan the next release before code changes start pouring in again.

For another approach, see: Golang Comments

By the time of the final release, Google will have been using this version of Go for nearly two months, which has helped improve the quality of the release. We strongly encourage other organizations to test release candidates as aggressively as they are able and to report problems that they find.

Once a release is stabilized, work on the next release, including code reviews and submission of new code, can begin, and the cycle repeats.

Readers also liked: Golang Source Code

Go 1.24 was released in February 2025, six months after Go 1.23.

Most of the changes in Go 1.24 are in the implementation of the toolchain, runtime, and libraries.

The release maintains the Go 1 promise of compatibility, meaning almost all Go programs will continue to compile and run as before.

Go 1.25 was released in August 2025, six months after Go 1.24.

The release focuses on implementation changes to the toolchain, runtime, and libraries.

Most Go programs will continue to compile and run as before due to the Go 1 promise of compatibility.

There are no language changes that affect Go programs in Go 1.25.

The language specification has removed the notion of core types in favor of dedicated prose.

Making Cherry-Pick CLs is a crucial part of the release process, and it's essential to understand the process to avoid any potential issues.

Only the authors of the original CL and approvers have the ability to create a cherry-pick CL.

Once the main fix has been submitted to master, you'll need to create a cherry-pick CL to the applicable release branch. This can be done using the Gerrit UI if there are no merge conflicts.

In the Gerrit UI, enter the branch name, add the commit message prefix, update the “Fixes” line, and do not change any of the other automated lines.

To cherry-pick from the command line or to resolve a merge conflict, take note of the final commit hash, then use git codereview and git cherry-pick to prepare a cherry-pick CL.

The cherry-pick CL must include a message prefix like [release-branch.go1.10], and update the “Fixes” line to the child issue. Do not change or remove the “Change-Id” line nor the other Gerrit lines.

The code review process is otherwise the same as regular CLs, but permission to submit to the release branches is more restricted. If you don't have submit permissions, release managers will submit the CL for you once it's ready.

For more insights, see: Golang Command Line Arguments

Go 1.24 includes a new set of mechanisms to facilitate FIPS 140-3 compliance.

The Go Cryptographic Module is a set of internal standard library packages that are transparently used to implement FIPS 140-3 approved algorithms. Applications require no changes to use the Go Cryptographic Module for approved algorithms.

You can use the new GOFIPS140 environment variable to select the Go Cryptographic Module version to use in a build.

The new fips140GODEBUG setting can be used to enable FIPS 140-3 mode at runtime. This allows for more flexibility in testing and deployment scenarios.

Go 1.24 includes Go Cryptographic Module version v1.0.0, which is currently under test with a CMVP-accredited laboratory.

Readers also liked: Golang Version Manager

In the latest release, testing has become even more robust with the introduction of new methods to emit attributes to the test log. The T.Attr, B.Attr, and F.Attr methods allow you to associate arbitrary key-value pairs with a test.

For example, you can use t.Attr("key", "value") to emit an attribute in a test named TestF. This will result in a new "attr" action appearing in the test output when the -json flag is used.

A unique perspective: T Golang

The Output method of T, B, and F now provides an io.Writer that writes to the same test output stream as TB.Log. This means you can use it to write indented output without including file and line numbers.

The AllocsPerRun function has been updated to panic if parallel tests are running, which helps catch bugs that would otherwise be flaky. This change ensures that AllocsPerRun behaves consistently and accurately.

Minor changes have been made to the library in the latest Go release.

The FilterPackage, PackageExports, and MergePackageFiles functions are deprecated, as they are no longer needed with the updated Object and Package machinery.

These functions were only used with the old Object and Package machinery, which has been replaced with more modern alternatives.

For your interest: Create a Package in Golang

Go 1.24 introduces significant language changes that improve developer experience.

The language now fully supports generic type aliases, which can be parameterized like defined types. This feature is a major upgrade, and you can find more details in the language spec.

For now, you can disable this feature by setting GOEXPERIMENT=noaliastypeparams in your environment. However, be aware that this setting will be removed in Go 1.25, so it's best to get familiar with the new feature.

The library has undergone some minor changes that are worth noting. Specifically, the FilterPackage function is deprecated.

The PackageExports and MergePackageFiles functions are also no longer supported. They were only used with the long-deprecated Object and Package machinery.

The MergeMode type and its constants are also deprecated, which means they're no longer recommended for use.

In the latest language and library updates, the Crypto Ecdsa has undergone some significant changes.

PrivateKey.Sign now produces a deterministic signature according to RFC 6979 if the random source is nil.

This change means that developers can rely on a consistent outcome when signing messages, which is especially useful for applications that require predictable behavior.

The update to Crypto Ecdsa is a welcome improvement, providing a more reliable and efficient way to handle digital signatures.

The new implementation of PrivateKey.Sign is a direct result of the updated specification from RFC 6979.

Overall, this change is a positive step forward for developers working with digital signatures and cryptographic algorithms.

The Hash/FNV package has seen some interesting updates. The values returned by New32, New32a, New64, New64a, New128, and New128a now also implement the encoding.BinaryAppender interface.

This means you can use these hash functions in a more flexible way, especially when working with binary data.

The encoding.BinaryAppender interface allows you to append binary data to the hash function's output, which can be really useful in certain situations.

Regexp now implements the encoding.TextAppender interface, which is a significant update for developers working with regular expressions.

This means that Regexp can now work seamlessly with encoding.TextAppender, making it easier to use in various applications.

Regexp is a powerful tool for pattern matching and searching in text, and this new implementation will likely make it even more versatile.

Developers can now take advantage of Regexp's enhanced capabilities, leading to more efficient and effective coding practices.

Text/Template has seen some exciting updates. Templates now support range-over-func and range-over-int.

This means developers can create more dynamic and flexible templates that can handle complex data structures. The range-over-func feature allows for functions to be applied to a range of values, while range-over-int enables iterating over a range of integers.

Templates are a powerful tool in any developer's arsenal, and these new features will make them even more versatile. With these updates, developers can now write more concise and readable code.

Loong64 has made significant strides, supporting the race detector. This allows for more efficient debugging and troubleshooting.

The linux/loong64 port now enables the gathering of traceback information from C code using runtime.SetCgoTraceback. This feature is particularly useful for developers working with cgo programs.

Linking cgo programs with the internal link mode is also now supported, making it easier to integrate cgo code into larger projects.

In the latest golang release, some minor changes have been made to the library.

The FilterPackage, PackageExports, and MergePackageFiles functions have been deprecated.

These functions were used only with the long-deprecated Object and Package machinery, making them unnecessary for modern development.

Developers who have been using these functions should update their code accordingly.

Minor Revisions can make a big difference in how we work with packages and functions.

The FilterPackage function is one of the things that's being deprecated. It's been around for a while, but it's no longer necessary.

If you're still using the Object and Package machinery, you'll want to know that the MergePackageFiles function is also being phased out. This is part of a larger effort to simplify the way we work with packages.

The PackageExports function is another thing that's being deprecated. It's been replaced by more modern and efficient approaches.

The MergeMode type and its constants are also being removed. This will help to reduce clutter and make it easier to work with packages.

It's worth noting that these changes are part of a larger effort to improve the way we work with packages and functions.

New crypto packages have been added to the Go standard library, including crypto/mlkem, crypto/hkdf, crypto/pbkdf2, and crypto/sha3. These packages implement various post-quantum key exchange mechanisms and hash functions.

The crypto/mlkem package implements ML-KEM-768 and ML-KEM-1024, a post-quantum key exchange mechanism formerly known as Kyber and specified in FIPS 203.

The crypto/hkdf, crypto/pbkdf2, and crypto/sha3 packages implement the HMAC-based Extract-and-Expand key derivation function HKDF, the password-based key derivation function PBKDF2, and the SHA-3 hash function and SHAKE and cSHAKE extendable-output functions, as defined in RFC 5869 and FIPS 202.

These new packages can be used for secure key exchange and data encryption in various applications.

The crypto/mlkem package is a significant addition, providing a post-quantum key exchange mechanism that can be used to establish secure connections.

These new packages are now part of the Go standard library, making it easier for developers to use them in their projects.

The new testing/synctest package provides support for testing concurrent code.

The synctest package is experimental and must be enabled by setting GOEXPERIMENT=synctest at build time.

The Test function runs a test function in an isolated "bubble". Within the bubble, time is virtualized: time package functions operate on a fake clock and the clock moves forward instantaneously if all goroutines in the bubble are blocked.

The Wait function waits for all goroutines in the current bubble to block.

This package was first available in Go 1.24 under GOEXPERIMENT=synctest, with a slightly different API. The experiment has now graduated to general availability.

Here are the key features of the synctest package:

The math library has seen some exciting updates.

Float, Int, and Rat now implement the encoding.TextAppender interface.

This means you can easily convert these types into a string representation.

In practice, this can be super useful for debugging or logging purposes.

Math/Rand has been updated to reflect the deprecation of the top-level Seed function. This change means that calls to Seed no longer have any effect.

If you want to restore the old behavior, you can use the GODEBUG setting "randseednop=0".

For more background on this change, see proposal #67273.

The Archive/Tar package has been updated to support symbolic links for filesystems that implement io/fs.ReadLinkFS. This means you can now work with symbolic links in Archive/Tar more easily.

The Writer.AddFS implementation now supports symbolic links for filesystems that implement io/fs.ReadLinkFS. This is a significant improvement, especially for developers working with file systems that need to handle symbolic links.

The io/fs.ReadLinkFS interface allows for reading the target of a symbolic link, which is essential for working with symbolic links in Archive/Tar. This interface is now supported by the Writer.AddFS implementation.

Worth a look: Golang Io

The Encoding/ASN1 update has brought some welcome changes to the way we work with ASN.1 types. Unmarshal and UnmarshalWithParams now parse T61String more consistently.

This may result in some previously accepted malformed encodings being rejected.

On Windows, NewFile now supports handles opened for asynchronous I/O, which is a game-changer for applications that communicate via named pipes.

This means that I/O methods like File.Read, File.Write, File.ReadAt, and File.WriteAt won't block an OS thread, making your code run smoother and more efficiently.

The Go runtime's I/O completion port provides two main benefits: non-blocking I/O and deadline support. With non-blocking I/O, your code can perform other tasks while waiting for I/O operations to complete, and with deadline support, you can set deadlines for I/O operations, ensuring they complete within a certain time frame.

Note that a handle can only be associated with one completion port at a time. If the handle provided to NewFile is already associated with a completion port, the returned File is downgraded to synchronous I/O mode, which means I/O methods will block an OS thread.

Here are the new methods supported by Root:

The runtime has seen significant improvements, with CPU overheads decreased by 2-3% on average across various benchmarks. These improvements include a new built-in map implementation based on Swiss Tables and more efficient memory allocation of small objects.

The new runtime-internal mutex implementation is also noteworthy, although it can be disabled at build time by setting GOEXPERIMENT=nospinbitmutex. This gives developers more control over the runtime's performance.

Cleanup functions scheduled by AddCleanup are now executed concurrently and in parallel, making cleanups more viable for heavy use. This is particularly useful for packages that rely heavily on cleanups, like the unique package.

A new GODEBUG setting, checkfinalizers=1, helps identify issues with finalizers and cleanups by running diagnostics on each garbage collection cycle. This setting will also regularly report the finalizer and cleanup queue lengths to stderr, making it easier to track down problems.

The new SetDefaultGOMAXPROCS function is a useful addition, as it sets GOMAXPROCS to the runtime default value, even if it's been disabled by the GOMAXPROCS environment variable or a prior call to GOMAXPROCS. This can be especially helpful for developers who want to take advantage of the new GOMAXPROCS default.

The mutex profile for contention on runtime-internal locks now correctly points to the end of the critical section that caused the delay. This matches the profile's behavior for contention on sync.Mutex values.

Go developers, get ready to experiment! A new garbage collector is now available as an experiment, designed to improve performance by reducing garbage collection overhead in real-world programs.

This new garbage collector is expected to provide a 10-40% reduction in garbage collection overhead, and can be enabled by setting GOEXPERIMENT=greenteagc at build time.

The design is still evolving, so Go developers are encouraged to try it out and report back their experiences.

Two new packages are also available as part of the experimental features: the encoding/json/v2 package and the encoding/json/jsontext package. The encoding/json/v2 package is a major revision of the encoding/json package, and can be enabled by setting the environment variable GOEXPERIMENT=jsonv2 at build time.

Here are the new packages and their features:

The new JSON implementation performs substantially better than the existing one under many scenarios, with encoding performance at parity and decoding substantially faster.

The experimental testing package, synctest, provides a way to test concurrent code in a controlled environment. This package is still in its early stages and requires the GOEXPERIMENT=synctest flag to be enabled at build time.

The synctest package allows you to start a group of goroutines in an isolated "bubble" using the synctest.Run function. Within this bubble, time package functions operate on a fake clock.

The synctest package also provides a Wait function that waits for all goroutines in the current bubble to block. This is useful for testing concurrent code that relies on the passage of time.

Here are some key features of the synctest package:

Keep in mind that the synctest package is still experimental and its API is subject to change in future releases. If you're interested in learning more, check out issue #67434 for more information and to provide feedback.

The new experimental encoding/json/v2 package is available in Go 1.25, which can be enabled by setting the environment variable GOEXPERIMENT=jsonv2 at build time.

This new package is a major revision of the encoding/json package and provides lower-level processing of JSON syntax through the encoding/json/jsontext package.

A unique perspective: Convert a Map to Json Golang

The encoding/json package uses the new JSON implementation when the "jsonv2" GOEXPERIMENT is enabled, but marshaling and unmarshaling behavior remains unaffected.

However, the text of errors returned by package functions may change, and the package contains new options to configure the marshaler and unmarshaler.

The new implementation performs substantially better than the existing one under many scenarios, with encoding performance at parity and decoding substantially faster in the new one.

To help detect any compatibility issues, we encourage users of encoding/json to test their programs with GOEXPERIMENT=jsonv2 enabled.

Here are some key features of the new encoding/json/v2 package:

We expect the design of encoding/json/v2 to continue to evolve, and developers are encouraged to try out the new API and provide feedback on the proposal issue.

The experimental garbage collector is now available for testing. It's designed to improve performance by better locality and CPU scalability, especially for marking and scanning small objects.

Benchmark results show a potential reduction in garbage collection overhead of 10-40% in real-world programs that heavily use the garbage collector. This is a significant improvement that could make a big difference in the performance of your application.

To enable the new garbage collector, you can set GOEXPERIMENT=greenteagc at build time. This will allow you to test the new design and provide feedback to the developers.

The design is expected to continue evolving and improving, and the developers are encouraging Go developers to try it out and report back their experiences.

On a similar theme: Golang Design