What Is the Rc Shell and How to Install It in Linux

The rc shell is a simple and innovative command interpreter built for the Plan 9 family of operating systems. It is currently a part of plan9port, which is a suite of Plan 9 software that is available for Linux.

Rc aims to improve on the default UNIX shell and it introduces a cleaner syntax for writing scripts. It is also built to be as simple to understand as possible. This makes rc a good program for someone that wants to learn how a shell works.

Also read: The Best Linux Desktop Environments of 2022

What Is Plan 9?

In a basic sense, Plan 9 is the successor to the UNIX operating system. It was developed by Bell Labs as an experimental project from the early 1980s up until 2015. Since then, a group of volunteers have been maintaining the operating system and it still sees occasional updates to this day.

Plan 9 aims to produce a simple and approachable system for both developers and users alike. It does this by implementing and improving on the basic UNIX concept. As such, Plan 9 carries a lot of similar commands to UNIX and other UNIX-likes such as cp, mv and rm.

Further, it also adds a number of new utilities and features that are unique to the operating system. For example, sam is a powerful text editor that you can fully control using regular expressions.

One of the most innovative features of Plan 9 is the rc shell. It is a command interpreter similar to Bash and it allows you to create scripts which you can then use to automate your machine. rc also aims to simplify how you create these scripts by removing all unnecessary and redundant features.

Also read: How to Resize and Optimize Images From the Linux Terminal

Installing the Rc Shell

Installing the rc shell in Linux is relatively straightforward.

1. Copy the Git repository of the Plan 9 tools to your machine. You can do that by installing Git and running the following commands:

git clone https://github.com/9fans/plan9port.git /home/$USER/plan9port
cd plan9port

2. Next up, run the installation script that comes with the repository. This is a simple script that compiles a Plan 9 builder which, in turn, compiles the rest of the utilities. To do this, you need to run the following:

./INSTALL

3. Once done, you can now use the Plan 9 utilities by going to the repository’s bin directory. For example, we’ll type ./bin/acme to run a graphical text editor.

4. One important thing to note is that these commands will only work while you are in plan9port’s “bin” directory. In order to use these elsewhere, you need to add this particular directory to your “PATH” variable. To do that, you need to open the “.bash_profile” file in your home directory:

nano /home/$USER/.bash_profile

5. Add the following string of text at the end of your “PATH” variable:

:/home/$USER/plan9port/bin/

Save and exit the file, and restart the rc shell.

Also read: 5 Useful Tips When Compiling Your Own Linux Kernel

Using and Writing Basic Rc Scripts

With that done, you can now start scripting in rc. In order to access this shell, all you need to do is to run the following command:

9 rc

Doing that will change the prompt of your terminal to “%”. This indicates that you are now inside the rc shell. From here, you can still access all of your files as well as traditional Linux commands. For example, we’ll type ls to get a list of the current directory.

Variables and File Operators

One of the most common uses for a shell language is for storing arbitrary values as well as manipulating files. In this regard, rc shell behaves exactly like Bash.

1. We’ll write the following to create a variable with the name “test” and assign the word “hello” to it:

test=hello

2. From there, we’ll type the following command to append the test variable to the file “world.txt”:

echo $test >> world.txt

3. On the other hand, it’s possible to also instruct the read operator to use the contents of a file as an input for a program:

cat < world.txt

Also read: 5 Best Linux-Libre Distributions for Better Security

Using UNIX Pipes in Rc Shell

Another common function in shell languages is the ability to create UNIX pipes. This is a special type of file operator where you can pass the output of one program to a different program’s input.

Similar to the functions above, rc shell largely follows the traditional Bash syntax when creating UNIX pipes.

1. We’ll run the following command to pass the contents of the “world.txt” file to a system pager:

cat world.txt | less

2. We should note here that UNIX pipes in rc are non-linear. This means that it is possible to pass the output from two active programs in a single program’s input. For example, we can run the following command to compare the output of two programs:

cmp <{echo hello} <{echo helloo}

Also read: What Is Gentoo Linux and How to Install It

Chaining Commands in Rc Shell

Aside from using UNIX pipes, it is also possible to chain different commands in rc shell. This allows you to run programs in sequence without the need to type them in separate lines. Check out this command that allows you to run less after running echo:

echo hello-world >> hello.txt; less hello.txt

