a build tool for Go, with a focus on cross-compiling, packaging and deployment
Go Smarty
Latest commit f8fbb3b Aug 21, 2016 @pdf pdf committed on GitHub Merge pull request #108 from pdf/task-rice-append
Add rice-append task
Failed to load latest commit information.
archive Improve logging for publish-github. fix support for prerelease. Some … Jun 20, 2015
config Add test case for fixed bug. Jul 1, 2015
core fix for ticket #85 - nil check Oct 25, 2015
deb-contents/etc/init.d fix for adding directories in other-mapped-files Aug 16, 2014
debian refactoring debian packaging tasks to use debber. 'ar' support to use… Aug 9, 2014
executils remove single-quotes from ldflag values (unless space is present) Dec 15, 2015
exefileparse goimports Dec 15, 2014
packaging/sdeb goimports Dec 15, 2014
platforms removing deprecated dragonfly/386 Oct 25, 2015
source Improve logging for publish-github. fix support for prerelease. Some … Jun 20, 2015
tasks Merge pull request #108 from pdf/task-rice-append Aug 21, 2016
testdata testdata is now excluded (by default) May 14, 2015
typeutils fix bug in CLI parser for task-settings Jun 21, 2015
.gitignore refactoring debian packaging tasks to use debber. 'ar' support to use… Aug 9, 2014
.goxc.json fix for ldflags Oct 25, 2015
.travis.yml Switch to valid git branches/tags for go versions Feb 22, 2015
README.md Merge pull request #106 from dg-ratiodata/feature/update-readme Jul 22, 2016
darwin.goxc.json adding build date to variable interpolation. Partial fix for issue #15 Aug 4, 2013
downloads.htpl adding html template for proof-of-concept Sep 22, 2013
downloads.tpl fix for file-based templates Sep 22, 2013
goxc.go publish-github: skip 422 errors (existing files). This enables re-run… Jun 21, 2015
goxc_test.go goimports Dec 15, 2014
htmltemplate.goxc.json adding html template for proof-of-concept Sep 22, 2013
notdarwin.goxc.json improved 'config inheritance'. Other configs now inherit from the 'ba… Jul 7, 2013
sample.goxc.local.json github progress. version ids in the API are numeric ids, not the name… May 23, 2015


goxc build status

NOTE: goxc has long been in maintenance mode. Ever since Go1.5 supported simple cross-compilation, this tool lost much of its value. There are still many aspects of goxc which I'm very proud of, and some packaging features in particular, which are still useful. I'm very much a go user, but I myself haven't had any need for goxc for a long while.

If you see something you'd like to add to goxc, please go ahead, fork and PR. Good PRs will earn you commit access to the repo. Thanks for everyone's help over the years.

goxc is a build tool for Go, with a focus on cross-compiling and packaging.

By default, goxc [g]zips (& .debs for Linux) the programs, and generates a 'downloads page' in markdown (with a Jekyll header).

goxc is written in Go but uses os.exec to call 'go build' with the appropriate flags & env variables for each supported platform.

goxc was inspired by Dave Cheney's Bash script golang-crosscompile.

  • goxc crosscompiles to all platforms at once.
  • The artifacts are saved into a directory structure along with a markdown file of relative links.
  • Artifacts are packaged as zips, tgzs, or debs. Defaults for each OS/architecture.
  • AND, goxc can now upload your files to github releases OR bintray.com.
  • See ‘Github Releases’ section below.

