A topic in the Open Knowledge Graph — a free, open map of 15,290 topics and the order to learn them in.
The Instruction Set Architecture (ISA) is the contract between hardware and software: it specifies the instructions a CPU can execute, the registers visible to programs, data types, addressing modes, and the binary encoding of each instruction. RISC designs use few, simple, fixed-length instructions; CISC designs provide many complex, variable-length instructions. Major ISAs include x86 (CISC), ARM and RISC-V (RISC). The ISA determines what machine code is valid for a given processor family and is independent of the underlying microarchitecture.
Study a simple ISA like MIPS or RISC-V. Encode a few instructions by hand into their binary format. Write a short program in assembly and trace how each instruction is fetched, decoded, and executed. Compare instruction formats across RISC and CISC designs.
When a program runs on a computer, it ultimately executes as a sequence of binary instructions: patterns of 0s and 1s that tell the CPU to add two numbers, load a value from memory, or jump to a new location. The Instruction Set Architecture (ISA) is the complete specification of this language — it defines which instructions exist, how they are encoded in binary, which registers a program can use, and exactly what each instruction does to the machine's state. Software talks to hardware through the ISA, and nothing else.
The ISA is a contract, not an implementation. This is the most important idea. Two CPUs can both implement the x86 ISA — meaning they both correctly execute every x86 instruction — while using completely different internal designs. One might use a 5-stage pipeline with in-order execution; the other might use a 20-stage pipeline with out-of-order execution and speculative execution. Both produce identical results for any valid x86 program. This separation lets hardware engineers continuously redesign internals for speed and efficiency without breaking existing software.
RISC (Reduced Instruction Set Computer) and CISC (Complex Instruction Set Computer) represent two design philosophies for what an ISA should look like. RISC ISAs (like ARM and RISC-V) provide few, simple, fixed-length instructions that each do a small amount of work — typically one operation per instruction, with memory access restricted to dedicated load/store instructions. CISC ISAs (like x86) accumulated many complex instructions over decades, some of which can do multiple operations in a single instruction. The original motivation for RISC was that compilers rarely used complex instructions, so simple instructions executed by a fast pipeline outperformed complex instructions executed slowly. Modern x86 CPUs blur the line by internally decomposing CISC instructions into RISC-like micro-operations.
Addressing modes — how an instruction specifies its operands — are another key ISA dimension. An instruction might operate on values stored in registers (register addressing), at a fixed memory address (direct addressing), or at an address computed from a register plus an offset (register-indirect with displacement). The available addressing modes affect how efficiently compilers can generate code for common patterns like array indexing and pointer dereferencing.
Understanding the ISA matters for anyone who wants to understand compilers, operating systems, or performance optimization. When a compiler transforms your Python or C++ code into machine code, it is translating into a specific ISA. When you profile a program and find a bottleneck, understanding what instructions are generated — and how the microarchitecture executes them — is often the key to understanding why.