perl.gg / essentials

The Backtick Heredoc

2026-03-24

This page explains how to run multi-line shell commands from Perl and capture their output cleanly. You will learn the backtick heredoc syntax, how variable interpolation works, and where the common pitfalls hide.

You already know the backtick operator. It runs a single shell command and returns the output as a string.

my $output = `ls -la /tmp`;
That works fine for one line. It breaks down fast when your shell command stretches across ten lines, includes redirects, or chains a few pipes together. You could join backtick strings with semicolons, or you could call system() and read the output yourself. The cleaner option is the heredoc variant that most Perl developers skip. 
my $output = <<`END_CMD`;
ls -la /tmp
echo "---"
df -h /
echo "---"
uptime
END_CMD
That is a backtick heredoc. Perl runs everything between the markers as a shell command and returns the stdout as a string. Multi-line shell scripts land in one readable block.

Part 1: THE THREE HEREDOC FLAVORS

Perl ships with three heredoc forms. They line up with the three quoting styles you already use in your code. 
SYNTAX         EQUIVALENT    BEHAVIOR
-----------    ----------    --------------------------
<<"TAG"        "..."         Interpolates variables
<<'TAG'        '...'         No interpolation (literal)
<<`TAG`        `...`         Executes as shell command
The double-quoted form is the default. The single-quoted form keeps dollar signs literal. The backtick form is the one people forget exists.

The backtick heredoc interpolates like a double-quoted string and then executes the result as a shell command. Your Perl variables expand first, and the shell runs the final text.

Part 2: YOUR FIRST BACKTICK HEREDOC

Here is the simplest case. One command, just to see the syntax: 
my $date = <<`CMD`;
date +"%Y-%m-%d %H:%M:%S"
CMD

print "Server time: $date";
Output: 
Server time: 2026-03-24 14:30:00
The CMD marker can be any word you like. END, SHELL, RUN, COMMANDS, whatever. It just has to match on both ends. The closing marker must sit alone on a line, flush left, with no trailing whitespace. Those rules match every other heredoc in Perl.

One detail to notice: the output keeps a trailing newline, just like regular backticks. If that trailing newline bothers you, chomp it.

my $hostname = <<`CMD`;
hostname
CMD
chomp $hostname;
Nothing magical yet. The real payoff shows up when you need more than one line.

Part 3: MULTI-LINE SHELL SCRIPTS

Here is where it gets useful. Say you need a system health snapshot: 
my $health = <<`HEALTH_CHECK`;
echo "=== DISK ==="
df -h / | tail -1
echo ""
echo "=== MEMORY ==="
free -h | grep Mem
echo ""
echo "=== LOAD ==="
uptime
echo ""
echo "=== PROCS ==="
ps aux | wc -l
HEALTH_CHECK

print $health;
Output: 
=== DISK ===
/dev/sda1       50G   32G   16G  67% /

=== MEMORY ===
Mem:           31Gi  12Gi  8.0Gi  1.5Gi  11Gi  18Gi

=== LOAD ===
14:30:00 up 42 days, 3:15, 2 users, load average: 0.15, 0.10, 0.08

=== PROCS ===
187
Try doing that with a single-line backtick. You would end up with a long string full of semicolons and escaped newlines. The heredoc keeps the script readable.

Part 4: VARIABLE INTERPOLATION

Because backtick heredocs interpolate like double-quoted strings, you can drop Perl variables straight into your shell commands: 
my $target_dir = '/var/log';
my $pattern    = '*.log';
my $days       = 7;

my $report = <<`FIND_CMD`;
echo "Files matching $pattern in $target_dir (last $days days):"
find $target_dir -name "$pattern" -mtime -$days -ls 2>/dev/null
echo "---"
echo "Total size:"
find $target_dir -name "$pattern" -mtime -$days -exec du -ch {} + 2>/dev/null | tail -1
FIND_CMD

print $report;
The Perl variables $target_dir, $pattern, and $days expand before the shell ever sees the command. That is handy for building dynamic system queries.

Watch out. That same interpolation is also where things get dangerous.

Part 5: THE DOLLAR SIGN TRAP

Here is the single most common mistake with backtick heredocs. Your shell uses $ variables too: 
# BROKEN - Perl eats the $HOME before the shell sees it
my $output = <<`CMD`;
echo $HOME
CMD
# Perl interpolates $HOME as a Perl variable (probably empty)
The fix is to escape the dollar sign: 
# FIXED - backslash tells Perl to leave it alone
my $output = <<`CMD`;
echo \$HOME
echo \$(whoami)
echo \${USER}
CMD
Now Perl passes the literal $HOME to the shell, and the shell expands it. 
RULE OF THUMB:
  - $perl_var    -> Perl expands it
  - \$shell_var  -> Shell expands it
  - \$(command)  -> Shell runs the subshell
If your script contains a lot of shell variables and almost no Perl variables, you might be better off with a single-quoted heredoc piped through qx or system. For mixed cases, escaping works fine.

Part 6: CAPTURING COMPLEX PIPELINES

The real killer use case is capturing output from pipelines that would be unreadable as a single backtick string. 
my $top_talkers = <<`PIPELINE`;
netstat -an 2>/dev/null | \\
    grep ESTABLISHED | \\
    awk '{print \$5}' | \\
    cut -d: -f1 | \\
    sort | \\
    uniq -c | \\
    sort -rn | \\
    head -10
