Termux Tutorials on Ivon's Blog

A simple Termux tutorial for beginners

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Fri, 22 May 2026 01:00:00 +0800

How to use Termux App?

Android is a Linux-based system, but it lacks a terminal. Termux, an open-source terminal emulator, fills this gap, allowing it to be used without root access and even has its own package manager.

Termux is a terminal emulator app that ports many commonly used Linux command-line programs to Android. Why type commands on your phone? Sometimes your phone doesn’t have a corresponding app for doing some tasks, but you can still achieve your goals using command-line software.

For example, Termux can be used for SSH connections, video transcoding, server setup, programming learning, and more. Furthermore, Termux provides a tool called proot-distro, which can create Linux container environments and run more Linux desktop programs.

Example usage: Running PC version of Firefox and XFCE Desktop on Android phone using Termux app.

Example usage: Coding Python with Vim on Android phone using Termux app.

Please note:

Termux CANNOT ROOT YOUR PHONE! If you want to modify system settings, you must root your phone first (e.g. unlocking bootloader and flashing Magisk).
Double-check before installing suspicious packages or running random scripts on the Internet! It may be harmful to your device.
Termux is not for hacking.

In this article I will tell you how to install and setupt Termux properly.

1. Download Termux APK
#

Termux requires an Android device running Android 7 or later.

Do not install Termux from Google Play store. The maintainers of Termux stated that Termux on Google Play is no longer maintained. It is outdated and contains lots of bugs.

Please download Termux apk from F-Droid or Github. For most devices, choose the arm64-v8a variant.

2. Things to do after installing Termux
#

2.1. Interface overview
#

After opening Termux, you’ll see the terminal interface. Tap the input box, and your phone’s keyboard will automatically open. The Termux screen also displays keyboard shortcuts like Ctrl and Esc, which you’ll frequently use when operating the terminal.
Pull down from the notification bar and press Exit to immediately terminate Termux; Acquire Wakelock keeps it running in the background.
Swipe in from the left side of the screen and press New Session to open multiple Termux terminals (working sessions); press Keyboard to wake up the phone’s keyboard.
How to input Chinese in Termux: Swipe the bottom toolbar to the left to reveal the input box.
If you find the Termux text too small, use two fingers to zoom in and out of the terminal screen.

2.2. Update packages
#

Linux systems typically install software from software repositories; those familiar with Ubuntu should understand this.

Termux packages are primarily in .deb format. The pkg command is essentially an APT wrapper, but you cannot directly install .deb packages from Ubuntu/Debian systems. Termux repositories contain modified versions specifically for mobile devices.

How to use Termux X11 - The X Server for Android Phone

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Fri, 17 Apr 2026 13:00:00 +0800

Termux X11 is an app that can run X servers on Android phones. What does this mean? It means it can be used to execute Linux programs that rely on the X11 display, such as Firefox, Chromium, GIMP, Blender, Visual Studio Code, and more. Although Android is based on the Linux kernel, its graphics protocol differs from that used by most Linux distributions. Most Linux program toolkits are designed for X11 or Wayland, so Android cannot run Linux programs. Termux X11 provides an X server that runs on Android, allowing Termux’s Linux programs to display a graphical interface within it.

In addition, you can also achieve 3D hardware acceleration through the experimental VirGL server (virglrenderer) in Termux.

This is how the X Server works on a GNU/Linux PC.

Termux X11 developers ported the X Server to Android, enabling X11 apps to output screens on Android.

Termux X11 can be used with mouse and keyboard, or with touching gestures. Just setting the appropriate desktop resolution so you could interact with the desktop environment using your phone’s keyboard.

1. Install Termux X11
#

Termux X11 was inspired by Sparkle, and was initially implemented using XWayland, but was later replaced by XCB.

Currently, Termux X11 requires devices running Android 8 or later.

Install Termux
Download latest Termux-x11 APK from Github Releases. Download the Termux X11 APK. For most devices, choose the arm64-v8a variant.
Install the Termux-x11 apk.
Launch Termux, install x11-repo. Then install termux-x11-nightly

pkg update

pkg upgrade

pkg install x11-repo

pkg install termux-x11-nightly

2. Usage 1: Run X11 apps in Termux
#

Personally, I recommended you to use Termux X11 with proot-distro because Termux has fewer package than proot-distros.

Open Termux X11 APP and you will see this
Go back to Termux. Install XFCE4 and GIMP

pkg install xfce gimp

Launch XFCE4 with dbus-launch

termux-x11 :0 -xstartup "dbus-launch --exit-with-session xfce4-session"

If you encounter Make sure an X server isn't already running(EE) error, close Termux, then “Force stop” and “Clear cache” Termux and Termux X11 App in Android system settings.

Now you should see XFCE4 running in Termux X11.
You could change Touchscreen input mode in Termux X11 preferences in notification bar.
If the font is too big, open System settings → Appearance → check Cutsom DPI. You can also set display resolution in Preferences of Termux X11 APP.
Press CTRL+C in Termux to stop XFCE4.

3. Usage 2: Run X11 apps in Proot-distro
#

Install a proot-distro. For example Debian proot or Arch Linux proot.
Open Termux X11 app. Then go back to Termux.
Log in to the installed Proot-distro using the regular account user. When logging in to proot here, you must add the --shared-tmp parameter, which means mounting the Termux $TMPDIR directory to the proot /tmp directory.

proot-distro login --user user debian --shared-tmp

Launch desktop environment. For example, XFCE4

termux-x11 :0 -xstartup "dbus-launch --exit-with-session xfce4-session"

While in Termux X11, you can activate phone keyboard by pressing back button. I suggest you to install Hacker’s Keyboard for using desktop shortcuts.

Accelerate QEMU virtual machines in Termux with pKVM

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Tue, 23 Dec 2025 11:00:00 +0800

I discussed the problem of running virtual machines on Android phones with Termux in Termux + QEMU Linux VM. The conclusion: it is slow as hell.

Without KVM, everything depends on software emulation. The result is that you can only run 20-year-old Windows XP systems; modern operating systems are simply too heavy.

Phones equipped with Google Tensor processors introduced pKVM after Android 15, which is the technology supported underneath the AVF framework.

At the moment, except for Android 16’s experimental Debian Linux Terminal, ordinary apps cannot access pKVM. You need root privileges to enable pKVM.

1. Install packages
#

With KVM acceleration, you should run a virtual machine of the same architecture. According to Termux developers, using the qemu-system-aarch64-headless package can give you a pKVM-accelerated virtual machine.

Install the following packages. On ARM machines, it is best to enable UEFI.

pkg install qemu-system-aarch64-headless qemu-utils qemu-common ovmf sudo

There is no Virt Manager in the graphical interface, and the Libvirt service probably will not run, so we have to use AVNC to access the virtual machine display.

2. Create a Linux virtual machine in Termux
#

Download the Ubuntu ARM ISO and put it in Termux’s home directory
Confirm that KVM exists

sudo ls /dev/kvm

Create a virtual disk

qemu-img create -f qcow2 ubuntu.qcow2 32G

Create files to store UEFI

truncate -s 64m varstore.img

truncate -s 64m efi.img

dd if=$PREFIX/share/qemu/edk2-aarch64-code.fd of=efi.img conv=notrunc

Add a boot script

touch startubuntu.sh

chmod +x startubuntu.sh

vim startubuntu.sh

The contents are as follows

qemu-system-aarch64 -M virt \
-enable-kvm \
-drive if=pflash,format=raw,file="efi.img",readonly \
-drive if=pflash,format=raw,file="varstore.img" \
-smp cpus=2 \
-m 1024 \
-cpu host \
-nographic \
-netdev user,id=n1,hostfwd=tcp::2222-:22 -device virtio-net,netdev=n1 \
-drive file=ubuntu.qcow2 \
-boot d \
-vnc :0 \
-cdrom ubuntu-24.04.3-live-server-arm64.iso

