Go 1.27 Finally Adds Generic Methods to the Language

Go 1.27 is now available, and one of its biggest language changes is something Go developers have been waiting for since generics arrived: generic methods.

Generics were introduced in Go 1.18, giving developers a way to write functions and data structures that work with different types. But there was an important limitation. While functions could declare their own type parameters, methods could not.

Go 1.27 changes that.

With the new release, a method can declare its own type parameters. This makes it possible to keep generic behavior attached to a specific type instead of always putting the generic function at package level.

Before Go 1.27, Go allowed generic functions, but methods could not introduce their own type parameters.

For example, a generic function could look like this:

func First[T any](items []T) T {
    return items[0]
}

The T type parameter allows the same function to work with different types.

However, developers could not write a method that introduced a new type parameter of its own.

Go 1.27 removes that limitation.

A method can now declare its own type parameter:

type Box struct {
    value any
}
func (b Box) Get[T any]() T {
    return b.value.(T)
}

The important part is the [T any] attached to the method. The method can use that type parameter independently of the receiver type.

This is the key language change introduced by Go 1.27. The official release notes describe it as allowing a method declaration to declare its own type parameters.

The easiest way to understand the change is to compare a generic function with a generic method.

A generic function belongs to the package:

func Convert[T any](value T) T {
    return value
}

A generic method, on the other hand, belongs to a type:

type Converter struct{}
func (Converter) Convert[T any](value T) T {
    return value
}

The method can then be called through the receiver:

converter := Converter{}
value := converter.Convert(42)

The compiler can infer the type parameter from the argument, so developers do not normally need to write the type explicitly.

This makes generic functionality easier to associate with the type that provides it.

One real example can be found in Go's math/rand/v2 package. Go 1.27 adds a generic N method to Rand that can work with different integer types. Before this change, separate methods such as Int32N, Int64N, and IntN were needed.

The new API can instead use:

func (r *Rand) N[Int intType](n Int) Int

That is a practical example of why generic methods can be useful. Instead of creating several methods that differ mainly by the integer type they accept, one generic method can handle the different types.

The main benefit is not simply being able to write shorter code. It is about where generic behavior can live.

Before Go 1.27, developers who wanted a generic operation had to use a package-level generic function when the operation needed its own type parameter.

That can be fine for many cases, but sometimes the operation logically belongs to a particular type.

Generic methods allow developers to express that relationship directly.

For example, imagine a type that represents a collection, query builder, converter, or another reusable component. The component might need to perform an operation where the receiver has one type while the operation itself needs another.

A generic method gives the method its own type parameter instead of forcing that generic behavior into a separate package-level function.

This can make APIs easier to organize and can reduce the need for multiple type-specific methods.

The math/rand/v2.Rand.N example shows this clearly. Instead of having a different method for each integer type, the generic method puts the operation directly on Rand.

Generic methods do not mean that every method in Go can suddenly use type parameters without restrictions.

There are some important rules developers need to know.

First, interface methods cannot declare type parameters.

For example, this is not allowed:

type Processor interface {
    Process [T any](value T)
}

The Go 1.27 specification specifically states that methods of interfaces may not declare type parameters.

There is another related restriction. An interface method cannot be implemented by a generic method.

So while generic methods provide considerably more flexibility, they do not change Go's interface system into a fully generic method dispatch system.

This is important when designing APIs. Developers should understand these restrictions before replacing existing interfaces or abstractions with generic methods.

For most existing Go projects, the change does not require any immediate action.

Go 1.27 maintains Go's compatibility promise, so existing programs should generally continue to compile and run as before. Generic methods are an additional language capability rather than a change that requires developers to rewrite existing code.

The bigger question is when to actually use the feature.

Developers should not add generic methods simply because they are available. A generic method is useful when the operation genuinely needs to work with multiple types and logically belongs to the receiver type.

In other situations, a normal method or a package-level generic function may still be simpler.

That fits well with Go's general approach to language design. The new feature gives developers another tool, but it does not mean every piece of code should become generic.

Generic methods are one of three notable language changes in Go 1.27.

The release also allows keys in struct literals to use valid field selectors, including fields promoted from embedded structs. Function type inference has also been expanded so generic functions can be inferred in additional assignment contexts.

There are also several changes outside the language itself.

Go 1.27 introduces a new uuid package, adds the crypto/mldsa package for the post-quantum ML-DSA signature scheme, makes the goroutine leak profile generally available, and includes improvements to memory allocation.

The release also adds encoding/json/v2 alongside encoding/json/jsontext, while keeping the existing encoding/json API compatible.

So generic methods are only one part of a much larger Go release. But for developers interested specifically in the language itself, this is arguably the most interesting change.

Go's generics story has taken another step forward with Go 1.27.

Generics arrived in Go 1.18, but methods were left with an important limitation. Developers could create generic functions, yet they could not give individual methods their own type parameters.

That limitation is now gone.

Generic methods make it possible to keep reusable, type-independent operations attached to the types they belong to. The new math/rand/v2.Rand.N method is a good example of how this can replace several type-specific methods with one generic API.

It is not a feature that every Go developer will need immediately, and there are still restrictions around interfaces. But for developers building reusable libraries and APIs, Go 1.27 provides a useful new way to structure generic code.

Go 1.27 was officially released on August 19, 2026, so developers interested in trying generic methods can now use them in the stable Go release rather than waiting for an experimental version.

Official resources: Go 1.27 release announcement | Go 1.27 release notes