O Go 1.26 saiu em 10 de fevereiro de 2026, seguindo o ciclo de releases semestrais da linguagem. Essa versão traz duas mudanças na linguagem, o garbage collector Green Tea como padrão, um go fix completamente reescrito e criptografia pós-quântica habilitada por padrão no TLS.

Se você roda Go em produção, as mudanças de runtime e performance são o que mais importa aqui. Se mantém bases de código grandes, o novo go fix merece atenção.

Duas mudanças na linguagem

A primeira: new() agora aceita expressões, não só tipos. Parece pouco, mas resolve uma dor antiga de quem trabalha com serialização em Go.

Antes, criar um ponteiro para um valor exigia declarar uma variável intermediária ou escrever uma função auxiliar:

func newInt(x int) *int { return &x }

data, err := json.Marshal(&Request{
    URL:      url,
    Attempts: newInt(10),
})

Agora:

data, err := json.Marshal(&Request{
    URL:      url,
    Attempts: new(10),
})

Quem trabalha com protocol buffers ou qualquer API que usa *T para campos opcionais sabe o quanto isso simplifica.

A segunda mudança é mais nichada: tipos genéricos agora podem se referenciar na própria lista de parâmetros de tipo. Isso habilita constraints recursivos que antes não compilavam:

type Adder[A Adder[A]] interface {
    Add(A) A
}

func sum[A Adder[A]](x, y A) A {
    return x.Add(y)
}

Na prática, quem precisa desse padrão já sabe que precisa. A maioria dos projetos não vai notar essa mudança.

Green Tea: o garbage collector que virou padrão

O Green Tea GC estreou como experimental no Go 1.25 e agora é o default. A diferença de performance é concreta: redução de 10 a 40% no overhead do GC em programas reais.

O nome vem da abordagem de escanear blocos contíguos de memória (spans) em vez de percorrer objetos individuais. Isso melhora a localidade de cache e escala melhor em CPUs multi-core.

Em CPUs mais recentes (Intel Ice Lake em diante, AMD Zen 4+), o ganho adicional chega a 10% por conta de instruções vetoriais que o runtime aproveita automaticamente. Somando: em hardware recente, o GC pode ser até 50% mais leve que o anterior.

Se por algum motivo o Green Tea causar problemas, ainda dá para desabilitar com GOEXPERIMENT=nogreenteagc. A equipe do Go planeja remover essa opção no 1.27, então se algo quebrar, reporte agora.

Além do GC, duas outras mudanças de runtime merecem nota:

  • Chamadas cgo ficaram cerca de 30% mais rápidas no overhead base
  • O compilador agora consegue alocar o backing store de slices na stack em mais situações, reduzindo pressão no heap

O go fix renovado

O go fix foi reescrito do zero e agora funciona como o hub de modernização de código Go. Ele usa o mesmo framework de análise do go vet e inclui dezenas de fixers que atualizam código antigo para idiomas e APIs mais recentes.

Para rodar em todo o projeto:

go fix ./...

Para ver o diff antes de aplicar:

go fix -diff ./...

Alguns dos modernizadores incluídos:

  • any transforma interface{} em any
  • minmax substitui cadeias de if por min() e max() (disponíveis desde Go 1.21)
  • rangeint converte for i := 0; i < n; i++ para for range n
  • stringscut troca strings.Index + fatiamento por strings.Cut
  • forvar remove shadowing redundante de variáveis em loops (desnecessário desde Go 1.22)
  • newexpr atualiza funções auxiliares do tipo newInt() para usar o novo new(expr) do 1.26

O sistema usa um algoritmo de merge three-way para reconciliar múltiplas correções no mesmo arquivo. Se duas correções entram em conflito sintático, ele pula a conflitante e avisa.

Um detalhe que achei bem pensado: o go fix respeita a versão declarada no go.mod. Se seu projeto declara go 1.22, ele só sugere correções compatíveis com 1.22. Nada de quebrar build por usar feature de versão mais nova.

Mudanças relevantes na biblioteca padrão

Três mudanças se destacam no dia a dia:

io.ReadAll ficou duas vezes mais rápido e usa 50% menos memória. A implementação anterior alocava buffers intermediários grandes que eram descartados no final. A nova versão cresce de forma mais eficiente e retorna um slice do tamanho exato.

