GitHub - Teamwork/reload: Lightweight automatic reloading of Go processes.

Lightweight automatic reloading of Go processes.

After initialisation with reload.Do() any changes to the binary (and only the binary) will restart the process. For example:

func main() {
    go func() {
        err := reload.Do(log.Printf)
        if err != nil {
            panic(err) // Only returns initialisation errors.
        }
    }()

    fmt.Println(os.Args)
    fmt.Println(os.Environ())
    ch := make(chan bool)
    <-ch
}

Now use go install or go build to restart the process.

Additional directories can be watched using reload.Dir(); this is useful for reloading templates:

func main() {
    go func() {
        err := reload.Do(log.Printf, reload.Dir("tpl", reloadTpl))
        if err != nil {
            panic(err)
        }
    }()
}

You can also use reload.Exec() to manually restart your process without calling reload.Do().

This is an alternative to the "restart binary after any *.go file changed"-strategy that some other projects – such as gin or go-watcher – take. The advantage of reload's approach is that you have a more control over when the process restarts, and it only watches a single directory for changes which has some performance benefits, especially when used over NFS or Docker with a large number of files.

It also means you won't start a whole bunch of builds if you update 20 files in a quick succession. On a desktop this probably isn't a huge deal, but on a laptop it'll save some battery power.

Because it's in-process you can also do things like reloading just templates instead of recompiling/restarting everything.

Caveat: the old process will continue running happily if go install has a compile error, so if you missed any compile errors due to switching the window too soon you may get confused.