Add sudo when running it.

sudo ./startubuntu.sh

If everything goes smoothly, you can open localhost:59000 in AVNC and see the virtual machine display.

The strange thing is that it can boot without enabling KVM, but once KVM is enabled it hits the qemu-system-aarch64: Failed to put registers after init: Invalid argument error.

If you switch to chroot and run KVM inside it, maybe the success rate will go up?

References
#

Android's new Debian Linux Terminal may not become a Termux killer

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

Android 16’s Linux Terminal may not become a Termux killer.

Termux is an Android terminal app developed by a group of open source software enthusiasts, with its own package repository.

After playing with the Debian Terminal on Pixel phones, I have temporarily reached this conclusion. It uses the AVF framework to run a Debian environment, with technology similar to ChromeOS crosvm. It is a complete virtual machine environment isolated from Android, capable of running Systemd and Docker.

However, startup takes some time. And isolation between the virtual machine and the host causes performance degradation.

Although GPU acceleration may be possible, its efficiency probably will not be much higher than Termux. They also have to deal with displaying Linux Wayland windows on Android’s compositor.

If you only want to run CLI programs, Termux is simpler and more efficient, because it has no virtualization layer. All packages are compiled for ARM64. If you suddenly need to open an SSH remote connection, Termux starts the fastest.

Termux’s GPU acceleration can still use Turnip and VriGL.

The more fundamental difference is that their technical architectures are completely different. Termux has always been a native Android app. It merely creates a userspace program, directly executes ARM64 ELF binaries, and has no real virtualization at all. It can access the filesystem with near-native performance and directly use resources provided by the Android system, so startup time is fast, I/O latency is low, and the experience of launching CLI tools is excellent.

Android 16 Linux Terminal takes another path. Judging from its current design, it uses full pKVM virtualization + VirtIO interfaces. Therefore, every launch is effectively booting a Linux virtual machine, and I/O has to go through VirtIO. GPU graphics processing has to handle the long data path of guest -> host -> Android SurfaceFlinger. If the virtual machine wants to use host hardware interfaces (camera, USB, GPU), it needs another translation layer, or may simply be forbidden from accessing them. This complete isolation is of course safe, but the price is that it is hard to expect the experience of “tap and open instantly, enter shell in seconds.”

In terms of performance, if you are only running CLI programs such as Python scripts, SSH, git, or compiling small to medium-sized codebases, Termux will probably be faster, because it interacts directly with the Android kernel and has no virtualization overhead. GPU acceleration is similar: Termux uses Android’s OpenGL and Vulkan acceleration through Turnip/VirGL. Although it is very hacky, at least it runs, and latency is lower after bypassing the virtualization layer.

On security, the objective advantage of the Linux virtual machine is obvious. No matter how Termux is sandboxed, in essence it still runs at the Android app layer, and its attack surface is similar to that of a normal app. AVF is hardware-level isolation, and pKVM can restrict a virtual machine’s DMA privileges, memory visibility, and define which peripherals are available. This should be very helpful for enterprise, tablet, and education markets.

Write Python on an Android phone: setting up a Termux Python development environment

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Sat, 12 Apr 2025 17:00:00 +0800

Sharing how to write Python programs with the Android phone app “Termux”, plus a bit of Ivon’s personal experience.

Many Android apps for writing Python on phones are awkward. They can only install packages written in pure python, and they fall over as soon as they encounter wheels. Perhaps their goal is more like Duolingo, for beginners to practice, rather than building a serious Python development environment.

Among them, only Termux keeps evolving. Although pip install still cannot run 100% like a normal Linux environment, more and more packages are being compiled as Termux-specific versions! Through the Python packages provided by Termux, you can run some simple Python programs and process files on your phone. Root privileges are not required.

For example, install Pillow through pip and write a small program that batch-processes EXIF photo information. It reads all photos in the phone’s DCIM folder, prints the date on each photo according to EXIF information, and outputs them to another folder. (This program really works; the source code is here)

Or use term-image, written in Python, to display images from the phone in the terminal.

1. Text-only or graphical interface?
#

Termux is a text-interface terminal emulator by default. You need to type commands to run Python programs. Although a graphical interface can be run through Termux X11, is it really necessary?

Text-based Python programs can only output plain text, including operations such as calculating numbers, arranging stars, batch-processing files, downloading files, and so on. To write programs in a text interface, you need to learn to edit with Vim or Emacs. This is a good chance to practice operating text editors.

With a graphical interface, you can run Python programs that need to display windows, draw charts, and so on. There are many choices for programming in a graphical interface, including VS Code and Jupyter Notebook, but they consume more phone resources.

A graphical interface is not necessary. If you only want to write small programs, you do not necessarily need an IDE; Vim is enough.

This article focuses primarily on the text environment, with graphics second.

2. Run Python in Termux or proot-distro?
#

Python can run directly in Termux, or you can use proot-distro to create a Debian environment and then run Python inside it.

What is the difference between the two? Termux’s Python packages are versions compiled for the Termux environment and run with native performance. But Termux is not a standard Linux environment, so some Python packages may not work.

As for proot-distro, the environment is closer to a Linux system, so installing Python inside it has better compatibility, and Debian’s repositories have more ready-made Python packages available without relying on pip wheels. But proot-distro runs more slowly.

This article focuses on the Termux environment.

3. How to install Python in Termux?
#

Install Termux

Launch X11 graphical programs from proot-distro on Termux's XFCE desktop

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

Allow apps in proot-distro to draw windows on XFCE desktop in Termux. Integrate X11 GUI apps in proot-distro with Termux host desktop environment.

By default, use Termux’s native packages to run the XFCE desktop environment, and through X11 network transparency, allow X11 program windows inside proot-distro to be displayed on the XFCE desktop.

This image shows Termux and the proot-distro environment running at the same time. The XFCE desktop runs directly in Termux, while LibreOffice starts from inside proot-distro

Here, the side responsible for running native XFCE programs can be called the Termux host for now, while proot-distro is naturally the container. The process is shown below:

This usage is a bit like the Linux desktop container tool Distrobox. It allows X11 graphical programs inside Docker to be displayed on the host desktop.

You might think: why not just start XFCE directly from proot-distro? Why use Termux’s XFCE packages?

Because it is faster. Processes inside proot are emulated with ptrace, so they are inherently slower than programs compiled natively for Termux. Termux now has more and more packages, even the Chromium browser (included in TUR Repo), so in the future there is less need to let the guest usurp the host by running the desktop environment in proot-distro. If most commonly used programs can run as Termux native versions, there is no need to use proot-distro; only start proot-distro when necessary to run programs that are only included in Debian repositories.

1. Install a desktop environment for Termux
#

See Termux Install XFCE4. For graphical display, either Termux X11 or VNC is fine.

Here we also need to add one extra package, used to control X client permissions for connecting to the X server:

pkg install xorg-xhost

Test whether the Termux desktop environment can start.

In addition, we can open XFCE’s file manager, open the storage/shared directory, and read files from Android internal storage.

2. Configure proot-distro
#

I installed proot Debian

It is recommended to add a normal user and configure Chinese localization inside proot-distro.

Termux lacks the locales package and cannot configure Chinese.

Also install graphical programs inside proot-distro, such as LibreOffice:

sudo apt install libreoffice

3. Launch programs inside proot-distro from the Termux desktop
#

First run xhost to allow programs inside proot-distro to draw windows on the X server of the Termux desktop. Because proot processes are started by the Termux user, use the whoami command to pass in the current username and allow this user to connect.

xhost +SI:localuser:$(whoami)

