TrueNAS on ARM Processors: The Future of Energy-Efficient Storage

The ARM architecture has evolved from a smartphone chip to a serious server processor over the past few years. AWS Graviton, Ampere Altra, and Apple’s M-series demonstrate that ARM-based CPUs can match or even surpass x86 processors in many workloads — at significantly lower power consumption. For storage systems that run around the clock, energy efficiency is a critical factor.

Important: TrueNAS SCALE currently runs on ARM platforms only through an unofficial community fork; iXsystems has announced official ARM support for version 26.04. Production deployments are therefore an early-adopter topic today, not an enterprise default.

Why ARM for Storage?

Storage servers have a unique workload profile. They spend most of their time on I/O operations, not compute-intensive tasks. The CPU waits for hard drives, SSDs, or the network. For this profile, ARM processors offer decisive advantages:

• Low TDP: An Ampere Altra Q80-33 is rated at 250W TDP and averages 180-220W in Phoronix measurements — well below the rated peak. Dual Xeon Silver setups under load typically sit in the 300-400W range.
• Many cores: More parallel threads for simultaneous SMB/NFS connections
• Lower heat output: Less cooling required, quieter operation
• PCIe lanes: Ampere Altra offers 128 PCIe Gen4 lanes — ideal for many NVMe SSDs

For a NAS running 24/7, the power difference adds up noticeably over the year. The actual savings depend heavily on load profile, drive count, and local electricity price — blanket “annual savings” numbers are misleading.

Supported ARM Hardware

Ampere Altra / Altra Max

The Ampere Altra platform is currently the most promising ARM foundation for TrueNAS:

Specification	Ampere Altra Q80-33	Ampere Altra Max M128-30
Cores	80	128
Clock Speed	3.3 GHz	3.0 GHz
TDP	250W	250W
PCIe Lanes	128x Gen4	128x Gen4
RAM	DDR4-3200 ECC, 8 channels	DDR4-3200 ECC, 8 channels
Max RAM	4 TB	4 TB

Available server platforms with Ampere Altra include the GIGABYTE R282-Z96, Supermicro Ampere series, and HPE ProLiant RL300. These systems provide sufficient PCIe slots for HBAs, network cards, and NVMe SSDs.

Raspberry Pi 5 (Experimental)

TrueNAS can run experimentally on the Raspberry Pi 5. This is not suitable for production environments but interesting for testing and learning:

• CPU: Broadcom BCM2712, 4x Cortex-A76 @ 2.4 GHz
• RAM: 8 GB LPDDR4X (no ECC)
• Storage: USB 3.0 or PCIe-to-NVMe adapter (1x PCIe Gen3)
• Network: 1 GbE (no 10G)

The limitations are obvious: No ECC RAM, only USB storage or a single NVMe, limited RAM. For a home NAS with 2-4 drives on a USB 3.0 hub it works — for anything more, it does not.

NVIDIA Jetson Orin (Community Builds)

Community experiments exist with NVIDIA Jetson Orin modules. The advantage here is the integrated GPU, which could be used for transcoding or AI-assisted data classification. However, there is no official support yet.

Performance: What Public Benchmarks Show

Independent TrueNAS benchmarks on identical ARM vs. x86 hardware are still rare — the community fork is young, and iXsystems has not published official comparison numbers yet. What can be inferred from general CPU and workload benchmarks:

• SPECrate 2017 Integer: According to Ampere Computing, the Altra Q80 is up to 2.4x faster than an Intel Xeon 8280 and slightly ahead of an AMD EPYC 7742.
• NGINX (webserver workload): The same source reports around 14% higher throughput than an EPYC 7742.
• Memcached: Up to 29% higher performance at comparable latency compared to an EPYC 7742.
• Homelab report: Jeff Geerling describes a working Altra-based TrueNAS setup with ZFS replication in TrueNAS on Arm is finally a thing — stable long-running workloads, but no published throughput numbers yet.

What this means for storage workloads:

• I/O-dominated profiles (SMB/NFS with many concurrent clients) map well to ARM because bottlenecks sit at the network and disks — not the CPU. Altra’s high core count helps with many parallel sessions.
• Single-thread-heavy tasks (e.g. a single iSCSI session driving a database) still benefit from the higher single-core performance of modern Xeon/EPYC generations.
• Reliable TrueNAS-on-ARM throughput numbers will emerge broadly with the official 26.04 release. Anyone evaluating today should run TN-Bench or fio on their own target hardware.

ZFS on ARM: Key Considerations

ZFS works well on ARM in general, but there are points to consider:

ARC Cache and RAM

ZFS uses the ARC (Adaptive Replacement Cache) aggressively. ARM servers with DDR4/DDR5 offer identical bandwidth to x86 counterparts. The ARC cache benefits from Ampere Altra’s 8 memory channels — more bandwidth means faster cache fills.

RAIDZ Expansion

The RAIDZ expansion feature in TrueNAS works identically on ARM and x86. Parity calculations are not architecture-specific and run through OpenZFS.

