MATE Desktop on Android Phone without Emulator

[Jakarta2]

MATE Desktop on a Android Phone with Native Termux

If it’s not understand, I’ll explain in full what Termux and PRoot is and how to run DE Linux on Android

Termux is a Linux terminal environment for Android that allows users to run many common command-line tools and programming languages without root access. Unlike traditional terminal emulators, it includes its own package repository and can install software such as Python, Node.js, Rust, Git, GCC, Clang, Vim, and many others. Applications running directly inside Termux use Android’s native Linux kernel, making them fast, lightweight, and efficient in terms of RAM, storage, and battery usage.

PRoot is a user-space implementation of chroot that does not require root privileges. It allows users to run complete Linux distributions such as Debian, Ubuntu, Arch Linux, or Alpine inside Termux. PRoot works by intercepting system calls and presenting an alternative filesystem layout to applications, making them believe they are running in a standard Linux environment.

Architecture Difference

Native Termux

• Runs directly on Android kernel
• Uses Android-compatible libraries (Bionic libc)
• Packages are compiled specifically for Android
• No emulation layer between user space and kernel

PRoot (proot-distro)

• Uses Linux distributions with standard GNU/glibc userspace
• Runs inside user-space emulation layer
• Intercepts filesystem and process calls using ptrace
• Simulates root filesystem without real root access

In simple terms:

• Termux = Android-native Linux environment
• PRoot = Linux distro running through a compatibility layer on top of Android

Package Repository Model

Termux Repository

Termux uses its own repository:

• Built and maintained specifically for Android
• Packages are heavily patched or rebuilt for Bionic libc
• Optimized for ARM Android devices

Includes:

• Python (Termux build)
• Node.js (Android-optimized build)
• Rust toolchain
• Clang / GCC
• Git, SSH, Vim, etc.
• Other packages

Key point: Not all Linux packages exist here because everything must be Android-compatible.

PRoot Repository (Debian/Ubuntu/Arch)

PRoot uses official Linux repositories:

• Debian: stable/testing/unstable repos
• Ubuntu official repos
• Arch Linux repos

Includes:

• Full GNU/Linux ecosystem
• System tools not available in Termux
• Desktop packages
• Office suite
• Browser
• other packages

Key point: This is a complete Linux software ecosystem identical to PC Linux distributions.

Performance Comparison

The main advantage of native Termux is performance. Applications run directly on Android with minimal overhead, making it the preferred choice for scripting, programming, automation, SSH, development tools, and lightweight servers. Because there is no translation layer, system calls are executed directly, resulting in high efficiency and low latency.

PRoot, on the other hand, introduces a user-space translation layer. It intercepts system calls, especially filesystem operations, and rewrites them dynamically. This introduces measurable overhead.

Real-world impact

Native Termux performance:

• Very fast startup time
• Fast package execution
• Efficient file I/O
• Low RAM usage
• Battery efficient

PRoot performance:

• Slower package installation (apt/dpkg)
• Slower file extraction
• Higher memory usage
• Noticeable overhead in build systems (npm, cargo, gcc large projects)

Practical Performance Insight

In practice, the performance difference is often small for tasks like:

• Editing files
• Running scripts
• Using Git
• SSH connections
• Remote server administration

However, workloads involving frequent filesystem access or large-scale compilation can be noticeably slower under PRoot. This includes:

• Building large C/C++ projects
• Installing heavy npm dependencies
• Compiling Linux software from source
• Extracting large archives

The bottleneck in PRoot is not CPU, but filesystem emulation overhead.

Compatibility vs Performance Trade-off

Native Termux

• High performance
• Limited Linux compatibility
• Android-centric ecosystem
• No full systemd support
• Not a full Linux distro

PRoot

• Full Linux compatibility
• Access to Debian/Ubuntu/Arch ecosystems
• Can run desktop environments
• Supports wider software range
• Slower due to emulation layer

Desktop Environment Support (DE)

PRoot becomes especially important when running a Linux desktop environment.

Supported DE inside PRoot:

• XFCE (most popular, balanced performance)
• LXQt (lightweight)
• MATE
• KDE Plasma (heavy but usable)
• GNOME (very heavy, not recommended on low-end devices)

With tools like:

• Termux:X11 (modern approach)
• VNC server (traditional method)

This enables a full Linux desktop experience inside Android without root access.

Native Termux can also run GUI applications, but it is more limited and requires additional configuration.

Resource Usage

Native Termux

• Small installation footprint
• Shared Android libraries
• Efficient memory usage
• Minimal battery drain

