x86 vs ARM: Who Really Owns the Chip in Your Next Laptop

By Tom Langston · 14 July 2026

Hardware
CPUs
ARM
Apple Silicon
Snapdragon

TL;DR

For decades the chip in almost every PC was x86, made by Intel or AMD. That is changing fast. ARM, the architecture that already runs every phone, is now in laptops via Apple’s M-series and Qualcomm’s Snapdragon, and it is winning on the thing that matters most in a portable device: how much computing you get per watt of power. More work per watt means more speed, less heat, and dramatically longer battery life. There is also a fascinating twist in who owns what: ARM does not make a single chip, it sells the blueprint, while x86 is a closed club of two.

x86 = Intel and AMD, the old guard, powerful but power-hungry, and a closed duopoly nobody else can join.
ARM = the mobile-born challenger now in real laptops (Apple M-series, Snapdragon X), built for efficiency from day one.
The ownership quirk: ARM designs nothing you can buy directly. Companies licence its blueprint and build their own chips on top. x86 you cannot licence at all.
Why ARM is the future: performance-per-watt. It does more compute for less power, which is exactly what laptops, phones, and even data centres are desperate for.

Now for the more technical explanation

Two philosophies: CISC vs RISC

At the bottom, x86 and ARM are two different answers to “how should a processor understand instructions.”

x86 is CISC (Complex Instruction Set Computing). It grew up in the 1970s and 80s prioritising powerful, feature-rich instructions and, above all, backward compatibility. Code written decades ago still runs. That is a genuine strength, but it means carrying a mountain of legacy, and instructions that vary wildly in length (from one to fifteen bytes).
ARM is RISC (Reduced Instruction Set Computing). Simpler, more uniform instructions of a fixed, predictable length. Less clever per instruction, but far easier for the chip to decode quickly and in parallel.

A fair caveat: the CISC-versus-RISC line is blurrier than it used to be. Modern x86 chips internally chop their complex instructions into simple RISC-like “micro-ops” and execute those. So it is not that x86 is crude; it is that x86 pays an ongoing tax for its legacy and its variable-length instructions, and that tax shows up as power and heat. ARM’s clean, fixed-length design lets it build very wide decoders (looking at many instructions at once) cheaply, in terms of watts, which is a big part of its efficiency advantage.

The strangest part: who owns ARM, and how you “buy” it

This is where it gets genuinely interesting, and it is the heart of why ARM is everywhere.

Intel and AMD’s x86 is a closed shop. Intel created x86; AMD makes x86 chips through a decades-old cross-licensing arrangement (AMD in fact created the 64-bit version, x86-64, that everyone now uses). Between them they hold the rights, and that is essentially the whole guest list. You cannot ring up Intel and licence x86 to design your own processor. New entrants are locked out by design.

ARM does the opposite. It does not manufacture a single chip. ARM Holdings is an intellectual-property company: it designs the architecture and sells the blueprint, then collects a licence fee up front and a small royalty on every chip anyone ships using it. That model is why ARM ended up in billions of devices. There are two main ways to buy in:

A core licence (the ready-made design): you licence one of ARM’s own finished core designs (the Cortex family) and drop it into your chip. This is the quick path, and it is how most Android phone chips are built.
An architecture licence (the blueprint only): you licence the instruction set itself and design your own custom core from scratch that speaks ARM. This is the expensive, powerful path, and it is what the heavyweights do. Apple and Qualcomm both hold architecture licences, which is how they build cores nobody else has.

So the short version is exactly that: to make your own ARM hardware you buy the blueprint from ARM, either as a finished core or as the raw instruction set you build your own core around. And ARM’s own ownership is a saga: it was founded in 1990 (Acorn, Apple, and VLSI), NVIDIA tried and failed to buy it (the deal collapsed in 2022 under regulatory pressure), and it is now majority-owned by SoftBank after returning to the stock market in 2023.

The players putting ARM in laptops

Apple Silicon (the M-series). Apple used its architecture licence to design custom cores and, from the M1 in 2020, moved the entire Mac line off Intel x86 to its own ARM chips. The results reset expectations: fanless laptops that stayed cool, and battery life measured in a full working day rather than a few hours. Apple keeps iterating: the M5 arrived in late 2025 drawing only around 26 watts under load, with the newest MacBook Pros delivering fourteen to sixteen hours of real productivity work. Apple’s advantages stack up: custom cores, a unified memory design that puts CPU, GPU, and memory extremely close together, and first access to the most advanced manufacturing.

Qualcomm Snapdragon (Windows on ARM). The x86 monopoly on Windows laptops is now under direct attack. Qualcomm’s Snapdragon X chips (built on custom “Oryon” cores it gained by buying a startup, Nuvia) power the “Copilot+ PC” class of Windows-on-ARM laptops, and the next generation, Snapdragon X2 Elite, which reached shop shelves in the first half of 2026 in machines from Asus, HP, and Lenovo, pushes to as many as eighteen cores and up to 128GB of on-package memory. Qualcomm also won its licensing fight with ARM (a December 2024 jury verdict, confirmed by a September 2025 judgment), though ARM has appealed, so the legal cloud over those chips is thinner rather than gone. This matters because it means ARM now has a serious, well-funded champion on Windows, not just on the Mac.

The compatibility bridge: Rosetta 2 and Prism