Scrubs and Resilver

ZFS scrubs and resilver operations compute checksums across all data blocks and scale well with core count. On an 80-core Altra, this load spreads over many more cores than on a typical Xeon Silver — in practice, however, wall-clock time for a scrub is usually bounded by disk I/O, not CPU. Real comparison numbers depend heavily on pool geometry, fragmentation, and drive type.

Encryption

ZFS native encryption uses AES-256-GCM. Ampere Altra supports AES acceleration (ARMv8 Crypto Extensions), so performance is identical to x86 with AES-NI.

Energy Efficiency in Continuous Operation

A storage server runs 8,760 hours per year — small differences in draw compound noticeably over time. The exact savings can only be quantified cleanly with the target hardware and load profile. Public reference points:

• Altra Q80-33 averages ~180-220W under typical load (Phoronix).
• Comparable dual-socket Xeon Silver setups under load tend to sit in the 300-400W range.
• Total NAS draw is strongly influenced by the number and type of drives, RAM size, and HBA cards.

A conservative midpoint of these ranges suggests savings in the low-hundreds-of-euros per server per year in continuous operation — the exact figure should be validated with measurements against the actual workload before procurement, not taken from a blanket table.

Limitations and Challenges

Software Compatibility

Not every piece of software that runs on TrueNAS is available for ARM:

• TrueNAS SCALE Apps: Docker containers require ARM images — most popular images (Plex, Nextcloud, Grafana) offer multi-arch builds, but some niche tools do not
• Plugins/Jails (CORE): TrueNAS CORE on ARM is not planned, as FreeBSD on ARM is less widespread
• NVIDIA GPU transcoding: Not available, as NVIDIA drivers for ARM servers are limited

ECC RAM Is Essential

ECC RAM is mandatory for ZFS. This rules out consumer ARM boards like the Raspberry Pi for production use. Only server platforms like Ampere Altra provide ECC.

Firmware and BIOS

ARM servers use UEFI, but the firmware landscape is less standardized than x86. Firmware updates and compatibility testing require more effort. ACPI support varies by manufacturer.

iSCSI Target Performance

iSCSI targets on ARM show slightly higher latency at small block sizes (4K, 8K) in our tests. For VMware datastores with many small IOPS, x86 remains the better choice — at least until software optimization for ARM progresses further.

TrueNAS SCALE Apps on ARM

TrueNAS SCALE uses Docker/Kubernetes for apps. The availability of ARM images is critical:

Works Seamlessly on ARM

Most popular self-hosting apps offer multi-arch images:

• Nextcloud: Official ARM64 image, full functionality
• Grafana: Multi-arch since version 8.x
• Prometheus/Node Exporter: Natively compiled on ARM
• Plex Media Server: ARM64 support, but no hardware transcoding
• MinIO: Full ARM64 support, ideal for S3-compatible object storage
• Traefik/Nginx: Multi-arch for years

Limited or Not Available

Some specialized tools do not yet offer ARM builds:

• Veeam Agent: x86 only
• Certain monitoring agents: Vendor-dependent
• Legacy software: Older versions without multi-arch support
• GPU-dependent containers: NVIDIA CUDA limited on ARM

Before migrating to ARM, verify app compatibility for your specific stack. Each Docker Hub image page shows supported architectures under “OS/Arch”.

Migration from x86 to ARM

Migrating existing TrueNAS systems to ARM requires planning:

Migrating ZFS Pools

ZFS pools are architecture-independent. A pool created on x86 can be imported on ARM:

# Export pool (on x86 system)
zpool export tank

# Move drives to ARM system

# Import pool (on ARM system)
zpool import tank

The metadata is endian-neutral, so the import works without issues. Recommendation: Run a scrub before migration to verify data integrity.

Back Up Configuration

TrueNAS configurations can be exported as a file and imported on the new system. Note that network interface names may differ between x86 and ARM (e.g., enp3s0 vs. enP2p1s0).

Recommendation: When Does ARM Make Sense?

ARM-based TrueNAS is particularly suitable for:

• File storage (SMB/NFS): Office environments with many concurrent users
• Backup targets: Proxmox Backup Server, Restic, BorgBackup repositories
• Cold/warm storage: Archive data that is rarely accessed
• Edge locations: Small branch offices that need energy-efficient storage
• New build projects: When new hardware is being procured anyway

For high-performance block storage workloads (iSCSI for databases, VMware vSAN), x86 remains the safe choice. The same applies when there is strong dependency on x86-only software.

Conclusion

TrueNAS on ARM is no longer a future vision — it works today on Ampere Altra platforms in early builds with impressive energy efficiency. Performance for file storage workloads matches x86 levels at significantly lower power consumption. ZFS runs stably, AES encryption is hardware-accelerated, and most Docker containers are available as multi-arch.

The limitations — restricted software compatibility, less standardized firmware, and higher iSCSI latency — will resolve as ARM adoption in the data center grows. Anyone planning a new storage system today who prioritizes energy efficiency should take ARM seriously as an option.