Command-line interface

Operating system command-line interfaces

Operating system (OS) command-line interfaces are usually distinct programs supplied with the operating system. A program that implements such a text interface is often called a command-line interpreter, command processor, or shell.

Examples of command-line interpreters are Nushell, DEC's DIGITAL Command Language (DCL) in OpenVMS and RSX-11, the various Unix shells (sh, ksh, csh, tcsh, zsh, Bash, etc.), CP/M's CCP, DOS' COMMAND.COM, as well as the OS/2 and the Windows CMD.EXE programs, the latter groups being based heavily on DEC's RSX-11 and RSTS CLIs.^{[citation needed]} Under most operating systems, it is possible to replace the default shell program with alternatives; examples include 4DOS for DOS, 4OS2 for OS/2, and 4NT / Take Command for Windows.

Although the term shell is often used to describe a command-line interpreter, strictly speaking, a shell is a command interpreter and processor and by extension a program that provides an interface (either a user interface (command-line interface, GUI, etc...) or a programming interface) to a command interpreter and processor and to the broad capabilities of the operating system. For example, the default Windows GUI is a shell GUI named EXPLORER.EXE, as defined in the SHELL=EXPLORER.EXE line in the WIN.INI configuration file. This program, strictly speaking, is a shell GUI and, by extension, a shell (strictly speaking, the Windows shell is shell32.dll not explorer.exe, which is a shell GUI for shell32.dll), but it is not a CLI (command-line interpreter) nor a shell CLI (shell command-line interface).

Application command-line interfaces

Application programs (as opposed to operating systems) may also have command-line interfaces.

An application program may support none, any, or all of these three major types of command-line interface mechanisms:

• Parameters: Most command-line interfaces support a means to pass additional information to a program when it is launched.
• Interactive command-line sessions: After launch, a program may provide an operator with an independent means to enter commands.
• Inter-process communication: Most operating systems support means of inter-process communication (for example, standard streams or named pipes). Command lines from client processes may be redirected to a CLI program by one of these methods.

Some applications support a CLI, presenting their own prompt to the user and accepting command lines. Other programs support both a CLI and a GUI. In some cases, a GUI is simply a wrapper around a separate CLI executable file. In other cases, a program may provide a CLI as an optional alternative to its GUI. CLIs and GUIs often support different functionality. For example, all features of MATLAB, a numerical analysis computer program, are available via the CLI, whereas the MATLAB GUI exposes only a subset of features.

In Colossal Cave Adventure from 1975, the user uses a CLI to enter one or two words to explore a cave system.

CLI and resource protection

On some systems, such as Unix-like systems or Windows, one can modify the set of available commands by modifying which paths appear in the PATH environment variable or its equivalent. On Unix-like systems, the file containing the executable or script for a command also needs to be given execute permission. The directories in the path variable are searched in the order they are given. By re-ordering the path, one can run e.g. \OS2\MDOS\E.EXE instead of \OS2\E.EXE, when the default is the opposite. Renaming of the executables also works: people often rename their favourite editor to EDIT, for example.

The command line allows one to restrict available commands, such as access to advanced internal commands. The Bourne shell and workalikes such as Bash can be run as a restricted shell; among other things, this prohibits the user from modifying the PATH environment variable, so that if PATH is set to include only directories that contain only permissible commands, the user will only be able to run those commands. The Windows CMD.EXE also supports restricting available commands. Often, shareware programs will limit the range of commands, including printing a command 'your administrator has disabled running batch files' from the prompt.^{[clarification needed]}

Some CLIs, such as those in network routers, have a hierarchy of modes, with a different set of commands supported in each mode. The set of commands are grouped by association with security, system, interface, etc. In these systems, the user might traverse through a series of sub-modes. For example, if the CLI had two modes called interface and system, the user might use the command interface to enter the interface mode. At this point, commands from the system mode may not be accessible until the user exits the interface mode and enters the system mode.

In IBM's flagship MVS operating systems, the Authorised Program Facility (APF) allows certain authorized programs to run with enhanced privileges, analogous to UID(0) in Unix-like systems. TSO/E supports calling, e.g., authorized commands, but only for those commands, programs and services in an installation-controlled list.

Command prompt