errors.AsType é uma alternativa genérica e type-safe ao errors.As. Em vez de declarar uma variável e passar o ponteiro, você extrai o erro tipado direto:

// Antes
var pathErr *os.PathError
if errors.As(err, &pathErr) {
    fmt.Println(pathErr.Path)
}

// Go 1.26
if pathErr, ok := errors.AsType[*os.PathError](err); ok {
    fmt.Println(pathErr.Path)
}

reflect ganhou métodos iteradores: Type.Fields(), Type.Methods(), Value.Fields(). Quem escreve código que inspeciona structs em runtime vai notar a diferença na legibilidade.

Outras adições que valem conhecer:

  • bytes.Buffer.Peek(n) retorna os próximos n bytes sem avançar o cursor
  • log/slog.NewMultiHandler despacha logs para múltiplos handlers de uma vez
  • net.Dialer ganhou métodos tipados com context: DialTCP, DialUDP, DialIP, DialUnix
  • testing.T.ArtifactDir() cria um diretório para artefatos de teste (logs, screenshots, dumps)

Criptografia pós-quântica habilitada por padrão

O Go 1.26 habilita por padrão as trocas de chave híbridas pós-quânticas no TLS: SecP256r1MLKEM768 e SecP384r1MLKEM1024.

Essas combinam curvas elípticas tradicionais com ML-KEM, o algoritmo que o NIST padronizou como substituto pós-quântico para troca de chaves. A ideia é proteger conexões TLS contra a ameaça futura de computadores quânticos capazes de quebrar criptografia de curvas elípticas.

Na prática, isso é transparente. O handshake TLS negocia automaticamente o melhor algoritmo disponível. Se o outro lado não suportar, cai para curvas elípticas puras sem ML-KEM.

O novo pacote crypto/hpke implementa Hybrid Public Key Encryption (RFC 9180), incluindo suporte a KEMs pós-quânticos. E a operação de encapsulamento/decapsulamento do ML-KEM ficou 18% mais rápida.

Para quem precisa desabilitar os KEMs pós-quânticos (proxies corporativos que inspecionam TLS, por exemplo):

tls.Config{
    CurvePreferences: []tls.CurveID{
        tls.X25519,
        tls.CurveP256,
    },
}

Ou via GODEBUG: GODEBUG=tlssecpmlkem=0.

Três features experimentais para acompanhar

O Go 1.26 traz três features experimentais que precisam de build flag para ativar, mas que devem virar padrão em versões futuras.

simd/archsimd expõe operações SIMD da arquitetura. Por enquanto só amd64, com tipos como Int8x16, Float64x8 e vetores de 128, 256 e 512 bits. A API ainda não é estável. Ative com GOEXPERIMENT=simd.

runtime/secret permite apagar de forma segura dados sensíveis da memória: registradores, stack e heap. Funciona em amd64 e arm64 no Linux. Pensado para código criptográfico que precisa de forward secrecy real. Ative com GOEXPERIMENT=runtimesecret.

O perfil goroutineleak detecta goroutines bloqueadas em primitivas de concorrência inalcançáveis. O GC identifica channels e mutexes que nenhuma goroutine ativa consegue alcançar, e qualquer goroutine esperando neles aparece no perfil. Acessível via /debug/pprof/goroutineleak. Ative com GOEXPERIMENT=goroutineleakprofile. A equipe do Go quer habilitar isso por padrão no 1.27.

Conclusão

O Go 1.26 não reinventa a linguagem, mas entrega ganhos concretos de performance e produtividade. O Green Tea GC reduzindo 10-40% do overhead é o tipo de melhoria que aparece na conta de infra sem mudar uma linha de código. O go fix renovado facilita manter bases de código grandes atualizadas. E a criptografia pós-quântica por padrão no TLS posiciona Go à frente de muitas linguagens nesse aspecto.

Para atualizar: baixe em go.dev/dl ou use go install golang.org/dl/go1.26.0@latest. O bootstrap exige Go 1.24.6 ou superior.

Uma nota de atenção: essa é a última versão com suporte a macOS 12 Monterey. A partir do Go 1.27, o mínimo será macOS 13 Ventura.

Referências pesquisadas nesta publicação