Skip to content
Simple go version manager, gluten-free
Shell
Branch: master
Clone or download
stefanmaric 0.6.0
- Make g POSIX compatible and use `sh` instead of `bash`
- Cleanup and normalize `g` code
- Make g-install POSIX compatible as well
- Fix g-install breaking on envs without $SHELL
- Fix g breaking when using non-GNU `wget`
- Add handling of misconfigured $GOPATH/bin
- Add support for ash, dash, csh, and tcsh to g-install
- Fix user input source for g-install
- Fix and normalize error logging
- Fix POSIX syntax error on BIN_DIR check
- Fix `stty` command breaking on MacOS
- Fix version listing broken with BSD version of `find`
- Fix IFs using `command` exiting the script due to errexit
- Update docs to reflect latest changes and update roadmap
Latest commit 9740b5c Oct 13, 2019
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
bin 0.6.0 Oct 13, 2019
.editorconfig Initial release 0.1.0 Apr 8, 2018
CHANGELOG.md 0.6.0 Oct 13, 2019
CODE_OF_CONDUCT.md Create CODE_OF_CONDUCT.md May 26, 2019
CONTRIBUTING.md Initial release 0.1.0 Apr 8, 2018
LICENSE Create LICENSE Apr 8, 2018
README.md Update docs to reflect latest changes and update roadmap Oct 13, 2019
screencast.gif Add screencast to show off Apr 22, 2018

README.md

g

Simple go version manager, gluten-free.

license

screencast

Why?

Existing version managers build go from source, have too many dependencies, pollute the PATH, and/or require you to use a specific shell environment. g aims to be as unobtrusive and portable as possible.

g is inspired by tj/n - which I have contributed to in the past - and borrows some of its code.

Features

  • Works no matter what shell you use as long as $GOPATH and $GOROOT are exported, which are not specific to g but idiomatic to go.
  • No need to source functions in your shell config.
  • Single shell script that ideally lives where your go binaries live.
  • Downloads pre-built binaries so it is fast and...
  • ...requires no git, no mercurial, no gcc, no xcode, etc.
  • curl and wget first-class support alike.
  • Colorful UI and interactive but safe to pipe and use in automated scripts.
  • self-upgrade command to keep up-to-date
  • Get started with a single line.

Requirements

Not strictly necessary, but highly recommended, to completely remove any previous go installation — just to prevent any weird outcome.

Single-line Installation

IMPORTANT: Before you continue, I encourage you to read the install script; never trust someone telling you to run random commands.

That said, you can install g with a single command:

curl -sSL https://git.io/g-install | sh -s

If you use wget instead:

wget -qO- https://git.io/g-install | sh -s

That will download the g script, put it inside $GOPATH/bin/, give it execution rights with chmod, and configure your default shell's initialization file, setting the GOPATH & GOROOT environment variables and adding $GOPATH/bin to the PATH.

Then you will prompted to install the latest version of go; you can skip this step and install your preferred version with g later.

NOTE: You must restart your current shell session for it to read these new env vars in order to use g or go.

Shell support

The install script currently supports the following shells:

  • bash
  • zsh
  • fish
  • ash
  • dash
  • csh
  • tcsh

That doesn't mean you cannot use g with other shells like tcsh, just proceed with the manual installation.

The install script is going to select your default shell for configuration. You might see what your default shell is by running:

echo $SHELL

If you wish to configure a diff shell, you might pass it as arguments:

curl -sSL https://git.io/g-install | sh -s -- fish

You might as well configure several shells, but that's usually not required:

curl -sSL https://git.io/g-install | sh -s -- fish bash zsh

Changing defaults

By default, these go environment variables are used:

GOROOT: $HOME/.go
GOPATH: $HOME/go

$GOPATH/bin is added to the PATH and there's where g is copied to.

You might set those variables before running the install script. For example, in bash and zsh:

export GOROOT=~/.local/share/golang
export GOPATH=~/MyProjects/go-projects
curl -sSL https://git.io/g-install | sh -s

In fish:

set -gx GOROOT ~/.local/share/golang
set -gx GOPATH ~/MyProjects/go-projects
curl -sSL https://git.io/g-install | sh -s

