DEV Community: Ai2th

Linxr | Part 11 — The v3.0.0 Milestone & Official Release

Ai2th — Wed, 05 Aug 2026 07:38:36 +0000

After months of intensive engineering across Linux kernel customization, QEMU virtualization tuning, Storage Access Framework (SAF) integration, and Docker container management, we are proud to publish the culmination of our journey: Linxr v3.0.0!

This final post in our 11-part series brings together all the technical innovations built across the project.

🌟 The Linxr v3.0.0 Landmark

Linxr turns any arm64 Android device into a rootless Linux workstation and Docker container host. Here is everything packed into our milestone release:

1. Alpine Linux 3.20 & Kernel 6.18-virt (LTS)

Guest kernel compiled with full preemption (PREEMPT_DYNAMIC), Virtio drivers (net, blk, rng, 9p), and SLIRP networking.
OpenRC init, OpenSSH server, sudo, and full apk repository access.

2. Embedded Docker Container Dashboard (Pockr Merged)

Single unified VM hosting both the root shell and the Docker daemon (dockerd).
45% RAM reduction compared to running separate VM instances.
Dedicated Containers tab in Flutter to pull images, launch microservices, and stream container logs in real time.

3. Live System & VM Boot Serial Logs

Expandable System & VM Logs console streaming real-time kernel output (dmesg, init, sshd) directly on the Home Screen for 100% transparency.

4. Virtio-9P Storage & SAF Folder Picker

POSIX file sharing at /storage/emulated/0/LinxrShare mounted inside guest VM at /mnt/sdcard.
Integrated Storage Access Framework (SAF) folder picker in Settings to select custom host directories.

5. High-Speed Terminal & Instant Typing

TCP_NODELAY socket tuning eliminating terminal typing latency (<15ms input response).
Thread-safe SSH ping lock guard ensuring instant auto-reconnection upon boot.

💬 Community & Discussion

Join our official Google Group for updates, feedback, and technical discussions:

👉 AI2TH Community: https://groups.google.com/g/ai2th

