Difference between revisions of "NixOS on ARM"

From NixOS Wiki
Jump to: navigation, search
(Undo revision 13892 by KaladinB4 (talk))
Tag: Undo
(Undo revision 13891 by KaladinB4 (talk))
Tag: Undo
 
Line 1: Line 1:
## NixOS installation & configuration
+
ARM support for NixOS is a work-in-progress, but is progressing quickly.
  
The installation image contains a MBR partition table with two partitions: a FAT16/32 `/boot` partition and an ext4 root filesystem. This design allows you to directly reuse the SD image's partition layout and "install" NixOS on the same storage device by replacing the default configuration and running `nixos-rebuild`. On first boot, the image automatically resizes the rootfs partition to utilize all available storage space.
+
The support varies depending on the architecture and the specific boards. The way the ARM integration is built into NixOS is by making generic builds the first-class citizens; as soon as there is upstream support for the board in the kernel and the bootloader, NixOS should work once updated to these versions. It is still possible, when needed, to build and use a customised bootloader and kernel for specific boards<sup>[[Talk:NixOS_on_ARM#NixOS_.22support.22_for_board-specific_kernels_or_bootloaders|[reference needed]]]</sup>. At this moment in time (late 2021) only AArch64 has full support upstream.
  
NixOS on ARM supports two approaches to system configuration: traditional configuration.nix files and the now-standard Flakes approach (recommended since NixOS 25.05). Both methods are covered below.
+
Though, neither armv6l or armv7l are being ignored, fixes are worked on and approved as needed; what's missing is support and upstream builds being maintained in binary form. At the time of writing, no publicly available caches for armv6l or armv7l are available.<!-- please get in touch with samueldr on the NixOS on ARM channel if you want to share your own cache, before editing. We need to review the wording to make it crystal clear it's a user-provided cache. -->
  
### Boot Process Overview
+
'''For images links, including UEFI install''', skip to the [[NixOS on ARM#Installation|Installation]] section.
  
All ARM boards in NixOS use U-Boot as the bootloader, alongside U-Boot's Generic Distro Configuration Concept to communicate boot information (kernel zImage path, initrd, DTB, command line arguments). U-Boot scans storage devices for `/extlinux/extlinux.conf` or `/boot/extlinux/extlinux.conf` files (generated by NixOS) and uses the bootable partition flag.
+
== Supported devices ==
  
U-Boot provides both an interactive shell and generation selection menu (similar to GRUB). Board-specific input/display support varies - check your device's wiki page for details.
+
Table legend:
 +
* SoC - https://en.wikipedia.org/wiki/System_on_a_chip
 +
* ISA - https://en.wikipedia.org/wiki/Instruction_set_architecture
  
### Basic Setup with configuration.nix
+
=== Upstream (NixOS) supported devices ===
  
To generate a default `/etc/nixos/configuration.nix` file and detect hardware:
+
NixOS has support for these boards using AArch64 architecture on the nixpkgs-unstable and stable channel.
  
```bash
+
Support for those board assumes as much is supported as Mainline Linux supports.
sudo nixos-generate-config
+
<!--
```
+
Order for the device table is:
 +
* By manufacturer name, alphabetical.
 +
* By release date, chronological (older first).
 +
-->
 +
{|class="table"
 +
!width="2%"| Manufacturer
 +
!width="2%"| Board
 +
!width="2%"| SoC
 +
!width="1%"| ISA
 +
!width="2%"| CPU
 +
!width="1%"| RAM
 +
!width="2%"| Storage
 +
|-
 +
| Raspberry Pi Foundation
 +
| [[NixOS_on_ARM/Raspberry_Pi_3|Raspberry Pi 3]]
 +
| Broadcom BCM2837
 +
| AArch64 / ARMv7
 +
| 4× Cortex-A53 @ 1.2 - 1.4 GHz
 +
| 1 GB
 +
| SD/microSD
 +
|-
 +
| Raspberry Pi Foundation
 +
| [[NixOS_on_ARM/Raspberry_Pi 4|Raspberry Pi 4]]
 +
| Broadcom BCM2711
 +
| AArch64 / ARMv7
 +
| 4× Cortex-A72 @ 1.5 - 1.8 GHz
 +
| 1-8 GB
 +
| microSD, eMMC
 +
|}
 +
=== Community supported devices ===
  
Here's a modern configuration template suitable for most ARM boards:
+
<!--
 +
Order for the device table is:
 +
* By manufacturer name, alphabetical.
 +
* By release date, chronological (older first).
 +
-->
 +
<div class="table">
 +
{|class="table"
 +
!width="2%"| Manufacturer
 +
!width="2%"| Board
 +
!width="2%"| SoC
 +
!width="1%"| ISA
 +
!width="2%"| CPU
 +
!width="2%"| RAM
 +
!width="2%"| Storage
 +
|-
 +
| Apple
 +
| [[NixOS_on_ARM/Apple Silicon Macs|Apple Silicon Macs]]
 +
| M1/M1 Pro/M1 Max
 +
| AArch64
 +
| —
 +
| —
 +
| NVMe
 +
|-
 +
| ASUS
 +
| [[NixOS_on_ARM/Tinker Board|Tinker Board]]
 +
| Rockchip RK3288
 +
| ARMv7
 +
| 4× Cortex-A17
 +
| 2 GB
 +
| microSD
 +
|-
 +
| Banana Pi
 +
| [[NixOS_on_ARM/Banana Pi|Banana Pi]]
 +
| Allwinner A20
 +
| ARMv7
 +
| 2× Cortex-A7
 +
| 1 GB
 +
| SD, SATA
 +
|-
 +
| Banana Pi M64
 +
| [[NixOS_on_ARM/Banana Pi M64|Banana Pi M64]]
 +
| Allwinner A64
 +
| ARMv8
 +
| 4× Cortex-A53
 +
| 2 GB
 +
| microSD, 8GB eMMc
 +
|-
 +
| Banana Pi BPI-M5
 +
| [[NixOS_on_ARM/Banana Pi BPI-M5|Banana Pi BPI-M5]]
 +
| Amlogic S905X3
 +
| ARMv8.2
 +
| 4× Cortex-A55
 +
| 4 GB LPDDR4
 +
| microSD, 16G eMMC
 +
|-
 +
| BeagleBoard.org
 +
| [[NixOS_on_ARM/BeagleBone_Black|BeagleBone Black]]
 +
| TI AM335x [https://git.beagleboard.org/beagleboard/beaglebone-black (src)]
 +
| ARMv7
 +
| 1× Cortex-A8 @ 1 GHz
 +
| 512 MB
 +
| 4 GB eMMC, microSD
 +
|-
 +
| Firefly
 +
| [[NixOS_on_ARM/Firefly_AIO-3399C|AIO-3399C]]
 +
| Rockchip RK3399
 +
| AArch64
 +
| 2× Cortex-A72 @ 2.0 GHz, 4× Cortex-A53 @ 1.5 Ghz
 +
| 2/4 GB
 +
| 8/16 GB eMMC, microSD
 +
|-
 +
| FriendlyElec
 +
| [[NixOS_on_ARM/NanoPC-T4|NanoPC-T4]]
 +
| Rockchip RK3399
 +
| AArch64
 +
| 2× Cortex-A72 @ 2.0 GHz, 4× Cortex-A53 @ 1.5 Ghz
 +
| 4 GB
 +
| 16 GB eMMC, microSD, NVMe
 +
|-
 +
| FriendlyElec
 +
| [[NixOS_on_ARM/NanoPi-M4|NanoPi-M4]]
 +
| Rockchip RK3399
 +
| AArch64
 +
| 2× Cortex-A72 @ 2.0 GHz, 4× Cortex-A53 @ 1.5 Ghz
 +
| 4 GB
 +
| optional eMMC, microSD
 +
|-
 +
| FriendlyElec
 +
| [[NixOS_on_ARM/NanoPi-R6C|NanoPi-R6C]]
 +
| Rockchip RK3588S
 +
| AArch64
 +
| 4× ARM Cortex-A76 @ 2.4 GHz, 4× Cortex-A55 @ 1.8 Ghz
 +
| 4 GB / 8 GB
 +
| optional eMMC, microSD, NVMe
 +
|-
 +
| Hardkernel
 +
| [[NixOS_on_ARM/ODROID-HC1|ODROID-HC1 & ODROID-HC2]]
 +
| Samsung Exynos 5422
 +
| ARMv7
 +
| 4× Cortex-A15 @ 2GHz, 4× Cortex-A7 @ 1.4GHz
 +
| 2 GB
 +
| microSD
 +
|-
 +
| Hardkernel
 +
| [[NixOS_on_ARM/ODROID-C2|ODROID-C2]]
 +
| Amlogic S905
 +
| AArch64
 +
| 4× Cortex-A53 @ 1.5GHz
 +
| 2 GB
 +
| eMMC, microSD
 +
|-
 +
| Hardkernel
 +
| [[NixOS_on_ARM/ODROID-HC4|ODROID-HC4]]
 +
| Amlogic S905X3
 +
| AArch64
 +
| 4× Cortex-A55 @ 1.8GHz
 +
| 4 GB
 +
| microSD, SATA
 +
|-
 +
| Libre Computer
 +
| [[NixOS_on_ARM/Libre_Computer_ROC-RK3399-PC|ROC-RK3399-PC]]
 +
| Rockchip RK3399
 +
| AArch64
 +
| 2× Cortex-A72 @ 2.0 GHz, 4× Cortex-A53 @ 1.5 Ghz
 +
| 4 GB
 +
| eMMC, microSD, NVMe
 +
|-
 +
| Libre Computer
 +
| [[NixOS_on_ARM/Libre_Computer_ROC-RK3328-CC|ROC-RK3328-CC]]
 +
| Rockchip RK3328
 +
| AArch64
 +
| 4× ARM Cortex-A53 @ 1.4GHz
 +
| 4 GB
 +
| eMMC, microSD
 +
|-
 +
| Libre Computer
 +
| [[NixOS_on_ARM/Libre_Computer_AML-S905X-CC-V2|AML-S905X-CC-V2]]
 +
| Amlogic S905X
 +
| AArch64
 +
| 4× Cortex-A53 @ 1.512 GHz
 +
| 1/2GB
 +
| eMMC, microSD
 +
|-
 +
| Linksprite
 +
| [[NixOS_on_ARM/PcDuino3_Nano|pcDuino3 Nano]]
 +
| Allwinner A20
 +
| ARMv7
 +
| 2× Cortex-A7 @ 1 GHz
 +
| 1 GB
 +
| 4 GB NAND, microSD, SATA
 +
|-
 +
| NVIDIA
 +
| [[NixOS_on_ARM/Jetson TK1|Jetson TK1]]
 +
| Tegra K1/T124
 +
| ARMv7
 +
| 4× Cortex-A15 @ 2.3 GHz
 +
| 2 GB
 +
| 16 GB eMMC, SD, SATA
 +
|-
 +
| NXP
 +
| [https://github.com/NiklasGollenstede/nixos-imx/ i.MX 8M Plus EVK]
 +
| i.MX 8M Plus
 +
| AArch64
 +
| 4× Cortex-A53 @ 1.8 Ghz
 +
| 6 GB
 +
| 32 GB eMMC, microSD
 +
|-
 +
| NXP
 +
| [https://github.com/gangaram-tii/nixos-imx8mq/ i.MX 8M Quad EVK]
 +
| i.MX 8M Quad
 +
| AArch64
 +
| 4× Cortex-A53 @ 1.5 Ghz + 1x Cortex-M4
 +
| 3 GB
 +
| 16 GB eMMC, microSD
 +
|-
 +
| OLIMEX
 +
| [[NixOS_on_ARM/OLIMEX_Teres-A64|Teres-A64]]
 +
| AllWinner A64
 +
| AArch64
 +
| 4x Cortex-A53 @ 1152MHz
 +
| 2GB
 +
| 16 GB eMMC, microSD
 +
|-
 +
| Orange Pi
 +
| [[NixOS_on_ARM/Orange_Pi_One|Orange Pi One]]
 +
| Allwinner H3
 +
| ARMv7
 +
| 4× Cortex-A7 @ 1.2 GHz
 +
| 512 MB
 +
| microSD
 +
|-
 +
| Orange Pi
 +
| [[NixOS_on_ARM/Orange_Pi_PC|Orange Pi PC]]
 +
| Allwinner H3
 +
| ARMv7
 +
| 4× Cortex-A7 @ 1.6 GHz
 +
| 1 GB
 +
| SD/microSD
 +
|-
 +
| Orange Pi
 +
| [[NixOS_on_ARM/Orange_Pi_Zero_Plus2_H5|Orange Pi Zero Plus2 (H5)]]
 +
| Allwinner H5
 +
| AArch64
 +
| 4× Cortex-A53 @ 1.2 GHz
 +
| 1 GB
 +
| SD/microSD + 8GB eMMC
 +
|-
 +
| Orange Pi
 +
| [[NixOS_on_ARM/Orange_Pi_Zero2_H626|Orange Pi Zero2 (H616)]]
 +
| Allwinner H616
 +
| AArch64
 +
| 4× Cortex-A53 @ 1.2 GHz
 +
| 1 GB
 +
| SD/microSD + 2MB SPI Flash
 +
|-
 +
| Orange Pi
 +
| [[NixOS_on_ARM/Orange_Pi_R1_Plus_LTS|Orange Pi R1 Plus LTS]]
 +
| Rockchip RK3328
 +
| AArch64
 +
| 4x Cortex-A53 @ -1.5 GHz
 +
| 1 GB
 +
| microSD
 +
|-
 +
| Orange Pi
 +
| [[NixOS_on_ARM/Orange_Pi_5|Orange Pi 5]]
 +
| Rockchip RK3588s
 +
| AArch64
 +
| 4× Cortex-A76 @ 2.4GHz, 4×Cortex-A55 @ 1.8 GHz
 +
| 4/8/16 GB
 +
| microSD, NVMe
 +
|-
 +
| Orange Pi
 +
| [[NixOS_on_ARM/Orange_Pi_5_Plus|Orange Pi 5 Plus]]
 +
| Rockchip RK3588
 +
| AArch64
 +
| 4× Cortex-A76 @ 2.4GHz, 4×Cortex-A55 @ 1.8 GHz
 +
| 4/8/16 GB
 +
| eMMC, microSD, NVMe
 +
|-
 +
| PINE64
 +
| [[NixOS_on_ARM/PINE A64-LTS|PINE A64-LTS]]
 +
| Allwinner R18
 +
| AArch64
 +
| 4× Cortex-A53 @ ? GHz
 +
| 2 GB
 +
| microSD & eMMC
 +
|-
 +
| PINE64
 +
| [[NixOS_on_ARM/PINE64_Pinebook|Pinebook]]
 +
| Allwinner A64
 +
| AArch64
 +
| 4× Cortex-A53 @ ? Ghz
 +
| 2 GB
 +
| microSD & eMMC
 +
|-
 +
| PINE64
 +
| [[NixOS_on_ARM/PINE64_Pinebook_Pro|Pinebook Pro]]
 +
| Rockchip RK3399
 +
| AArch64
 +
| 2× Cortex-A72 @ 2.0 GHz, 4× Cortex-A53 @ 1.5 Ghz
 +
| 4 GB
 +
| microSD & eMMC
 +
|-
 +
| PINE64
 +
| [[NixOS_on_ARM/PINE64_ROCK64|ROCK64]]
 +
| Rockchip RK3328
 +
| AArch64
 +
| 4× Cortex-A53 @ 1.5 GHz
 +
| 1/2/4 GB
 +
| microSD/eMMC
 +
|-
 +
| PINE64
 +
| [[NixOS_on_ARM/PINE64_ROCKPro64|ROCKPro64]]
 +
| Rockchip RK3399
 +
| AArch64
 +
| 2× Cortex-A72 @ 2.0 GHz, 4× Cortex-A53 @ 1.5 Ghz
 +
| 2/4 GB
 +
| microSD/eMMC
 +
|-
 +
| Clockworkpi
 +
| [[NixOS_on_ARM/Clockworkpi_A06_uConsole|uConsole A06]]
 +
| Rockchip RK3399
 +
| AArch64
 +
| 2× Cortex-A72 @ 2.0 GHz, 4× Cortex-A53 @ 1.5 Ghz
 +
| 4 GB
 +
| microSD
 +
|-
 +
| Radxa
 +
| [[NixOS on ARM/Radxa ROCK5 Model B|ROCK5 Model B]]
 +
| Rockchip RK3588
 +
| AArch64
 +
| 4× Cortex-A76 @ 2.4GHz, 4×Cortex-A55 @ 1.8 GHz
 +
| 4/8/16 GB
 +
| eMMC, microSD, NVMe
 +
|-
 +
| Radxa
 +
| [[NixOS on ARM/Radxa ROCK5 Model A|ROCK5 Model A]]
 +
| Rockchip RK3588s
 +
| AArch64
 +
| 4× Cortex-A76 @ 2.4GHz, 4×Cortex-A55 @ 1.8 GHz
 +
| 4/8/16 GB
 +
| eMMC, microSD, NVMe
 +
|-
 +
| Raspberry Pi Foundation
 +
| [[NixOS_on_ARM/Raspberry_Pi|Raspberry Pi]]
 +
| Broadcom BCM2835
 +
| ARMv6
 +
| 1 × ARM1176 @ 700 MHz
 +
| 256 MB / 512 MB
 +
| SD/microSD
 +
|-
 +
| Raspberry Pi Foundation
 +
| [[NixOS_on_ARM/Raspberry_Pi|Raspberry Pi 2]]
 +
| Broadcom BCM2836
 +
| ARMv7
 +
| 4× Cortex-A7 @ 900 MHz
 +
| 1 GB
 +
| SD/microSD
 +
|-
 +
| Raspberry Pi Foundation
 +
| [[NixOS_on_ARM/Raspberry_Pi 3|Raspberry Pi 3]]
 +
| Broadcom BCM2837
 +
| AArch64 / ARMv7
 +
| 4× Cortex-A53 @ 1.2 GHz
 +
| 1 GB
 +
| SD/microSD
 +
|-
 +
| Raspberry Pi Foundation
 +
| [[NixOS_on_ARM/Raspberry_Pi 4|Raspberry Pi 4]]
 +
| Broadcom BCM2711
 +
| AArch64 / ARMv7
 +
| 4× Cortex-A53 @ 1.5 GHz
 +
| 1-8 GB
 +
| microSD
 +
|-
 +
| Raspberry Pi Foundation
 +
| [[NixOS_on_ARM/Raspberry_Pi 5|Raspberry Pi 5]]
 +
| Broadcom BCM2712
 +
| AArch64
 +
| 4× Cortex-A76 @ 2.4 GHz
 +
| 4-16 GB
 +
| microSD
 +
|-
 +
| Toshiba
 +
| [[NixOS_on_ARM/Toshiba AC100|AC100 (mini laptop)]]
 +
| Tegra 2 250 (T20)
 +
| ARMv7
 +
| 2× Cortex-A9 @ 1 GHz
 +
| 512 MB
 +
| 8­­–32 GB eMMC, SD
 +
|-
 +
| Wandboard
 +
| [[NixOS_on_ARM/Wandboard|Wandboard Solo/Dual/Quad]]
 +
| Freescale i.MX6
 +
| ARMv7
 +
| 1×/2×/4× Cortex-A9 @ 1000 MHz
 +
| 512 MB / 1 GB / 2 GB
 +
| microSD, SATA
 +
|}
 +
</div>
  
```nix
+
==== Special Devices ====
{ config, pkgs, lib, ... }:
+
 
 +
It is possible to emulate an ARM platform with QEMU.
 +
 
 +
<div class="table-responsive">
 +
{|class="table"
 +
!width="2%"| Manufacturer
 +
!width="2%"| Board
 +
!width="2%"| SoC
 +
!width="2%"| ISA
 +
!width="2%"| CPU
 +
!width="2%"| RAM
 +
!width="2%"| Storage
 +
|-
 +
| QEMU
 +
| [[NixOS_on_ARM/QEMU|QEMU]]
 +
| —
 +
| ARMv7
 +
| up to 8
 +
| up to 2 GB
 +
| Anything QEMU supports
 +
|}
 +
</div>
 +
 
 +
== Installation ==
 +
 
 +
=== Getting the installer ===
 +
 
 +
==== UEFI iso ====
 +
 
 +
{{note| On Raspberry Pi devices, the NixOS ISO are not compatible due to hardware limitations rather than issues with the NixOS installer itself. As a result, it is recommended to use the SD card images files (.img) instead for a successful installation experience.}}
 +
 
 +
Continue to the [[NixOS on ARM/UEFI|UEFI]] page.
 +
 
 +
==== SD card images (SBCs and similar platforms) ====
 +
 
 +
For <code>AArch64</code> it is possible to download images from Hydra.
 +
 
 +
* [https://hydra.nixos.org/job/nixos/release-24.11/nixos.sd_image.aarch64-linux 24.11]
 +
* [https://hydra.nixos.org/job/nixos/release-24.05/nixos.sd_image.aarch64-linux 24.05]
 +
* [https://hydra.nixos.org/job/nixos/release-23.11/nixos.sd_image.aarch64-linux 23.11]
 +
* [https://hydra.nixos.org/job/nixos/trunk-combined/nixos.sd_image.aarch64-linux unstable (LTS kernel)]
 +
* [https://hydra.nixos.org/job/nixos/trunk-combined/nixos.sd_image_new_kernel_no_zfs.aarch64-linux unstable (Latest kernel)]
 +
 
 +
On the page click on the latest successful build to get a download link under build products.
 +
 
 +
If the image has the extension <code>.zst</code>, it will need to be decompressed before writing to installation device. Use <code>nix-shell -p zstd --run "unzstd <img-name>.img.zst"</code> to decompress the image.
 +
 
 +
=== Installation steps ===
 +
 
 +
The .img files can be directly written to a microSD/SD card (minimal recommended size: 4 GB) using dd, once uncompressed from the ZSTD container. The SD card needs to be unmounted first.
 +
 
 +
Once the NixOS image file is downloaded, run the following command to install the image onto the SD Card, replace <code>/dev/mmcblk0</code> with the path to the SD card (use <code>dmesg</code> to find it out).
 +
 
 +
<code>
 +
sudo dd if=nixos-sd-image-23.05pre482417.9c7cc804254-aarch64-linux.img of=/dev/mmcblk0 bs=10MB oflag=dsync status=progress
 +
</code>
 +
 
 +
This should be enough to get you started, you may now boot your device for the first time.
 +
 
 +
The base images are configured to boot up with a serial TTY ( RX/TX UART ) @ 115200 Baud. That way you not necessarily have to have a HDMI Display and keyboard.
 +
 
 +
{{note| For some platforms, manually editing and adding kernel command-line arguments to <code>/boot/extlinux/extlinux.conf</code> may be needed for serial to work, and is "as" supported as would be editing the command-line manually during boot.}}
 +
 
 +
Continue with [[#NixOS installation & configuration]].
 +
 
 +
== Binary cache ==
  
{
+
=== AArch64 ===
  # NixOS wants to enable GRUB by default
 
  boot.loader.grub.enable = false;
 
 
 
  # Enables the generation of /boot/extlinux/extlinux.conf
 
  boot.loader.generic-extlinux-compatible.enable = true;
 
 
  # Import hardware configuration generated by nixos-generate-config
 
  # This should correctly set up your file systems
 
  imports = [ ./hardware-configuration.nix ];
 
 
 
  # File systems configuration (if not correctly detected)
 
  # Usually nixos-generate-config handles this properly,
 
  # but this is provided as a fallback
 
  /*
 
  fileSystems = {
 
    "/" = {
 
      device = "/dev/disk/by-label/NIXOS_SD";
 
      fsType = "ext4";
 
    };
 
  };
 
  */
 
 
 
  # Adding a swap file is optional, but recommended for RAM-constrained devices
 
  # Size is in MiB
 
  # swapDevices = [ { device = "/swapfile"; size = 1024; } ];
 
 
 
  # Enable basic networking
 
  networking.networkmanager.enable = true;
 
 
 
  # Basic firewall
 
  networking.firewall.enable = true;
 
 
 
  # Set your time zone
 
  time.timeZone = "UTC";
 
 
 
  # System state version - IMPORTANT: Do not change this after initial install
 
  system.stateVersion = "25.05";
 
}
 
```
 
  
Apply your configuration with:
+
The [https://hydra.nixos.org/ official NixOS Hydra] instance builds a full set of binaries (available on https://cache.nixos.org) for the AArch64 architecture on the nixpkgs-unstable and stable channels.
  
```bash
+
=== armv6l and armv7l ===
sudo nixos-rebuild switch
 
```
 
  
### Kernel Selection
+
Some '''''users''''' have provided best effort caches for 32 bit ARM, but none are currently available.
  
Kernel selection depends on your specific ARM device:
+
== Build your own image natively ==
  
- **For boards with good mainline support** (including Raspberry Pi 4/5 on aarch64):
+
You can customize image by using the following snippet.
  ```nix
 
  boot.kernelPackages = pkgs.linuxPackages_latest;
 
  ```
 
  
- **For legacy Raspberry Pi models on armv6/armv7**:
+
<syntaxHighlight lang=nix>
   ```nix
+
# save as sd-image.nix somewhere
   boot.kernelPackages = pkgs.linuxPackages_rpi;
+
{ ... }: {
  ```
+
   imports = [
 +
    <nixpkgs/nixos/modules/installer/sd-card/sd-image-aarch64.nix>
 +
   ];
 +
  # put your own configuration here, for example ssh keys:
 +
  users.users.root.openssh.authorizedKeys.keys = [
 +
    "ssh-ed25519 AAAAC3NzaC1lZDI1.... username@tld"
 +
  ];
 +
}
 +
</syntaxHighlight>
  
- **For boards requiring specialized kernels**:
+
Then build with:
  Refer to the board-specific wiki page for recommended kernel packages.
 
  
### Modern Flakes-Based Approach (Recommended)
+
<syntaxHighlight lang=nix>
 +
$ nix-build '<nixpkgs/nixos>' -A config.system.build.sdImage -I nixos-config=./sd-image.nix
 +
</syntaxHighlight>
  
Since NixOS 25.05, Flakes are the standard recommended approach for system configuration. They provide reproducible builds, locked dependencies, and simplify cross-device management.
+
Note that this requires a machine with aarch64. You can however also build it from your laptop using an aarch64 remote builder as described in [[Distributed build]] or ask for access on the [https://github.com/nix-community/aarch64-build-box community aarch64 builder].
  
1. Create a `flake.nix` file:
+
if you use the experimental flake, instead of doing the above stuff, can put the following lines in <code>flake.nix</code>, <code>git add flake.nix</code> and build with <code>nix build .#images.rpi2</code>:
  
```nix
+
<syntaxHighlight lang=nix>
 
{
 
{
   description = "NixOS configuration for my ARM device";
+
   description = "Build image";
 
+
   inputs.nixpkgs.url = "github:nixos/nixpkgs/nixos-22.11";
   inputs = {
+
   outputs = { self, nixpkgs }: rec {
    nixpkgs.url = "github:nixos/nixpkgs/nixos-25.05";
+
     nixosConfigurations.rpi2 = nixpkgs.lib.nixosSystem {
    nixos-hardware.url = "github:NixOS/nixos-hardware";
 
  };
 
 
 
   outputs = { self, nixpkgs, nixos-hardware, ... }: {
 
     nixosConfigurations.mydevice = nixpkgs.lib.nixosSystem {
 
      system = "aarch64-linux"; # Or "armv6l-linux"/"armv7l-linux" for 32-bit ARM
 
 
       modules = [
 
       modules = [
         # Hardware-specific modules (if available)
+
         "${nixpkgs}/nixos/modules/installer/sd-card/sd-image-raspberrypi.nix"
         # nixos-hardware.nixosModules.raspberry-pi-4
+
         {
        # nixos-hardware.nixosModules.raspberry-pi-5
+
          nixpkgs.config.allowUnsupportedSystem = true;
       
+
          nixpkgs.hostPlatform.system = "armv7l-linux";
        # Your main configuration file
+
          nixpkgs.buildPlatform.system = "x86_64-linux"; #If you build on x86 other wise changes this.
         ./configuration.nix
+
          # ... extra configs as above
 +
         }
 
       ];
 
       ];
 
     };
 
     };
 +
    images.rpi2 = nixosConfigurations.rpi2.config.system.build.sdImage;
 
   };
 
   };
 
}
 
}
```
+
</syntaxHighlight>
  
2. Apply your configuration with:
+
=== Cross-compiling ===
  
```bash
+
It is possible to cross-compile from a different architecture. To cross-compile to <code>armv7l</code>, on the same <code>sd-image.nix</code> add in <code>crossSystem</code>:
sudo nixos-rebuild switch --flake .#mydevice
 
```
 
  
The `#mydevice` part corresponds to the `nixosConfigurations.mydevice` entry in your flake.nix file.
+
<syntaxHighlight lang=nix>
 
+
{ ... }: {
### Binary Caches
+
  nixpkgs.crossSystem.system = "armv7l-linux";
 
+
   imports = [
#### AArch64 (ARM64)
+
     <nixpkgs/nixos/modules/installer/sd-card/sd-image-aarch64.nix>
The official NixOS Hydra instance builds full binary sets for the AArch64 architecture, available on https://cache.nixos.org for both the nixpkgs-unstable and stable channels:
 
 
 
```nix
 
nix.settings = {
 
   substituters = [
 
     "https://cache.nixos.org"
 
 
   ];
 
   ];
   trusted-public-keys = [
+
   # ...
    "cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY="
+
}
  ];
+
</syntaxHighlight>
};
 
```
 
  
#### armv6l and armv7l (32-bit ARM)
+
=== Compiling through binfmt QEMU ===
There are currently no official binary caches for 32-bit ARM. Consider:
 
- Building packages natively (slow on low-power devices)
 
- Using cross-compilation (see below)
 
- Setting up your own binary cache
 
  
For better performance on bandwidth-constrained devices, limit parallel connections:
+
It is also possible to compile for aarch64 on your non-aarch64 local machine, or a remote builder, by registering QEMU as a binfmt wrapper for the aarch64 architecture. This <b>wrapper uses emulation</b> and will therefore be slower than comparable native machines or cross-compiling.
  
```nix
+
To enable the binfmt wrapper on NixOS, add the following to <code>configuration.nix</code>
nix.settings = {
 
  max-substitution-jobs = 2;
 
};
 
```
 
  
### Building on Resource-Constrained ARM Devices
+
<syntaxHighlight lang=nix>
 +
{
 +
  boot.binfmt.emulatedSystems = [ "aarch64-linux" ];
 +
}
 +
</syntaxHighlight>
  
ARM devices, especially older or low-power models, may struggle with building large packages. Consider these approaches:
+
Then, add <code>--argstr system aarch64-linux</code> to the build command:
  
#### 1. Remote Builders
+
<syntaxHighlight lang=nix>
 +
$ nix-build '<nixpkgs/nixos>' -A config.system.build.sdImage -I nixos-config=./sd-image.nix --argstr system aarch64-linux
 +
</syntaxHighlight>
  
Configure a more powerful machine (ideally ARM64) as a remote builder:
+
If you are building on non-NixOS machine with QEMU binfmt wrapper configured, you will want to configure nix daemon to let it know that it can build for aarch64. Add the following line to <code>/etc/nix/nix.conf</code>:
 +
<code>extra-platforms = aarch64-linux arm-linux</code>
 +
{{note| archlinux users can install <code>extra/qemu-system-aarch64</code>, <code>extra/qemu-user-static</code> and <code>extra/qemu-user-static-binfmt</code>
 +
and restart <code>systemd-binfmt.service</code>. Check if binfmt is loaded by <code>ls  /proc/sys/fs/binfmt_misc/</code> (there must be  <code>qemu-aarch64</code> or needed architecture) and add line <code><nowiki>extra-sandbox-paths = /usr/bin/qemu-aarch64-static</nowiki></code> to <code>/etc/nix/nix.conf</code> and don't forget to restart the <code>nix-daemon.service</code> systemd unit afterwards.}}
  
```nix
+
If you want to build just one specific package, use this:
nix.buildMachines = [{
+
<syntaxHighlight lang=nix>
  hostName = "builder";
+
nix-build '<nixpkgs/nixos>' -A pkgs.theRequiredPackage --argstr system aarch64-linux -I nixos-config=/path/to/target/machine/nixos/config/copy
  system = "aarch64-linux";
+
</syntaxHighlight>
  maxJobs = 4;
+
(the last option should not be required on NixOS machines)
  speedFactor = 2;
 
  supportedFeatures = [ "nixos-test" "benchmark" "big-parallel" "kvm" ];
 
}];
 
nix.distributedBuilds = true;
 
```
 
  
For setup instructions, see the [Distributed Build](https://nixos.wiki/wiki/Distributed_build) wiki page.
+
=== Compiling through QEMU/kvm ===
  
#### 2. Cross-Compilation using QEMU with binfmt_misc
+
It is also possible to build nixos images through full emulation using QEMU/kvm but will be way slower than native and binfmt QEMU.
  
On an x86_64 NixOS system, enable ARM emulation:
+
== Installer image with custom U-Boot ==
  
```nix
+
The [https://github.com/Mic92/nixos-aarch64-images Mic92/nixos-aarch64-images] repository provides a mechanism to modify the official NixOS installer to embed the board-specific U-Boot firmware required for different boards. This method does not require QEMU or native ARM builds since the existing Hydra-built U-Boot binaries are used.
boot.binfmt.emulatedSystems = [ "aarch64-linux" ];
 
```
 
  
Then build ARM packages from your x86_64 machine using:
+
== Board-specific installation notes ==
  
```bash
+
Depending on the board, some additional preparation steps might be needed to make the SD card bootable on your device. All of the board-specific installation notes are now found on their respective pages.
nix build --system aarch64-linux .#package
 
```
 
  
Or for non-Flake commands:
+
== Enable UART ==
  
```bash
+
If you try to use UART to log on NixOS, you might hang on the line "Starting kernel ...". To enable UART, you will need to add at the end of the line that contains <code>loglevel4</code> in the file <code>/extlinux/extlinux.conf</code> the text:
nix-build '<nixpkgs>' -A pkgs.hello --argstr system aarch64-linux
+
{{file|/extlinux/extlinux.conf||<nowiki>
```
+
    console=ttyAMA0,115200n8
 +
</nowiki>}}
 +
{{file|/extlinux/extlinux.conf||<nowiki>
 +
    console=ttyS0,115200n8
 +
</nowiki>}}
 +
The actual device (<code>ttyAMA0</code>, <code>ttyS0</code>, <code>ttyS1</code>) will depend on the hardware.
  
#### 3. Building through QEMU/KVM
+
== NixOS installation & configuration ==
  
While slower than other methods, full emulation through QEMU/KVM is possible for ARM development. See the [NixOS on ARM/QEMU](https://nixos.wiki/wiki/NixOS_on_ARM/QEMU) page for detailed setup.
+
{{outdated|The kernel version recommendations of this section are severely outdated. This section should be rewritten to be generic and refer people to the board-specific page. Only the board specific page should make recommendations about the kernel.}}
  
### Creating Custom ARM Images
+
The installation image is actually a MBR partition table plus two partitions; a FAT16 /boot and a ext4 root filesystem. The image is designed such that it's possible to directly reuse the SD image's partition layout and "install" NixOS on the very same SD card by simply replacing the default configuration.nix and running nixos-rebuild. Using this installation method is strongly recommended, though if you know exactly what you're doing and how U-Boot on your board works, you can use nixos-install as usual. To help with the SD card installation method, the boot scripts on the image automatically resize the rootfs partition to fit the SD card on the first boot.
  
#### Building with Flakes (Recommended)
+
* To generate a default <code>/etc/nixos/configuration.nix</code> file, run <code>sudo nixos-generate-config</code>.
  
Create a custom SD card image with a Flake:
+
* You can also use an existing template:
 +
{{file|/etc/nixos/configuration.nix|nix|<nowiki>
 +
{ config, pkgs, lib, ... }:
 +
{
 +
  # NixOS wants to enable GRUB by default
 +
  boot.loader.grub.enable = false;
 +
  # Enables the generation of /boot/extlinux/extlinux.conf
 +
  boot.loader.generic-extlinux-compatible.enable = true;
 +
 +
  # !!! If your board is a Raspberry Pi 1, select this:
 +
  boot.kernelPackages = pkgs.linuxPackages_rpi;
 +
  # On other boards, pick a different kernel, note that on most boards with good mainline support, default, latest and hardened should all work
 +
  # Others might need a BSP kernel, which should be noted in their respective wiki entries
  
```nix
+
  # nixos-generate-config should normally set up file systems correctly
{
+
  imports = [ ./hardware-configuration.nix ];
  description = "Custom ARM image";
+
  # If not, you can set them up manually as shown below
 
+
  /*
  inputs = {
+
  fileSystems = {
    nixpkgs.url = "github:nixos/nixpkgs/nixos-25.05";
+
    # Prior to 19.09, the boot partition was hosted on the smaller first partition
 +
    # Starting with 19.09, the /boot folder is on the main bigger partition.
 +
    # The following is to be used only with older images. Note such old images should not be considered supported anymore whatsoever, but if you installed back then, this might be needed
 +
    /*
 +
    "/boot" = {
 +
      device = "/dev/disk/by-label/NIXOS_BOOT";
 +
      fsType = "vfat";
 +
    };
 +
    */
 +
    "/" = {
 +
      device = "/dev/disk/by-label/NIXOS_SD";
 +
      fsType = "ext4";
 +
    };
 
   };
 
   };
    
+
   */
  outputs = { self, nixpkgs }: {
 
    nixosConfigurations.armimage = nixpkgs.lib.nixosSystem {
 
      system = "aarch64-linux"; # For building 64-bit ARM images
 
      modules = [
 
        # Base SD image module for your architecture
 
        "${nixpkgs}/nixos/modules/installer/sd-card/sd-image-aarch64.nix"
 
        # Your customizations
 
        ({ ... }: {
 
          # Add your customizations here
 
          users.users.root.openssh.authorizedKeys.keys = [
 
            "ssh-ed25519 AAAAC3NzaC1lZDI1.... username@tld"
 
          ];
 
        })
 
      ];
 
    };
 
 
      
 
      
    # Make the SD image the default output
+
  # !!! Adding a swap file is optional, but recommended if you use RAM-intensive applications that might OOM otherwise.  
    packages.aarch64-linux.default =
+
  # Size is in MiB, set to whatever you want (though note a larger value will use more disk space).
      self.nixosConfigurations.armimage.config.system.build.sdImage;
+
   # swapDevices = [ { device = "/swapfile"; size = 1024; } ];
   };
+
}</nowiki>}}
}
+
Note: the default configuration.nix will contain something like <code>imports = [ <nixos/modules/installer/sd-card/sd-image-armv7l-multiplatform.nix> ];</code> do not include that in your final installation or you will experience interesting problems. It is only for building the installation image!
```
+
 
 +
==== First rebuild on ARMv6 and ARMv7 ====
 +
 
 +
To rebuild your system, run: <code>sudo nixos-rebuild switch</code>
  
Build with:
+
{{note|Instructions removed since they referred to a long abandoned user-provided cache...}}
 +
<!--
 +
To make the unsupported ARM experience slightly less painful, the config template adds <code>[...]</code> as a binary cache, which contains a small subset of packages on the unstable channel (though a caution for US users: the server hosting them is physically located in Finland). Note that the binary cache isn't enabled on the prebuilt images, so enable it via the command line when building for the first time:
  
```bash
+
<syntaxhighlight lang="bash">nixos-rebuild switch --fast --option binary-caches [...]/channel --option binary-cache-public-keys [...]-1:XXXXXXXXXXXXXX+XXXXXXXXXXXXXX=%</syntaxhighlight>
nix build
+
-->
```
 
  
#### Building the Traditional Way
+
== Details about the boot process ==
  
For non-Flake builds:
+
On NixOS, all ARM boards are expected to use U-Boot as the firmware and bootloader. NixOS uses [https://github.com/u-boot/u-boot/blob/master/doc/develop/distro.rst U-Boot's Generic Distro Configuration Concept] as the mechanism to communicate boot information (such as path to kernel zImage, initrd, DTB, command line arguments). For a quick TL;DR about the generic distro configuration support: U-Boot is scripted to scan all attached storage devices & partitions and look for a file named <code>/extlinux/extlinux.conf</code> or <code>/boot/extlinux/extlinux.conf</code> (which will be generated by NixOS, just like <code>/boot/grub/grub.cfg</code> is generated on PCs). The partition needs to have its "bootable" flag set.
  
```bash
+
U-Boot also provides an interactive shell and the generation selection menu (just like GRUB). However, support for input or display devices varies greatly, depending on the board. Details for what the boards support in relationship to the boot process are detailed in their respective pages.
nix-build '<nixpkgs/nixos>' -A config.system.build.sdImage -I nixos-config=./sd-image.nix
 
```
 
  
Where `sd-image.nix` contains:
+
== Porting NixOS to new boards ==
  
```nix
+
=== The easiest way ===
{ ... }: {
 
  imports = [
 
    <nixpkgs/nixos/modules/installer/sd-card/sd-image-aarch64.nix>
 
  ];
 
 
 
  # Your customizations here
 
  users.users.root.openssh.authorizedKeys.keys = [
 
    "ssh-ed25519 AAAAC3NzaC1lZDI1.... username@tld"
 
  ];
 
}
 
```
 
  
### U-Boot Customization
+
Assuming upstream U-Boot supports the board through a defconfig, it is possible possible to build U-Boot using the cross-compiling architecture from an x86_64 host. Here's a sample use.
  
Some boards may require custom U-Boot builds. For boards supported by upstream U-Boot, you can cross-compile from an x86_64 host:
+
<syntaxhighlight>
 +
# Assuming you're in a recent nixpkgs checkout
 +
$ nix-shell \
 +
    -I "nixpkgs=$PWD" \
 +
    -p 'let plat = pkgsCross.aarch64-multiplatform; in plat.buildUBoot{defconfig = "orangepi_zero_plus2_defconfig"; extraMeta.platforms = ["aarch64-linux"]; BL31 = "${plat.armTrustedFirmwareAllwinner}/bl31.bin"; filesToInstall = ["u-boot-sunxi-with-spl.bin"];}'
 +
</syntaxhighlight>
  
```bash
+
For armv7 and armv6 <code>pkgsCross.arm-embedded</code> should work, this is available in the unstable channel (19.03 and following) by setting <code>-I "nixpkgs=/path/to/new-nixpkgs-checkout</code>.
nix-shell -p 'let plat = pkgsCross.aarch64-multiplatform; in plat.buildUBoot{defconfig = "board_defconfig"; extraMeta.platforms = ["aarch64-linux"];}'
 
```
 
  
Replace `board_defconfig` with your board's U-Boot configuration name.
+
This should build whatever is needed for, and then build U-Boot for the desired defconfig, then open a shell with the build in <code>$buildInputs</code>. Do note that this particular invocation may need more changes than only the defconfig if built for other than allwinner boards.
  
For manual builds (when NixOS packages are unavailable):
+
Here's an example command, for allwinner boards, on how to write to an SD card.
  
```bash
+
<syntaxhighlight>
nix-shell -E 'with import <nixpkgs> {}; stdenv.mkDerivation { name = "arm-shell"; buildInputs = [git gnumake gcc gcc-arm-embedded dtc bison flex python3 swig]; }'
+
$ sudo dd if=$buildInputs/u-boot-sunxi-with-spl.bin of=/dev/sdX bs=1024 seek=8
git clone git://git.denx.de/u-boot.git
+
</syntaxhighlight>
cd u-boot
 
make CROSS_COMPILE=arm-none-eabi- board_defconfig
 
make CROSS_COMPILE=arm-none-eabi-
 
```
 
  
Flash the resulting U-Boot image to your storage device (SD card/eMMC/etc.) at the appropriate offset, typically:
+
=== The easy way ===
  
```bash
+
''(if you're lucky)''
sudo dd if=u-boot-sunxi-with-spl.bin of=/dev/sdX bs=1024 seek=8
 
```
 
  
The seek value and filename vary by board - check your board's wiki page or documentation.
+
If your board is an ARMv7 board supported by multi_v7_defconfig and you have access to U-Boot on the board, getting <code>sd-image-armv7l-linux.img</code> to boot is the easiest option:
  
### Optimizing Performance on ARM
+
* If you're lucky and your U-Boot build comes with the extlinux.conf support built in, the image boots out-of-the-box. This is the case for all (upstream) Allwinner and Tegra U-Boots, for instance.
 +
* Otherwise, you can get the boot information (path to kernel zImage, initrd, DTB, command line arguments) by extracting <code>extlinux.conf</code> from the boot partition of the image, and then attempt to boot it via the U-Boot shell, or some other mechanism that your board's distro uses (e.g. <code>uEnv.txt</code>).
  
For better performance on ARM devices:
+
==== Building U-Boot from your NixOS PC ====
  
```nix
+
Assuming
{
 
  # CPU frequency scaling (if supported by your hardware)
 
  powerManagement.cpuFreqGovernor = "ondemand";
 
 
 
  # IO scheduler tuning (improves SD card performance)
 
  services.udev.extraRules = ''
 
    # Set deadline scheduler for SD cards
 
    ACTION=="add|change", KERNEL=="mmcblk[0-9]", ATTR{queue/scheduler}="mq-deadline"
 
  '';
 
 
 
  # Zram swap (better than SD card swap)
 
  zramSwap = {
 
    enable = true;
 
    algorithm = "zstd";
 
  };
 
 
 
  # Using tmpfs for temp directories
 
  boot.tmpOnTmpfs = true;
 
}
 
```
 
  
### Security Hardening for ARM Devices
+
* Your board is supported upstream by U-Boot or there is a recent enough fork with <code>extlinux.conf</code> support.
 +
* You do not have nix setup on an ARM device
 +
* Your nix isn't setup for cross-compilation
  
Since NixOS 25.05, additional security features are available that are relevant for ARM devices:
+
It is still possible to build U-Boot using tools provided by NixOS.
  
```nix
+
In the following terminal session, replace <code>orangepi_pc_defconfig</code> with the appropriate board [http://git.denx.de/?p=u-boot.git;a=tree;f=configs;hb=HEAD from the configs folder] of U-Boot.
{
 
  # Kernel hardening options
 
  boot.kernelParams = [ "slab_nomerge" "init_on_alloc=1" "init_on_free=1" ];
 
  boot.kernel.sysctl = {
 
    "kernel.kptr_restrict" = 2;
 
    "kernel.dmesg_restrict" = 1;
 
  };
 
 
 
  # Mandatory Access Control (if supported by your hardware)
 
  security.apparmor.enable = true;  # Less resource-intensive than SELinux
 
 
 
  # Memory protection
 
  security.protectKernelImage = true;
 
}
 
```
 
  
Note: Always understand the security implications and compatibility impact of hardening options before applying them. Some settings may affect hardware compatibility or performance on specific ARM devices.
+
{{Commands|<nowiki>
 +
$ nix-shell -E 'with import <nixpkgs> {}; stdenv.mkDerivation { name = "arm-shell"; buildInputs = [git gnumake gcc gcc-arm-embedded dtc]; }'
 +
$ git clone git://git.denx.de/u-boot.git
 +
$ cd u-boot
 +
# We're checking out a version from before the use of `binman`.
 +
# The dtc package is 1.4.2, which does not include `pylibftd`.
 +
# Furthermore, I do not know how to package the library so it would be
 +
# available in the python interpreter, making binman happy.
 +
$ git checkout v2017.03
 +
$ make -j4 CROSS_COMPILE=arm-none-eabi- orangepi_pc_defconfig
 +
$ make -j4 CROSS_COMPILE=arm-none-eabi-
 +
</nowiki>}}
  
### Wayland Support on ARM64
+
The name of the final file will change depending on the board. For this specific build, and most Allwinner builds, the file will be named <code>u-boot-sunxi-with-spl.bin</code>.
  
Recent NixOS releases provide good Wayland support on ARM64 devices:
+
You can flash this file to boot device with
  
```nix
+
{{Commands|<nowiki>
{
+
dd if=u-boot-sunxi-with-spl.bin of=/dev/sdX bs=1024 seek=8
  # For GNOME
+
</nowiki>}}
  services.xserver = {
 
    enable = true;
 
    displayManager.gdm.enable = true;
 
    desktopManager.gnome.enable = true;
 
    displayManager.gdm.wayland = true; # Explicitly enable Wayland
 
  };
 
 
 
  # For KDE Plasma
 
  services.xserver = {
 
    enable = true;
 
    displayManager.sddm.enable = true;
 
    desktopManager.plasma5.enable = true;
 
    displayManager.defaultSession = "plasmawayland";
 
  };
 
 
 
  # Required for GPU acceleration
 
  hardware.opengl = {
 
    enable = true;
 
    driSupport = true;
 
  };
 
}
 
```
 
  
For Raspberry Pi 5, add `dtoverlay=vc4-kms-v3d-pi5` in `/boot/config.txt` to enable GPU drivers compatible with Wayland.
+
Note: This mailing list contains a patch which may help some builds: https://lists.denx.de/pipermail/u-boot/2016-December/275664.html
  
### Common ARM Device Troubleshooting
+
=== The hard way ===
  
1. **UART Console Access**: If your device isn't booting properly, enable UART:
+
Alternatively/if all else fails, you can do it the hard way and bootstrap NixOS from an existing ARM Linux installation.
  ```nix
 
  boot.kernelParams = [
 
    "console=ttyS0,115200n8"  # Adjust ttyS0 to match your device's UART
 
  ];
 
  ```
 
  
  The actual device (ttyAMA0, ttyS0, ttyS1) depends on your hardware. See the [Enable UART](https://nixos.wiki/wiki/NixOS_on_ARM#Enable_UART) section for details.
+
=== Contributing new boards to nixpkgs ===
  
2. **Memory Constraints**: For devices with limited RAM:
+
* Add a new derivation for your board's U-Boot configuration, see for example ubootPine64LTS in {{Nixpkgs Link|short=all-packages.nix|pkgs/top-level/all-packages.nix}}.
  ```nix
+
* If your board's U-Boot configuration doesn't use the <code>extlinux.conf</code> format by default, create a patch to enable it. Some C hacking skills & U-Boot knowledge might be required. For some pointers, see this patch to enable it on the Versatile Express.
  nix.settings.cores = 1; # Limit parallel builds
+
* Make a pull request, also containing the board-specific instructions.
  nix.settings.max-jobs = 1;
 
  boot.tmp.cleanOnBoot = true; # Clean /tmp on boot
 
  ```
 
  
3. **Network Issues**: For better wireless support:
+
== Support ==
  ```nix
 
  networking.networkmanager.enable = true;
 
  hardware.enableRedistributableFirmware = true; # For WiFi firmware
 
  ```
 
  
### Related Projects
+
Only AArch64 is supported by NixOS.
  
#### NixOS Mobile
+
All 32 bit ARM platforms are experimental for the time being.
  
For mobile devices like smartphones and tablets, check out the [Mobile NixOS project](https://github.com/mobile-nixos/mobile-nixos). This project extends NixOS to run on devices like the PinePhone and select OnePlus models, with features specifically designed for mobile use cases.
+
There is a dedicated room for the upstream effort on Matrix,  
 +
[https://matrix.to/#/#nixos-on-arm:nixos.org #nixos-on-arm:nixos.org].
  
Mobile NixOS provides specialized modules for:
+
== Resources ==
- Touch input and mobile-friendly UI
 
- Power management
 
- Cellular modem support
 
- Mobile hardware integration
 
  
Visit the [Mobile NixOS documentation](https://mobile.nixos.org/) for detailed setup and configuration guidance.
+
=== Subpages ===
  
#### QEMU Emulation
+
The following is a list of all sub-pages of the ''NixOS on ARM'' topic.
  
For detailed instructions on running NixOS ARM in QEMU, see the dedicated [NixOS on ARM/QEMU](https://nixos.wiki/wiki/NixOS_on_ARM/QEMU) wiki page.
+
{{Special:PrefixIndex/{{FULLPAGENAME}}/ |hideredirects=1 |stripprefix=1}}

Latest revision as of 23:47, 4 April 2025

ARM support for NixOS is a work-in-progress, but is progressing quickly.

The support varies depending on the architecture and the specific boards. The way the ARM integration is built into NixOS is by making generic builds the first-class citizens; as soon as there is upstream support for the board in the kernel and the bootloader, NixOS should work once updated to these versions. It is still possible, when needed, to build and use a customised bootloader and kernel for specific boards[reference needed]. At this moment in time (late 2021) only AArch64 has full support upstream.

Though, neither armv6l or armv7l are being ignored, fixes are worked on and approved as needed; what's missing is support and upstream builds being maintained in binary form. At the time of writing, no publicly available caches for armv6l or armv7l are available.

For images links, including UEFI install, skip to the Installation section.

Supported devices

Table legend:

Upstream (NixOS) supported devices

NixOS has support for these boards using AArch64 architecture on the nixpkgs-unstable and stable channel.

Support for those board assumes as much is supported as Mainline Linux supports.

Manufacturer Board SoC ISA CPU RAM Storage
Raspberry Pi Foundation Raspberry Pi 3 Broadcom BCM2837 AArch64 / ARMv7 4× Cortex-A53 @ 1.2 - 1.4 GHz 1 GB SD/microSD
Raspberry Pi Foundation Raspberry Pi 4 Broadcom BCM2711 AArch64 / ARMv7 4× Cortex-A72 @ 1.5 - 1.8 GHz 1-8 GB microSD, eMMC

Community supported devices

Manufacturer Board SoC ISA CPU RAM Storage
Apple Apple Silicon Macs M1/M1 Pro/M1 Max AArch64 NVMe
ASUS Tinker Board Rockchip RK3288 ARMv7 4× Cortex-A17 2 GB microSD
Banana Pi Banana Pi Allwinner A20 ARMv7 2× Cortex-A7 1 GB SD, SATA
Banana Pi M64 Banana Pi M64 Allwinner A64 ARMv8 4× Cortex-A53 2 GB microSD, 8GB eMMc
Banana Pi BPI-M5 Banana Pi BPI-M5 Amlogic S905X3 ARMv8.2 4× Cortex-A55 4 GB LPDDR4 microSD, 16G eMMC
BeagleBoard.org BeagleBone Black TI AM335x (src) ARMv7 1× Cortex-A8 @ 1 GHz 512 MB 4 GB eMMC, microSD
Firefly AIO-3399C Rockchip RK3399 AArch64 2× Cortex-A72 @ 2.0 GHz, 4× Cortex-A53 @ 1.5 Ghz 2/4 GB 8/16 GB eMMC, microSD
FriendlyElec NanoPC-T4 Rockchip RK3399 AArch64 2× Cortex-A72 @ 2.0 GHz, 4× Cortex-A53 @ 1.5 Ghz 4 GB 16 GB eMMC, microSD, NVMe
FriendlyElec NanoPi-M4 Rockchip RK3399 AArch64 2× Cortex-A72 @ 2.0 GHz, 4× Cortex-A53 @ 1.5 Ghz 4 GB optional eMMC, microSD
FriendlyElec NanoPi-R6C Rockchip RK3588S AArch64 4× ARM Cortex-A76 @ 2.4 GHz, 4× Cortex-A55 @ 1.8 Ghz 4 GB / 8 GB optional eMMC, microSD, NVMe
Hardkernel ODROID-HC1 & ODROID-HC2 Samsung Exynos 5422 ARMv7 4× Cortex-A15 @ 2GHz, 4× Cortex-A7 @ 1.4GHz 2 GB microSD
Hardkernel ODROID-C2 Amlogic S905 AArch64 4× Cortex-A53 @ 1.5GHz 2 GB eMMC, microSD
Hardkernel ODROID-HC4 Amlogic S905X3 AArch64 4× Cortex-A55 @ 1.8GHz 4 GB microSD, SATA
Libre Computer ROC-RK3399-PC Rockchip RK3399 AArch64 2× Cortex-A72 @ 2.0 GHz, 4× Cortex-A53 @ 1.5 Ghz 4 GB eMMC, microSD, NVMe
Libre Computer ROC-RK3328-CC Rockchip RK3328 AArch64 4× ARM Cortex-A53 @ 1.4GHz 4 GB eMMC, microSD
Libre Computer AML-S905X-CC-V2 Amlogic S905X AArch64 4× Cortex-A53 @ 1.512 GHz 1/2GB eMMC, microSD
Linksprite pcDuino3 Nano Allwinner A20 ARMv7 2× Cortex-A7 @ 1 GHz 1 GB 4 GB NAND, microSD, SATA
NVIDIA Jetson TK1 Tegra K1/T124 ARMv7 4× Cortex-A15 @ 2.3 GHz 2 GB 16 GB eMMC, SD, SATA
NXP i.MX 8M Plus EVK i.MX 8M Plus AArch64 4× Cortex-A53 @ 1.8 Ghz 6 GB 32 GB eMMC, microSD
NXP i.MX 8M Quad EVK i.MX 8M Quad AArch64 4× Cortex-A53 @ 1.5 Ghz + 1x Cortex-M4 3 GB 16 GB eMMC, microSD
OLIMEX Teres-A64 AllWinner A64 AArch64 4x Cortex-A53 @ 1152MHz 2GB 16 GB eMMC, microSD
Orange Pi Orange Pi One Allwinner H3 ARMv7 4× Cortex-A7 @ 1.2 GHz 512 MB microSD
Orange Pi Orange Pi PC Allwinner H3 ARMv7 4× Cortex-A7 @ 1.6 GHz 1 GB SD/microSD
Orange Pi Orange Pi Zero Plus2 (H5) Allwinner H5 AArch64 4× Cortex-A53 @ 1.2 GHz 1 GB SD/microSD + 8GB eMMC
Orange Pi Orange Pi Zero2 (H616) Allwinner H616 AArch64 4× Cortex-A53 @ 1.2 GHz 1 GB SD/microSD + 2MB SPI Flash
Orange Pi Orange Pi R1 Plus LTS Rockchip RK3328 AArch64 4x Cortex-A53 @ -1.5 GHz 1 GB microSD
Orange Pi Orange Pi 5 Rockchip RK3588s AArch64 4× Cortex-A76 @ 2.4GHz, 4×Cortex-A55 @ 1.8 GHz 4/8/16 GB microSD, NVMe
Orange Pi Orange Pi 5 Plus Rockchip RK3588 AArch64 4× Cortex-A76 @ 2.4GHz, 4×Cortex-A55 @ 1.8 GHz 4/8/16 GB eMMC, microSD, NVMe
PINE64 PINE A64-LTS Allwinner R18 AArch64 4× Cortex-A53 @ ? GHz 2 GB microSD & eMMC
PINE64 Pinebook Allwinner A64 AArch64 4× Cortex-A53 @ ? Ghz 2 GB microSD & eMMC
PINE64 Pinebook Pro Rockchip RK3399 AArch64 2× Cortex-A72 @ 2.0 GHz, 4× Cortex-A53 @ 1.5 Ghz 4 GB microSD & eMMC
PINE64 ROCK64 Rockchip RK3328 AArch64 4× Cortex-A53 @ 1.5 GHz 1/2/4 GB microSD/eMMC
PINE64 ROCKPro64 Rockchip RK3399 AArch64 2× Cortex-A72 @ 2.0 GHz, 4× Cortex-A53 @ 1.5 Ghz 2/4 GB microSD/eMMC
Clockworkpi uConsole A06 Rockchip RK3399 AArch64 2× Cortex-A72 @ 2.0 GHz, 4× Cortex-A53 @ 1.5 Ghz 4 GB microSD
Radxa ROCK5 Model B Rockchip RK3588 AArch64 4× Cortex-A76 @ 2.4GHz, 4×Cortex-A55 @ 1.8 GHz 4/8/16 GB eMMC, microSD, NVMe
Radxa ROCK5 Model A Rockchip RK3588s AArch64 4× Cortex-A76 @ 2.4GHz, 4×Cortex-A55 @ 1.8 GHz 4/8/16 GB eMMC, microSD, NVMe
Raspberry Pi Foundation Raspberry Pi Broadcom BCM2835 ARMv6 1 × ARM1176 @ 700 MHz 256 MB / 512 MB SD/microSD
Raspberry Pi Foundation Raspberry Pi 2 Broadcom BCM2836 ARMv7 4× Cortex-A7 @ 900 MHz 1 GB SD/microSD
Raspberry Pi Foundation Raspberry Pi 3 Broadcom BCM2837 AArch64 / ARMv7 4× Cortex-A53 @ 1.2 GHz 1 GB SD/microSD
Raspberry Pi Foundation Raspberry Pi 4 Broadcom BCM2711 AArch64 / ARMv7 4× Cortex-A53 @ 1.5 GHz 1-8 GB microSD
Raspberry Pi Foundation Raspberry Pi 5 Broadcom BCM2712 AArch64 4× Cortex-A76 @ 2.4 GHz 4-16 GB microSD
Toshiba AC100 (mini laptop) Tegra 2 250 (T20) ARMv7 2× Cortex-A9 @ 1 GHz 512 MB 8­­–32 GB eMMC, SD
Wandboard Wandboard Solo/Dual/Quad Freescale i.MX6 ARMv7 1×/2×/4× Cortex-A9 @ 1000 MHz 512 MB / 1 GB / 2 GB microSD, SATA

Special Devices

It is possible to emulate an ARM platform with QEMU.

Manufacturer Board SoC ISA CPU RAM Storage
QEMU QEMU ARMv7 up to 8 up to 2 GB Anything QEMU supports

Installation

Getting the installer

UEFI iso

Note: On Raspberry Pi devices, the NixOS ISO are not compatible due to hardware limitations rather than issues with the NixOS installer itself. As a result, it is recommended to use the SD card images files (.img) instead for a successful installation experience.

Continue to the UEFI page.

SD card images (SBCs and similar platforms)

For AArch64 it is possible to download images from Hydra.

On the page click on the latest successful build to get a download link under build products.

If the image has the extension .zst, it will need to be decompressed before writing to installation device. Use nix-shell -p zstd --run "unzstd <img-name>.img.zst" to decompress the image.

Installation steps

The .img files can be directly written to a microSD/SD card (minimal recommended size: 4 GB) using dd, once uncompressed from the ZSTD container. The SD card needs to be unmounted first.

Once the NixOS image file is downloaded, run the following command to install the image onto the SD Card, replace /dev/mmcblk0 with the path to the SD card (use dmesg to find it out).

sudo dd if=nixos-sd-image-23.05pre482417.9c7cc804254-aarch64-linux.img of=/dev/mmcblk0 bs=10MB oflag=dsync status=progress

This should be enough to get you started, you may now boot your device for the first time.

The base images are configured to boot up with a serial TTY ( RX/TX UART ) @ 115200 Baud. That way you not necessarily have to have a HDMI Display and keyboard.

Note: For some platforms, manually editing and adding kernel command-line arguments to /boot/extlinux/extlinux.conf may be needed for serial to work, and is "as" supported as would be editing the command-line manually during boot.

Continue with #NixOS installation & configuration.

Binary cache

AArch64

The official NixOS Hydra instance builds a full set of binaries (available on https://cache.nixos.org) for the AArch64 architecture on the nixpkgs-unstable and stable channels.

armv6l and armv7l

Some users have provided best effort caches for 32 bit ARM, but none are currently available.

Build your own image natively

You can customize image by using the following snippet.

# save as sd-image.nix somewhere
{ ... }: {
  imports = [
    <nixpkgs/nixos/modules/installer/sd-card/sd-image-aarch64.nix>
  ];
  # put your own configuration here, for example ssh keys:
  users.users.root.openssh.authorizedKeys.keys = [
     "ssh-ed25519 AAAAC3NzaC1lZDI1.... username@tld"
  ];
}

Then build with:

$ nix-build '<nixpkgs/nixos>' -A config.system.build.sdImage -I nixos-config=./sd-image.nix

Note that this requires a machine with aarch64. You can however also build it from your laptop using an aarch64 remote builder as described in Distributed build or ask for access on the community aarch64 builder.

if you use the experimental flake, instead of doing the above stuff, can put the following lines in flake.nix, git add flake.nix and build with nix build .#images.rpi2:

{
  description = "Build image";
  inputs.nixpkgs.url = "github:nixos/nixpkgs/nixos-22.11";
  outputs = { self, nixpkgs }: rec {
    nixosConfigurations.rpi2 = nixpkgs.lib.nixosSystem {
      modules = [
        "${nixpkgs}/nixos/modules/installer/sd-card/sd-image-raspberrypi.nix"
        {
          nixpkgs.config.allowUnsupportedSystem = true;
          nixpkgs.hostPlatform.system = "armv7l-linux";
          nixpkgs.buildPlatform.system = "x86_64-linux"; #If you build on x86 other wise changes this.
          # ... extra configs as above
        }
      ];
    };
    images.rpi2 = nixosConfigurations.rpi2.config.system.build.sdImage;
  };
}

Cross-compiling

It is possible to cross-compile from a different architecture. To cross-compile to armv7l, on the same sd-image.nix add in crossSystem:

{ ... }: {
  nixpkgs.crossSystem.system = "armv7l-linux";
  imports = [
    <nixpkgs/nixos/modules/installer/sd-card/sd-image-aarch64.nix>
  ];
  # ...
}

Compiling through binfmt QEMU

It is also possible to compile for aarch64 on your non-aarch64 local machine, or a remote builder, by registering QEMU as a binfmt wrapper for the aarch64 architecture. This wrapper uses emulation and will therefore be slower than comparable native machines or cross-compiling.

To enable the binfmt wrapper on NixOS, add the following to configuration.nix

{
  boot.binfmt.emulatedSystems = [ "aarch64-linux" ];
}

Then, add --argstr system aarch64-linux to the build command:

$ nix-build '<nixpkgs/nixos>' -A config.system.build.sdImage -I nixos-config=./sd-image.nix --argstr system aarch64-linux

If you are building on non-NixOS machine with QEMU binfmt wrapper configured, you will want to configure nix daemon to let it know that it can build for aarch64. Add the following line to /etc/nix/nix.conf: extra-platforms = aarch64-linux arm-linux

Note: archlinux users can install extra/qemu-system-aarch64, extra/qemu-user-static and extra/qemu-user-static-binfmt and restart systemd-binfmt.service. Check if binfmt is loaded by ls /proc/sys/fs/binfmt_misc/ (there must be qemu-aarch64 or needed architecture) and add line extra-sandbox-paths = /usr/bin/qemu-aarch64-static to /etc/nix/nix.conf and don't forget to restart the nix-daemon.service systemd unit afterwards.

If you want to build just one specific package, use this:

nix-build '<nixpkgs/nixos>' -A pkgs.theRequiredPackage --argstr system aarch64-linux -I nixos-config=/path/to/target/machine/nixos/config/copy

(the last option should not be required on NixOS machines)

Compiling through QEMU/kvm

It is also possible to build nixos images through full emulation using QEMU/kvm but will be way slower than native and binfmt QEMU.

Installer image with custom U-Boot

The Mic92/nixos-aarch64-images repository provides a mechanism to modify the official NixOS installer to embed the board-specific U-Boot firmware required for different boards. This method does not require QEMU or native ARM builds since the existing Hydra-built U-Boot binaries are used.

Board-specific installation notes

Depending on the board, some additional preparation steps might be needed to make the SD card bootable on your device. All of the board-specific installation notes are now found on their respective pages.

Enable UART

If you try to use UART to log on NixOS, you might hang on the line "Starting kernel ...". To enable UART, you will need to add at the end of the line that contains loglevel4 in the file /extlinux/extlinux.conf the text:

Breeze-text-x-plain.png
/extlinux/extlinux.conf
    console=ttyAMA0,115200n8
Breeze-text-x-plain.png
/extlinux/extlinux.conf
    console=ttyS0,115200n8

The actual device (ttyAMA0, ttyS0, ttyS1) will depend on the hardware.

NixOS installation & configuration

The installation image is actually a MBR partition table plus two partitions; a FAT16 /boot and a ext4 root filesystem. The image is designed such that it's possible to directly reuse the SD image's partition layout and "install" NixOS on the very same SD card by simply replacing the default configuration.nix and running nixos-rebuild. Using this installation method is strongly recommended, though if you know exactly what you're doing and how U-Boot on your board works, you can use nixos-install as usual. To help with the SD card installation method, the boot scripts on the image automatically resize the rootfs partition to fit the SD card on the first boot.

  • To generate a default /etc/nixos/configuration.nix file, run sudo nixos-generate-config.
  • You can also use an existing template:
Breeze-text-x-plain.png
/etc/nixos/configuration.nix
{ config, pkgs, lib, ... }:
{
  # NixOS wants to enable GRUB by default
  boot.loader.grub.enable = false;
  # Enables the generation of /boot/extlinux/extlinux.conf
  boot.loader.generic-extlinux-compatible.enable = true;
 
  # !!! If your board is a Raspberry Pi 1, select this:
  boot.kernelPackages = pkgs.linuxPackages_rpi;
  # On other boards, pick a different kernel, note that on most boards with good mainline support, default, latest and hardened should all work
  # Others might need a BSP kernel, which should be noted in their respective wiki entries

  # nixos-generate-config should normally set up file systems correctly
  imports = [ ./hardware-configuration.nix ];
  # If not, you can set them up manually as shown below
  /*
  fileSystems = {
    # Prior to 19.09, the boot partition was hosted on the smaller first partition
    # Starting with 19.09, the /boot folder is on the main bigger partition.
    # The following is to be used only with older images. Note such old images should not be considered supported anymore whatsoever, but if you installed back then, this might be needed
    /*
    "/boot" = {
      device = "/dev/disk/by-label/NIXOS_BOOT";
      fsType = "vfat";
    };
    */
    "/" = {
      device = "/dev/disk/by-label/NIXOS_SD";
      fsType = "ext4";
    };
  };
  */
    
  # !!! Adding a swap file is optional, but recommended if you use RAM-intensive applications that might OOM otherwise. 
  # Size is in MiB, set to whatever you want (though note a larger value will use more disk space).
  # swapDevices = [ { device = "/swapfile"; size = 1024; } ];
}

Note: the default configuration.nix will contain something like imports = [ <nixos/modules/installer/sd-card/sd-image-armv7l-multiplatform.nix> ]; do not include that in your final installation or you will experience interesting problems. It is only for building the installation image!

First rebuild on ARMv6 and ARMv7

To rebuild your system, run: sudo nixos-rebuild switch

Note: Instructions removed since they referred to a long abandoned user-provided cache...

Details about the boot process

On NixOS, all ARM boards are expected to use U-Boot as the firmware and bootloader. NixOS uses U-Boot's Generic Distro Configuration Concept as the mechanism to communicate boot information (such as path to kernel zImage, initrd, DTB, command line arguments). For a quick TL;DR about the generic distro configuration support: U-Boot is scripted to scan all attached storage devices & partitions and look for a file named /extlinux/extlinux.conf or /boot/extlinux/extlinux.conf (which will be generated by NixOS, just like /boot/grub/grub.cfg is generated on PCs). The partition needs to have its "bootable" flag set.

U-Boot also provides an interactive shell and the generation selection menu (just like GRUB). However, support for input or display devices varies greatly, depending on the board. Details for what the boards support in relationship to the boot process are detailed in their respective pages.

Porting NixOS to new boards

The easiest way

Assuming upstream U-Boot supports the board through a defconfig, it is possible possible to build U-Boot using the cross-compiling architecture from an x86_64 host. Here's a sample use.

# Assuming you're in a recent nixpkgs checkout
$ nix-shell \
    -I "nixpkgs=$PWD" \
    -p 'let plat = pkgsCross.aarch64-multiplatform; in plat.buildUBoot{defconfig = "orangepi_zero_plus2_defconfig"; extraMeta.platforms = ["aarch64-linux"]; BL31 = "${plat.armTrustedFirmwareAllwinner}/bl31.bin"; filesToInstall = ["u-boot-sunxi-with-spl.bin"];}'

For armv7 and armv6 pkgsCross.arm-embedded should work, this is available in the unstable channel (19.03 and following) by setting -I "nixpkgs=/path/to/new-nixpkgs-checkout.

This should build whatever is needed for, and then build U-Boot for the desired defconfig, then open a shell with the build in $buildInputs. Do note that this particular invocation may need more changes than only the defconfig if built for other than allwinner boards.

Here's an example command, for allwinner boards, on how to write to an SD card.

$ sudo dd if=$buildInputs/u-boot-sunxi-with-spl.bin of=/dev/sdX bs=1024 seek=8

The easy way

(if you're lucky)

If your board is an ARMv7 board supported by multi_v7_defconfig and you have access to U-Boot on the board, getting sd-image-armv7l-linux.img to boot is the easiest option:

  • If you're lucky and your U-Boot build comes with the extlinux.conf support built in, the image boots out-of-the-box. This is the case for all (upstream) Allwinner and Tegra U-Boots, for instance.
  • Otherwise, you can get the boot information (path to kernel zImage, initrd, DTB, command line arguments) by extracting extlinux.conf from the boot partition of the image, and then attempt to boot it via the U-Boot shell, or some other mechanism that your board's distro uses (e.g. uEnv.txt).

Building U-Boot from your NixOS PC

Assuming

  • Your board is supported upstream by U-Boot or there is a recent enough fork with extlinux.conf support.
  • You do not have nix setup on an ARM device
  • Your nix isn't setup for cross-compilation

It is still possible to build U-Boot using tools provided by NixOS.

In the following terminal session, replace orangepi_pc_defconfig with the appropriate board from the configs folder of U-Boot.

$ nix-shell -E 'with import <nixpkgs> {}; stdenv.mkDerivation { name = "arm-shell"; buildInputs = [git gnumake gcc gcc-arm-embedded dtc]; }'
$ git clone git://git.denx.de/u-boot.git
$ cd u-boot
# We're checking out a version from before the use of `binman`.
# The dtc package is 1.4.2, which does not include `pylibftd`.
# Furthermore, I do not know how to package the library so it would be
# available in the python interpreter, making binman happy.
$ git checkout v2017.03
$ make -j4 CROSS_COMPILE=arm-none-eabi- orangepi_pc_defconfig
$ make -j4 CROSS_COMPILE=arm-none-eabi-

The name of the final file will change depending on the board. For this specific build, and most Allwinner builds, the file will be named u-boot-sunxi-with-spl.bin.

You can flash this file to boot device with

 dd if=u-boot-sunxi-with-spl.bin of=/dev/sdX bs=1024 seek=8

Note: This mailing list contains a patch which may help some builds: https://lists.denx.de/pipermail/u-boot/2016-December/275664.html

The hard way

Alternatively/if all else fails, you can do it the hard way and bootstrap NixOS from an existing ARM Linux installation.

Contributing new boards to nixpkgs

  • Add a new derivation for your board's U-Boot configuration, see for example ubootPine64LTS in Nixpkgs-link.pngall-packages.nix.
  • If your board's U-Boot configuration doesn't use the extlinux.conf format by default, create a patch to enable it. Some C hacking skills & U-Boot knowledge might be required. For some pointers, see this patch to enable it on the Versatile Express.
  • Make a pull request, also containing the board-specific instructions.

Support

Only AArch64 is supported by NixOS.

All 32 bit ARM platforms are experimental for the time being.

There is a dedicated room for the upstream effort on Matrix, #nixos-on-arm:nixos.org.

Resources

Subpages

The following is a list of all sub-pages of the NixOS on ARM topic.