Manual Installation

  1. Make sure to export the $GOPATH & $GOROOT environment variables and add $GOPATH/bin to your PATH.
  2. Grab a copy of the ./bin/g script and put it anywhere available in your PATH — inside $GOPATH/bin/ is a good option.
  3. Give the script execution rights with chmod +x $GOPATH/bin/g.
  4. Restart your shell session to make sure the env variables are loaded.

Upgrading

g includes a self-upgrade command you can run to get the latest version of g. This command simply runs the install script once again.

Usage

  Usage: g [COMMAND] [options] [args]

  Commands:

    g                           Open interactive UI with installed versions
    g install <version>         Install go <version>
    g install latest            Install or activate the latest go release
    g install -a 386 latest     Force 32 bit architecture
    g install -o darwin latest  Override operating system
    g run <version>             Run a given version of go
    g which <version>           Output bin path for <version>
    g remove <version ...>      Remove the given version(s)
    g prune                     Remove all versions except the current version
    g list                      Output installed go versions
    g list-all                  Output all available go versions
    g self-upgrade              Upgrades g to the latest version
    g help                      Display help information, same as g --help

  Options:

    -h, --help              Display help information and exit
    -v, --version           Output current version of g and exit
    -q, --quiet             Disable curl output (if available)
    -d, --download          Download only
    -c, --no-color          Force disabled color output
    -y, --non-interactive   Prevent prompts
    -o, --os                Override operating system
    -a, --arch              Override system architecture
    -u, --unstable          Include unstable versions in list

Uninstall

g is a single portable shell script that acts like a binary that's available in your $PATH. If you setup g with the install script, its removal should be pretty straight forward.

First of all, get some info about your system:

echo $SHELL
echo $GOROOT
echo $GOPATH
command -v g

You will notice the g file lives inside your $GOPATH/bin/ directory. If you only want to remove g and keep your currently installed go binaries and related files, simply delete g:

# If you're using bash, zsh, or other POSIX shell:
rm "$(command -v g)"

# If you're using fish:
rm (command -v g)

Now, if you want to remove everything, first be sure to backup your projects inside $GOROOT, if any. Then remove everything inside $GOROOT and $GOPATH:

rm -r $GOPATH $GOROOT

Then open your shell config file with your text editor of choice and look of for a line that includes g-install to remove it. These are the locations usually used by the install script:

# bash on MacOS
~/.bash_profile

# bash on linux/BSD
~/.bashrc

# zsh
~/.zshrc

# fish shell
~/.config/fish/config.fish

# csh
~/.cshrc

# tcsh
~/.tcshrc

# For ash for dash, check your $ENV var
echo $ENV

At this point you would have removed g and go entirely.

TODO

  • Improve docs a bit more
  • Make g and g-install POSIX compliant
  • Add support for more shells
  • Warn users they already have a golang installation when using g-install
  • Use better naming for g install <version>, maybe use or set. See #8
    • Use install only for install and remove the --download option
  • Handle the case when g already exists, mainly zsh with oh-my-zsh
    • Make it so g-install offers the user to setup an alternative alias for g
  • Make the self-upgrade command throw if g was not installed in the common way
  • Add a complete command that generates completions for the supported shells
    • And have g-install setup the shells to call this command for completions
  • Explore feature to configure shells to autoload go versions based on a project file
  • Test it on diff platforms
  • Crete a test setup with docker and Github actions

The alternatives (and why I prefer g)

  • moovweb/gvm
    • Too many features.
    • Builds from source, i.e, requires gcc, make, xcode, etc.
    • Requires git and mercurial.
    • Requires bootstrapping, i.e., install go 1.4 first.
    • Specific to a shell, i.e., doesn't work with fishshell.
  • syndbg/goenv
    • Too many features and weird DX.
    • Uses an hard-coded list of go versions...
    • ...thus you have to upgrade goenv before installing a new version of go.
    • Adds a lot to your env and PATH.
  • hit9/oo
    • Pretty much same as gvm.
  • asdf-golang
  • andrewkroh/gvm
    • Bash, batch and powershell support only.
    • Cumbersome to use.
  • MakeNowJust/govm
    • Builds from source.
    • Requires python 2.

Contributing

Please read CONTRIBUTING.md. ♥

Acknowledgments

License

MIT

You can’t perform that action at this time.