Histórico de Lançamentos do Go

Versões de Manutenção:

go1.25, primeiro lançamento: 2025-08-12, última atualização: go1.25.0 (2025-08-12)
go1.24, primeiro lançamento: 2025-02-11, última atualização: go1.24.6 (2024-08-06)

Histórico de lançamentos oficial da linguagem Go: Release History - The Go Programming Language

A equipe oficial do Go usa versionamento semântico para identificação de versão, no formato vversão principal.versão secundária.versão de correção (veja Semantic Versioning). Atualizações de versão principal significam que ocorreram Breaking Changes, ou seja, atualizações incompatíveis com versões anteriores. Atualizações de versão secundária significam que novos recursos foram adicionados mantendo a compatibilidade com versões anteriores. Atualizações de versão de correção significam que problemas foram corrigidos mantendo a compatibilidade com versões anteriores.

A equipe do Go lança uma versão secundária a cada seis meses, e apenas as duas versões secundárias mais recentes são mantidas a longo prazo, com um período de manutenção de seis meses. Dado que cada atualização do Go mantém uma compatibilidade bastante alta, é recomendado atualizar o Go para a versão mais recente após a estabilização da nova versão.

O Go 2.0 teve seu rascunho proposto pela última vez em 19 de novembro de 2018, quando ainda estava na versão go1.13. Cinco anos depois, a versão iterou para go1.21, e várias ideias do Go 2.0 foram incorporadas ao Go 1.0 através de atualizações incrementais. Um dos fundadores também indicou claramente que pode não haver um Go 2.0 no futuro, e o Go continuará se esforçando para manter a compatibilidade com versões anteriores (veja Go 1 and the Future of Go Programs).

Dica

Esta página é apenas uma transcrição simples do registro oficial e não é atualizada regularmente. Para obter as últimas notícias, vá para o site oficial.

1.25

Primeiro lançamento: 2025-08-12

Última atualização: go1.25.0 (2025-08-12)

O registro de atualizações detalhado da versão go1.25 pode ser encontrado em Go 1.25 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.25 - Release Patch.

Nível de Linguagem

Removido o conceito de tipos centrais (core types) em genéricos, veja o post oficial do blog Goodbye core types

Biblioteca Padrão

Adicionado test/synctest para testar código concorrente
Adicionada biblioteca experimental encoding/json/v2, contendo:
- encoding/json/v2, velocidade de desserialização 2-10 vezes maior que v1, benchmark em go-json-experiment/jsonbench
- encoding/json/jsontext, fornece capacidade de interação de baixo nível com strings JSON

Ferramentas

Versões futuras do Go incluirão algumas ferramentas binárias pré-compiladas
go mod adicionou diretiva ignore para especificar pastas que o comando go deve ignorar
go doc -http pode iniciar um servidor HTTP local para visualizar documentação de código
go vet, adicionados analisadores waitgroup e hostport
Quando a linha de comando do go atualiza a versão do go em go.mod ou go.work, não adiciona mais a versão da ferramenta go especificada

Tempo de Execução

GOMAXPROCS perceberá o limite de CPU do contêiner em ambientes de contêiner
Novo GC experimental greenteagc, a unidade básica de agendamento do GC mudou de objeto para memory span

Quando um panic não é capturado, não imprime mais repetidamente

panic: PANIC [recovered]
  panic: PANIC

muda para

panic: PANIC [recovered, repanicked]

Adicionado runtime/trace.FlightRecorder, capaz de capturar continuamente informações de execução em tempo real de forma mais leve

Compilador

Corrigido bug de verificação tardia de ponteiro nulo da versão 1.21 (adiado para após a verificação de erro). O seguinte código obviamente problemático poderia executar normalmente antes da versão 1.25

package main

import "os"

func main() {
	f, err := os.Open("nonExistentFile")
	name := f.Name()
	if err != nil {
		println("should panic") // Antes de 1.25 imprimiria esta linha
		return
	}
	println(name)
}

O compilador reservará mais memória de backup para slices na pilha para melhorar o desempenho de uso
Suporte para gerar informações de depuração DWARF5

1.24

Primeiro lançamento: 2025-02-11

Última atualização: go1.24.6 (2025-08-06)

O registro de atualizações detalhado da versão go1.24 pode ser encontrado em Go 1.24 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.24 - Release Patch.

