Nura on Ivon's Blog

Chasing the Future of the Open Source Linux Ecosystem (Phones, Tablets, and Laptops All Running Linux)

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Mon, 16 Mar 2026 01:00:00 +0800

If Apple users have their own ecosystem: iPhone, iPad, Mac, Apple Watch, AirPods…

Why can’t we Linux users build an open source ecosystem of our own?

This is my final plan for that possible “doomsday”.

Open source Linux ecosystem, together, strong.

The phone is Linux, the tablet is Linux, and the computer is also Linux.

They are, respectively, Xiaomi Poco F1 + postmarketOS, Microsoft Surface Go 2 + Debian, and MSI Modern 15 + Fedora.

Although the distributions are different, they are all GNU/Linux free software systems, not Android and not ChromeOS, and they all run Wayland desktop environments.

Originally, Ubuntu Touch seemed more likely to realize the old dream of a unified cross-platform UI. Today, maybe we can do it with the Phosh desktop + GTK. Personally, though, I do not care that much about making the cross-platform design language perfectly consistent. KDE Plasma’s QT desktop on the computer side is not bad either.

The three devices can connect to each other through KDE Connect. Cloud syncing can be left to Nextcloud.

I am considering putting Linux on a smartwatch and Bluetooth earbuds too. If I buy a game console someday, I will install Linux on that as well. The Steam Deck is already a qualified Linux gaming machine. If I get a PS5 or Switch, I would also flash Linux onto them (assuming emulators work properly; otherwise it is better to leave them alone). In reality, though, Bluetooth earbuds and smartwatches are technically not very likely to run Linux… RTOS is more common there. Well, anything open source is welcome.

Ideally, the hardware should also be made by companies that support Linux. Unfortunately, they cannot deliver good full-stack hardware without charging an absurd premium. So I can only use third-party hardware and rely on community effort to make it run Linux.

Among companies that release hardware for a full-stack Linux ecosystem, the closest are probably Pine64 and Purism. Pine64 in particular has released a pile of cheap ARM devices assembled from Chinese components, much cheaper than Purism’s boutique gear. I almost bought the whole Pine64 family bucket. Then I learned about their product quality and decided: never mind.

This is the final plan I prepared for “doomsday”. If Android and iOS both get ruined, turn into mass surveillance machines, and strip people of their freedom, I will switch fully to Linux.

In reality, among the three Linux-running devices at the start of this article, only the computer side with a keyboard attached is relatively mature. After all, the average Linux user is a keyboard warrior, typing vim commands at disturbing speed. As for mobile devices with touchscreens, Linux is still maladapted. In other words, Linux cannot survive without a keyboard.

So for now, on mobile devices, I still mostly use an Android phone (near-stock system) + iPad.

Phosh: An Introduction to the Touch Desktop Environment for Linux Phones

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Sat, 28 Feb 2026 00:30:00 +0800

Question: Can a Linux system survive without a keyboard, using only touch input?

Introduction to Phosh
#

There are not many Linux desktops designed for mobile devices.

Existing KDE Plasma and GNOME desktops are hard to turn into touch-only interfaces, never mind tiny phone screens.

Currently, the options are: Phosh, KDE Plasma Mobile, SXMO, and Lomiri.

Phosh is simple and easy to use.

Plasma Mobile crashes too easily and force-fits KDE desktop logic onto a phone.

SXMO is modified from dwm and is for super hackers.

Lomiri is Ubuntu touch’s signature weapon.

Introduction to Phosh: this desktop environment was developed by Purism, a free software company. In the United States, Purism is a crowdfunding-based company that sells free hardware, the kind even more extreme than System76 and Framework.

They have also released a Linux tablet and Linux phone.

Phosh is the user interface for their Librem 5 phone. Or, in Linux terminology, it is called a desktop environment.

In the PinePhone community (sample size ~=1000), Phosh is the best-reviewed interface.

Based on my personal PinePhone experience, I think Phosh has a very bare interface, but it is also the most stable one.

There are not many full Wayland desktops right now. Besides KDE Plasma, GNOME, and Cosmic, most are pure compositors where you have to assemble the desktop components yourself. Not everyone wants to write a Sway config.

Phosh is one of the few options that is reasonably lightweight while still having complete functionality.

Features
#

Interaction designed for touchscreens first, mouse and keyboard second
Provides an on-screen virtual keyboard
Very low RAM usage, below 1GB
Not performance-hungry. As long as GPU 3D works properly, it can run even on awful processors. Animations are still very smooth on the seriously underpowered PinePhone (Allwinner A64), PineTab 2 (Rockchip RK3566), and Surface Go 2 (Intel Pentium 4425y).
Roughly speaking, system resource usage is close to Sway
Phosh is very useful for users who want pure touch operation. Most phones do not have a keyboard and mouse, so running traditional Linux desktops like KDE Plasma or GNOME feels awkward. Phosh, which is specially optimized for touch gestures, is an excellent choice.

Technical Points
#

Uses a Wayland compositor named Phoc, based on wlroots and written in Rust.
Uses some GNOME technologies and can use GTK themes
Can be used with either Systemd or OpenRC
PipeWire manages audio
ModemManager manages mobile networking
Uses feedbackd to handle keyboard vibration events and iio-sensor-proxy to handle screen rotation

Interaction Model
#

To match how mobile devices are used, every program window is maximized. Tap to open, swipe up to close.

There is also a touch keyboard, which automatically pops up where text should be entered.

Connect a keyboard and enable Docked mode, and you can move windows. At that point it becomes a stacking compositor, and windows are allowed to overlap.

App Store Ecosystem
#

Only a small portion of Linux mobile systems are designed as immutable distros, so root is writable.

They rely on deb or rpm packages packaged by each distribution. This easily creates fragmentation and inconsistent versions.

If you want something distro-agnostic, use Flatpak or Snap.

Phosh developers promote libhandy, allowing GTK programs to be optimized for touch devices. Many GTK4 programs on Flathub already have designs that adapt to screens of different sizes.

Chinese Input Method?
#

Long-press the bottom pill, and the Phosh touch keyboard pops up.

The current problem is that there is no Chinese keyboard.

Luckily, it allows simulating physical keyboard input events.

So you can use the touch keyboard to type Fcitx5 pinyin. It is a bit rough, yes.

Phosh provides Linux mobile devices with a desktop that can be daily-driven without relying on a physical keyboard.

The current issue is that the Phosh desktop is too minimal and purely function-oriented. Judging from recent updates, they are slowly adding practical features, such as a Pomodoro shortcut in the status bar.

References
#

postmarketOS Installation Guide: Building an Installer with pmbootstrap

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Fri, 10 Oct 2025 23:00:00 +0800

What is postmarketOS? For an introduction to postmarketOS, see this article.

This article explains how to install postmarketOS with pmbootstrap. As long as your device is on the official support list, you can follow these steps and install postmarketOS onto the device.

pmbootstrap is the official tool provided by postmarketOS. It can build a postmarketOS system from scratch, with fully customizable package contents, so you can control exactly which packages are installed and build your own system.

Besides building installation files, pmbootstrap is also used for porting new devices.

In this article, Ivon demonstrates manually building postmarketOS installation files on a computer and then flashing them to a phone. My computer runs Ubuntu LTS. The phone is a Xiaomi Pocophone F1 with the latest stock firmware installed, an unlocked bootloader, and TWRP installed as the recovery.

1. Install pmbootstrap
#

Refer to the instructions on pmbootstrap - postmarketOS Wiki.

Because it needs to create a QEMU virtual machine, pmbootstrap only supports x86_64 computers.

The first method, and the recommended one, is to install it with Git and a symbolic link. This gets you the latest version of pmbootstrap.

cd ~

git clone https://gitlab.postmarketos.org/postmarketOS/pmbootstrap.git

mkdir -p ~/.local/bin

