What should be the values of GOPATH and GOROOT?

I'm trying to install doozer like this:

$ goinstall github.com/ha/doozer

I get these errors.

> goinstall: os: go/build: package could not be found locally
> goinstall: fmt: go/build: package could not be found locally
> goinstall: io: go/build: package could not be found locally
> goinstall: reflect: go/build: package could not be found locally
> goinstall: math: go/build: package could not be found locally
> goinstall: rand: go/build: package could not be found locally
> goinstall: url: go/build: package could not be found locally
> goinstall: net: go/build: package could not be found locally
> goinstall: sync: go/build: package could not be found locally
> goinstall: runtime: go/build: package could not be found locally
> goinstall: strings: go/build: package could not be found locally
> goinstall: sort: go/build: package could not be found locally
> goinstall: strconv: go/build: package could not be found locally
> goinstall: bytes: go/build: package could not be found locally
> goinstall: log: go/build: package could not be found locally
> goinstall: encoding/binary: go/build: package could not be found locally

GOPATH is discussed in the cmd/go documentation:

> The GOPATH environment variable lists places to look for Go code. On
> Unix, the value is a colon-separated string. On Windows, the value is
> a semicolon-separated string. On Plan 9, the value is a list.
>
> GOPATH must be set to get, build and install packages outside the
> standard Go tree.

GOROOT is discussed in the installation instructions:

> The Go binary distributions assume they will be installed in
> /usr/local/go (or c:\Go under Windows), but it is possible to install
> the Go tools to a different location. In this case you must set the
> GOROOT environment variable to point to the directory in which it was
> installed.
>
> For example, if you installed Go to your home directory you should add
> the following commands to $HOME/.profile:
>
> export GOROOT=$HOME/go
> export PATH=$PATH:$GOROOT/bin
>
> Note: GOROOT must be set only when installing to a custom location.

