Go makes cross-compilation extremely simple. You only need to set GOOS and GOARCH environment variables to generate binary files of the target platform; 1. Use GOOS and GOARCH to specify the target operating system and architecture, such as linux, windows, darwin, amd64, arm64, etc.; 2. Use GOOS=target system GOARCH=target architecture go build command to generate executable files for the corresponding platform; 3. Use shell scripts or Makefile to automate multi-platform construction processes to improve efficiency; 4. Ensure CGO_ENABLED=0 to avoid cross-compilation problems caused by CGO dependency; 5. Use Go's build tag (//go:build) to handle specific code logic of different operating systems. The appropriate files will be automatically selected according to the target platform. The entire process does not require an additional tool chain, and multi-platform compilation can be completed from a single machine.

Go makes cross-compiling applications incredibly straightforward thanks to its built-in support for multiple operating systems and architectures. Unlike many other languages, you don't need complex toolchains or external dependencies—just a single command can produce binaries for different platforms.

Here's how to effectively cross-compile Go applications.

Set GOOS and GOOSARCH for Target Platforms

Go uses environment variables GOOS (target operating system) and GOARCH (target architecture) to control cross-compilation. You don't need to install anything extra—Go's toolchain includes compilers for many platforms.

Common values:

• GOOS (Operating Systems):
  linux , windows , darwin (macOS), freebsd , openbsd , android , etc.

  

• GOARCH (Architectures):
  amd64 , 386 , arm , arm64 , riscv64 , etc.

To build a Linux 64-bit binary on a macOS or Windows machine:

 GOOS=linux GOARCH=amd64 go build -o myapp-linux main.go

For a Windows executable:

 GOOS=windows GOARCH=amd64 go build -o myapp.exe main.go

And for macOS on Apple Silicon (arm64):

 GOOS=darwin GOARCH=arm64 go build -o myapp-mac main.go

These commands can be run from any development machine—no need for a target OS.

Automate Builds for Multiple Platforms

If you need to support several platforms, manually running commands gets tedious. Use a script or Makefile to automate.

Example shell script:

 #!/bin/bash

set -e

version="1.0.0"
mkdir -p releases

build() {
  os=$1
  arch=$2
  ext=""
  if [ "$os" = "windows" ]; then
    ext=".exe"
  fi
  echo "Building for $os/$arch..."
  GOOS=$os GOARCH=$arch go build -o "releases/myapp-$version-$os-$arch$ext" main.go
}

# Build for common platforms
build linux amd64
build linux arm64
build windows amd64
build darwin amd64
build darwin arm64

Now a single ./build.sh gives you binaries for deployment across environments.

Watch Out for CGO and External Dependencies

Cross-compilation works flawlessly as long as you avoid CGO . If your code (or a dependency) uses CGO—like calling C libraries—you'll run into issues because it requires platform-specific C compilers.

By default, CGO is disabled when cross-compiling, which is usually fine unless you're using packages like:

• sqlite3 (with CGO bindings)
• gopsutil (some features)
• Custom C extensions

To ensure CGO stays off:

 CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o app main.go

If you must use CGO, you'll need cross-compiling C toolchains (like x86_64-linux-gnu-gcc ), which complicates things significantly. For maximum portability, prefer pure Go implementations.

Use Build Tags to Handle Platform-Specific Code

Sometimes your app needs different logic per OS (eg, file paths, system calls). Use build tags to include/exclude code during compilation.

Example: windows_setup.go

 //go:build windows
// build windows

package main

func init() {
    println("Running on Windows")
}

And unix_setup.go :

 //go:build darwin || linux
// build darwin,linux

package main

func init() {
    println("Running on Unix-like system")
}

Go automatically includes the right files based on GOOS . No extra configuration needed.

Cross-compiling in Go is simple, reliable, and part of the standard workflow. Just set GOOS and GOARCH , keep CGO disabled unless necessary, and automate with scripts. Whether you're shipping CLI tools, microservices, or desktop apps, Go lets you target nearly any platform from a single machine.

Basically, that's all it takes.

The above is the detailed content of Cross-Compiling Go Applications for Different Platforms. For more information, please follow other related articles on the PHP Chinese website!