ln -s "$PWD/pmbootstrap/pmbootstrap.py" ~/.local/bin/pmbootstrap

echo 'PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc

source ~/.bashrc

The second method is to install pmbootstrap with your Linux package manager. This is only suitable for rolling-release distributions, because the postmarketOS development team keeps changing things. If your pmbootstrap package is too old, trouble tends to find you.

# Alpine Linux, postmarketOS
apk add pmbootstrap

# Arch Linux
pacman -S pmbootstrap

# Debian
apt install pmbootstrap

# Fedora
dnf install pmbootstrap

2. Choose a Device and Configure Options
#

Run the pmbootstrap init command:

pmbootstrap init

Follow the prompts. During initialization, pmbootstrap downloads the latest device configuration files from GitLab.

# Press Enter to use the default work directory (~/.local/var/pmbootstrap)
Work path: Enter

# For the update channel, choose edge, or enter the stable release number marked Recommended for best stability.
Channel: edge

# Choose the phone vendor.
Vendor: xiaomi

# Choose the phone's device codename.
Device codename: beryllium

# Create the postmarketOS user account.
Username: User

# Choose the desktop environment. XFCE4 (X11) is suitable for devices without hardware acceleration; Phosh (Wayland, requires 3D acceleration) is suitable as a phone UI. You can install other desktop environments later after booting.
User Interface: phosh

# Use systemd as the init system? Recommended. Older postmarketOS releases used OpenRC.
Install systemd? (default/always/never) [default]: always

# Press Enter for everything else.

This is the setup you need to do before building installation files for a specific device. You have to tell pmbootstrap what your postmarketOS system should look like before it can start building the files.

3. Choose How to Install postmarketOS on the Phone
#

If this is an Android phone, make sure you install the latest stock firmware and unlock the bootloader before flashing.

This step is where the installation files are built. There are three main ways to install postmarketOS:

Flash with fastboot (wipes data, recommended)
Install to an SD card (does not affect the phone’s existing system, not recommended)
Flash with a recovery ZIP (wipes data, too slow, not recommended)

There are also some stranger installation methods, listed later.

Flash with fastboot
#

This method wipes all data on the phone.

Build the installation files:

pmbootstrap install

Put the phone into fastboot mode, connect it to the computer, and flash it:

pmbootstrap flasher flash_rootfs

# If the target partition is too small, add the --partition option and flash to another partition:
pmbootstrap flasher flash_rootfs --partition userdata

Then flash the kernel to the boot partition and reboot:

pmbootstrap flasher flash_kernel

fastboot reboot

Install to an SD Card
#

This method does not modify the phone’s data and can be used for a dual-boot setup, but booting into postmarketOS requires running a command from the computer. Note that some phones may not support booting a boot.img from fastboot.

Insert the SD card into the computer. Use lsblk to confirm the SD card device name and mount point:

sdb      8:16   1  29.7G  0 disk /media/ivon/E8D8-4246

Unmount it first:

umount /media/ivon/E8D8-4246

Then start the installation:

pmbootstrap install --sdcard=/dev/sdb

pmbootstrap automatically formats the SD card and installs the system onto it. During the process, it asks you to create a user password and confirms again whether you want to format the SD card.
Next, insert the SD card into the phone, put the phone into fastboot mode, connect it to the computer, and enter this command to boot:

pmbootstrap flasher boot

Install with a Recovery ZIP
#

This method wipes all data on the phone. You can sideload the ZIP or transfer it to the phone and install it with TWRP. However, building the ZIP takes a lot of time.

Build the recovery ZIP. This takes about five minutes.

pmbootstrap install --android-recovery-zip

# If you want to install to another larger partition, add the --partition option.

pmbootstrap install --android-recovery-zip --recovery-install-partition=data

Connect the phone to the computer and reboot into TWRP. Find the generated pmos-*.zip package in the computer’s work directory. For example, my file is under ~/.local/var/pmbootstrap/chroot_buildroot_aarch64/var/lib/postmarketos-android-recovery-installer.
Transfer the file to the phone, install it with TWRP, and then reboot.
Shut down pmbootstrap on the computer:

pmbootstrap shutdown

Other Flashing Methods
#

Netboot: temporarily boot with the postmarketOS boot.img, then mount the filesystem from the computer without wiping the phone’s data.
Boot with Netcat
Boot with NFS

4. Post-install Tweaks for postmarketOS
#

Even if the phone fails to boot into the desktop, you can still SSH into it while it is connected to the computer with a USB cable:

# This IP is fixed. Just change the part before "@" to your username.
ssh user@172.16.42.1

Assuming your device boots successfully into the postmarketOS desktop environment, and GPU acceleration, touch, networking, and audio all work, see this article next: postmarketOS tips. It covers postmarketOS configuration details and how to use postmarketOS as a phone operating system.

Try Phone Linux on a Computer: postmarketOS QEMU/KVM Virtual Machine Installation Guide

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Fri, 27 Jun 2025 11:00:00 +0800

The real phone version of Linux, postmarketOS, can already be installed on many older Android phones and give them something useful to do again. postmarketOS is a mobile Linux distribution based on Alpine Linux. It can run applications, including docker. Linux apps designed specifically for phones are also slowly appearing.

See here to learn how to install postmarketOS.

If your phone cannot flash postmarketOS, why not try it in a virtual machine on your computer? With a QEMU/KVM virtual machine, we can experience the current state of phone Linux interfaces. If you need to test apps for phone Linux, this VM is useful too.

postmarketOS officially provides a Generic x86_64 EFI System image, which can be installed on a normal x86 computer like other desktop GNU/Linux systems. However, postmarketOS is based on Alpine Linux, and the package repositories are mostly shared. So if you want to install it as your main desktop system, you might as well install Alpine Linux directly.

The main goal of this article is to set up a development and testing environment so you can see what postmarketOS looks like. Note: virtual machines have a hard time providing graphics acceleration, so Wayland desktop environments may render with bugs.

Below are two ways to install a postmarketOS virtual machine.

1. Install a QEMU Virtual Machine with pmbootstrap
#

Use pmbootstrap to customize your desktop environment. This method is suitable for developers.

pmbootstrap is the toolchain used to generate postmarketOS installation files and port new device models. Because pmbootstrap creates a chroot environment, the computer must be running Linux. A virtual machine is fine. WSL is not.

In this example, the host computer is Ubuntu. Install pmbootstrap with git:

git clone https://gitlab.postmarketos.org/postmarketOS/pmbootstrap.git

cd pmbootstrap

mkdir -p ~/.local/bin

ln -s "$PWD/pmbootstrap.py" ~/.local/bin/pmbootstrap

pmbootstrap --version

Enter the following command to start configuration:

pmbootstrap init

Next, answer a series of questions. The steps are explained below.

# Initialize.
pmbootstrap init

# Press Enter to use the default work directory (~/.local/var/pmbootstrap)
Work path: Enter

# For the update channel, choose edge, or enter the stable release marked Recommended for best stability.
Channel: edge

# Choose the vendor. Enter QEMU here.
Vendor: qemu

# Choose the AMD64 version. AARCH64 cross-architecture emulation is very slow and cannot use KVM acceleration.
Device codename: amd64

# Create the pmOS user account.

Username: User

# Choose the desktop environment. Phosh, which only supports Wayland, may fail to start, so choose Plasma Mobile or GNOME.
User Interface: plasma-mobile
# Press Enter for everything else.

Then install the system:

pmbootstrap install

Now boot it. pmbootstrap’s default RAM allocation is too small and will be painfully sluggish, so I recommend booting with the following command. It uses the host CPU, allocates 4GB of memory, sets the disk size to 32GB, emulates a phone portrait display, and enables audio. Enter pmbootstrap --help to view the available options.

pmbootstrap qemu --cpu max --memory 4096 --image-size 32G --video 720x1080 --audio pa

