SSD Nodes Learn Hosting plans →
Guides Matt ConnorBy Matt Connor

ARM VPS vs x86 VPS: what actually changes

ARM VPS prices vary by provider and plan. The compatibility checks that decide whether your stack runs on arm64, and the commands that prove it.

What changes when you move to an ARM VPS

An ARM VPS runs the same Linux and the same Nginx as an x86 VPS. The risk in switching is compatibility. A program compiled for x86-64 cannot run natively on arm64. QEMU user mode emulation can run it on an ARM CPU, but performance depends on the workload, so native execution requires every piece of software in your stack to ship an arm64 build or be something you can rebuild.

Most modern stacks pass that test with no work. The failures cluster in two places: container images that were only ever built for one architecture, and closed source software with no arm64 download. The commands below answer both questions for your own stack before you pay for an instance. If you are still working out what kind of server you need, start with what a VPS is and how it differs from shared hosting.

arm64, aarch64, amd64: which name means what

Run these on any instance before anything else.

uname -m
dpkg --print-architecture
lscpu | head -n 12
getconf PAGESIZE

uname -m prints aarch64 on an ARM machine and x86_64 on an Intel or AMD one. dpkg --print-architecture prints arm64 and amd64 for those same two machines. Both answers are correct. The Linux kernel and the Debian packaging system picked different names for the same instruction set, so aarch64 and arm64 mean one thing, and x86_64 and amd64 mean the other. Docker uses the Debian style names, which is why an image platform reads linux/arm64.

On arm64, a normal 64-bit program reading /proc/cpuinfo gets no model name line. The kernel prints one only when the reading process runs under the 32-bit compatibility personality (PER_LINUX32), and even then it is a generic ARMv8 Processor rev N string rather than a product name. A native read gives you a Features field instead, and hardware crypto appears there as flags like aes pmull sha1 sha2. Those are the ARMv8 Cryptographic Extensions, and they do the job AES-NI does on Intel and AMD parts: they make TLS (transport layer security) and disk encryption fast in hardware. Checking for AES hardware acceleration on a VPS covers the test on both architectures.

Why containers break first, and what the error looks like

Every Docker image configuration records the architecture it was built for. Pull a tag whose image index contains only amd64 manifests onto an arm64 host and platform selection fails with no matching manifest unless you override the requested platform. If an amd64 image reaches process start without emulation, the failure looks like this:

WARNING: The requested image's platform (linux/amd64) does not match the detected host platform (linux/arm64/v8) and no specific platform was requested
exec /usr/local/bin/docker-entrypoint.sh: exec format error

exec format error is the kernel refusing to run the file, because its ELF (executable and linkable format) header names a machine type this CPU does not implement. No setting makes the CPU run it natively. The instructions are not in the silicon. The only workaround is emulation, which the next paragraphs cover.

Check the manifest before you deploy:

docker buildx imagetools inspect nginx:1.27

For an image index or manifest list, the output lists Platform: lines such as linux/amd64 and linux/arm64. A single-platform image has no Platform: line in the default output; inspect its configuration with docker buildx imagetools inspect <image> --format '{{json .Image}}' and check for "os": "linux" and "architecture": "arm64". If the tag has no arm64 image, it will not start natively on an ARM VPS. Docker either rejects the pull during platform selection or, if an amd64 image reaches startup without emulation, execution fails with exec format error. docker manifest inspect --verbose nginx:1.27 shows the same information, but Docker documents docker manifest as an experimental command whose behaviour can change between releases, so prefer imagetools.

For images you build yourself, build both architectures in one command and push a manifest list:

docker buildx build --platform linux/amd64,linux/arm64 -t registry.example.com/app:1.4 --push .

Official BuildKit releases bundle QEMU user mode emulators, so foreign architecture builds usually need no manual installation. If your builder lacks working bundled emulators, install QEMU and register it with the kernel's binfmt_misc handler:

docker run --privileged --rm tonistiigi/binfmt --install all

Use emulation to build and to test. Do not use it to serve traffic. Docker's own documentation states that emulation with QEMU "can be much slower than native builds, especially for compute-heavy tasks like compilation and compression or decompression". That build performance warning does not establish whether an emulated service preserves an instance's cost saving; measure your workload. Host setup for the native case is identical on both architectures: running Docker on a VPS covers it, and an existing Compose file also needs checking for architecture settings such as platform: linux/amd64, which still requests amd64 even when an arm64 image is available. Remove that override or change it to platform: linux/arm64 for native arm64 execution.

Will the packages I need exist on arm64?