Nível de Linguagem

Alias de tipo genérico, permite criar aliases para tipos genéricos, o que é muito útil ao referenciar tipos genéricos definidos por terceiros, por exemplo
go
```
import (
    "other"
)

type MyQuque[T any] = other.Queue[T]
```

Biblioteca Padrão

Adicionado pacote weak: fornece ponteiros fracos (Weak Pointers), permitindo que objetos sejam referenciados sem aumentar a contagem de referências, evitando vazamentos de memória causados por cache. É necessário verificar se o ponteiro é nil antes de usar
Restrições de acesso ao sistema de arquivos: introduzido tipo os.Root, limitando operações de arquivo a diretórios específicos, aumentando a segurança
Suporte a criptografia e hash: adicionados pacotes crypto/mlkem, crypto/hkdf, crypto/pbkdf2 e crypto/sha3, otimizando o desempenho de algoritmos de criptografia existentes
Adicionada função de benchmark testing.B.Loop para melhor teste de loops
encoding/json: adicionada tag omitzero, suportando filtragem de valores zero baseada no método IsZero()
strings e bytes: adicionadas funções iteradoras (como Lines, SplitSeq, FieldsSeq)

Tempo de Execução

Mapa interno reformulado baseado em Swiss Tables, acesso a mapas grandes melhorou 30%, velocidade de iteração melhorou 10%-60%
sync.Map agora usa trie hash concorrente (hash-trie) para otimizar desempenho, especialmente em situações de escrita concorrente
Mutexes internos do tempo de execução usam nova implementação spinbit, reduzindo competição de lock e melhorando desempenho em cenários de alta concorrência
Otimizada estratégia de alocação de pequenos objetos, reduzindo fragmentação de memória e tempo de pausa do GC
Adicionado runtime.AddCleanup para substituir runtime.SetFinalizer, suportando registro de múltiplas funções de limpeza para objetos e execução sequencial em goroutines independentes

Cgo

Suporte para anotações #cgo noescape e #cgo nocallback, declarando que funções C não escapam memória e não retornam chamadas para Go, melhorando desempenho do tempo de execução
Cgo agora recusará compilar chamadas para funções C com múltiplas declarações incompatíveis, detectando estritamente declarações de funções C incompatíveis entre arquivos (como void f(int) e void f(double)), evitando geração de sequências de chamada erradas

Ferramentas

Gerenciamento de dependências de ferramentas de módulo: rastreia dependências de ferramentas através da diretiva tool do go.mod, substituindo o esquema de importação vazio tradicional tools.go
Saída estruturada: go build e go test suportam flag -json, produzindo saída JSON de resultados de build e teste
Otimização de compilação e link: compilador gera código com maior eficiência, linkador gera GNU Build ID por padrão (plataforma ELF) e UUID (macOS)
Proibido contornar restrições de definição de método para tipos gerados por CGO através de aliases
go build incorpora automaticamente informações de sistema de controle de versão no arquivo binário (suporta desativar com -buildvcs=false)
Variável de ambiente GOAUTH suporta autenticação de módulos privados.
go.mod suporta diretiva tool para gerenciar dependências executáveis, substituindo importações vazias tools.go
Adicionados novo parâmetro go get -tool e comando go install tool para gerenciar dependências de ferramentas de módulo
Cache de build suporta cache binário para go run e go tool
objdump suporta desmontagem para LoongArch, RISC-V, S390X
vet adicionou analisador tests (detecta erros de assinatura de funções de teste)

Compatibilidade de Plataforma

macOS: Go 1.24 será a última versão a suportar macOS 11 Big Sur, Go 1.25 exigirá macOS 12+
Windows: arquitetura ARM de 32 bits marcada como incompleta (GOOS=windows GOARCH=arm), veja issue #70705
Linux: requisito mínimo de versão do kernel atualizado para 3.2
Requer Go 1.22.6+ como ferramenta de bootstrap

Descontinuado

math/rand.Seed() completamente ineficaz, é necessário usar GODEBUG=randseednop=0 para restaurar comportamento antigo.
runtime.GOROOT() marcado como descontinuado, recomendado obter caminho através de go env GOROOT

1.23

Primeiro lançamento: 2024-08-13

Última atualização: go1.23.4 (2024-12-03)

O registro de atualizações detalhado da versão go1.23 pode ser encontrado em Go 1.23 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.23 - Release Patch.