After booting, you can log into the system from the terminal opened by QEMU, or log in with SSH:

ssh user@VM_IP -p 2222

After booting, the VM window should enter the desktop. Resizing the window changes the display size automatically. The QEMU VM also grabs keyboard and mouse input automatically.

In this example, I chose Plasma Mobile as the interface. Its UI scales with the window. It descends from KDE Plasma, but has become an interface optimized for phones.

After installing the Discover software store, it can act as a frontend for downloading software. App sources are the postmarketOS and Alpine Linux repositories.

A terminal is still mandatory. Recommended packages: chromium, font-noto-cjk, and docker. You can use this to evaluate docker performance on postmarketOS.

Some software just feels like the desktop version. Some software automatically reshapes its UI according to the window size.

The files remain after this VM shuts down, but every time you run pmbootstrap init, the system automatically deletes the old filesystem. Remember to back up the QEMU image under ~/.local/var/pmbootstrap/chroot_native/home/pmos/rootfs/.

2. Manually Install a postmarketOS VM with Virt Manager
#

Boot the system with the official prebuilt postmarketOS image. This does not require pmbootstrap.

This method is a bit tedious because postmarketOS does not officially provide an .iso image. It provides an .img file instead, so you have to write it manually with dd. (Note: there is now an os-installer image, but it is mainly intended for installing on real hardware.)

Install Virt Manager on Linux.
Go to the postmarketOS website and download the Generic x86_64 EFI System image. For example, I chose the Phosh version.
After downloading, extract the .xz file. You will get an .img file.
Open Virt Manager and create a new virtual machine. Select Alpine Linux as the system. Choose UEFI for the boot firmware, VGA for the display card, and add a qcow2 virtual disk of at least 64GB. Do not boot it yet.
Before booting, mount the qcow2 file as an NBD device:

sudo modprobe nbd max_part=10

sudo qemu-nbd -c /dev/nbd0 /var/lib/libvirt/images/postmarketos.qcow2

Use dd to write the postmarketOS image, then remove the NBD device:

sudo dd if=postmarketos-phosh.img  of=/dev/nbd0 bs=4M status=progress conv=fsync

sudo qemu-nbd -d /dev/nbd0

Return to Virt Manager, boot the VM, and you can use the system.

References
#

QEMU - PostmarketOS Wiki

postmarketOS Tips: Installing Apps, Localization, Running Android Apps, and Docker

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Mon, 23 Jun 2025 13:00:46 +0800

postmarketOS is a phone-oriented Linux operating system based on Alpine Linux. It has already been ported to quite a few Android phones.

Related article: What is postmarketOS

postmarketOS has a graphical interface, but sometimes you still need the command line. If you need to type commands, SSH is usually the sane way to do it remotely. postmarketOS also provides terminal apps for the phone itself.

In this article, Ivon uses postmarketOS v25.12 with the Phosh desktop environment to demonstrate a few practical postmarketOS tricks.

1. How Phosh works
#

Phosh is a desktop environment designed for mobile devices. Its original author is Purism. Phosh is built with GNOME and wlroots technologies. Its Wayland compositor is phoc, its display manager is TinyDM, which is specially packaged by the postmarketOS maintainers, and its touch keyboard is Stevia. Stevia is a touch keyboard developed by the postmarketOS maintainers, and it has more features than the original Squeekboard.

If you install the system with an official postmarketOS image, the default user account is user and the password is 147147.

After unlocking the phone, you will see all applications. Long-press an icon to pin frequently used apps to the top.

After opening multiple applications, swipe up from the bottom of the screen to enter the multitasking view. Swipe left and right to switch apps. Swipe an app’s small window upward to close it.

Swipe down from the top of the screen to open quick settings. Use the upper-right buttons to lock the screen or power off.

Phosh has Docked and Undocked modes, and you can switch between them manually in quick settings. Undocked is the normal phone mode, where one app window fills the whole screen. Docked mode automatically turns on when you connect a physical keyboard or external display. It makes windows resizable and stackable, more like using desktop Linux.

To change the wallpaper and ringtone, install the postmarketOS Tweaks app:

sudo apk add postmarketos-tweaks

After opening this app, you can set the wallpaper, configure when sleep mode, also called suspend, should trigger, and choose whether to force app UI scaling for a small screen.

To let a specific app prevent the phone from sleeping, use the gnome-session-inhibit command:

gnome-session-inhibit –inhibit suspend <command>

2. Linux phone apps
#

App stores
#

Even though you can install desktop Linux applications on postmarketOS, including programs written with GTK and QT, not every Linux app works smoothly on a small screen. Some UIs do not reshape themselves automatically, so you have to test them yourself. See: Applications by category - postmarketOS Wiki

Phosh has an app store called GNOME Software. It can download apps from the postmarketOS APK package repositories and Flathub. You click to install apps just like on an Android phone, without typing commands.

Honestly, though, GNOME Software’s interface is not exactly smooth. The most convenient way to install software is still typing commands. Very futuristic, as always.

Flatpak and the GNOME Software plugin need to be installed separately before they show up:

sudo apk add flatpak gnome-software gnome-software-plugin-flatpak

flatpak remote-add --user --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

Tips for mobile Firefox
#

postmarketOS ships a modified Firefox with custom CSS, making it easier to operate with touch gestures. Its features are mostly the same as the desktop version, but it forces Duckduckgo as the search engine. Tap Firefox settings in the lower-right corner, then Search, then restore the default search engine, and you can use Google Search.

Firefox’s default User Agent here is “Firefox on Android.” You can install User-Agent Switcher and Manager to switch the User Agent.

Maps and navigation
#

Go to system Settings -> Privacy and enable location access, then install a maps or navigation app.

I recommend installing Pure Maps through Flatpak. It can be used for navigation.

Running Android apps with Waydroid
#

Use an LXC container to run Android apps. See Waydroid + postmarketOS

Remote desktop
#

Most postmarketOS desktop environments use Wayland. Phosh is a Wayland desktop based on wlroots.

If your device’s Type-C port does not support HDMI output, how do you project it to a large screen?

Answer: share it with WayPipe or WayVNC.

3. postmarketOS Chinese localization and input methods
#

Phosh on postmarketOS partially supports Chinese. Common apps like Firefox also support Chinese.

At the time of writing, the Phosh environment still does not have a “touch” Chinese input method. In that case, you can use the built-in touch keyboard to emulate physical keyboard input, then pair it with Fcitx5 Pinyin to type Chinese.

First, install Chinese fonts and Fcitx5 packages. If the packages built by postmarketOS do not work, try the Flatpak version of Fcitx5.

sudo apk add font-noto-cjk fcitx5 fcitx5-chinese-addons fcitx5-configtool fcitx5-gtk4 fcitx5-gtk3 fcitx5-qt

To change the system language to Chinese, open Settings -> System -> Region & Language, change it to Chinese (Taiwan), then log in again.
Edit the environment variables:

sudo vim /etc/environment

Add the following content:

# Specify the input method framework
GTK_IM_MODULE=fcitx # If you are running pure Wayland apps in GNOME, you do not need this line
QT_IM_MODULE=fcitx
XMODIFIERS=@im=fcitx
SDL_IM_MODULE=fcitx
GLFW_IM_MODULE=ibus

# Force the locale environment variables
LANG=zh_TW.UTF-8
LC_CTYPE=zh_TW.UTF-8
LC_NUMERIC=zh_TW.UTF-8
LC_TIME=zh_TW.UTF-8
LC_COLLATE=zh_TW.UTF-8
LC_MONETARY=zh_TW.UTF-8
LC_MESSAGES=zh_TW.UTF-8
LC_PAPER=zh_TW.UTF-8
LC_NAME=zh_TW.UTF-8
LC_ADDRESS=zh_TW.UTF-8
LC_TELEPHONE=zh_TW.UTF-8
LC_MEASUREMENT=zh_TW.UTF-8
LC_IDENTIFICATION=zh_TW.UTF-8
LC_ALL=

