Laravel’s New pipe() Method: Chain System Commands Cleanly

Last updated: October 12, 2026

Laravel's Process facade, the wrapper around Symfony's Process component, picked up a useful addition: a chaining helper for system commands. A walkthrough from Amit Merchant shows how to run ls piped through grep without spinning up the shell yourself.

The helper takes either a callback with explicit steps or a simple array of strings. Either way, Laravel returns the output of the final command in the chain.

• Process::pipe() lives on Laravel's Process facade.
• It accepts a callback with a Pipe instance, or an array of command strings.
• The return value exposes ->output() for the final command's result.
• It avoids spawning a shell just to chain simple system calls.

The basic syntax

The cleanest form is a callback that registers each step:

Use Illuminate\Support\Facades\Process;

$out = Process::pipe(function ($chain) {

$chain->command('ls -la');

$chain->command('grep -i "php"');

});

// $out->output() returns the final command's result

The result matches piping ls through grep in a shell: a list of files and folders whose names contain "php". No /bin/sh -c invocation required.

For short two-command flows, you can skip the closure and just hand over a plain array:

$out = Process::pipe(['ls -la', 'grep -i "php"']);

$out->output();

Both forms behave identically. The closure is more flexible for chains with three or more stages, since you can branch or compute arguments at each step. The array form is the quickest way to wire up a fixed pipeline.

Why this exists

Symfony's Process component lets you run a single command cleanly. Chaining two commands without the shell used to require manual stream wiring, which got old fast. The new helper abstracts that plumbing behind a fluent call. Laravel has been steadily aligning its process utilities under one facade; this addition fits that pattern.

The trade-off is the default shell-less mode. That's the safer choice — every argument stays escaped — but it does mean you can't lean on shell features like redirection or glob expansion. If you genuinely need shell semantics, fall back to Process::run() with a single string.

A worked example

Imagine a Laravel console command that lists every PHP file in a project, sorted by modification time. Pre-helper, you'd run a single ls | grep | sort pipeline through Process::run() with a hand-built string. With the new helper, you write:

$out = Process::pipe(function ($chain) {

$chain->command('ls -la');

$chain->command('grep -i "php"');

$chain->command('sort -k 6,7');

});

The output is the final sort's result: a clean list of PHP files ordered by date. No shell escaping worries, no manual stream wiring. The result can be printed to the terminal, written to a log file, or stored in a database — your call.

Our analysis

This is one of those small additions that quietly improves daily Laravel work. The old path was either shelling out (a security smell when arguments come from users) or hand-wiring Symfony's process streams (clunky for two commands, worse for three). The new helper removes both excuses.

Stacked against Symfony's standalone Process component, Laravel's facade is friendlier but doesn't expose the underlying streams. If you need fine control — like writing intermediate output to a log file or capturing per-step timing — drop down to Symfony directly. For the common two-or-three-command case, this is the right level of abstraction.

A subtle benefit worth calling out: the array form is easier to test. You can mock it cleanly because it's just data, not a closure with side effects. The closure form is harder to mock but gives you branching logic.

What to watch next

The Process facade still has room to grow. Chains with per-command error handling, timeouts, and per-command environment variables are the obvious next asks.

Bottom line: if you script system commands in Laravel, this is the cleaner way to chain them.

Key takeaways

• Process::pipe() accepts a callback with a Pipe instance or an array of commands.
• The output method returns the final command's result.
• It runs without spawning a shell, so arguments stay escaped.
• For shell semantics or redirection, fall back to Process::run() with a single string.
• The array form is easier to mock in tests than the closure form.