Module path

You can now use subdirectories of a repository as module paths.
If the module path has a VCS qualifier at the end of a path component, the Go command will split the path by that qualifier.
The first part is treated as the repository, and the second part as the module’s subdirectory.
Example:

go get example.com/foo.git/bar@v1.1.1

The Go command downloads the repository example.com/foo and takes the module from the bar subdirectory.

If a module path doesn’t include a VCS qualifier, Go sends a GET request to the module address with the ?go-get=1parameter.
In the response, Go expects an HTML document containing a <meta> tag with the go-import attribute.
Example:

<meta name="go-import" content="company.com/api git https://gitlab.com/company/api">

After that, you can use the command:

go get company.com/api

to download the module.

This is a good way to keep the module path short and clear.

WaitGroup analyser for go vet

If sync.WaitGroup.Add is called in the wrong place, the vet command will report an error.

func main() {
    var wg sync.WaitGroup

    go func() {
        wg.Add(1) // <-- WRONG
        defer wg.Done()
    }()
    wg.Wait()
}

go vet
# ert
# [ert]
./main.go:8:9: WaitGroup.Add called from inside new goroutine

Container-aware GOMAXPROCS

In previous versions, GOMAXPROCS defaulted to the number of logical CPUs — runtime.NumCPU().

Starting with Go 1.25, this behavior has changed:

1. On Linux, the runtime now reads the CPU bandwidth limit from the cgroups that contain the process. If the bandwidth limit is lower than the number of available logical CPUs, GOMAXPROCS is set to that lower limit. In Kubernetes, this corresponds to the container’s CPU limit.

2. The runtime periodically checks the number of available logical CPUs or cgroup bandwidth limits and updates GOMAXPROCS dynamically if they change.

3. A manually set GOMAXPROCS (via environment variable or runtime.GOMAXPROCS()) always takes priority and disables automatic updates.

Trace flight recorder

Previously, if we wanted to trace the execution of an application, we had to use runtime/trace. However, this approach often caused issues — large trace files, high CPU overhead, and overall performance impact
.
Now we can use runtime/trace.FlightRecorder, which records traces in an in-memory ring buffer and saves them to disk only when needed. For example, you can capture just the last 5 seconds of execution and write it to a file using io.Writer. FlightRecorder can be configured through the FlightRecorderConfig structure.

These are just a few interesting highlights — you can find the full release information on the official website Go 1.25 Release Notes