Click the Fcitx5 icon and enable the Pinyin input method.
In Phosh, you need to long-press the pill bar at the bottom of the screen to bring up the on-screen keyboard. The touch keyboard will not appear in Docked mode. One of the keyboard modes is the “Terminal” layout, which can emulate physical keyboard input events. Press CTRL+Space to wake up Fcitx5’s Pinyin input method.

4. postmarketOS system administration
#

postmarketOS is based on Alpine Linux and inherits its package manager: APK (Alpine Package Keeper). This APK has nothing to do with Android APKs.

Usually, you can find a terminal app on a newly installed system.

postmarketOS uses doas to elevate user privileges. When you run the sudo command, it is actually linked to doas. If you use an official postmarketOS image, the default user account is user and the password is 147147.

Package management
#

Use the following commands to update system packages:

sudo apk update

sudo apk upgrade

If you installed the Stable Release of postmarketOS, you can use the following commands to upgrade whenever a major version is released, for example v24.06 -> v24.12:

sudo apk add postmarketos-release-upgrade

sudo postmarketos-release-upgrade

Reboot command:

sudo reboot

Poweroff command:

sudo poweroff

Use the following command to search for packages:

sudo apk search "package name"

Install a package:

sudo apk add "package name"

Remove a package:

sudo apk del "package name"

Service management
#

postmarketOS uses Systemd as its init system. Versions before v24.12 used OpenRC, and versions after v25.06 switched to Systemd. Users can freely choose OpenRC or Systemd during the pmbootstrap init stage, but the official prebuilt system images use Systemd.

Systemd-related commands:

# Stop or start a service with systemctl, such as docker:
sudo systemctl stop docker
sudo systemctl start docker

# Use systemctl to make a service start automatically at boot:
sudo systemctl enable docker

OpenRC-related commands:

# Stop or start a service with rc-service, such as docker:
sudo rc-service docker stop
sudo rc-service docker start

# Use rc-update to make a service start automatically at boot:
sudo rc-update add docker

Firewall
#

postmarketOS uses iptables as its default firewall. Install UFW if you want easier management:

sudo apk add ufw

sudo systemctl enable --now ufw

# Deny all incoming connections
sudo ufw default deny incoming

# Allow the SSH port
sudo ufw allow ssh

# Reload rules
sudo ufw reload

5. Network connections
#

Wifi network
#

Just like on a normal phone, to get online through the graphical interface, tap Settings on the Phosh desktop, then Mobile Network or Wifi.

In the terminal, use ip addr to check network interfaces, then connect with nmcli:

sudo nmcli dev wifi connect "Wifi name" password "Wifi password" ifname wlan0

sudo nmcli device set wlan0 autoconnect yes

If the phone cannot get online, you can also reverse-share a Linux computer’s network connection to the phone with USB Networking.

Mobile network
#

If the graphical interface cannot enable the 4G network, use the following commands.

Confirm that the ModemManager service is enabled:

sudo systemctl status modemmanager

Use sudo nmcli d to check network status:

DEVICE TYPE STATE        CONNECTION
qrtr0  gsm  disconnected --

Try automatically connecting with APN:

sudo nmcli con add con-name "modem" type "gsm" ifname "qrtr0" auto-config "TRUE"

Bring up the connection:

sudo nmcli c up "modem"

To enable 4G hotspot sharing: on the Phosh desktop, open Settings -> Wifi, turn on Wifi, then tap the upper-right corner to turn on the mobile hotspot.

SSH connection
#

After installing postmarketOS, you can connect the phone to a computer and make it an RNDIS device. Then SSH from the computer into the system. The IP is fixed. Use sudo systemctl status sshd to confirm whether the phone’s SSH service is running:

ssh username@172.16.42.1

If the phone itself is connected to the network, you can also connect through its local IP:

# Enable SSH on the phone
sudo apk update
sudo apk add openssh
sudo systemctl start sshd
sudo systemctl enable sshd

# Check the phone's IP
ip addr

# SSH from the computer to the phone
ssh username@LAN_IP

Set the time zone and correct the time
#

Use a symbolic link to set the time zone to Taipei:

sudo ln -sf /usr/share/zoneinfo/Asia/Taipei /etc/localtime

You can also use Alpine Linux’s script to correct the time automatically:

sudo setup-timezone
# Enter Asia/Taipei

Or configure automatic time synchronization at boot:

sudo apk add systemd-timesyncd

sudo systemctl enable systemd-timesyncd

How to Run Linux on a Phone: A Few Ways to Try It

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Fri, 28 Mar 2025 13:00:00 +0800

Want to install Linux on a phone and run desktop programs? Strictly speaking, those are two different ideas. After a long stretch of trying this stuff myself, Ivon put together this article to share the results.

With today’s technology, there are two main ways to run Linux on a phone:

Use an app to emulate a Linux environment
Delete the phone’s operating system and flash it with a real Linux system

Let’s first look at the pros and cons of these two methods. At the end, we will also discuss option 3: buying a real Linux phone.

1. Use an App to Emulate a Linux Environment
#

By “emulate,” I mean using an app to emulate a Linux system environment, mostly as an auxiliary tool. The upside is that almost every phone can install one. The downside is that what you can do is limited. Running terminal commands is fine, but containerization and virtualization are basically out.

Emulating a Linux environment with an app does not require root or jailbreaking, so it works for most devices. How Linux fits into your life is up to you, but starting with apps like Termux is a decent entry point. You might even get a taste of the free and open source software spirit. Once you are ready, then go play with Linux phones.

Android
#

This includes Android phones and Android tablets, but not ChromeOS.

Termux
#

Related article: Termux usage guide

Termux works on most Android phones and supports Android 7 and later. It does not require root.

Termux is not a virtual machine. It provides a Linux-like environment and then tries to run programs with native performance. Termux also provides proot-distro (using ptrace to emulate chroot functionality) for installing Linux distributions. Combined with Termux X11, it can run the X Window System and Linux graphical programs, then use VirGL to achieve 3D graphics acceleration.

Running Linux graphical programs on Android through Termux

But even if you use proot-distro to install another Linux distribution container, that system is still constrained by Android, and it is hard to access hardware-level operations.

Termux is more of an auxiliary tool that mixes into the Android ecosystem. In this kind of Linux environment, you can write small Python, Java, or C++ programs, run office software, and play some little Linux games. Since Termux can access some Android system files, batch-converting videos with ffmpeg also works.

If the phone has root access, installing a Linux container with chroot and pairing it with Busybox lets you do a bit more.

Related article: Create a chroot Ubuntu environment on a phone with Termux, no Linux Deploy needed

But chroot is still limited by Android’s trimmed-down Linux kernel. For example, Android kernels generally lack the cgroups kernel modules, so Docker still will not run. chroot is better suited for doing some system modification work together with Magisk.

QEMU
#

The options here are more limited and not as versatile as Termux.

The emulator software “QEMU” has Android ports. Termux includes QEMU packages, and some people have made standalone apps, including Limbo PC Emulator and Vectras VM.

Related article: Run an x86_64 Ubuntu virtual machine on a phone with QEMU

What about using QEMU to run an ARM Linux virtual machine? Sorry, most Android phones do not have the KVM kernel module, so VM performance is miserable. Even at the time of writing, with 2025 flagship phones, they are only good enough for Windows XP or a text-only Linux VM.

An Ubuntu virtual machine running on an Android phone through QEMU

Google Pixel phones are the exception. Pixel phones with Tensor processors support pKVM virtualization, so Limbo PC Emulator runs very quickly, even Windows 11 ARM. You need this custom Limbo build: Limbo For Tensor-based devices

In addition, Google Pixel phones running Android 16 or later can run Linux virtual machines through the AVF framework. See: Google slips built-in terminal, Debian Linux VM into Android 15 March feature drop

