From Computer History Wiki
Jump to: navigation, search

Creator: DEC
Architecture: PDP-11

RSTS/E (an acronym for Resource Sharing Time Sharing Extended) was a multi-user time-shared operating system developed by Digital Equipment Corporation ("DEC") for the PDP-11 series of 16-bit minicomputers, and used primarily during the 1970s and 1980s, although some installations were still being upgraded well into the 1990s.


RSTS/E started as RSTS-11, for the PDP-11/20. Unlike RSTS/E, it ran on PDP-11s without memory mapping hardware. RSTS-11 only supported the BASIC-PLUS programming language. RSTS/E (V5A) was introduced in 1973, to take advantage of the memory mapping hardware and larger memory support introduced with the PDP-11/45. Starting with V5B, RSTS/E supported multiple programming languages, although that support was not made official until some time later.

The cost of micro computers dropped so drastically, and their performance rose so radically, that minicomputers such as the PDP-11 were no longer cost effective. In the late 1990s DEC sold its PDP-11 software business to a company named Mentec, and DEC then essentially discontinued releases of RSTS in order to concentrate on their VAX series of mainframe computers.

Mentec would later publicly grant a no-cost license to anyone for non-commercial hobby purpose use of the operating system software developed for the PDP-11, and as the result of the release (for non-commercial use) of a PDP-11 simulator for the IBM-PC, as well as image copies of disk drives of RSTS which exist on the Internet, it is possible for a hobbyist to run RSTS/E on a personal computer in software emulation as fast or faster than it originally ran on the real hardware.

The last release of RSTS/E was version 10.1A(1998).


The RSTS/E Operating System is usually referred to just as "RSTS" and this article will generally use the shorter form. The acronym was usually pronounced as "RIST-ess" or "RIST-uhs". RSTS was primarily programmed using an extended version of the BASIC programming language which DEC called "BASIC-PLUS". Essentially all of the system software for the operating system, including the programs for resource accounting, login, logout and managing the system, were written using BASIC-PLUS.

RSTS operates strictly in text mode as it used non-graphical computer terminals (and modems) connected to it by the equivalent of serial ports, and uses a command line interpreter (or CLI) whose primary command language is BASIC-PLUS, although special "CCL" (Concise Command Language) commands which can be installed by the System Manager may be used. A CCL is analogous to a shortcut to a program on a Windows system or a symbolic link on Unix-based systems, although a CCL is installed as a memory-resident command each time the system is restarted, it is not permanent like a disk file. Later versions of RSTS include DCL as a choice for the CLI, giving users access to essentially the same command language used in RSX-11 and, later, VMS. Starting with RSTS V9.0, command files containing DCL commands were supported for batch processing jobs, and also as indirect command files.

As many as 127 terminals could be connected to a RSTS system, depending on the processor being used, the amount of main memory and disk space, and the system load. Most RSTS systems had nowhere near that many terminals. As many as 63 concurrent jobs (processes, execution states) were supported. These might be interactive jobs (controlled by a terminal), detached (similar to Unix "daemons"), or batch jobs (controlled by a batch command file). A typical interactive job would interact only with its control terminal, but special programming techniques enabled the use of additional terminals ("multi terminal mode"), which is why 127 terminals were potentially useable even though the interactive job limit is at most 63.


Users connected to the system by typing the LOGIN command (or HELLO) at a logged-out terminal and pressing return. Actually, typing any command at a logged-out terminal simply started the LOGIN program which then interpreted the command. If it was one of the commands which were allowed to be used by a user that is not yet logged in ("Logged Out"), then the associated program for that command was CHAINed to, otherwise the message "Please say HELLO" was printed on the terminal. One could determine the status of a terminal by the prompt printed by the command interpreter, usually the BASIC-PLUS run-time system. A logged-in user was given the prompt "Ready" and a user who is logged out is given the prompt "Bye".

A user would log in by supplying their user number and password. User numbers consisted of a project number (this would be the equivalent of a group number in Unix), a comma, and a programmer number. Both numbers were in the range of 0 to 254, with special exceptions. When specifying an account, the project and programmer number were enclosed in brackets. A typical user number could be [10,5] (project 10, programmer 5), [2,146], [254,31], or [200,220], etc. When a user was running a system program while logged out (because the system manager had enabled it) their user number would appear as [0,0]. Thus that is not a valid account number.

In every project, the programmer number 0 was usually reserved as a group account, as it could be referenced by the special symbol #. If one's user number were [20,103], a reference to a file name beginning with "#" would refer to a file stored in the account of the user number [20,0]. This feature would be useful in educational environments, as programmer number 0 could be issued to the instructor of a class, and the individuals students given accounts with the same project number, and the instructor could store in his account files marked as shared only for that project number (which would be students in that class only, and no other).

Two special classes of project numbers existed. Project numbers of 0 were generally reserved for system software. Project numbers of 1 are privileged accounts, equivalent to the single account "root" on Unix systems, except that the account numbers [1,0] through [1,254] are all privileged accounts.

