Android app workshop · ARM64

Build Android apps where you are.

A practical Android toolchain for Linux ARM64—from native SDK tools to signed APKs on a real device. Develop on an Android phone with Termux + PRoot Debian, or on any ARM64 Linux machine.

Real-device workflow validated· native aarch64 tools · offline artifacts

DEVICE25053RT47C · onyx
ANDROID16 · API 36 · arm64-v8a
SOC / GPUSnapdragon 8s Gen 4 · Adreno 825
HOSTTermux + PRoot Debian · aarch64

01What is ADT?

Google's Linux SDK host binaries are x86_64. ADT builds the native host tools from official AOSP source for aarch64/glibc, keeps offline-installable verified artifacts, and validates the whole pipeline on a real physical device.

What it is

Native ARM64 Android SDK build-tools and platform-tools, built from AOSP source, plus the host toolchain around them: JDK, CMake, Ninja, NDK shims and Flutter/Dart support.

Why it exists

An ARM64 machine — including an Android phone running Termux + PRoot Debian — should be able to produce, sign, install and validate real APKs, with no x86_64 host in the loop.

Who it is for

Developers on ARM64 Linux — Android devices via Termux/PRoot, Asahi Linux, ARM64 servers and boards — who need a complete, honest Android toolchain.

Build
aapt2 · aidl · Gradle/Flutter produce the APK
Sign
zipalign · apksigner sign and verify
Install
native adb pushes to a physical device
Verify
arm64-v8a selected · app alive · logs clean
ADT Architecture Diagram

02Features

Tools that only need a JVM execution path are architecture-independent at the Java level; everything else is a native aarch64 binary, built from source, or shimmed — and documented as such.

01SDK build-tools

ARM64-native aapt, aapt2, aidl, zipalign, dexdump and split-select, built from AOSP source for linux-arm64.

02Platform-tools

ARM64-native adb, fastboot and the full platform-tools set, used in the real-device validation.

03Host toolchain

GCC/Clang, CMake, Ninja and Make for native builds, with Git and source-management tooling.

04JVM tool paths

JDK plus apksigner, d8 and R8 through their JVM execution paths — architecture-independent.

05Flutter & Dart

Flutter and Dart alongside Android SDK platforms for application builds on ARM64.

06Offline artifacts

SHA256-verified ARM64 tarballs for expensive builds — install without rebuilding from source.

03Toolchain

Every component is classified by how it actually runs — a tool is not marked supported simply because it exists upstream.

LayerToolsExecution pathStatus
build-tools 35.0.2aapt aapt2 aidl zipalign dexdump split-selectnative ARM64, offline artifactVerified
build-tools 36.0.0aapt2 aidl zipalign …native ARM64, offline artifactVerified
build-tools 37.0.0aapt2 aidl zipalign …native ARM64, GitHub ReleaseVerified
platform-tools 35.0.2 / 37.0.0adb fastbootnative ARM64, offline artifactVerified
NDK 27.2.12479018llvm-strip shimshim → system ARM64 llvm-stripVerified
apksigner · d8 · R8 · sdkmanagersigning · dex · shrink · packagesJVM, architecture-independentVerified
cmdline-tools · platformssdkmanager downloadsGoogle-hosted, network neededVerified
build-tools 35.0.1 · 34.xolder patches, deliberately not builtsuperseded by verified versionsNot yet tested

Per-version AOSP tags, CI runs and notes are tracked in versions.json. Everyday commands for every tool live in COMMANDS.md.

04Installation

Works on any aarch64 Linux with glibc — the validated target is Termux + PRoot Debian on an ARM64 phone; Asahi, Raspberry Pi and ARM64 servers follow the same path. Idempotent: re-running updates an existing clone and skips what is already installed.

# এক লাইনে — সংগ্রহশালা এনে সম্পূর্ণ প্রাথমিক সেটআপ চালায়
curl -fsSL https://raw.githubusercontent.com/soobujmiah/adt/main/install.sh | bash
source ~/.bashrc
# কপি থেকে — ধাপে ধাপে নির্দেশসহ অথবা সম্পূর্ণ স্বয়ংক্রিয়
git clone --depth 1 https://github.com/soobujmiah/adt.git && cd adt
./setup.sh                    # নির্দেশসহ
./setup.sh bootstrap --auto   # কোনো প্রশ্ন ছাড়াই
# পরে যাচাই — সমস্যা হলে কোন অংশে তা শনাক্ত করে
./setup.sh doctor

Fully offline

build-tools and platform-tools 35.0.2, build-tools 36.0.0 (checked-in, SHA256-verified artifacts), NDK/CMake shims.

Network needed

cmdline-tools (Google zip) and platforms;android-* — any other build-tools version builds from AOSP source (~2–4 GB, ~15–30 min).

Validated profile

The guided CLI can install the exact tested bundle: ./setup.sh install-profile validated — build-tools 35.0.2 + NDK 27.2 + android-36.

05Workflows

The everyday developer paths. Exact commands — including wireless adb pairing, which trips most people — are in COMMANDS.md.

ADT Pipeline and Closed-Loop Automation Diagram