iOS
#

This includes iPhone, iPad, and iPod touch devices.

iSH Shell
#

Related article: iSH Shell usage guide

iSH Shell on iOS is an app that emulates 32-bit Alpine Linux. Its text-only interface is suitable for running some Python scripts and serving as an SSH client.

Running simple terminal programs on an iPad with iSH Shell

Because iSH’s filesystem can be opened with the Files app, you can drop files into the Linux environment for processing, such as batch-converting photos with ImageMagick. In that sense, iSH is similar to Termux on Android: a Linux environment mixed into the iOS ecosystem.

The downside is that iSH Shell is a plain x86 emulator. It is only compatible with 32-bit packages, and some instruction sets are not implemented yet, so some programs may fail.

UTM
#

Related article: UTM usage guide

UTM is virtual machine software. With JIT acceleration enabled, or virtualization enabled after jailbreaking, it can run VMs for other systems at high performance. It is especially suitable for iPad.

Combined with Apple’s obnoxiously strong processor performance, high-end iPads with M-series chips have already been proven capable of handling Windows 11 ARM. Linux, naturally, is not a problem.

Running an Alpine Linux virtual machine on an iPad with UTM and sharing a folder with the host

The downside is that Apple only allows the unaccelerated “UTM SE” on the App Store. That version of UTM even struggles with Windows XP. The normal version of UTM must be sideloaded. Whether you use JIT acceleration or jailbreak to enable virtualization, the setup process is tedious and not very practical.

2. Flash the Phone with a Real Linux System
#

Even after jailbreaking, iOS devices cannot be flashed with other systems, except for the special case of Project Sandcastle on the iPhone 7. What about relatively open Android devices? In reality, there are not that many Android phones that can be flashed with Linux either.

The Linux systems discussed here do not include Android. That includes LineageOS, GrapheneOS, ClayxOS, and similar systems. They are Android variants, not Linux in the sense used here. Some people will ask: does Android not count as Linux? It does, and also does not. Android uses the Linux kernel, but its architecture is very different from desktop GNU/Linux. The “real Linux phone systems” discussed below are designed more like desktop GNU/Linux systems, not Google’s heavily modified result. A shorter way to say it: these systems keep the root user available by default, instead of removing it Android-style.

So what choices are there for phone Linux systems? Right now, there are more than a dozen “real Linux phone system” distributions outside of Android. The two strongest players are “Ubuntu Touch” and “postmarketOS.” These two Linux distributions support the largest number of phones and have been ported to many Android devices.

You need to buy a phone suitable for flashing. Even if a phone has many Android ROMs available, that does not mean it can be turned into Linux. Want to know which phones are suitable? Check the postmarketOS Wiki and Ubuntu touch Wiki.

Ubuntu touch
#

Related article: Ubuntu touch installation guide

Ubuntu touch appeared the earliest, back in 2014. It was originally supposed to push further into phones, then after a few years its parent company Canonical abandoned it and it became maintained by the open source community.

Ubuntu touch has its own desktop environment, with a fairly complete UI design and even Chinese input methods. As a feature-phone-style system, it passes. Ubuntu touch’s system partition is read-only like Android’s. Even if you access it with root privileges, the next OTA update will overwrite your changes. To run desktop Linux programs, you need to enable an LXC container and install them there.

A Redmi Note 5 running Ubuntu touch

Ubuntu touch developed a porting method based on Halium, which mixes in Android drivers and trades away some free software purity for compatibility. Because of this, Ubuntu touch has better compatibility with Android phone hardware and is easier to port.

It supports running Android apps through Waydroid.

postmarketOS
#

Related article: postmarketOS installation guide

postmarketOS, which appeared around 2019, is more like a desktop GNU/Linux distribution. Its graphics stack uses Wayland or X11, and you can freely choose the desktop environment you want. The system partition is yours to modify, and if performance is good enough, Docker and virtual machines are fair game too.

postmarketOS emphasizes that ported devices must use the latest mainline Linux kernel, and drivers should use open source versions as much as possible. It gave up Ubuntu Touch’s Halium-style compromise and took the real GNU/Linux phone route.

A Xiaomi Poco F1 running postmarketOS

Maybe because postmarketOS is more free than Ubuntu touch, “Linux phone apps” actually have room to exist. The GNOME and KDE communities have successively developed apps and SDKs that adapt to different screen sizes, letting developers reuse existing GTK and Qt technologies to build Linux phone apps.

It supports running Android apps through Waydroid.

3. Buy a Real Linux Phone
#

Besides flashing an Android phone into Linux, you can also buy a phone that ships with Linux from the factory. Since dedicated development teams maintain them, they avoid many of the problems you run into when flashing Linux onto Android hardware. Their hardware is usually fairly open too, so you can freely install other Linux distributions maintained by community members.

A PinePhone playing video

That said, these Linux phones may not be more usable than Android, and the price-to-performance ratio is not great. They are for users willing to get their hands dirty. Real Linux phones look powerful, but the ecosystem is still immature. At the moment, they can mostly satisfy calling and web browsing, and users need a strong tinkering spirit to stick with them. Open source may slowly fill the ecosystem gaps, but people who use Linux phones should have at least some command-line literacy.

Currently, phones that ship with Linux instead of Android include:

FuriLabs FLX1 (2024), ships with FuriOS, based on Debian.
Purism Liberty Phone (2023), ships with PureOS, based on Debian
Purism Librem 5 (2020), ships with PureOS, based on Debian
Pine64 PinePhone Pro (2022), ships with Manjaro, can install more than a dozen other distributions
Pine64 PinePhone (2020), ships with Manjaro, can install more than a dozen other distributions
Volla Phone (2020), ships with Ubuntu touch
Fxtec Pro1X (2020), ships with Ubuntu touch

Back Up an Android Phone's postmarketOS Partitions to a PC

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Mon, 06 Jan 2025 21:00:00 +0800

Backup postmarketOS partitions of Android phone.

This article discusses how to back up data from postmarketOS system partitions.

postmarketOS has plenty of backup tools, such as rsync and Timeshift, which can restore the system to a previous state. Linux has more complete permissions than Android, so in theory you can back up any directory. If the phone supports the Linux mainline kernel, then you can make even better use of BTRFS snapshots.

However, this article is about a “full device backup” approach. I want a one-to-one backup of the phone data, so it can be restored to a previous state with one command.

1. postmarketOS and Android Partitions
#

When installing postmarketOS on the PinePhone, we can use Tow-Boot to make the PinePhone appear as a disk. After plugging it into a computer, we can use the dd command to extract the entire system image and back up the whole system.

But many postmarketOS devices are converted from Android phones, and their partition tables are inherited from Android. So we need to back them up the Android way.

Devices before Android 9 often used A/B partitions, while devices after Android 10 mostly use dynamic partitions. Every device is different. Take the Xiaomi Poco F1 as an example: postmarketOS is flashed through fastboot to the boot and userdata partitions, while the other partitions remain in their original Android state. Therefore, Fastboot and Recovery can still be used.

In theory, those two partitions can be extracted as full partition image files from the Android Recovery interface using ADB commands.

Because this is a full device backup, the required space can easily exceed the phone’s own storage capacity. Store the extracted image files on a larger SD card or on a computer. I recommend using a USB 3 or faster port for transfer.

2. Back Up postmarketOS Partitions
#

Xiaomi’s stock Recovery does not have ADB support, so I used LineageOS recovery. Backing up with TWRP also works, but TWRP is not available for every phone.

Reboot the phone into Fastboot mode.
Download Recovery from the LineageOS website and flash it.
Reboot into LineageOS Recovery:

fastboot reboot recovery

Tap the Advanced menu and enable ADB.
Connect the phone to the computer.
Pull the partitions to the computer:

adb pull /dev/block/bootdevice/by-name/userdata userdata.img

adb pull /dev/block/bootdevice/by-name/boot boot.img

Now we have two img files.

3. Restore postmarketOS Partitions
#

Restoration test:

Reboot into postmarketOS.
Delete some files.
Flash the img files back. This time, use fastboot:

fastboot flash boot boot.img

fastboot flash userdata userdata.img

After rebooting, it should return to the previous state.

You might ask: if the phone system is flashed back to Android, can this method still restore the postmarketOS data? Pretty risky. The partition table may get messed up.

References
#

Running postmarketOS on Android Termux proot without flashing a custom rom

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Sat, 16 Nov 2024 21:00:00 +0800

閱讀中文版

Running postmarketOS and Phosh on Android phone without rooting or flashing a custom ROM.

I’ve taken the unofficial and weird approach of running postmarketOS on Termux Proot, so that we can run mobile Linux on Android.

A video demonstration. Phosh + postmarketOS runs on Sony Xperia 10 V Android 14.

1. Motivation
#

Why do I do this? To explore the possibilities of running mobile Linux on an Android phone. And we needed a desktop environment designed for touchscreens.

It’s my personal wish to run mobile Linux on my Sony Xperia 5 & 10 series, but not many people have ported postmarketOS for them, and I didn’t succeed myself. So I’m just using Termux to taste the sweetness of the mobile Linux OS. I would like to share this highly experimental method of running postmarketOS on Android with you.

postmarketOS is a GNU/Linux system designed for out-of-season mobile phones. Based on Alpine Linux, it has full Linux functionality and is able to run Linux pc applications, and it has become one of the most popular distro choice among PinePhone users. However, postmarketOS is not available for all Android phones, see postmarketOS pmbootstrap installation instruction. In order to port a postmarketOS to an Android phone, you need to pacth the Linux kernel a lot, and since many drivers are not compatible between Android and Linux, it is more difficult to create a postmarketOS ROM than to port LineageOS. Even if you finally get it up and running, there will be lots of missing proprietary drivers, which makes the system unpleasant to use.

Moreover, the entry barrier for installing postmarketOS is very high, and for many mobile phone users, they can’t even unlock the bootloader, so it’s impossible to flash a custom ROM. This makes Termux a good option to consider, as it allows you to run Linux containers on your Android without rooting, and display the Linux container X server screen with Termux X11. The first question we have to ask is whether pmbootstrap can be run on Termux. According to this Github issue, chroot is hard to run on Android without rooting. So we use a slower proot instead.

Termux provides rootfs for Alpine Linux, and postmarketOS is originally based on Alpine Linux, so if you do a little trick to convert Alpine Linux to postmarketOS, you can get those packages designed for mobile Linux. Why don’t we use Alpine Linux directly, because some packages of postmarketOS are not being upstreamed, some packages are not found in Alpine Linux’s repsitory.

Finally, let’s talk about Phosh, a desktop environment developed by Purism, a free software company, designed for Linux phones. Its Wayland compositor, Phoc, is based on wlroots. In the PinePhone community, Phosh is one of the best rated interfaces. According to my personal experience of using PinePhone, I think Phosh is the most stable interface although the interface is very simple, and Phosh is very resource-saving. The animation of Phosh is still very smooth even running on the underpowered PinePhone which equipped with Allwinner A64 processor. I think Phosh is very useful for users who want to interact with Linux system in Termux X11. Because most Android phones don’t have keyboard and mouse, so if you run XFCE, KDE Plasma, GNOME and other traditional Linux desktops in Termux X11, it would be very awkward. So that , the touchscreen-optimized Phosh would be an excellent choice.

However, you may ask, Phosh is a Wayland compositor, how can it run on Termux X11? Although we cannot use Wayland directly, the nested Wayland session under X11 is still possible. Some compositors can do this, such as Weston or Cage. Some features of Wayland can still be used even running under X11 environment. However, simply running cage will result in an incomplete X session and no way to detect the resolution of the phone. So before running cage, I will start a X window manager in the first place. I choose Openbox for performance-wise.

2. Prerequisites
#

Termux
Termux X11
virglrenderer: Optional hardware acceleration.
Hacker’s keyboard: For interacting with the desktop environment. It can simulate PC keyboard inputs which would be very useful.

3. Install Proot Alpine Linux
#

postmarketOS provides two updating channels, Edge and Stable. The version number of Stable channel can be found in Wiki, currently it is v24.06.

The default Alpine Linux of Termux proot uses Edge branch, but this branch is unstable, so I suggest to switch it to Alpine 3.20 (corresponding to postmarketOS v24.06).

P.S. At the time of writing, I am using Edge repo for getting latest packages in order to make Phosh launch through Cage. But for stability, you may choose the stable channel.

Start Termux and install proot Alpine Linux.

pkg update

pkg install proot-distro pulseaudio

proot-distro install alpine

Change the Alpine Linux repository from Edge to v3.20.

proot-distro login alpine --shared-tmp

apk update

apk add vim

vim /etc/apk/repositories

# Change "http://dl-cdn.alpinelinux.org/alpine/edge/main" to "http://dl-cdn.alpinelinux.org/alpine/v3.20/main"
# Change "http://dl-cdn.alpinelinux.org/alpine/edge/community" to "http://dl-cdn.alpinelinux.org/alpine/v3.20/community"

apk update

apk upgrade

Add a new user, add it to sudo group, and set the timezone

apk add sudo

addgroup storage

adduser -g wheel,storage,video,audio user

visudo

sudo ln -sf /usr/share/zoneinfo/Asia/Taipei /etc/localtime

sudo setup-timezone

Enable SSH remote connection in Termux proot.

sudo vim /etc/ssh/sshd_config

# Change `Port` from 22 to 8023

ssh-keygen -A

rc-update add sshd

rc-serive sshd start

# Check the IP address.
ip addr

4. Convert Alpine Linux installtion to postmarketOS
#

Add the postmarketOS v24.06 (Alpine v3.20) repository.

vim /etc/apk/repositories

# Add this line at the top:
https://mirror.postmarketos.org/postmarketos/v24.06

# For your reference, the url of the Edge channel is: https://mirror.postmarketos.org/postmarketos/master/

Install postmarketos-keys

apk add -u --allow-untrusted postmarketos-keys

apk update && apk upgrade

Add the following lines to /etc/os-release

PRETTY_NAME="postmarketOS v24.06"
NAME="Nura"
VERSION_ID="v24.06"
VERSION="v24.06"
ID="postmarketos"
ID_LIKE="alpine"
HOME_URL="https://www.postmarketos.org/"
SUPPORT_URL="https://gitlab.com/postmarketOS"
BUG_REPORT_URL="https://gitlab.com/postmarketOS/pmaports/issues"
LOGO="postmarketos-logo"

5. Installing Phosh desktop environment
#

Install Openbox and Cage:

sudo apk add openbox cage

The Phosh package name is postmarketos-ui-phosh. It is recommended to install some of the mobile device packages made by postmarektOS along with it:

sudo apk add postmarketos-ui-phosh \
postmarketos-tweaks \
firefox \
mobile-config-firefox \
font-noto \
font-noto-cjk \
font-noto-cjk-extra \
font-noto-emoji

6. Launch Termux X11 and Phosh
#

The inspiration to start Phosh in proot comes from phosh-vnc and termux-phosh, although running it with WayVNC is one way, why not make good use of Termux X11 for better performance?

The process of starting Phosh desktop is as follows: start PulseAudio audio server on Termux side, start Termux X11, then log in to Proot Alpine, start Openbox, cage and Phosh.

The whole process is as follows:

Luanch Termux and start Pulse Audio

pulseaudio --start --exit-idle-time=-1
pacmd load-module module-native-protocol-tcp auth-ip-acl=127.0.0.1 auth-anonymous=1

Luanch Termux X11 APP and start Termux X11 in Termux