Notable Features

  • Cross-compilation, to all supported platforms, or a specified subset.
    • Validation of toolchain & verification of cross-compiled artifacts
    • Specify target platform, via 'Build Constraint'-like syntax (via commandline flag e.g. -bc="windows linux,!arm", or via config)
  • Automatic (re-)building toolchain to all or specified platforms.
  • 'task' based invocation, similar to 'make' or 'ant'. e.g. goxc xc or goxc clean go-test
    • The 'default' task alias will, test, cross-compile, verify, package up your artifacts for each platform, and generate a 'downloads page' with links to each platform.
    • Various go tools available via tasks: go-test, go-vet, go-fmt, go-install, go-clean.
    • You can modify task behaviour via configuration or commandline flags.
  • JSON-based configuration files for repeatable builds.
    • Most config data can be written via flags (using -wc option) - less JSON fiddliness.
    • Includes support for multiple configurations per-project.
    • Per-task configuration options.
    • 'Override' config files for 'local environment' - working-copy-specific, or branch-specific, configurations.
  • Packaging & distribution
    • Zip (or tar.gz) archiving of cross-compiled artifacts & accompanying resources (READMEs etc)
    • Packaging into .debs (for Debian/Ubuntu Linux)
    • Upload to github.com releases.
    • bintray.com integration (deploys binaries to bintray.com). bintray.com registration required
    • 'downloads page' generation (markdown/html format; templatable).
  • Versioning:
    • track your version number via configuration data.
    • version number interpolation at compile-time (uses go's -ldflags compiler option to populate given constants or global variables with build version or build date)
    • version number interpolation of source code. goxc interpolate-source (new task available in 0.10.x).
    • the bump task facilitates increasing the app version number.
    • the tag task creates a tag in your vcs (currently only 'git' supported).
  • support for multiple binaries per project (goxc now searches subdirectories for 'main' packages)
  • support for multiple Go installations - choose at runtime with -goroot= flag.


goxc requires the go source and the go toolchain.

  1. Install go from source. (Requires gcc (or MinGW) and 'hg')

    • OSX Users Note: If you are using XCode 5 (OSX 10.9), it is best to go straight to Go 1.2rc5 (or greater). This is necessary because Apple have replaced the standard gcc with llvm-gcc, and Go 1.1 compilation tools depend on the usual gcc.

      • There is another workaround incase Go 1.2rc5 is not an option:

          brew tap homebrew/versions
          brew install apple-gcc42
          go get github.com/laher/goxc
          CC=`brew list apple-gcc42 | grep bin/gcc-4.2` goxc -t
  2. Install goxc:

    go get github.com/laher/goxc
  3. a. (just once per Go version): to pre-build the toolchains for all platforms:

    goxc -t
    • Note that rebuilding the toolchain is only required for Go up until v1.4. This step will become unnecessary in Go 1.5.
    • Note that, until goxc v0.16.0, rebuilding the toolchain was triggered automatically. This has now been switched off (by default). Automatic rebuilding was causing a number of subtle bugs for different users, and has been switched off since v0.16.0.
    • Also note that building the toolchain takes a while. Cross-compilation itself is quite fast.

Basic Usage

cd path/to/app/dir

More options

Use goxc -h to list all options.

  • e.g. To restrict by OS and Architecture (using the same syntax as Go Build Constraints):

     goxc -bc="linux,!arm windows,386 darwin"
  • e.g. To set a destination root directory and artifact version number:

     goxc -d=my/jekyll/site/downloads -pv=0.1.1
  • 'Package version' can be compiled into your app if you define a VERSION variable in your main package.


goxc performs a number of operations, defined as 'tasks'. You can specify tasks as commandline arguments

  • goxc -t performs one task called 'toolchain'. It's the equivalent of goxc -d=~ toolchain
  • The default task is actually several tasks, which can be summarised as follows:
    • validate (tests the code) -> compile (cross-compiles code) -> package ([g]zips up the executables and builds a 'downloads' page)
  • You can specify one or more tasks, such as goxc go-fmt xc
  • You can skip tasks with '-tasks-='. Skip the 'package' stage with goxc -tasks-=package
  • For a list of tasks and 'aliases', run goxc -h tasks
  • Several tasks have options available for overriding. You can specify them in config or via flags. Just use goxc <taskname> -task-setting=value <othertask>
  • For more info on a particular task, run goxc -h <taskname>. This will also show you the options available for that task.
  • The easiest way to see how to configure tasks in config is to write some task config via -wc, e.g. goxc -wc xc -GOARM=5


By default, artifacts are generated and then immediately archived into (outputdir).


  • /my/outputdir/0.1.1/myapp_0.1.1_linux_arm.tar.gz
  • /my/outputdir/0.1.1/myapp_0.1.1_windows_386.zip
  • /my/outputdir/0.1.1/myapp_0.1.1_linux_386.deb

The version number is specified with -pv=0.1.1 .

By default, the output directory is ($GOBIN)/(appname)-xc, and the version is 'unknown', but you can specify these.


  goxc -pv=0.1.1 -d=/home/me/myuser-github-pages/myapp/downloads/

NOTE: it's bad idea to use project-level github-pages - your repo will become huge. User-level gh-pages are an option, but it's better to use the 'bintray' tasks.:

If non-archived, artifacts generated into a directory structure as follows:


Be careful if you want to build a project with multiple executables. You need to add {{.ExeName}} to your OutPath-setting in your '.goxc.json'. So it may look like the following code snippet.

"OutPath": "{{.Dest}}{{.PS}}{{.AppName}}{{.PS}}{{.Version}}{{.PS}}{{.ExeName}}_{{.Version}}_{{.Os}}_{{.Arch}}{{.Ext}}"

Configuration file

For repeatable builds (and some extra options), it is recomended to use goxc with one or more configuration file(s) to save and re-run compilations.

To create a config file (`.goxc.json`), just use the -wc (write config) option.

	goxc -wc -d=../site/downloads -bc="linux windows" xc -GOARM=7

You can also use multiple config files to support different paremeters for each platform.

The following would add a 'local' config file, `.goxc.local.json`. This file's contents will override `.goxc.json`. The idea of the .local.json files is to git-ignore them - for any local parameters which you only want on this particular computer, but not for other users or even for yourself on other computers/OS's.

	goxc -wlc -d=../site/downloads

The configuration file(s) feature is documented in much more detail in [the wiki](https://github.com/laher/goxc/wiki/config)

Github Releases

This is the good stuff, so let’s go from the top.

 * *First, install Go from source, and goxc. See ‘Installation’, above*

 * If you haven’t already, build toolchain (all platforms!). This takes a while.

goxc -t

 * Write a config file `.goxc.json` with info about your repo

goxc -wc default publish-github -owner=<username> 
goxc -wc default publish-github -repository=<reponame>
cat .goxc.json

 * Bump a version, to get a meaningful version number.

goxc bump

 * *Go to your github account and create a personal access token*


 * Write a local config file `.goxc.local.json` with your key info, ensuring that the key doesn’t end up in your git repo. See more about config files in [the wiki](https://github.com/laher/goxc/wiki/config)

goxc -wlc default publish-github -apikey=123456789012
echo ".goxc.local.json" >> .gitignore

*Note that you can put a dummy key into the commandline and edit the file later with the real key.*

 * Now, cross-compile, package and upload. All in one go.


There’s heaps of ways to reconfigure each task to get the outcome you really want, but this produces some pretty sensible defaults. Have fun.


 * Tested on Linux and Mac recently. Windows - some time ago now.
 * Currently goxc is only designed to build standalone Go apps without linked libraries. You can try but YMMV
 * The *API* is not considered stable yet, so please don't start embedding goxc method calls in your code yet - unless you 'Contact us' first! Then I can freeze some API details as required.
 * Bug: issue with config overriding. Empty strings do not currently override non-empty strings. e.g. `-pi=""` doesnt override the associated config setting PackageInfo


   Copyright 2013 Am Laher

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at


   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   See the License for the specific language governing permissions and
   limitations under the License.

See also
 * [Package Versioning](https://github.com/laher/goxc/wiki/versioning)
 * [Wiki home](https://github.com/laher/goxc/wiki)
 * [Contributions](https://github.com/laher/goxc/wiki/contributions)