Back to the blog
LinuxARMLocal AI

Linux on Snapdragon X2: what changes for developers

October 03, 2026·7 min read·Diego Horvatti

Qualcomm used Snapdragon Summit 2026 to announce that Linux is coming to the Snapdragon X2 lineup. If you ever tried installing a distro on a first-gen X Elite laptop, you know why this made the news. Linux support on Snapdragon X2 answers an old complaint from the community. The promise is to treat Linux as a first-class citizen. Not as a side project the company leaves to volunteers.

The original announcement is on Qualcomm's OnQ blog. It comes wrapped in a lot of talk about "agentic AI PCs". I'll split the two, because for people who write code only one of them matters right now.

What happened with Linux on Snapdragon X2

The X2 line is Qualcomm's second generation of ARM chips for laptops. It brings a new Oryon CPU, an Adreno GPU and a Hexagon NPU rated at around 80 TOPS. That's the number Qualcomm has been repeating since launch. Until now the focus was 100% Windows on ARM.

What changes now is the public commitment to Linux. The company says it will bring support to the X2 platform. That includes the kernel and driver work that was missing in the first generation.

It's worth remembering how it went last time. On the X Elite, support arrived in pieces:

  • The mainline kernel got basic SoC support fairly quickly.
  • Each laptop needed its own device tree, and many models went months without one.
  • Things like suspend, webcam, audio and GPU acceleration worked on one model and broke on another.
  • The NPU, the big selling point, was basically out of reach if you didn't use Windows.

In other words, it ran. But only if you were willing to play distro maintainer on weekends.

Why this matters for developers

Most of the code we write runs on Linux. Your Node or Bun backend, your Postgres, your CI container, your serverless function. All of it is Linux, and more and more it's Linux on ARM. Graviton on AWS, Ampere on Oracle Cloud, Axion on Google Cloud.

Developing on x86 and deploying to ARM works, but there's friction. A Docker image with no arm64 build. A native dependency that compiles differently. A local benchmark that tells you nothing about production.

An ARM laptop running real Linux closes that loop. You develop on the same architecture and the same OS where the code will run. A Mac with Apple Silicon already gives you half of that: the architecture. The other half, the operating system, still needs a VM.

Developing on the same architecture that runs in production removes a whole category of bugs.

Then there's battery life. Qualcomm's ARM chips deliver battery life that x86 laptops on Linux rarely reach. If power management works on Linux the way it does on Windows, that alone is worth a serious look.

What about AI in your code?

This is where it gets interesting. And where I ask for some calm.

Qualcomm sells the X2 as a platform for agentic AI: agents running locally, calling tools, no cloud required. For developers, the practical translation is running code models on your own laptop. Local autocomplete. An agent that reads your repo without sending anything out. Embeddings for semantic code search.

Today, on Linux on ARM, almost all of that work lands on the CPU. And the X2 CPU can handle a lot. A small quantized model, 3B to 8B parameters, runs at a usable speed with llama.cpp or Ollama. You don't even need the NPU to get started:

# confirm you're really on ARM
uname -m
# aarch64

# Ollama already ships an arm64 build
ollama run qwen2.5-coder:7b

The NPU is a different story. To use those 80 TOPS, you need a kernel driver and a runtime that knows how to talk to the Hexagon. In Qualcomm's ecosystem that goes through its own AI SDK. And the question nobody has properly answered yet is: how much of that will be available, open and integrated into the runtimes we actually use, like ONNX Runtime and llama.cpp?

If the answer is "a proprietary SDK that only runs on one specific distro", the NPU stays a sticker on the box. If it's "upstream driver plus an ONNX Runtime backend", that's a game changer for local AI on Linux.

My strong opinion: an NPU without support in popular runtimes is worthless to developers. Nobody is going to rewrite their inference pipeline for one vendor's SDK. The real test is whether a pip install or bun add of a common library can use the NPU without ceremony.

What changes in your workflow

Assuming support lands well, a few things get simpler day to day.

Docker without emulation. You build and run arm64 images natively. To publish for both architectures, the flow stays the same. Only now the emulated one is x86:

docker buildx build \
  --platform linux/arm64,linux/amd64 \
  -t my-api:latest --push .

Native dependencies exposed early. If a library in your package.json has no linux-arm64 binary, you find out on your machine, not in the deploy pipeline. Things like sharp, bcrypt or database drivers with native bindings have had ARM builds for a while. But there's always a forgotten dependency deep in node_modules.

JavaScript runtimes without drama. Node and Bun have official linux-arm64 builds. React Native is a separate case. The Android emulator on ARM actually gets lighter, because the system image is ARM too. iOS builds still require a Mac, and no Qualcomm chip is going to fix that.

Local AI in your editor. With a model running locally, you can point your editor at an endpoint on your own machine:

const res = await fetch('http://localhost:11434/api/generate', {
  method: 'POST',
  body: JSON.stringify({
    model: 'qwen2.5-coder:7b',
    prompt: 'Explain this SQL query: SELECT ...',
    stream: false,
  }),
})
const { response } = await res.json()

Your company's private code never leaves the laptop. For a lot of people, that's the difference between being allowed to use AI at work or not.

Is it worth buying an X2 laptop to run Linux?

Not yet. At least not on launch day.

A support announcement is an intention. What matters is the state of the kernel on the specific laptop you want to buy. The first generation taught us that "the SoC is supported" and "your model works" are very different sentences.

Before spending money, I'd check:

  • Whether the model has a device tree in the mainline kernel, not just in a vendor fork.
  • Whether suspend and resume work, and how much battery it loses while asleep.
  • Whether the GPU has acceleration with an open driver (Freedreno, in Mesa, covers Adreno).
  • Whether the NPU is reachable through a common runtime or only through a proprietary SDK.
  • Whether there are reports from real users running it daily, not just a boot video.

If three of those five are green, it's worth considering. If only boot works, it's an expensive toy.

And the inevitable joke: the "year of the Linux desktop" now comes with an NPU. At least this time a chipmaker is signing off on it.

My take

I like the announcement. Qualcomm finally understood that developers are exactly the people who buy powerful laptops, want good battery life and run Linux. Ignoring that group in the first generation was a mistake. Fixing it is good news for the whole ARM ecosystem.

But I judge by the kernel, not by the stage. If in six months the main X2 laptops are in mainline and the NPU works with ONNX Runtime or llama.cpp, ARM with Linux becomes a serious option for a dev machine. Until then, it's an interesting promise worth keeping an eye on.

I keep testing local AI in my own projects, and some of them are here in my portfolio.

LinkedIn summary

An ARM laptop running real Linux: Qualcomm promised first-class support for Snapdragon X2.

Anyone who tried installing a distro on the X Elite remembers it well: broken suspend, a silent webcam and an NPU you couldn't reach outside Windows.

Almost everything we write runs on Linux, and more and more of it on ARM. Developing on the same architecture as production removes a whole category of bugs.

But an NPU that doesn't work with ONNX Runtime or llama.cpp is worthless to developers. Nobody is going to rewrite their pipeline for one vendor's SDK.

I judge by the kernel, not by the stage. Before you buy, check if your model is in mainline.

I wrote about what changes in the workflow, plus the full checklist, on the blog. Would you swap your laptop for an X2 running Linux?

#Linux #ARM #Snapdragon #DevLife #LocalAI