export DISPLAY=:0

termux-x11 :0 &

Start virglrenderer

virgl_test_server_android &

Log into Alpine Linux

proot-distro login alpine --user user --shared-tmp

Launch Openbox, cage, Phosh

export DISPLAY=:0

export XDG_RUNTIME_DIR=/tmp

openbox &

cage phoc -E '/usr/libexec/phosh' -U &

In Termux X11 wait for the Openbox window to come out, double click on the title bar to maximize it.
Tap Preferences in your phone’s notification bar and set Termux X11’s Output to Scaled to zoom in to a size that fits your phone.

And change the Termux X11 Pointer to Direct Touch to simulate a touch screen.

7. Phosh user experience
#

Most of the touch gestures work. The control logic of Phosh is to swipe up from the bottom to view all the tasks, and swipe up to close the app window.

Note Phosh in proot is not a full Linux environment, so some functions are not available.

For example, Phosh uses GNOME Control Center to adjust system settings, but the GUI app cannot be opened, so many places have to be changed with commands. For example, to modify the file manager Portfolio to open the app with a specific file format preset, you should use xdg-mime to modify it. Also GNOME Software doesn’t work, please use apk command to install the apps.

Regarding Chinese input methods: Phosh’s built-in Squeekboard only supports English. Press and hold the bar at the bottom of Phosh to activate it (it seems that it doesn’t work in proot environment). In order to type Chinese, you’ll have to use your Android phone’s keyboard.

You can wake Android keyboard by pressing the back button in the Termux X11 APP. And then scroll the toolbar at the bottom to left to type charcters.

8. Let’s try other desktop environments?
#

Besides Phosh, the desktop environments of postmarketOS are Plasma Mobile and SXMO, but I think they have more problems, one is unstable and the other is too complicated.

Plasma Mobile

Plasma Mobile is a desktop envrionment based on the PC version of KDE Plasma, which can be launched with X11 or Wayland backend.

Personally, I think this desktop envrionment is very unstable, so it is better to use the PC version of KDE Plasma.

Packages name: postmarketos-ui-plasma-mobile。Launch in X11: startplasma-x11. Launch in Wayland: startplasma-wayland

You can start Plasma Mobile X11 session by: dbus-launch --exit-with-session startplasma-x11 &

SXMO

The package name is postmarketos-ui-sxmo but Termux X11 only support X server so I choose postmarketos-ui-sxmo-de-dwm.

Install SXMO packages

sudo apk add postmarketos-ui-sxmo-de-dwm postmarketos-tweaks-sxmo-x11 feh dwm svkbd conky clickclack

Execute: export XDG_RUNTIME_DIR=/tmp before launching SXMO.
SXMO can be launched by executing dbus-launch --exit-with-session /usr/bin/sxmo_xinit.sh &
The configuration files of SXMO is located at ~/.config/sxmo/. Hooks are at /usr/share/sxmo/default_hooks/.

Gestures are not working.

You may modify dwm source code to change default keybindings.

git clone git@git.sr.ht:~mil/sxmo-dwm
# Modify config.def.h then reinstall dwm

Uninstall sxmo-dwm package before installing your cutsom dwm.

Or you can just install vanilla dwm package and use default dwm keybindings.

References
#

Installing Linux on an iPhone 6: Run postmarketOS Through a checkra1n Jailbreak

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Mon, 07 Oct 2024 08:00:00 +0800

For attempts at running Linux on iOS devices, I have previously discussed iSH Shell terminal and the UTM virtual machine approach. This time I am going to try installing Linux directly on an iPhone.

1. Background
#

checkm8 is arguably Apple’s biggest vulnerability in recent years. Combined with checkra1n, it can complete the jailbreak process before boot. In 2020, some wizard put together Project Sandcastle and successfully ran Android 10 on the iPhone 7. The author also started porting the Linux kernel. Even though Apple almost sued them, the project is still under development.

Recently, people have already developed LineageOS ports, such as Android device tree for “snowcastle”, which can run the latest Android 16 on supported iPhones.

A few years later, more developers tried running Linux on other iPhones. The vulnerability checkm8 relies on only supports A7 to A11 chips, meaning devices from the iPhone 5S through the iPhone X. Older or newer devices do not work.

Ideally, the iPhone 7 is currently one of the better-supported devices. It can mount postmarketOS on AFPS and boot, and some developers have even gotten Wayland running on it. Unfortunately, I do not have one.

I have two old iOS devices that support checkm8: an iPhone SE (iOS 15) and an iPod touch 6 (iOS 12). There are many successful Linux boot cases online, but they do not mention their iOS versions. On iOS 15 and later, you can only jailbreak with palera1n, and you need to use the command palera1n -p -f to start the pongoOS Shell. I tested it and ran into other problems. So I switched to the iPod touch 6 for testing. Its processor is similar to the iPhone 6, so it should theoretically work.

So how do we run Linux? First, enter the pongoOS Shell through checkra1n, then boot Linux from there.

Which Linux distro should we pick? Although someone on Reddit successfully compiled Ubuntu and booted it, and someone on Twitter got Asahi Linux running (see references at the end), there are more successful photos on the postmarektOS Wiki. Also, that community pays more attention to mobile Linux, so I used that distro as the base for this attempt.

There are two possible approaches after that. One is to compile Linux into a ramdisk and boot it; after rebooting, the data disappears.

The second is to use the Netboot feature provided by pmbootstrap for network booting. Data still disappears after reboot, but the rootfs stays on the computer.

So, strictly speaking, none of this is really “installing” Linux on an iPhone. The system is not actually written to the iPhone’s storage; it only boots Linux temporarily. At the moment, no matter which method you use, you still need a computer to guide the device into Linux.

2. Requirements
#

A Linux or Mac computer. I used Ubuntu 24.04.
An iOS device that supports checkra1n, meaning A7 to A11 chip devices from the iPhone 5S through the iPhone X. I used an iPod touch 6 running iOS 12.5.7.
Lightning to USB OTG adapter, mouse, and keyboard. Linux has no touch driver, so after the iPhone boots you need to control it with a keyboard and mouse. If you are comfortable controlling X11 with SSH commands, you can skip these.

3. Compile pongoOS
#

pongoOS is the program that runs before loading the iOS XNU kernel.

Before compiling pongoOS, you need checkr1an. (paler1an does not require compiling pongoOS.)
Download the checkra1n executable from the official website and put it in a system directory.

wget https://assets.checkra.in/downloads/linux/cli/x86_64/dac9968939ea6e6bfbdedeb41d7e2579c4711dc2c5083f91dced66ca397dc51d/checkra1n

sudo mv checkra1n /usr/bin/

Install Clang 11 on Linux.

sudo apt install clang-11 xdd

Install ld64 and cctools-strip from the checkra1n package repository. Other distros need to manually compile them for newer Clang versions.

echo 'deb https://assets.checkra.in/debian /' | sudo tee /etc/apt/sources.list.d/checkra1n.list
sudo apt-key adv --fetch-keys https://assets.checkra.in/debian/archive.key

sudo apt update

sudo apt install ld64 cctools-strip

Get the pongoOS source code and compile it, using konradybcio’s fork.

git clone https://github.com/konradybcio/pongoOS

cd pongoOS

LD_LIBRARY_PATH="/usr/lib/llvm-11/lib/" EMBEDDED_CC="/usr/bin/clang-11" EMBEDDED_LDFLAGS=-fuse-ld=/usr/bin/ld64 STRIP=cctools-strip make all

Note: the pongoOS source has not been updated in a long time, so it sometimes fails to compile. You can also compile it inside a macOS virtual machine. The following commands compile it with Xcode on macOS Ventura:

xcode-select --install

git clone https://github.com/konradybcio/pongoOS

cd pongoOS

make all

You will end up with build/Pongo.bin.

4. Compile the Linux Kernel
#

