Beyond the Buzzwords: How x86 and ARM64 Actually Work
I first became curious about this way back in 2020 when Apple released the M1 chip and ARM was all the craze. I had heard the term before in the context of mobile phone processors, but I had no idea what it actually meant. Whenever I asked for the difference, people would just say, “ARM is more efficient,” or “It uses less power.”
That wasn’t enough for me. I wanted to know the why. What does the architecture actually mean? Why does ARM use less power? What does the “64” stand for? Why did Apple bet their entire Mac lineup on it, and why does older software need a translator like Apple’s Rosetta just to run?
That is exactly what this article explores. If you just want a quick, surface-level comparison, you might want to skip this one. This article may not be worth your time. But if, like me, you want to truly understand it, stick around. I’ll be explaining it in detail, and while some computer science knowledge might be helpful, you won’t need it to understand this article.
How Does a Processor Work?
Before we get into the differences, we have to cover a prerequisite: how does a processor actually work? I won’t go into too much detail here to avoid digressing from the topic, so consider this a quick overview.
You might have heard about storage sizes like 256 GB, 512 GB, or 1 TB. These larger sizes are composed of much smaller pieces:
- 1 GB is 1024 MB
- 1 MB is 1024 KB
- 1 KB is 1024 bytes
The capital “B” at the end of each term stands for bytes, with the preceding letter telling you just how many bytes there are.
If you are a careful observer, you may have noticed that storage sizes always use a capital “B”. However, when you look at speeds marketed by your internet service provider (ISP), you see a lowercase “b,” like Gbps. If you pay close attention, you might realize that a 1 Gbps connection doesn’t download a 1 GB file in one second. The reason? That smaller “b” stands for a bit. One byte (B) is equal to 8 bits (b).
A bit is the most basic unit of data a computer can store. It holds just a 1 or a 0.
Think of it like a light switch in your home, it is either on (
1) or off (0) It might seem boring, but combining these 1s and 0s in specific formats leads to incredibly powerful things. In fact, every piece of electronics you use relies on this fundamental concept, which we call binary.
Based on this, a processor performs various actions. For simplicity, let’s consider just one action: adding two numbers. This might sound basic, but the underlying mechanics of playing games or streaming videos eventually boil down to operations like addition. Every processor has a set of supported operations, and each one is represented by a binary code called an opcode.
For example, the command to “ADD” might look like 0001. Those 4 bits are arranged in a specific order to tell the processor, “Hey, add these two numbers.” The number of bits used to write these instructions isn’t fixed; it changes depending on the processor. Keep this in mind, because this exact concept is what leads to the core difference between ARM64 and x86.
Also, you may have noticed I keep using the word “processor” instead of “CPU.” That is deliberate. The CPU (Central Processing Unit) is just one kind of processor—think of it as the main manager that delegates tasks to a bunch of smaller, specialized components. Older computers had several distinct chips on the motherboard to handle specific tasks, with the CPU orchestrating everything. Modern devices use an SoC, or System on a Chip. This means all those specialized chips (like the graphics processor, or GPU) aren’t separate pieces on a board anymore; they are integrated into one single, incredibly complex chip alongside the CPU.
Instruction Set
Now that we have covered the pre-requisite let’s talk about instruction sets. Remember the earlier mention about how the command to ADD might look like 0001? Well, just like ADD, there are a lot of different instructions. Understandably, you might wonder: how does a processor know which instruction is which, and how is it mapped?
That is determined by something called an instruction set. As the name suggests, it is simply a set of instructions that defines what should happen in a specific scenario. We won’t get into the deep technical details of how it is set up, but the key takeaway is that this is part of the hardware, not the software.
Think of the chip as a box. You give it a specific input, and what it does based on that input is defined by the instruction set. In most cases (ignoring complex scenarios like microcode for now), this is an automatic physical behavior, not a program that is stored in memory. When the chip gets 0001, the action it physically must undertake is addition.
The Light Switch Analogy
The actual mechanism of doing this would take us way off topic, so let’s look at a simpler example.
You might have seen a setup in a house where one light can be controlled by multiple switches, like a bedroom light with one switch at the door and another right next to the bed. Let’s combine these concepts. Imagine you have two switches controlling a single light bulb. The wiring is set up so that the bulb behaves differently depending on the combination of those two switches:
- If both switches are OFF, the light is OFF.
- If Switch 1 is ON and Switch 2 is OFF, the light turns ON.
- If Switch 1 is OFF and Switch 2 is ON, the light turns ON.
- If both switches are ON, the light turns OFF.
This gives you four distinct behaviors. The exact behavior doesn’t matter; what matters is understanding that you can build physical logic where the state of the inputs (the switches) directly controls the behavior of the output (the light). This logic is essentially an instruction. You are basically writing a physical rule that says: “Do A when B and C are in this specific state.”
Hardware Logic: The XOR Gate
Try flipping the switches to see how physical state dictates the output.
In a processor, this behavior is controlled using something called logic gates (which handle binary operations like AND, OR, and NOT). These gates are built using microscopic electrical circuits. They don’t require software code or memory to store anything—the behavior is literally hardwired into the chip.
Bits as Switches
Now, if two switches gave us four possible behaviors for our light, it is logical to deduce that adding more switches would give us even more scenarios and allow for much more complex instructions. Can you guess whether processor designers want more of these switches or fewer of them? What happens in either case?
In computer science, the role of these switches is played by the bits we discussed earlier. The more bits you have for an instruction, the more complex your processor can be, meaning it can execute very complex decisions in a single go. Based on this idea of how many “switches” to use, ARM64 and x86 took two completely different approaches.
ARM64 and RISC
ARM64 uses a philosophy called RISC (pronounced risk), which stands for Reduced Instruction Set Computer. Based on our previous discussion, the naming is fairly straightforward. “Reduced” means it uses fewer or simpler instructions, “Instruction Set” is what we just described, and “Computer” simply refers to the processor running the logic.
ARM64 (also officially known as AArch64, meaning ARM Architecture 64-bit) is a very specific implementation of this RISC philosophy. Here is a very interesting and slightly confusing point: Both ARM64 and the older ARM32 use an instruction size of exactly 32 bits. Of those 32 bits, the actual command (in most systems) occupies only about 17 bits. The remaining bits are used to point to the data that needs to be operated on (which is stored in a temporary holding area called a register).
So, what does the “64” in ARM64 actually mean if the instructions are still 32 bits long? It refers to the size of those registers (the amount of data the processor can handle at one time). We will explore that more in a different article. For now, just consider 64 bits is the size of a register.
x86 and CISC
x86 uses something completely different called CISC, where the “C” stands for Complex. Unlike ARM, where every single instruction is a fixed 32 bits long, the instructions in CISC can be anywhere between 1 byte (8 bits) up to a hardware-enforced maximum of 15 bytes (120 bits).
This is the most important takeaway: Unlike ARM (RISC) where every instruction is a uniform, fixed size, x86 (CISC) instructions are highly variable. This lack of uniformity is actually what creates significant problems and inefficiencies with this style of processor design.
RISC vs CISC
Consider the following simplified example. You have two processors. One only has an ADD behavior, and the other has more bits so it has both ADD and MULTIPLY behaviors. You want to know what 3x3 is. Processor One only has ADD, so it first has to do 3+3, take that result, and add another 3 to it. Processor Two simply does 3x3 and gives you the result in one step. Since Processor One needed two steps and Processor Two needed just one step, it is clear that Processor Two will be faster in this specific scenario.
This example is simplified (in truth, ADD and MULTIPLY are core supported instructions for both), but for the sake of explanation, Processor One represents the RISC philosophy used by ARM. Processor Two represents the CISC philosophy used by x86. Effectively, the RISC philosophy is: “Let’s do a bunch of very small actions in a predictable, fast manner.” The CISC philosophy is: “Let’s ensure we can do the maximum amount of work with one single complex action.”
That CISC approach was heavily needed in the 1970s and 1980s because we had very little memory, or RAM. Memory is important because instructions are placed in RAM before they are processed by the chip. Consider the processor as a chef chopping vegetables. He can chop incredibly fast. However, if the vegetables are not on the cutting board and he always has to turn to the fridge to fetch them, he will spend most of his time fetching vegetables instead of cutting them. RAM is the cutting board. It is a staging area where the instruction is kept so it can be fetched extremely fast. (This is oversimplified, as we have L1, L2, and L3 caches too, but let’s pretend they don’t exist for now).
Back in the 80s, RAM was extremely expensive and rare, so loading multiple small instructions into memory was considered inefficient. You wanted one complex instruction to do a lot of work. Today, even in 2026 when there are hardware shortages, we still measure RAM in gigabytes (8GB, 16GB, etc.), not kilobytes. Memory is plentiful, so the RISC approach of using many simple instructions is actually winning the cost war.
x86 vs ARM64
Now you might be thinking, “Wait a minute. Apple says its M-series chips are much faster, and I noticed my ARM laptop is faster than my Intel one. So how can CISC (x86) doing things in one step be slower than RISC (ARM) doing things in multiple steps?”
The answer lies in practical hardware realities. Consider the following scenario: There is a set number of bits available for a specific processor or logical unit. This is your hardware constraint. Let’s, for the sake of example, say this number is 128 bits. Now, as stated earlier, all instructions for ARM processors are 32 bits, so you end up having the ability to process four things in parallel always. Whereas in the case of x86, an instruction could be anywhere between 8 bits to 120 bits. Because of this, the stream first needs to be decoded (see below) just to determine what the size of an instruction is, making it very likely that it cannot run as many tasks in parallel.
This also brings another problem to light. ARM (RISC) instructions are uniform, so only 32 bits need to be read, whereas x86 (CISC) instructions are variable. So, how do you know how many bits are actually needed for an instruction? Well, it relies on a very complex and power-hungry hardware component called the Instruction Length Decoder (ILD) to determine what the size of an instruction needs to be. This means that for a single task, x86 doesn’t just need enough power to run the complex instruction; it first needs to run a complex algorithm to determine what size the instruction needs to be, which itself takes up a lot of power. So, for equivalent processing, ARM-based architecture is far more power-efficient.
Instruction Decoding: RISC vs CISC
ARM64 (RISC): Uniform 32-bit Instructions
Uniform size means the decoder processes them in a smooth, predictable flow.
x86 (CISC): Variable Length Instructions
Variable sizes require a complex decoder, causing bottlenecks when checking lengths.
This discussion about power brings up another problem: your processors have to obey the laws of physics. Which is to say that if they heat up too much, they end up melting, and you have a very expensive souvenir in your hands. So, processors throttle themselves, which is to say they reduce their own ability to process things so they get time to cool down. This means ARM processors that use way less power throttle themselves much less compared to x86 processors. Ultimately, in terms of real-world performance, they might end up performing much better.
So, reiterating what was said earlier, we can say that ARM does a lot of simple things in parallel and faster than x86. This leads us to the only two questions we have not yet answered:
- Why did Apple bet their entire Mac lineup on it?
- Why does older software need a translator like Apple’s Rosetta just to run?
If you think a bit, the answer to the second question becomes very clear. The instruction set that basically tells the processor what task you need to run changes between ARM and x86, so we need a middle layer that translates this to support legacy software. Now, for 90-95% of applications, this has zero direct impact on the user. You don’t notice the translation, as the entire behavior is abstracted by the operating system on which the task is run. However, for the operating system itself, or specific software for video editing, games, etc., developers directly use processor-specific optimizations to make things faster. For applications like these, you heavily rely on a translation layer. It is also not without cost; the translation does slow the performance down by anywhere between 15-30% of what it could have been if it was built natively for the chipset. However, in the modern era, this isn’t as big of a dealbreaker as the chipset itself compensates for the loss. That is, the processors are good enough that even when delivering 70% of actual performance, they can run things smoothly.
Now to the first question: why did Apple bet their entire Mac lineup on it? Originally, it was all about power efficiency and battery life. As ARM chips generate very low heat chip designers can add a number of components together onto a single System on Chip (SoC) without them melting. It just so happened, that this architecture perfectly positioned them for the major buzzword going around today. If you guessed AI, congratulations, you are right. LLMs and most ML loads don’t care about parsing complex logic; they just repeatedly carry out the same multiply operations billions of times. So having a single tightly packed chipset is a boon for this type of workload. An SoC reduces latency because the RAM and processors are physically closer together, which allows the NPU (Neural Processing Unit, maybe topic for another article) to seamlessly integrate and run AI workloads.
Well if you survived until now. Congratulations! I’m glad you found my writing interesting enough to devote so much time to it and hope that I’ve managed to clarify the topic.