Ruby exec vs system vs backticks (%x): Differences, Return Values, and When to Use Each

By the end of this page, you will understand how Ruby runs external commands using exec, system, and backticks (%x()), and why they behave differently. You will learn which one replaces the current process, which one returns a success value, which one captures command output, and how to choose the right tool for real programs.

Ruby gives you multiple ways to run external commands because programs often need different kinds of behavior.

At first glance, exec, system, and backticks all seem similar because they all run a shell command. But they answer different needs:

• exec: replace the current Ruby process with another program
• system: run a command and wait for it to finish, returning whether it succeeded
• backticks / %x(): run a command and capture its standard output as a string

These differences matter because when you run another program, you usually care about one or more of these questions:

• Should Ruby continue running afterward?
• Do I need the command's output?
• Do I only care whether it succeeded?
• Do I want to fully hand control over to another executable?

exec

exec does not start a child process and then return to Ruby in the usual way. Instead, it replaces the current Ruby process with the target command.

That means:

• Ruby code after exec will not run if exec succeeds
• The operating system process becomes the new program
• This is useful when Ruby is only acting as a launcher

system

system runs a command, waits for it to finish, and returns:

Think of Ruby as a person sending work to another worker.

• exec is like Ruby taking off its badge and letting the other worker take its place completely. Ruby is gone.
• system is like Ruby asking another worker to do a job, waiting for the result, and hearing only whether it succeeded or failed.
• backticks / %x() are like Ruby asking another worker to do a job and bring back a written report of the output.

So the main question is:

Do you want to replace yourself, check success, or capture output?

That choice determines which tool to use.

Core syntax

exec("ls")
system("ls")
output = `ls`
output = %x(ls)

Example: system

success = system("mkdir test_folder")
puts success

If the command succeeds, success will usually be true.

Example: backticks

files = `ls`
puts files

Here, the command output is stored in files as a string.

Example: exec

puts "Before exec"
exec("ls")
puts "After exec"

If exec succeeds:

• Before exec is printed
• ls runs

Consider this example:

puts "Start"
result = system("ruby -e 'puts 1 + 1'")
puts "Command success: #{result}"
puts "Exit status: #{$?.exitstatus}"
puts "End"

Step by step

1. Ruby prints:

   Start
   

2. Ruby runs this external command:

   ruby -e 'puts 1 + 1'
   

3. That external Ruby process prints:

   2
   

4. The command finishes successfully.

5. system(...) returns true, so result becomes true.

6. $?.exitstatus is usually 0, which means success.

7. Ruby prints:

When to use exec

Use exec when your Ruby program is only a wrapper that should hand control to another program.

Examples:

• launching another executable from a setup script
• replacing the current process in deployment scripts
• starting a server process from a small bootstrap script

When to use system

Use system when you want to run a command and only need to know whether it succeeded.

Examples:

• calling mkdir, cp, or rm in automation scripts
• running tests from a Ruby script
• executing a build command and stopping on failure
• invoking CLI tools during deployment

When to use backticks / %x()

Use them when you need the command's output as data.

Examples:

• reading the current Git commit hash
• getting a list of files from a command
• checking the hostname or username
• parsing command-line tool output in a script

branch = `git branch --show-current`.strip
puts "Current branch: "

In real projects, developers often prefer the method that matches their intent as clearly as possible.

Common patterns

Guard clauses with system

unless system("bundle exec rspec")
  abort("Tests failed")
end

This is common in scripts and CI helpers.

Capture and clean output with backticks

ruby_version = `ruby -v`.strip
puts "Running on #{ruby_version}"

.strip is commonly used because command output often ends with a newline.

Bootstrap and handoff with exec

ENV["RACK_ENV"] ||= "production"
exec("bundle exec puma -C config/puma.rb")

This is useful when the current Ruby script should not remain as an extra process.

Exit status handling

Developers often inspect $? after system or backticks.

1. Expecting system to return command output

Broken expectation:

files = system("ls")
puts files

files is not the listing. It is usually true or false.

Use backticks instead:

files = `ls`
puts files

2. Expecting code after exec to run

Broken code:

exec("ls")
puts "Done"

If exec works, puts "Done" never runs.

3. Forgetting that backticks include a trailing newline

name = `whoami`
puts name == "alice"   # often false

Why? Because name may actually be "alice\n".

Quick reference

exec

exec("ls")

• Replaces the current Ruby process
• Does not return if successful
• Use when handing off execution to another program

system

ok = system("ls")

• Runs command and waits
• Returns true, false, or nil
• Good when you care about success/failure

Backticks / %x()

output = `ls`
output = %x(ls)

• Runs command and captures standard output
• Returns a string
• Good when you need the command result as data

Exit status

system("ls")
puts $?.exitstatus
puts $?.success?

Common rule of thumb

Why does Ruby have both system and backticks?

Because they solve different problems. system tells you whether a command succeeded, while backticks give you the command output as a string.

What is the difference between backticks and %x() in Ruby?

There is no meaningful difference in behavior. %x() is just another syntax for command substitution.

Does exec create a new process in Ruby?

exec replaces the current process with the target program. The Ruby program does not continue if exec succeeds.

How do I capture shell command output in Ruby?

Use backticks or %x():

output = `pwd`

How do I check if a shell command succeeded in Ruby?

Use system or inspect $? after running a command:

ok = system("ls")
puts $?.success?

Why is my backtick result ending with ?

• Process::Status - Related because $? stores information about the last child process.
• spawn - Related because it starts external processes with more control than system.
• IO.popen - Related because it allows reading or writing to a child process stream.
• Open3 - Related because it provides access to stdout, stderr, and exit status separately.
• Shell command interpolation - Related because string-built commands can introduce bugs or security problems.
• Standard output and standard error - Related because command results and error messages are often separate streams.
• Exit codes - Related because command success and failure are communicated through exit status.
• Environment variables - Related because external commands often depend on ENV values.