The Compatible Time-Sharing System (CTSS) is an early time-sharing operating system developed at the Massachusetts Institute of Technology (MIT) during the early 1960s. It was one of the first systems to allow multiple users to interact concurrently with a single computer through remote terminals, pioneering concepts such as interactive computing, file systems, and command-line interfaces. CTSS ran on an IBM 7090/7094 mainframe, later modified, and served as a foundational platform for the development of the Multics project and subsequent time-sharing systems. Its design influenced modern operating systems and user-computer interaction paradigms.
1 History and development
1.1 Origins at MIT's Project MAC
CTSS was created under the auspices of Project MAC (Machine-Aided Cognition or Multiple-Access Computer), a research initiative funded by the Advanced Research Projects Agency (ARPA) at MIT. The project aimed to demonstrate the feasibility of interactive, multi-user computing, which was a radical departure from the batch-processing paradigm then dominant. CTSS was developed as a testbed for time-sharing concepts and as a practical system for researchers.
1.2 Key personnel and institutions
The development of CTSS was led by Fernando J. Corbató, who later received the Turing Award for his work on time-sharing and CTSS. Other key figures included Robert M. Fano (director of Project MAC), Marjorie S. Corcoran, and a team of graduate students and staff at MIT’s Computation Center. The system was built in collaboration with the IBM Corporation, which provided the hardware and some technical support.
1.3 Chronological milestones
1.3.1 Initial design (1961)
Work on CTSS began in 1961, building on earlier experimental time-sharing projects at MIT, such as the “Compatible Time-Sharing System” concept proposed by Corbató and colleagues. The design was influenced by the need for a system that could support multiple users in “compatible” manner with existing batch software.
1.3.2 First operational version (1962)
The first operational version of CTSS became available in 1962, running on a modified IBM 7090. It allowed up to 32 simultaneous users, each connected via teletype terminals. This version demonstrated the basic features of interactive computing, including command-line input, file storage, and simple editing.
1.3.3 Continued enhancements until 1965
From 1963 to 1965, CTSS underwent numerous enhancements. The system was migrated to the more powerful IBM 7094, memory was expanded, and the user count was increased to 48. Improvements included a more robust file system, a command interpreter (the RUNCOM shell), and support for remote job entry. By 1965, CTSS had become a mature, widely used platform within MIT.
2 Architecture and design
2.1 Hardware platform
2.1.1 IBM 7090/7094 modifications
CTSS ran on an IBM 7090 mainframe, later upgraded to an IBM 7094. To support time-sharing, the hardware was modified with additional memory protection hardware and a high-speed clock for interrupt-driven scheduling. The system used a “trapping” mechanism to switch between user and supervisor modes, a precursor to modern privileged mode concepts.
2.1.2 Memory and storage
The IBM 7094 had a maximum memory of 32,768 36-bit words (approximately 144 KB). CTSS used a drum memory for swapping user processes, with a typical swap time of around 100 milliseconds. Permanent storage was provided by IBM 1301 disk drives, each holding about 25 MB. The system also used magnetic tape for backup and data exchange.
2.2 Software structure
2.2.1 Supervisor and user modes
CTSS implemented a two-level protection scheme: the supervisor (kernel) ran in privileged mode with access to all hardware resources, while user programs ran in a restricted mode. System calls were performed through a “supervisor call” instruction, which caused a trap to the kernel. This design isolated user processes from each other and from the operating system, enhancing reliability and security.
2.2.2 Scheduling and time-slicing
2.2.2.1 Round-robin algorithm
CTSS used a round-robin scheduling algorithm to allocate CPU time among active users. Each user’s process was given a small time slice (typically 100–200 milliseconds). When the time slice expired, the process was interrupted and the next ready process was loaded from the swap drum. This provided the illusion of simultaneous execution for interactive users.
2.2.2.2 Interrupt handling
The system relied on a hardware timer to generate interrupts at the end of each time slice. Additionally, input/output (I/O) interrupts were used to signal completed disk or terminal operations. The interrupt handler in the supervisor saved the state of the interrupted process, dispatched the appropriate service routine, and then resumed scheduling.
2.3 File system
2.3.1 Hierarchical directory design
CTSS introduced a hierarchical (tree-structured) file system, a pioneering feature. Files were organized into directories, which could contain subdirectories. The root directory was called the “master file directory.” Each user had a home directory, and files could be accessed by a path name (e.g., <user>.<filename>). This design influenced nearly all subsequent operating systems.
2.3.2 File protection mechanisms
CTSS implemented a simple file protection scheme based on user authorization. Each file had an owner and could be assigned read, write, and execute permissions for the owner, a designated group, and all other users. Access control was enforced by the file system supervisor, which checked permissions on every open operation. This was a precursor to the access control lists used in modern systems.
3 User interface and command system
3.1 Command Language (RUNCOM) and shell
CTSS provided a command interpreter named RUNCOM (RUN Command). Users typed commands at a teletype terminal, and RUNCOM parsed the input, executed the corresponding program, and displayed output. RUNCOM supported simple scripting: a user could create a file containing a sequence of commands and execute it as a batch job. This was the direct ancestor of the UNIX shell and other command-line interpreters.
3.2 Interactive terminal support
3.2.1 Teletype models used
CTSS users connected via teletype machines, primarily the IBM 1050, the IBM 2741, and the Teletype Corporation’s Model 33 and 35 KSR (Keyboard Send-Receive). These devices printed on paper and operated at speeds of 10 to 15 characters per second. Later, video display terminals such as the IBM 2260 were used experimentally.
3.2.2 Text editing capabilities
CTSS included a line-oriented text editor called TYPSET (or simply “ed”). Users could insert, delete, modify, and print lines by specifying line numbers and editing commands. The editor was rudimentary by modern standards but enabled basic document preparation and program editing. A more sophisticated editor, QED, was later developed for CTSS and influenced the vi editor.
3.3 Notable commands and utilities
3.3.1 List files (LISTF)
The LISTF command displayed the names and attributes of files in a directory. It supported options to sort files by name, date, or size, and to show detailed information such as protection settings. This command is analogous to the modern ls utility.
3.3.2 Debugging tools
CTSS offered debugging tools such as DDT (Dynamic Debugging Technique), a symbolic debugger that allowed users to examine and modify memory, set breakpoints, and trace program execution. DDT could run interactively under CTSS, enabling programmers to fix errors without recompiling.
4 Key features and innovations
4.1 Multi-user interactive computing
4.1.1 Simultaneous remote access
CTSS supported up to 48 simultaneous users (later increased to 64) from remote terminals connected via telephone lines or direct cables. Users could log in, run programs, edit files, and share data in real time—a radical innovation in an era when most computing was batch oriented.
4.1.2 Response time performance
The system was designed to provide sub-second response to simple commands. Under typical loads, CTSS achieved response times of 1–2 seconds for short tasks, which was considered highly interactive. This responsiveness was critical for user acceptance and laid the groundwork for modern interactive computing.
4.2 Shared file system and permanent storage
CTSS provided a shared file system that allowed users to create, store, and retrieve files across sessions. Files were stored on disk and persisted even after logout. Users could share files by granting read or write permissions to others. This concept of a permanent, sharable file system became a standard feature of operating systems.
4.3 Protection and security concepts
4.3.1 User authentication
CTSS required users to log in with a username and a password. Password files were stored in an encrypted form (using a hash algorithm). This was one of the earliest implementations of password-based authentication in a multi-user system.
4.3.2 Access control lists
For each file, CTSS maintained a list of users and groups that were allowed specific types of access (read, write, execute). This access control list (ACL) mechanism was more flexible than simple owner/group/other permissions and inspired later systems such as Multics and Windows NT.
5 Legacy and influence
5.1 Impact on Multics development
CTSS directly led to the Multics project, a more ambitious time-sharing system started in 1964 at MIT with Bell Labs and General Electric. Many CTSS concepts—including hierarchical file systems, dynamic linking, and security rings—were evolved and expanded in Multics. Several CTSS developers later worked on Multics, and CTSS was used as a development platform for early Multics software.
5.2 Contribution to UNIX design philosophy
UNIX, created at Bell Labs in the early 1970s, was inspired by CTSS and Multics. Ken Thompson and Dennis Ritchie had used CTSS before joining the Multics effort. UNIX adopted CTSS’s simple command-line interface, hierarchical file system, and the concept of a shell (modeled after RUNCOM). The CTSS influence is evident in UNIX’s focus on small tools, pipe mechanisms, and user-level utilities.
5.3 Historical significance in operating system research
5.3.1 First major time-sharing system
CTSS is widely recognized as the first successful, large-scale time-sharing system. It demonstrated that interactive computing could be practical and affordable, paving the way for commercial systems such as IBM’s TSO and DEC’s TOPS-10.
5.3.2 Educational and research tool
CTSS was used extensively at MIT for education and research in computer science. Students wrote programs, developed algorithms, and learned about operating system principles by using and modifying CTSS. Many influential computer scientists—including future contributors to the ARPANET, the GNU Project, and the Internet—gained their first interactive computing experience on CTSS.
5.4 Preservation and emulation projects
5.4.1 Modern reconstructions
Several projects have reconstructed CTSS for modern hardware or emulators. The most notable is the “CTSS Emulation” project, which runs CTSS on an IBM 7094 emulator and allows users to log in remotely. This effort preserves the original software and enables historical research.
5.4.2 Documentation and archives
Original CTSS documentation, including user manuals, technical notes, and source code listings, has been archived at the MIT Libraries and by the Computer History Museum. Digital scans of these documents are available online, providing a valuable resource for historians and enthusiasts. The CTSS source code (in MAD and FAP assembly languages) has been released under an open-source license by MIT.