PRoot

• Large storage usage (full Linux filesystem)
• Higher RAM consumption
• Duplicate system libraries
• More CPU overhead during filesystem operations

The trade-off between Termux native and PRoot is straightforward.

The main advantage of native Termux is performance, simplicity, and efficiency. It is ideal for development workflows, scripting, automation, and lightweight server tasks directly on Android.

PRoot, on the other hand, offers much greater compatibility with traditional Linux software and package repositories, but introduces additional overhead, particularly for file-intensive operations such as package installation, archive extraction, and large software builds.

For most users, native Termux is the best option for everyday development and command-line work. PRoot becomes useful when specific Debian, Ubuntu, or Arch packages are required, or when setting up a full desktop Linux environment through solutions such as Termux:X11.

If you want a complete setup method, I will separate it into a separate topic, and then I will experiment installing Ubuntu via PRoot and then installing Full GNOME.

Device: Tecno Pova 6

Phone specs:

• SoC: Mediatek Helio G99
• GPU: Mali G57MC2
• Ram: 8GB LPDDR4X
• Storage: 256GB UFS 2.2
• OS: Android 15

[andreas]

That’s really cool! Nice

[Jakarta2]

Yeah, especially if I install Proot Debian/Ubuntu, then install MATE, OnyOffice, GIMP, Inkspace, chrome, programming language, blender, etc., my phone will become a mini Linux desktop

[Jakarta2]

Now I have fixed it to use GPU Acceleration

[ericmarceau]

Marcel, would you offer an opinion on whether that would work for an Acer Iconia One 10 (B3-A20) tablet 16GB?

It has Android 5.1 (Lollipop) running.

Sounds like I would need to root to accomplish that, but I have never seen any references that gave me that warm fuzzy feeling that a specified tool+method would actually give me root.

[Jakarta2]

The Acer Iconia One 10 B3-A20 is basically a low-end budget tablet from around 2015. It runs a MediaTek MT8163 quad-core Cortex-A53 chip, Mali-T720 GPU, 1GB of RAM, and 16GB of storage. On paper it still looks usable for light Android tasks like browsing or video playback, but it’s clearly limited by its RAM and aging system.

Main bottleneck isn’t the CPU, but the memory and Android version. Android 5.1 already consumes a large portion of that 1GB RAM, leaving very little space for anything else. Once you try to push it into heavier workloads like Linux userspace or a desktop environment, things fall apart quickly. The system starts killing background apps, swapping aggressively, and generally struggling to keep stability.

For Termux:X11 specifically, this is where it breaks down. It relies on a modern Android graphics stack and updated SurfaceFlinger behavior, which simply doesn’t exist properly on Android 5.1. Even with older Termux builds, X11 support is either unstable or practically unusable.

So realistically, running a Linux GUI on this device isn’t about tweaking or rooting. It’s a hard platform limitation. Basic CLI Linux might still work through Termux or proot, but anything like XFCE or MATE over X11 feels like forcing modern desktop workflows onto legacy hardware. It may boot, but it’s not comfortable to use.

If the goal is a smooth Termux + X11 desktop experience, a more realistic baseline is at least Android 10 with 6GB RAM or more.

Good modern options in this range include devices like:

Xiaomi Pad 6 - very strong performance for the price, smooth 144Hz display, and excellent for Linux experimentation

Samsung Galaxy Tab S9 FE - more software polish, better long-term updates, and solid ecosystem integration

Samsung Galaxy Tab S9 - high-end performance, closest to laptop-level Android experience

Lenovo Xiaoxin Pad Plus 11 - more budget-friendly, still usable but less powerful than the others

These devices sit in the “actually usable desktop Android” zone. Anything below 6GB RAM tends to drift into experimental territory rather than something you can rely on daily for Linux GUI workflows.

[ericmarceau]

Thank you, Marcel! I appreciate your insights and feeback on this.

My tablet is showing its age, with the battery coming to end-of-life, and no way to replace it short of ripping it open and using a soldering iron, according to a cell-phone shop where I asked about a battery replacement!

So, I am about to scrap it, but still use it for reading some PDFs at night, until it decides to not boot up anymore.

I was prepared to “experiment” if there was a chance at success.

Thanks again.

[svhs27102]

I have an Android tablet that I like quite a bit, but my problem with Android is always how laggy it seems to be in my experiences. True Linux always seems to be way snappier. How would I go about installing a Linux distro like Debian/Ubuntu on my tablet like you said?