(updated version of Chris Bunch's answer.)

Here is a my simple setup:

directory for go related things: ~/programming/go
directory for go compiler/tools: ~/programming/go/go-1.4
directory for go software      : ~/programming/go/packages

GOROOT, GOPATH, PATH are set as following:

export GOROOT=/home/user/programming/go/go-1.4
export GOPATH=/home/user/programming/go/packages
export PATH=$PATH:$GOROOT/bin:$GOPATH/bin

So, in short:

GOROOT is for compiler/tools that comes from go installation.<br/>
GOPATH is for your own go projects / 3rd party libraries (downloaded with "go get").

First run go env.
If you see that the go isn't installed, you can install it via homebrew or via package and/or other ways.
If you are seeing output then your Go is installed.
It shows you all the envs that are set and are not.

If you see empty for GOROOT:

1. Run which go (On my computer : /usr/local/go/bin/go)
2. then export like this export GOROOT=/usr/local/go

If you see empty for GOPATH:

1. Create any directory anywhere on your computer for go projects in my case: ~/GO_PROJECTS
2. Then export GOPATH=~/GO_PROJECTS

GOPATH is discussed here:

> The GOPATH Environment Variable
>
> GOPATH may be set to a colon-separated list of paths inside which Go
> code, package objects, and executables may be found.
>
> Set a GOPATH to use goinstall to build and install your own code and
> external libraries outside of the Go tree (and to avoid writing
> Makefiles).

And GOROOT is discussed here:

> $GOROOT The root of the Go tree, often $HOME/go. This defaults to the
> parent of the directory where all.bash is run. If you choose not to
> set $GOROOT, you must run gomake instead of make or gmake when
> developing Go programs using the conventional makefiles.

I read the go help gopath docs and was still incredibly confused, but found this little nugget from another go doc page:

> The GOPATH environment variable specifies the location of your workspace. It is likely the only environment variable you'll need to set when developing Go code.

http://golang.org/doc/code.html#GOPATH

Starting with go 1.8 (Q2 2017), GOPATH will be set for you by default to $HOME/go

See issue 17262 and Rob Pike's comment:

> $HOME/go it will be.
There is no single best answer but this is short and sweet, and it can only be a problem to choose that name if $HOME/go already exists, which will only happen for experts who already have go installed and will understand GOPATH.

The GOPATH should not point to the Go installation, but rather to your workspace (see https://golang.org/doc/code.html#GOPATH). Whenever you install some package with go get or go install, it will land within the GOPATH. That is why it warns you, that you most definitely do not want random packages from the internet to be dumped into your official installation.

You generally should not set GOROOT explicitly. The go command identifies the appropriate GOROOT automatically based on its own directory location.

GOPATH defaults to $HOME/go. You only need to set it explicitly if you want to put it somewhere else.

GOPATH contains:

• Binaries installed using go install, located at $GOPATH/bin.¹
  • This location can be overridden using the GOBIN environment variable.
• A cache of downloaded module source code and checksums, located at $GOPATH/pkg/mod.
  • This location can be overridden using the GOMODCACHE environment variable.

If you set both GOBIN and GOMODCACHE, and do not set GO111MODULE=off, then GOPATH itself should have essentially no effect.

In addition, in the legacy GOPATH mode (when GO111MODULE=off is also set), GOPATH contains:

• Source code used to build packages, stored in a directory tree rooted at $GOPATH/src.
• Non-binaries installed using go install, located at $GOPATH/pkg.
  • Installing non-binary packages is no longer particularly useful: the go command has a cache of built artifacts, which has been required since Go 1.12 even in GOPATH mode.
  • The build cache is not located within GOPATH. Its location can be set with the GOCACHE environment variable.

¹ Binaries can also be installed using go get on Go 1.17 and earlier, but go install is preferred as of Go 1.16; see https://golang.org/doc/go1.16.

Regarding GOROOT specifically, Go 1.9 will set it automatically to its installation path.
Even if you have multiple Go installed, calling the 1.9.x one will set GOROOT to /path/to/go/1.9 (before, if not set, it assumed a default path like /usr/local/go or c:\Go).

See CL Go Review 53370:

> The go tool will now use the path from which it was invoked to attempt to locate the root of the Go install tree.
This means that if the entire Go installation is moved to a new location, the go tool should continue to work as usual.

> This may be overriden by setting GOROOT in the environment, which should only be done in unusual circumstances.
Note that this does not affect the result of the runtime.GOROOT() function, which will continue to report the original installation location; this may be fixed in later releases.

In modern Go, you don't need to set GOPATH or GOROOT. In fact, unless you're doing something very specialized, it's best to have them unset on your system.

Use Go modules. Having installed Go, pick a directory where you want to work. Then:

$ mkdir example
$ cd example
$ go mod init example.com

Note that the module name example.com is arbitrary; if you keep your work on GitHub, this could be something like github.com/your-username/project-name.

The last command will have created a go.mod file; now you can grab dependencies with go get:

$ go get rsc.io/quote

Now your code using this dependency:

$ touch main.go

Place this in main.go:

package main

import (
	"fmt"

	"rsc.io/quote"
)

func main() {
	fmt.Println(quote.Go())
}

And run with:

$ go run .

W.r.t. original question, you can now get your doozer dependency with:

$ go get github.com/ha/doozer

Now you can use the doozer module in your code. And so on. You can also examine the go.mod file in your directory to see the dependencies listed, along with their versions. Each module is self-contained, with its own versions of dependencies. You can have two modules alongside each other, each with its own go.mod file pointing to different versions of some dependency - this will all work OK because of the isolation between modules.

For additional information, start with the official tutorial here. In several chapters, it walks you through the steps shown above, as well as writing your own reusable modules and packages, and importing them from other modules. Additional interactive tutorials are available at https://play-with-go.dev/

GOPATH and GOROOT configurations are deprecated.

You can use the GO module instead.

For example:

mkdir go_app
cd go_app
go mod init go_app

As mentioned above:

> The GOPATH environment variable specifies the location of your
> workspace.

For Windows, this worked for me (in Ms-dos window):

set GOPATH=D:\my_folder_for_go_code\

This creates a GOPATH variable that Ms-dos recognizes when used as follows:

cd %GOPATH%

Lots of answers but no substance, like robots doing cut and paste on what's on their system. There is no need to set GOROOT as an environment variable. However, there is a beneficial need to set the GOPATH environment variable, and if not set it defaults to ${HOME}/go/ folder.

It is the PATH environment variable that you must pay attention because this variable is the variable that can change your go version. Not GOROOT! Forget GOROOT.

Now, if you switch or change to a new go version, your downloaded packages will use the default $HOME/go folder and it will mixed-up with whatever your previous go version was. This is not good.

Therefore, this is where GOPATH you need to define in order to isolate downloaded packages of the new go version.

In summary, forget GOROOT. Think more on GOPATH.

Run go help environment it has documentation for every environment variable that can be listed by go env command

There's a command you can use: go env GOPATH

Here is one solution (single user):

GOROOT=$HOME/.local # your go executable is in $GOROOT/bin
GOPATH=$HOME/.gopath
PATH=$GOROOT/bin:$GOPATH/bin:$PATH

go complains if you change .gopath to .go.

I wish they went with how the rust/cargo guys did and just put everything at one place.

You don't need to explicitly set GOROOT (Modern versions of Go can figure it out on their own based on the location of the go binary that you run).

Also, got the follow error when trying to work with vgo:

go: modules disabled inside GOPATH/src by GO111MODULE=auto; see 'go help modules'

Removing GOROOT, updating my GOPATH and export GO111MODULE="on" resolved the issue.

GOPATH see in here

> GOPATH may be set to a colon-separated list of paths inside which Go code, package objects, and executables may be found.
>
> Set a GOPATH to use goinstall to build and install your own code and external libraries outside of the Go tree (and to avoid writing Makefiles).

As of 2020 and Go version 1.13+, in Windows the best way for updating GOPATH is just typing in command prompt:

setx GOPATH C:\mynewgopath

I had to append

export GOROOT=/usr/local/Cellar/go/1.10.1/libexec

to my ~/.bash_profile on Mac OS X

There is also a case where when we use go it compiles all the go files.

So lets say we had one file main.go and later we changed the current file to main_old.go and then added our new main.go file. Then when we build our app all the go files will get compiled. So the error that's happening might be due to compilation error in some other go files.

Once Go lang is installed, GOROOT is the root directory of the installation.

When I exploded Go Lang binary in Windows C:\ directory, my GOROOT should be C:\go.
If Installed with Windows installer, it may be C:\Program Files\go (or C:\Program Files (x86)\go, for 64-bit packages)

 GOROOT = C:\go

while my GOPATH is location of Go lang source code or workspace.

If my Go lang source code is located at C:\Users&lt;xyz>\GO_Workspace, your GOPATH would be as below:

 GOPATH = C:\Users\<xyz>\GO_Workspace

For all newcomers they could do a simply export GOPATH=$HOME/go if you are using Ubuntu or do go help gopath for more information.

in osx, i installed with brew, here is the setting that works for me

GOPATH="$HOME/my_go_work_space" //make sure you have this folder created

GOROOT="/usr/local/Cellar/go/1.10/libexec"

If you are using the distro go, you should point to where the include files are, for example:

$ rpm -ql golang | grep include
/usr/lib/golang/include

(This is for Fedora 20)

the values should be (MACOS):

GOROOT="/usr/local/go" --> all binaries file core go
GOPATH="/Applications/proyectos/go" --> the route to workspace (custom workspace)