(Note: Please check your Spam folder if you haven't received your email invitation!)

📥 Get Linxr v3.0.0

📲 Get it on Google Play: https://play.google.com/store/apps/details?id=com.ai2th.linxr
🐙 GitHub Release: https://github.com/AI2TH/Linxr/releases/tag/v3.0.0%2B26
🌐 Official Website: https://ai2th.github.io/linxr.html

Thank you to everyone in our community for following this engineering journey!

Linxr | Part 10 — Automated End-to-End Testing for Mobile Virtual Machines

Ai2th — Wed, 05 Aug 2026 07:37:37 +0000

In Part 9, we detailed automatic disk expansion. In this installment (Part 10), we share how we built automated End-to-End (E2E) testing pipelines for Android QEMU virtual machines!

Automated Quality Assurance for Mobile VMs

Testing a virtual machine running inside an Android app sandbox presents unique challenges:

How do you verify QEMU booted cleanly without manual screen inspection?
How do you measure boot speed benchmarks across different device models?
How do you validate vCPU and RAM resource limits automatically?

Kotlin Instrumentation Test Pipeline

We created dedicated Android JUnit instrumentation tests (VmE2ETest.kt and VmResourceTest.kt):

@RunWith(AndroidJUnit4::class)
class VmE2ETest {

    @Test
    fun testVmBootAndSshConnection() {
        val context = InstrumentationRegistry.getInstrumentation().targetContext
        val vmManager = VmManager(context)

        // 1. Start QEMU VM
        val bootSuccess = vmManager.startVm(vCpus = 2, ramMb = 2048)
        assertTrue("VM failed to boot within timeout", bootSuccess)

        // 2. Execute test command over SSH
        val sshClient = SshClient("127.0.0.1", 2222, "root", "alpine")
        val output = sshClient.executeCommand("uname -a && docker --version")

        assertTrue(output.contains("Linux"))
        assertTrue(output.contains("Docker"))
    }
}

These tests run automatically on physical test devices via ADB, logging boot timings, verifying SSH socket readiness, and guaranteeing release stability before Play Store uploads.

Download Linxr

📲 Google Play: https://play.google.com/store/apps/details?id=com.ai2th.linxr
🐙 GitHub: https://github.com/AI2TH/Linxr
💬 Google Group: https://groups.google.com/g/ai2th

Linxr | Part 9 — Dynamic Storage Expansion & Automatic resize2fs on Boot

Ai2th — Wed, 05 Aug 2026 07:36:45 +0000

In Part 8, we solved network latency for instant terminal typing. Today in Part 9, we explain how we implemented dynamic virtual disk expansion (resize2fs) across reboots without data loss.

The Problem: Hardcoded 1.4 GB Filesystems

In early Linxr builds, setting 30 GB or 50 GB storage in Settings appeared to allocate a larger QCOW2 virtual disk. However, inside Alpine Linux, running df -h still reported only 1.4 GB of usable disk space!

Why?

The base rootfs image was formatted as a 1.4 GB ext4 partition.
Expanding the QCOW2 overlay on Android enlarged the block device, but the guest ext4 filesystem never expanded to fill the new capacity.

The Solution: OpenRC diskexpand Service

To automate seamless filesystem expansion:

Bundling e2fsprogs-extra: Installed resize2fs into the base Alpine Linux rootfs.
Boot-Time Auto-Expansion: Created a dedicated OpenRC init service (/etc/init.d/diskexpand) running before sshd starts:

#!/sbin/openrc-run

depend() {
    need localmount
    before sshd
}

start() {
    ebegin "Expanding ext4 filesystem to fill virtual disk"
    resize2fs /dev/vda2 >/dev/null 2>&1
    eend $?
}

Because resize2fs is a fast online operation, it runs in milliseconds on boot. If the disk cap is unchanged, it returns instantly as a no-op; if the user selects 50 GB in Settings, it expands the filesystem dynamically with zero data loss!

Linxr | Part 8 — Fixing Network Latency & SLIRP Terminal Slowness

Ai2th — Wed, 05 Aug 2026 07:36:43 +0000

In earlier parts of our series, we covered SSH terminals, Docker integration, and storage passthrough. Today in Part 8, we share the deep network engineering required to fix terminal latency and optimize SLIRP user-mode networking in QEMU on Android.

The Symptom: Terminal Typing Lag

During initial testing, typing commands in the SSH terminal tab felt slightly delayed. Keystrokes would buffer for 100–300ms before rendering on screen.

When investigating with tcpdump and socket trace tools, we discovered the root cause:

QEMU SLIRP User-Mode Stack: SLIRP runs entirely in user-space inside the Android process sandbox (no TAP/TUN devices without root).
Nagle’s Algorithm & Socket Buffering: Small SSH keystroke packets (1 byte) were being delayed by socket buffering mechanisms looking to coalesce small TCP frames.

The Fix: TCP_NODELAY & Virtio-Net Tuning

To eliminate typing latency:

Disabling Nagle's Algorithm: Forced TCP_NODELAY on local SSH port forwards (port 2222) and local proxy bridges.
Virtio-Net MTU Configuration: Tuned guest network interface MTU to 1500 with checksum offloading disabled to reduce guest-to-host packet fragmentation.

The result? Keystroke response times dropped from 250ms to under 15ms, delivering a desktop-grade shell experience on phone screens.

Download & Links

📲 Google Play: https://play.google.com/store/apps/details?id=com.ai2th.linxr
🐙 GitHub Releases: https://github.com/AI2TH/Linxr/releases/latest
💬 Google Group: https://groups.google.com/g/ai2th

Pockr | Part 7 — Standalone App Deprecated & Merged into Linxr

Ai2th — Wed, 05 Aug 2026 07:32:19 +0000

In earlier parts of the Pockr engineering series, we chronicled our journey bundling native binaries, configuring Linux kernel modules, and executing Docker containers on non-rooted Android hardware.

Today, we are announcing a major milestone: Standalone Pockr has officially been merged into Linxr!

Why Merge Pockr into Linxr?

Running Pockr and Linxr as separate applications required users to run two independent QEMU virtual machine instances:

Double memory overhead (consuming 2 GB+ RAM for two VMs).
Fragmented workflows between terminal commands and container dashboards.

By unifying Pockr into Linxr v3.0.0:

Single Lightweight VM: One Alpine Linux 3.20 guest VM hosts both the interactive root shell and the Docker daemon (dockerd).
Native Containers Tab: All container dashboards, image pulling, live container log streaming, and container lifecycle actions are natively accessible inside Linxr.
45% RAM Reduction: Drastically lower memory and CPU usage on mobile processors.

How to Access Pockr Features in Linxr

Upgrade to Linxr v3.0.0 (Build 26).
Open the app and navigate to the new Containers tab.
Pull Docker images, launch microservices, and inspect container logs directly inside Linxr!

Join the Community & Get Started

📲 Get Linxr on Google Play: https://play.google.com/store/apps/details?id=com.ai2th.linxr
🐙 Linxr GitHub Repository: https://github.com/AI2TH/Linxr
💬 AI2TH Google Group: https://groups.google.com/g/ai2th
🌐 Official Website: https://ai2th.github.io/linxr.html

Thank you for following the Pockr development journey! All future container & Linux updates will continue in the Linxr series.

Linxr | Part 7 — Merging Docker Engine & Container Dashboard into Flutter

Ai2th — Wed, 05 Aug 2026 07:23:45 +0000

In Part 6, we explored how Virtio-9P and Android SAF enable seamless host-to-guest file sharing. Today in Part 7, we dive into how we merged Pockr into Linxr to create a unified Docker container management dashboard running on non-rooted Android devices.

The Vision: One App for VMs and Containers

Initially, Pockr was built as a standalone Android app for running Docker containers. However, managing two separate QEMU VM instances consumed double the RAM and disk space on mobile devices.

For Linxr v3.0.0, we unified both projects:

Single Guest VM: Alpine Linux 3.20 host running both the root shell and the Docker daemon (dockerd).
Containers Tab: A Flutter UI tab for deploying, monitoring, and streaming logs from Docker containers.

Architecture: Talking to `dockerd` Inside QEMU

To manage Docker containers from Flutter without SSH overhead for every action, we created a lightweight Python API daemon (api_server.py) running inside Alpine Linux:

Docker Unix Socket Access: api_server.py communicates directly with /var/run/docker.sock.
REST API Endpoints: Exposes endpoints for listing containers (GET /containers), starting/stopping containers (POST /containers/:id/start), and streaming logs (GET /containers/:id/logs).
Flutter Platform Client: Flutter calls local VM API endpoints over port 8080.

[ Flutter Containers UI ] ──( HTTP / port 8080 )──> [ api_server.py ] ──( Unix Socket )──> [ Docker Daemon ]

Container Log Streaming in Flutter

Streaming real-time container stdout/stderr logs required a non-blocking chunked response handler in Flutter:

Stream<String> streamContainerLogs(String containerId) async* {
  final request = await httpClient.getUrl(Uri.parse('http://127.0.0.1:8080/containers//logs'));
  final response = await request.close();

  await for (final chunk in response.transform(utf8.decoder)) {
    yield chunk;
  }
}

This stream feeds directly into a reactive Flutter log viewer with auto-scroll and line filtering.

Results & Benchmark

By merging Pockr into Linxr:

RAM Savings: Memory usage dropped by 45% compared to running separate VM instances.
Unified Controls: Developers can spin up an nginx container in the Containers tab and immediately inspect its configuration files via the built-in Terminal tab (linxr:~#).

Download Linxr v3.0.0

📲 Google Play: https://play.google.com/store/apps/details?id=com.ai2th.linxr
🐙 GitHub Releases: https://github.com/AI2TH/Linxr/releases/latest
💬 Google Group: https://groups.google.com/g/ai2th

Linxr | Part 6 — Building Virtio-9P Storage Sharing & SAF on Android

Ai2th — Wed, 05 Aug 2026 07:23:42 +0000

In Part 5 of our engineering series, we introduced the high-level features of Linxr v3.0.0. Today in Part 6, we take a deep technical dive into how we solved host-to-guest file sharing on modern Android using Virtio-9P and Android’s Storage Access Framework (SAF).

The Challenge: Android Scoped Storage vs Linux Filesystems

Standard Linux virtual machines expect direct POSIX file path access (/home/root/files, /mnt/storage). However, Android 10+ enforces strict Scoped Storage rules and granular URI permissions.

Passing raw host paths to QEMU without root permissions often fails due to Android app sandbox boundaries. We needed a dual-layer solution:

Direct high-speed POSIX passthrough for app-managed storage.
User-configurable folder selection via Android Storage Access Framework (SAF).

Layer 1: Virtio-9P Driver in QEMU

QEMU provides the 9P network filesystem protocol (virtio-9p-pci), which exposes host directory trees to Linux guests with low CPU overhead.

We configured QEMU command-line parameters in VmManager.kt:

val virtioArgs = listOf(
    "-fsdev", "local,id=fsdev0,path=$sharePath,security_model=none",
    "-device", "virtio-9p-pci,fsdev=fsdev0,mount_tag=LinxrShare"
)

Inside Alpine Linux, an OpenRC startup service automounts this tag on boot:

mount -t 9p -o trans=virtio,version=9p2000.L LinxrShare /mnt/sdcard

Any file saved in /storage/emulated/0/LinxrShare on Android instantly appears inside Alpine Linux under /mnt/sdcard!

Layer 2: Storage Access Framework (SAF) & `pickFolder` Channel

To allow users to select custom folders (such as Downloads, Documents, or external SD cards), we implemented a native Kotlin MethodChannel handler (pickFolder):

MethodChannel(flutterEngine.dartExecutor.binaryMessenger, "com.ai2th.linxr/vm")
    .setMethodCallHandler { call, result ->
        if (call.method == "pickFolder") {
            val intent = Intent(Intent.ACTION_OPEN_DOCUMENT_TREE).apply {
                addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_GRANT_WRITE_URI_PERMISSION)
            }
            activity.startActivityForResult(intent, REQUEST_CODE_SAF_PICK_FOLDER)
        }
    }

When a user selects a folder, Android returns a persistent DocumentFile URI. We resolve the underlying POSIX path and pass it to QEMU's Virtio-9P filesystem driver.

What’s Next?

In Part 7, we will explore how we embedded the Docker Engine and built a real-time container management dashboard in Flutter!

👉 Official Website: https://ai2th.github.io/linxr.html

👉 Google Group: https://groups.google.com/g/ai2th

Linxr | Part 5 — Live Boot Logs, SAF Storage & Merging Docker

Ai2th — Wed, 05 Aug 2026 07:22:47 +0000

In Part 4, we showcased Linxr booting Alpine Linux in QEMU on non-rooted Android devices. Today in Part 5, we dive deep into the major architectural updates that powered our v3.0.0 release: bringing live serial boot diagnostics, seamless Storage Access Framework (SAF) file sharing, and embedding full Docker container management directly into Linxr.

1. Opening the Black Box: Live Serial Log Streaming

In earlier builds, VM startup was a bit of a black box—users saw a spinning loading indicator until port 2222 opened for SSH. If the kernel panicked or a system service hung during boot, there was no visibility inside the app UI.

To solve this, we redirected Alpine’s kernel console to serial output (/dev/ttyS0):

Kernel & OpenRC Logs: Intercepted dmesg, init scripts, and sshd startup logs directly from the guest virtual serial console.
Flutter UI Integration: Added a real-time System & VM Logs console widget on the Home Screen with live auto-scroll, search, and copy-to-clipboard actions.

2. Bridging Host & Guest Storage: Virtio-9P + SAF

Linux virtual machines running under QEMU require clean POSIX filesystem access to exchange files with the Android host system.

Virtio-9P Passthrough: Configured QEMU's virtio-9p-pci driver to expose host directories to the guest OS, mounting /storage/emulated/0/LinxrShare inside Alpine Linux at /mnt/sdcard.
SAF Document Tree Picker: Built a Kotlin MethodChannel handler (pickFolder) calling Android’s Storage Access Framework (ACTION_OPEN_DOCUMENT_TREE) to allow users to select custom host folders from Settings.

3. Merging Pockr: Native Docker Container Dashboard

Previously, container management lived in a separate project named Pockr. For v3.0.0, we unified our architecture by deprecating standalone Pockr and embedding its container controls directly into Linxr:

Containers Tab: Inspect running Docker containers, view CPU/RAM usage, and launch containerized microservices (nginx, redis, alpine).
Live Container Logs: Stream real-time container stdout/stderr logs from the Docker daemon socket inside the Alpine VM.

4. Hardened Boot Probing & SSH Lock Guard

When launching QEMU, the OpenSSH daemon takes a few seconds to initialize. Probing TCP port 2222 concurrently from Flutter while QEMU bound socket ports caused intermittent race conditions.

We introduced a thread-safe SSH probe lock in Kotlin (VmManager.kt):

Suppresses redundant socket connection attempts until QEMU signals full network initialization.
Guarantees instant terminal auto-reconnection as soon as the root shell becomes active.

What’s Next?

Linxr v3.0.0 is officially live on Google Play and GitHub Releases!

Join our community for feature requests and discussions:
👉 Google Group: https://groups.google.com/g/ai2th

Linxr | Part 4 — Test Results

Ai2th — Mon, 09 Mar 2026 17:05:50 +0000

Test Results

Part 4 of 4 — the final chapter of building Linxr, a single APK that runs Alpine Linux on non-rooted Android.
← Part 3: SSH Terminal in Flutter

Download

linxr-v1.apk — v1.0 · ARM64 · 63 MB

Requires Android 8.0+ (API 26), ARM64 device. Enable "Install from unknown sources" before sideloading.

How We Test

Testing on a Mac with an Android emulator doesn't work — QEMU inside an emulator needs nested virtualisation, which isn't available.

We use Firebase Test Lab with an automated Robo test:

Setting	Value
Device	Pixel 2 (arm64)
Android version	11 (API 31)
Test type	Robo (automated UI crawler)
Timeout	600 seconds

Test Result: Pass ✅

→ Full test results

No crashes. Key events from the logcat:

01:29:38  VmManager: startVm()
01:29:38  VmManager: Reusing existing user.qcow2
01:29:38  VmManager: VM process launched

01:29:43  QEMU: OpenRC 0.52.1 is starting up Linux 6.6.14-0-virt (aarch64)
01:29:51  QEMU: * eth0 ... [ ok ]
01:29:52  QEMU: * Starting sshd ... [ ok ]
01:29:52  QEMU: Welcome to Alpine Linux 3.19

From QEMU launch to sshd ready: ~14 seconds.

What the Robo Test Found

The crawler navigated all three tabs — Home, Terminal, About — and exercised the Start VM / Stop VM flow. It found and read through the full open-source component list in the About screen: dartssh2, xterm, QEMU, Alpine, OpenSSH.

No crashes. No ANRs. No unexpected states.

What Works

✅ Install APK → tap Start VM → Alpine boots in ~14 seconds
✅ sshd starts automatically; built-in terminal auto-connects
✅ Persistent overlay — state survives VM restarts
✅ Internet access — apk add works inside the VM
✅ No root. No Termux. No PC required after install.
✅ Foreground service keeps VM alive when app is backgrounded

Current Limitations

Limitation	Notes
ARM64 only	QEMU binary targets `aarch64` only
Password auth	SSH key setup requires manual `~/.ssh/authorized_keys`
No GUI	Text terminal only
APK size 63 MB	Alpine disk image + QEMU + 50 shared libraries

What's Next

[ ] SSH key management from the app UI
[ ] Configurable RAM and vCPU in settings
[ ] File transfer (SCP/SFTP) from the app
[ ] ARM32 / x86_64 support

The Full Series

Linxr Series — Alpine Linux on Android

Linxr = Linux + r. A single Android APK that runs a full Alpine Linux shell on any Android phone — no root, no Termux, no PC required.

#	Post	Topic
📖	Intro	What is Linxr? Start here
1	Part 1	The Idea and Architecture
2	Part 2	Shipping QEMU in an APK
3	Part 3	SSH Terminal in Flutter
4	Part 4	Test Results

GitHub: github.com/AI2TH/Linxr
Website: ai2th.github.io

Contributor: Kalvin Nathan
skalvinnathan@gmail.com · LinkedIn

Linxr | Part 3 — SSH Terminal in Flutter

Ai2th — Mon, 09 Mar 2026 17:03:29 +0000

SSH Terminal in Flutter

Part 3 of 4 — building Linxr, a single APK that runs Alpine Linux on non-rooted Android.
← Part 2: Shipping QEMU in an APK

The Goal

Once Alpine boots and sshd starts, the app needs a usable terminal — without requiring an external SSH client.

Two Flutter packages make this possible:

Package	Role
`dartssh2`	Pure-Dart SSH2 client — connects to the VM's sshd
`xterm`	Terminal emulator widget — renders VT100/xterm sequences

Both are pure Dart. No platform channels, no native code, no extra Android permissions.

Connecting to the VM

final socket = await SSHSocket.connect('127.0.0.1', 2222)
    .timeout(const Duration(seconds: 10));

_client = SSHClient(
    socket,
    username: 'root',
    onPasswordRequest: () => 'alpine',
);

_session = await _client!.shell(
    pty: SSHPtyConfig(
        type: 'xterm-256color',
        width: _terminal.viewWidth,
        height: _terminal.viewHeight,
    ),
);

SSHPtyConfig allocates a pseudo-terminal with xterm-256color — enabling colour output, cursor movement, and correct TERM variable.

Wiring SSH to the Terminal

// VM output → terminal display
_session!.stdout.listen(
    (data) => _terminal.write(String.fromCharCodes(data)),
);

// Keyboard input → SSH session
_terminal.onOutput = (data) {
    _session?.stdin.add(Uint8List.fromList(data.codeUnits));
};

// Terminal resize → SSH PTY resize
_terminal.onResize = (w, h, pw, ph) {
    _session?.resizeTerminal(w, h);
};

Resize events keep tools like vim, htop, and nano correctly sized.

Auto-Reconnect

Alpine takes ~15 seconds to boot. The terminal handles the window where sshd isn't ready yet:

static const _maxRetries = 24; // 24 × 5s = 2 minutes

void _retryOrError(String msg) {
    _retryCount++;
    if (_retryCount < _maxRetries) {
        _terminal.write('\r\n[$msg — retrying in 5s...]\r\n');
        _scheduleConnect(delaySeconds: 5);
    } else {
        _setError('Gave up after $_maxRetries attempts.');
    }
}

Progress messages appear inline in the terminal buffer — no separate loading spinner.

Terminal Theme

theme: const TerminalTheme(
    cursor:     Color(0xFF20C997),   // teal
    foreground: Color(0xFFE0E0E0),   // light grey
    background: Color(0xFF0E1117),   // near-black
    green:      Color(0xFF20C997),
    blue:       Color(0xFF0D6EFD),
    yellow:     Color(0xFFFFC107),
    red:        Color(0xFFDC3545),
)

The cursor teal (#20C997) matches the "Connected" status chip.

VM-Not-Running Banner

if (vmStatus != 'running')
    _Banner(
        icon: Icons.warning_amber,
        color: Color(0xFFFFC107),
        message: 'VM is not running. Start it from the Home tab.',
    )

Prevents confusing "Connection refused" errors when the user opens the terminal before starting the VM.

Next: Part 4 — Test Results

GitHub: github.com/AI2TH/Linxr

Linxr Series — Alpine Linux on Android

Linxr = Linux + r. A single Android APK that runs a full Alpine Linux shell on any Android phone — no root, no Termux, no PC required.

#	Post	Topic
📖	Intro	What is Linxr? Start here
1	Part 1	The Idea and Architecture
2	Part 2	Shipping QEMU in an APK
3	Part 3	SSH Terminal in Flutter
4	Part 4	Test Results

GitHub: github.com/AI2TH/Linxr
Website: ai2th.github.io

Linxr | Part 2 — Shipping QEMU in an APK

Ai2th — Mon, 09 Mar 2026 17:03:22 +0000

Shipping QEMU in an APK

Part 2 of 4 — building Linxr, a single APK that runs Alpine Linux on non-rooted Android.
← Part 1: The Idea and Architecture

The Same Wall as Pockr

Getting QEMU to run on non-rooted Android is the same challenge Pockr solved first. If you've read Pockr Part 2 and Part 3, you already know the full story. This article gives the overview as it applies to Linxr.

Problem 1: SELinux Blocks execve()

On Android 10+, files in app storage have the SELinux label app_data_file. That label does not allow execve().

Cannot run program ".../files/qemu/qemu-system-aarch64":
error=13, Permission denied

chmod +x doesn't help — it's a mandatory access control policy, not a Unix permission issue.

Fix: Put QEMU in jniLibs/arm64-v8a/ as a .so file.

qemu-system-aarch64  →  jniLibs/arm64-v8a/libqemu.so
qemu-img             →  jniLibs/arm64-v8a/libqemu_img.so

Android's PackageManager installs these to nativeLibraryDir which has exec_type SELinux label — execve() works.

Problem 2: Compressed jniLibs

AGP 3.6+ compresses native libraries inside the APK by default — they're loaded directly from the zip, not extracted to disk. QEMU needs to be on disk to execute.

Fix in build.gradle:

android {
    packagingOptions {
        jniLibs {
            useLegacyPackaging true
        }
    }
}

Problem 3: Wrong ELF Interpreter

A self-built QEMU from a Linux desktop uses glibc:

[Requesting program interpreter: /lib/ld-linux-aarch64.so.1]

Android's PackageManager only extracts .so files using Android's Bionic linker:

[Requesting program interpreter: /system/bin/linker64]

Fix: Use Termux's pre-built QEMU packages — compiled against Bionic.

Problem 4: 50 Shared Library Dependencies

Termux QEMU dynamically links ~50 shared libraries that live at Termux's prefix — a path that doesn't exist on non-Termux devices. All 50 must be bundled in jniLibs/.

Two sub-problems:

Termux embeds a hardcoded RUNPATH pointing to /data/data/com.termux/files/usr/lib/ — Android's linker tries it first and fails
patchelf --remove-rpath corrupts ELF — it restructures LOAD segments, breaking Android 11's strict segment count limits

Fix: An in-place Python script that zeroes only the d_val field of DT_RPATH/DT_RUNPATH ELF entries, leaving the structure intact. See Pockr Part 3 for the full implementation.

Linxr vs Pockr: Same Libraries

Linxr uses the same 50-library bundle as Pockr. The only difference in the QEMU launch command is the forwarded port:

// Linxr: SSH only
cmd += listOf("-netdev", "user,id=net0,hostfwd=tcp::2222-:22")

// Pockr: HTTP API
cmd += listOf("-netdev", "user,id=net0,hostfwd=tcp::7080-:7080")

Next: Part 3 — SSH Terminal in Flutter

GitHub: github.com/AI2TH/Linxr

Linxr Series — Alpine Linux on Android

Linxr = Linux + r. A single Android APK that runs a full Alpine Linux shell on any Android phone — no root, no Termux, no PC required.

#	Post	Topic
📖	Intro	What is Linxr? Start here
1	Part 1	The Idea and Architecture
2	Part 2	Shipping QEMU in an APK
3	Part 3	SSH Terminal in Flutter
4	Part 4	Test Results

GitHub: github.com/AI2TH/Linxr
Website: ai2th.github.io

Linxr | Part 1 — The Idea and Architecture

Ai2th — Mon, 09 Mar 2026 17:01:16 +0000

The Idea and Architecture

Part 1 of 4 — building Linxr, a single APK that runs Alpine Linux on non-rooted Android.

The Constraint

Android is a locked-down Linux system. For regular (non-root) apps:

execve() from app storage is blocked by SELinux W^X policy
Native Linux tools are unavailable without Termux
The kernel disables CONFIG_USER_NS — Docker rootless mode is impossible
No way to load kernel modules or create network namespaces

A QEMU virtual machine sidesteps all of this. The VM runs its own kernel with its own namespace — completely isolated from Android's restrictions.

Why Alpine?

Alpine Linux is the right guest OS for a mobile VM:

Property	Alpine	Debian/Ubuntu
Compressed disk image	~35 MB	~300 MB+
Boot time	~5 s	~30+ s
RAM at idle	~30 MB	~100 MB+
Package manager	`apk`	`apt`
Init system	OpenRC	systemd

Small footprint, fast boot, full POSIX shell — ideal for embedding in an APK.

Architecture

Android OS (non-rooted)
└── APK (Flutter + Kotlin)
    ├── VmManager — asset extraction, QEMU lifecycle
    ├── VmService — ForegroundService (keeps QEMU alive)
    └── Flutter UI — Home, Terminal, About tabs
          └── TerminalScreen (dartssh2 + xterm)

QEMU process (libqemu.so)
└── Alpine Linux 3.19 VM
    └── OpenRC init → sshd on :22
          ↑
          SLIRP hostfwd tcp::2222-:22
          ↑
    SSH on 127.0.0.1:2222 (from Android app)

Disk Layout

Linxr uses QCOW2 copy-on-write layering:

base.qcow2 (read-only — Alpine rootfs, openssh baked in)
  └── user.qcow2 (writable overlay — your data lives here)

base.qcow2 ships compressed in the APK assets. Extracted once on first install.
user.qcow2 is created fresh on first install. Persists across VM restarts — installed packages and files survive.

The overlay is only recreated when base.qcow2 changes (asset version marker bumps on app update).

SLIRP Networking

QEMU SLIRP requires no root and no kernel modules:

Android app
  └── TCP to 127.0.0.1:2222
        └── QEMU hostfwd: tcp::2222-:22
              └── Alpine VM eth0 (10.0.2.15):22
                    └── sshd

Inside the VM:

eth0:    10.0.2.15/24
gateway: 10.0.2.2
DNS:     10.0.2.3  (SLIRP built-in resolver)

The VM has full outbound internet access. apk add, curl, git all work normally.

Token-Free Design

Pockr uses a UUID token injected via QEMU kernel cmdline to authenticate its HTTP API. Linxr doesn't need that — SSH handles authentication natively:

Username: root
Password: alpine (baked into the base image)

No tokens, no custom API — standard SSH.

Next: Part 2 — Shipping QEMU in an APK

GitHub: github.com/AI2TH/Linxr

Linxr Series — Alpine Linux on Android

Linxr = Linux + r. A single Android APK that runs a full Alpine Linux shell on any Android phone — no root, no Termux, no PC required.

#	Post	Topic
📖	Intro	What is Linxr? Start here
1	Part 1	The Idea and Architecture
2	Part 2	Shipping QEMU in an APK
3	Part 3	SSH Terminal in Flutter
4	Part 4	Test Results

GitHub: github.com/AI2TH/Linxr
Website: ai2th.github.io

DEV Community: Ai2th

Linxr | Part 11 — The v3.0.0 Milestone & Official Release

🌟 The Linxr v3.0.0 Landmark

1. Alpine Linux 3.20 & Kernel 6.18-virt (LTS)

2. Embedded Docker Container Dashboard (Pockr Merged)

3. Live System & VM Boot Serial Logs

4. Virtio-9P Storage & SAF Folder Picker

5. High-Speed Terminal & Instant Typing

💬 Community & Discussion

📥 Get Linxr v3.0.0

Linxr | Part 10 — Automated End-to-End Testing for Mobile Virtual Machines

Automated Quality Assurance for Mobile VMs

Kotlin Instrumentation Test Pipeline

Download Linxr

Linxr | Part 9 — Dynamic Storage Expansion & Automatic resize2fs on Boot

The Problem: Hardcoded 1.4 GB Filesystems

The Solution: OpenRC diskexpand Service

Links

Linxr | Part 8 — Fixing Network Latency & SLIRP Terminal Slowness

The Symptom: Terminal Typing Lag

The Fix: TCP_NODELAY & Virtio-Net Tuning

Download & Links

Pockr | Part 7 — Standalone App Deprecated & Merged into Linxr

Why Merge Pockr into Linxr?

How to Access Pockr Features in Linxr

Join the Community & Get Started

Linxr | Part 7 — Merging Docker Engine & Container Dashboard into Flutter

The Vision: One App for VMs and Containers

Architecture: Talking to dockerd Inside QEMU

Container Log Streaming in Flutter

Results & Benchmark

Download Linxr v3.0.0

Linxr | Part 6 — Building Virtio-9P Storage Sharing & SAF on Android

The Challenge: Android Scoped Storage vs Linux Filesystems

Layer 1: Virtio-9P Driver in QEMU

Layer 2: Storage Access Framework (SAF) & pickFolder Channel

What’s Next?

Linxr | Part 5 — Live Boot Logs, SAF Storage & Merging Docker

1. Opening the Black Box: Live Serial Log Streaming

2. Bridging Host & Guest Storage: Virtio-9P + SAF

3. Merging Pockr: Native Docker Container Dashboard

4. Hardened Boot Probing & SSH Lock Guard

What’s Next?

Linxr | Part 4 — Test Results

Test Results

Download

How We Test

Test Result: Pass ✅

What the Robo Test Found

What Works

Current Limitations

What's Next

The Full Series

Linxr Series — Alpine Linux on Android

Linxr | Part 3 — SSH Terminal in Flutter

SSH Terminal in Flutter

The Goal

Connecting to the VM

Wiring SSH to the Terminal

Auto-Reconnect

Terminal Theme

VM-Not-Running Banner

Linxr Series — Alpine Linux on Android

Linxr | Part 2 — Shipping QEMU in an APK

Shipping QEMU in an APK

The Same Wall as Pockr

Problem 1: SELinux Blocks execve()

Problem 2: Compressed jniLibs

Problem 3: Wrong ELF Interpreter

Problem 4: 50 Shared Library Dependencies

Linxr vs Pockr: Same Libraries

Linxr Series — Alpine Linux on Android

Linxr | Part 1 — The Idea and Architecture

The Idea and Architecture

The Constraint

Why Alpine?

Architecture

Disk Layout

SLIRP Networking

Token-Free Design

Architecture: Talking to `dockerd` Inside QEMU

Layer 2: Storage Access Framework (SAF) & `pickFolder` Channel