Unix shell

From Wikipedia, the free encyclopedia
  (Redirected from Unix shells)
Jump to: navigation, search
tcsh and sh shell windows on an OS X desktop

A Unix shell is a command-line interpreter or shell that provides a traditional user interface for the Unix operating system and for Unix-like systems. Users direct the operation of the computer by entering commands as text for a command line interpreter to execute, or by creating text scripts of one or more such commands. Users typically interact with a Unix shell using a terminal emulator, however, direct operation via serial hardware connections, or networking session, are common for server systems.

The most influential Unix shells have been the Bourne shell and the C shell. These shells have both been used as the coding base and model for many derivative and work-alike shells with extended feature sets.

The Bourne shell, sh, was written by Stephen Bourne at AT&T as the original Unix command line interpreter; it introduced the basic features common to all the Unix shells, including piping, here documents, command substitution, variables, control structures for condition-testing and looping and filename wildcarding. The language, including the use of a reversed keyword to mark the end of a block, was influenced by ALGOL 68.[1]

The C shell, csh, was written by Bill Joy while a graduate student at University of California, Berkeley. The language, including the control structures and the expression grammar, was modeled on C. The C shell also introduced a large number of features for interactive work, including the history and editing mechanisms, aliases, directory stacks, tilde notation, cdpath, job control and path hashing.


Interaction with pdksh in OpenBSD (default shell)

The most generic sense of the term shell means any program that users employ to type commands. A shell hides the details of the underlying operating system and manages the technical details of the operating system kernel interface, which is the lowest-level, or "inner-most" component of most operating systems.

In Unix-like operating systems, users typically have many choices of command-line interpreters for interactive sessions. When a user logs in to the system interactively, a shell program is automatically executed for the duration of the session. The type of shell, which may be customized for each user, is typically stored in the user's profile, for example in the local passwd file or in a distributed configuration system such as NIS or LDAP; however, the user may execute any other available shell interactively.

The Unix shell is both an interactive command language as well as a scripting programming language, and is used by the operating system as the facility to control (shell script) the execution of the system.[2] Shells created for other operating systems often provide similar functionality.

On hosts with a windowing system, like OS X, some users may never use the shell directly. On Unix systems, the shell has historically been the implementation language of system startup scripts, including the program that starts a windowing system, configures networking, and many other essential functions. However, some system vendors have replaced the traditional shell-based startup system (init) with different approaches, such as systemd.

Graphical user interfaces for Unix, such as GNOME, KDE, and Xfce are sometimes called visual or graphical shells.[citation needed]

Bourne shell[edit]

The Bourne shell was one of the major shells used in early versions of the Unix operating system and became a de facto standard. It was written by Stephen R. Bourne at Bell Labs and was first distributed with Version 7 Unix, circa 1977. Every Unix-like system has at least one shell compatible with the Bourne shell. The Bourne shell program name is sh and its path in the Unix file system hierarchy is typically /bin/sh. On many systems, however, this may be a symbolic link or hard link to a compatible, but more feature-rich shell than the Bourne shell.

The POSIX standard specifies its standard shell as a strict subset of the Korn shell, an enhanced version of the Bourne shell. From a user's perspective the Bourne shell was immediately recognized when active by its characteristic default command line prompt character, the dollar sign ($).

C shell[edit]

The C shell was developed by Bill Joy for the Berkeley Software Distribution (BSD), a line of Unix operating systems derived from Unix and developed at the University of California, Berkeley. It was originally derived from the 6th Edition Unix shell (Thompson shell), with its syntax modeled after the C programming language. The C shell is used primarily for interactive terminal use, and less frequently for scripting and operating system control. It has interactive keyboard shortcuts in form of special control-key sequences for special effects such as job control.

Shell categories[edit]

Bourne shell compatible[edit]

C shell compatible[edit]

Others or exotic[edit]

There are various other shells, including the following:[6]


Configuration files[edit]

sh ksh csh tcsh bash zsh
/etc/.login login login
/etc/csh.cshrc yes yes
/etc/csh.login login login
~/.tcshrc yes
~/.cshrc yes yes[a]
~/etc/ksh.kshrc int.
/etc/sh.shrc int.[b]
$ENV (typically ~/.kshrc)[8] int.[c][d] int. int.[e]
~/.login login login
~/.logout login login
/etc/profile login login login login
~/.profile login login login[f] login
~/.bash_profile login[f]
~/.bash_login login[f]
~/.bash_logout login
~/.bashrc int.+n/login
/etc/zshenv yes
/etc/zprofile login
/etc/zshrc int.
/etc/zlogin login
/etc/zlogout login
~/.zshenv yes
~/.zprofile login
~/.zshrc int.
~/.zlogin login

Shells read configuration files on multiple circumstances that differ depending on the shell. These files usually contain commands for the particular shell and are executed when loaded; they are usually used to set important variables used to find executables, like $PATH, and others that control the behavior and appearance of the shell. The table in this section shows the configuration files for popular shells.


  • blank means a file is not read by a shell at all.
  • "yes" means a file is always read by a shell upon startup.
  • "login" means a file is read if the shell is a login shell.
  • "n/login" means a file is read if the shell is not a login shell.
  • "int." means a file is read if the shell is interactive.

See also[edit]


  1. ^ only if ~/.tcshrc not found
  2. ^ Newer versions of the Bourne Shell only
  3. ^ Available on systems that support the "User Portability Utilities option"; value of the variable must be an absolute path, and it is ignored "if the user's real and effective user IDs or real and effective group IDs are different."[9]
  4. ^ $ENV is $HOME/.shrc in newer versions of the Bourne Shell
  5. ^ Same behavior as sh, but only if invoked as sh (bash 2+) or, since bash 4.2, also if invoked explicitly in POSIX compatibility mode (with options --posix or -o posix).[10]
  6. ^ a b c in fact, the first readable of ~/.bash_profile, ~/.bash_login and ~/.profile; and only ~/.profile if invoked as sh or, as of at least Bash 4.2, if invoked explicitly in POSIX compatibility mode (with options --posix or -o posix)


  1. ^ "Re: Late Bloomers Revisited". Retrieved 20 September 2014. 
  2. ^ Bourne, Stephen R. (October 1983). "The Unix Shell". BYTE. p. 187. Retrieved 30 January 2015. 
  3. ^ Korn, David G. (October 26, 1994), "ksh - An Extensible High Level Language", Proceedings of the USENIX 1994 Very High Level Languages Symposium (USENIX Association), retrieved February 5, 2015, Instead of inventing a new script language, we built a form entry system by modifying the Bourne shell, adding built-in commands as necessary. 
  4. ^ Harley Hahn, Harley Hahn's Guide to Unix and Linux.
  5. ^ "Hamilton C shell for Windows Release Notes 4.0". Retrieved 20 September 2014. 
  6. ^ "FreeBSD Ports: Shells". Freebsd.org. 2014-03-30. Retrieved 2014-04-05. 
  7. ^ "Zoidberg: A Shell That Speaks Perl". Dr. Dobb's. Retrieved 20 September 2014. 
  8. ^ SCO Unix Group, SCO Unixware 7 documentation, 22 Apr 2004, retrieved 18 Oct 2012.
  9. ^ "Shell Command Language". opengroup.org. Retrieved 15 June 2015. 
  10. ^ "Bash Reference Manual: Bash Startup Files". gnu.org. Retrieved 15 June 2015. 

Further reading[edit]

  • Ellie Quigley (2001). "Introduction to UNIX shells". Unix Shells by Example. Prentice Hall PTR. ISBN 013066538X.  — a history of the various shells, and the uses of and responsibilities of a shell on Unix

External links[edit]