igo installs multiple Go versions side by side in your home directory

What igo is

igo — short for "Install Go" — is a small command-line program written in Go that manages multiple installations of the Go runtime. It lives at github.com/andreimerlescu/igo, is MIT-licensed, and its latest release is v1.1.0.

The project's own README makes a pointed recommendation about how to install it: don't use go install. If Go is already on your system and you let igo manage that same installation, the reasoning goes, you can break your system configuration. Instead you download one of the prebuilt binaries from the GitHub release — for macOS Apple Silicon (igo-darwin-arm64), Intel Macs, Linux arm64 or Linux amd64 — drop it in ~/bin, and run it directly.

The tool is a deliberate re-implementation of andreiwashere/install-go, an older Bash script the author had used for years. igo folds that project's separate igo / sgo / rgo commands into single Go functions: install(), use() and uninstall().

What it does

igo installs each requested version of Go as a self-contained directory under your home folder, then makes one version "active" through symlinks. The default workspace is ~/go. Inside it you find stable names that point at the current toolchain:

• root — a symlink to versions/<version>/go, used for GOROOT
• bin — a symlink to versions/<version>/go/bin, used for GOBIN
• path — a symlink to versions/<version>, used for GOPATH

The actual per-version trees live under ~/go/versions. During install, igo downloads the official tarball from go.dev (https://go.dev/dl/go<version>.<goos>-<goarch>.tar.gz), extracts it into place, renames bin/go to go.<version> and gofmt to gofmt.<version>, then writes shell shims so the right binaries are found on your PATH. It also injects the Go environment variables (GOROOT, GOPATH, GOBIN, GOMODCACHE and friends) into ~/.zshrc or ~/.bashrc.

The command surface is a set of short flags:

| Flag | What it does | |------|--------------| | -i <version> | Install that Go version | | -u <version> | Uninstall that version | | -s <version> / -a <version> | Switch to (activate) an installed version | | -f <version> | Repair a broken installation's symlinks | | -l | List all installed versions in a table | | -e | Show the current Go environment and PATH | | -v / -version | Print igo's own version |

There are also options for where things go and how they build: -godir <path> overrides the workspace, -goos and -goarch set the target platform explicitly, and -system switches to /usr/go. Debug and verbose flags turn on extra logging.

Windows is not supported; main.go panics with a note pointing at Go's MSI installers instead.

How it is built

The repository is small — 35 files, about 16 MB including the bundled assets. The top level holds application.go, commands.go, data.go, version.go and main.go, plus an internal/ package with helpers for symlinks, file permissions and error handling.

Configuration parsing comes from figtree, which reads a ~/.igo.config.yml. Output uses the fatih/color library for colored terminal text and olekukonko/tablewriter to render the version list as an ASCII table — complete with a footer reading "I ❤ YOU! / Made In America / Be Inspired."

The Makefile cross-compiles four binaries (darwin-amd64, darwin-arm64, linux-amd64, linux-arm64) with stripped symbols, and the GitHub Actions workflow uploads them to each release. The version number is embedded at build time from a VERSION file via Go's embed package.

Testing through Docker

Development testing runs inside containers rather than on the host — fittingly, since igo itself exists so one machine can hold many Go versions without disturbing system state. A test.sh script drives docker build and docker run, executing a testing/tester.sh suite against a fresh image as an unprivileged tester user.

The Dockerfile builds the binary in a golang:1.26-bookworm stage, then copies it into a slim Debian runtime that also installs bump (a versioning tool from the same author) and a set of shell utilities. The test script exercises each command in sequence — checking the version banner, inspecting the environment, confirming an empty initial list, installing Go 1.24.2, then listing again to confirm it appears.

Who it is for

The README is explicit about scope: if you need Go installed as a system service, don't use igo. It is made for your $HOME environment running as a non-privileged user — no sudo, and multiple versions of Go on one box without touching the OS package manager. For developers who juggle toolchains across projects or test against several releases at once, that is exactly the niche it fills.

The project notes also frame igo partly as an exercise in test-driven development with automation: "Isn't it ironic that I'm using Go to write a Go installer?" The author describes building out a Docker-based TDD workflow they couldn't do natively. That explains the heavy testing scaffolding around what is otherwise a fairly focused utility.

Getting started

After downloading and making the binary executable, the flow is:

chmod +x ~/bin/igo && export PATH=~/bin:$PATH

# see installed versions (empty at first)
igo -l

# install Go 1.24.2 into your home workspace
igo -i 1.24.2

# switch to it when you need that toolchain
igo -s 1.24.2

A custom location and debug output work the same way:

igo -i 1.23.4 -godir /Shared/go -debug

The project is still on a short TODO list: packaging into yum (EPEL), apt, and Homebrew are all open items, so for now installation means pulling a release binary from GitHub.