The IBM System/360 was the first family of computers built around one shared architecture. IBM announced it on 7 April 1964. A program written for one model ran on another model of a different size without rewriting, which changed how businesses bought and kept computers.

A hand pushes a lever that drives a precise mechanical chain, each link moving the next. The shared linkage mirrors how one System/360 architecture drove many machine sizes.
One architecture connected a whole range of machines, the way a single linkage drives every link in a chain.

What it was

Before 1964, each new computer model often had its own instruction set. Software written for one machine did not run on the next. Upgrading meant rewriting programs, retraining staff, and replacing peripherals. This cost time and money.

The System/360 fixed this with a shared architecture. IBM defined one instruction set, one way to address memory, and one set of input and output rules. Then it built many physical machines that all obeyed those rules. Small models were cheap and slow. Large models were expensive and fast. The software did not care which model it ran on.

Think of it like a family of cars that all use the same pedals, the same steering, and the same fuel. You move from a small car to a large one, and you already know how to drive. Your skills and your habits carry over. The System/360 did this for programs and peripherals.

The instruction set was the contract. Hardware below it could change. Software above it stayed stable.

Software
Business programsScientific programsWritten once, runs on any model in the family
Architecture
Shared instruction set8-bit byteStandard I/O channels
Hardware
Small modelMid-range modelLarge modelDifferent speed and memory, same rules
Peripherals
Tape drivesDisk unitsPrinters

Why it mattered

The System/360 carried huge risk for IBM. The company spent enormous sums developing the line and reorganised much of its engineering around it. People later called it a bet-the-company project. The bet paid off, and the family became a commercial success.

The impact reached past IBM. The 8-bit byte became a standard unit of data, and that choice still shapes computing. Customers could now upgrade to a faster machine without throwing away their software. This idea, backward and forward compatibility within a family, became normal across the whole industry.

The System/360 also separated architecture from implementation. The published architecture told programmers what the machine did. The internal design told engineers how it did it. Different models met the same specification in different ways. This clean split is now a core idea in computer design.

The line helped move computing into mainstream business. Banks ran accounts on it. Airlines ran reservations on it. Governments ran records on it. Many of those workloads never left.

How it connects to AI today

The System/360 introduced an idea that sits under modern AI: a stable instruction set architecture that hides the hardware beneath it. You write to the architecture, not to one chip. That principle now drives the entire AI stack.

When you train a model, you rarely write raw machine code. You write Python with frameworks like PyTorch. The framework targets an abstraction, and a compiler maps it onto whatever hardware you have, whether a CPU, a GPU, or a custom accelerator. The same model code runs across very different machines. That is the System/360 promise of compatibility, applied to AI workloads.

Cloud computing repeats the pattern at larger scale. You request a virtual machine or an instance type. The provider runs your workload across many physical servers of varying size and speed. You see one consistent interface. The hardware below changes without breaking your code.

The descendants of the System/360 also run AI directly. Modern IBM Z mainframes include on-chip accelerators for machine learning inference. Banks use them to score transactions for fraud in real time, next to the account data already living on the mainframe. So a builder meets this lineage in two places: in the layered abstractions of every AI framework, and in the production mainframes that now run AI models on data they have held for decades.

Still in use today

The original System/360 hardware is long retired, so the 1964 machines themselves are discontinued. The architecture is a different story, and its status is legacy-accepted.

IBM extended the line through System/370, System/390, and then the modern IBM Z family. Each generation kept compatibility with the one before. The result is one of the longest-running architectures in computing. A modern IBM Z system can still run application code written for the original System/360 instruction set, decades after that code was first compiled.

This persistence is deliberate. Many banks, insurers, airlines, and government agencies built core systems on this architecture and never had a reason to rewrite them. The code works, it is reliable, and rewriting it carries large risk. So the lineage continues, maintained and current, rather than replaced. The System/360 is legacy in the best sense: old, proven, and still earning its place.

Further reading