Log in to proot-distro. You must use --shared-tmp to share X server resources, and add --termux-home to mount Termux’s home directory as well (if you do not want files to be messed up by programs inside proot, you can skip mounting it)

proot-distro login debian --user user --shared-tmp --termux-home

Specify the DISPLAY environment variable. The value should be the address of the Termux X server, generally :0. Then run a program, such as LibreOffice:

export DISPLAY=:0

libreoffice

You will then see the LibreOffice window start.

How to connect remotely to Termux's Linux desktop with VNC

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Thu, 10 Apr 2025 01:00:00 +0800

This article explains how to set up a VNC server so that we can access the Linux system desktop in Termux. It applies to Linux systems installed through proot or chroot.

Termux can run Linux on an Android phone. After setting up the environment, the next concern is how to connect to the desktop (graphical environment). To connect to Termux’s Linux system desktop, there are three methods: Termux X11, XSDL, and VNC.

The first two run an X server on the phone. The latter is the remote desktop concept: run a VNC server on the phone, start a virtual Xvnc server, then connect with a VNC client. This VNC client can be local or a client on another computer.

In terms of graphics performance, an X server is better than VNC, and it is easier to achieve 3D hardware acceleration.

When I first learned Termux, I saw many people using VNC, but as Termux X11 gradually matured, I gradually abandoned VNC.

If all three run on the same phone, since they are all localhost, there is no latency issue, and VNC really has no performance advantage over an X server.

VNC’s strength is remote access from other computers! Compared with SSH X server forwarding, VNC can lower image quality to reduce bandwidth, and can even start headlessly. Its performance advantages appear when viewing remotely.

So VNC is suitable for the scenario of “using a computer to connect to the phone’s Termux desktop”. You do not like staring at a tiny screen and typing commands like crazy, right? Then, besides text-only SSH access, graphical VNC is a good choice.

VNC and Termux X11 can coexist and should not affect each other.

1. Choose a VNC client
#

On phones, I recommend AVNC or RealVNC Viewer. The latter has more features, but it is proprietary software.

On computers, I recommend Remmina

2. Configure the VNC server
#

Choose one of the two.

Run the VNC server directly in Termux
#

In fact, proot-distro is not required. Termux itself provides a native VNC server package. But if you want to open the desktop of a Linux distribution inside proot-distro, do not use this method.

Also, the desktop environment packages included in Termux are not as rich as those in proot-distro. The most complete one at present is XFCE.

Install the XFCE desktop for Termux, but do not install Termux X11.
Install the TigerVNC package. The current version is 1.13.0.

pkg install tigervnc

Set the VNC server password

vncpasswd

Add the program to execute after the VNC server starts by editing ~/.vnc/xstartup

mkdir ~/.vnc/

vim ~/.vnc/xstartup

Fill in the following content

#!/bin/bash
unset SESSION_MANAGER
unset DBUS_SESSION_BUS_ADRESS

# Start the PulseAudio sound server; audio will come out from Termux
pulseaudio --start --exit-idle-time=-1
pacmd load-module module-native-protocol-tcp auth-ip-acl=127.0.0.1 auth-anonymous=1

# Run the desktop environment, XFCE here
exec startxfce4

Grant execute permission to xstartup

chmod +x ~/.vnc/xstartup

Define the VNC server configuration file. Edit ~/.vnc/tigervnc.conf

vim ~/.vnc/tigervnc.conf

Fill in the following content:

# Current session XFCE
$session="xfce-session";
# Resolution; higher values use more bandwidth
$geometry="1920x1080";
# Bit depth, values are 8/16/24/32; larger numbers look better but use more bandwidth
$depth="32";
# Allow external networks to connect
$localhost="no";

Run the VNC server inside proot-distro
#

First install Termux proot-distro, such as Debian. Then install a desktop environment inside proot-distro. XFCE uses the fewest resources, but KDE Plasma is also worth trying.

Use a phone as a computer: run desktop Linux software with iPad + Android Termux

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

iPad is too limited, Android is too tiny. So why not combine then together?

Use Android + Termux Proot Debian + KasmVNC + Safari on the iPad to build a mobile working environment that runs desktop software.

What the iPad cannot do, let the Android phone do!

Use the Android phone as a computer through Termux Proot, run Linux desktop software, and control it through the iPad.

The iPad remotes into the Linux container on Android for operation. What the iPad cannot do, let the Android phone do!

Joplin organizing notes

Visual Studio Code launching pygame

Do not understand what the title means? This is the usage scenario I want:

1. Motivation
#

My current mobile work setup is an Android phone paired with an iPad. Although they are different ecosystems, with the help of free software such as LocalSend, the two get along quite pleasantly. Thanks to the large battery of the Android phone, it seems I can share a hotspot to the iPad for 6 hours without running out of power.

All of this is to run desktop software on the iPad. Some software is very smart on the desktop version, but becomes idiotic after being ported to mobile. This is true for both free software and proprietary software.

Take the note-taking software Joplin, for example. Joplin on the iPad is only an enlarged iPhone version, with overly crude functionality, and many desktop features have not been ported, such as the note relationship graph. When dealing with notes, it always feels shackled, and many things have to be handled on a computer. So I started thinking about how to run desktop Joplin.

Sell the iPad and switch to a Surface? I have thought about it, but I do not want to cut off my toes to fit the shoes, so I took out Termux on the Android phone. Termux can run a Linux desktop environment container without root, and it can be accessed by the iPad through VNC.

I previously shared methods for mirroring Android to a large screen with Scrcpy and Rustdesk, but I do not need the entire Android screen! Linux alone is enough. Run the VNC server headlessly; as long as Android has enough RAM, it will not be easily killed in the background, so the Android phone can still be used while Linux programs are running.

The iPad’s network is shared from Android, so the local connection latency for the remote desktop is low. The iPad becomes the screen for Android’s Linux container.

If I could choose, the Android phone should be replaced with a Raspberry Pi. I have written about using a Raspberry Pi with an iPad, after all, its I/O is more complete, and the Raspberry Pi’s size is also suitable for carrying around. But if the phone has a large battery and a powerful processor, why not use what is already there? For example, my Sony Xperia 10 V has only one third of the performance of an iPad Air 6, but it does not heat up when sharing a hotspot and has extremely long battery life, so let’s squeeze it a bit and run Linux on it!

Manage auto-starting services: how to use Termux-services & Termux:Boot

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Mon, 18 Nov 2024 06:00:00 +0800

Manage auto-startup services in Termux.

Here I share two Termux extensions. The first is Termux-services, which manages services after the Termux app is started. The second is Termux:Boot, which configures Termux services to start automatically after Android boots.

Why would you need Termux-services?

If you want to start and stop services in Termux, and configure services to start automatically after opening the app, but Termux has no Systemd, are you stuck writing auto-start services into ~/.bashrc or ~/.profile, then killing processes with the kill command when you want to stop them?

At this point, Termux-services is a pretty good tool.

Termux-services lets you use a set of commands to control service execution, so you can freely start and stop services. It is very useful for programs that need daemons, such as sshd, apache2, and bitcoin, which can be started automatically through Termux-services after the Termux app opens.

Termux-services uses “runit” to manage system services. This is a very simple init service manager, now used by only a small number of Linux distributions. Speaking of Linux distributions that use runit, the most famous are probably Artix Linux and Void Linux.

First I will introduce how to use Termux-service, then explain how to use Termux: Boot.

1. Termux-services auto-start
#

Install the Termux-services package

pkg install termux-services

When installing some packages, Termux will also install runit service files. The files for all services are located at $PREFIX/var/service/sv.
For example, after installing the openssh package, Termux-services will automatically install the SSHD service file. $PREFIX/var/service/sv/sshd/run defines the command executed after the service starts, and $PREFIX/var/service/sv/sshd/down defines the command executed after the service stops.
To start and stop the SSHD service, use the following commands:

