Command-line shell

Related articles
Core utilities
dotfiles
From
Wikipedia
:
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.
List of shells
Shells that are more or less
POSIX compliant
are listed under
#POSIX compliant
, while shells that have a different syntax are under
#Alternative shells
.
POSIX compliant
These shells can all be linked from
/usr/bin/sh
. When
Bash
,
mksh
AUR
and
zsh
are invoked with the
sh
name, they automatically become more POSIX compliant.
Bash
— Bash extends the Bourne shell with command-line history and completion, indexed and associative arrays, integer arithmetic, process substitution, here strings, regular expression matching and brace expansion.
https://www.gnu.org/software/bash/
||
bash
Dash
— Descendant of the NetBSD version of the Almquist SHell (ash). A fast POSIX-compliant shell that aims to be as small as possible.
http://gondor.apana.org.au/~herbert/dash/
||
dash
KornShell (ksh)
— The KornShell language is a complete, powerful, high-level programming language for writing applications, often more easily and quickly than with other high-level languages. This makes it especially suitable for prototyping. ksh has the best features of the Bourne shell and the C shell, plus many new features of its own. Thus ksh can do much to enhance your productivity and the quality of your work, both in interacting with the system, and in programming. ksh programs are easier to write, and are more concise and readable than programs written in a lower level language such as C.
http://www.kornshell.com
||
ksh
nsh
— A command-line shell like fish, but POSIX compatible.
https://github.com/nuta/nsh
||
nsh-git
AUR
Oil Shell
(OSH)
— Oil Shell is a Bash-compatible UNIX command-line shell. OSH can be run on most UNIX-like operating systems, including GNU/Linux. It is written in Python (v2.7), but ships with a native executable. The dialect of Bash recognized by OSH is called the OSH language.
https://oils.pub/
||
oil
Yash
— Yet another shell, is a POSIX-compliant command line shell written in C99 (ISO/IEC 9899:1999). Yash is intended to be the most POSIX-compliant shell in the world while supporting features for daily interactive and scripting use.
https://magicant.github.io/yash/
||
yash
AUR
Zsh
— Shell designed for interactive use, although it is also a powerful scripting language. Many of the useful features of Bash, ksh, and tcsh were incorporated into Zsh; many original features were added. The
introductory document
details some of the unique features of Zsh.
https://www.zsh.org/
||
zsh
Tip
POSIX and Bash scripts can be linted with
shellcheck
.
Alternative shells
C shell
(tcsh)
— Command language interpreter usable both as an interactive login shell and a shell script command processor. It includes a command-line editor, programmable word completion, spelling correction, a history mechanism, job control and a C-like syntax.
https://www.tcsh.org
||
tcsh
Closh
— Bash-like shell based on Clojure.
https://github.com/dundalek/closh
||
closh
AUR
Elvish
— Elvish is a modern and expressive shell, that can carry internal structured values through pipelines. This feature makes possible avoiding a lot of complex text processing code. It features an expressive programming language, with features like exceptions, namespacing and anonymous functions. It also has a powerful readline which checks the syntax while typing, and syntax highlighting by default.
https://elv.sh
||
elvish
fish
— Smart and user-friendly command line shell. Fish performs full-color command line syntax highlighting, as well as highlighting and completion for commands and their arguments, file existence, and history. It supports complete-as-you-type for history and commands. Fish is able to parse the system's man pages in order to determine valid arguments for commands, allowing it to highlight and complete commands. Easy last-command revision can be done using
Alt+Up
. Additionally, fish features significantly simplified programming syntax and control flow (similar to ruby). For more information, see the
tutorial
.
https://fishshell.com/
||
fish
ion
— Ion is a modern system shell that features a simple, yet powerful, syntax. It is written entirely in Rust, which greatly increases the overall quality and security of the shell, eliminating the possibilities of a ShellShock-like vulnerability, and making development easier. It also offers a level of performance that exceeds that of Dash, when taking advantage of Ion's features. While it is developed alongside, and primarily for, RedoxOS, it is a fully capable on other *nix platforms. For more details lookup its
manual
.
https://gitlab.redox-os.org/redox-os/ion/
||
ion-git
AUR
Murex
— A command line shell with improved features and an enhanced UX.
https://murex.rocks/
||
murex
AUR
nushell
— Nu draws inspiration from functional programming languages, and modern CLI tools. Rather than thinking of files and services as raw streams of text, Nu looks at each input as something with structure.
https://www.nushell.sh
||
nushell
Oh
— Unix shell written in Go. It is similar in spirit but different in detail from other Unix shells. Oh extends the shell's programming language features without sacrificing the shell's interactive features.
https://github.com/michaelmacinnis/oh
||
oh-git
AUR
PowerShell
— PowerShell is an object-oriented programming language and interactive command line shell, originally written for and exclusive to Windows. Later on, it was open sourced and ported to macOS and Linux.
https://github.com/PowerShell/PowerShell
||
powershell
AUR
rc
— Command interpreter for Plan 9 that provides similar facilities to UNIX’s Bourne shell, with some small additions and less idiosyncratic syntax.
https://doc.cat-v.org/plan_9/4th_edition/papers/rc
||
9base
xonsh
— Python-powered shell with additional shell primitives that you are used to from Bash and IPython.
https://xon.sh/
||
xonsh
Changing your default shell
After installing one of the above shells, you can execute that shell inside of your current shell, by just running its executable. If you want to be served that shell when you login however, you will need to change your default shell.
To list all installed shells, run:
$ chsh -l
And to set one as default for your user do:
$ chsh -s
/full/path/to/shell
If you are using
systemd-homed
, run:
$ homectl update --shell=
/full/path/to/shell
user
where
/full/path/to/shell
is the full path as given by
chsh -l
.
Note
The default shell for new users is
Bash
. To switch back to it, use
/usr/bin/bash
as the shell path in the above commands.
If you now log out and log in again, you will be greeted by the other shell.
Tip
chsh
uses
/etc/shells
as reference. If a recently installed shell is not present on the list, it can be manually added to this file.
Uninstalling shell
Warning
Failure to follow the below procedure may result in users no longer having access to a working shell.
Change the default shell
before removing the package of the shell.
Alternatively, modify the
user database
.
Use it for every user with a shell other than
bash
set as their login shell (including root if needed). When completed, the package can be removed.
Login shell
A
login shell
is an invocation mode, in which the shell reads files intended for one-time initialization, such as system-wide
/etc/profile
or the user's
~/.profile
or other shell-specific file(s). These files set up the initial environment, which is inherited by all other processes started from the shell (including other non-login shells or graphical programs). Hence, they are read-only once at the beginning of a session, which is, for example, when the user logs in to the console or via
SSH
, changes the user with
sudo
or
su
using the
--login
parameter, or when the user manually invokes a login shell (e.g. by
bash --login
).
See
#Configuration files
and the links therein for an overview of the various initialization files. For more information about login shell, see also
Difference between Login Shell and Non-Login Shell?
and
Why a "login" shell over a "non-login" shell?
on Stack Exchange.
Configuration files
To autostart programs in console or upon login, you can use shell startup files/directories. Read the documentation for your shell, or its ArchWiki article, e.g.
Bash#Configuration files
or
Zsh#Startup/Shutdown files
.
See also
Wikipedia:Unix shell#Configuration files
for a comparison of various configuration files of various shells.
/etc/profile
Upon login, all Bourne-compatible shells source
/etc/profile
, which in turn sources any readable
*.sh
files in
/etc/profile.d/
: these scripts do not require an interpreter directive, nor do they need to be executable. They are used to set up an environment and define application-specific settings.
Standardisation
It is possible to make (some) shells configuration files follow the same naming convention, as well as supporting some common configuration between the shells.
See
the article about this
and the
related repository
. See also
xsh
.
Input and output
See also
GregsWiki
and
I/O Redirection
.
Redirections truncate files before commands are executed:
$
command
file
>
file
will therefore not work as expected. While some commands (
sed
for example) provide an option to edit files in-place, many do not. In such cases you can use the
sponge(1)
command from the
moreutils
package.
Because
cat
is not built into the shell, on many occasions you may find it more convenient to use a
redirection
, for example in scripts, or if you care a lot about performance. In fact
<
file
does the same as
cat
file
.
POSIX-compliant shells support
Here Documents
:
$ cat << EOF
one
two
three
EOF
Shell
pipelines
operate on stdout by default. To operate on
stderr(3)
you can redirect
stderr
to
stdout
with
command
2>&1 |
othercommand
or, for Bash 4,
command
|&
othercommand
.
Remember that many GNU
core utilities
accept files as arguments, so for example
grep
pattern
<
file
is replaceable with
grep
pattern
file
.
See also
Evolution of shells in Linux
on the IBM developerWorks
terminal.sexy
— Terminal Color Scheme Designer
Hyperpolyglot
— Side-by-side comparison of shell syntaxes
UNIX Power Tools
— General command-line tool usage
commandlinefu.com
— Command-line snippets sharing
List of applications/Utilities#Terminal emulators