Install build dependencies.

sudo apt install build-essential clang  libncurses5 flex git bc bison

Get the linux-apple kernel source provided by konradybcio.

git clone https://github.com/konradybcio/linux-apple

cd linux-apple

Get the defconfig provided by SoMainline.

wget https://raw.githubusercontent.com/SoMainline/linux-apple-resources/master/example.config -O ./.config

Adjust PAGESIZE.

make ARCH=arm64 LLVM=1 menuconfig

Press / to search, enter _PAGE, and press 1.
For PAGESIZE, set A8 processors to 4K and A9 or newer processors to 16K. Then press Exit and save .config.
Compile the kernel.

make ARCH=arm64 LLVM=1 -j$(nproc) Image.lzma dtbs

You will end up with arch/arm64/boot/Image.lzma.
Get the dtbpack script and put it in the Linux kernel directory.

wget https://raw.githubusercontent.com/SoMainline/linux-apple-resources/master/dtbpack.sh

chmod +x dtbpack.sh

Generate dtbpack.

./dtbpack.sh

5. Compile the postmarketOS rootfs
#

Install pmbootstrap.
Initialize it. Select apple-iphone6 as the device model and xfce4 as the desktop environment.

pmbootstrap init

Create the rootfs.

pmbootstrap install

6. Boot into Linux
#

Set up libimobiledevice and confirm that Linux recognizes the iPhone.
Connect the iPhone to the computer and manually enter DFU mode: power it off and wait 5 seconds. Hold the power button for 3 seconds, then hold power + Home for 10 seconds. Release the power button and keep holding Home.
After confirming it is in DFU mode, open a terminal in the pongoOS source directory and use checkra1n to enter the pongoOS Shell.

cd pongoOS

sudo checkra1n -v -V -p -c -k ./build/Pongo.bin

At this point, you should see the pongoOS Shell on the iOS device screen.
Start postmarketOS netboot.

pmbootstrap initfs hook_add netboot

pmbootstrap export

Send the Linux initramfs to the iOS device.

cd pongoOS

python3 scripts/load_linux.py -k "linux-apple-kernel-directory/arch/arm64/boot/Image.lzma" -d "linux-apple-kernel-directory/dtbpack" -r /tmp/postmarketOS-export/initramfs

Wait for Linux to boot… and it kernel panics. Damn it.
If it boots normally, send the Netboot rootfs and you can enter the Linux system.

pmbootstrap netboot serve

ssh user@172.16.42.1

7. Conclusion
#

Every time I do this kind of thing, I think of this song. It’s all a waste of time again.

At the moment, this is not practical. It is a bit like stubbornly flashing postmarketOS onto an Android phone with terrible driver support. The biggest problem is still poor driver support. Just look at the table provided by SoMainline: almost every hardware feature has an X next to it.

And who is going to reverse engineer Apple device drivers? Are there developers with Asahi Linux-level enthusiasm for this? On top of that, booting Linux still depends on a hardware vulnerability.

Aside from booting and running some Linux programs, there is not much room for this to grow.

A more realistic strategy is probably to run a JIT-accelerated UTM virtual machine on the iOS device, then run a Linux VM inside it. Much more practical, which is annoying but true.

Nura on Ivon's Blog

Chasing the Future of the Open Source Linux Ecosystem (Phones, Tablets, and Laptops All Running Linux)

Phosh: An Introduction to the Touch Desktop Environment for Linux Phones

Introduction to Phosh #

Features #

Technical Points #

Interaction Model #

App Store Ecosystem #

Chinese Input Method? #

References #

postmarketOS Installation Guide: Building an Installer with pmbootstrap

1. Install pmbootstrap #

2. Choose a Device and Configure Options #

3. Choose How to Install postmarketOS on the Phone #

Flash with fastboot #

Install to an SD Card #

Install with a Recovery ZIP #

Other Flashing Methods #

4. Post-install Tweaks for postmarketOS #

Try Phone Linux on a Computer: postmarketOS QEMU/KVM Virtual Machine Installation Guide

1. Install a QEMU Virtual Machine with pmbootstrap #

2. Manually Install a postmarketOS VM with Virt Manager #

References #

postmarketOS Tips: Installing Apps, Localization, Running Android Apps, and Docker

1. How Phosh works #

2. Linux phone apps #

App stores #

Tips for mobile Firefox #

Maps and navigation #

Running Android apps with Waydroid #

Remote desktop #

3. postmarketOS Chinese localization and input methods #

4. postmarketOS system administration #

Package management #

Service management #

Firewall #

5. Network connections #

Wifi network #

Mobile network #

SSH connection #

Set the time zone and correct the time #

How to Run Linux on a Phone: A Few Ways to Try It

1. Use an App to Emulate a Linux Environment #

Android #

Termux #

QEMU #

iOS #

iSH Shell #

UTM #

2. Flash the Phone with a Real Linux System #

Ubuntu touch #

postmarketOS #

3. Buy a Real Linux Phone #

Back Up an Android Phone's postmarketOS Partitions to a PC

1. postmarketOS and Android Partitions #

2. Back Up postmarketOS Partitions #

3. Restore postmarketOS Partitions #

References #

Running postmarketOS on Android Termux proot without flashing a custom rom

1. Motivation #

2. Prerequisites #

3. Install Proot Alpine Linux #

4. Convert Alpine Linux installtion to postmarketOS #

5. Installing Phosh desktop environment #

6. Launch Termux X11 and Phosh #

7. Phosh user experience #

8. Let’s try other desktop environments? #

References #

Installing Linux on an iPhone 6: Run postmarketOS Through a checkra1n Jailbreak

1. Background #

2. Requirements #

3. Compile pongoOS #

4. Compile the Linux Kernel #

5. Compile the postmarketOS rootfs #

6. Boot into Linux #

7. Conclusion #

References #

Introduction to Phosh
#

Features
#

Technical Points
#

Interaction Model
#

App Store Ecosystem
#

Chinese Input Method?
#

References
#

1. Install pmbootstrap
#

2. Choose a Device and Configure Options
#

3. Choose How to Install postmarketOS on the Phone
#

Flash with fastboot
#

Install to an SD Card
#

Install with a Recovery ZIP
#

Other Flashing Methods
#

4. Post-install Tweaks for postmarketOS
#

1. Install a QEMU Virtual Machine with pmbootstrap
#

2. Manually Install a postmarketOS VM with Virt Manager
#

References
#

1. How Phosh works
#

2. Linux phone apps
#

App stores
#

Tips for mobile Firefox
#

Maps and navigation
#

Running Android apps with Waydroid
#

Remote desktop
#

3. postmarketOS Chinese localization and input methods
#

4. postmarketOS system administration
#

Package management
#

Service management
#

Firewall
#

5. Network connections
#

Wifi network
#

Mobile network
#

SSH connection
#

Set the time zone and correct the time
#

1. Use an App to Emulate a Linux Environment
#

Android
#

Termux
#

QEMU
#

iOS
#

iSH Shell
#

UTM
#

2. Flash the Phone with a Real Linux System
#

Ubuntu touch
#

postmarketOS
#

3. Buy a Real Linux Phone
#

1. postmarketOS and Android Partitions
#

2. Back Up postmarketOS Partitions
#

3. Restore postmarketOS Partitions
#

References
#

1. Motivation
#

2. Prerequisites
#

3. Install Proot Alpine Linux
#

4. Convert Alpine Linux installtion to postmarketOS
#

5. Installing Phosh desktop environment
#

6. Launch Termux X11 and Phosh
#

7. Phosh user experience
#

8. Let’s try other desktop environments?
#

References
#

1. Background
#

2. Requirements
#

3. Compile pongoOS
#

4. Compile the Linux Kernel
#

5. Compile the postmarketOS rootfs
#

6. Boot into Linux
#

7. Conclusion
#

References
#