Skip to content

Arch Linux ARM

Minimal Image for the RPi2

Create the image file

For creating the image file we can exploit my favourite command dd. The command below, for example, creates a file of the size of 2GiB:

dd if=/dev/zero of=./image.img bs=2G count=1

Setup a loop device

In this step we create a loopback device so we can format and partition the image disk file like a normal block device file or hard disk. In short, a loopback device allows files to be interpreted as real block devices.

The next command setups the image file image.img as a loop device:

sudo losetup -f image.img

To list the status of all loop devices and to find out the corresponding loop device for our image, we can run losetup with the option -a:

losetup -a

In my case the loop device for my image file is /dev/loop0.

Partiton the image

Now that we setup a loopback device for the image, we can finally partition it using fdisk like any other hard disk:

fdisk /dev/loop0

At the fdisk prompt, delete old partitions and create a new one:

  1. Type o. This will clear out any partitions on the drive.
  2. Type p to list partitions. There should be no partitions left.
  3. Type n, then p for primary, 1 for the first partition on the drive, press ENTER to accept the default first sector, then type +100M for the last sector.
  4. Type t, then c to set the first partition to type W95 FAT32 (LBA).
  5. Type n, then p for primary, 2 for the second partition on the drive, and then press ENTER twice to accept the default first and last sector.
  6. Write the partition table and exit by typing w.

Once we have partioned the image file, we need to reload the partition table of the loop device. This can be done using partprobe which informs the OS of partition table changes.

sudo partprobe /dev/loop0

Format the partitions

In this step, we format the previously created partitions.

The first partition will contain the bootloader and must be formatted using the FAT filesystem:

sudo mkfs.vfat /dev/loop0p1

The second partiton will contain the root filesystem of the Arch system, which should be formatted using the ext4 filesystem:

sudo mkfs.ext4 /dev/loop0p2

Bootstrap the Arch system

In the following, we bootstrap the Arch system on the image file.

First we must create two empty directories so we can mount the two partitions of the image file:

mkdir boot root

Second, we mount both partitions as shown below:

mount /dev/loop0p1 boot
mount /dev/loop0p2 root

Third, we download and extract the Arch root filesystem to the mounted root partition (as root, not via sudo):

bsdtar -xpf ArchLinuxARM-rpi-2-latest.tar.gz -C root

Fourth, we need to move the boot files from the root filesystem to the first partition:

mv root/boot/* boot

Lastly, unmount the two partitions:

umount boot root

Testing the image on a RPi

Flash the image to a sdcard

Now that we have an Arch Linux image file, we can easily flash it to a sdcard. As before, we can use the handy dd command. In my case the sdcard is available under /dev/mmcblk0 on my system so the command looks as follows:

sudo dd if=./image.img of=/dev/mmcblk0 bs=4M status=progress && sync

Poweron and Login

Once the RPi is powered on, we can ssh into the Arch system, assuming we know the IP address. The default settings of an Arch Linux ARM are as follows:

  • Hostnane: alarmpi
  • User: alarm
  • Password: alarm
  • Root password: root

Resizing the root partition

As final adjustments, it's a good idea to resize the ext4 root partition so we don't run out of disk space. Otherwise, the root partition is limited to 1.9GiB.

Overall, extending a root partition at runtime is possible by simply using fdisk. So the steps are as follows:

  1. Delete the root partiton.
  2. Recreate the root partition.

Afterwards, the system should be rebooted and the root partition be resized using resize2fs.

sudo reboot
sudo resize2fs /dev/mmcblk0p2

Post Installation

Useful development tools

In case you intend to compile and develop some Arch Linux ARM packages, you should definitely install the following packges:

pacman -S base-devel 
pacman -S git vim zsh sudo wget
pacman -S python-pip ipython


Changing the hostname is just a matter of editing the files /etc/hostname and /etc/hosts.

echo chaotix > /etc/hostname

In case of the hosts file we should add an extra line like the one below. For example, I decided to use the hostname chaotix:   chaotix.localdomain chaotix

Custom DNS Nameserver

On ArchLinux|ARM DNS is managed by systemd. This means for setting a custom DNS nameserver you need to edit the file /etc/systemd/resolved.conf.

Basically, we just need to set a value for the DNS entry as shown below:


As one can see, multiple DNS nameservers are separated by a whitespace.

Create a new user

A default user on a new Arch Linux ARM system is the user alarm. If you like to create a new user you can do that as follows:

useradd -m -s /bin/zsh xander
passwd xander

As you can see, my new user is called xander and uses the awesome zsh shell :-).

Setup sudo

I often use sudo instead of a root account to administer my Linux systems, so I added my user account to the group wheel:

gpasswd -a xander wheel

To complete the sudo configuration, we must not forget to uncomment the first line starting with #%wheel in /etc/sudoers. In other words, remove the Hashbang # before %wheel. Also note that you should use visudo to edit the sudoers file.

Delete default user

And if you're like me and don't need the existing alarm user, you can simply remove the user from the image:

userdel -r alarm

Root password

Lastly, we should change the default root password of the Arch Linux ARM image:



In order to make the single board computer discoverable on the home network, we can install avahi and mdns. Overall, the installation procedure is the same as described on the Arch Linux Wiki.

pacman -S avahi nss-mdns

Once installed, we should adapt the /etc/nsswitch.conf so the hostname resolution using the .local naming scheme works:

hosts: ... mdns_minimal [NOTFOUND=return] resolve [!UNAVAIL=return] dns ...

And finally, to enable the avahi service on every boot, we can run the following systemctl command:

systemctl enable avahi-daemon.service


Install the i2c tools:

pacman -S i2c-tools

Add the line below to /boot/config.txt:


Add the following lines to /etc/modules-load.d/raspberrypi.conf:



To use I2C with python, you need to install the packages cffi and smbus-cffi:

pip install cffi smbus-cffi