# Start
sv up sshd

# Stop
sv down sshd

# Auto-start after opening the app 
sv-enable sshd

# Disable auto-start after opening the app 
sv-disable sshd

By analogy, if you want to execute other programs after Termux starts, create a service file in the same way. Refer to the official runit templates when writing scripts. I will use running a custom script as an example:

# Edit content
echo "echo 'Hello world' ">> ~/run.sh
chmod +x ~/run.sh

# Add service file
vim $PREFIX/var/service/sv/myscript/run

# Fill in:
bash ~/run.sh

# Configure auto-start after starting the Termux app
sv-enable myscript

2. Termux:Boot auto-start on boot
#

Termux:Boot automatically executes the scripts you write after the Android system boots.

Actually, you do not have to use it together with Termux-service. Termux:Boot can call Termux to execute arbitrary commands, but I think system services are better managed centrally. So the architecture becomes: first add the services you want to run through Termux-services, then use Termux:Boot to automatically start Termux, and all the services you wrote will start with it.

Install the Termux: Boot APK
Tap the icon once to launch it, so it will start automatically after boot

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.

Solutions when Termux proot cannot use the systemctl command

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Sat, 31 Aug 2024 23:00:00 +0800

Systemd is an init program. Almost all Linux distributions use Systemd to manage system services, and common commands include systemctl, journalctl, and so on.

However, Termux cannot use Systemd. If you run commands related to systemctl start inside a Termux proot-distro or chroot container environment, you will see this error: System has not been booted with systemd as init system (PID 1). Can't operate. Failed to connect to bus: Host is down

This is because the container environment does not support Systemd.

There is actually no real solution, unless the Termux development team learns from Microsoft WSL and finds a way to make Systemd run. However, we do have some alternatives to address this problem.

Method 1: Start the program directly from the executable path
#

First, understand that Systemd is just an init program for managing system services. It is responsible for starting programs after Linux boots and letting users turn programs on and off. But simply starting a program does not actually require systemctl.

For example, to start the SSH service in proot Debian, the Systemd way is to run the following command:

sudo systemctl start sshd

If we find Systemd’s service file /etc/systemd/system/sshd.service (most Systemd service files are here), we will see that what follows ExecStart= is the command it really executes:

[Service]
EnvironmentFile=-/etc/default/ssh
ExecStartPre=/usr/sbin/sshd -t
ExecStart=/usr/sbin/sshd -D

Therefore, the SSH service can be started directly with this command and run in the background:

mkdir -p /run/sshd

/usr/sbin/sshd -D

Note: programs inside Termux proot-distro cannot use ports below 1000. When logging in to proot-distro, add the --fix-low-ports parameter to redirect SSH port 22 to 2022.

If you want to automatically start a specific program after logging in to proot-distro, the simplest way is to add the command you want to run to ~/.bashrc in the user’s home directory.

Method 2: Switch to a distribution that uses OpenRC
#

OpenRC and runit are more traditional init programs. They are not as complex as Systemd, and they can run and manage services in proot. Users unfamiliar with OpenRC commands can refer to the Systemd and OpenRC command comparison table below.

At present, the proot-distro distribution that uses OpenRC is Alpine Linux, while Artix Linux and Void Linux use runit.

Install Alpine Linux

proot-distro install alpine
proot-distro login alpine

Install the OpenRC package

apk add openrc

After that, append this command when logging in to proot, and the OpenRC program will start

proot-distro login alpine --fix-low-ports -- /bin/ash -c "/sbin/openrc default; /bin/ash -l"

After that, you can use OpenRC to manage services. For example, SSH can be managed with the rc-service command, without typing the executable path

sudo rc-service sshd start

You can also configure the SSH service to start automatically after logging in to proot-distro.

sudo rc-update add sshd

Method 3: Run a full Linux system virtual machine
#

The ultimate solution is to emulate a full Linux system so that Systemd can run.

Install a graphical desktop environment and audio output in Termux

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Sun, 25 Aug 2024 13:00:00 +0800

Note: because the Termux filesystem differs from ordinary Linux and has fewer packages, I tend to install a Linux proot container and run the desktop environment there. Although it is slower, the experience is better.

By default, Termux only has a text interface. Users can install a desktop environment themselves, then connect through VNC or Termux X11 to get a desktop-computer-like experience.

At present, desktop environments included in the Termux package repository include XFCE, LXQT, MATE, OpenBox, i3wm, Weston, and so on.

Termux can also use Android GELS to output audio, so we can run a PulseAudio server for audio output in the desktop environment.

This article explains how to install the XFCE desktop and configure the PulseAudio server.

Termux running the XFCE desktop environment and desktop Firefox browser

1. Prerequisites
#

To run a desktop environment, I recommend a phone with at least 6GB RAM.

Please install Termux first, and remember to disable Phantom Process Killing to prevent Termux from being terminated by the system in the background.

2. Install the XFCE desktop environment
#

Termux does not package many desktop environments, so choose XFCE, which is lightweight but still sufficiently functional.

Install XFCE4, the Firefox browser, and the VIM editor:

pkg install x11-repo

pkg install xfce xfce4-goodies pulseaudio pavucontrol vim firefox

3. Connect to the graphical interface
#

Choose one of the two; they can coexist. I recommend Termux X11, which performs better than VNC, but is less convenient for remote connections.

Termux X11
#

Configure Termux X11 and virglrenderer.
To make starting the desktop environment easier later, add a script

vim ~/startxfce4.sh

Fill in the following content:

#!/bin/bash

# Start GPU acceleration
virgl_test_server_android &

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

# Start desktop environment
termux-x11 :0 -xstartup "dbus-launch --exit-with-session xfce4-session" &

Grant execute permission

chmod +x ~/startxfce4.sh

Exit Termux.

exit

Start the Termux X11 app
Return to Termux and start the desktop environment. The XFCE4 desktop will appear in the Termux X11 app screen.

./startxfce4.sh

VNC server
#

Install the AVNC client on the phone
Install the TigerVNC package. The current version is 1.13.0.

pkg install tigervnc

Set the VNC server password

vncpasswd

Add the program to execute after the VNC server starts by editing ~/.vnc/xstartup

mkdir ~/.vnc/

vim ~/.vnc/xstartup

Fill in the following content

#!/bin/bash
unset SESSION_MANAGER
unset DBUS_SESSION_BUS_ADRESS

# Start the PulseAudio sound server; audio will come out from Termux
pulseaudio --start --exit-idle-time=-1
pacmd load-module module-native-protocol-tcp auth-ip-acl=127.0.0.1 auth-anonymous=1

# Run the desktop environment, XFCE here
exec startxfce4

Grant execute permission to xstartup

chmod +x ~/.vnc/xstartup

Define the VNC server configuration file. Edit ~/.vnc/tigervnc.conf

vim ~/.vnc/tigervnc.conf

Fill in the following content:

# Current session XFCE
$session="xfce-session";
# Resolution; higher values use more bandwidth
$geometry="1920x1080";
# Bit depth, values are 8/16/24/32; larger numbers look better but use more bandwidth
$depth="32";
# Allow external networks to connect
$localhost="no";

Enter the tigervncserver or vncserver command in Termux to start the VNC server. Observe the port number output on the screen; it usually starts from 1. Since VNC server ports count from 5900, the port here is 5901.

A brief look at Termux file management: sharing files between Linux environments and Android

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Wed, 21 Aug 2024 11:00:00 +0800

Manage and access files in Termux APP.

Discussing Termux’s directory structure and techniques for sharing files between Linux environments and Android.

Test environment:

Android 14
Termux 0.119

1. Termux’s own root directory
#

