Computing history: from mainframe to your VPS

Where your VPS comes from

The history of computing from the mainframe to the cloud is one idea getting cheaper. That idea is time-sharing: let many people use one expensive machine at the same time, and give each of them a private view of it. It was invented around 1960 because a computer cost more than the people using it. Every part of the VPS you rent today was built for that problem: the isolation between users, the scheduler that hands out CPU time, the hypervisor, and the bill that counts hours. The problem never went away. The hardware got cheap, so a slice that once needed a research grant now costs a few dollars a month.

1959 to 1961: why time-sharing was invented

A computer in the 1950s ran in batch. You punched your program onto cards, handed the deck to an operator, and came back later for a printout. One mistyped character cost you a day. The machine stayed busy, which was the whole point, because a machine like the IBM 7090 cost millions of dollars and the time of the people waiting for it did not appear on any invoice.

In January 1959 John McCarthy put the opposite case in a memo at MIT. The machine should wait for the person. Christopher Strachey described a form of time-sharing at a UNESCO conference the same year, though he meant one programmer debugging while other jobs ran, rather than many people typing at once. Speaking at MIT's centennial in 1961, McCarthy went further: computing could be sold as a public utility, metered like electricity.

The objection at the time was that time-sharing wastes the machine. Switching between users costs cycles, and cycles were the expensive thing. The objection was correct, and it stopped mattering, because the price of a cycle fell for sixty years while the price of an hour of human attention did not.

What CTSS had to invent

Fernando Corbató's group at the MIT Computation Center built the Compatible Time-Sharing System (CTSS) to settle the argument. It was first demonstrated in November 1961 on an IBM 709, serving four users, swapping each user's work out to its own magnetic tape drive. "Compatible" meant the machine could still run the old batch system underneath, because nobody buys a computer that only does the new thing.

Four users is a small number. The list of problems that had to be solved to reach it is not small, and it is the same list your kernel works through right now. CTSS needed a scheduler, so one long job could not freeze every other terminal. It needed memory protection, so a crashing program took down one user rather than the whole system. It needed storage that survived a logout, which is why CTSS had one of the first file systems a modern user would recognise. And it needed passwords, so one user could not read another user's files.

Rename those parts and you have a Linux box. The scheduler is EEVDF, which replaced CFS in Linux 6.6. Memory protection is the MMU (memory management unit) giving each process its own virtual address space. Storage that survives a logout is your home directory. The password file is still called /etc/passwd.

Multics and the computer utility

MIT's next system was meant to be the utility McCarthy had described. Project MAC began in 1963, signed for a General Electric GE-645 in August 1964, and published the first Multics papers in 1965. The name carries the argument: Multiplexed Information and Computing Service. Service, as in something you buy by the hour.

Multics took far longer than planned. Prototype GE-645 machines reached MIT and Bell Labs in January 1967. Bell Labs left the project in April 1969. Multics opened to MIT Information Processing Center customers on 1 October 1969, and it then ran in production somewhere for thirty-one years. The last live Multics system, at the Canadian Department of National Defence in Halifax, Nova Scotia, was shut down on 30 October 2000.

Multics is often filed as a failure because it arrived late and ran slowly. The vocabulary says otherwise. It gave us the hierarchical file system of directories inside directories, an access control list on each file, segmented virtual memory that let a program address a file as if it were memory, and protection rings that ranked code by how far it was trusted. Rings are still in the silicon in front of you. Ring 0 for the kernel and ring 3 for user code is Multics vocabulary, and hardware virtualisation later added a mode underneath ring 0 for the hypervisor, which people informally call ring -1.

Unix: time-sharing on a machine you could afford

Leaving Multics left Ken Thompson at Bell Labs without a system he wanted to use. In 1969 he started a much smaller one on a discarded PDP-7. The first Unix Programmer's Manual is dated November 1971, by which point the work had moved to a PDP-11. In 1973 Thompson and Dennis Ritchie rewrote the kernel in C, so the system could move to new hardware without being written again by hand.

That is why you type into a descendant of Unix and not a descendant of Multics. Multics needed hardware built for Multics. Unix ran on whatever was cheap and available, and that turned out to be the deciding feature.

