Skip to main content

The Importance of Redirection Order in Linux

Linux, Unix, and Unix-like operating systems offer a powerful suite of tools for directing and manipulating streams of data. Among these tools are the redirection operators, which allow you to route Standard Output (stdout), Standard Error (stderr), and even custom file descriptors to various locations like files, devices, or other commands. While these capabilities are immensely powerful, their usefulness depends significantly on the order in which they are applied. This article will delve into why the order of redirection in Linux is crucial, and how you can use this feature to your advantage.

Understanding 0>, 1>, and 2> File Descriptors

Before we delve into the nitty-gritty, it's important to understand what the numbers preceding the greater-than (>) symbol represent. In the Linux operating system, every open file is associated with a file descriptor, which is an integer. The standard file descriptors are:

  • 0 for Standard Input (stdin)
  • 1 for Standard Output (stdout)
  • 2 for Standard Error (stderr)

You can also define custom file descriptors beyond these, like 3, 4, 5, etc., based on your specific needs.

Here's how they differ:

  • 1> or simply > redirects the standard output (stdout). For example, ls > output.txt will save the list of files in the current directory to output.txt.

  • 2> redirects the standard error (stderr). For instance, ls /nonexistent 2> error.txt will save the error message in error.txt.

  • 3> would be a custom file descriptor that you have defined in your script or command sequence. It would need to be associated with a file or a stream explicitly.

Custom File Descriptors

In Linux, you can create custom file descriptors beyond the standard stdin, stdout, and stderr, which are represented by 0, 1, and 2 respectively. Custom file descriptors like 3> are often used in shell scripts for specialized input/output operations.

Here's a simple example that demonstrates using a custom file descriptor (3) to write to a file:

# Open file descriptor 3 for writing and associate it with a file.
exec 3> custom_output.txt

# Write to file descriptor 3
echo "This is a message from custom file descriptor" >&3

# Close file descriptor 3
exec 3>&-

After you run this script, you should see a file called custom_output.txt in the current directory containing the text "This is a message from custom file descriptor".

Here’s a breakdown of what’s happening in the script:

  • exec 3> custom_output.txt: This opens a new file descriptor 3 and associates it with the file custom_output.txt. Any subsequent writes to file descriptor 3 will go to this file.

  • echo "This is a message from custom file descriptor" >&3: This writes the specified message to file descriptor 3, which, as per the previous command, is associated with custom_output.txt.

  • exec 3>&-: This closes file descriptor 3, ensuring that no more writes are sent to custom_output.txt via this descriptor.

Remember that custom file descriptors like 3 are not inherently special—they are simply integers that you can associate with files or other I/O streams for specific tasks. This gives you greater flexibility for managing input and output in complex shell scripts.

Swapping stdout and stderr

Linux allows the possibility of swapping stdout and stderr using advanced redirection techniques. The operation leverages additional file descriptors. Let's consider the following example:

command 3>&1 1>&2 2>&3 3>&-

Here’s a breakdown of what’s happening:

  • 3>&1: This duplicates stdout (&1) to a new file descriptor, 3.
  • 1>&2: This directs stdout (1) to the location of stderr (2).
  • 2>&3: This directs stderr (2) to the new file descriptor 3, which was a copy of the original stdout.
  • 3>&-: This closes the new file descriptor 3.

This sequence effectively swaps stdout and stderr, and the order is critical. Reversing any of these would break the intended functionality.

The Impact of Redirection Order

Redirecting stderr to stdout

Take a look at this example:

command > all_output.txt 2>&1

Here, stdout is redirected first, and then stderr is redirected to stdout. If you change the order, like so:

command 2>&1 > all_output.txt

This won't work as you might expect. The stderr is redirected to the terminal, not all_output.txt.

Combining Multiple Redirections

Suppose you want to send stdout to output.txt and stderr to error.txt:

command > output.txt 2> error.txt

Here, the order doesn’t matter because the redirections are independent.

Digging Deeper into Redirection - Append Operator

The ability to manipulate data streams in Linux is a powerful feature. This is made possible through redirection operators like >, 2>, and >>. As you might already know, the order of these operators plays a critical role in achieving the desired effect. But the twist in the plot comes when you introduce the append operator >>, which adds another layer of complexity. This article will focus on the importance of the order of redirection when using the append operator.

The Append Operator >>

Before diving into examples, let's understand the append operator. The >> operator is used to append data to a file. It works similarly to the overwrite operator > but instead of erasing the existing content, it adds new data at the end of the file. For example:

echo "Hello, World!" >> greeting.txt

This will append "Hello, World!" to the end of the file greeting.txt.

Impact of Order with Overwrite and Append

Imagine you want to append stdout to an existing file and overwrite a file with stderr. You might do something like this:

command >> append_to_this.txt 2> overwrite_this.txt

In this example, stdout will append its content to append_to_this.txt, and stderr will overwrite overwrite_this.txt.

Now, if you switch the order:

command 2> overwrite_this.txt >> append_to_this.txt

The effect remains the same; stdout appends to append_to_this.txt and stderr overwrites overwrite_this.txt. In this specific instance, order doesn't matter because both operations are independent.

Appending Both stdout and stderr

If you want to append both stdout and stderr to a single file, the order does matter. Consider this:

command >> all_output.txt 2>&1

This appends stdout to all_output.txt and then redirects stderr to wherever stdout is going, effectively appending both to all_output.txt.

Switch the order, and you'll get an unintended result:

command 2>&1 >> all_output.txt

Here, stderr is redirected to stdout before stdout is appended to all_output.txt. This means stderr will go to the terminal, not get appended to all_output.txt.

Swapping stdout and stderr with Append

For more advanced operations like swapping stdout and stderr while also using the append operator, the order becomes critical:

command 3>>append.txt 1>&2 2>&3 3>&-

This complex command performs the following:

  • 3>>append.txt: Appends a new file descriptor 3 to append.txt.
  • 1>&2: Redirects stdout to stderr.
  • 2>&3: Redirects stderr to file descriptor 3, which is appending to append.txt.
  • 3>&-: Closes the new file descriptor 3.


Understanding the order of redirection is essential for mastering the Linux command line. It’s not just a matter of knowing the syntax, but comprehending how each operation impacts the flow of data between commands, files, and streams. By paying close attention to the order of your redirection operators, you ensure that you are correctly capturing or discarding the information you intend to, whether for logging, debugging, or any other form of data manipulation.

What Can You Do Next 🙏😊

If you liked the article, consider subscribing to Cloudaffle, my YouTube Channel, where I keep posting in-depth tutorials and all edutainment stuff for software developers.

YouTube @cloudaffle