According to the Termux Wiki, Termux does not comply with the FHS standard, and its directory structure differs from ordinary desktop Linux distributions. Therefore, if your software relies heavily on the standard Linux directory structure, it is safer to consider using proot or chroot to create a Linux container environment.

Termux’s file directory (document directory) is located at /data/data/com.termux/files/

Only Termux can access this directory.

Termux provides two environment variables: $TERMUX_PREFIX and $PREFIX. Both point to the /data/data/com.termux/files/usr directory.

Software installed through pkg in Termux is usually placed in /data/data/com.termux/files/usr/bin

Termux’s home directory is located at /data/data/com.termux/files/home

Without root privileges, Termux cannot access the root directory (/) of the Android system

2. Termux’s home directory
#

Termux’s home directory is located at /data/data/com.termux/files/home. When running commands, the home directory path can be replaced with ~.

Note that Termux has only a single user account (confirm with the whoami command), and no root account. Users also cannot add accounts.

Only Termux can access the home directory. Other apps have to read this directory through Android Scoped Storage. See: Access Termux Directory

Usually there are no files in the Termux home directory, but ls -a can show hidden files

~ $ ls -a
. .bash_history .ssh
.. .npm .termux storage
.Xauthority .npmrc .vnc

Most directories starting with a dot are software configuration files. For example, .termux contains program behavior and fonts.

If the XFCE4 desktop environment is installed, Termux’s home directory will automatically generate directories that conform to the XDG Base Directory standard.

If you want to set the $PATH environment variable, put it in ~/.bashrc or ~/.profile.

If you want a text-based file manager, you can install the ranger package in Termux to conveniently manage files under Termux’s home directory.

3. Termux reading Android internal storage
#

By default, Termux cannot access Android user files outside its own environment.

After running the termux-setup-storage command, Termux can access files in Android internal storage.

To be precise, Termux bind mounts Android’s /sdcard path to ~/storage under the Termux home directory

Android internal storage is mounted to ~/storage under the Termux home directory

Use the ls command to view directories under ~/storage/shared, and you can see all files in Android internal storage

~ $ ls ~/storage/shared/

Documents Android Download Movies Pictures
DCIM Music

However, without root privileges, Termux cannot access the Android/data directory.

We can use the cp command to copy files inside Termux to the Android phone’s internal storage

cp ~/file.txt ~/storage/shared/Download/

Likewise, files from the Android phone’s internal storage can be copied to the Termux home directory

cp ~/storage/shared/Download/file.txt ~

Be careful: running rm -rf can delete all files in the Android phone’s internal file storage (except directories requiring root privileges). Operate commands carefully.

Install Ubuntu on Android: emulate an x86_64 Linux virtual machine with QEMU in Termux

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Sat, 17 Aug 2024 01:00:00 +0800

Introducing how to install a complete Linux system virtual machine on an Android phone/tablet without root.

Termux can use QEMU to emulate and run Linux virtual machines, making up for the shortcomings of the proot-distro environment.

Why use QEMU? The Linux environment provided by proot-distro is similar to chroot, but there are still some packages that cannot run, such as Podman, Docker, Snap, Flatpak, and programs that depend on Systemd, so a virtual machine becomes necessary.

QEMU lets you emulate virtual machines with x86 or ARM architectures and run a complete Linux desktop system. The image below shows Xubuntu running on an Android phone.

This way, almost all software can run. The image shows Podman execution results.

Incidentally, QEMU is the emulator used behind Limbo PC Emulator. After Limbo stopped updating, you can still run virtual machines with Termux’s QEMU package.

Please note: Most Android phones do not have a KVM kernel module (only Pixel phones can use pKVM to accelerate QEMU after root), so QEMU in Termux cannot use KVM to accelerate virtual machine execution like desktop Linux. Without KVM, QEMU virtual machines run extremely slowly. Programs inside the virtual machine run at less than about one fifth the speed of Termux native packages. Text-only programs are barely acceptable, but the office-work experience is poor, let alone gaming.

Given this execution speed, you can skip the graphical interface and SSH directly into it to run programs.

1. Environment
#

Phone: Sony Xperia 5 II
System version: Android 14
Processor: Qualcomm Snapdragon 865
RAM：8GB
Linux virtual machine system: Ubuntu 24.04 x86_64 (Xubuntu)

A phone running QEMU should use a flagship processor and have at least 8GB RAM.

The Linux distribution used is Ubuntu, but GNOME is a bit too heavy, so here I choose the lightweight Xubuntu, which uses the XFCE desktop. If you do not need a graphical interface, Ubuntu Server is also fine. Besides Ubuntu, there is an even lighter option: Alpine Linux, designed for embedded systems, which boots faster. (See: Termux headless Alpine Linux QEMU VM)

Because there is no KVM acceleration, there is not much difference between emulating an x86 or ARM virtual machine.

Tip: you can run QEMU on a Linux computer (faster with KVM), create a qcow2 image with the system already installed, then put it on the phone and boot it, saving system installation time.

2. Install prerequisite packages
#

Install a VNC client, such as AVNC
Install Termux
Open Termux and keep it running in the background
Go to the Xubuntu official site, copy the ISO download link, and download it with the wget command

pkg install wget

wget https://ftp.ubuntu-tw.net/mirror/ubuntu-cdimage/xubuntu/releases/24.04/release/xubuntu-24.04-desktop-amd64.iso

Then install QEMU and SSH packages

pkg install qemu-system-x86_64 qemu-utils qemu-common openssh vim ovmf

3. Install the Linux virtual machine
#

The installation command is similar to running QEMU on a Linux computer, but slightly modified because Android has no KVM.

Play Windows games from Steam on an Android phone: Mobox emulator tutorial

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Fri, 26 Apr 2024 04:00:00 +0800

Note: this project is no longer maintained. Please switch to Winlator or another alternative.

Mobox is an open source exe emulator that lets us play Windows games from Steam on Android phones.

Specifically, what Steam games can Mobox play? As long as a game can be launched on Steam Deck (Proton), Mobox should also be able to run it.

As long as the phone hardware is powerful enough, running any game is not a problem. For example, Youtuber Geek Bay successfully ran Cyberpunk 2077 on a Qualcomm 8 Gen 3 phone:

1. Hardware requirements
#

More than 10GB storage space
More than 8GB RAM
Prepare an external keyboard and mouse

For the principles behind Mobox, see Android轉譯玩Windows exe遊戲的方法一覽

The biggest difference is that Mobox uses Termux’s native packages to run the Linux system. Without container overhead, it runs at almost native performance, much faster than Winlator and Termux Proot, and roughly on par with Termux chroot performance.

The drawback is that Mobox operation is not as intuitive as Winlator’s interface, and requires typing a few commands.

Because Box64 translating Wine consumes a lot of performance, if you plan to play 3D AAA games, the phone processor should preferably be Qualcomm SD 865 or above. Also, considering graphics driver compatibility, Qualcomm processors are preferable; MediaTek may not be able to run at full speed.

My test environment
#

Sony Xperia 5 II
Lineage OS 21 (Android 14)
Qualcomm Snapdragon 865
8GB RAM

2. Install prerequisite packages
#

Refer to the original author olegos2’s Github instructions

Install Termux
Configure Termux X11
In Termux X11’s Preferences, set Display Mode to exact, and Display Resolution to 1280x720 (you can set a higher resolution depending on phone performance). Then uncheck Reseed screen while software keyboard is open. Also check Force Landscape Orientation.

3. Install Mobox
#

In the phone system settings, force stop both the Termux and Termux X11 apps.
Open Termux X11 and leave it waiting in the background
Open Termux
Run the script provided by the Mobox author

curl -s -o ~/x https://raw.githubusercontent.com/olegos2/mobox/main/install && . ~/x