Nível de Linguagem

for range suporta funções iteradoras, para mais detalhes veja Go Wiki: Rangefunc Experiment.

func Upper(s []string) iter.Seq2[int, string] {
  return func(yield func(int, string) bool) {
    for i, s1 := range s {
      if !yield(i, strings.ToUpper(s1)) {
        return
      }
    }
    return
  }
}

func main() {
  sl := []string{"hello", "world", "golang"}
  for i, s := range Upper(sl) {
    fmt.Printf("%d : %s\n", i, s)
  }
}

//0 : HELLO
//1 : WORLD
//2 : GOLANG

Este é um recurso bastante prático, geralmente usado em conjunto com genéricos.

Biblioteca Padrão

Adicionada biblioteca padrão iter, que define e descreve informações detalhadas sobre iteradores
Biblioteca maps adicionou várias funções iteradoras
Biblioteca slices adicionou várias funções iteradoras
Adicionada biblioteca structs, fornecendo capacidade de modificar propriedades de struct, como layout de memória
go
```
type Person struct {
  Name string
  Age  int
  _    structs.HostLayout
}
```
Otimizada implementação da biblioteca padrão time

Linker

Tratamento de abuso de //go:linkname, permitindo temporariamente a existência de algumas APIs frequentemente referenciadas, como runtime.memhash64, runtime.nanotime, etc. Novas referências não serão permitidas após isso.
go
```
//go:linkname gcinit runtime.gcinit
func gcinit()

func main() {
  gcinit()
}
```
Código como este não poderá ser compilado
```
link: main: invalid reference to runtime.gcinit
```

Ferramentas

Adicionado comando go telemetry para gerenciamento de dados de telemetria

1.22

Primeiro lançamento: 2024-02-06

Última atualização: go1.22.6 (lançado em 2024-08-06)

O registro de atualizações detalhado da versão go1.22 pode ser encontrado em Go 1.22 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.22 - Release Patch.

Nível de Linguagem

Resolvido o problema de variáveis de loop na linguagem Go

func main() {
  var wg sync.WaitGroup
  const n = 10
  wg.Add(n)
  for i := 0; i < n; i++ {
    go func() {
      fmt.Println(i)
      wg.Done()
    }()
  }
  wg.Wait()
}

Este código antes de 1.22 imprimiria 10 noves, após 1.22 imprimirá corretamente de 0 a 9.

for range agora suporta iteração sobre tipos numéricos, como segue
go
```
for i := range 10 {
  fmt.Println(i)
}
```

Biblioteca Padrão

Aprimorado o roteamento da biblioteca padrão net/http

database/sql adicionou tipo genérico sql.Null

type Null[T any] struct {
  V     T
  Valid bool
}

Uso como segue

type Person struct {
  Name sql.Null[string]
  Age  sql.Null[int]
}

1.21

Primeiro lançamento: 2023-08-08

Última atualização: go1.21.13 (lançado em 2024-08-06)

O registro de atualizações detalhado da versão go1.21 pode ser encontrado em Go 1.21 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.21 - Release Patch.

Nível de Linguagem

Adicionadas duas funções embutidas min e max para calcular valores máximos e mínimos.
Adicionada função embutida clear para limpar maps e slices
Atualizada ordem de inicialização de package
- Ordena todos os pacotes por caminho de importação
- Repete até que a lista de pacotes esteja vazia
- Encontra o primeiro pacote na lista cujas importações já foram inicializadas
- Inicializa o pacote e o remove da lista
Melhorada e aprimorada a capacidade e precisão da inferência de tipos, principalmente relacionada a genéricos.
Lançada versão de visualização da melhoria de variáveis de loop for range, um problema que aflige desenvolvedores Go por quase uma década, finalmente a equipe oficial vai resolver, para mais detalhes veja: LoopvarExperiment · golang/go Wiki (github.com) e Proposal: Less Error-Prone Loop Variable Scoping (googlesource.com)
Garantido que o valor de retorno de recover não será nil. Se o parâmetro ao chamar panic for nil, outro panic será acionado, retornando *runtime.PanicNilError. Para compatibilidade, definir GODEBUG=panicnil=1 no momento da compilação permite passar nil para panic.

Biblioteca Padrão