A command prompt (or just prompt) is a sequence of (one or more) characters used in a command-line interface to indicate readiness to accept commands. It literally prompts the user to take action. A prompt usually ends with one of the characters $, %, #,^[21][22] :, > or -^[23] and often includes other information, such as the path of the current working directory and the hostname.

On many Unix and derivative systems, the prompt commonly ends in $ or % if the user is a normal user, but in # if the user is a superuser ("root" in Unix terminology).

End-users can often modify prompts. Depending on the environment, they may include colors, special characters, and other elements (like variables and functions for the current time, user, shell number or working directory) in order, for instance, to make the prompt more informative or visually pleasing, to distinguish sessions on various machines, or to indicate the current level of nesting of commands. On some systems, special tokens in the definition of the prompt can be used to cause external programs to be called by the command-line interpreter while displaying the prompt.

In DOS' COMMAND.COM and in Windows NT's cmd.exe users can modify the prompt by issuing a PROMPT command or by directly changing the value of the corresponding %PROMPT% environment variable. The default of most modern systems, the C:\> style is obtained, for instance, with PROMPT $P$G. The default of older DOS systems, C> is obtained by just PROMPT, although on some systems this produces the newer C:\> style, unless used on floppy drives A: or B:; on those systems PROMPT $N$G can be used to override the automatic default and explicitly switch to the older style.

Many Unix systems feature the $PS1 variable (Prompt String 1),^[24] although other variables also may affect the prompt (depending on the shell used). In the Bash shell, a prompt of the form:

[time] user@host: work_dir $

could be set by issuing the command

export PS1='[\t] \u@\H: \W $'

In zsh the $RPROMPT variable controls an optional prompt on the right-hand side of the display. It is not a real prompt in that the location of text entry does not change. It is used to display information on the same line as the prompt, but right-justified.

In RISC OS the command prompt is a * symbol, and thus (OS) CLI commands are often referred to as star commands.^[25] One can also access the same commands from other command lines (such as the BBC BASIC command line), by preceding the command with a *.

In IBM's TSO, the command prompt is referred to as the READY prompt, after the word READY in the prompt.

Example of prompt system displays

All the information that can be displayed by the "Liquidprompt" command prompt system, here using its "Jolly" theme

Liquidprompt display example, using its default theme

Liquidprompt display example, using its "Pureship" theme

Liquidprompt display example, using its "Powerline" theme

Some shells, such as Bash, zsh, and PowerShell, allow the use of prompt systems that display a lot more information in the command prompt, like the type of remote connection, the state of machine sensors, or additional information about a version control system. They often use several ANSI colors, Unicode characters, and advanced shell features to set up a colorful display.

Arguments

This article needs more citations. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. Find sources: "Command-line interface" – news · newspapers · books · scholar · JSTOR (June 2026) (Learn how and when to remove this message)

A command-line argument or parameter is an item of information provided to a program when it is started.^[26] A program can have many command-line arguments that identify sources or destinations of information, or that alter the operation of the program.

When a command processor is active a program is typically invoked by typing its name followed by command-line arguments (if any). For example, in Unix and Unix-like environments, an example of a command-line argument is:

rm file.s

file.s is a command-line argument which tells the program rm to remove the file named file.s.

Some programming languages, such as C, C++ and Java, allow a program to interpret the command-line arguments by handling them as string parameters in the main function.^[27][28] Other languages, such as Python, expose operating system specific API (functionality) through the sys module,^[29] and in particular sys.argv for command-line arguments.

In Unix-like operating systems, a single hyphen used in place of a file name is a special value specifying that a program should handle data coming from the standard input or send data to the standard output.

Command-line option

A command-line option or simply option (also known as a flag or switch) modifies the operation of a command; the effect is determined by the command's program. Options follow the command name on the command line, separated by, e.g., commas or spaces. Separators are not always required, such as Dir/? and DIR /? in DOS, which have the same effect^[23] of listing the DIR command's available options, whereas dir --help (in many versions of Unix) does require the option to be preceded by at least one space (and is case-sensitive).

The format of options varies widely between operating systems. In most cases, the syntax is by convention rather than an operating system requirement; the entire command line is simply a string passed to a program, which can process it in any way the programmer wants, so long as the interpreter can tell where the command name ends and its arguments and options begin.