There are also certain special accounts on the system. The account [0,1] is used to store the operating system file itself, all run-time library systems, and certain system files relating to booting the system (author's comments appear on the right in bold):

 DIR [0,1]
  Name .Ext    Size   Prot    Date       SY:[0,1]
 BADB  .SYS       0P  < 63> 06-Jun-98         '''List of bad blocks'''
 SATT  .SYS       3CP < 63> 06-Jun-98         '''Bitmap of allocated disk storage'''   
 INIT  .SYS     419P  < 40> 06-Jun-98         '''Operating system loader program'''
 ERR   .ERR      16CP < 40> 06-Jun-98         '''System error messages'''
 RSTS  .SIL     307CP < 60> 06-Jun-98         '''Operating system itself'''
 BASIC .RTS      73CP < 60> 06-Jun-98         '''BASIC-PLUS run time system'''
 RT11  .RTS      20C  < 60> 06-Jun-98         '''[[RT-11]] run time system'''
 SWAP  .SYS    1024CP < 63> 06-Jun-98         '''System swap file'''   
 CRASH .SYS      35CP < 63> 06-Jun-98         '''System crash dump'''
 RSX   .RTS      16C  < 60> 23-Sep-79         '''[[RSX-11]] run-time system'''
 TECO  .RTS      39C  < 60> 24-Sep-79         '''[[Text Editor and Corrector|TECO]] text editor'''
 Total of 1952 blocks in 11 files in SY:[0,1]

Ready in this case is the system command prompt, similar to the C> prompt in MS-DOS or the % prompt in many Unix-based shells. The DIR command is an installed CCL equivalent to a RUN command for the DIRECT program. [0,1] is the account number (and directory name) of the main system storage account. It would be referred to as "project number 0, programmer number 1".

The numbers shown after each file represent its size in disk blocks, a block being 512 bytes or 1/2 kilobyte (K). "C" indicates the file is contiguous (is stored as one file without being separated into pieces, similar to files on a Microsoft Windows system after a drive has been defragmented), while "P" indicates it is specially protected (cannot be deleted, even by a privileged user unless the P bit is cleared using the "Refresh" system initialization option). The numbers in brackets (like "< 40>") represent the protections for the file, which is always displayed in decimal. Protections indicate if the file may be seen by any other user, by other users with the same programmer number, if the file is read only or if it may be altered by another user, and whether the file may be executed by an ordimary user giving them additional privileges. These protection codes are very similar to the r, w and x protections in Unix and similar operating systems such as BSD and Linux. Code 60 is equivalent to a private file, code 62 is a private non-deletable file, and 40 is a public file.

Certain other system files are kept in account [1,1]. The account [1,2] is the system-wide public library, and any public file in that account could be referenced by prefixing its name with a dollar sign ($). "!" is used for account [1,3], "%" for [1,4] and "&" for [1,5]. The account [1,1] also had the special privilege of being the only account where a user logged in under that account is permitted to execute the POKE system call to put values into any memory in the system. Thus the account number [1,1] is the closest equivalent to "root" on Unix-based systems.

When logged in, a user may either type language statements in the BASIC-PLUS programming language, issue the RUN command to run a program, or issue a special command called a CCL to execute a program with command options.

One of the features of RSTS is the means for the execution of programs and the environment used to run them. The various environments allowed for programming in BASIC-PLUS, the enhanced BASIC Plus 2, and in more traditional programming languages such as COBOL and FORTRAN. These environments were separate from each other such that one could start a program from one environment and switch to a different environment to run a different program. These environments were referred to as "run-time systems".

One of the most powerful text editors ever developed, the TECO editor, was itself implemented as a run-time system partly to maximize the amount of memory available for the text buffer, and partly because it was originally ported to RSTS/E before general support for assembly language programming was released. (The RT11 and RSX emulation run time systems appeared later.)

Programs written in BASIC-PLUS ran under the BASIC run-time system, which allowed them 32K bytes of memory. If one wrote programs in a language that permitted true binary executables such as FORTRAN or the Macro Assembler or others that ran under the RT-11 run-time system, the amount of memory available would be 56K.

Programs written for the RSX run time system such as COBOL, the Macro Assembler, or the later releases of BASIC Plus 2, the amount of memory available to such a binary program would still be 56K due to the requirements of the RSX Run-Time System being allowed the top 8K to use for itself. RSTS version 7 and later allowed the RSX Run-Time system to be included in the kernel of RSTS, making it completely "disappear" from the user address space, thus allowing 62K of memory for user programs. The remaining 2K still could not be used, either because of software limitations in RSTS memory management, or deliberately, to catch accidental wraparound of addresses in user programs.

Programs got around the limitations of the amount of available memory by using libraries (when permissible), by complicated overlay strategies, or by calling other programs ("Chaining") and passing them commands in a shared memory area called "Core Common," among other practices.

RSTS Release Dates and historical notes

Version Date Notes
V03A-19 1970?
V03C-32 1971?
V04A-12 1972 October
V05-21 1973 July First version called "RSTS/E".
V05B-24 1974 September
V05C-01 1975 February
V04B-17 1975 July Final patch release of V04; last version for non-MMU machines.
V06A-02 1975 July Last version to be installed using DOS-11.
V06B 1977 January
V06C 1978 July First release of RSTS/E supporting DECnet.
7.0 1979 September
7.1 1981 December First release of RSTS/E supporting DECnet Phase III.
7.2 1982 May
7.2A 1982 June
8.0 1983 November
8.0C 1983 November
8.0F 1984 November
9.0 1985 May DCL becomes the default command line interface.
8.0G 1985 September Final patch release of 8.0
9.1 1985 October
9.2 1986 April
9.3 1986 December First release of RSTS/E supporting DECnet Phase IV.
9.4 1987 June
9.5 1987 October
9.6 1988 August
9.7 1989 June
10.0 1990 September
10.1 1992 August
10.1A 1998 First and only Mentec release, Year 2000 fixes only.


RSTS/E is available under a non-commercial free licence for hobbyist use on the Supnik emulator.

RSTS/E is still available under a commercial license from Mentec.



Version 9.x

RSTS/E System Installation and Update Guide v9.7

Practical Guides

System Generation

External links