"The UNIX Time-Sharing System" by Ritchie and Thompson appeared in Communications of the ACM in July 1974. The paper describes your VPS: processes, one hierarchical file system, files as plain byte streams, fork, users and groups with permission bits, and a shell that is an ordinary program rather than part of the kernel. Fifty-two years later that interface has been extended, never replaced.

Did mainframes really run virtual machines in 1972?

Yes, and this is the part of the story most people miss. While MIT built Multics, IBM's Cambridge Scientific Center attacked the same goal from the other end. Instead of one operating system serving many users, Robert Creasy and Les Comeau built a control program that gave each user a complete simulated computer. CP-40 went into production in January 1967. Every user got a virtual System/360 and ran a small single-user operating system, CMS, inside it.

CP-40 became CP-67 on the System/360-67 in 1968, and IBM announced VM/370 on 2 August 1972. That is a commercial hypervisor, sold to paying customers, fifty-four years ago. A control program multiplexed the real hardware, and guest operating systems ran unmodified inside virtual machines that believed they owned the machine.

The theory arrived two years later, in the same July 1974 issue of Communications of the ACM that carried the Unix paper. Gerald Popek and Robert Goldberg's "Formal Requirements for Virtualizable Third Generation Architectures" set out what a processor must do to be virtualisable. The core rule is short. Every instruction that can read or change the state of the machine must trap when a guest executes it outside kernel mode, so the hypervisor takes control and answers with that guest's own private version of the state. This is called trap and emulate. IBM's hardware obeyed the rule.

Why the minicomputer broke the model

DEC introduced the PDP-8 on 22 March 1965 at about $18,000 in 1965 dollars, the first minicomputer priced under $20,000, and it went on to sell more than 50,000 units. The microprocessor then pushed the price down again. Once a department could buy its own machine, and later once a person could, sharing one central computer looked like a solved problem that no longer needed solving. Through the 1980s and 1990s computing moved out to the desk and into racks of small x86 servers.

The waste came back in a different shape. One application per server is simple to reason about, and it leaves most of the hardware idle while the power and the rack space are paid for in full. That is the CTSS problem again at a new scale, with the expensive resource now being the room and the electricity rather than the processor. The answer was the old answer. Share the machine.

Why was x86 so hard to virtualise?

Because x86 broke Popek and Goldberg's rule. At the 9th USENIX Security Symposium in August 2000, John Scott Robin and Cynthia Irvine worked through the Pentium instruction set and found seventeen instructions that read or change privileged state without faulting when user-mode code runs them. popf is the standard example. Run it in user mode and the processor quietly ignores the bits the program is not allowed to set, instead of trapping, so a hypervisor built on trap and emulate never learns that the guest tried.

Two answers appeared before the hardware was fixed. VMware, founded in 1998 out of Stanford's Disco research, inspected guest kernel code and rewrote the awkward instructions before they executed, a technique called binary translation. Xen, from the University of Cambridge Computer Laboratory, changed the guest instead. The paper "Xen and the Art of Virtualization", presented at SOSP in October 2003, described paravirtualisation: a modified guest kernel calls the hypervisor on purpose rather than running instructions the hypervisor cannot intercept.

Then the hardware was fixed, the way IBM had fixed it in the 1960s. Intel shipped VT-x on two Pentium 4 models on 14 November 2005, and AMD shipped AMD-V in May 2006. Both add a processor mode below the guest kernel's, so a guest runs its own kernel at full speed while the hypervisor keeps control of the events it asks for. That made a hypervisor small enough to live inside an ordinary operating system, and Avi Kivity's KVM at Qumranet did exactly that: it turned the Linux kernel itself into the hypervisor. KVM was merged for Linux 2.6.20, released in February 2007, and it is what a large share of VPS hosts run today.

How the VPS got its name

Two lines converged in the early 2000s. One was the full virtual machine on x86, a guest booting its own kernel. The other was operating-system-level virtualisation: a single shared Linux kernel carved into separate environments, each with its own root user and its own process table. Linux-VServer and SWsoft's Virtuozzo both appeared in 2001, and SWsoft released part of Virtuozzo as the open-source OpenVZ in 2005. The phrase "virtual private server" comes from that side of the family, formed by analogy with the virtual private network.