Adicionada biblioteca log/slog, fornecendo biblioteca de log estruturado padrão
Adicionada biblioteca testing/slogtest para validar implementações de slog.Handler
Adicionada biblioteca slices, fornecendo uma série de funções genéricas para operar slices.
Adicionada biblioteca maps, fornecendo uma série de funções genéricas para operar maps
Adicionada biblioteca cmp para comparar tipos ordenados.

Outros

go1.21.0 requer pelo menos Windows 10 ou Windows Server 2016 ou superior no sistema Windows, versões anteriores não são mais suportadas.
go1.21.0 requer pelo menos macOS 10.15 Catalina ou versões mais recentes para executar, versões anteriores não são mais suportadas.
Adicionada interface experimental WebAssembly System Interface, o Go continua explorando o WASM.
PGO (Profile-guided optimization), que era experimental na versão 1.20 (veja Profile-guided optimization - The Go Programming Language), é oficialmente habilitado na versão 1.21. Incluir o arquivo default.pgo no pacote main habilitará este recurso, e o desempenho pode melhorar 2%-7% após a ativação.
Ao imprimir pilhas de chamadas de tempo de execução muito profundas, em vez de imprimir apenas os primeiros cem quadros, agora imprime separadamente os primeiros 50 e os últimos 50 quadros.
Otimizado desempenho de chamadas CGO em plataformas Unix, de 1-3 microssegundos para 100-200 nanossegundos.
Na versão 1.21, a velocidade de compilação melhorou quase 6%, principalmente graças ao próprio compilador usando PGO para construir.

1.20

Primeiro lançamento: 2023-02-01

Última atualização: go1.20.14 (lançado em 2024-02-06)

O registro de atualizações detalhado da versão go1.20 pode ser encontrado em Go 1.20 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.20 - Release Patch.

Nível de Linguagem

Ao converter tipo slice para array, antes era necessário desreferenciar ponteiro de array *(*[4byte])(x) para evitar compartilhar o mesmo array subjacente com o slice, agora pode-se escrever diretamente [4]byte(x).
unsafe adicionou funções SliceData, String, StringData para construir e obter slices e valores de string.

Biblioteca Padrão

Adicionada biblioteca crypto/ecdh, fornecendo suporte para ECDH (Elliptic Curve Diffie-Hellman, um método de criptografia assimétrica).
go1.20 expandiu o suporte a empacotamento de error, permitindo que um error empacote múltiplos errors.
Adicionado net/http.ResponseController, fornecendo um método mais claro e fácil de descobrir para adicionar controles por handler.
httputil.ReverseProxy inclui uma nova função Rewrite Hook para substituir o hook Director anterior.

Outros

go1.20 é a última versão a suportar win7, 8, Server2008 e Server2012, versões futuras não fornecerão suporte.
go1.20 é a última versão a suportar macOS 10.13 ou 10.14, versões futuras não fornecerão suporte.
Nas versões 1.18 e 1.19, devido ao surgimento de genéricos, a velocidade de compilação regrediu em comparação com 1.17, go1.20 verá uma melhoria de cerca de 10% na velocidade de compilação.
Lançada versão de visualização do PGO (Profile-guided optimization), uma técnica de otimização de compilador no mundo da computação que pode melhorar o desempenho em tempo de execução.
Em go1.20, o comando go desabilita cgo em sistemas sem ferramentas C.
Suporte para coletar arquivos de cobertura de código do programa, veja Coverage profiling support for integration tests - The Go Programming Language
Melhorias no GC, aumentando estabilidade, reduzindo uso de memória, melhorando desempenho geral de CPU em 2%.

1.19

Primeiro lançamento: 2022-08-02

Última atualização: go1.19.13 (lançado em 2023-09-06)

O registro de atualizações detalhado da versão go1.19 pode ser encontrado em Go 1.19 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.19 - Release Patch.

Mudanças Importantes

Modelo de memória alinhado com c/c++, semelhante a TcMollcate
Pacote sync/atomic agora fornece mais tipos para uso
Suporte para usar a função runtime/debug.SetMemoryLimit para impor limite suave à memória do Go, o que pode melhorar a eficiência de uso de memória em certas situações
O tempo de execução agora selecionará um tamanho apropriado para inicializar o espaço de memória da pilha de goroutines com base no uso médio da pilha de goroutines, evitando assim expansões e reduções frequentes da pilha