When asked which version of Box86 to install, enter 2 to select the Wow64 version
Wait for Mobox to install packages, then enter the mobox command to start the environment.
Use the on-screen arrow keys to move to Start Wine, then press Enter
Turn the phone sideways and wait for Mobox to initialize the system (pay attention to whether there is a Cannot Open Display: error message)
Next, your screen should automatically switch to the Termux X11 app, and you will see the Wine file manager.
Termux X11 operates in touchpad mode by default: two-finger tap for right click, double tap for left click, and use the back gesture to bring up the phone keyboard

How to run Windows programs on Android with Box86 + Wine in Termux Proot

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Thu, 25 Apr 2024 19:00:00 +0800

🇹🇼 中文版

We can run Windows programs (.exe) with Box86 and Wine in Termux proot on Android. No root required.

Wine is a translation layer for running x86/x64 Windows programs on Linux. However, most of Android devices run on ARM architecture so Wine will not work in ARM platform.

Fortunately, a new program named Box86 can transalte x86 instructions into ARM instructions. And there is Box64 for transalting x64 instrcutions.

Therefore, you can run x86 appplications on ARM devices! And Box86 is faster than QEMU emualtion.

By combining Box86 and Wine, now we could run Windows programs in Termux proot.

1. Install Termux Proot
#

Install proot Debian and setup Termux X11.

2. Install Box86 & Box64
#

Log into proot Debian as normal user.

proot-distro login debian --user user shared-tmp

Enable armhf support

dpkg --add-architecture armhf

Add ryanfortner’s repo and install Box86

sudo apt install gpg

sudo wget https://ryanfortner.github.io/box86-debs/box86.list -O /etc/apt/sources.list.d/box86.list

wget -qO- https://ryanfortner.github.io/box86-debs/KEY.gpg | sudo gpg --dearmor -o /etc/apt/trusted.gpg.d/box86-debs-archive-keyring.gpg

sudo apt update

sudo apt install box86-android

Add ryanfortner’s repo and install Box64

sudo wget https://ryanfortner.github.io/box64-debs/box64.list -O /etc/apt/sources.list.d/box64.list

wget -qO- https://ryanfortner.github.io/box64-debs/KEY.gpg | sudo gpg --dearmor -o /etc/apt/trusted.gpg.d/box64-debs-archive-keyring.gpg

sudo apt update

sudo apt install box64-android

3. Install Wine and Wine64
#

Wine is for running x86 (32bit) programs;whereas Wine64 is for x64 programs.

Since we are on ARM64 platform, we cannot install pacakges (i386:wine) from foreign architecture while using APT. Here we will install Wine by downloading binaries and moving them to the proper path.

Install Wine’s dependencies

sudo apt install nano cabextract libfreetype6 libfreetype6:armhf libfontconfig libfontconfig:armhf libxext6 libxext6:armhf libxinerama-dev libxinerama-dev:armhf libxxf86vm1 libxxf86vm1:armhf libxrender1 libxrender1:armhf libxcomposite1 libxcomposite1:armhf libxrandr2 libxrandr2:armhf libxi6 libxi6:armhf libxcursor1 libxcursor1:armhf libvulkan -dev libvulkan-dev:armhf zenity

Download Wine and Wine64 from Kron4ek’s Wine-Builds. The latest version is Wine 9.7.

cd ~/

wget https://github.com/Kron4ek/Wine-Builds/releases/download/9.7/wine-9.7-amd64.tar.xz

wget https://github.com/Kron4ek/Wine-Builds/releases/download/9.7/wine-9.7-x86.tar.xz

Unzip the file and delete redundant files

tar xvf wine-9.7-amd64.tar.xz

tar xvf wine-9.7-x86.tar.xz

rm wine-9.7-amd64.tar.xz wine-9.7-x86.tar.xz

mv wine-9.7-amd64 wine64

mv wine-9.7-x86 wine

Create a symbolic link and point /usr/local/bin/wine to $HOME/wine/bin/wine.

echo '#!/bin/bash
export WINEPREFIX=~/.wine32
box86 '"$HOME/wine/bin/wine "'"$@"' > /usr/local/bin/wine

chmod +x /usr/local/bin/wine

echo '#!/bin/bash
export WINEPREFIX=~/.wine64
box64 '"$HOME/wine64/bin/wine64 "'"$@"' > /usr/local/bin/wine64

chmod +x /usr/local/bin/wine64

Add the PATH of Box86 and Box64 to ~/.bashrc

echo 'export DISPLAY=:0
export BOX86_PATH=~/wine/bin/
export BOX86_LD_LIBRARY_PATH=~/wine/lib/wine/i386-unix/:/lib/i386-linux-gnu/:/lib/aarch64-linux-gnu/:/lib/arm-linux-gnueabihf/:/usr/lib /aarch64-linux-gnu/:/usr/lib/arm-linux-gnueabihf/:/usr/lib/i386-linux-gnu/
export BOX64_PATH=~/wine64/bin/
export BOX64_LD_LIBRARY_PATH=~/wine64/lib/i386-unix/:~/wine64/lib/wine/x86_64-unix/:/lib/i386-linux-gnu/:/lib/x86_64-linux-gnu:/lib/aarch64 -linux-gnu/:/lib/arm-linux-gnueabihf/:/usr/lib/aarch64-linux-gnu/:/usr/lib/arm-linux-gnueabihf/:/usr/lib/i386-linux-gnu /:/usr/lib/x86_64-linux-gnu' >> ~/.bashrc

source ~/.bashrc

Install Winetricks

cd ~/

wget https://raw.githubusercontent.com/Winetricks/winetricks/master/src/winetricks

chmod +x winetricks

mv winetricks /usr/local/bin/

echo '#!/bin/bash
export BOX86_NOBANNER=1 WINE=wine WINEPREFIX=~/.wine32 WINESERVER=~/wine/bin/wineserver
wine '"/usr/local/bin/winetricks "'"$@"' > /usr/local/bin/winetricks32

chmod +x /usr/local/bin/winetricks32

echo '#!/bin/bash
export BOX64_NOBANNER=1 WINE=wine64 WINEPREFIX=~/.wine64 WINESERVER=~/wine64/bin/wineserver
wine64 '"/usr/local/bin/winetricks "'"$@"' > /usr/local/bin/winetricks64

chmod +x /usr/local/bin/winetricks64

Create a shortcut to the Wine file manager on the Linux desktop, so that you can directly click the exe to start:

cd ~/Desktop

echo '[Desktop Entry]
Name=Wine32 Explorer
Exec=bash -c "wine explorer"
icon=wine
Type=Application' > ~/Desktop/Wine32_Explorer.desktop

chmod +x ~/Desktop/Wine32_Explorer.desktop

cp ~/Desktop/Wine32_Explorer.desktop /usr/share/applications/

cd ~/Desktop

echo '[Desktop Entry]
Name=Wine64 Explorer
Exec=bash -c "wine64 explorer"
icon=wine
Type=Application' > ~/Desktop/Wine64_Explorer.desktop

chmod +x ~/Desktop/Wine64_Explorer.desktop

cp ~/Desktop/Wine64_Explorer.desktop /usr/share/applications/

4. Install DXVK
#

DXVK is a Vulkan-based translation layer for Direct3D 9/10/11. This may improve performance of some Windows games.

Use debootstrap on x86 to create an ARM rootfs and install a chroot Debian environment on Android

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Thu, 16 Nov 2023 23:00:00 +0800

According to the Debian Wiki, debootstrap is a wrapper script that can produce a minimal Debian or Ubuntu rootfs (root filesystem) according to personal preference. It is suitable for people who want to set up Linux from scratch themselves, installing a Linux system in a way similar to Arch Linux’s pacstrap.

But that is not my purpose here. I want to move the completed rootfs to a phone for chroot or Termux proot use, and run a Debian environment on the phone.

