The workshop is closed
You installed Rust six months ago to build a CLI tool. The tool is done. The cargo command is still hanging around in your PATH, and rustup is quietly downloading updates in the background. Or maybe you tried the official installer, realized your company mandates apt or brew, and now you have two conflicting Rust installations fighting over the same binaries. You need to wipe the slate clean.
Removing Rust is not like deleting a single application file. Rust's standard installation uses a toolchain manager called rustup. This manager controls the compiler, the build tool, the package registry, and a cache of downloaded crates. Uninstalling Rust means removing the manager, the tools it controls, the cached data, and the environment variables that tell your shell where to find everything.
What rustup actually installs
When you run the official installer, rustup sets up a directory structure in your home folder. On Unix-like systems, this is ~/.rustup and ~/.cargo. On Windows, it is %USERPROFILE%\.rustup and %USERPROFILE%\.cargo.
The ~/.rustup directory holds the toolchains. Each toolchain is a snapshot of the Rust compiler and standard library for a specific version. If you have stable, beta, and nightly installed, they all live here. This directory also contains settings.toml, which tracks your default toolchain and other preferences.
The ~/.cargo directory holds the cargo registry and the binary directory. The registry caches every crate you have ever downloaded. This cache can grow to several gigabytes over time. The bin subdirectory contains the symlinks or wrappers for cargo, rustc, rustup, and other tools. Your shell's PATH points here so you can run these commands from anywhere.
rustup also modifies your shell configuration files. It adds lines to .bashrc, .zshrc, or .profile that set environment variables like CARGO_HOME and RUSTUP_HOME, and it ensures the cargo bin directory is on your PATH. Some older installations source a helper script from ~/.cargo/env. Newer installations patch the shell config directly.
Rust is more than a compiler. It is a managed ecosystem. Removing it means removing the manager, the tools, and the cache.
The uninstall command
The official way to remove Rust is to invoke the uninstaller built into rustup. This script knows exactly where the files are and how to clean up the environment.
# Invoke the rustup binary to remove itself and all managed toolchains.
# This command prompts for confirmation before deleting files.
rustup self uninstall
The command asks for confirmation. It lists the directories it will remove. If you confirm, it deletes the toolchains, the registry, the binaries, and attempts to remove the environment variable lines from your shell configuration.
Run the command. Confirm the deletion. Do not skip the verification step.
What happens behind the scenes
When rustup self uninstall runs, it performs a sequence of cleanup operations. First, it locates the ~/.rustup directory. It iterates through every installed toolchain and removes the compiler binaries and standard library files. It deletes the settings.toml file.
Next, it targets ~/.cargo. It removes the registry directory, which frees up the cached crates. It removes the bin directory, which removes the command wrappers. If you have built projects that left artifacts in ~/.cargo, those are also removed.
The uninstaller then scans your shell configuration files. It looks for lines that reference cargo or rustup. It removes lines that export PATH with ~/.cargo/bin. It removes lines that source ~/.cargo/env. It removes lines that set CARGO_HOME or RUSTUP_HOME. The exact behavior depends on your shell. Bash and Zsh are well supported. Fish and PowerShell have their own handling.
On Windows, the uninstaller removes the directories in %USERPROFILE%. It also attempts to remove environment variables from the user environment block. This requires administrative privileges in some cases, or it may only remove variables for the current user.
The uninstaller handles the heavy lifting. Your job is to check for leftovers.
Cleaning up the remnants
The uninstaller is thorough, but it is not perfect. Shell configuration files can contain custom modifications that the script does not recognize. If you manually edited your .zshrc to add Rust paths, the uninstaller will not remove those lines. If you have multiple shell configs, the script might only patch the one it detects.
After the uninstaller finishes, open your shell configuration files. Search for cargo, rustup, RUSTUP_HOME, and CARGO_HOME. Delete any lines that reference these. Restart your terminal to reload the config.
# Check for residual environment variables in the current session.
# These variables should be empty or unset after a clean uninstall.
echo $CARGO_HOME
echo $RUSTUP_HOME
# Verify the binaries are gone.
# A clean uninstall returns "command not found" or similar.
which rustc
which cargo
which rustup
On Windows, open the System Properties dialog. Navigate to Environment Variables. Check the User variables for CARGO_HOME and RUSTUP_HOME. Remove them if they exist. Check the Path variable for entries pointing to %USERPROFILE%\.cargo\bin. Remove those entries.
Ghost environment variables cause subtle bugs. Hunt them down.
Pitfalls and edge cases
The most common pitfall is mixing installation methods. If you installed Rust via rustup and also installed a package via apt or brew, you have two independent Rust installations. Running rustup self uninstall removes the rustup installation. It does not touch the package manager installation. You will still have rustc and cargo available, but they will be managed by the system package manager.
If you try to run rustup self uninstall and get command not found, you likely never installed rustup. You might have installed Rust via a package manager, or the binaries were deleted manually. In this case, you need to use the package manager to remove Rust, or manually delete the directories.
Another pitfall is the cargo registry cache. If you uninstall Rust and then reinstall it, the registry cache is gone. You will need to download all your dependencies again. This can slow down your first build after reinstalling. If you plan to reinstall soon, you can back up ~/.cargo/registry before uninstalling. Restore it after reinstalling to skip the download step.
Some users keep ~/.cargo to preserve the registry cache while removing the toolchains. This is not recommended. The registry format can change between versions. Keeping an old cache can lead to corruption or compatibility issues. A clean uninstall removes everything.
Package managers and rustup are strangers. They do not talk to each other.
Choosing the right removal method
The removal method depends entirely on how you installed Rust. Using the wrong method leaves debris or fails to remove anything.
Use rustup self uninstall when you installed Rust via the official installer or the rustup toolchain manager. This handles the toolchain cache, the cargo registry, and attempts to clean environment variables.
Use your system package manager when you installed Rust via apt, yum, pacman, or brew. The package manager owns the binaries and configuration paths, so rustup commands will not exist or will not affect the system installation. Run apt remove rustc cargo or brew uninstall rust to remove the package.
Use manual directory deletion only as a last resort when the uninstaller is missing or corrupted. This requires you to track down every path and environment variable yourself, which is error-prone. Delete ~/.rustup, ~/.cargo, and clean your shell configs.
Use rustup toolchain uninstall when you want to remove a specific version of Rust but keep the toolchain manager and other versions. This is useful for freeing disk space without losing your build environment. Run rustup toolchain uninstall nightly to remove only the nightly toolchain.
Match the removal method to the installation method. Mixing them leaves debris.