Ubuntu and Debian build nearly the whole archive for arm64, so apt install nginx postgresql redis-server behaves the same on both architectures. Third party repositories are where the gaps are.

Ask apt directly, on the ARM instance:

apt-cache policy some-vendor-agent
apt-get install -s some-vendor-agent

apt-cache policy reporting Candidate: (none) means APT has no installation candidate under the current repository configuration and package priorities. apt-get install -s simulates the install and writes nothing; a missing package and a known package with no installation candidate produce different errors.

Then read the output of apt update instead of scrolling past it. A vendor repository that is amd64 only says so:

N: Skipping acquire of configured file 'main/binary-arm64/Packages' as repository 'https://repo.example.com/apt stable InRelease' doesn't support architecture 'arm64'

The repository is configured and reachable, but it does not provide the requested arm64 package index. Check the source entry itself too. A line pinned with [arch=amd64] requests amd64 repository indexes even on an arm64 host; it does not skip the source entry or request arm64 indexes.

Which workloads are safe, and which need a check first

Interpreted and bytecode runtimes are portable by design. PHP, Python, Ruby and Node.js all have arm64 packages in the main distributions. Go and Rust both cross-compile to arm64. For Rust, rustup target add installs only the standard library for the target, so you usually need a linker for that target as well. A LEMP stack, a Node API, a Go binary behind Nginx or a Postgres database is ordinary work on arm64.

A just in time (JIT) compiler produces machine code while the program runs, so it needs a code generator for the target architecture. Current versions have one: OpenJDK, .NET, the V8 engine inside Node.js and PyPy all support arm64 on Linux. Pinned old versions are the real hazard. A deploy script that installs a runtime release from several years ago should be checked against that release's notes for aarch64 support rather than assumed to work.

Libraries carrying hand written x86 assembly, or SSE and AVX intrinsics, are the quieter case. Most also have a NEON path (NEON is the ARM vector instruction set) or a plain C fallback, so they compile and run. Performance can differ from the x86 build in either direction. Measure that on your instance rather than predicting it from an article.