I will use a Linux computer to create the Debian rootfs. Since the computer is x86_64, I need to use the QEMU emulator in order to enter an ARM64 chroot environment on the computer.

If you do not want to use a computer, then take a more roundabout route: first install chroot Ubuntu on the phone, then install debootstrap inside it to create the Debian rootfs. This method does not need QEMU translation, but it cannot be done through a rootless Termux environment.

Install the debootstrap package; most Linux distributions include it. As for installing arch-linstall-scripts, that is because it provides the useful arch-chroot script

sudo apt install debootstraparch-linstall-scripts

To create an ARM rootfs on an x86 computer, we need to use the qemu-user-static tool to emulate the ARM64 instruction set

sudo apt install qemu-user-static

Confirm that the binfmt service is enabled

sudo systemctl enable --now systemd-binfmt.service

Create the Debian rootfs directory

cd ~/Downloads
mkdir debian

Start creating the Debian 12 Bookworm rootfs, downloading packages from the Taiwan Debian server

sudo debootstrap --arch arm64 --components=main,universe bookworm debian12 http://ftp.tw.debian.org/debian/

After installation, first put qemu-aarc64 into the rootfs, so it will automatically translate instructions

which qemu-aarch64

sudo cp /usr/bin/qemu-aarch64 debian/usr/bin

Chroot into it and do some initialization. When using arch-chroot, you do not need to manually mount /proc and such; everything is handled automatically

sudo arch-chroot debian

Use cat /etc/os-release to confirm that it is a Debian system
After configuring it, exit chroot

exit

Compress the rootfs into a tar.gz

