razzi.abuissa.net

Razzi's guide to instruction set architectures

This is a practical guide to instruction set architectures (ISAs) based on the current crop of computer architectures (as of 2026).

For a more generic overview of how computers are put together, see the Wikipedia page for computer architecture.

In this article, whenever I refer to the “architecture of a computer”, I’ll be referring to its instruction set architecture.

32-bit versus 64-bit

One key attribute of a computer architectures is the size of a word.

By now, almost all devices are running some sort of 64-bit architecture.

32-bit architectures were once dominant, however modern operating systems do not support it any more: the last Windows version to support 32-bits was Windows 10 (which ended support in 2025).

Similarly, Android 13 was the last version to support 32-bit, which is still technically supported, but Android 14 was released in 2023.

The reason for this is 32-bit pointers can only distinctly refer to 2^32 == 4,294,967,296 addresses, which is 4 gibibytes (4 GiB). 32-bit computers would then max out of memory with 4 Gib. They can technically support more, but it’s more complex and less efficient.

Microcontrollers however still use 32-bit processors, such as the Raspberry Pi Pico 2, released in 2024.

32-bit is still cheaper and more energy efficient, so it’ll probably stick around for quite a while in niche applications, however it is prone to problems such as the year 2038 problem.

my computer architectures

Of my current devices, there are 3 ISAs:

x86-64

This started as the 32-bit Intel 386 and evolved through 486, 586 etc (hence x86).

In 1999, AMD extended the 32-bit ISA to 64-bit, calling it x86-64. This was backwards compatible with 32-bit code.

This is currently the ISA of my older Macbook (before Apple-designed M processors) and my Framework Windows laptop.

This ISA goes by many names: x86-64, x86_64, x64, and amd64.

arm64

The R in ARM stands for RISC, which in turn stands for Reduced Instruction-Set Computer.

This came on the scene first with iPhones, then eventually Macs switched from Intel chips to custom apple-designed silicon. In any case it uses the ISA from ARM with 64 bit words. There are various versions of this ISA but for most software applications all that matters is that it’s ARM and 64 bits.

This ISA goes by 2 names: arm64 and aarch64.

riscv64

Kinda just for fun and looking towards an open computing idealistic future, I purchased one of the first consumer-grade RISC-V boards, the StarFive VisionFive2. I couldn’t really do much with it at all, but I could run their custom debian build.

The name is pretty much just riscv64, thankfully.

how to see what architecture your computer is

Run uname -m. You can also use arch however that’s not as standard.

$ uname -m
arm64

Here are some examples of its output:

ubuntu@ubuntu:~$ uname -m
riscv64
ubuntu@ubuntu:~$ arch
riscv64

$ uname -m
arm64
$ arch
arm64

Apple’s intel processors confusingly report arch of i386, to disambiguate from even earlier processors that used the PowerPC architectures:

$ uname -m
x86_64
$ arch
i386

should I care about ISAs

There was this interview with Linus Torvalds where he said that end users won’t really notice anything changing with the introduction of RISC-V, and I generally agree. As long as software works (and this is handled by the hardware, kernel, and compiler, not even by interpreted languages), users won’t see the difference, other than, say, power efficiency.

You may notice I didn’t even mention endianness. That’s because in software, as long as everything agrees, there’s no issue. When you might actually care about endianness is if you’re debugging serial output or actual gates within a computer. But I’ve never really had to do that!