Further, rc also allows you to check a program’s status code before going to an adjacent command. This can be useful if your program depends on either the success or failure of other programs.

To this end, rc provides two operators: &&” and ||. These are special characters which you can use to replace the semicolon symbol.

• The && operator tells rc to chain and run programs as long as the command on the left side runs successfully. This is helpful in situations where you need the whole chain to run properly.
• The || operator tells rc to chain and run programs if the command on the left side fails to run. Unlike the previous operator, this is incredibly useful if you are trying to fix issues in your scripts and programs.

Knowing that, you can then use these operators to create commands that can queue and check programs. For example, we’ll instruct rc to only run touch if mkdir runs successfully:

mkdir ./hello && touch ./hello/world

Also read: How to Check Sudo History in Linux

Using Strings and Lists in Rc Shell

One of the biggest differences between Bash and the rc shell is the latter’s focus on simplifying the use of plain text. In traditional shell, text and strings are often hard to declare in functions and variables.

This issue is partly due to the fact that there are two ways to declare a string in Bash. It is possible to enclose text in both single and double quotes to treat a word as a string.

As such, rc aims to reduce this complexity by only using single quotes when declaring strings. Doing this allows you to use special and control characters without any issues.

By using this command we’ll turn a bracket to a string without any escape characters:

# rc
hello='[world]'
# bash
hello='\[world\]'

Further, rc also allows you to manipulate these string variables and directly compile them as a list. This can be especially useful if you want to create a script that stores variables in a simple array.

To do this, all you need to do is to enclose a group of strings in parenthesis. As such, we’ll write the following to create a variable with 5 elements inside it:

shop=(eggs milk cheese rice beef)

Knowing that, you can then use a variety of commands to pull data out of an array. For example, this command will pull the first three elements of an array:

echo $shop(1 2 3)

Also read: How to Fix Can’t Type in Terminal Issue in Linux

Basic Flow Control in Rc Shell

Aside from being a simple shell, rc is also a full programming language. This means that it is capable of not only basic string manipulation but also of logical branching similar to Python.

Rc allows you to easily create if-then statements, for loops as well as the ability to define complex functions. This can be incredibly helpful if you are just starting out with programming.

Also read: How to Use the dd Command in Linux

Using Conditional Statements

One of the most basic feature of programming languages is the ability to create conditional statements. These are structures which tell a program what to do depending on the circumstance that it is in. For example, you can tell a program to only run if it has a value of 1.

You can write a conditional statement for rc in a single line:

if ( condition ) program

• The “condition” field is a list of commands that rc will attempt to run. The way it works is that any program that successfully runs itself provides a value of “true”.
• The “program” field, on the other hand, depends on the condition field’s “true” value to run any command that you give to it.

Unlike Bash, this approach allows you to use almost any type of program for a script’s conditional statement. For example, you can tell rc to only run this statement if a hello.world file exists in the current directory:

if ( test -r hello.world ) echo "there is a hello world!"

Also read: How to Test Various Linux Distros Online

Creating Simple for Loops

Aside from writing conditional statements, it is also possible to use rc for creating repeating scripts through loops. A loop is a structure that allows you to repeat a particular command for set number of times.

Similar to conditional statements, you can also write the syntax of a loop in a single line:

for ( i in step ) program

• The “step” field can either be a variable or a program that rc will go through one by one. For example, writing a list here will tell rc to go through each element of the list.
• The “program” field is the line of code that you want rc to run every time it goes through the step field.

Creating Functions in Rc

Lastly, it is also possible to create a general function in rc. Similar to other programming languages, this is a structure that you can define to perform a custom task.

For example, the following will create a function that uses both conditional statements and for loops:

fn hello {
    for (i in ./hello/) if(test -r ./hello/$i) echo "There is a file here!"
}

While this might seem complex, writing a function is incredibly simple. At its core, the basic syntax of an rc function looks something like this:

fn name { function }

• The “name” field tells rc the label of a particular function. This can be especially useful if you want to reuse the same function for a later command.
• The “function” field, on the other hand, contains all the variables and commands that you want it to run.

Also read: How to Choose a Linux Distro Without Trying All of Them

Frequently Asked Questions

Image credits: Unsplash All screenshots by Ramces Red

Ramces Red - Staff Writer

Ramces is a technology writer that lived with computers all his life. A prolific reader and a student of Anthropology, he is an eccentric character that writes articles about Linux and anything *nix.