Arm64 VPS: 64-bit Arm servers with full root access
A virtual server with 64-bit Arm (AArch64) processors and full root access. Build and test your software natively for arm64, run CI for multi-architecture container images and serve Arm-native web apps and APIs, on the operating systems listed with each plan.
- 64-bit Arm (AArch64) virtual server
- Full root access over SSH
- Native arm64 builds, no emulation
- Systems and locations listed with each plan
root@arm64:~# uname -m
aarch64
root@arm64:~# docker build -t app .
Successfully tagged app:latest
root@arm64:~# docker run app uname -m
aarch64
root@arm64:~#
Choose a plan that fits
Tell us what you need and our team will help you choose the right plan.
The Linux server you know, on 64-bit Arm
An Arm64 VPS works like our other Linux virtual servers: root access, your own share of processor, memory and storage, and the operating system you pick when you order. The difference is the processor architecture: it runs 64-bit Arm (AArch64) code, so arm64 binaries and container images run natively, without emulation.
Choose it when you build or ship software for Arm, when your stack already publishes arm64 builds, or when you want your services on Arm servers. Keep software that exists only for x86 on a Linux VPS.
- 64-bit Arm (AArch64) virtual processors
- arm64 binaries and container images run natively
- Root access over SSH
- Operating systems listed with each plan
- Locations listed with each plan
A Linux server built on 64-bit Arm
64-bit Arm processors
Your server's virtual processors run 64-bit Arm (AArch64) code, so software built for arm64 runs the way it was built to.
Full root access
Log in as root over SSH, install packages from your system's arm64 repositories and configure every service yourself.
Native builds
Compile and test arm64 binaries on Arm itself instead of cross-compiling or emulating on an x86 machine.
Arm64 CI runners
Register the server as a GitHub Actions, GitLab or Jenkins runner and build arm64 releases in every pipeline.
Containers and Kubernetes
Run arm64 and multi-platform images with Docker or Podman, or a small Kubernetes cluster with k3s.
Systems from the plan
Each plan lists the operating systems it offers, and you pick one in the order form.
Locations from the plan
Each plan lists the data centers it is offered in; pick the one closest to your users when you order.
One client area
Order, renew and manage the server and its invoices from the same client area as your other services.
Help from our team
Open a support ticket if the server or the network needs attention, and follow every reply in one place.
What runs well on an Arm64 VPS
Native arm64 builds and tests
Compile Go, Rust, C and C++ projects, Java and .NET applications and native modules for Node.js or Python on Arm itself, and run your test suite on the architecture your code will run on. There is no cross-compiler toolchain and no emulation layer to maintain.
- Release binaries for linux/arm64
- Native extensions built on Arm
- Test results from the real architecture
Multi-architecture container images
Build the linux/arm64 variant of your images natively with Docker Buildx, push it next to the amd64 variant and publish one multi-platform tag, so every user pulls the right image for their machine.
- Native arm64 layers, no emulation
- One tag for arm64 and amd64
- Your own registry or Docker Hub
root@arm64:~# uname -m
aarch64
root@arm64:~# docker build -t app .
Successfully tagged app:latest
root@arm64:~# docker run app uname -m
aarch64
root@arm64:~#
CI runners for Arm
Register the server as a self-hosted runner for GitHub Actions or GitLab, or as a Jenkins or Buildkite agent, and add arm64 jobs to the pipelines you already have, on a runner that only your projects use.
Arm-native web servers and APIs
Serve websites, APIs and background workers with Nginx, Caddy, Node.js, Python, Go, PHP or Java, all of which run natively on arm64, with PostgreSQL, MySQL or Redis next to them.
Testing software for Arm devices
Gateways, edge boxes and single-board computers often run 64-bit Arm Linux too. Build and test their software on a server that is always online, then ship the same arm64 binaries to your devices.
Cost-efficient scale-out
Spread stateless web services, queue workers and caches over several Arm64 servers behind a load balancer, and add servers as traffic grows instead of moving everything to one bigger machine.
Technical specifications
What every plan on this page shares. vCPU, memory and storage differ by plan and are listed with each plan.
- Architecture
- 64-bit Arm (AArch64)
- uname -m prints aarch64
- Server type
- Virtual private server
- Need VMs inside? Choose an Arm64 VDS
- Access
- Root over SSH
- Sign in with your SSH key
- Containers
- Docker, Podman and k3s on arm64
- Pull the arm64 or multi-platform variant of an image
- x86 software
- Needs an arm64 build or emulation
- Keep x86-only software on a Linux VPS
- Operating systems
- Listed with each plan
- Pick one in the order form
- Locations
- Listed with each plan
- Pick one in the order form
- Management
- The HyperDC client area
- Services, invoices and support tickets in one place
- Support
- Support tickets from the client area
Arm64 VPS, Arm64 VDS or Linux VPS?
All three are virtual servers with full root access. They differ in the processor architecture and in whether you can run your own virtual machines inside.
| Feature |
This page Arm64 VPS
A 64-bit Arm virtual server (Recommended)
|
Arm64 VDS
64-bit Arm with nested virtualization
|
Linux VPS
An x86-64 virtual server
|
|---|---|---|---|
| Processor architecture | 64-bit Arm (AArch64) | 64-bit Arm (AArch64) | x86-64 |
| Native arm64 softwareBinaries and container images built for linux/arm64. | Included | Included | Not included |
| Native x86 softwareBinaries and container images built for linux/amd64. | Not included | Not included | Included |
| Your own VMs insideNested virtualization lets your server start virtual machines of its own; on Arm64 these are 64-bit Arm virtual machines. | Not included | Included | Not included |
| Root access | Included | Included | Included |
| Operating systems | Listed with each plan | Listed with each plan | Linux distributions and BSD |
| Best for | Arm-native apps, arm64 builds and CI, scale-out services | Clean build VMs, image testing and labs on Arm | x86-only software, control panels and classic hosting stacks |
-
This page
Arm64 VPS (Recommended)
A 64-bit Arm virtual server
- Processor architecture
- 64-bit Arm (AArch64)
- Native arm64 softwareBinaries and container images built for linux/arm64.
- Included
- Native x86 softwareBinaries and container images built for linux/amd64.
- Not included
- Your own VMs insideNested virtualization lets your server start virtual machines of its own; on Arm64 these are 64-bit Arm virtual machines.
- Not included
- Root access
- Included
- Operating systems
- Listed with each plan
- Best for
- Arm-native apps, arm64 builds and CI, scale-out services
-
Arm64 VDS
64-bit Arm with nested virtualization
- Processor architecture
- 64-bit Arm (AArch64)
- Native arm64 softwareBinaries and container images built for linux/arm64.
- Included
- Native x86 softwareBinaries and container images built for linux/amd64.
- Not included
- Your own VMs insideNested virtualization lets your server start virtual machines of its own; on Arm64 these are 64-bit Arm virtual machines.
- Included
- Root access
- Included
- Operating systems
- Listed with each plan
- Best for
- Clean build VMs, image testing and labs on Arm
-
Linux VPS
An x86-64 virtual server
- Processor architecture
- x86-64
- Native arm64 softwareBinaries and container images built for linux/arm64.
- Not included
- Native x86 softwareBinaries and container images built for linux/amd64.
- Included
- Your own VMs insideNested virtualization lets your server start virtual machines of its own; on Arm64 these are 64-bit Arm virtual machines.
- Not included
- Root access
- Included
- Operating systems
- Linux distributions and BSD
- Best for
- x86-only software, control panels and classic hosting stacks
A comparison of the server lines, not of single plans: each page lists its plans with their resources and price.
Set up your Arm64 VPS
Step-by-step guides for SSH, security, Docker and Kubernetes that apply to Arm64 servers too.
-
How to install Docker Engine on Ubuntu 24.04 and 26.04
Install Docker Engine, Buildx and Compose from Docker's official apt repository on Ubuntu LTS, run it without sudo, rotate logs and keep published ports private.
15 min Beginner -
Docker Compose basics: run multi-container apps on a Linux server
Write a compose.yaml with services, volumes and networks, keep secrets in .env, start services in the right order with healthchecks, then update, back up and run several stacks side by side.
35 min Beginner -
How to install K3s on Ubuntu: single-node Kubernetes with Traefik and HTTPS
Set up a single-node K3s Kubernetes cluster on Ubuntu LTS, open only the ports it needs, expose a test app through the bundled Traefik ingress with cert-manager TLS, and learn backups and upgrades.
45 min Intermediate -
How to install Forgejo or Gitea with Docker Compose, PostgreSQL and HTTPS
Run your own Git forge with Forgejo or Gitea: official Docker images, PostgreSQL, Caddy for HTTPS, SSH on port 2222 and no open registration, plus dump-based backups and safe major-version updates.
40 min Intermediate -
Connect to your Linux server with SSH
Your first login to a new Linux server: where to find the details, how to connect from any computer and what to do in the first five minutes.
10 min Beginner -
How to secure a new Linux server in the first hour
A new server is reachable from the internet the moment it boots. These steps close the most common gaps before you install anything else.
30 min Beginner
What you get with HyperDC
One account for everything
Hosting, servers, domains and invoices are managed from the same client area.
Invoices in one place
Every invoice is listed in the client area, where you can also pay it online.
Support from the client area
Open a support ticket whenever you need help and follow every reply in one place.
From order to online
-
Choose a service
Pick the product, location and billing cycle that fit your project.
-
Complete your order
Review your cart and pay with one of the available payment methods.
-
Receive your details
We email your login details as soon as the service is ready.
-
Get help when you need it
Open a support ticket from the client area and follow every reply.
One provider for hosting, servers and domains
Hosting and servers since 2013, with 267k+ websites hosted on our services.
One client area for every service
Order, manage and pay for hosting, servers and domains from the same account.
Linux VPSActiveHelp from our team
Open a support ticket from the client area and follow every reply.
Choose your location
Pick the data center when you order. Each service page lists where it runs.
All data centersRoom to grow
Move between hosting, VPS, VDS and dedicated servers as your project grows.
Compare serversMoving from another provider?
Tell us what you run today and where it is hosted. We will reply with the steps to move it to your new HyperDC service.
- Tell us what you run today and where it is hosted
- Get the steps to move it to your new HyperDC service
- Switch over when everything is ready
Services that work well together
Policies that apply
Frequently asked questions
What is an Arm64 VPS?
An Arm64 VPS is a virtual private server whose processor architecture is 64-bit Arm, also called AArch64 or arm64, instead of x86. It has its own share of processor, memory and storage, and you get full root access to install and configure the software yourself, as on any of our virtual servers.
Are Arm64, AArch64 and ARM64 the same?
Yes. AArch64 is Arm's name for its 64-bit execution state, Linux reports it as aarch64 in the output of uname -m, and Debian-based distributions and Docker call the same architecture arm64. Software built for any of these names runs on your server.
Will my software run on Arm64?
Most open-source server software does: web servers, databases, language runtimes such as Node.js, Python, Go, Java, .NET, PHP and Rust, and many Docker images are published for arm64. Software that exists only for x86, such as some closed-source agents or tools, has to be rebuilt for arm64 or replaced. Check the vendor's download page or the image's platform list before you move.
Can I run x86 programs on an Arm64 server?
Not natively. Programs built for x86 need user-mode emulation through binfmt_misc, which is fine for an occasional tool or a cross-build step but much slower than native code. For production, use arm64 builds of your software, or choose a Linux VPS for software that exists only for x86.
How do I build multi-architecture container images?
Build the linux/arm64 image natively on your Arm64 server and the linux/amd64 image on an x86 server, then publish both under one tag with docker buildx imagetools create, or add both servers as nodes of one Docker Buildx builder. Native builds avoid the slowdown of emulation, which matters most for compiled languages and large images.
Can I use it as a CI runner?
Yes. Register it as a self-hosted GitHub Actions runner, a GitLab Runner, or a Jenkins or Buildkite agent: all of them run on Linux arm64. Your arm64 jobs then build and test natively, next to the x86 runners you already have.
Which operating systems can I install?
The systems each plan offers are listed on this page and in the order form; pick one when you order. They are 64-bit Arm builds, so the packages you install from the system's repositories are arm64 packages as well.
How do I connect to my Arm64 VPS?
We email the IP address and root login details as soon as the server is ready. Connect with any SSH client, such as Terminal on macOS and Linux or Windows Terminal and PuTTY on Windows, then add your SSH key and turn off password logins.
Arm64 VPS or Arm64 VDS: which one do I need?
Both are 64-bit Arm virtual servers with full root access. An Arm64 VDS adds nested virtualization, so you can run 64-bit Arm virtual machines of your own inside it, for example a clean VM for every build. Choose an Arm64 VPS when your workload runs directly on the server, and an Arm64 VDS when you need virtual machines inside it.
Can I run Docker and Kubernetes on it?
Yes. Docker Engine, Docker Compose, Podman and lightweight Kubernetes distributions such as k3s are available for arm64, and the steps in our Docker and k3s guides apply to Arm64 servers too. Pull the arm64 or multi-platform variant of an image, or build your own on the server.
Which billing cycles can I choose?
Every plan lists the billing cycles it is offered with. Switch the cycle above the plans to compare prices; longer cycles show the saving against monthly billing when there is one.
How do I pay?
Choose one of the payment methods offered at checkout. Every invoice also stays available in the client area, where you can pay it online.
Where do I manage my service after ordering?
Your service appears in the client area as soon as it is set up. From there you can manage it, pay invoices and open support tickets.
Questions before you order?
Send us a message and our team will help you choose the right service.