It looks like your GOOS is getting set to "linux " (with an extra space at the end), not "linux".

It tells you it needs all tools built before you can use them.

If your windows GOARCH is amd64, then you could "build" all required tools by running this small batch programs:

set GOARCH=amd64
set GOOS=linux
go tool dist install -v pkg/runtime
go install -v -a std

If that succeeds then you should be able to do what you've described (just use amd64, not AMD64 - it is case sensitive).

If your windows GOARCH is 386, then you would need to build your 386 tools first. You would need to download mingw gcc for that. Do what user2714852 said.

Here https://golang.org/wiki/WindowsCrossCompiling are similar instructions for linux, perhaps you find them helpful.

Alex

What it's saying you need to do is rebuild the library and runtime for linux-amd64. You can do that this way:

1. Find the root of your Go installation (if you don't know where this is, running which go may help - the binary is often installed with the rest of the sources).
2. cd into the src directory
3. Run GOOS=linux GOARCH=amd64 ./make.bash --no-clean (or GOOS=linux GOARCH=amd64 bash make.bash --no-clean if make.bash is not executable). This will rebuild the library and runtime using the specified OS and architecture.

Once you've done this, you can build a go package or binary for this architecture using GOOS=linux GOARCH=amd64 go build. You can follow the same instructions for other architectures and operating systems.

Edit (08/13/15):

As of Go 1.5, cross compiling is much easier. Since the runtime is written in Go, there's no need to set anything up in order to be able to cross-compile. You can now just run GOOS=<os> GOARCH=<arch> go build from a vanilla Go installation and it will work.

However, there's one exception to this. If you're using cgo, you'll still need to set stuff up ahead of time. And you'll need to inform the tooling that you want to enable cgo cross-compiling by setting the CGO_ENABLED environment variable to 1. So, to be precise:

1. cd into the src directory of your Go installation (see the instructions above).
2. Run CGO_ENABLED=1 GOOS=<os> GOARCH=<arch> ./make.bash --no-clean
3. Run CGO_ENABLED=1 go build to build your project. It is important that you specify CGO_ENABLED=1 even when you're compiling.

You can easily set the target operating system and processor architecture using the environment variables GOOS and GOARCH respectively. So, as you want to build it for linux operating system, following command with above environment variables will do,

$ GOOS=linux GOARCH=amd64 go build -o hello main.go

Here is the list of all the supported operating system with which you can easily do cross compilation using Go lang.

Note that those values are defined in:

• src/internal/syslist/syslist.go, and
• doc/install/source#environment.

With Go 1.5 (Q3 2015), GOARCH will become much more complete.
See commit 1eebb91 by Minux Ma (minux)

go/build: reserve GOARCH values for all common architectures

Whenever we introduce a new GOARCH, older Go releases won't recognize them and this causes trouble for both our users and us (we need to add unnecessary build tags).

Go 1.5 has introduced three new GOARCHes so far: arm64 ppc64 ppc64le, we can take the time to introduce GOARCHes for all common architectures that Go might support in the future to avoid the problem.

Copyconst goosList = "android darwin dragonfly freebsd linux nacl \ 
  netbsd openbsd plan9 solaris windows "

const goarchList = "386 amd64 amd64p32 arm arm64 ppc64 ppc64le \
   mips mipsle mips64 mips64le mips64p32 mips64p32le \ # (new)
   ppc s390 s390x sparc sparc64 " # (new)

The list is still being review in Change 9644, with comments like:

I wouldn't bother with Itanium. It's basically a dead architecture.
Plus, it's so hard to write a compiler for it that I really can't see it happening except as a labor of love, and nobody loves the Itanium.

The official documentation now (GO 1.5+ Q3 2015) reflects that completed list.

Update 2018: as documented in Giorgos Oikonomou's answer, Go 1.7 (Q1 2016) has introduced the
go tool dist list command.
See commit c3ecded: it fixes issue 12270 opened in Q3 2015:

To easier write tooling for cross compiling it would be good to programmatically get the possible combinations of GOOS and GOARCH.

This was implemented in CL 19837

cmd/dist: introduce list subcommand to list all supported platforms

You can list in plain text, or in json:

Copy> go tool dist list -json
[
        {
                "GOOS": "android",
                "GOARCH": "386",
                "CgoSupported": true
        },
        ...
]

As Mark Bates tweeted:

Bonus: Column output properly formatted for display:

Copygo tool dist list | column -c 75 | column -t

The first thing you should do is remove the @ at the beginning of your makefile recipes, so you can see the actual commands that are being invoked, and check carefully that they contain what you expect. Using @ is like running your compiler with output redirected to /dev/null so you can't see the output then trying to figure out what's wrong.

In your case, the problem is that $ is a special character to make; it introduces a make variable. So in this line:

$Env:GOOS='linux'; $Env:GOARCH='amd64'

the $ is expanded by make and since $E is an empty variable, make will invoke:

nv:GOOS='linux'; nv:GOARCH='amd64'

which is wrong. If you hadn't added the @ then make would show you this incorrect text.

You need to double the dollar sign to escape it:

$$Env:GOOS='linux'; $$Env:GOARCH='amd64'