1.18

Primeiro lançamento: 2022-03-15

Última atualização: go1.18.10 (lançado em 2023-01-10)

O registro de atualizações detalhado da versão go1.18 pode ser encontrado em Go 1.18 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.18 - Release Patch.

Nível de Linguagem

Atualização importante, suporte a genéricos, interfaces de conjuntos de tipos, restrições de tipo de parâmetro

Outros

Otimizado comportamento de expansão da função append
Adicionado pacote debug/buildinfo, permitindo obter informações de build de programas Go em tempo de execução
gofmt agora pode formatar arquivos de origem de forma concorrente

1.17

Primeiro lançamento: 2021-08-16

Última atualização: go1.17.13 (lançado em 2022-08-01)

O registro de atualizações detalhado da versão go1.17 pode ser encontrado em Go 1.17 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.17 - Release Patch.

Nível de Linguagem

Adicionada função unsafe.Add, suportando aritmética de ponteiros
Adicionada função unsafe.Slice, suportando obtenção de ponteiro para array subjacente de slice
Slices agora podem ser convertidos para tipo de ponteiro de array, []T => *[N]T, desde que o comprimento do array seja menor ou igual ao comprimento do slice

1.16

Primeiro lançamento: 2021-02-16

Última atualização: go1.16.15 (lançado em 2022-03-03)

O registro de atualizações detalhado da versão go1.16 pode ser encontrado em Go 1.16 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.16 - Release Patch.

Mudanças Importantes

Esta versão não teve mudanças importantes de sintaxe, algumas mudanças importantes são as seguintes

Pacote ioutil descontinuado
Suporte para incorporar arquivos estáticos ao programa através da diretiva //go:embed
Adicionado tipo io/fs.Fs, fornecendo melhor abstração para sistemas de arquivos

1.15

Primeiro lançamento: 2020-08-11

Última atualização: go1.15.15 (lançado em 2021-08-05)

O registro de atualizações detalhado da versão go1.15 pode ser encontrado em Go 1.15 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.15 - Release Patch.

Mudanças Importantes

Esta versão não teve mudanças importantes de sintaxe, algumas mudanças importantes são as seguintes

Otimizada eficiência de alocação de pequenos objetos
Adicionado pacote time/tzdata, suportando incorporação de banco de dados de fuso horário ao programa da seguinte forma, pois muitos sistemas não possuem informações de fuso horário localmente.
go
```
import _ "time/tzdata"
```
Feitas melhorias significativas ao linkador do Go, reduzindo seu uso de recursos e aumentando a robustez do código
Em certas situações, permite conversão de unsafe.Pointer para uintptr

1.14

Primeiro lançamento: 2020-02-25

Última atualização: go1.14.15 (lançado em 2021-02-04)

O registro de atualizações detalhado da versão go1.14 pode ser encontrado em Go 1.14 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.14 - Release Patch.

Nível de Linguagem

Suporte para aninhamento de tipos de interface de conjuntos de métodos
go
```
type MyIO interface {
  io.WriteCloser
}
```

Outros

Introduzida otimização de codificação aberta, reduzindo o custo de chamadas defer para quase o mesmo que chamadas nativas
Suporte para preempção assíncrona entre goroutines, loops sem chamadas de função não bloquearão mais permanentemente o agendador

1.13

Primeiro lançamento: 2019-09-03

Última atualização: go1.13.15 (lançado em 2020-08-06)

O registro de atualizações detalhado da versão go1.13 pode ser encontrado em Go 1.13 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.13 - Release Patch.

Nível de Linguagem

Suporte para literais numéricos mais modernos, como
go
```
0b101 // binário
0o10 // octal
0x1B // hexadecimal
```
Suporte para sublinhado para separar números para melhor legibilidade
go
```
10_000
```
O sufixo imaginário i agora pode ser qualquer número binário, octal, hexadecimal ou de ponto flutuante

Outros

Valor padrão de GO111MODULE é auto
Adicionada variável de ambiente GOPRIVATE para suportar fontes de dependências privadas
Adicionada variável de ambiente GOSUMDB
Custo de uso de defer reduzido em 30%
Quando ocorre violação de índice de array, panic agora imprime informações de índice
Go realiza validação de versão semântica ao baixar dependências

1.12

Primeiro lançamento: 2019-02-25

