How to Find Where Ruby Gems Are Installed

By the end of this page, you will understand how RubyGems decides where gems are stored, how to inspect the current gem installation paths, how to find the directory for a specific installed gem, and how environment settings such as user installs, Ruby version managers, and custom gem homes affect gem locations.

Ruby gems are packages of Ruby code that RubyGems installs into one or more directories on your system. The key idea behind this question is gem path resolution: RubyGems uses configuration and environment settings to decide where gems are stored and where Ruby looks for them.

A few important parts are involved:

• System gem directory: a shared location tied to a Ruby installation
• User gem directory: a per-user location, often used when you do not have system write access
• GEM_HOME: the main directory where new gems are installed
• GEM_PATH: the list of directories Ruby searches for installed gems
• Ruby version managers: tools like rbenv, rvm, or chruby can change gem locations by switching Ruby installations

This matters because in real development you often need to:

• inspect gem source files
• debug version conflicts
• understand why a gem command is not found
• know whether a gem was installed globally or only for one user
• verify where CI, Docker, or deployment environments install dependencies

RubyGems provides commands to inspect these locations. Instead of only asking “Is this gem installed?”, you often need to ask:

• Where is Ruby installing gems right now?
• Which gem directories is Ruby searching?
• Where is one specific gem located?

Understanding those questions makes Ruby environments much easier to troubleshoot.

Think of Ruby gems like books in a library system.

• gem install is like adding a new book.
• GEM_HOME is the main shelf where new books are placed.
• GEM_PATH is the list of shelves Ruby checks when looking for a book.
• gem list tells you which books exist, but not exactly which shelf each one is on.
• gem env is the librarian report that tells you where the shelves are.

So if you want the exact location of a gem, you need to inspect the shelf information, not just the catalog of titles.

To inspect gem installation paths, RubyGems provides a few useful commands.

Show the full RubyGems environment

gem env

This prints details such as:

• RubyGems version
• Ruby version
• installation directory
• user installation directory
• gem search paths
• executable directory

Show the main gem installation directory

gem env home

Example output:

/Users/alex/.gem/ruby/3.2.0

This is typically where new gems will be installed for the current setup.

Show all gem search paths

gem env path

Example output:

/Users/alex/.gem/ruby/3.2.0:/usr/local/lib/ruby/gems/3.2.0

Ruby will search these directories for installed gems.

Find the directory of a specific gem from Ruby

ruby -e 'puts Gem::Specification.find_by_name("rake").gem_dir'

Example output:

Consider this command:

ruby -e 'puts Gem::Specification.find_by_name("rake").gem_dir'

Here is what happens step by step:

1. ruby -e runs a short Ruby script directly from the command line.
2. Gem::Specification accesses RubyGems metadata about installed gems.
3. find_by_name("rake") searches for the installed gem named rake.
4. It returns the gem specification object for that gem.
5. .gem_dir asks that object for the directory where the gem is installed.
6. puts prints that path.

For example, if the output is:

/Users/alex/.gem/ruby/3.2.0/gems/rake-13.1.0

then:

• the gem name is rake
• the installed version is 13.1.0
• the gem lives inside the gems subdirectory of your gem home

Now compare that with:

gem env home

If this prints:

Knowing gem installation paths is useful in many practical situations.

Debugging a gem issue

If a gem behaves unexpectedly, you may want to open its source code:

ruby -e 'puts Gem::Specification.find_by_name("rails").gem_dir'

Then inspect the files directly.

Fixing PATH or executable issues

A gem may install a command like rubocop or bundler, but your shell cannot find it. In that case, inspect:

• the gem installation directory
• the executable directory from gem env
• your shell PATH

Understanding user vs system installs

On a machine with limited permissions, gems may install into a user directory instead of a system directory. This helps explain why one user can access a gem while another cannot.

Working in CI, containers, or servers

In Docker images or CI pipelines, it is common to verify exactly where dependencies were installed, especially when caching gem directories.

