The IBM 650 Magnetic Drum Data-Processing Machine is an early digital computer produced by IBM in the mid-1950s. It was the first mass-produced computer in the world. Almost 2,000 systems were produced, the last in 1962, and it was the first computer to make a meaningful profit. The first one was installed in late 1954 and the IBM 650 was the most popular computer of the 1950s.
The 650 was offered to business, scientific and engineering users as a slower and less expensive alternative to the IBM 701 and IBM 702 computers, which were for scientific and business purposes respectively. It was also marketed to users of punched card machines who were upgrading from calculating punches, such as the IBM 604, to computers.
Because of its relatively low cost and ease of programming, the 650 was used to pioneer a wide variety of applications, from modeling submarine crew performance to teaching high school and college students computer programming. The IBM 650 became highly popular in universities, where a generation of students first learned programming.
It was announced in 1953 and in 1956 enhanced as the IBM 650 RAMAC with the addition of up to four disk storage units. The purchase price in 1959 for the bare Model 4 IBM 650 console, without the reader punch unit or power supply, was . Support for the 650 and its component units was withdrawn in 1969.
The 650 was a two-address, bi-quinary coded decimal computer (both data and addresses were decimal), with memory on a rotating magnetic drum. Character support was provided by the input/output units converting punched card alphabetical and special character encodings to/from a two-digit decimal code.
The 650 was a digit-serial machine, clocked at a frequency of 125 kHz, with a basic digit time of 8 μs. Since the 650 had a 10-digit word, together with a sign, and there was a switching interval of one digit time between words, the word time, a basic unit of IBM 650 timing, was 12 digit times, or 96 μs."Glossary of 650 Timing Designations", pp. II-30 ff., IBM Customer Engineering Manual of Instruction, 650 Data-Processing System, Form 22-6284-1, 1957. Accessed July 8, 2026. Since there were 50 words on each track of the drum, the drum rotated once every 50 word times (4.8 ms, or 12,500 rpm.) Instruction times varied as they depended on the time to locate the instruction data and next instruction on the drum as well as, for multiplies and divides, the digits of the multiplier and quotient. The total time for an add or subtract instruction was between 7 and 106 word times, or approximately 0.7 to 10.2 ms. Multiplies took between 23 and 253 word times and divides between 63 and 293 (2.2 to 24.3 and 6.0 to 28.1 ms.)"Optimum Programming", pp. 79 ff., 650 Magnetic Drum Data-Processing Machine, Manual of Operation, IBM, June 1955, Form 22-6060-1. Accessed July 8, 2026.
Donald Knuth's series of books The Art of Computer Programming is famously dedicated to a 650.
History The first 650 was installed on December 8, 1954 in the controller's department of the John Hancock Mutual Life Insurance Company in Boston.
The IBM 7070 (signed 10-digit decimal words), announced 1958, was expected to be a "common successor to at least the 650 and the [IBM] 705". The IBM 1620 (variable-length decimal), introduced in 1959, addressed the lower end of the market. The UNIVAC Solid State (a two-address computer, signed 10-digit decimal words) was announced by Sperry Rand in December 1958 as a response to the 650. None of these had an instruction set that was compatible with the 650.
Hardware The basic 650 system consisted of three units:
IBM 650 Console Unit housed the magnetic drum storage, arithmetical device (using vacuum tubes) and the operator's console. IBM 655 Power Unit IBM 533 or IBM 537 Card Read Punch UnitOther IBM names for the 533 included Input-Output Unit and Read-Punch Unit. The IBM 533 had separate feeds for reading and punching; the IBM 537 had one feed, thus could read and then punch into the same card. Weight: .
Optional units:
IBM 46 Tape To Card Punch, Model 3 IBM 47 Tape To Card Printing Punch, Model 3 IBM 355 Disk Storage Unit Systems with a disk unit were known as IBM 650 RAMAC Data Processing Systems IBM 407 Accounting Machine IBM 543 Card Reader Unit IBM 544 Card Punch Unit IBM 652 Control Unit (magnetic tape, disk) IBM 653 Storage Unit (magnetic tape, disk, core storage, index registers, floating-point arithmetic) IBM 654 Auxiliary Alphabetic Unit IBM 727 Magnetic Tape Unit IBM 838 Inquiry Station
Main memory Rotating drum memory provided 1,000, 2,000, or 4,000 words of memory at addresses 0000 to 0999, 1999, or 3999 respectively. Each word had 10 bi-quinary coded decimal digits, representing a signed 10-digit number or five characters. (Counting a bi-quinary coded digit as seven bits, 4000 words would be equivalent to 35 kilobytes.) Words on the drums were organized in bands around the drum, fifty words per band, and 20, 40, or 80 bands for the respective models. A word could be accessed when its location on the drum surface passed under the read/write heads during rotation (rotating at 12,500 rpm, the non-optimized average access time was 2.5 ms). Because of this timing, the second address in each instruction was the address of the next instruction. Programs could then be optimized by placing instructions at addresses that would be immediately accessible when execution of the previous instruction was completed. IBM provided a form with ten columns and 200 rows to allow programmers to keep track of where they put instructions and data. Later an assembler, SOAP (Symbolic Optimal Assembly Program), was provided that performed rough optimization.
The LGP-30, Bendix G-15 and IBM 305 RAMAC computers used vacuum tubes and drum memory too, but they were quite different from the IBM 650.
Instructions read from the drum went to a program register (in current terminology, an instruction register). Data read from the drum went through a 10-digit distributor. The 650 had a 20-digit accumulator, divided into 10-digit lower and upper accumulators with a common sign. Arithmetic was performed by a one-digit adder. The console (10 digit switches, one sign switch, and 10 bi-quinary display lights), distributor, lower and upper accumulators were all addressable; 8000, 8001, 8002, 8003 respectively.
IBM 653 Storage Unit The optional IBM 653 Storage Unit, was introduced on May 3, 1955, ultimately providing up to five features:
Magnetic tape controller (for IBM 727 Magnetic Tape units) (10 extra operation codes) Disk storage controller (1956 enhancement for then new IBM 355 Disk Storage Unit) (five extra operation codes) Sixty 10-digit words of magnetic core memory at addresses 9000 to 9059. This small fast memory had an access time of 96μs, a 26-fold improvement relative to the rotating drum. This feature added five operation codes and was needed as a buffer for tape and disk I/O. The 60 words could also be used by programs to speed up inner loops and table lookups. Three four-digit index registers at addresses 8005 to 8007; drum addresses were indexed by adding 2000, 4000 or 6000 to them, core addresses were indexed by adding 0200, 0400 or 0600 to them. If the system had the 4000 word drum then indexing was by adding 4000 to the first address for index register A, adding 4000 to the second address for index register B, and by adding 4000 to each of the two addresses for index register C (the indexing for 4000-word systems only applied to the first address). The 4000-word systems required transistorized read/write circuitry for the drum memory and were available before 1963. (18 extra operation codes) Floating point – arithmetic instructions supported an eight-digit mantissa and two-digit characteristic (offset exponent) – MMMMMMMMCC, providing a range of ±0.00000001E-50 to ±0.99999999E+49. (seven extra operation codes)
Instruction set The 650 instructions consisted of a two-digit operation code, a four-digit data address and the four-digit address of the next instruction. The sign was ignored on the basic machine, but was used on machines with optional features. The base machine had 44 operation codes. Additional operation codes were provided for options, such as floating point, core storage, index registers and additional I/O devices. With all options installed, there were 97 operation codes.IBM 650 CPU Extensions
The Table lookup (TLU) instruction could high-equal compare a referenced 10-digit word with 48 consecutive words on the same drum band in one 5ms revolution and then switch to the next band in time for the next 48 words. This feat was about one-third the speed of a one-thousand times faster binary machine in 1963 (1,500 microseconds on the IBM 7040 to 5,000 microseconds on the 650) for looking up 46 entries as long as both were programmed in assembler. There was an optional Table lookup Equal instruction, with the same performance.
The Read (RD) instruction read an 80-column card of numeric data into ten memory words; the distribution of digits to words determined by the card reader's control panel wiring. When used with the 533 Reader Punch unit's Alphabetic device, a combination of numeric and alphanumeric columns (maximum of 30 alphanumeric columns) could be read. An expansion feature allowed more alphanumeric columns but certainly not over 50, as only ten words (five characters per word) were stored on the drum by a card read operation.
The base machine operation codes were:
17AABLAdd absolute to lower accumulator15ALAdd to lower accumulator10AUAdd to upper accumulator45BRNZBranch on accumulator non-zero46BRMINBranch on minus accumulator44BRNZUBranch on non-zero in upper accumulator47BROVBranch on overflow90-99BRDBranch on 8 in distributor positions 1-1014DIVDivide64DIVRUDivide and reset upper accumulator69LDLoad distributor19MULTMultiply00NO-OPNo operation71PCHPunch a card70RDRead a card67RAABLReset accumulator and add absolute to lower accumulator65RALReset accumulator and add to lower accumulator60RAUReset accumulator and add to upper accumulator68RSABLReset accumulator and subtract absolute from lower accumulator66RSLReset accumulator and subtract from lower accumulator61RSUReset accumulator and subtract from upper accumulator35SLTShift accumulator left36SCTShift accumulator left and count30SRTShift accumulator right31SRDShift accumulator right and round accumulator01STOPStop if console switch is set to stop, otherwise continue as a NO-OP24STDStore distributor into memory22STDAStore lower accumulator data address into distributor Then store distributor into memory23STIAStore lower accumulator instruction address into distributor Then store distributor into memory20STLStore lower accumulator into memory21STUStore upper accumulator into memory.18SABLSubtract absolute from lower accumulator16SLSubtract from lower accumulator11SUSubtract from upper accumulator84TLUTable lookup
Notes:
The IBM 653 options could implement additional instruction codes.
Sample program
This one-card program, taken from the 650 Programming Bulletin 5, IBM, 1956, 22-6314-0, will set most of the drum storage to minus zeros. The program includes examples of instructions being executed from the console switches and from an accumulator.
To begin, a load card is keypunched with 80 consecutive digits (the second column below) so that, when read, drum locations 0001 through 0008 contents will be as shown.A 12 punch can be used to identify cards as load cards. Load cards are directly read into words 1-8 of the specified storage band
0001 0000010000 0002 0000000000- 0003 1000018003 0004 6100080007 0005 2400008003 0006 0100008000 0007 6900060005 0008 2019990003
The console digit switches (address 8000) are manually set to a Read instruction with data address 0004.
loc- op|data|next ation |addr|instruction | |addr
8000 RD 70 0004 xxxx Read load card into first band read area