Última atualização: go1.12.17 (lançado em 2020-02-12)

O registro de atualizações detalhado da versão go1.12 pode ser encontrado em Go 1.12 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.12 - Release Patch.

Mudanças Importantes

Esta versão não teve mudanças importantes de sintaxe, algumas mudanças importantes são as seguintes

Melhoria significativa no desempenho de varredura do heap
Tempo de execução libera memória solicitada ao sistema operacional de forma mais agressiva
Comando para baixar dependências do Go agora pode ser usado de forma concorrente e segura

1.11

Primeiro lançamento: 2018-08-24

Última atualização: go1.11.13 (lançado em 2019-08-13)

O registro de atualizações detalhado da versão go1.11 pode ser encontrado em Go 1.11 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.11 - Release Patch.

Mudanças Importantes

Esta versão não teve mudanças importantes de sintaxe, algumas mudanças importantes são as seguintes

GoMod lançado pela primeira vez, o cenário caótico de gerenciamento de dependências anterior está prestes a terminar
Suporte experimental inicial para WASM
Tempo de execução usa layout de heap esparso, não limita mais o tamanho do heap

1.10

Primeiro lançamento: 2018-02-16

Última atualização: go1.10.8 (lançado em 2019-01-23)

O registro de atualizações detalhado da versão go1.10 pode ser encontrado em Go 1.10 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.10 - Release Patch.

Mudanças Importantes

Esta versão não teve mudanças importantes de sintaxe, algumas mudanças importantes são as seguintes

Comando go install agora é usado apenas para instalar e compilar ferramentas de linha de comando, não é mais usado para baixar dependências
Comando go get agora é usado para baixar dependências de código-fonte
Testes do Go agora armazenam em cache resultados de testes e executam automaticamente go vet antes de executar
Redução significativa no atraso causado pelo GC durante atividade

1.9

Primeiro lançamento: 2017-08-24

Última atualização: go1.9.7 (lançado em 2018-06-05)

O registro de atualizações detalhado da versão go1.9 pode ser encontrado em Go 1.9 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.9 - Release Patch.

Nível de Linguagem

Suporte para aliases de tipos

Outros

Suporte para compilação paralela
Adicionado sync.Map seguro para concorrência

1.8

Primeiro lançamento: 2017-02-16

Última atualização: go1.8.7 (lançado em 2018-02-07)

O registro de atualizações detalhado da versão go1.8 pode ser encontrado em Go 1.8 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.8 - Release Patch.

Nível de Linguagem

Quando duas structs são convertidas, diferenças nas tags de struct são ignoradas

func example() {
    type T1 struct {
        X int `json:"foo"`
    }
    type T2 struct {
        X int `json:"bar"`
    }
    var v1 T1
    var v2 T2
    v1 = T1(v2) // agora permitido
}

Outros

Tempo de pausa causado pela coleta de lixo reduzido para até 10 microssegundos, na maioria dos casos abaixo de 100 microssegundos (pode-se ver que quase todas as versões do Go se esforçam para melhorar o GC)
Custo de chamadas defer reduzido em quase metade
Custo de chamadas do Go para C reduzido em quase metade
Otimizada detecção de uso concorrente de maps

1.7

Primeiro lançamento: 2016-08-15

Última atualização: go1.7.6 (lançado em 2017-05-23)

O registro de atualizações detalhado da versão go1.7 pode ser encontrado em Go 1.7 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.7 - Release Patch.

Mudanças Importantes

Adicionado golang.org/x/net/context à biblioteca padrão
Tempo de gc significativamente reduzido em comparação com 1.6
Pacote testing suporta subtestes

1.6

Primeiro lançamento: 2016-02-17

Última atualização: go1.6.4 (lançado em 2016-12-01)

O registro de atualizações detalhado da versão go1.6 pode ser encontrado em Go 1.6 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.6 - Release Patch.

Mudanças Importantes

Esta versão não teve mudanças de sintaxe, abaixo estão as mudanças mais importantes

Detecção de uso concorrente de maps, se for detectado que um map está sendo usado concorrentemente, lançará fatal
Ao ocorrer panic, apenas a pilha de chamadas da goroutine em execução será impressa
Suporte para HTTP/2

1.5

Primeiro lançamento: 2015-08-19

Última atualização: go1.5.4 (lançado em 2016-04-12)