sudo tar -zcpf debian.tar.gz debian/*

Send it to the Android phone with ADB and extract it on the phone.

The process of installing a desktop environment is similar, so I will not repeat it. The steps involving commands below can also be completed first on the computer described above.

If the phone has root privileges, refer to chroot Ubuntu

If it does not have root privileges, refer to Termux proot for installing the desktop environment.

Use Termux qemu-user to emulate x86_64 Ubuntu on ARM64 Android

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Thu, 16 Nov 2023 18:00:00 +0800

This explains how to emulate an x86_64 Ubuntu system on an ARM64 (Aarch64) Android phone through Termux proot-distro.

1. Explanation
#

You may say: most Android devices are ARM64, right? Why not just install the ARM version of Ubuntu? Some programs are just obnoxious and are not compiled for ARM.

So on the road of force-running x86 programs, we have three choices:

Run an ARM64 system and install the Box64 translator
Use qemu-system to start a complete x86_64 emulator, such as Ubuntu x86_64 + QEMU
Use qemu-user to emulate an x86_64 system.

qemu-system runs a virtual machine, emulating complete hardware devices so Linux can run as if it were on a real computer. Of course, it consumes a lot of resources.

qemu-user, on the other hand, is a userspace emulator that can emulate x86 executables on ARM64 devices without needing the resources of an entire virtual machine.

QEMU supports emulating many architectures. Besides x86_64, emulating 32-bit x86, RISC-V, and other architectures is also possible.

In Termux, as long as we have a rootfs, we can get a Linux system running without using qemu-system virtual machine emulation.

The proot-distro tool has built-in qemu support. This article discusses using the proot-distro tool together with qemu-user to run an x86_64 system.

Because it is emulated, program execution is naturally slower than native. Add proot’s performance overhead and it becomes even slower. At the end of the article, we will compare the speed of Proot native vs Box64 vs qemu-user.

2. Test environment
#

Phone: Sony Xperia 10 V, Android 13
Linux kernel version: 5.4
Termux version: 0.118.0
qemu-user version: 8.1.0
Ubuntu version: 20.04 (Ubuntu 22.04 runs into a problem where apt pub_key cannot be imported)

3. Create an x86_64 proot Ubuntu
#

Refer to proot-distro rootfs and add the Ubuntu 20.04_x86_64.sh script. But here we need to change the content a little.

vim $PREFIX/etc/proot-distro/ubuntu20.04_x86_64.sh

Modify it as follows

# Specify the architecture as x86_64
DISTRO_ARCH=x86_64

DISTRO_NAME="Ubuntu20.04 x86_64"

DISTRO_COMMENT="Ubuntu 20.04 Focal x86_64"

TARBALL_STRIP_OPT=0

# Download the x86_64 Ubuntu base
TARBALL_URL['x86_64']="https://cdimage.ubuntu.com/ubuntu-base/focal/daily/current/focal-base-amd64.tar.gz"

TARBALL_SHA256['x86_64']="16c831cc71b8ab79e5156451558df4a025783ba335047f6343518e7225416929"

Install qemu-user-x86-64

pkg install qemu-user-x86-64

Install Ubuntu

proot-distro install ubuntu20.04_x86_64

proot-distro login ubuntu20.04_x86_64

Through the uname -a command, you can see that the architecture is x86_64, and no Exec format error appears.
If a signal 11 Segmentfault error appears while installing packages, just run dpkg --configure -a once.

4. Compare native and emulated execution speed
#

Note: qemu-user in the table below refers to the method in this article

native represents the arm64 executables installed in proot Ubuntu

Box64 means using the box64 command in proot Ubuntu to translate and run x86_64 executables

Use 7z to extract a 133MB zip file, and use time to measure how long it takes to complete.

Use a custom rootfs in Termux proot-distro to create a Linux container

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Thu, 16 Nov 2023 16:00:00 +0800

This article demonstrates how to add your preferred Linux distribution to the proot-distro tool in Android Termux.

Using Ubuntu as an example, we will install the older Ubunut 22.04 LTS proot Ubuntu.

1. proot vs proot-distro
#

proot is a userspace implementation of chroot, allowing chroot-like functionality without root privileges.

Some developers distribute Termux proot distributions by brute-forcing it with the proot command. For example, Box64Droid downloads a custom rootfs, then uses a long chain of commands to log in to the proot distribution.

But since we have the useful proot-distro script, why not make good use of it? It is a wrapper script for proot, integrating the processes of downloading, logging in to, and logging out of proot distributions, while also making it convenient to execute commands.

I explained its usage in proot-distro usage, but what if the distributions provided by the proot-distro maintainers do not meet your needs? For example:

You need a rootfs for a specific Linux version, such as an LTS version of Ubuntu, but proot-distro’s Ubuntu is always the latest version.
You need a rootfs for a specific architecture, such as 32-bit x86 Manjaro
You want to run an x86_64 system on an ARM64 device

Fortunately, proot-distro allows us to “register” proot distributions. We can add our own rootfs and then operate it with the proot-disro command.

2. How to build a custom Linux rootfs
#

Most distributions have their own rootfs building tools. Note that packages like debootstrap included in Termux may have permission issues, so it is safer to create the rootfs on a Linux computer and then move it to the phone.

Ubuntu: debootstrap or download an automatically built rootfs
Debian：debootstrap
Fedora：supermin
openSUSE: download an automatically built rootfs
Alpine：Bootstrapping Alpine Linux
Arch：pacstrap
Manjaro：pacstrap
Void：Installation via chroot

You can also refer to the proot-distro author’s scripts to understand how to create a custom rootfs.

3. Register a new Ubuntu proot-distro
#

Open Termux and install proot-distro

pkg install proot-distro

Go to Ubuntu daily builds and copy the Ubuntu base 22.04 URL. This is a minimal system.
Temporarily download it to the Termux home directory

pkg install wget

wget https://cdimage.ubuntu.com/ubuntu-base/releases/22.04/release/ubuntu-base-22.04.3-base-arm64.tar.gz

Calculate the SHA256 checksum, then remove it

pkg install coreutils

sha256sum ubuntu-base-22.04.3-base-arm64.tar.gz

rm ubuntu-base-22.04.3-base-arm64.tar.gz

Switch to $PREFIX/etc/proot-distro, where proot scripts are stored, copy the sample script, and name it ubuntu22.04.sh

cd $PREFIX/etc/proot-distro
cp distro.sh.sample ubuntu22.04.sh

Edit it

vim ubuntu22.04.sh

Add the following content. I omitted the original comments.

# The architecture should match the phone processor architecture
DISTRO_ARCH=aarch64

# Display name of the distribution
DISTRO_NAME="Ubuntu 22.04 LTS"

# Comment
DISTRO_COMMENT="Ubuntu 22.04 LTS Jammy Jellyfish"

# Directory depth of the archive, default is 1, which ignores the root directory. But Ubuntu base extracts directly as the filesystem, so set 0 here
TARBALL_STRIP_OPT=0

# Each architecture in the array corresponds to a rootfs URL. You can also upload the rootfs to your own Github instead
TARBALL_URL['aarch64']="https://cdimage.ubuntu.com/ubuntu-base/releases/22.04/release/ubuntu-base-22.04.3-base-arm64.tar.gz"

# Fill in the archive's SHA256 checksum
TARBALL_SHA256['aarch64']="bdae94b05d0fca7decbe164010af2ac1b772a9dda21ed9fb5552b5674ad634a3"

# Commands to run after installation
distro_setup() {
 run_proot_cmd touch /etc/hello-world
}

Try running proot-distro list; you can see that the Ubuntu 22.04 LTS we just added has appeared in the list

Install Linux distributions on an Android phone: Termux proot-distro tutorial

infoivonblog.nkfjt@aleeas.com (Ivon Huang) — Thu, 16 Nov 2023 15:00:00 +0800

This article discusses how to use proot-distro to install Linux distributions.

Termux, as a terminal emulator, can install Linux distributions on a phone with the proot-distro tool, without root privileges.

For example, you can install Ubuntu, Arch Linux, Alpine Linux, Fedora, Debian, openSUSE, and so on.

Running Debian 11 on a Sony Xperia 5 II

Linux distributions installed by proot-distro only have a text interface. The graphical interface has to be configured yourself.

If you find that troublesome, you can refer to the automated scripts provided at the end of the article.

1. What are proot & proot-distro?
#

On a GNU/Linux computer system, we can use the chroot command to create an isolated Linux environment. This is the earliest container concept, which appeared before cgroups. After switching into it through the chroot command, it feels as if you have entered another system. For example, using debootstrap on Ubuntu to create a Debian environment, then running a Debian environment.

chroot is neither a virtual machine nor an emulator, because the inside of a chroot container shares the Linux kernel with the host and shares many system resources.

Termux Tutorials on Ivon's Blog

A simple Termux tutorial for beginners

1. Download Termux APK #

2. Things to do after installing Termux #

2.1. Interface overview #

2.2. Update packages #

How to use Termux X11 - The X Server for Android Phone

1. Install Termux X11 #

2. Usage 1: Run X11 apps in Termux #

3. Usage 2: Run X11 apps in Proot-distro #

Accelerate QEMU virtual machines in Termux with pKVM

1. Install packages #

2. Create a Linux virtual machine in Termux #

References #

Android's new Debian Linux Terminal may not become a Termux killer

Write Python on an Android phone: setting up a Termux Python development environment

1. Text-only or graphical interface? #

2. Run Python in Termux or proot-distro? #

3. How to install Python in Termux? #

Launch X11 graphical programs from proot-distro on Termux's XFCE desktop

1. Install a desktop environment for Termux #

2. Configure proot-distro #

3. Launch programs inside proot-distro from the Termux desktop #

How to connect remotely to Termux's Linux desktop with VNC

1. Choose a VNC client #

2. Configure the VNC server #

Run the VNC server directly in Termux #

Run the VNC server inside proot-distro #

Use a phone as a computer: run desktop Linux software with iPad + Android Termux

1. Motivation #

Manage auto-starting services: how to use Termux-services & Termux:Boot

1. Termux-services auto-start #

2. Termux:Boot auto-start on boot #

Running postmarketOS on Android Termux proot without flashing a custom rom

1. Motivation #

Solutions when Termux proot cannot use the systemctl command

Method 1: Start the program directly from the executable path #

Method 2: Switch to a distribution that uses OpenRC #

Method 3: Run a full Linux system virtual machine #

Install a graphical desktop environment and audio output in Termux

1. Prerequisites #

2. Install the XFCE desktop environment #

3. Connect to the graphical interface #

Termux X11 #

VNC server #

A brief look at Termux file management: sharing files between Linux environments and Android

1. Termux’s own root directory #

2. Termux’s home directory #

3. Termux reading Android internal storage #

Install Ubuntu on Android: emulate an x86_64 Linux virtual machine with QEMU in Termux

1. Environment #

2. Install prerequisite packages #

3. Install the Linux virtual machine #

Play Windows games from Steam on an Android phone: Mobox emulator tutorial

1. Hardware requirements #

My test environment #

2. Install prerequisite packages #

3. Install Mobox #

How to run Windows programs on Android with Box86 + Wine in Termux Proot

1. Install Termux Proot #

2. Install Box86 & Box64 #

3. Install Wine and Wine64 #

4. Install DXVK #

Use debootstrap on x86 to create an ARM rootfs and install a chroot Debian environment on Android

Use Termux qemu-user to emulate x86_64 Ubuntu on ARM64 Android

1. Explanation #

2. Test environment #

3. Create an x86_64 proot Ubuntu #

4. Compare native and emulated execution speed #

Use a custom rootfs in Termux proot-distro to create a Linux container

1. proot vs proot-distro #

2. How to build a custom Linux rootfs #

3. Register a new Ubuntu proot-distro #

Install Linux distributions on an Android phone: Termux proot-distro tutorial

1. What are proot & proot-distro? #

1. Download Termux APK
#

2. Things to do after installing Termux
#

2.1. Interface overview
#

2.2. Update packages
#

1. Install Termux X11
#

2. Usage 1: Run X11 apps in Termux
#

3. Usage 2: Run X11 apps in Proot-distro
#

1. Install packages
#

2. Create a Linux virtual machine in Termux
#

References
#

1. Text-only or graphical interface?
#

2. Run Python in Termux or proot-distro?
#

3. How to install Python in Termux?
#

1. Install a desktop environment for Termux
#

2. Configure proot-distro
#

3. Launch programs inside proot-distro from the Termux desktop
#

1. Choose a VNC client
#

2. Configure the VNC server
#

Run the VNC server directly in Termux
#

Run the VNC server inside proot-distro
#

1. Motivation
#

1. Termux-services auto-start
#

2. Termux:Boot auto-start on boot
#

1. Motivation
#

Method 1: Start the program directly from the executable path
#

Method 2: Switch to a distribution that uses OpenRC
#

Method 3: Run a full Linux system virtual machine
#

1. Prerequisites
#

2. Install the XFCE desktop environment
#

3. Connect to the graphical interface
#

Termux X11
#

VNC server
#

1. Termux’s own root directory
#

2. Termux’s home directory
#

3. Termux reading Android internal storage
#

1. Environment
#

2. Install prerequisite packages
#

3. Install the Linux virtual machine
#

1. Hardware requirements
#

My test environment
#

2. Install prerequisite packages
#

3. Install Mobox
#

1. Install Termux Proot
#

2. Install Box86 & Box64
#

3. Install Wine and Wine64
#

4. Install DXVK
#

1. Explanation
#

2. Test environment
#

3. Create an x86_64 proot Ubuntu
#

4. Compare native and emulated execution speed
#

1. proot vs proot-distro
#

2. How to build a custom Linux rootfs
#

3. Register a new Ubuntu proot-distro
#

1. What are proot & proot-distro?
#