CTSS

CTSS stands for “Compatible Time-Sharing System.” It was a program that managed a very large computer from the early 1960s. Its special feature: multiple people could use this one computer at the same time, each at their own writing device with a keyboard. Until then, people submitted computing jobs on punch cards and waited hours for the result. CTSS ran starting in 1961 at the Massachusetts Institute of Technology, known as MIT, a renowned technical university in the USA. It was the first system of its kind to be used by many people in real everyday operation.

The break with queue-based operation

Computers at the time were extremely expensive, often several million dollars. A single user could never have kept such a machine fully utilized. That’s because while they think or type, the processor computes nothing. CTSS filled exactly this idle time with the tasks of other users.

But the gain wasn’t just economic. Someone who gets an answer immediately works in a completely different way. You can write a program, test it, see the error, and correct it right away. This rapid switching between writing and checking is taken for granted today. CTSS invented it.

This environment also produced things we still use every day. One of the first email programs was created on CTSS, back then only for messages between users of the same machine. The password as a means of protecting access to personal files also became standard practice here. And the first text editor of the family from which many programming tools later emerged also ran on CTSS.

How a computer divides itself into time slices

The trick is called time-sharing. The processor only ever works on one task at a time, but only for a few milliseconds at a stretch. Then a clock interrupts it, and the next task takes its turn. Because this switching happens much faster than a human can notice, every user believes the machine belongs to them alone. A waiter serving twenty tables at once works on the same principle.

For this to work, the system must fully save the state of a task with every switch. All intermediate results are written out, later loaded back in, and the work continues. If memory wasn’t sufficient, CTSS would move entire programs to a magnetic drum as temporary storage. This offloading is called swapping, and modern operating systems still do it today.

The “Compatible” in the name explains a second part of the idea. CTSS was not meant to abolish the old mode of operation, but to support it alongside the new one. Large computing jobs in batch mode continued to run, simply as one task among many. The hardware had to be modified for this, among other things with doubled memory: one for the control program, one for the users.

What remains of CTSS in today’s systems

Today, the name CTSS is encountered almost exclusively in technology history and anniversary articles. Its after-effects, however, are encountered constantly. The successor project Multics emerged from CTSS at MIT. From criticism of Multics, researchers at Bell Labs then developed Unix. And Unix is the direct ancestor of Linux, Android, and macOS.

The underlying principle also lives on, just on a larger scale. When you use an AI model in your browser today, you are sharing a very expensive graphics card in a data center with many other users. Requests are batched and processed in turns so that the hardware never sits idle. That is the same economic idea as in 1961: expensive computing power must not be left waiting.

A common misconception: time-sharing is not the same as a multi-core processor. In true parallel processing, tasks really do run simultaneously because there are multiple computing units. CTSS created simultaneity only as an illusion through rapid switching. Both ideas are combined today, but they solve different problems.