How To Fix “Failed to Build Gem Native Extension” Error

When installing Ruby gems with native extensions, you may encounter an error like:

Failed to build gem native extension.

This occurs when the gem installation process fails to compile the C/C++ extension for your environment.

In this comprehensive guide, I’ll explain the causes of this Ruby gem installation error and provide troubleshooting steps to resolve build failures on Linux, macOS and Windows.

Let’s start by understanding what Ruby gem native extensions are and why builds can fail.

Understanding Ruby Gem Native Extensions

Ruby gems provide reusable packages of Ruby code and functionality. Some gems only contain pure Ruby code.

But many gems also have compiled native extensions written in C/C++ for performance gains and system integrations.

When you install one of these gems, RubyGems runs a compilation step first to build the native extension before packaging the complete gem.

If this compilation fails, you’ll see the generic “Failed to build gem native extension” error.

Next, let’s explore some specific reasons this build can fail.

Why the Failure Happens

There are a few common reasons gem native extension compilation fails during gem install:

  • Missing build tools and compilers like gcc, make, rake
  • Uninstalled libraries or headers like OpenSSL, libyaml, Python headers
  • Incompatible Ruby or gem versions
  • Improper rbenv, RVM or chruby usage
  • File permission problems
  • Buggy extensions in the gem code itself
  • User environment issues

Many dependencies must be installed and configured properly for building native extensions. Next we’ll go through how to check for these dependencies.

Checking Ruby Build Tools

Make sure fundamental build tools like gcc and make are installed:

# Ubuntu/Debian 
sudo apt-get install build-essential

# Fedora
sudo dnf groupinstall "Development Tools" 

# macOS
xcode-select --install

Also confirm rake is available for extconf builds:

gem install rake

With these basic tools present, you can compile most extensions.

Installing Build Dependencies

Many gems depend on specific libraries being installed for compilation.

For example, mysql2 may require:

sudo apt-get install libmysqlclient-dev

And nokogiri needs libxml2 development headers present.

Consult the gem documentation to see which libraries are required. Installing them with the system package manager will fix missing dependency errors.

Using rbenv and RVM Properly

rbenv and RVM provide isolated Ruby environments, but can complicate native extensions if used improperly:

  • Always install build tools and libraries at the system level, not within rbenv/RVM.
  • Make sure RVM/rbenv Ruby installs and gems are fully compatible.
  • Use the latest rbenv/RVM stable release and reinstall if needed.
  • Run rbenv rehash after installing new libraries.

Proper rbenv/RVM usage prevents many gem extension issues.

Checking Gemfile for Native Gems

If bundler installation fails, your Gemfile may specify gems with incompatible native extensions.

Inspect the output to see which gem is causing issues. Then check its documentation for dependencies.

You may need to modify your Gemfile to use alternate gems or loosen version constraints.

Upgrading RubyGems

An outdated RubyGems version can cause installation failures.

Upgrade to the latest RubyGems before installing gems:

gem update --system

Use the latest stable RubyGems for best results with gem builds.

Setting Gem Build Configuration

You can configure build arguments in a .gemrc file:

build_args: --with-cflags -O3

Or set variables before install:

export CFLAGS="-O3"
gem install mysql2

See build documentation for the specific gem to troubleshoot options.

Fixing File Permission Issues

If Ruby cannot write to directories during compilation, builds may fail.

Make sure your user account has permissions to:

  • The gem installation directory
  • The Ruby install directory
  • Any dependency directories like /usr/local/lib

Use sudo if necessary to install gems.

Cleaning up Failed Installs

Partially installed or corrupted gems can prevent installing properly.

Use gem cleanup to remove failed gem installations and stale files:

gem cleanup mysql2

Then try reinstalling the gem.

Reinstalling Libraries and Dependencies

If fixing permissions, upgrading tools, and cleaning up stale gems doesn’t resolve the issue, try completely reinstalling dependencies:

# Uninstall libraries
sudo apt-get remove libmysqlclient-dev 

# Reinstall dependencies fully 
sudo apt-get install libmysqlclient-dev

# Reinstall build tools fully
sudo apt-get install --reinstall build-essential

Reinstalling from scratch clears up any inconsistencies.

Using –conservative Flag

Some gem build issues only occur with compiler optimizations like -O3.

Use the --conservative flag which avoids optimizations and may resolve certain compilation issues:

gem install mysql2 -- --conservative

However, this disables optimizations so performance may decrease.

Switching to Ruby Version Managers

If fixing the system Ruby fails, try switching to rbenv or RVM instead:

# Install rbenv 
rbenv install 2.7.0
rbenv global 2.7.0

# Use rbenv Ruby for gems
rbenv exec gem install mysql2

A pristine Ruby environment often resolves difficult native extension problems.

Troubleshooting on Windows

On Windows, you may need to install a compiler toolchain like MSYS2 before native gem installations succeed.

Key steps include:

  1. Install MSYS2 and follow the setup instructions.
  2. Close and reopen any command shells to inherit new environment.
  3. Run ridk install to add missing development kit tools.
  4. Use gem install mysql2 and confirm it installs properly now.

This is often necessary for WINDOWS-based gems with native extensions.

Rerunning Gem Installation

After resolving any dependencies or configuration issues, rerun:

gem install GEMNAME

Hopefully the native extension builds successfully now.

If not, it may point to an underlying bug in the gem’s extension code itself.

Reporting Bugs to Gem Authors

If you are still unable to build a gem’s native extension after thoroughly troubleshooting your environment, the issue likely lies in the gem’s extension code itself.

You can report a bug to the gem developers providing:

  • Your Ruby, gem, and dependency versions
  • The full installation error output
  • Details on troubleshooting steps attempted

This will help them identify flaws in the gem’s native compiling process.

Preventing Extension Build Failures

Here are some tips to avoid gem native extension installation failures:

  • Maintain consistent Ruby and dev tools versions across environments.
  • Periodically update RubyGems and check for outdated gems.
  • Use .gemrc configuration files to standardize build arguments.
  • Test gems locally before deploying to servers.
  • Follow a change management process before updating Ruby versions.
  • Consider using Docker containers to encapsulate dependencies.

Carefully managing Ruby and gem versions will prevent many extension build problems.


Failed Ruby gem native extension builds are often caused by missing compilers, outdated tools/libraries, or dependency conflicts.

Following a methodical troubleshooting approach of validating configurations, installing missing components, removing stale artifacts, reinstalling dependencies, and reporting build bugs can resolve many “Failed to build gem native extension” errors.

Preventing issues comes down to proper management of Ruby environments, dependencies, and gems across deployments.

Consistently following Ruby best practices will help avoid painful gem native extension build failures.

Let me know if you have any other tips for troubleshooting failed gem installations!

Leave a Comment