gox

Compile Go program in the current directory for all operating systems and architecture combinations

$ gox

$ gox [url_1] [url_2]

$ gox -os="[os]"

$ gox -osarch="[os]/[arch]"

gox [] []

-os OS[,OS...]
    Specifies the target operating system(s) (e.g., linux, windows, darwin). Multiple values can be comma-separated.

-arch ARCH[,ARCH...]
    Specifies the target architecture(s) (e.g., amd64, 386, arm, arm64). Multiple values can be comma-separated.

-output PATH
    Specifies the output path for the built binaries. Can use placeholders like {{.OS}}, {{.Arch}}, {{.Dir}}, {{.Basename}} for dynamic naming. Example: "dist/{{.OS}}_{{.Arch}}/{{.Basename}}".

-ldflags LDFLAGS
    Arguments to pass to the Go linker (-ldflags).

-tags TAGS
    Arguments to pass to the Go compiler (-tags), used for conditional compilation.

-verbose
    Enable verbose output, showing commands being executed.

-rebuild
    Force a rebuild of packages, ignoring the build cache.

-parallel COUNT
    The number of parallel builds to run. Defaults to the number of CPU cores.

-path PATH
    Path to the Go packages to build. Defaults to the current directory (./...).

-cgo
    Enable CGO support for cross-compilation. Note: Cross-compiling with CGO can be complex and may require additional setup (e.g., target C toolchains).

gox is a powerful utility designed to automate and simplify the process of cross-compiling Go applications for various operating systems and architectures. Traditionally, cross-compiling a Go program involves manually setting GOOS and GOARCH environment variables for each target platform before running go build. gox abstracts this complexity, allowing developers to specify multiple target OS/ARCH combinations (e.g., Linux, Windows, macOS, x86, ARM) in a single command. It can build simultaneously for these targets, organizing the output binaries into a specified directory structure.

This tool is particularly useful for projects that need to distribute binaries for a wide range of platforms, significantly streamlining the release process. It's built on top of the standard Go toolchain and integrates seamlessly into existing Go workflows, making it a popular choice for developers seeking efficient cross-platform build solutions.

Go Toolchain Requirement: gox requires a Go development environment to be installed and configured, as it leverages the standard go build command internally.
CGO Limitations: Cross-compiling Go programs that use CGO (C language bindings) is significantly more complex. It often requires specific C compilers (cross-compilers like gcc-arm-linux-gnueabihf) for each target architecture and OS, which are not automatically managed by gox. This can be a major hurdle for CGO-enabled projects.
External Dependencies: If your Go application has external C/C++ dependencies linked via CGO, you'll need to ensure those dependencies are available and correctly configured for each target platform, which can be non-trivial.

To build for Linux (amd64), Windows (amd64), and macOS (amd64) from the current directory, placing binaries in a bin folder:
gox -os "linux,windows,darwin" -arch "amd64" -output "bin/{{.OS}}_{{.Arch}}/{{.Basename}}" ./...
This command demonstrates how to specify multiple targets and control the output directory structure using placeholders.

gox is frequently integrated into automated build systems and CI/CD pipelines (e.g., GitHub Actions, GitLab CI, Jenkins). Its simplicity and command-line interface make it easy to incorporate into scripts for generating release artifacts, ensuring consistent cross-platform builds.

gox was developed by Mitchell Hashimoto, co-founder of HashiCorp, known for tools like Vagrant, Terraform, and Vault. It emerged as a practical solution to streamline the release process for Go applications, which often need to be distributed across a variety of operating systems and architectures. Its design philosophy aligns with HashiCorp's focus on automation and ease of use, making it a popular choice for developers looking to simplify their Go build pipelines. While not part of the official Go distribution, it has become a de-facto standard tool in the Go ecosystem for cross-compilation.

go(1), env(1)