Using multiple Ruby versions

If you switch between Ruby versions, each one often has its own gem set. Checking gem env helps confirm which environment you are actually using.

In real projects, developers rarely guess gem locations. They inspect the environment and rely on repeatable patterns.

Common patterns

Environment inspection

Before troubleshooting, developers often run:

gem env
ruby -v
which ruby
which gem

This confirms which Ruby installation and RubyGems executable are active.

Guarding against the wrong Ruby

A common issue is having multiple Rubies installed. A project may work in one shell but fail in another because gem belongs to a different Ruby. Checking which ruby and which gem is a simple guard clause before deeper debugging.

Bundler-managed dependencies

In real applications, gems are often installed through Bundler rather than plain gem install. Even then, understanding gem paths helps when:

• debugging native extension builds
• locating cached dependencies
• verifying deployment paths
• diagnosing lockfile and environment mismatches

Configuration-driven installs

Teams may set:

• GEM_HOME
• GEM_PATH
• Bundler path settings
• Ruby version manager configuration

Beginners often run into a few predictable issues.

Mistake 1: Assuming gem list shows file locations

gem list

This only lists installed gems and versions. It does not tell you their directories.

Better approach

Use:

gem env

or for one gem:

ruby -e 'puts Gem::Specification.find_by_name("rake").gem_dir'

Mistake 2: Confusing gem directory with executable directory

A gem's Ruby files may be in one place, while its executable scripts are linked or stored in another.

Check both

gem env home
gem env | grep "EXECUTABLE DIRECTORY"

Mistake 3: Forgetting about multiple Ruby installations

Broken assumption:

gem env home

You may think this is the only gem location on your machine, but if you switch Ruby versions, the result can change.

Avoid it

Also inspect:

Here is a quick comparison of related RubyGems commands and concepts.

# Show full RubyGems environment
gem env

# Show main gem install directory
gem env home

# Show all gem search paths
gem env path

# Find exact directory of one installed gem
ruby -e 'puts Gem::Specification.find_by_name("rake").gem_dir'

# Check which Ruby and gem are active
which ruby
which gem
ruby -v

# Check environment overrides
echo $GEM_HOME
echo $GEM_PATH

Rules to remember

• gem list shows names and versions, not install directories.
• gem env home usually tells you where new gems will be installed.
• gem env path shows every directory RubyGems searches.
• A specific gem folder is usually inside GEM_HOME/gems/gem-name-version.
• Different Ruby versions often have different gem directories.
• sudo, version managers, and environment variables can change install location.

Common path pattern

<gem-home>/gems/<gem-name>-<version>

Example:

How do I find the folder for a specific installed gem?

Use RubyGems metadata:

ruby -e 'puts Gem::Specification.find_by_name("rake").gem_dir'

How can I see where Ruby will install gems before installing one?

Run:

gem env home

This usually shows the main target directory for new gem installations.

Why does my gem install to a different location than expected?

Common reasons include:

• a different active Ruby version
• GEM_HOME or GEM_PATH being set
• using sudo
• using a Ruby version manager
• using a user install instead of a system install

What is the difference between GEM_HOME and GEM_PATH?

• GEM_HOME is the primary install directory.
• GEM_PATH is the list of directories searched for gems.

Does gem list show where gems are installed?

No. It only shows gem names and versions.

• RubyGems environment: directly related because it controls gem installation and lookup paths.
• GEM_HOME: important for understanding the primary install directory.
• GEM_PATH: important for understanding how Ruby searches for gems.
• Bundler: commonly used to manage project dependencies and interacts with gem locations.
• Ruby version managers: tools like rbenv or RVM change which Ruby and gem directories are active.
• PATH environment variable: relevant when gem executables are installed but commands are not found.
• Ruby executable lookup: helps explain why which ruby and which gem matter.
• Environment variables: useful because configuration often changes install behavior.