O registro de atualizações detalhado da versão go1.5 pode ser encontrado em Go 1.5 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.5 - Release Patch.

Nível de Linguagem

Ao inicializar chaves de literais de map, permite omitir o tipo do elemento

m := map[Point]string{
    Point{29.935523, 52.891566}:   "Persepolis",
    Point{-25.352594, 131.034361}: "Uluru",
    Point{37.422455, -122.084306}: "Googleplex",
}

// Omitir tipo
m := map[Point]string{
    {29.935523, 52.891566}:   "Persepolis",
    {-25.352594, 131.034361}: "Uluru",
    {37.422455, -122.084306}: "Googleplex",
}

Outros

Tempo de execução e compilador completamente reescritos em Go, não contêm mais nenhum código C
Suporte para coleta de lixo concorrente, reduzindo significativamente o tempo de pausa do programa
Valor padrão de GOMAXPROCS muda para número de núcleos lógicos da máquina
Semântica de pacotes internal pode ser aplicada em qualquer lugar, não mais limitada apenas a pacotes de código-fonte do Go
Suporte experimental para gerenciamento de dependências vendor (finalmente começando a lidar com essa parte de gerenciamento de dependências)

1.4

Primeiro lançamento: 2014-12-10

Última atualização: go1.4.3 (lançado em 2015-09-22)

O registro de atualizações detalhado da versão go1.4 pode ser encontrado em Go 1.4 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.4 - Release Patch.

Nível de Linguagem

Loop for range pode ter um parâmetro de iteração, por exemplo
```
for i := range x {
    ...
}
```
Mas não pode ter nenhum
Ao chamar métodos de tipos de referência dupla, não desreferencia mais automaticamente
go
```
type T int
func (T) M() {}
var x **T

// Não permitido
x.M()
```

Outros

Antes de 1.4, o tempo de execução do Go era escrito em C, agora é totalmente concluído em Go
Suporte para modificar nome do pacote para internal para indicar que todo o conteúdo do pacote é privado e não exportável

1.3

Primeiro lançamento: 2014-06-18

Última atualização: go1.3.3 (lançado em 2014-09-30)

O registro de atualizações detalhado da versão go1.3 pode ser encontrado em Go 1.3 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.3 - Release Patch.

Mudanças Importantes

Esta versão não teve mudanças de sintaxe, algumas mudanças relativamente importantes são as seguintes

Modelo de pilha de goroutines mudou de pilha segmentada para pilha contínua, melhorando o desempenho de expansão da pilha.
Melhorada a precisão de julgamento de ponteiros do coletor de lixo
Em maps de pequena capacidade, a ordem de iteração também se torna imprevisível
Devido a alguns aprimoramentos no tempo de execução, o desempenho dos programas Go desta versão teve um aumento significativo

1.2

Primeiro lançamento: 2013-12-01

Última atualização: go1.2.2 (lançado em 2014-05-05)

O registro de atualizações detalhado da versão go1.2 pode ser encontrado em Go 1.2 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.2 - Release Patch.

Nível de Linguagem

Operar em variáveis com valor nil causará panic
Ao fatiar slices, pode-se usar um terceiro parâmetro para limitar a capacidade do slice sendo dividido para usar slices de forma mais segura
go
```
var array [10]int
slice := array[2:4:4]
```

Outros

Tamanho mínimo de memória da pilha de goroutines aumentado de 4KB para 8KB
Número máximo de threads limitado a 10000
Goroutines de longa execução serão preemptas ao ocorrer chamadas de função (primeira introdução de preempção colaborativa)

1.1

Primeiro lançamento: 2013-05-13

Última atualização: go1.1.2 (lançado em 2013-08-13)

O registro de atualizações detalhado da versão go1.1 pode ser encontrado em Go 1.1 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.1 - Release Patch.

Nível de Linguagem

Dividir um número por 0 causará panic antes, em 1.1 não compila diretamente.
Métodos podem existir como valores.
Introduzido conceito de instruções de terminação, regras de retorno de função mais flexíveis, definição de instruções de terminação - go-sepc.

Desempenho:

Programas Go compilados com ferramentas go1.1 podem ter desempenho melhorado em cerca de 30%-40%

Outros:

Valor máximo de memória do heap em máquinas de 64 bits aumentado para dezenas de GB
Compilação cruzada desabilita cgo por padrão

1.0

