How to Remove Packages Installed with go get in Go

By the end of this page, you will understand what go get used to install, where Go stores downloaded source code and compiled binaries, and how to safely remove packages from your Go workspace. You will also learn the difference between removing source code, cached modules, and installed executables, plus how this differs between older GOPATH workflows and modern Go modules.

In Go, go get has historically been used to download and install packages. The important part is that Go does not usually install third-party code into the Go compiler itself. Instead, it places files in specific workspace locations.

The exact behavior depends on which Go workflow you are using:

• Older GOPATH mode: packages are downloaded into your GOPATH/src, compiled package files may appear under GOPATH/pkg, and executables may be placed in GOPATH/bin.
• Modern module mode: dependencies are usually stored in the module cache, typically under GOPATH/pkg/mod, and command-line tools may still install binaries into GOPATH/bin or GOBIN.

This matters because removing a package means removing it from the correct location:

• Remove the source or module files if you no longer want the downloaded package.
• Remove the binary executable if go get or go install installed a command.
• Sometimes you may also want to clean Go's build or module cache.

A common beginner misunderstanding is thinking that go get modifies the core Go installation under GOROOT. Normally, third-party packages belong in your workspace or module cache, not in the standard library directory.

So the real question is not "How do I uninstall Go itself?" but rather "Which Go-managed files did this package create, and which of those do I want to remove?"

Think of Go's package system like a workshop with separate storage areas:

• GOROOT is the factory equipment. You usually do not touch it.
• GOPATH/src or the module cache is the storage shelf for downloaded parts.
• GOPATH/bin is the tool rack where runnable tools are placed.
• pkg and cache folders are the temporary workbench outputs.

If you downloaded the wrong tool, you do not throw away the whole workshop. You remove:

• the stored parts,
• the built tool,
• and maybe the temporary scraps.

That is how removing packages installed by go get works in practice.

Check your Go paths

Before deleting anything, inspect where Go is storing files:

go env GOPATH
go env GOROOT
go env GOBIN

This helps you avoid deleting files from the wrong place.

Typical old GOPATH locations

If you ran:

go get github.com/user/tool

Go may have created files in these locations:

$GOPATH/src/github.com/user/tool
$GOPATH/pkg/...               # compiled package files
$GOPATH/bin/tool              # executable, if the package builds a command

To remove them manually:

rm -rf "$GOPATH/src/github.com/user/tool"
rm -f "$GOPATH/bin/tool"

You can also clear compiled package data with:

go clean -i github.com/user/tool

Modern module-related cleanup

If the package was downloaded into the module cache, you can clean unused downloaded modules with:

go clean -modcache

Be careful: this removes the entire module cache, not just one package.

Example

Suppose you ran:

go get github.com/rakyll/hey

Now you want to remove it.

Step 1: Find your workspace

Run:

go env GOPATH

Assume it returns:

/home/alex/go

Step 2: Check whether a binary was installed

Look in:

/home/alex/go/bin

If you see a file named hey, remove it:

rm -f /home/alex/go/bin/hey

Step 3: Remove the downloaded source or package files

In older GOPATH mode, the source code may be here:

/home/alex/go/src/github.com/rakyll/hey

Remove it:

rm -rf /home/alex/go/src/github.com/rakyll/hey

Step 4: Remove compiled artifacts if needed

Run:

Developers remove Go packages for several practical reasons:

• Cleaning a mistaken install: you installed a package before setting GOPATH or GOBIN correctly.
• Removing old CLI tools: a tool was installed globally and you no longer use it.
• Resetting a broken environment: cached modules or compiled artifacts are causing confusing behavior.
• Keeping development environments reproducible: you want dependencies defined in go.mod, not installed ad hoc.
• Freeing disk space: the module cache can become large over time.

Examples:

• A developer accidentally installs a CLI tool into the default workspace and wants it removed.
• A CI machine needs a clean module cache before rebuilding dependencies.
• A team standardizes on go install module@version and removes older binaries installed with go get.
• A local machine has stale package data after switching Go versions.

In real Go projects, developers usually avoid manually installing library dependencies globally. Instead, they use these patterns:

Module-managed dependencies

Inside a project with go.mod, dependencies are tracked in files rather than manually managed in GOPATH:

go mod tidy

This removes unused dependencies from go.mod and go.sum, though it does not directly delete all cached module files.

Installing tools explicitly

Modern Go commonly uses:

go install example.com/cmd/tool@latest

This makes it clearer that you are installing a binary tool, not adding a library dependency to a project.

Environment inspection and guard checks

Developers often verify paths before deleting anything:

go env GOPATH GOBIN GOROOT

This acts like a guard clause for shell operations: check first, then delete.

Cleaning caches during troubleshooting

Common cleanup commands include:

go clean -cache
go clean -modcache
go clean -testcache

These are often used when builds behave unexpectedly.

1. Confusing GOROOT with GOPATH

A very common mistake is assuming third-party packages are installed into the Go standard library.

• GOROOT = where Go itself is installed
• GOPATH = your workspace for user-downloaded packages in older workflows

Do not delete random directories from GOROOT unless you are intentionally uninstalling or repairing Go itself.

2. Deleting the wrong thing

Broken approach:

rm -rf /usr/local/go

This removes the Go installation, not just one downloaded package.

Safer approach:

go env GOPATH
rm -rf "$GOPATH/src/github.com/user/package"

3. Forgetting about binaries

A package may be gone from source storage, but its executable may still remain in bin.

Example:

rm -rf "/src/github.com/user/tool"

Related cleanup targets

Quick reference

Check paths

go env GOPATH GOROOT GOBIN

Old GOPATH cleanup

Remove downloaded source:

rm -rf "$GOPATH/src/github.com/user/package"

Remove installed binary:

rm -f "$GOPATH/bin/package"

Remove compiled artifacts:

go clean -i github.com/user/package

Module/cache cleanup

Remove build cache:

go clean -cache

Remove test cache:

go clean -testcache

Remove module cache:

go clean -modcache

Important rules

• Third-party packages are usually not part of GOROOT.

How do I uninstall a Go package installed with go get?

Usually by deleting the downloaded package directory from your workspace and removing any installed binary from GOPATH/bin or GOBIN.

Does go get install packages into GOROOT?

Normally, no. Third-party packages are typically stored in GOPATH or the module cache, not inside the core Go installation.

How do I remove an installed Go command-line tool?

Delete its executable from $(go env GOPATH)/bin or from GOBIN if that variable is set.

What does go clean -modcache do?

It removes the entire downloaded module cache. Use it when you want a full dependency cache reset, not just one package removed.

What is the difference between removing a package and removing a binary?

Removing a package deletes source or cached dependency files. Removing a binary deletes the runnable executable. Sometimes you need to do both.

Should I delete files from GOROOT to clean up third-party packages?

No. Deleting files from GOROOT can damage your Go installation. Check GOPATH and first.

GOPATH

The older Go workspace system. It determines where source code, packages, and binaries are stored.

GOROOT

The location of the Go installation itself. It helps clarify what should usually not be deleted.

Go modules

The modern dependency management system in Go. It changes how packages are downloaded and tracked.

go install

The preferred modern command for installing Go tools as executables.

go clean

Used to remove build artifacts, caches, and some installed package data.

go mod tidy

Helps remove unused module requirements from a project's dependency files.

GOBIN

Controls where Go installs executable binaries, which matters when removing installed tools.