A few representative samples of command-line options, most relating to listing files in a directory, to illustrate some conventions:

Operating system	Command	Valid alternative	Notes
OpenVMS	directory/owner	Dir /Owner	instruct the directory command to also display the ownership of the files. Note the Directory command name is not case sensitive, and can be abbreviated to as few letters as required to remain unique.
Windows	DIR/Q/O:S d*	dir /q d* /o:s	display ownership of files whose names begin with d (or D), sorted by size, smallest first. Note spaces around argument d* are required.
Unix-like systems	ls -lS D*	ls -S -l D*	display in long format files and directories whose names begin with D (but not d), sorted by size (largest first). Note spaces are required around all arguments and options, but some can be run together, e.g. -lS is the same as -l -S.
Data General RDOS CLI	list/e/s 04-26-80/b	List /S/E 4-26-80/B	list every attribute for files created before 26 April 1980. Note the /B at the end of the date argument is a local switch, that modifies the meaning of that argument, while /S and /E are global switches, i.e. apply to the whole command.
VM/CMS CLI	LISTFILE (FULLDATE)	l(ful	includes the date the file was last written in the list. Note the LISTFILE command name is not case sensitive, and can be abbreviated to as few letters as required to remain unique.
OS/360 operator commands	START TAPERDR,DSNAME=FOO.BAR	S TAPERDR,DSN=FOO.BAR	Start the procedure named TAPERDR with the supplied data set name
TSO	LISTCAT LEVEL(FOO) MEMBERS	LISTC L(FOO) M	List datasets at specified index level and list members for each PDS.
	SEND 'text' USER(FOO)	SE 'text' U(FOO)	Send message to specified user

Command-line argument parsing is used to parse the arguments of a program, and such functionality is offered in various languages. For example, getopt() is in the C POSIX library for parsing arguments.

Abbreviating commands

See also: Tab completion

In Multics, command-line options and subsystem keywords may be abbreviated. This idea appears to derive from the PL/I programming language, with its shortened keywords (e.g., STRG for STRINGRANGE and DCL for DECLARE). For example, in the Multics forum subsystem, the -long_subject parameter can be abbreviated -lgsj. It is also common for Multics commands to be abbreviated, typically corresponding to the initial letters of the words that are strung together with underscores to form command names, such as the use of did for delete_iacl_dir.

In some other systems abbreviations are automatic, such as permitting enough of the first characters of a command name to uniquely identify it (such as SU as an abbreviation for SUPERUSER) while others may have some specific abbreviations pre-programmed (e.g. MD for MKDIR in COMMAND.COM) or user-defined via batch scripts and aliases (e.g. alias md mkdir in tcsh).

Option conventions in DOS, Windows, OS/2

On DOS, OS/2 and Windows, different programs called from their COMMAND.COM or CMD.EXE (or internally their commands) may use different syntax within the same operating system. For example:

• Options may be indicated by either of the switch characters: /, -, or either may be allowed. See below.
• They may or may not be case-sensitive.
• Sometimes options and their arguments are run together, sometimes separated by whitespace, and sometimes by a character, typically : or =; thus Prog -fFilename, Prog -f Filename, Prog -f:Filename, Prog -f=Filename.
• Some programs allow single-character options to be combined;^[23] others do not. The switch -fA may mean the same as -f -A,^[23] or it may be incorrect, or it may even be a valid but different parameter.

In DOS, OS/2 and Windows, the forward slash (/) is most prevalent, although the hyphen-minus is also sometimes used. In many versions of DOS (MS-DOS/PC DOS 2.xx and higher, all versions of DR-DOS since 5.0, as well as PTS-DOS, Embedded DOS, FreeDOS and RxDOS) the switch character (sometimes abbreviated switchar or switchchar) to be used is defined by a value returned from a system call (INT 21h/AX=3700h). The default character returned by this API is /, but can be changed to a hyphen-minus on the above-mentioned systems, except for under Datalight ROM-DOS and MS-DOS/PC DOS 5.0 and higher, which always return / from this call (unless one of many available TSRs to reenable the SwitChar feature is loaded). In some of these systems (MS-DOS/PC DOS 2.xx, DOS Plus 2.1, DR-DOS 7.02 and higher, PTS-DOS, Embedded DOS, FreeDOS and RxDOS), the setting can also be pre-configured by a SWITCHAR directive in CONFIG.SYS. General Software's Embedded DOS provides a SWITCH command for the same purpose, whereas 4DOS allows the setting to be changed via SETDOS /W:n.^[30] Under DR-DOS, if the setting has been changed from /, the first directory separator \ in the display of the PROMPT parameter $G will change to a forward slash / (which is also a valid directory separator in DOS, FlexOS, 4680 OS, 4690 OS, OS/2 and Windows) thereby serving as a visual clue to indicate the change.^[23] Also, the current setting is reflected also in the built-in help screens.^[23] Some versions of DR-DOS COMMAND.COM also support a PROMPT token $/ to display the current setting. COMMAND.COM since DR-DOS 7.02 also provides a pseudo-environment variable named %/% to allow portable batch jobs to be written.^[31][32] Several external DR-DOS commands additionally support an environment variable %SWITCHAR% to override the system setting.

However, many programs are hardwired to use / only, rather than retrieving the switch setting before parsing command-line arguments. A very small number, mainly ports from Unix-like systems, are programmed to accept - even if the switch character is not set to it (for example netstat and ping, supplied with Microsoft Windows, will accept the /? option to list available options, and yet the list will specify the - convention).

Option conventions in Unix-like systems

This section needs more citations. Please help improve this section by adding citations to reliable sources. Unsourced material may be challenged and removed. (July 2021) (Learn how and when to remove this message)

In Unix-like systems, the ASCII hyphen-minus begins options; the new (and GNU) convention is to use two hyphens then a word (e.g. --create) to identify the option's use while the old convention (and still available as an option for frequently used options) is to use one hyphen then one letter (e.g., -c); if one hyphen is followed by two or more letters it may mean two options are being specified, or it may mean the second and subsequent letters are a parameter (such as filename or date) for the first option.^[33]

Two hyphen-minus characters without following letters (--) may indicate that the remaining arguments should not be treated as options, which is useful, for example, if a file name itself begins with a hyphen, or if further arguments are meant for an inner command (e.g., sudo). Double hyphen-minuses are also sometimes used to prefix long options where more descriptive option names are used. This is a common feature of GNU software. The getopt function and program, and the getopts command are usually used for parsing command-line options.

Unix command names, arguments and options are case-sensitive (except in a few examples, mainly where popular commands from other operating systems have been ported to Unix).

Option conventions in other systems

FlexOS, 4680 OS and 4690 OS use -.

CP/M typically used [.

Conversational Monitor System (CMS) uses a single left parenthesis to separate options at the end of the command from the other arguments. For example, in the following command, the options indicate that the target file should be replaced if it exists, and the date and time of the source file should be retained on the copy: COPY source file a target file b (REPLACE OLDDATE)

OS/360 operator commands use a comma-separated list of positional and keyword parameters; only documented command and keyword abbreviations are valid. Keyword values are separated from the keywords with equal signs.

TSO commands use a space-separated list of positional and keyword parameters; keywords may be truncated to any unique substring. Only documented command abbreviations are valid. Keyword values are inside parentheses.

Data General's CLI under their RDOS, AOS, etc. operating systems, as well as the version of CLI that came with their Business Basic, uses only / as the switch character, is case-insensitive, and allows local switches on some arguments to control the way they are interpreted, such as MAC/U LIB/S A B C $LPT/L has the global option U to the macro assembler command to append user symbols, but two local switches, one to specify LIB should be skipped on pass 2 and the other to direct listing to the printer, $LPT.

Built-in usage help

One of the criticisms of a CLI is the lack of cues to the user as to the available actions.^[34] In contrast, GUIs usually inform the user of available actions with menus, icons, or other visual cues.^[35] To overcome this limitation, many CLI programs display a usage message, typically when invoked with no arguments or one of ?, -?, -h, -H, /?, /h, /H, /Help, -help, or --help.^[23][36]

However, entering a program name without parameters in the hope that it will display usage help can be hazardous, as programs and scripts for which command line arguments are optional will execute without further notice.

Although desirable at least for the help parameter, programs may not support all option lead-in characters exemplified above. Under DOS, where the default command-line option character can be changed from / to -, programs may query the SwitChar API in order to determine the current setting. So, if a program is not hardwired to support them all, a user may need to know the current setting even to be able to reliably request help. If the SwitChar has been changed to - and therefore the / character is accepted as an alternative path delimiter at the DOS command line, programs might misinterpret options like /h or /H as paths rather than help parameters.^[23] However, if given as the first or only parameter, most DOS programs will, by convention, accept it as a request for help regardless of the current SwitChar setting.^[23][30]

In some cases, different levels of help can be selected for a program. Some programs supporting this allow giving a verbosity level as an optional argument to the help parameter (as in /H:1, /H:2, etc.) or they give just a short help on help parameters with a question mark and a longer help screen for the other help options.^[37]

Depending on the program, additional or more specific help on accepted parameters is sometimes available by either providing the parameter in question as an argument to the help parameter or vice versa (as in /H:W or in /W:? (assuming /W would be another parameter supported by the program)).^{[38][39][36][37][nb 1]}

In a similar fashion to the help parameter, but much less common, some programs provide additional information about themselves (like mode, status, version, author, license or contact information) when invoked with an about parameter like -!, /!, -about, or --about.^[36]

Since the ? and ! characters typically also serve other purposes at the command line, they may not be available in all scenarios, therefore, they should not be the only options to access the corresponding help information.

If more detailed help is necessary than provided by a program's built-in internal help, many systems support a dedicated external help command" command (or similar), which accepts a command name as a calling parameter and will invoke an external help system.

In the DR-DOS family, typing /? or /H at the COMMAND.COM prompt instead of a command itself will display a dynamically generated list of available internal commands;^[23] 4DOS and NDOS support the same feature by typing ? at the prompt^[30] (which is also accepted by newer versions of DR-DOS COMMAND.COM); internal commands can be individually disabled or reenabled via SETDOS /I.^[30] In addition to this, some newer versions of DR-DOS COMMAND.COM also accept a ?% command to display a list of available built-in pseudo-environment variables. Besides their purpose as quick help reference, this can be used in batch jobs to query the facilities of the underlying command-line processor.^[23]

Command description syntax

Built-in usage help and man pages commonly employ a small syntax to describe the valid command form:^{[40][41][42][nb 2]}

• angle brackets for required parameters: ping <hostname>
• square brackets for optional parameters: mkdir [-p] <dirname>
• ellipses for repeated items: cp <source1> [source2…] <dest>
• vertical bars for choice of items: netstat {-t|-u}

Notice that these characters have different meanings than when used directly in the shell. Angle brackets may be omitted when confusing the parameter name with a literal string is not likely.

The space character

In many areas of computing, but particularly in the command line, the space character can cause problems as it has two distinct and incompatible functions: as part of a command or parameter, or as a parameter or name separator. Ambiguity can be prevented either by prohibiting embedded spaces in file and directory names in the first place (for example, by substituting them with underscores _), or by enclosing a name with embedded spaces between quote characters or using an escape character before the space, usually a backslash (\). For example

Long path/Long program name Parameter one Parameter two …

is ambiguous (is program name part of the program name, or two parameters?); however

Long_path/Long_program_name Parameter_one Parameter_two …,

LongPath/LongProgramName ParameterOne ParameterTwo …,

"Long path/Long program name" "Parameter one" "Parameter two" …

and

Long\ path/Long\ program\ name Parameter\ one Parameter\ two …

are not ambiguous. Unix-based operating systems minimize the use of embedded spaces to minimize the need for quotes. In Microsoft Windows, one often has to use quotes because embedded spaces (such as in directory names) are common.

Early history

The earliest computers did not support interactive input/output devices, often relying on sense switches and lights to communicate with the computer operator. This was adequate for batch systems that ran one program at a time, often with the programmer acting as operator. This also had the advantage of low overhead, since lights and switches could be tested and set with one machine instruction. Later a single system console was added to allow the operator to communicate with the system.

From the 1960s onwards, user interaction with computers was primarily by means of command-line interfaces, initially on machines like the Teletype Model 33 ASR, but then on early CRT-based computer terminals such as the VT52.

All of these devices were purely text based, with no ability to display graphics or pictures.^{[nb 3]} For business application programs, text-based menus were used, but for more general interaction the command line was the interface.

Around 1964 Louis Pouzin introduced the concept and the name shell in Multics, building on earlier, simpler facilities in the Compatible Time-Sharing System (CTSS).^{[44][better source needed]}

From the early 1970s, the Unix operating system adapted the concept of a powerful command-line environment, and introduced the ability to pipe the output of one command in as input to another. Unix also had the capability to save and re-run strings of commands as shell scripts which acted like custom commands.

The command line was also the main interface for the early home computers such as the Commodore PET, Apple II and BBC Micro – almost always in the form of a BASIC interpreter. When more powerful business-oriented microcomputers arrived with CP/M and later DOS computers such as the IBM PC, the command line began to borrow some of the syntax and features of the Unix shells such as globbing and piping of output.

The command line was first seriously challenged by the PARC GUI approach used in the 1983 Apple Lisa and the 1984 Apple Macintosh. A few computer users used GUIs such as GEOS and Windows 3.1 but the majority of IBM PC users did not replace their COMMAND.COM shell with a GUI until Windows 95 was released in 1995.^[45][46]

Modern usage as an operating system shell

While most non-expert computer users now use a GUI almost exclusively, more advanced users have access to powerful command-line environments:

• Unix-like systems include the Bourne shell and compatible shells such as Bash, and other Unix shells.
  • FreeBSD uses tcsh as its default interactive shell for the superuser, and ash as default scripting shell.
  • Many Linux distributions have Bash.
  • Apple macOS and some Linux distributions use zsh. Previously, macOS used tcsh and Bash.
  • Embedded Linux (and other embedded Unix-like) systems often use ash, as part of Busybox.
  • Android uses the mksh shell,^[47] which replaces a shell derived from ash^[48] that was used in older Android versions, supplemented with commands from the separate toolbox^[49] binary.
• OpenVMS uses the DIGITAL Command Language (DCL).
  • Unix command shells have been ported to OpenVMS.
• DOS and Windows have several command-line environments
  • COMMAND.COM is the command-line interpreter of MS-DOS, IBM PC DOS, and Windows 9x, as well as clones such as DR-DOS, SISNE plus, PTS-DOS, ROM-DOS, and FreeDOS.
  • Windows NT has cmd.exe, and later versions have PowerShell
  • The Windows Resource Kit and Windows Services for UNIX include Korn and the Bourne shells along with a Perl interpreter (Services for UNIX contains ActiveState ActivePerl in later versions and Interix for versions 1 and 2 and a shell compiled by Microsoft)
  • Windows users might use the CScript interface to alternate programs, from the command line. Implementations of the Unix shell are also available as part of the POSIX sub-system,^[50] Cygwin, MKS Toolkit, UWIN, Hamilton C shell and other software packages. Available shells for these interoperability tools include csh, ksh, sh, Bash, rsh, tclsh and less commonly zsh, psh
  • DCL has been ported to Windows systems at least three times, including PC-DCL and Acceler8 DCL Lite.
  • Yet another cmd.exe is a stripped-down shell for Windows CE 3.0.
  • An MS-DOS type interpreter called PocketDOS has been ported to Windows CE machines; the most recent release is almost identical to MS-DOS 6.22 and can also run Windows 1, 2, and 3.0, QBasic and other development tools, 4NT and 4DOS. The latest release includes several shells, namely MS-DOS 6.22, PC DOS 7, DR DOS 3.xx, and others.
• IBM OS/2 (and derivatives such as eComStation and ArcaOS) has the cmd.exe processor. This copies the COMMAND.COM commands, with extensions to REXX.
• Implementations of PHP have a shell for interactive use called php-cli.
• Standard Tcl/Tk has two interactive shells, Tclsh and Wish, the latter being the GUI version.
• Python, Ruby, Lua, XLNT, and other interpreters also have command shells for interactive use.
• HarmonyOS, OpenHarmony and Oniro use the commands from third-party toolbox compatibility system attached to Linux kernel of the KAL subsystem and POSIX (musl-libc) library with Linux ABI of HongMeng kernel alongside default Shell with its own native exec commands.^[51][52]
• Routers with Cisco IOS,^[53] Junos^[54] and many others are commonly configured from the command line.
• The Plan 9 operating system uses the rc shell, which is similar in design to the Bourne shell.