Go Release and Support Timeline - Release History, the Release Policy, and the Go 1 Compatibility Promise
First Published:
Last Updated:
The end of Go support is defined by a rule, not a specific date. The end date for Go 1.N is determined by the release date of Go 1.(N+2). As of the verification date of October 2, 2026, both Go 1.26 and Go 1.27 are still supported. Support for Go 1.26 will end on the release date of Go 1.28, although the release date for Go 1.28 is not listed in the go.dev documents this article checked.
This article provides a timeline of key milestones from the initial release in 2009 through Go 1.27, listing the release date and the end of support for each version from Go 1.8 through Go 1.27. It also details when the support rules were established, how they have evolved, and how the Go 1 compatibility promise supports version updates. The end dates in the table are not dates found in official Go documentation; rather, they are values that this article derived from the rule and the release dates. All information was verified as of October 2, 2026.
Background and Method of Creating the Go Release and Support Timeline
In Python and Node.js, the end-of-support dates for each version are listed as dates in tables in the official documentation. The same applies to .NET. With Go, users must derive the end-of-support date by referring to established rules and the release date. The purpose of this article is to explain, based only on primary sources, until when the Go version you use will receive fixes, where that information can be found, and what to look for when a specific end date is not explicitly provided.Sources Used in This Article
The entries in this timeline are drawn mainly from the following resources:- Release History — This refers to the release page on go.dev. It contains the release dates for major and minor versions, as well as the Release Policy section. All release dates in the tables come from this page.
- Release Notes for Each Version — These are found on the
go.dev/doc/go1.Npages. Information on what changed in each version is taken from these pages. - Go Security Policy — This document outlines which versions receive security fixes.
- Go Wiki: Go-Release-Cycle — This page details the target schedule for releases.
- Go 1 and the Future of Go Programs; Go Toolchains; Go, Backwards Compatibility, and GODEBUG — These documents describe the compatibility promise and the mechanisms that support it.
- The Go Blog — This blog provides announcements regarding the release of each version, as well as explanations of compatibility and toolchains.
- GitHub's
golang/gorepository — When and in which commit the wording of the support policy on the release page changed was checked against the commits and issues. - Internet Archive — Used to check how the golang.org release page looked at the time. ⚠ This is an archive, not a live primary source.
How the End Dates in This Timeline Were Derived
The first step was to check whether Go states an end date for each version as a date. The release page, Go Security Policy, and the Release Cycle wiki were searched forend of life, end-of-life, EOL, no longer supported, unsupported, and end of support. None of these terms appeared in any of the three. The FAQ and the Go 1 compatibility document also returned no hits. Of these resources, the rules section on the release page, the Go Security Policy's Fixes are prepared for the two most recent major releases, and the Release Cycle wiki's Minor releases to address problems (including security issues) for Go 1.x stop once Go 1.x+2 is released describe how far support extends, but none provides specific dates. Outside the scope of this search, the Go 1.18 release notes state Since the release of Go 1.18 marks the end of support for Go 1.16, all supported versions of Go now understand //go:build lines. This also indicates the end of support by a release rather than by a date. From these results, this article concludes that Go does not state the end of support for each version as a date.The end dates in the table were then derived as follows: The end date for Go 1.N is the release date of the first release of Go 1.(N+2). The release dates are those listed on the release page.
The dates of the final minor releases were not used as end dates. This is because there are instances where the date of the final minor release does not align with the derived end date. For example, go1.19.13 was released on September 6, 2023, after the release of Go 1.21.0.
As of the verification date, the end dates for Go 1.26 and Go 1.27 have not yet been determined. The table names the release that will set each end date.
The How the End Date Is Set Column
The table includes a column labeled How the End Date Is Set. This column indicates how the end date for each version is determined. The values in this column are as follows:Derived— Two major versions newer than this one have already been released. The end date in the table is a value derived from the release date of the second newer major version.Derived, pending Go 1.28— This applies to Go 1.26. Go 1.26 will end on the release date of Go 1.28. As of the verification date, the release date for Go 1.28 was not available in the go.dev documents this article checked.Derived, pending Go 1.29— This applies to Go 1.27. Go 1.27 will end on the release date of Go 1.29.
The .NET Release and Support Timeline in this series also uses the same column. The end dates for .NET versions are currently calculated according to the rule of 12 months after the release of the next LTS version. However, Microsoft publicly announces the calculated end date before that date arrives. Go documentation specifies the rule but does not list specific end dates for each version. Therefore, the end date for a Go version is not determined until two newer versions are actually released.
What This Article Leaves to Other Articles
This article does not provide detailed explanations of new features in each version. The entries in the timeline simply describe the major changes for each version. It also does not recommend which version to choose. The lifecycle dates for the AWS Lambda Go runtime and the AWS SDK for Go are in AWS End-of-Support and EOL Reference and AWS History and Timeline regarding AWS Lambda. The standardization process for ML-KEM and ML-DSA is covered in Post-Quantum Cryptography Standardization Timeline and Migration on AWS. The versions and lifecycles of other languages are covered in Java Version and LTS Timeline, Python Version Support and EOL Timeline, and Node.js Release and EOL Timeline.Go Release and Support Historical Timeline (Updates from November 10, 2009)
The following five tables represent the core timeline. Each table has the following columns. All references were obtained on 2026-10-02.- Date — For releases, this indicates the date on the release page. For changes to the wording of the support policy, this indicates the date of the commit in the
golang/gorepository. For issues, this is the creation date; for announcements, this is the publication date. - Area — This indicates the type of event. It will be one of the following:
Project,Release,Minor release,Support policy, orCompatibility. - What Happened — This describes the event that occurred.
- Source — This provides the documentation that supports the information in the row.
Index:
- 2009–2012 - The period when Go became an open-source project and Go 1 was released.
- 2013–2017 - The period when the compiler came to be written in Go, and when the support policy was first documented, transitioning to the current wording.
- 2018–2021 - The period when modules were introduced and became the default.
- 2022–2023 - The period when generics were introduced, and when the version notation, GODEBUG, and toolchain mechanisms changed with Go 1.21.
- 2024–2026 - The period when Go 1.22 through Go 1.27 were released.
* You can sort the table by clicking on the column name.
2009–2012 — The Open Source Release and Go 1
During this period, Go was released, and the first stable version, Go 1, was launched.| Date | Area | What Happened | Source |
|---|---|---|---|
| 2009-11-10 | Project | Go became a public open source project. The Go FAQ states Go became a public open source project on November 10, 2009. | Frequently Asked Questions (FAQ) |
| 2012-03-28 | Release | Go 1 was released. The announcement described Go 1 as the release that defines the language and core libraries to provide a stable foundation, and as the first release available in supported binary distributions. The announcement also pointed to the Go 1 compatibility document. | Go version 1 is released / Release History |
2013–2017 — A Self-Hosted Toolchain and the First Written Support Policy
During this period, the compiler and runtime were written in Go. A support policy was first documented on the release page and was changed to the current wording a little over a year later.| Date | Area | What Happened | Source |
|---|---|---|---|
| 2015-08-19 | Release | Go 1.5 was released. The release notes stated that the compiler and runtime were now written entirely in Go, with only minor exceptions for assembly code, and that C was no longer involved in the implementation. | Go 1.5 Release Notes |
| 2015-09-29 | Support policy | An issue was created to formalize the support policy. The issue stated that support would generally not be provided for versions older than the previous stable release. With Go 1.5 as the latest version, only security issues would be addressed for the 1.4.x series. Furthermore, the issue noted that the policy was not yet formally documented. | Issue #12790 (golang/go) |
| 2016-01-06 | Support policy | The support policy was first documented on the release page. The wording was Each major Go release obsoletes and ends support for the previous one. As an exception, any critical security issues would be addressed in both the latest version and the immediately preceding version. | Commit fc1793d (golang/go) |
| 2016-08-15 | Release | Go 1.7 was released. The Release Cycle wiki says that a version of the current release schedule, with a shorter development window, was first adopted for Go 1.7. | Release History / Go Wiki: Go-Release-Cycle |
| 2017-02-13 | Support policy | An issue was created proposing to extend release support to two release cycles. The issue noted that when macOS Sierra was released and Go 1.6 stopped working, Go 1.7 was already available, and under the existing policy, there was no reason to release a 1.6.x version. | Issue #19069 (golang/go) |
| 2017-03-02 | Support policy | The support policy was updated to the current wording. The commit stated Each major Go release is supported until there are two newer major releases. As an example, it stated that Go 1.8 would be supported until Go 1.10 is released. The golang.org release page, archived on the Internet Archive, showed the older wording in the copy dated 2017-08-07, while the copy dated 2017-08-25 showed the newer wording. | Commit 86abfbb (golang/go) / Internet Archive (2017-08-07) / Internet Archive (2017-08-25) |
2018–2021 — Modules Replace GOPATH as the Default
During this period, modules were introduced and became the default in Go 1.16. The method of installing commands usinggo get was deprecated.| Date | Area | What Happened | Source |
|---|---|---|---|
| 2018-04-16 | Support policy | The example of the support policy was updated to reflect past versions. The commit noted that using past versions would help avoid confusion regarding current and future releases, and the example was changed to Go 1.5 was supported until the Go 1.7 release. The sentence stating the rule did not change. | Commit 7b7affa (golang/go) |
| 2018-08-24 | Release | Go 1.11 was released. It included preliminary support for modules, a new concept. The release notes stated that using modules allowed developers to work outside of the GOPATH. | Go 1.11 Release Notes |
| 2019-09-03 | Release | Go 1.13 was released. By default, the go command began using Google's module mirror and checksum database to download and verify modules. | Go 1.13 Release Notes / Module Mirror and Checksum Database Launched |
| 2021-02-16 | Release | Go 1.16 was released. Module-aware mode became the default, regardless of whether a go.mod file was present. The default value for the GO111MODULE environment variable was set to on. | Go 1.16 Release Notes |
| 2021-08-16 | Release | Go 1.17 was released. Installing commands outside of the main module using go get now produces a deprecation warning. The release notes recommend using go install cmd@version instead. | Go 1.17 Release Notes |
2022–2023 — Generics, Go 1.21, and the toolchain Line
During the 2022–2023 period, generics were introduced. Go 1.21 brought changes to version notation, along with enhanced compatibility and toolchain functionality. Under the rule, support for Go 1.19 ended on the release date of Go 1.21.0, but go1.19.13 was released after that.| Date | Area | What Happened | Source |
|---|---|---|---|
| 2022-03-15 | Release | Go 1.18 was released. This version included generics, following the proposal for Type Parameters. The release notes stated that while this was a significant language change, full backward compatibility was maintained. In module-aware mode, go get no longer builds or installs packages. Under the release policy, support for Go 1.16 ended on this date. | Go 1.18 Release Notes |
| 2023-08-08 | Release | Go 1.21.0 was released. The first release of each version is now numbered 1.N.0. The ability to modify default behavior using the GODEBUG environment variable was formalized. The go line in go.mod became a strict minimum requirement, and a toolchain line was added. Under the release policy, support for Go 1.19 ended on this date. | Go 1.21 Release Notes / Release History |
| 2023-08-14 | Compatibility | It was stated that there would not be a Go 2 that breaks programs written for Go 1. The Go Blog post Backward Compatibility, Go 1.21, and Go 2 stated There will not be a Go 2 that breaks Go 1 programs. On the same day, Forward Compatibility and Toolchain Management in Go 1.21 provided details on toolchain management. | Backward Compatibility, Go 1.21, and Go 2 / Forward Compatibility and Toolchain Management in Go 1.21 |
| 2023-09-06 | Minor release | go1.19.13 was released. This follows the release of Go 1.21.0 on August 8, 2023. The release page lists fixes to the go command and the crypto/tls and net/http packages. The Go1.19.13 milestone on the issue tracker includes the entry: cmd/go: extended forwards compatibility for Go [1.19 backport]. Among Go 1.8 and later, this is the only minor release that shipped after the second newer release, as far as the release page shows. | Release History / Go1.19.13 milestone (golang/go) |
2024–2026 — Go 1.22 to Go 1.27
During this period, Go versions 1.22 through 1.27 were released approximately every six months. The final minor releases of Go 1.20 and Go 1.25 shipped on the same day as the second newer release.| Date | Area | What Happened | Source |
|---|---|---|---|
| 2024-02-06 | Release | Go 1.22.0 was released. Variables declared by for loops now are created anew with each iteration. In the traditional GOPATH mode (GO111MODULE=off), the go get command is no longer available outside of modules. go1.20.14 was also released on this day. Under the release policy, support for Go 1.20 ended on this date. | Go 1.22 Release Notes / Release History |
| 2024-08-13 | Release | Go 1.23.0 was released. for-range loops now accept a function as an iterator. Under the release policy, support for Go 1.21 ended on this date. | Go 1.23 Release Notes |
| 2025-02-11 | Release | Go 1.24.0 was released. Full support was added for generic type aliases. The crypto/mlkem package, which implements ML-KEM, was included, and the post-quantum hybrid key exchange X25519MLKEM768 became available in crypto/tls. It is enabled by default when Config.CurvePreferences is nil. Support was also added to aid in compliance with FIPS 140-3, including Go Cryptographic Module v1.0.0. Under the release policy, support for Go 1.22 ended on this date. | Go 1.24 Release Notes / FIPS 140-3 Compliance |
| 2025-08-12 | Release | Go 1.25.0 was released. A new JSON implementation, encoding/json/v2, was included as an experimental feature, accessible only when GOEXPERIMENT=jsonv2 is set at build time. Under the release policy, support for Go 1.23 ended on this date. | Go 1.25 Release Notes |
| 2026-02-10 | Release | Go 1.26.0 was released. The built-in function new now accepts expressions as operands. The Green Tea garbage collector, previously an experimental feature in Go 1.25, is now enabled by default. Under the release policy, support for Go 1.24 ended on this date. | Go 1.26 Release Notes |
| 2026-08-19 | Release | Go 1.27.0 was released. This release includes generic methods, allowing method declarations to define their own type parameters. The encoding/json/v2 and encoding/json/jsontext packages are now available, and the encoding/json package now operates on top of the v2 implementation. The release notes state that support for the v1 API will continue, and migration is not required. If issues arise with the new implementation, the original v1 implementation can be used by setting GOEXPERIMENT=nojsonv2 at build time; however, this setting is likely to be removed in future releases. A new package, crypto/mldsa, was added, implementing the post-quantum signature scheme ML-DSA. On the same day, go1.25.14 was also released. Under the release policy, support for Go 1.25 ended on this date. | Go 1.27 Release Notes / Release History |
| 2026-09-01 | Minor release | go1.27.1 and go1.26.8 were released. As of the verification date of 2026-10-02, these are the latest minor releases of the two supported Go versions. | Release History |
Current Overview of Go Releases, the Release Policy, and Support
This section summarizes the Go support policy and the status of each release as of the verification date of October 2, 2026. The "Status" column in the table reflects the status as of that verification date. With the release of Go 1.28, support for Go 1.26 will end.The Release Policy: Supported Until Two Newer Major Releases
The Release Policy section on the release page states, as of the verification date:Each major Go release is 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. We fix critical problems, including critical security problems, in supported releases as needed by issuing minor revisions (for example, Go 1.6.1, Go 1.6.2, and so on).This policy defines the support period based on the number of subsequent major releases, rather than in months or dates. The Go Security Policy also specifies the scope of security fixes, stating
Fixes are prepared for the two most recent major releases and the head/master revision. The Go Toolchains documentation explains how the go command selects a supported toolchain when switching to a newer one. Besides the latest release candidate of an unreleased version, when one exists, the candidates include the two most recent language releases, each with its latest patch version. The documentation states These are the supported Go releases according to Go’s release policy.Major releases ship every six months. The Release Cycle wiki states
Go is released every six months. and sets the publication target for the second week of August and February. Under this schedule, each release is supported for approximately one year. However, this one-year timeframe is an estimate derived from the policy and schedule; it is not explicitly stated as a period in Go's documentation.The wording of the support policy has changed as follows, as far as the commits in the
golang/go repository show.| Date | Wording of the Release Policy | Source |
|---|---|---|
| 2016-01-06 | Each major Go release obsoletes and ends support for the previous one. As an exception, critical security problems are also fixed in the previous release. | Commit fc1793d (golang/go) |
| 2017-03-02 | Each major Go release is supported until there are two newer major releases. An example of this was the pairing of Go 1.8 and Go 1.10, and Go 1.9 and Go 1.11. | Commit 86abfbb (golang/go) |
| 2018-04-16 | The wording of the rule remains the same. The examples have been updated to reflect past versions: Go 1.5 and Go 1.7, and Go 1.6 and Go 1.8. | Commit 7b7affa (golang/go) |
Even under the 2016 wording, security fixes were released for the previous release. For example, go1.6.4 was released on December 1, 2016, after the release of Go 1.7, and included two security fixes. With the 2017 change, the wording extended fixes for critical problems, not only security problems, to two releases. Issue #19069, which prompted this change, cited the case where Go 1.6 stopped functioning on macOS Sierra. The dates in the table represent the commit dates. On the golang.org release pages, archived on the Internet Archive, the new wording first appears in the copy archived on August 25, 2017.
Deriving the End of Support for Each Version
The process for deriving the end-of-support date for each version is as follows:- Take the major release two versions newer than Go 1.N, namely Go 1.(N+2).
- On the release page, identify the release date of the first release of Go 1.(N+2). Up to and including Go 1.20, the first release is designated as
go1.N; from Go 1.21 onwards, it is designated asgo1.N.0. - Consider that date as the end-of-support date for Go 1.N.
The following figure and table show the end of support derived using this process. The figure depicts versions from Go 1.19 to Go 1.27. The table lists Go 1.8 to Go 1.27, the versions covered by the current wording of the rule. The commit of 2017-03-02 uses Go 1.8 as its example.
| Version | GA | Supported Until | How the End Date Is Set | Latest Minor Release (as of October 2, 2026) | Status (as of October 2, 2026) |
|---|---|---|---|---|---|
| Go 1.27 | 2026-08-19 | When Go 1.29 is released | Derived, pending Go 1.29 | go1.27.1 (2026-09-01) | Supported |
| Go 1.26 | 2026-02-10 | When Go 1.28 is released | Derived, pending Go 1.28 | go1.26.8 (2026-09-01) | Supported |
| Go 1.25 | 2025-08-12 | 2026-08-19 (Go 1.27.0) | Derived | go1.25.14 (2026-08-19) | Out of support |
| Go 1.24 | 2025-02-11 | 2026-02-10 (Go 1.26.0) | Derived | go1.24.13 (2026-02-04) | Out of support |
| Go 1.23 | 2024-08-13 | 2025-08-12 (Go 1.25.0) | Derived | go1.23.12 (2025-08-06) | Out of support |
| Go 1.22 | 2024-02-06 | 2025-02-11 (Go 1.24.0) | Derived | go1.22.12 (2025-02-04) | Out of support |
| Go 1.21 | 2023-08-08 | 2024-08-13 (Go 1.23.0) | Derived | go1.21.13 (2024-08-06) | Out of support |
| Go 1.20 | 2023-02-01 | 2024-02-06 (Go 1.22.0) | Derived | go1.20.14 (2024-02-06) | Out of support |
| Go 1.19 | 2022-08-02 | 2023-08-08 (Go 1.21.0) | Derived | go1.19.13 (2023-09-06) | Out of support |
| Go 1.18 | 2022-03-15 | 2023-02-01 (Go 1.20) | Derived | go1.18.10 (2023-01-10) | Out of support |
| Go 1.17 | 2021-08-16 | 2022-08-02 (Go 1.19) | Derived | go1.17.13 (2022-08-01) | Out of support |
| Go 1.16 | 2021-02-16 | 2022-03-15 (Go 1.18) | Derived | go1.16.15 (2022-03-03) | Out of support |
| Go 1.15 | 2020-08-11 | 2021-08-16 (Go 1.17) | Derived | go1.15.15 (2021-08-05) | Out of support |
| Go 1.14 | 2020-02-25 | 2021-02-16 (Go 1.16) | Derived | go1.14.15 (2021-02-04) | Out of support |
| Go 1.13 | 2019-09-03 | 2020-08-11 (Go 1.15) | Derived | go1.13.15 (2020-08-06) | Out of support |
| Go 1.12 | 2019-02-25 | 2020-02-25 (Go 1.14) | Derived | go1.12.17 (2020-02-12) | Out of support |
| Go 1.11 | 2018-08-24 | 2019-09-03 (Go 1.13) | Derived | go1.11.13 (2019-08-13) | Out of support |
| Go 1.10 | 2018-02-16 | 2019-02-25 (Go 1.12) | Derived | go1.10.8 (2019-01-23) | Out of support |
| Go 1.9 | 2017-08-24 | 2018-08-24 (Go 1.11) | Derived | go1.9.7 (2018-06-05) | Out of support |
| Go 1.8 | 2017-02-16 | 2018-02-16 (Go 1.10) | Derived | go1.8.7 (2018-02-07) | Out of support |
Notes on the table:
- The "Supported Until" date is a derived value — It is not a date that Go's documentation gives as the end date of a version. The text in parentheses is the release that shipped on that day.
- go1.19.13 — The final minor release of Go 1.19, go1.19.13, shipped on 2023-09-06, which is after the "Supported Until" date of 2023-08-08. Therefore, the date of the final minor release cannot be used as the "Supported Until" date.
- The final minor release shipped on the same day — go1.20.14 shipped on 2024-02-06, the same day as Go 1.22.0, and go1.25.14 shipped on 2026-08-19, the same day as Go 1.27.0. The final minor releases of other versions shipped before their "Supported Until" dates.
- Go 1.26 and Go 1.27 — As of the verification date, the release dates for Go 1.28 and Go 1.29 are not listed on the release page, the Release Cycle wiki, or the release notes page for Go 1.28. The Release Cycle wiki states that releases are targeted for the second week of February and August, with the disclaimer
All dates are subject to change based on the year’s holiday timings.Actual release dates have varied around the target week. According to the wiki's week numbering system, Go 1.21.0 and Go 1.22.0 shipped in the first week, and Go 1.27.0 shipped in the third week. While go.dev has a release notes page for Go 1.28, the content on the page, as of the verification date, simply statesNo next release note fragments available. - Version Notation — The Go Toolchains documentation states
go1.21rc1 and go1.21.0 are toolchain names; go1.21 and go1.22 are not (the initial releases are go1.21.0 and go1.22.0), but go1.20 and go1.19 are.The parentheses next to the "Supported Until" dates in the table are also formatted according to this notation.
The Go 1 Compatibility Promise, GODEBUG, and the toolchain Line
Only the two most recent versions will continue to receive support. Under the rule and the schedule, continuing to receive fixes means upgrading to a newer version roughly once a year at least. The Go 1 compatibility promise is what supports programs continuing to run after such upgrades.Go 1 and the Future of Go Programs states:It is intended that programs written to the Go 1 specification will continue to compile and run correctly, unchanged, over the lifetime of that specification.The same document states
Compatibility is at the source level. and clarifies that binary compatibility between versions is not guaranteed for compiled packages. The Go Blog post of 2023-08-14, Backward Compatibility, Go 1.21, and Go 2, states There will not be a Go 2 that breaks Go 1 programs.Starting with Go 1.21, two lines in
go.mod and two settings support this promise.
goline — This specifies the minimum required version of Go necessary to use the module. Starting with Go 1.21, it is treated as a strict minimum requirement.- GODEBUG — This setting controls behavior changes that, while not technically breaking changes according to the compatibility rules, could potentially break existing programs. The default value is aligned with the version specified in the
go.mod(orgo.workin a workspace) of the main module being built. For example, theGo, Backwards Compatibility, and GODEBUGdocument explains that even when using the Go 1.21 toolchain, if thego.modfile statesgo 1.20, the default value ofpanicnilwill remainpanicnil=1, consistent with Go 1.20. toolchainline — This recommends the toolchain to use with the module. It can specify a version newer than thegoline.GOTOOLCHAIN— This is an environment setting that determines the toolchain to use. The default value isauto. If thegoline or thetoolchainline specifies a version newer than the toolchain currently on your system, thegocommand will search for that version in your PATH or download and execute it.
The release notes for Go 1.21 describe the purpose of this mechanism as follows:
With this compatibility support, the latest Go toolchain should always be the best, most secure, implementation of an older version of Go.GODEBUG settings also have rules regarding lifetime.
Go, Backwards Compatibility, and GODEBUG states GODEBUG settings added for compatibility will be maintained for a minimum of two years (four Go releases). In Go 1.27, seven settings, including asynctimerchan, were removed. According to the Go 1.27 release notes, from Go 1.27 onwards, if a removed setting appears in go.mod or //go:debug, the go command will accept it as long as the last default value before its removal is specified. If an outdated value is present, the go command will fail.Go Support on AWS
The AWS Lambda page for Go states that Go doesn't require a dedicated language runtime because it's natively compiled into executable binaries, and that you should use OS-only runtimes (theprovided runtime family). The managed Go runtime for Lambda (identified as go1.x) is deprecated. The same page lists provided.al2023 or provided.al2 as the runtimes to migrate to. However, the Lambda runtime table lists a deprecation date of 2026-07-31 for provided.al2, which has already passed. According to the Lambda runtimes page, go1.x is deprecated as of 2024-01-08, and provided.al2023 is scheduled for deprecation on 2029-06-30.AWS SDK for Go determines which versions of Go it supports based on Go's release policy. An announcement on the AWS Developer Tools Blog, dated 2023-05-26, stated that from 2023-10-31, both v1 and v2 of the AWS SDK for Go would follow Go's release policy, supporting each major version of Go for an additional six months after Go's own support for that version ends. The table in the announcement lists when Go's support for each version ends, with the note
These dates are speculative based on previous Go release cadence. Go's documentation does not give end dates as dates, and AWS also projects these dates from the rule and the schedule.Following the deprecation of the Lambda Go runtime, the dates for when function creation and updates will cease, along with the end-of-support date for AWS SDK for Go v1 (July 31, 2025), are detailed in AWS End-of-Support and EOL Reference. Information on the transition of the Lambda runtime can be found in AWS History and Timeline regarding AWS Lambda, and a list of Lambda articles is available at AWS Lambda Master Index. The underlying Amazon Linux 2023 foundation for
provided.al2023 is discussed in Amazon Linux History and Timeline. The AWS Credential Provider Chain Across SDKs and the CLI and Endpoint Resolution in the AWS SDKs and CLI explain how AWS SDK for Go v2 determines credentials and endpoints.Frequently Asked Questions about Go Releases and Support
This section answers common questions regarding Go support, based on the content presented here. The information provided is current as of the verification date of October 2, 2026.How long is each Go version supported?
Each version is supported until two newer major releases ship. The Release Policy section on the release page statesEach major Go release is supported until there are two newer major releases. Since major releases ship roughly every six months, each version is supported for approximately one year. However, this one-year timeframe is an estimate derived from the rule and the release schedule and is not explicitly stated as a duration in Go's official documentation.When does support for Go 1.26 and Go 1.27 end?
Support for Go 1.26 ends on the date that Go 1.28 is released, and support for Go 1.27 ends on the date that Go 1.29 is released. As of the verification date, the release dates for Go 1.28 and Go 1.29 are not listed on the release page, the Release Cycle wiki, or the release notes page for Go 1.28. While the Release Cycle wiki states that releases are targeted for the second weeks of February and August, it also notes that these dates are subject to change, and actual release dates have varied around the target weeks.Does Go publish end-of-life dates for its versions?
Go does not state the end of support for each version as a date. None of the release page, the Go Security Policy, and the Release Cycle wiki lists an end date for any version, and none of them uses the termsend of life or EOL. What Go states is the rule that each version is supported until two newer major releases ship. The end dates in this article's table are derived from this rule and the release dates on the release page.Is the date of a version's last minor release its end-of-support date?
It's not necessarily the case. go1.19.13 was released on September 6, 2023, after August 8, 2023 (the release date of Go 1.21.0), which is Go 1.19's end date under the rule. go1.20.14 and go1.25.14 were released on the same day as the second newer release. For other versions, the last minor release shipped before the end-of-support date. For example, for Go 1.21 through Go 1.24, the last minor release shipped six to seven days before the end-of-support date. This article takes the end-of-support date to be the release date of the second newer release, rather than the date of the last minor release.What do the go and toolchain lines in go.mod control?
Thego line in a go.mod file specifies the minimum Go version required to use that module, and as of Go 1.21, it is treated as a strict requirement. The default value for GODEBUG is also aligned with the version specified in the go line. The toolchain line indicates the toolchain that the module recommends using. With GOTOOLCHAIN at its default value, auto, if either the go or toolchain line specifies a version newer than the currently installed toolchain, the go command will search for or download and execute that version of the toolchain.Will there be a Go 2 that breaks Go 1 programs?
No, there will not be a Go 2 that breaks Go 1 programs. The Go Blog post from August 14, 2023, titledBackward Compatibility, Go 1.21, and Go 2, states There will not be a Go 2 that breaks Go 1 programs. The Go 1 compatibility document states that programs written according to the Go 1 specification are intended to be compiled and run correctly, without modification, over the lifetime of that specification.Summary
This article outlines key milestones in Go, from its initial release in 2009 through version 1.27, and presents a timeline detailing the release date and the end of support for each major version from 1.8 to 1.27.The end of support for Go is written as a rule. Each major version is supported until two newer major versions are released. Go's documentation does not explicitly state end-of-support dates as specific dates.
The end dates in the table are derived. The end date for Go 1.N is determined by the release date of the first release of Go 1.(N+2). The date of the final minor release may not necessarily coincide with the end-of-support date; for example, go1.19.13 was released after the end-of-support date.
The current policy was established in 2017. First written on January 6, 2016, the policy ended support for the previous release when a new release came out. On March 2, 2017, it changed to the current wording, under which a version is supported until two newer major releases ship.
The compatibility promise supports version updates. The Go 1 compatibility promise, along with the GODEBUG defaults and the
toolchain line introduced in Go 1.21, lets a newer toolchain build code while keeping the behavior of an older version.⚠ Some things will be decided after the verification date. The end dates for Go 1.26 and Go 1.27 will be set on the days Go 1.28 and Go 1.29 are released. As of the verification date, those release dates are not listed in the go.dev documents this article checked. All information presented is current as of October 2, 2026.
This timeline will be updated as Go releases and the Go release policy continue to evolve.
In addition, there are related history-and-timeline articles on this site, so please have a look if you are interested.
- .NET Release and Support Timeline - STS and LTS Releases, the Move to Two-Year STS Support, and End-of-Support Dates
- Java Version and LTS Timeline - Release History, the LTS Model, and Support Across Distributions
- Python Version Support and EOL Timeline - Release Schedule, Support Policy, and End-of-Life Dates
- Node.js Release and EOL Timeline - LTS Schedule, Active LTS and Maintenance, and End-of-Life Dates
- AWS End-of-Support and EOL Reference - Lambda, EKS, RDS and Aurora, ElastiCache, and OpenSearch Service
References:
- Release History
- Go Security Policy
- Go Wiki: Go-Release-Cycle
- Go 1 and the Future of Go Programs
- Go Toolchains
- Go, Backwards Compatibility, and GODEBUG
- Go 1.21 Release Notes
- Go 1.27 Release Notes
- Backward Compatibility, Go 1.21, and Go 2
- Commit 86abfbb: doc/devel: update release.html for new support policy (golang/go)
- Building Lambda functions with Go (AWS Lambda Developer Guide)
- Lambda runtimes (AWS Lambda Developer Guide)
- AWS SDK for Go Aligns with Go Release Policy on Supported Runtimes
References:
Tech Blog with curated related content
Written by Hidekazu Konishi