Acommand-line interface (CLI) is a means of interacting with acomputer program by inputting lines of text calledcommand lines. Command-line interfaces emerged in the mid-1960s, oncomputer terminals, as an interactive and more user-friendly alternative to the non-interactive mode available withpunched cards.[1]
Today, most computer users rely ongraphical user interfaces ("GUIs") instead of CLIs. However, many programs andoperating systemutilities lack GUIs, and are intended to be used through CLIs.
Knowledge of CLIs is also useful forautomation of programs via the writing ofscripts. Automation is a more accessible option for programs that have CLIs, in contrast to purely graphical UI's, since many individual commands can be described together into single files called scripts. Executed individually as programs in their own right, scripts allow the group of CLI commands that they contain to be executed at the same time as a single batch of commands.
CLIs are made possible bycommand-line interpreters orcommand-line processors, which are programs that read command lines and carry out the commands.
Alternatives to CLIs include GUIs (most notablydesktop metaphors with amouse pointer, such asMicrosoft Windows),text-based user interfacemenus (such asDOS Shell andIBM AIX SMIT), andkeyboard shortcuts.
Compared with a graphical user interface, a command-line interface requires fewer system resources to implement. Since options to commands are given in a few characters in each command line, an experienced user often finds the options easier to access. Automation of repetitive tasks is simplified by line editing and history mechanisms for storing frequently used sequences; this may extend to ascripting language that can take parameters and variable options. A command-line history can be kept, allowing review or repetition of commands.
A command-line system may require paper or online manuals for the user's reference, although often ahelp option provides a concise review of the options of a command. The command-line environment may not provide graphical enhancements such as differentfonts or extendededit windows found in a GUI. It may be difficult for a new user to become familiar with all the commands and options available, compared with theicons anddrop-down menus of a graphical user interface, without reference to manuals.
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 orshell.
Examples of command-line interpreters includeNushell,DEC'sDIGITAL Command Language (DCL) inOpenVMS andRSX-11, the variousUnix shells (sh,ksh,csh,tcsh,zsh,Bash, etc.),CP/M'sCCP,DOS'COMMAND.COM, as well as theOS/2 and the WindowsCMD.EXE programs, the latter groups being based heavily on DEC's RSX-11 andRSTS CLIs. Under most operating systems, it is possible to replace the default shell program with alternatives; examples include4DOS for DOS,4OS2 for OS/2, and4NT / Take Command for Windows.
Although the termshell is often used to describe a command-line interpreter, strictly speaking, ashell can be any program that constitutes the user interface, including fully graphically oriented ones. For example, the default Windows GUI is a shell program namedEXPLORER.EXE, as defined in the SHELL=EXPLORER.EXE line in the WIN.INI configuration file. These programs are shells, but not CLIs.
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:
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 awrapper around a separate CLIexecutable 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 ofMATLAB, anumerical analysis computer program, are available via the CLI, whereas the MATLAB GUI exposes only a subset of features.
InColossal Cave Adventure from 1975, the user uses a CLI to enter one or two words to explore a cave system.
The command-line interface evolved from a form of communication conducted by people overteleprinter (TTY) machines. Sometimes these involved sending an order or a confirmation usingtelex. Early computer systems often used teleprinter as the means of interaction with an operator.
The mechanical teleprinter was replaced by a"glass tty", a keyboard and screen emulating the teleprinter."Smart" terminals permitted additional functions, such as cursor movement over the entire screen, or local editing of data on the terminal for transmission to the computer. As themicrocomputer revolution replaced the traditional – minicomputer + terminals – time sharing architecture, hardware terminals were replaced byterminal emulators — PC software that interpreted terminal signals sent through the PC'sserial ports. These were typically used to interface an organization's new PC's with their existing mini- or mainframe computers, or to connect PC to PC. Some of these PCs were runningBulletin Board System software.
Early operating system CLIs were implemented as part ofresident monitor programs, and could not easily be replaced. The first implementation of the shell as a replaceable component was part of theMulticstime-sharingoperating system.[2] In 1964,MIT Computation Center staff memberLouis Pouzin developed theRUNCOM tool for executing command scripts while allowing argument substitution.[3] Pouzin coined the termshell to describe the technique of using commands like a programming language, and wrote a paper about how to implement the idea in theMultics operating system.[4] Pouzin returned to his native France in 1965, and the first Multics shell was developed byGlenda Schroeder.[3]
The firstUnix shell, theV6 shell, was developed byKen Thompson in 1971 atBell Labs and was modeled after Schroeder's Multics shell.[5][6] TheBourne shell was introduced in 1977 as a replacement for the V6 shell. Although it is used as an interactive command interpreter, it was also intended as a scripting language and contains most of the features that are commonly considered to produce structured programs. The Bourne shell led to the development of theKornShell (ksh),Almquist shell (ash), and the popularBourne-again shell (or Bash).[6]
Early microcomputers themselves were based on a command-line interface such asCP/M,DOS orAppleSoft BASIC. During the 1980s and 1990s, the introduction of theApple Macintosh and ofMicrosoft Windows on PCs saw the command line interface as the primary user interface replaced by theGraphical User Interface.[7] The command line remained available as an alternative user interface, often used bysystem administrators and other advanced users for system administration,computer programming andbatch processing.
In November 2006,Microsoft released version 1.0 ofWindows PowerShell (formerly codenamedMonad), which combined features of traditional Unix shells with their proprietary object-oriented.NET Framework.MinGW andCygwin areopen-source packages for Windows that offer a Unix-like CLI. Microsoft providesMKS Inc.'sksh implementationMKS Korn shell for Windows through theirServices for UNIX add-on.
Since 2001, theMacintosh operating systemmacOS has been based on aUnix-like operating system calledDarwin.[8] On these computers, users can access a Unix-like command-line interface by running theterminal emulator program calledTerminal, which is found in the Utilities sub-folder of the Applications folder, or by remotely logging into the machine usingssh.Z shell is the default shell for macOS; Bash,tcsh, and theKornShell are also provided. BeforemacOS Catalina, Bash was the default.
A CLI is used whenever a large vocabulary of commands or queries, coupled with a wide (or arbitrary) range of options, can be entered more rapidly as text than with a pure GUI. This is typically the case withoperating system command shells. CLIs are also used by systems with insufficient resources to support a graphical user interface. Some computer language systems (such asPython,[9]Forth,LISP,Rexx, and many dialects ofBASIC) provide an interactive command-line mode to allow for rapid evaluation of code.
CLIs are often used by programmers and system administrators, in engineering and scientific environments, and by technically advanced personal computer users.[10] CLIs are also popular among people with visual disabilities since the commands and responses can be displayed usingrefreshable Braille displays.
The general pattern of a command line interface[11][12] is:
Prompt command param1 param2 param3 … paramN
In this format, the delimiters between command-line elements arewhitespace characters and the end-of-line delimiter is thenewline delimiter. This is a widely used (but not universal) convention.
A CLI can generally be considered as consisting ofsyntax andsemantics. Thesyntax is the grammar that all commands must follow. In the case ofoperating systems,DOS andUnix each define their own set of rules that all commands must follow. In the case ofembedded systems, each vendor, such asNortel,Juniper Networks orCisco Systems, defines their own proprietary set of rules. These rules also dictate how a user navigates through the system of commands. Thesemantics define what sort of operations are possible, on what sort of data these operations can be performed, and how the grammar represents these operations and data—the symbolic meaning in the syntax.
Two different CLIs may agree on either syntax or semantics, but it is only when they agree on both that they can be considered sufficiently similar to allow users to use both CLIs without needing to learn anything, as well as to enable re-use of scripts.
A simple CLI will display a prompt, accept acommand line typed by the user terminated by theEnter key, then execute the specified command and provide textual display of results or error messages. Advanced CLIs will validate, interpret and parameter-expand the command line before executing the specified command, and optionally capture or redirect its output.
Unlike a button or menu item in a GUI, a command line is typically self-documenting,[16] stating exactly what the user wants done. In addition, command lines usually include manydefaults that can be changed to customize the results. Useful command lines can be saved by assigning acharacter string oralias to represent the full command, or several commands can be grouped to perform a more complex sequence – for instance, compile the program, install it, and run it — creating a single entity, called a command procedure or script which itself can be treated as a command. These advantages mean that a user must figure out a complex command or series of commands only once, because they can be saved, to be used again.
The commands given to a CLI shell are often in one of the following forms:
doSomething how toFilesdoSomething how sourceFile destinationFiledoSomething how < inputFile > outputFiledoSomething how | doSomething how | doSomething how > outputFilewheredoSomething is, in effect, averb,how anadverb (for example, should the command be executedverbosely orquietly) andtoFiles an object or objects (typically one or more files) on which the command should act. The> in the third example is aredirection operator, telling the command-line interpreter to send the output of the command not to its own standard output (the screen) but to the named file. This will overwrite the file. Using>> will redirect the output and append it to the file. Another redirection operator is thevertical bar (|), which creates apipeline where the output of one command becomes the input to the next command.[17]
One can modify the set of available commands by modifying which paths appear in thePATH environment variable. Under Unix, commands also need be marked asexecutable files. 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 WindowsCMD.EXE does this. 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 innetwork routers, have a hierarchy ofmodes, 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 calledinterface andsystem, the user might use the commandinterface 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.
A command prompt (or justprompt) is a sequence of (one or more) characters used in a command-line interface to indicate readiness to accept commands. It literallyprompts the user to take action. A prompt usually ends with one of the characters$,%,#,[18][19]:,> or-[20] and often includes other information, such as the path of the currentworking directory and thehostname.
On manyUnix andderivative systems, the prompt commonly ends in$ or% if the user is a normal user, but in# if the user is asuperuser ("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'scmd.exe users can modify the prompt by issuing aPROMPT command or by directly changing the value of the corresponding%PROMPT%environment variable. The default of most modern systems, theC:\> style is obtained, for instance, withPROMPT $P$G. The default of older DOS systems,C> is obtained by justPROMPT, although on some systems this produces the newerC:\> style, unless used on floppy drives A: or B:; on those systemsPROMPT $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),[21] although other variables also may affect the prompt (depending on theshell used). In the Bash shell, a prompt of the form:
[time]user@host:work_dir$
could be set by issuing the command
exportPS1='[\t] \u@\H: \W $'
Inzsh the$RPROMPT variable controls an optionalprompt 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.
InRISC OS the command prompt is a* symbol, and thus (OS) CLI commands are often referred to asstar commands.[22] One can also access the same commands from other command lines (such as theBBC BASIC command line), by preceding the command with a*.
 | This sectiondoes notcite anysources. Please helpimprove this section byadding citations to reliable sources. Unsourced material may be challenged andremoved.(October 2023) (Learn how and when to remove this message) |