ABuild workflow

Native ARM64 aapt2/aidl compile resources and AIDL; Gradle or Flutter assemble the APK. On Termux, Android-targeted native code compiles with Termux Clang and an Android target triple.

Native build guide →

BAPK workflow

Package → align → inspect: aapt2 links resources, zipalign aligns the APK, dexdump inspects DEX. The validated Flutter/Gradle build finished in 1m 21s on the test device.

Validation record →

CSigning

apksigner (JVM, Debian-packaged — no native rebuild needed) signs and verifies APKs on ARM64. Used in the validated end-to-end pipeline.

Signing commands →

DADB & device

Native adb over USB or wireless debugging: install, launch, logcat, shell. Pairing and connect use different ports — COMMANDS.md documents the exact sequence.

ADB commands →

EBuild, run, inspect

The verified path builds an APK, installs and launches it on the physical phone, checks the ARM64 ABI and reviews logs. Manual and scripted use is verified; an autonomous agent loop is not claimed.

Device validation →

What I have used ADT for on this phone

These are recorded outcomes from my Redmi Turbo 4 Pro workstation, not promises for every ARM64 device.

Build a Flutter app

A clean Gradle/Flutter APK build completed in 1m 21s; I installed it on the phone, confirmed arm64-v8a, exercised the app and checked for crashes.

Validate native Android code

I compiled Android-targeted native code, packaged it into an APK, loaded its JNI library on-device and confirmed the process remained alive with clean logs.

Keep a known-good toolchain

The validated setup profile pins build-tools 35.0.2, NDK 27.2 and Android API 36. NDK 28 was also tested as an option after its ARM64 llvm-strip shim was repaired.

See the device record and commands →

06Evidence — real results

The strongest test is the full path, not the presence of binaries. On 2026-09-01 this chain ran end-to-end on a real physical device:

native source → ARM64 shared library → APK packaging → signing →
ADB installation → ARM64 ABI selection → JNI loading → native execution →
log output → process remains alive

# final build      BUILD SUCCESSFUL in 1m 21s   (60 actionable tasks)
# install         adb install -r app-debug.apk → Success
# abi             Device ABI: arm64-v8a · APK primaryCpuAbi: arm64-v8a
# runtime         PID observed · crash/ANR scan clean · app alive

Validation record

REAL_DEVICE_BUILD_VALIDATION.md — status VERIFIED / CLOSED for the validated project state. Device topology, commands and outputs recorded in-repo.

Open record →

Releases

v35.0.2, v36.0.0 and v37.0.0 published by CI (build.yml on tags) with ARM64 tarballs attached and confirmed via gh release view.

Open releases →

Version registry

versions.json records per-version status, AOSP tag, CI run and honest notes — including what was deliberately not built and why.

Open registry →

Shared evidence vocabulary — Verified · Measured · Observed · Experimental · Not yet tested · Not supported:

Verified Measured Observed Experimental Not yet tested Not supported

Honesty boundary: the full chain is physically validated on one device family (Redmi Turbo 4 Pro, PRoot Debian). On any other host the scripts are identical, but "should work" is not "verified" — run ./setup.sh doctor as your first evidence check.

07ADT and Ternux — two layers of one ARM64 story

ADT and TERNUX Relationship Diagram

ADT — this repository

The development-toolchain layer: native SDK build-tools, platform-tools, signing and ADB workflows for Linux ARM64.

Ternux — the desktop layer

A no-root Debian + Xfce4 desktop on Android via PRoot and Termux:X11, with GPU acceleration (Mesa/Zink, Turnip on Adreno).

Ternux website →

Physical host target

The host Android device is the actual physical target machine. PRoot/Termux serves as the user-space environment. Builds run on bare metal; execution and debugging target that physical phone, not an emulator or external PC.

Verified vs experimental

ADT's pipeline is verified on the shared Termux + PRoot Debian host; Ternux verifies the desktop and GPU stack separately. Combined cross-project workflows are observed to coexist but are not yet tested formally — they remain experimental.

Use both on the same phone

Install Ternux for the Debian desktop, then install ADT inside that same Debian userland. From Termux, enter with db; from Xfce, open a terminal in the Debian session.

# টারনাক্সের ডেবিয়ান পরিবেশের ভেতরে
curl -fsSL https://raw.githubusercontent.com/soobujmiah/adt/main/install.sh | bash
source ~/.bashrc
cd ~/adt && ./setup.sh doctor

ADT's build and physical-device workflow is verified on this shared Termux + PRoot host. Running the tools specifically from a Ternux Xfce session has been observed, but is not yet a formally tested combined workflow.

08Documentation

Simple first in the README; technical depth lives in the repository, linked here directly so what you read matches what the toolchain actually does.

README

What ADT is, evidence, the Ternux relationship and limits — the fast path.

Read →

Technical reference

Tool roles, native build strategy, NDK/PRoot reality, setup.sh surface, profiles.

Read →

Command reference

Everyday commands for every installed tool, device pairing, troubleshooting.

Read →

Validation records

Real-device evidence and dated session records, kept next to the work they describe.

Read →