PIPELINE

print "Top 10 connections by IP:\n$top_talkers";
Notice the double backslashes at the end of the continuation lines. The first backslash escapes the second one for Perl, so the shell sees a single backslash for line continuation.

Also notice \$5 inside the awk command. Without the backslash, Perl would try to interpolate $5 as the fifth capture group from the last regex.

     +------------------+
     |  Perl variables  |  $target_dir, $pattern
     +--------+---------+
              |
              v  (interpolation happens first)
     +------------------+
     |  Shell commands   |  echo, find, awk, grep
     +--------+---------+
              |
              v  (shell executes)
     +------------------+
     |  Captured output  |  -> back into $variable
     +------------------+

Part 7: PRACTICAL SYSADMIN RECIPES

Here are some real-world patterns where backtick heredocs shine.

Service status dashboard:

my $service = 'nginx';
my $dashboard = <<`STATUS`;
echo "Service: $service"
echo "Status:  \$(systemctl is-active $service 2>/dev/null || echo 'unknown')"
echo "PID:     \$(pidof $service 2>/dev/null || echo 'not running')"
echo "Uptime:  \$(systemctl show $service --property=ActiveEnterTimestamp 2>/dev/null | cut -d= -f2)"
echo "Memory:  \$(ps -o rss= -p \$(pidof $service 2>/dev/null) 2>/dev/null | awk '{printf "%.1f MB", \$1/1024}')"
STATUS

print $dashboard;
Quick backup with timestamp: 
my $config_file = '/etc/nginx/nginx.conf';
my $backup_log = <<`BACKUP`;
cp $config_file ${config_file}.\$(date +%Y%m%d%H%M%S).bak
echo "Backup created: \$(ls -la ${config_file}.*.bak | tail -1)"
BACKUP

print $backup_log;
Gathering remote info through SSH: 
my $host = 'web01.example.com';
my $remote_info = <<`SSH_CMD`;
ssh $host 'hostname; uptime; df -h / | tail -1' 2>/dev/null
SSH_CMD

print "Remote report:\n$remote_info";

Part 8: COMPARED TO ALTERNATIVES

Why not just use system() or open() with a pipe? Let's compare. 
# Option 1: system() - no capture
system("ls -la /tmp && df -h /");
# Output goes to STDOUT, you can't capture it

# Option 2: open() pipe - verbose
open my $fh, '-|', 'ls -la /tmp && df -h /' or die $!;
my $output = do { local $/; <$fh> };
close $fh;

# Option 3: qx() multi-line - ugly
my $output = qx{ls -la /tmp
df -h /
uptime};

# Option 4: backtick heredoc - clean
my $output = <<`CMD`;
ls -la /tmp
df -h /
uptime
CMD
The heredoc wins on readability when you have more than two or three commands. It is visually clear where the shell block starts and ends. The commands look like they would in an actual shell script.

The qx{} form handles multi-line text too, but heredocs give you a cleaner visual boundary and a named terminator.

Part 9: GOTCHAS AND WARNINGS

A few things to keep in mind before you go wild with these.

Security: If any of your interpolated variables come from user input, you have a shell injection vulnerability. Sanitize everything. Or better yet, use IPC::Run or Capture::Tiny for anything that touches untrusted data.

Error handling: Backtick heredocs do not die on command failure. Check $? after execution:

my $output = <<`CMD`;
some_command --that-might-fail
CMD

if ($? != 0) {
    my $exit_code = $? >> 8;
    warn "Command failed with exit code $exit_code\n";
}
STDERR: Backtick heredocs only capture STDOUT. If you want STDERR too, redirect it: 
my $output = <<`CMD`;
some_command 2>&1
CMD
Portability: Your shell commands are only as portable as the shell they run in. What works on Linux might not work on macOS or BSD. Keep that in mind if your Perl script needs to travel.

Part 10: THE INDENTED VARIANT

Since Perl 5.26, you can use the indented heredoc syntax with backticks too: 
sub get_system_info {
    my $info = <<~`CMD`;
        hostname
        uname -a
        uptime
        CMD

    return $info;
}
The ~ after << strips leading whitespace that matches the indentation of the terminator. This keeps your code nicely indented without the extra whitespace ending up in the shell command.

This matters more than you might think. Without the indented form, heredocs force you to break your indentation:

sub get_info {
    # ugly - the heredoc body slams to column 0
    my $info = <<`CMD`;
hostname
uname -a
CMD

    # nice - everything stays indented with your code
    my $info = <<~`CMD`;
        hostname
        uname -a
        CMD

    return $info;
}
The indented form keeps your functions readable. No more jagged left-aligned blocks in the middle of nested code.

Clean code, clean output.

      .--.
     |o_o |     "My heredoc has backticks
     |:_/ |      and it executes things."
    //   \ \
   (|     | )
  /'\_   _/`\
  \___)=(___/
The backtick heredoc is one of those features that hides in plain sight. It sits right there in perldoc perlop, documented alongside its siblings. Most Perl developers never reach for it because they never needed multi-line shell execution, or they never knew it existed.

The next time you find yourself cramming a five-line pipeline into a single backtick string, stop. Breathe. Use a backtick heredoc. Your shell commands will read like a shell script, your Perl code will stay clean, and you will wonder why you ever did it any other way.

Now you know. Use it wisely. Or at least, use it.

perl.gg