Acommand-line argument orparameter is an item of information provided to a program when it is started.[23] 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, inUnix andUnix-like environments, an example of a command-line argument is:
rmfile.s
file.s is a command-line argument which tells the programrm to remove the file namedfile.s.
Some programming languages, such asC,C++ andJava, allow a program to interpret the command-line arguments by handling them as string parameters in themain function.[24][25] Other languages, such asPython, expose operating system specificAPI (functionality) throughsysmodule, and in particularsys.argv forcommand-line arguments.
InUnix-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 thestandard input or send data to thestandard output.
Acommand-line option or simplyoption (also known as aflag orswitch) 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 spaces. A space before the first option is not always required, such asDir/? andDIR /? in DOS, which have the same effect[20] of listing the DIR command's available options, whereasdir --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, all relating to listing files in a directory, to illustrate some conventions:
| Operating system | Command | Valid alternative | Notes |
|---|---|---|---|
| OpenVMS | directory/owner | Dir /Owner | instruct thedirectory 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 RDOSCLI | 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 alocal switch, that modifies the meaning of that argument, while /S and /E areglobal 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. |
InMultics, command-line options and subsystem keywords may be abbreviated. This idea appears to derive from thePL/I programming language, with its shortened keywords (e.g., STRG for STRINGRANGE and DCL for DECLARE). For example, in the Multicsforum 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 ofdid fordelete_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 asSU as an abbreviation forSUPERUSER) while others may have some specific abbreviations pre-programmed (e.g.MD forMKDIR in COMMAND.COM) or user-defined via batch scripts andaliases (e.g.alias md mkdir intcsh).
On DOS, OS/2 and Windows, different programs called from their COMMAND.COM or CMD.EXE (or internal their commands) may use different syntax within the same operating system. For example:
/,-, or either may be allowed. See below.: or=; thusProg -fFilename,Prog -f Filename,Prog -f:Filename,Prog -f=Filename.-fA may mean the same as-f -A,[20] or it may be incorrect, or it may even be a valid but different parameter.InDOS,OS/2 andWindows, 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 ofDR-DOS since 5.0, as well asPTS-DOS,Embedded DOS,FreeDOS andRxDOS) theswitch character (sometimes abbreviatedswitchar orswitchchar) to be used is defined by a value returned from asystem 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 availableTSRs 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 aSWITCHAR directive inCONFIG.SYS. General Software's Embedded DOS provides a SWITCH command for the same purpose, whereas4DOS allows the setting to be changed viaSETDOS /W:n.[26] Under DR-DOS, if the setting has been changed from/, the first directory separator\ in the display of thePROMPT 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.[20] Also, the current setting is reflected also in the built-in help screens.[20] Some versions of DR-DOSCOMMAND.COM also support a PROMPT token$/ to display the current setting. COMMAND.COM since DR-DOS 7.02 also provides apseudo-environment variable named%/% to allow portable batchjobs to be written.[27][28] Several external DR-DOS commands additionally support anenvironment 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 examplenetstat andping, supplied withMicrosoft Windows, will accept the /? option to list available options, and yet the list will specify the- convention).
| This sectionneeds additional citations forverification. Please helpimprove this article byadding citations to reliable sources in this section. Unsourced material may be challenged and removed.(July 2021) (Learn how and when to remove this message) |
InUnix-like systems, the ASCIIhyphen-minus begins options; the new (andGNU) convention is to usetwo 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.[29]
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 prefixlong options where more descriptive option names are used. This is a common feature ofGNU software. Thegetopt function and program, and thegetopts 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).
FlexOS,4680 OS and4690 OS use-.
CP/M typically used[.
Conversational Monitor System (CMS) uses a singleleft 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)
Data General's CLI under theirRDOS,AOS, etc. operating systems, as well as the version of CLI that came with theirBusiness Basic, uses only/ as the switch character, is case-insensitive, and allowslocal switches on some arguments to control the way they are interpreted, such asMAC/U LIB/S A B C $LPT/L has the global optionU 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.
One of the criticisms of a CLI is the lack of cues to the user as to the available actions.[citation needed] In contrast, GUIs usually inform the user of available actions with menus, icons, or other visual cues.[citation needed] To overcome this limitation, many CLI programs display ausage message, typically when invoked with no arguments or one of?,-?,-h,-H,/?,/h,/H,/Help,-help, or--help.[20][30][31]
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 defaultcommand-line option character can be changed from/ to-, programs may query theSwitChar 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 alternative path delimiter also at the DOS command line, programs may misinterpret options like/h or/H as paths rather than help parameters.[20] However, if given as first or only parameter, most DOS programs will, by convention, accept it as request for help regardless of the current SwitChar setting.[20][26]
In some cases, different levels of help can be selected for a program. Some programs supporting this allow to give 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 question mark and a longer help screen for the other help options.[32]
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)).[33][34][31][30][32][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 anabout parameter like-!,/!,-about, or--about.[30]
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 externalhelpcommand" command (or similar), which accepts a command name as calling parameter and will invoke an external help system.
In the DR-DOS family, typing/? or/H at theCOMMAND.COM prompt instead of a command itself will display a dynamically generated list of available internal commands;[20]4DOS andNDOS support the same feature by typing? at the prompt[26] (which is also accepted by newer versions of DR-DOS COMMAND.COM); internal commands can be individually disabled or reenabled viaSETDOS /I.[26] In addition to this, some newer versions of DR-DOS COMMAND.COM also accept a?% command to display a list of available built-inpseudo-environment variables. Besides their purpose as quick help reference this can be used in batchjobs to query the facilities of the underlying command-line processor.[20]
Built-in usage help andman pages commonly employ a small syntax to describe the valid command form:[35][36][37][nb 2]
ping <hostname>mkdir [-p] <dirname>cp <source1> [source2…] <dest>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.
In many areas of computing, but particularly in the command line, thespace character can cause problems as it has two distinct and incompatible functions: as part of a command or parameter, or as a parameter or nameseparator. Ambiguity can be prevented either by prohibiting embedded spaces in file and directory names in the first place (for example, by substituting them withunderscores_), or by enclosing a name with embedded spaces between quote characters or using anescape character before the space, usually abackslash (\). For example
Long path/Long program name Parameter one Parameter two …is ambiguous (isprogram 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. InMicrosoft Windows, one often has to use quotes because embedded spaces (such as in directory names) are common.
Although most users think of the shell as an interactive command interpreter, it is really a programming language in which each statement runs a command. Because it must satisfy both the interactive and programming aspects of command execution, it is a strange language, shaped as much by history as by design.
The termcommand-line interpreter (CLI) is applied tocomputer programs designed tointerpret a sequence of lines of text which may be entered by a user, read from afile or another kind ofdata stream. The context of interpretation is usually one of a givenoperating system orprogramming language.
Command-line interpreters allow users to issue various commands in a very efficient (and often terse) way. This requires the user to know the names of the commands and their parameters, and the syntax of thelanguage that is interpreted.
The Unix#! mechanism and OS/2 EXTPROC command facilitate the passing of batch files to external processors. One can use these mechanisms to write specific command processors for dedicated uses, and process external data files which reside in batch files.
Many graphical interfaces, such as the OS/2Presentation Manager and early versions of Microsoft Windows use command lines to call helper programs to open documents and programs. The commands are stored in the graphical shell[clarification needed] or in files like the registry or theOS/2OS2USER.INI file.
The earliest computers did not support interactive input/output devices, often relying onsense switches and lights to communicate with thecomputer operator. This was adequate forbatch 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 singlesystem 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 theTeletype Model 33 ASR, but then on earlyCRT-basedcomputer terminals such as theVT52.
All of these devices were purely text based, with no ability to display graphic or pictures.[nb 3] For businessapplication programs, text-basedmenus were used, but for more general interaction the command line was the interface.
Around 1964Louis Pouzin introduced the concept and the nameshell inMultics, building on earlier, simpler facilities in theCompatible Time-Sharing System (CTSS).[39][better source needed]
From the early 1970s theUnix operating system adapted the concept of a powerful command-line environment, and introduced the ability topipe the output of one command in as input to another. Unix also had the capability to save and re-run strings of commands asshell scripts which acted like custom commands.
The command line was also the main interface for the early home computers such as theCommodore PET,Apple II andBBC Micro – almost always in the form of aBASIC interpreter. When more powerful business-oriented microcomputers arrived withCP/M and laterDOS computers such as theIBM PC, the command line began to borrow some of the syntax and features of the Unix shells such asglobbing andpiping of output.
The command line was first seriously challenged by thePARCGUI approach used in the 1983Apple Lisa and the 1984Apple Macintosh. A few computer users used GUIs such asGEOS andWindows 3.1 but the majority ofIBM PC users did not replace theirCOMMAND.COM shell with a GUI untilWindows 95 was released in 1995.[40][41]
While most non-expert computer users now use a GUI almost exclusively, more advanced users have access to powerful command-line environments:
Most command-line interpreters supportscripting, to various extents. (They are, after all, interpreters of aninterpreted programming language, albeit in many cases the language is unique to the particular command-line interpreter.) They will interpret scripts (variously termedshell scripts orbatch files) written in thelanguage that they interpret. Some command-line interpreters also incorporate the interpreter engines of other languages, such asREXX, in addition to their own, allowing the executing of scripts, in those languages, directly within the command-line interpreter itself.
Conversely,scripting programming languages, in particular those with anevalfunction (such as REXX,Perl,Python,Ruby orJython), can be used to implement command-line interpreters and filters. For a fewoperating systems, most notablyDOS, such a command interpreter provides a more flexible command-line interface than the one supplied. In other cases, such a command interpreter can present a highly customised user interface employing the user interface and input/output facilities of the language.
The command line provides an interface between programs as well as the user. In this sense, a command line is an alternative to adialog box. Editors and databases present a command line, in which alternate command processors might run. On the other hand, one might have options on the command line, which opens a dialog box. The latest version of 'Take Command' has this feature. DBase used a dialog box to construct command lines, which could be further edited before use.
Programs like BASIC,diskpart,Edlin, and QBASIC all provide command-line interfaces, some of which use the system shell. Basic is modeled on the default interface for 8-bit Intel computers. Calculators can be run as command-line or dialog interfaces.
Emacs provides a command-line interface in the form of its minibuffer. Commands and arguments can be entered using Emacs standard text editing support, and output is displayed in another buffer.
There are a number of text mode games, likeAdventure orKing's Quest 1-3, which relied on the user typing commands at the bottom of the screen. One controls the character by typing commands like 'get ring' or 'look'. The program returns a text which describes how the character sees it, or makes the action happen. Thetext adventureThe Hitchhiker's Guide to the Galaxy, a piece ofinteractive fiction based onDouglas Adam's book of the same name, is a teletype-style command-line game.
The most notable of these interfaces is thestandard streams interface, which allows the output of one command to be passed to the input of another. Text files can serve either purpose as well. This provides the interfaces of piping, filters and redirection. Under Unix,devices are files too, so the normal type of file for the shell used for stdin, stdout and stderr is atty device file.
Another command-line interface allows a shell program to launch helper programs, either to launch documents or start a program. The command is processed internally by the shell, and then passed on to another program to launch the document. The graphical interface of Windows and OS/2 rely heavily on command lines passed through to other programs – console or graphical, which then usually process the command line without presenting a user-console.
Programs like the OS/2E editor and some other IBMeditors, can process command lines normally meant for the shell, the output being placed directly in the document window.
A web browser's URL input field can be used as a command line. It can be used tolaunchweb apps,access browser configuration, as well as perform a search.Google, which has been called "the command line of the internet" will perform a domain-specific search when it detects search parameters in a known format.[51] This functionality is present whether the search is triggered from a browser field or on Google's website.
There areJavaScript libraries that allow to write command line applications in browser as standalone Web apps or as part of bigger application.[52] An example of such a website is the CLI interface toDuckDuckGo.[53] There are alsoWeb-based SSH applications, that allow to give access to server command line interface from a browser.
Many PCvideo games feature a command line interface often referred to as a console. It is typically used by the game developers during development and by mod developers for debugging purposes as well as for cheating or skipping parts of the game.
?? at the debug prompt (rather than only the default? overview). Specific help pages can be selected via?n (wheren is the number of the page). Additionally, help for specific commands can be displayed by specifying the command name after?, f.e.?D will invoke help for the various dump commands (likeD etc.). Some of these features were already supported by theDR DOS 3.41SID86 andGEMSID.the notion of having a replaceable "command shell" rather than a "monitor" tightly integrated with the OS kernel tends to be attributed to Multics.
The shell has four different command prompts, called PS1, P52, P53, and PS4. PS stands for Prompt String.
[…] CPI /H […] CPI [@] [@] [/?|/Help[:topic]] [/!|/About] […] [?|&] […] /?, /Help Display this help screen or specific help for a topic (+) […] /!, /About Display the 'About' info screen […] /Cpifile (+) .CPI/.CP file name <EGA.CPI>; extension: <.CPI>; CPI.EXE=StdIn […] /Report Report file name <''=StdOut>; extension: <.RPT> […] /Style (+) Export <0>-6=BIN-raw/ROM/RAM/PSF0/1/SH/CHED; 7-12/13-18/19-24=ASM-hex/dec/bin/ip/il/p/l/mp/ml […] CPI /H:C […] Overview on codepage file parameter usage: […] CPI /H:S […] Overview on /Style parameters: […] ?, & Online edit mode (prompts for additional parameter input) […]
[…] Since theDR-DOS 7.03DEBUG is still based on the oldSID86.EXE, I suggest to run DEBUG 1.51 and enter the extended help system with ?? from the debug prompt. This will give you eight screens full of syntax and feature help. Some of these features were also supported by older issues. […]
? and comprehensive help on??.)man-pages(7) – Linux Conventions and MiscellanyManual (NB. Conventions for describing commands on Unix-like operating systems.)The Cisco IOS command-line interface (CLI) is the primary user interface…
| File system | |
|---|---|
| Processes | |
| User environment | |
| Text processing | |
| Shell builtins | |
| Searching | |
| Documentation | |
| Software development | |
| Miscellaneous | |
