An instruction-set architecture, or ISA, is the abstract definition of what a processor can do as seen by the software running on it. It specifies the set of machine instructions, the registers a program may use, how memory is addressed, the data types the processor understands, and how exceptions and privileged operations behave. The ISA is the part of a computer’s design that programmers and compilers target, as opposed to the microarchitecture, which is how a particular chip actually implements those instructions in silicon.
The defining property of an ISA is that it is a contract between hardware and software. Any chip that faithfully implements the specification will correctly run any program written for it, regardless of the internal circuitry. This is why architecture specifications are published as precise, versioned documents: the Arm Architecture Reference Manual, for instance, exists so that every Arm-compatible processor and every Arm program agree on exactly what each instruction means. The RISC-V International project publishes its instruction-set specifications for the same reason, and notes that they are free and publicly available so anyone can implement the contract.
Because the ISA is a stable boundary, it enables binary compatibility, the ability to take a compiled program and run it on a different chip, or a much later chip, without recompiling. A binary built for an architecture decades ago can still run on a modern implementation of the same ISA, which is why software ecosystems can outlive the individual processors they were written for. The instruction set, not the transistor layout, is what software depends on.
This stable interface also lets hardware and software evolve independently. Chip designers can radically rearchitect the internals of a processor, adding pipelines, caches, out-of-order execution, or multiple cores, while keeping the same ISA, so existing software keeps working. Conversely, compilers and operating systems can advance while continuing to emit the same instructions. Most architectures extend their ISA carefully and additively for exactly this reason, so that old binaries remain valid even as new instructions appear.
The choice of what goes into an ISA is a central design debate, captured in the contrast between RISC and CISC philosophies. Whether an architecture offers a few simple instructions or many complex ones, the instruction set remains the fundamental dividing line in computing, the agreed-upon interface that makes it possible for software written by one party to run on hardware built by another.