Closed source software is the genuine blocker. A vendor monitoring agent, a licensed database driver, a commercial control panel or an anti-virus daemon arrives as a compiled binary, and when the vendor publishes no arm64 build you cannot rebuild it. QEMU user mode emulation can still run a userspace x86-64 binary on ARM, but performance depends on the workload, and whether the vendor supports it that way is a separate question. cPanel and WHM is the clearest case in hosting: its system requirements state that cPanel does not support ARM architecture systems, so a control panel server stays on x86 (checked November 2026, and worth re-reading on the vendor's own requirements page). If that is the only thing holding you back, the cPanel alternatives worth running on a VPS is where to start, and check each one's architecture support the same way.

Kernels and page size: where ARM instances still differ

x86-64 servers are almost interchangeable. ARM servers are less uniform, and the differences sit below your application.

Page size is the one that reaches production. Most arm64 kernels use 4 KiB pages, the same as x86-64. Some use 64 KiB. Red Hat Enterprise Linux 8 for aarch64 shipped a 64 KiB page kernel by default, and RHEL 9 moved the default back to 4 KiB while keeping a separate kernel-64k package for workloads that want the larger size. A 64 KiB page size raises the memory floor for a process with many small mappings, because the smallest chunk the kernel can hand out is sixteen times bigger. Run getconf PAGESIZE on the instance and read the number rather than assuming it. Page size is not the only kernel decision that reaches you, because the version your provider ships also governs how work is scheduled onto cores, and the cache aware scheduling added in Linux 7.2 lands on arm64 and x86-64 alike.

A few smaller differences are worth knowing. There is no operating system CPU microcode package on arm64, so firmware updates come from your provider and not from apt. ARM servers boot through UEFI (unified extensible firmware interface) and describe their hardware through ACPI (advanced configuration and power interface). Some x86 features are not available on ARM, including AMD SEV memory encryption and Intel GVT-g mediated GPUs. ARM has its own approach to confidential computing instead of SEV: Arm CCA, where the Memory Encryption Contexts extension lets each Realm use a distinct memory encryption context.

Has the ARM server platform matured?

On the software side, yes. Debian, Ubuntu, Fedora and RHEL all ship first class arm64 builds, and official images on Docker Hub are commonly multi-arch. Official status does not guarantee it, though: the current tags of the Percona Docker Official Image list only linux/amd64 (checked November 2026), so inspect each image anyway.

The clearest recent evidence is Proxmox. On 5 August 2026 Proxmox announced the first officially supported arm64 edition of Proxmox Virtual Environment, version 9.2, sharing package repositories and the release lifecycle with the x86-64 edition. The release announcement said it was built on Debian 13.5 with Linux 7.0, QEMU 11.0, LXC 7.0 and ZFS 2.4, and the configuration and tooling match x86-64 apart from a small set of architecture specific items.

Read the caveats in that same announcement, because they show how narrow officially supported ARM server hardware still is. Proxmox validated NVIDIA Grace and NVIDIA Vera systems on day one, after joint testing with NVIDIA and Supermicro on Grace Hopper hardware, and those two are the only fully supported platforms. Proxmox's forum announcement says other UEFI based ARMv9-A or newer hardware is supported on a best effort basis, and the host must boot through UEFI and describe its hardware through ACPI. The forum announcement says that ARMv8-A hardware generally works, also on a best effort basis (checked November 2026). Device tree only single board computers such as the Raspberry Pi are not supported. A guest only runs on a node of its own architecture, live migration works only between nodes of the same architecture, and mixed architecture clusters are not officially supported.

That is the honest position as of August 2026. A hypervisor vendor shipping arm64 on the same lifecycle as x86-64 is real progress for the platform. The day one supported hardware list is two CPU families.

A checklist to run before you commit

  1. Run uname -m on a trial instance and confirm it prints aarch64.
  2. Run docker buildx imagetools inspect on every image in your Compose file and confirm a linux/arm64 platform entry in its image index, or inspect a single-platform image's configuration for Linux and arm64. Check the Compose file for platform: linux/amd64 overrides too.
  3. Run apt update on the ARM instance and read every Skipping acquire warning it prints.
  4. Open the download page for each closed source agent you depend on and look for an arm64 or aarch64 build by name.
  5. Run getconf PAGESIZE and note the answer before you size memory.
  6. Run your own benchmark on both the ARM plan and the x86 plan you are choosing between.

What this post does not claim

We are not going to hand you a price to performance ratio for ARM against x86. Per core prices vary by provider and by plan, and a number measured on somebody else's hardware does not predict yours. Measure it instead. Our guide to benchmarking a VPS covers sysbench and fio with a method you can repeat, and what a VPS actually costs covers the pricing side of the comparison. Storage is a separate decision from CPU architecture, and how NVMe compares with SATA SSD on a VPS deals with that half. Run the same test on both plans, with your own workload where you can, and let your numbers decide.

FAQ

Will my Docker containers run on an ARM VPS?

Native execution requires a Linux arm64 image for every service and Compose settings that select arm64. Check each one with docker buildx imagetools inspect <image> and look for a Platform: linux/arm64 line in an image index; for a single-platform image, use --format '{{json .Image}}' and check its OS and architecture instead. Many official images on Docker Hub are multi-arch, but not all of them: Percona's official image tags list only linux/amd64. Images from smaller vendors, and images you built yourself on an x86 machine, often are not multi-arch either. For your own images, rebuild with docker buildx build --platform linux/amd64,linux/arm64 ... --push so one tag serves both architectures.

What does exec format error mean on an ARM server?

The kernel tried to execute a binary whose ELF header names a different machine type, and refused. On an arm64 host this almost always means an x86-64 binary or container image. Docker can reject an incompatible image during the pull; if it reaches startup, Docker can also print a warning saying the requested image platform linux/amd64 does not match the detected host platform linux/arm64/v8. The fix is a build for the right architecture. No configuration change makes an x86-64 binary run natively on ARM.

Is arm64 the same thing as aarch64?

Yes. They are two names for the 64-bit ARM instruction set. The kernel reports aarch64 through uname -m, while Debian and Ubuntu packaging, and Docker platform strings, use arm64. The same split exists on the other side, where uname -m says x86_64 and packaging says amd64. If a download page offers only aarch64 files, those are the right files for a machine that dpkg --print-architecture calls arm64.

Is an ARM VPS faster than an x86 VPS?

That question has no general answer, and any single ratio you read was measured on hardware that is not yours. Speed depends on the specific CPU model, the number of cores you are given, how the provider handles contention between tenants, and how well your workload uses vector instructions. Benchmark the two plans you are actually choosing between, with your own workload if you can, and compare those numbers.

What should I check before moving a production server to arm64?

Four checks, in this order. Confirm every container image supports Linux arm64, including single-platform images, and that Compose selects that architecture. Confirm every third party apt repository provides the packages you need for arm64 or as architecture-independent packages. Confirm every closed source agent has an aarch64 download. Then run getconf PAGESIZE on the target instance, because a 64 KiB page kernel changes the memory footprint of processes with many small mappings. Anything that fails one of those four checks is a reason to keep that particular server on x86.

Was this article useful?

#arm64#cpu-architecture#vps#docker#performance