Primeiro lançamento: 2012-03-28

O registro de atualizações detalhado da versão go1.0 pode ser encontrado em Go 1.0 Release Notes. Todas as versões de correção lançadas durante seu período de manutenção podem ser encontradas em Go1.0 - Release Patch.

Nível de Linguagem

Em comparação com a versão de visualização, a sintaxe adicionou as seguintes coisas

Adicionada função embutida append para adicionar elementos a slices
Adicionada função embutida close para fechar canais

Semântica composta, ao inicializar elementos de literais de slice, map e struct, pode-se omitir seus tipos, como mostrado abaixo

// Declarar tipo
holiday1 := []Date{
    Date{"Feb", 14},
    Date{"Nov", 11},
    Date{"Dec", 25},
}

// Omitir tipo
holiday2 := []Date{
    {"Feb", 14},
    {"Nov", 11},
    {"Dec", 25},
}

Goroutines usadas em funções init serão iniciadas diretamente, não é mais necessário aguardar que todos os pacotes sejam inicializados.
Adicionado tipo rune, representando um caractere UTF-8
Adicionada interface embutida error, representando tipo de erro
Adicionada função embutida delete para remover pares chave-valor de maps
A ordem de iteração de maps usando for range se torna imprevisível
Suporte para atribuir valores a múltiplas variáveis simultaneamente
```
a := 1
b := 2
a, b = 3, 4
```

Problema de ocultação de variáveis: quando uma função tem valores de retorno nomeados, se algum valor de retorno for ocultado, a instrução return deve conter valores de retorno, caso contrário não compila. Abaixo está um exemplo de erro

func Bug() (i, j, k int) {
    for i = 0; i < 5; i++ {
        for j := 0; j < 5; j++ { // Redeclara j.
            k += i * j
            if k > 100 {
                return // Rejeitado: j está ocultado aqui.
            }
        }
    }
    return // OK: j não está ocultado aqui.
}

Permitido copiar valores de struct com campos privados
Quando structs e slices são compostos de elementos comparáveis, permite que sejam usados como chaves de maps, ao mesmo tempo remove comparabilidade de funções e maps

Além do nível de linguagem, go1.0 teve mudanças muito grandes em relação à versão de visualização na organização de pacotes, biblioteca padrão e linha de comando. Devido ao grande volume de conteúdo, não será detalhado aqui. Interessados podem ir ao site oficial para entender.

pre

Antes do lançamento oficial do go1, todas as versões eram chamadas de versões de visualização. Para essas versões de visualização, a equipe oficial lançava uma versão instantânea semanal. As versões mais importantes incluem

r60 (2011-09-07), especificou que blocos else agora devem ter parênteses
r59 (2011-08-01), projetou novo esquema de tags de struct
r58 (2011-06-29), corrigiu problema de memória não inicializada devido ao abuso de goto, adicionados pacotes gui, exec
r57 (2011-05-03), suporte para sintaxe de atribuição múltipla de variáveis curtas, redesenhados pacotes http, reflect, transformou gotest em um programa Go em vez de script shell
r56 (2011-03-07), primeira versão estável

O desenvolvimento da versão de visualização começou em 09 de dezembro de 2009 e parou após o lançamento oficial do go1 em 28 de março de 2012, durando quase três anos. Versões instantâneas semanais não serão mais registradas após isso. Vá para Pre-Go 1 Release History para obter informações sobre essas versões principais, e vá para Weekly Snapshot History para obter informações sobre todas as versões instantâneas semanais de visualização.

Histórico de Lançamentos do Go ​

1.25 ​

1.24 ​

1.23 ​

1.22 ​

1.21 ​

1.20 ​

1.19 ​

1.18 ​

1.17 ​

1.16 ​

1.15 ​

1.14 ​

1.13 ​

1.12 ​

1.11 ​

1.10 ​

1.9 ​

1.8 ​

1.7 ​

1.6 ​

1.5 ​

1.4 ​

1.3 ​

1.2 ​

1.1 ​

1.0 ​

pre ​

Histórico de Lançamentos do Go

1.25

1.24

1.23

1.22

1.21

1.20

1.19

1.18

1.17

1.16

1.15

1.14

1.13

1.12

1.11

1.10

1.9

1.8

1.7

1.6

1.5

1.4

1.3

1.2

1.1

1.0

pre