Motorola opens its 1977 MC14500B handbook with the kind of questions an industrial controls engineer would recognise immediately: is a limit switch closed, has a timer finished, should a pump turn on when three relays are active, or should a motor start after a certain number of pulses?1
Every one of those questions has the same useful property: the answer fits in one bit, so widening the value being manipulated would not make the decision any more expressive.
That is the useful way to understand the MC14500B. It was not an eight-bit computer stripped of seven bits merely to save silicon; it was a programmable core aimed at a world where many inputs were open or closed contacts and many outputs were actuators that needed to be on or off.
One result
The component fits in a 16-pin DIP package. Its logic unit takes one bit from the data line and one from its sole Result Register, RR; it can load or invert a value, perform AND, OR and complemented variants or XNOR, then store the result outside the chip.16
That is what “one bit” describes: the data path and accumulator operate on one Boolean value at a time.
The program is not, obviously, a stream of isolated single bits. Four instruction pins encode 16 opcodes, while the system memory and external logic provide addresses for inputs and outputs.1
Nor does the chip contain program memory, a program counter or a stack. A minimal controller therefore adds an external counter, ROM or RAM, an input selector and an output latch.1 Saying that the CPU “ran a factory” is convenient shorthand; in practice it was the tiny Boolean core inside a controller built around it.
Four lines
Take the example Motorola gives in the handbook preface: a pump should run when relays A, B and C are all closed.1
The logic is simply:
PUMP = A AND B AND C
On an MC14500B the decision unfolds almost literally:
LD A ; RR takes the state of contact A AND B ; RR becomes A AND B AND C ; RR becomes A AND B AND C STO PUMP ; write RR to the output
There is no number to add, string to manipulate or pixel to move. The machine only needs to decide whether three true conditions permit one true output, which makes a one-bit accumulator exactly wide enough.
Then the controller repeats, following the cyclic scan idea still recognisable in PLCs today: evaluate the logic, update results and return to the beginning before the physical process has moved very far.
Motorola gives a revealing timing example. With a 1,000-instruction program and a 500 kHz clock, the loop is scanned 500 times each second, so an input change can affect an output within the following two milliseconds.1
For this kind of control, the useful performance question is how quickly the controller revisits the decision, rather than how wide its accumulator happens to be.
Series and parallel
The architecture looks even less peculiar when viewed through the language industrial electricians already used: ladder logic, drawn like rails and rungs of relay contacts and coils.
Two contacts in series require both paths to conduct and map directly to an AND; put branches in parallel and either path may conduct, which maps to an OR, while a normally closed contact becomes a complemented condition.
The MC14500B therefore did not ask an electrician to think like the programmer of a general-purpose computer. It serialised a control language already made of Boolean decisions.
Motorola explicitly sold simplicity as a feature. Its handbook contrasts relays, which were understandable but bulky and awkward to change, with microcomputers that could be overqualified for elementary control work.1 The ICU tried to keep the relay mental model while making the wiring programmable.
State appears
The A-B-C pump needs no memory because every scan can recompute the output from the three contacts. A real machine quickly asks for something more subtle.
Nicola Cimmino, whose Hackaday Europe 2026 talk brought the chip back into view,23 uses the classic START/STOP motor circuit in his open-source PLC14500 Nano trainer.4
Release START and the motor should keep running, which means the controller must remember a RUN state.
His main rung maps to another compact sequence: load START, OR it with the previous RUN value, cancel the result when STOP is pressed, store the new RUN value, then send it to the motor.4
LD START OR RUN ANDC STOP STO RUN STO MOTOR
Persistent RUN does not live magically inside the result register. Cimmino’s board maps it to an external scratchpad bit looped back as an input.4 The processor remains tiny and the system adds state only where the problem requires it.
Not a whole computer
That modularity explains both the elegance and the limitations of the MC14500B.
The chip has sixteen instructions, yet such basic functions as the program counter, code storage and temporary bits belong to the circuit surrounding it. Instructions such as JMP and RTN even expose flags for outside logic to interpret.1
The architecture looks strange if it is compared directly with a contemporary Z80. That comparison misses the intended jobs: a Z80 wants to be the processor in a computer, while the MC14500B wants to be programmable logic at the centre of a controller.
Ken Shirriff’s reverse engineering puts the chip at roughly 500 transistors.6 To be sure, the one-bit path explains only part of the simplicity, because Motorola also left many familiar CPU functions outside the package and expected the surrounding controller to provide them.
“Ran factories”
Hackaday titled this week’s article “The 1-Bit CPU That Ran Factories” after Cimmino’s talk.2 The phrase captures the chip’s industrial purpose, although the surviving public sources are much better at documenting the architecture than providing an auditable inventory of named factories and machines.
Motorola’s handbook is unambiguous about the target: industrial decisions involving relays, pumps, motors, timers and PLC-like systems.1 Hackaday describes the chip as having powered many programmable industrial systems.2 A derivative of the architecture also found its way into a custom automotive controller for Nippon Denso according to the component’s historical record.7
What IRZ did not find is a registry that would support a neat list of specific production lines and their exact MC14500B controllers. We therefore keep “ran factories” as a description of a class of industrial use, rather than pretending the archive lets us count deployments today.
A modern trainer
Cimmino first rebuilt systems around the chip and eventually produced the PLC14500 Nano: 256 bytes of program RAM, seven inputs, seven outputs, one timer, seven scratchpad bits and three clock modes, including manual stepping.4
An Arduino Nano hides underneath, but only to load program memory from a modern computer; the MC14500B executes the program afterwards.4 The board is Open Source Hardware certified, and its repository contains schematics, PCB files, assembler, simulator and programming guide.45
Manual step mode is perhaps the clearest way to understand the architecture, because LEDs expose the address, data, RR, write signal and internal states while each instruction crosses the system.
The right width
Nobody would normally choose an MC14500B to automate a new machine in 2026. A modern microcontroller or PLC is inexpensive, carries far more capability and comes with an ecosystem that is incomparably easier to use.
The old chip still preserves a useful lesson: useful power depends on the problem, not on the number of bits printed in a brochure.
If A, B and C decide whether a pump may run, eight bits would not produce a truer answer. Neither would thirty-two.
The MC14500B could be extraordinarily small because, at that particular instant, the world it needed to observe reduced cleanly to yes or no.