Go Environment Variables

External

• https://pkg.go.dev/cmd/go#hdr-Environment_variables

Internal

• Go Development and Execution Environment

GOPATH

The GOPATH environment variable defines the workspace directory. Go tools assume that your code is under the path designated by GOPATH. Used to search for packages during compilation, when packages are being imported. Also see

Relationship between Workspace and GOPATH

To display the value, as seen by the Go runtime, execute:

go env GOPATH

For documentation on GOPATH, execute:

go help gopath

As of Go 1.16, the module-aware mode is turned on by default and the value of GOPATH is ignored while resolving package dependencies. In module-aware mode, GOPATH no longer defines the meaning of imports during a build, but it still stores downloaded dependencies in ${GOPATH}/pkg/mod and installed commands in ${GOPATH}/bin, unless GOBIN is set.

For more details see:

Module-Aware or GOPATH Mode

For an example of building and installing an executable with go install see:

Build and Install an Executable with go_install

GOPATH is used by the compiler to locate source files and package objects for the packages listed by the import statements in source files being compiled.

It must contain absolute paths.

GOPATH content lists directories on the local file system. GOPATH may contain multiple directories. On UNIX, the value is a colon-separated string. On Windows, the value is a semicolon-separated string. GOPATH must be set every time we need to get and build packages outside the standard Go tree.

The compiler loops over the values listed in GOPATH, in order, appends /src/<package-path-string-literal> to them, as declared in the import statement, and looks into the directories whose name are thus generated for source files that belong to the required packages. This is why it is important that the package and the directory containing the package sources have the same name: if they don't, the compilation fails to find the source file.

Each directory listed in GOPATH must have a prescribed structure:

• The src directory holds source code. The path below src determines the import path or executable name.
• The pkg directory holds installed package objects. As in the Go tree, each target operating system and architecture pair has its own subdirectory of pkg: pkg/GOOS_GOARCH.

If DIR is a directory listed in the GOPATH, a package with source in DIR/src/x/y can be imported as "x/y" and has its compiled form installed to "DIR/pkg/GOOS_GOARCH/x/y.a".

• The bin directory holds compiled commands. Each command is named for its source directory, but only the final element, not the entire path. That is, the command with source in DIR/src/x/blah is installed into DIR/bin/blah, not DIR/bin/x/blah. The "x/" prefix is stripped so that you can add DIR/bin to your PATH to get at the installed commands.

"internal" directories

Code in or below a directory named "internal" is importable only by code in the directory tree rooted at the parent of "internal". For more details see https://golang.org/s/go14internal.

Vendor directories

Organizatorium

Validated, to integrate:

• GOPATH cannot have relative entries, all entries must be absolute directories.

Relative Order

The order in which root directories are listed in GOPATH matters. If two directories contain packages with the same name, the compiler will stop searching once it finds the first package that satisfies the import statement. The compiler first look into Go installation directory, then into the directories listed in GOPATH. go install handles multiple-entry GOPATH is a similar manner.

In-line Documentation

go help gopath

GOBIN

If the GOBIN environment variable is set, go install installs binary executable artifacts into the directory designated by it, instead of ${GOPATH}/bin. GOBIN must be an absolute path.

Also see:

Build and Install an Executable with go_install

GOROOT

GOROOT specifies the root directory of the local Go distribution, also known as the Go runtime installation directory. The directory contains all packages of the standard library under the src subdirectory . The typical value for GOROOT is /usr/local/go. The actual value can be obtained with:

go env GOROOT

GOROOT must be set at installation, Go runtime expects to find the variable in the environment, unless the runtime is installed in its default location /usr/local/go. The installation procedure typically sets it.

GO111MODULE

Controls whether the go tool runs in module-aware mode or GOPATH mode. Accepts the following values:

• "off": run in GOPATH mode and ignore go.mod.
• "on": run. in module-aware mode, even if no go.modfile is present.
• "auto": run in module-aware mode if a go.mod file is present.

For more details see:

Module-Aware or GOPATH Mode

GOOS

"darwin" for MacOS.

GOARCH

"amd64"

GOCACHE

Go Build Cache