Switching a laptop from x86 to ARM raises an obvious problem: the mountain of existing software was built for x86. If none of it ran, nobody would move. Both camps solve this with a translation layer that lets old x86 apps run on the new ARM chips, and it is worth understanding because it is often the deciding factor in whether an ARM laptop feels great or frustrating.

Apple: Rosetta 2. When Apple moved the Mac to its own chips in 2020, Rosetta 2 was the bridge. Rather than emulating x86 live, it mostly translates an app ahead of time (when you install it) into native ARM code, so translated apps run fast, often close to native speed, and the whole thing is essentially invisible to the user: you double-click an old app and it just works. That smoothness is a big reason Apple’s transition went so well. It was always meant as a temporary bridge, though: as developers shipped native (Universal) versions, reliance on it faded, and Apple has set an end date: Rosetta 2 stays as a general-purpose tool through macOS 27 (autumn 2026), then largely stops working in macOS 28 (autumn 2027), where only a narrow carve-out remains for older, unmaintained games built on Intel frameworks. The point of a good bridge is that you eventually do not need it.

Qualcomm and Windows: Prism. Windows on ARM has the same job to do, and its modern answer is Prism, Microsoft’s x86 and x64 emulator that shipped with the Copilot+ PC push. Prism is a large step up from the older, clunkier Windows-on-ARM emulation, translating x86 apps on the fly with much better performance and compatibility. The honest difference is that Windows’ transition is bumpier than Apple’s, for a structural reason: Apple controls its entire hardware-and-software ecosystem and could force a clean cutover, whereas Microsoft has to coax a huge, open landscape of third-party developers to ship native ARM builds. So Prism carries more of the load for longer, and the rough edges are more visible: some drivers, anti-cheat games, and niche legacy software still stumble. It is improving quickly as native ARM versions of the big applications arrive, but “will my specific software run well” remains a fair question to ask before buying a Snapdragon laptop, in a way it largely is not for a modern Mac.

The takeaway: both Rosetta 2 and Prism exist to make the old world run on the new chips while the software catches up. Apple’s is smoother and being retired on purpose; Microsoft’s is doing heavier lifting on a harder, more open playing field.

Why ARM wins on watts: performance-per-watt

Here is the crux, the metric that explains the whole shift: performance-per-watt, or how much computing you get for each watt of power you burn.

Raw peak performance is not the whole story. A chip that is slightly faster but drinks twice the power is a bad deal in anything that runs on a battery or pays an electricity bill. ARM’s whole heritage is mobile, where every milliwatt counts, so efficiency was the design goal from the start rather than an afterthought. Several things compound into its lead:

Simpler, fixed-length instructions make it cheap (in power) to decode many instructions at once, so ARM designs go very “wide” without the energy blow-up x86 suffers.
Less legacy baggage: no decades of old operating modes and compatibility quirks to keep powered and validated.
Heterogeneous cores: a mix of big performance cores and small efficiency cores, so light work sips power and heavy work gets the muscle only when needed. (x86 has since copied this idea, which tells you it was a good one.)
Leading manufacturing: the biggest ARM designers get first access to the newest, most efficient production processes.

The payoff is exactly what you feel in a laptop: all-day battery, a machine that stays cool and quiet or has no fan at all, and no performance cliff the moment you unplug. And it scales up as well as down. In the data centre, where power and cooling are among the largest costs, the same efficiency is driving a wave of ARM server chips (Amazon’s Graviton, Ampere, and others), because performance-per-watt there translates straight into money. Efficiency is the whole game, top to bottom, and it is ARM’s home turf.

The honest counterpoint: x86 is not dead

Passion should not tip into overclaiming, so the fair view:

Compatibility is x86’s moat. Decades of Windows software was built for x86, and although Rosetta 2 and Prism (above) bridge the gap, the reliance on translation, especially on Windows, is exactly the friction that keeps some people on x86.
x86 is fighting back on efficiency. Intel and AMD have poured effort into their own efficient designs and heterogeneous cores, and the gap on laptops is narrower than the headlines suggest.
Peak performance is competitive. At the very top end, high-power x86 chips still trade blows with anything, and the huge installed base is not going anywhere soon.

So the accurate framing is not “x86 is finished.” It is that the default is shifting. ARM has gone from “phones only” to a credible, often superior choice for laptops and servers, and the momentum is clearly in its direction.

The bonus twist: RISC-V, the truly open blueprint

If ARM’s “buy the blueprint” model sounds clever, there is an even more radical idea gaining ground: RISC-V. It is an open, royalty-free instruction set that anyone can use to build a chip without paying anyone a licence or a royalty. Where x86 is a closed duopoly and ARM is a paid blueprint, RISC-V is the open-source option. It is still early for high-performance laptop-class RISC-V, but it is spreading fast in embedded and specialised chips, and it is the reason some argue the next fight is not x86 versus ARM at all, but paid architectures versus a free one.

The short version

x86 (Intel and AMD) built modern computing and is not going away, but it is a closed club of two carrying decades of legacy, and legacy costs power. ARM took the opposite path: it makes no chips, it licenses a blueprint that anyone can build on, and it was engineered for efficiency from its mobile roots. That efficiency, measured as performance-per-watt, is exactly what laptops, phones, and data centres want, which is why Apple Silicon and Snapdragon are eating into a market x86 owned outright. Compatibility keeps x86 relevant for now, and RISC-V waits in the wings as the fully open alternative, but the direction of travel is hard to miss: more compute, fewer watts, and a blueprint anyone can license.

Written by Tom Langston, IT Infrastructure and Cybersecurity.