Amazon turned the rental into an API call. S3 launched on 14 March 2006, and EC2 opened as a limited public beta on 25 August 2006 with a single instance type, running on Xen. Buying compute stopped being a contract with a service bureau and became a request that returns in a minute.

Both lines survive, and the split still decides what you can do with the server you rent. A KVM VPS boots its own kernel, so you can load kernel modules and even run a hypervisor inside your VPS. A container-based plan shares the host kernel and cannot. Sixty years of history sit behind that one line on a pricing page, which is why it pays to understand how a VPS, a VM and a VPC differ before you pick one.

What changed from the mainframe to your VPS, and what did not

Four things changed. The machine is not in your building. The terminal is a program instead of a piece of furniture. The unit you rent is a whole computer with its own kernel, rather than an account on somebody else's operating system. And the price fell far enough that the purchase is a card payment rather than a procurement process.

The mechanism did not change at all.

• Your ssh session is a time-sharing terminal. You get a login and a shell, and a scheduler decides when your process runs next.
• Isolation is still enforced by hardware. The MMU and the processor's privilege levels do the work, exactly as CP-40 needed them to in 1967.
• You are still billed for a share of a machine by elapsed time, the way service bureaus billed for connect hours.
• You still feel the other tenants. When a host is oversubscribed your guest waits for a physical CPU, and Linux reports that wait as CPU steal time from a noisy neighbour.

That last point is the honest summary of the whole history. Sharing a machine is a trade. It was accepted in 1961 because the computer cost more than the people, and it is accepted in 2026 because a server running at ten percent of its capacity is money burned. If you would rather stand on the operator's side of that trade, running Proxmox on hardware you own hands you the hypervisor and the operator's problems together.

Keep the ratio in mind. CTSS served four users on a machine that cost millions of 1961 dollars and filled a room. Your VPS, for a few dollars a month in 2026, is a far better computer than the one Corbató's team was rationing, and you have it to yourself. The reason you can rent it at all is a sixty-five-year-old idea that finally met cheap hardware. If you are working out what to put on it, start with what a VPS actually gives you and then what people run on one.

FAQ

What was the first time-sharing computer system?

CTSS, the Compatible Time-Sharing System, built by Fernando Corbató's group at the MIT Computation Center. It was first demonstrated in November 1961 on an IBM 709 and served four users, each swapped out to a separate tape drive. The first time-sharing service for a whole community was the Dartmouth Time-Sharing System: on 1 May 1964, John Kemeny and a student programmer ran BASIC programs at the same time on two terminals and both got correct answers back.

Were virtual machines really invented in the 1960s?

Yes. IBM's Cambridge Scientific Center put CP-40 into production in January 1967, giving each user a complete virtual System/360 with the CMS operating system running inside it. CP-67 followed in 1968 on the System/360-67, and IBM announced VM/370 on 2 August 1972. Those are real hypervisors running unmodified guest operating systems, sold commercially, decades before x86 hardware could do the same thing.

Why was x86 hard to virtualise when mainframes were not?

Popek and Goldberg's 1974 rule says every instruction that can read or change machine state must trap when a guest runs it outside kernel mode. x86 broke that rule. Robin and Irvine counted seventeen Pentium instructions that fail silently in user mode instead of trapping, so a classic trap-and-emulate hypervisor never sees them, and popf is the usual example. VMware worked around it with binary translation and Xen with paravirtualisation, until Intel VT-x in November 2005 and AMD-V in May 2006 added a hardware mode for the hypervisor.

Is renting a VPS the same as having a time-sharing account?

The billing model and the isolation problem are the same. The unit is different. A time-sharing user got an account on an operating system shared with everyone else, so the administrator was somebody at the computer centre. A KVM VPS gives you a virtual machine with your own kernel and your own root account, so the administrator is you. A container-based VPS sits between the two, because it shares the host kernel while still giving you root inside your own environment.