# Instruction set architecture
An instruction set architecture (ISA) is the formal specification of the machine-level instructions, registers, addressing modes, data types, and execution model that a processor exposes to software[1](https://maloneuniversity.org/library/encyclopedia/computer-science/computer-architecture/instruction-set-architecture). It is the contract between hardware and software: applications, compilers, and operating systems are written to target the ISA, and every physical processor that implements the ISA must execute whatever the specification defines[2](https://cs315-f25.cs.usfca.edu/lectures/11-cs315-2025-10-28-processor-components/) • [3](https://www.cs.umd.edu/users/meesh/411/CA-online/chapter/instruction-set-architecture/index.html).
| Key fact | Detail |
|---|---|
| Definition | Specification of instructions, registers, addressing modes, data types, and execution model visible to software[1](https://maloneuniversity.org/library/encyclopedia/computer-science/computer-architecture/instruction-set-architecture) |
| Distinction | The microarchitecture is the internal processor design that implements the ISA; the two are deliberately kept separate[2](https://cs315-f25.cs.usfca.edu/lectures/11-cs315-2025-10-28-processor-components/) |
| Major families | As of 2024, the two most prominent CPU ISA families are x86-64 (also called amd64) and ARM[4](https://courses.grainger.illinois.edu/cs340/sp2025/text/isa.html) |
| Open standard | RISC-V is an open standard ISA based on reduced instruction set computer (RISC) principles, defined as a base integer ISA plus optional extensions[5](https://docs.riscv.org/) |
| Register count | Program registers in CPU ISAs are typically 16 or 32 in number[4](https://courses.grainger.illinois.edu/cs340/sp2025/text/isa.html) |
| Compatibility payoff | Successive processor generations implementing the same ISA have delivered order-of-magnitude performance improvements primarily through microarchitectural refinements[6](https://technav.ieee.org/topic/microarchitecture/) |
## ISA versus microarchitecture
The single most important distinction in computer architecture is between the ISA and the microarchitecture[2](https://cs315-f25.cs.usfca.edu/lectures/11-cs315-2025-10-28-processor-components/). The ISA is the machine language, the interface seen by the assembly-language programmer and by compiled programs; the microarchitecture is the design of the machine itself, its functional units and data paths, built to implement that ISA[7](https://cseweb.ucsd.edu/classes/fa96/cse30/lec1/). The ISA defines what a processor can do without specifying how its internal circuits carry out each operation[8](https://technav.ieee.org/topic/instruction-sets/).
**Why the split matters.** Because the contract is fixed, hardware vendors can improve processor implementations over time while preserving software compatibility[1](https://maloneuniversity.org/library/encyclopedia/computer-science/computer-architecture/instruction-set-architecture). Successive generations of processors implementing the same ISA have delivered order-of-magnitude performance improvements primarily through microarchitectural refinements such as pipelining and out-of-order execution[6](https://technav.ieee.org/topic/microarchitecture/). This principle is stated openly in the RISC-V specification: the ISA is defined with implementation details kept to a minimum and is meant to be understood as the interface that software sees across many different implementations, not as the blueprint of any single piece of hardware.[9](https://docs.riscv.org/reference/isa/v20240411/unpriv/intro.html)
## What an ISA specifies
From the software side, an ISA is a set of instructions with two representations: machine code, a compact binary encoding, and assembly, a less-compact textual representation of the same information. Converting assembly to machine code is fully reversible, so the two terms are often used informally as synonyms[4](https://courses.grainger.illinois.edu/cs340/sp2025/text/isa.html).
Each instruction is defined by an operation and typically a few operands. Three forms of operand are common: immediate values embedded in the instruction itself, program registers (typically 16 or 32 in number), and memory addresses[4](https://courses.grainger.illinois.edu/cs340/sp2025/text/isa.html). Most instructions fall into a small set of types: load a value from memory into a register, store a value from a register to memory, compute a value from register values, and jump to a new location[4](https://courses.grainger.illinois.edu/cs340/sp2025/text/isa.html). ISAs also specify conditional behavior, commonly through flags or condition-code registers updated by compute instructions and checked by later conditional instructions, and modern ISAs include a small number of atomic operations that load, compute, and store with a guarantee that no other processor can modify the memory in between[4](https://courses.grainger.illinois.edu/cs340/sp2025/text/isa.html).
An ISA also defines the execution model beyond individual instructions. The [Intel 64](https://www.edgepedia.org/x86-64) and IA-32 architectures, for example, recognize four privilege levels numbered 0 to 3, where level 0 is the highest privilege and is used for the most critical code, usually the operating-system kernel; lower-privilege code reaches higher-privilege services only through a controlled interface called a gate[10](https://cdrdv2-public.intel.com/671436/253665-sdm-vol-1.pdf).
## RISC and CISC
The terms CISC (complex instruction set computer) and RISC (reduced instruction set computer) arose when a university professor proposed an alternative to the then-dominant x86 ISA and dubbed x86-style designs CISC while advocating RISC; the names stuck, and most non-x86 ISAs advertise themselves as RISC[4](https://courses.grainger.illinois.edu/cs340/sp2025/text/isa.html). A CISC ISA such as x86 uses variable-length instructions and richer addressing modes, while RISC designs favor simpler, fixed-length instructions that are easier to decode, leading to shorter cycle times[7](https://cseweb.ucsd.edu/classes/fa96/cse30/lec1/).
In practice the boundary has blurred at the implementation level. For a complex-instruction-set design like x86, the microarchitecture can break down the ISA's variable-length instructions into simpler [micro-operations](https://www.edgepedia.org/micro-operation) (uops), which then proceed through an out-of-order pipeline.[6](https://technav.ieee.org/topic/microarchitecture/) Modern x86 implementations thereby achieve performance comparable to RISC designs by translating CISC instructions at decode time into micro-operations that feed a RISC-like execution core, effectively layering a RISC microarchitecture beneath a CISC ISA surface[8](https://technav.ieee.org/topic/instruction-sets/).
## Major ISA families
Since 1978, x86-64 has developed while maintaining backward compatibility, and it is widely found in Intel- and AMD-made devices serving as servers, workstations, desktops, and laptops.[4](https://courses.grainger.illinois.edu/cs340/sp2025/text/isa.html) Intel documents the architecture in a multi-volume software developer's manual: Volume 1 describes the architecture and programming environment, Volume 2 provides the full instruction set reference A to Z, and Volumes 3 and 4 cover system programming and model-specific registers[11](https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html?wapkw=intel+64).
**Arm.** Qualcomm, Samsung, and Apple frequently build phones, embedded systems, and low-power laptops around Arm, which actually consists of multiple ISAs with loose connections to one another; among these, aarch64 is widely used[4](https://courses.grainger.illinois.edu/cs340/sp2025/text/isa.html). Arm publishes annual updates to its A-Profile architecture alongside full instruction set and system register documentation; the 2024 update was Armv9.6-A and the 2026 update is Armv9.8-A[12](https://developer.arm.com/community/arm-community-blogs/b/architectures-and-processors-blog/posts/arm-a-profile-architecture-developments-2024) • [13](https://developer.arm.com/community/arm-community-blogs/b/architectures-and-processors-blog/posts/arm-a-profile-architecture-developments-2026). The A64 instruction set keeps a 32-bit instruction size while adding 64-bit capability, passes up to 8 parameters in registers X0 through X7, and produces 64-bit Dalvik JIT code around 6% smaller than the 32-bit equivalent[14](https://developer.arm.com/community/arm-community-blogs/b/architectures-and-processors-blog/posts/the-a64-isa-and-compilers).
**RISC-V.** RISC-V (pronounced "risk-five") is an open standard ISA based on established RISC principles[5](https://docs.riscv.org/). The RISC-V ISA consists of a base integer ISA—required in every implementation—together with optional extensions; its two main base variants, RV32I and RV64I, offer 32-bit and 64-bit address spaces, respectively, and XLEN gives the width of the integer registers in bits.[9](https://docs.riscv.org/reference/isa/v20240411/unpriv/intro.html) Standard extensions add integer multiply and divide (M), atomic operations (A), single- and double-precision floating point (F and D), and compressed 16-bit instructions (C), and a naming convention concatenates the base prefix with extension letters, as in RV64IMAFD[9](https://docs.riscv.org/reference/isa/v20240411/unpriv/intro.html) • [15](https://docs.riscv.org/reference/isa/unpriv/naming.html). The base RV32I ISA uses less than 1/8 of the 32-bit instruction-word encoding space, deliberately leaving room for custom and non-standard extensions[9](https://docs.riscv.org/reference/isa/v20240411/unpriv/intro.html).
## The ISA, compilers, and the ABI
Compilers are the main producers of ISA-level code: they translate high-level source into machine instructions for a target ISA, and a compiler told which extensions a target implements will generate instruction words only from those sets[4](https://courses.grainger.illinois.edu/cs340/sp2025/text/isa.html). The ISA is the language component of the application binary interface (ABI), which also encompasses libraries and the conventions describing high-level features of programs written for the ABI[16](https://fileserver-az.core.ac.uk/download/pdf/19879480.pdf).
**Compatibility across ISA changes.** Because so much software is tied to an ISA, transitions are expensive and are usually managed rather than forced. Intel's IA-64 (Itanium) effort, announced with HP in 1999, aimed at a 64-bit ISA for workstations and servers while protecting customer software investments through compatibility with Intel's IA-32 processors in hardware and HP's PA-RISC instructions through software translation[17](https://www.intel.com/pressroom/archive/releases/1999/Sp052699.htm). More recently, Intel has published a paper and draft specification exploring a simplified, 64-bit-mode-only future architecture while stating it will continue to maintain its longstanding commitment to software compatibility[18](https://www.intel.com/content/www/us/en/developer/articles/technical/envisioning-future-simplified-architecture.html). Research on automatic CISC-to-RISC translation, including language-model-guided transpilation compared against Apple's Rosetta 2, shows active work on moving code across the x86-to-ARM divide[19](https://arxiv.org/abs/2506.14606).
## References
1. [Instruction Set Architecture, MGU Encyclopedia](https://maloneuniversity.org/library/encyclopedia/computer-science/computer-architecture/instruction-set-architecture)
2. [Processor Components, CS 315 Computer Architecture, University of San Francisco](https://cs315-f25.cs.usfca.edu/lectures/11-cs315-2025-10-28-processor-components/)
3. [Instruction Set Architecture, CMSC 411 Computer Architecture, University of Maryland](https://www.cs.umd.edu/users/meesh/411/CA-online/chapter/instruction-set-architecture/index.html)
4. [ISAs and Assembly, CS 340, University of Illinois Grainger College of Engineering](https://courses.grainger.illinois.edu/cs340/sp2025/text/isa.html)
5. [risc-v ratified specifications library::risc-v ratified specifications library](https://docs.riscv.org/)
6. [Microarchitecture, IEEE Technology Navigator](https://technav.ieee.org/topic/microarchitecture/)
7. [CSE 30 Lecture 1, UC San Diego](https://cseweb.ucsd.edu/classes/fa96/cse30/lec1/)
8. [Instruction sets, IEEE Technology Navigator](https://technav.ieee.org/topic/instruction-sets/)
9. [RISC-V Ratified Specifications Library, Unprivileged ISA introduction](https://docs.riscv.org/reference/isa/v20240411/unpriv/intro.html)
10. [Intel 64 and IA-32 Architectures Software Developer's Manual, Volume 1: Basic Architecture](https://cdrdv2-public.intel.com/671436/253665-sdm-vol-1.pdf)
11. [Manuals for Intel 64 and IA-32 Architectures, Intel Developer Zone](https://www.intel.com/content/www/us/en/developer/articles/technical/intel-sdm.html?wapkw=intel+64)
12. [Arm A-Profile Architecture Developments 2024, Arm Community](https://developer.arm.com/community/arm-community-blogs/b/architectures-and-processors-blog/posts/arm-a-profile-architecture-developments-2024)
13. [Arm A-Profile Architecture Developments 2026, Arm Community](https://developer.arm.com/community/arm-community-blogs/b/architectures-and-processors-blog/posts/arm-a-profile-architecture-developments-2026)
14. [The A64 ISA and compilers, Arm Community](https://developer.arm.com/community/arm-community-blogs/b/architectures-and-processors-blog/posts/the-a64-isa-and-compilers)
15. [ISA Extension Naming Conventions, RISC-V Ratified Specifications Library](https://docs.riscv.org/reference/isa/unpriv/naming.html)
16. [Execution Model and Optimizing Compilation for the EM 2 Core ISA, CORE](https://fileserver-az.core.ac.uk/download/pdf/19879480.pdf)
17. [Intel, HP Reveal IA-64 Instruction Set Architecture, Intel press release (1999)](https://www.intel.com/pressroom/archive/releases/1999/Sp052699.htm)
18. [Envisioning a Simplified Intel Architecture, Intel Developer Zone](https://www.intel.com/content/www/us/en/developer/articles/technical/envisioning-future-simplified-architecture.html)
19. [Guaranteed Guess: A Language Modeling Approach for CISC-to-RISC Transpilation with Testing Guarantees, arXiv](https://arxiv.org/abs/2506.14606)
---
*Topic: Encyclopedia › Technology and the built world › Computing and digital systems › Computer hardware › Processors & processor engineering › Instruction set architectures*
*Initially written Sep 17, 2026 · Reviewed: Sep 17, 2026; Sep 30, 2026; Oct 15, 2026 · Edited: Oct 15, 2026 · Last review: Oct 15, 2026*
*Copyright 2026 EdgeChat AI, a subsidiary of Biostate AI.*
License: Edgepedia Community License 1.0, https://www.edgepedia.org/edgepedia/license