You need to enable the stdout pipe, which otherwise defaults to $*OUT, by setting :out. So:

my $proc = run("uname", :out);
my $stdout = $proc.out;
say $stdout.slurp;
$stdout.close;

which can be shortened to:

my $proc = run("uname", :out);
say $proc.out.slurp(:close);

If you want to capture output on stderr separately than stdout you can do:

my $proc = run("uname", :out, :err);
say "[stdout] " ~ $proc.out.slurp(:close);
say "[stderr] " ~ $proc.err.slurp(:close);

or if you want to capture stdout and stderr to one pipe, then:

my $proc = run("uname", :merge);
say "[stdout and stderr] " ~ $proc.out.slurp(:close);

Finally, if you don't want to capture the output and don't want it output to the terminal:

my $proc = run("uname", :!out, :!err);
exit( $proc.exitcode );

The solution covered in this answer is concise.

This sometimes outweighs its disadvantages:

• Doesn't store the result code. If you need that, use ugexe's solution instead.

• Doesn't store output to stderr. If you need that, use ugexe's solution instead.

• Potential vulnerability. This is explained below. Consider ugexe's solution instead.

Documentation of the features explained below starts with the quote adverb :exec.

Safest unsafe variant: q

The safest variant uses a single q:

say qx[ echo 42 ] # 42

If there's an error then the construct returns an empty string and any error message will appear on stderr.

This safest variant is analogous to a single quoted string like 'foo' passed to the shell. Single quoted strings don't interpolate so there's no vulnerability to a code injection attack.

That said, you're passing a single string to the shell which may not be the shell you're expecting so it may not parse the string as you're expecting.

Least safe unsafe variant: qq

The following line produces the same result as the q line but uses the least safe variant:

say qqx[ echo 42 ]

This double q variant is analogous to a double quoted string ("foo"). This form of string quoting does interpolate which means it is subject to a code injection attack if you include a variable in the string passed to the shell.

By default run just passes the STDOUT and STDERR to the parent process's STDOUT and STDERR.

You have to tell it to do something else.

The simplest is to just give it :out to tell it to keep STDOUT. (Short for :out(True))

my $proc = run 'uname', :out;
my $result = $proc.out.slurp(:close);

my $proc = run 'uname', :out;
for $proc.out.lines(:close) {
  .say;
}

You can also effectively tell it to just send STDOUT to /dev/null with :!out. (Short for :out(False))

There are more things you can do with :out

{
  my $file will leave {.close} = open :w, 'test.out';
  run 'uname', :out($file); # write directly to a file
}

print slurp 'test.out'; # Linux

my $proc = run 'uname', :out;

react {
  whenever $proc.out.Supply {
    .print

    LAST {
      $proc.out.close;
      done; # in case there are other whenevers
    }
  }
}

If you are going to do that last one, it is probably better to use Proc::Async.