TERMUX

Package Management

Filesystem & Storage

Services & Power

System Info

Termux:API Highlights

Architecture

Android itself runs on the Linux kernel. Termux exploits this by providing a user-space Linux environment that talks directly to the same kernel powering your phone. When you run python3 or gcc in Termux, those are real ARM64 ELF binaries executing natively — no translation, no overhead.

Bionic vs. glibc

Android does not use the standard GNU C Library (glibc) that desktop Linux uses. Instead, it uses Bionic, Google's custom C library. This means:

• You cannot just copy a binary from an Ubuntu server and run it in Termux
• Every package in Termux's repository has been cross-compiled specifically to link against Bionic
• Some glibc-specific APIs are missing or behave differently
• Packages are patched at build time to handle these differences

The $PREFIX Convention

Standard Linux follows the Filesystem Hierarchy Standard (FHS) with paths like /usr/bin, /etc, /var. Termux cannot use these paths because it runs as an unprivileged Android app with no access to the root filesystem. Instead, everything lives under $PREFIX:

All Termux packages are patched at build time to replace hardcoded paths like /usr/bin/python3 with $PREFIX/bin/python3. This is done automatically by the Termux build infrastructure — the termux-packages repository handles this patching for every package.

User-Space Only

Termux operates entirely in user space. There is no sudo, no su, and no ability to modify system files — unless your device is rooted. This means:

• No binding to ports below 1024 (use 8080 instead of 80, 8022 instead of 22)
• No systemd or init — use termux-services (sv/runit) instead
• No /proc write access or kernel module loading
• No creating users or groups — everything runs as the Termux app UID
• No chroot without root (but proot works as a userspace alternative)

Where to Install From

There are two recommended sources:

First Boot Steps

After installing and opening Termux for the first time:

# 1. Update the package index and upgrade base packages
pkg update && pkg upgrade

# 2. Grant storage access (creates ~/storage symlinks)
termux-setup-storage

# 3. Install essential tools
pkg install git curl wget openssh nano

# 4. Optional: install a better shell
pkg install zsh
chsh -s zsh

The pkg update command will prompt you to choose a repository mirror. Pick one geographically close to you for best speeds. You can change mirrors later by editing $PREFIX/etc/apt/sources.list or running termux-change-repo.

Storage Access

Running termux-setup-storage does two things:

1. Triggers Android's storage permission dialog
2. Creates symlinks in ~/storage/ pointing to shared storage locations

termux.properties Configuration

Customize Termux behavior by editing ~/.termux/termux.properties. Create the file if it doesn't exist, then run termux-reload-settings to apply changes.

# ~/.termux/termux.properties

# Extra keys row — the toolbar above the keyboard
# This is the most important setting for usability
extra-keys = [ \
  ['ESC','/','-','HOME','UP','END','PGUP'], \
  ['TAB','CTRL','ALT','LEFT','DOWN','RIGHT','PGDN'] \
]

# Alternative: single-row with common keys
# extra-keys = [['ESC','TAB','CTRL','ALT','-','DOWN','UP']]

# Use black keyboard (matches dark theme)
use-black-ui = true

# Bell behavior: vibrate, beep, or ignore
bell-character = vibrate

# Terminal cursor style: block, underline, or bar
terminal-cursor-style = bar

# Allow external apps to run termux commands
allow-external-apps = true

# Fullscreen mode
fullscreen = false

# Volume keys as special keys
# volume-keys = volume  (default: virtual)

Shell Configuration

Termux ships with bash by default. Your dotfiles go in the standard locations:

# Bash config
~/.bashrc        # Interactive shell config
~/.bash_profile  # Login shell config
~/.profile       # POSIX login profile

# If using Zsh
~/.zshrc
~/.zprofile

# Useful .bashrc additions for Termux
export EDITOR=nano
alias ll='ls -la'
alias update='pkg update && pkg upgrade'

# Fix for some programs that expect /tmp
export TMPDIR=$PREFIX/tmp

Styling the Terminal

Customize colors and font via ~/.termux/:

# Install premade themes and fonts
pkg install termux-style

# Or manually:
# Place a colors.properties file
~/.termux/colors.properties

# Place a font file (TTF or OTF)
~/.termux/font.ttf

# Apply changes
termux-reload-settings

Core Commands

Why Not Ubuntu Repos?

You cannot add Ubuntu, Debian, or any standard Linux repository to Termux. Termux packages are cross-compiled specifically for the Android/Bionic environment. Standard Linux packages are linked against glibc and assume FHS paths like /usr/bin — both of which are incompatible with Termux.

The Termux package repository currently contains 1000+ packages, all patched and compiled to work within the Termux environment. If a package you need isn't available, you can try compiling it from source within Termux, or use proot-distro to run a full glibc-based distro.

Additional Repositories

Beyond the main repository, Termux offers several additional repos for specialized packages:

Mirror Selection

If package downloads are slow or failing, switch to a different mirror:

# Interactive mirror selector (recommended)
termux-change-repo

# Or manually edit the sources list
nano $PREFIX/etc/apt/sources.list

The termux-change-repo command provides a dialog-based interface to select mirrors for each repository. Pick the mirror geographically closest to you for best performance.

Commonly Needed Packages

Key Environment Variables

FHS Path Mapping

A complete reference of how standard Linux paths map into Termux:

Shebangs

Because binaries do not live at standard paths, hardcoded shebangs will break:

# WRONG — this path does not exist in Termux
#!/usr/bin/python3

# WRONG — /bin is Android's system bin, not Termux
#!/bin/bash

# CORRECT — env finds the right binary via $PATH
#!/usr/bin/env python3

# CORRECT — env finds bash in $PREFIX/bin
#!/usr/bin/env bash

Shared Storage

After running termux-setup-storage, the ~/storage/ directory contains symlinks to Android's shared storage areas:

Where Things Live

# Your config files
$PREFIX/etc/              # System configs (sshd_config, profile.d/, etc.)
$HOME/.bashrc             # Bash user config
$HOME/.termux/            # Termux-specific config (colors, font, keys)

# Installed binaries
$PREFIX/bin/              # All executables (python, node, git, etc.)
which python3             # Shows $PREFIX/bin/python3

# Libraries
$PREFIX/lib/              # Shared objects (.so)
$PREFIX/lib/python3.*/    # Python standard library

# Package databases
$PREFIX/var/lib/dpkg/     # dpkg/apt package database
$PREFIX/var/cache/apt/    # Downloaded .deb files

Node.js

# Install Node.js and npm
pkg install nodejs

# Verify installation
node --version
npm --version

# Initialize a project
mkdir my-project && cd my-project
npm init -y

# Install packages (most work fine)
npm install express
npm install typescript -g

Node.js works well on Termux. The npm ecosystem is largely compatible — pure-JavaScript packages install without issues. However, native modules that use node-gyp can fail because node-gyp expects standard Linux paths and GCC, while Termux uses Clang and non-standard paths.

Python

# Install Python 3 with pip
pkg install python

# Verify
python3 --version
pip --version

# Create a virtual environment
python3 -m venv myenv
source myenv/bin/activate

# Pure-Python packages — no issues
pip install flask requests beautifulsoup4 click

# Scientific packages — install via pkg, not pip
pkg install python-numpy
pkg install python-scipy
pkg install python-pillow

Python works well for most use cases. Pure-Python packages install normally via pip. Packages with C extensions (NumPy, SciPy, Pillow) should be installed via pkg when available, as the Termux-packaged versions are pre-compiled for Bionic. Building C extensions from source with pip may fail due to missing headers or Bionic incompatibilities.

Rust

# Install Rust toolchain
pkg install rust

# Verify
rustc --version
cargo --version

# Create and build a project
cargo new hello-termux
cd hello-termux
cargo build
cargo run

# The target triple in Termux
rustc --print target-list | grep android
# aarch64-linux-android

Rust compiles natively for aarch64-linux-android. Cargo works, crate downloads work, and most crates build without issues. Rust is particularly important in the Termux ecosystem because it's the language used to build native PTY handling solutions — a critical topic covered in Section 07.

Go

# Install Go
pkg install golang

# Verify
go version

# Create a module
mkdir my-go-app && cd my-go-app
go mod init my-go-app

# Build and run
go build -o app main.go
./app

# Cross-compilation still works
GOOS=linux GOARCH=amd64 go build -o app-x86 main.go

Go works well on Termux. Modules, vendoring, and the standard library all function as expected. Cross-compilation to other targets is fully supported.

C / C++

# Install the compiler toolchain
pkg install clang make cmake

# Compile a simple program
echo '#include <stdio.h>
int main() { printf("Hello from Termux\\n"); return 0; }' > hello.c
clang hello.c -o hello
./hello

# Use cmake for larger projects
mkdir build && cd build
cmake ..
make

# Additional build tools
pkg install ninja autoconf automake libtool

Clang is the compiler in Termux, not GCC. GCC is not available. Most C/C++ projects that support Clang will compile fine. Build systems like CMake, Ninja, and Autotools are all available.

Ruby & PHP

# Ruby
pkg install ruby
ruby --version
gem install bundler

# PHP
pkg install php
php --version

# PHP with common extensions
pkg install php-fpm php-pgsql

Both Ruby and PHP are available and functional. gem install works for most gems. PHP includes common extensions with additional ones available via pkg.

What Does NOT Work

proot-distro: The Escape Hatch

# Install proot-distro
pkg install proot-distro

# List available distros
proot-distro list

# Install Ubuntu
proot-distro install ubuntu

# Launch into Ubuntu
proot-distro login ubuntu

# Now you're in a full Ubuntu environment:
apt install docker.io   # Still won't work (no kernel support)
apt install gcc         # GCC works here (glibc-based)
apt install python3     # Standard Ubuntu Python

Inside a proot-distro environment, you get a standard FHS filesystem, glibc, and the distribution's full package repository. Performance is slightly reduced due to proot's syscall translation, but for most development tasks the overhead is negligible. Note that kernel-level features (Docker, systemd, etc.) still won't work even inside proot.

What Is a PTY?

A pseudoterminal (PTY) is a kernel mechanism that lets a program act as a terminal. It is the fundamental abstraction behind every terminal emulator, every SSH session, every tmux pane, and every screen session on any Unix system.

A PTY is a pair of virtual file descriptors:

• Master side — held by the controlling program (the terminal emulator, SSH daemon, or multiplexer). It reads what the child process writes and sends keystrokes to the child.
• Slave side — presented to the child process (the shell, or whatever runs inside the terminal). From the child's perspective, the slave looks exactly like a real hardware terminal.

# The kernel PTY architecture

  Terminal Emulator (xterm, Alacritty, Termux)
         │
         │  reads/writes
         ▼
    ┌──────────┐
    │  Master   │  <── PTY pair (kernel-managed)
    │  (ptmx)   │
    └────┬─────┘
         │  kernel passes data between master ↔ slave
    ┌────┴─────┐
    │  Slave    │  <── looks like /dev/pts/N
    │  (pts/N)  │
    └──────────┘
         │
         │  stdin/stdout/stderr
         ▼
    Shell (bash, zsh, fish)

The POSIX convenience function forkpty() bundles the entire dance into one call: it allocates the PTY pair, forks a child process, connects the child's stdin/stdout/stderr to the slave side, and returns the master file descriptor to the parent. Every major terminal emulator on Linux and macOS uses forkpty() — it is the standard way to spawn a shell inside a program.

node-pty — The Standard That Breaks on Android

node-pty is Microsoft's npm package for PTY allocation in Node.js. It is the de facto standard for any Node.js application that needs to spawn a terminal session. The list of tools that depend on it is staggering:

node-pty has two fatal problems on Termux:

This has been a long-standing, well-known blocker. Issues have been reported against node-pty since 2024. As of late 2025, there is no upstream fix. The problem is fundamental — node-pty was designed for desktop operating systems and has no Android code path.

The real-world impact: any xterm.js-based web terminal with a Node.js backend simply cannot work on Android. code-server's terminal tab? Broken. ttyd on your phone? Dead on arrival. Building a web-based terminal tool in Node.js for Termux? Impossible.

portable-pty — The Rust Solution

portable-pty is a Rust crate by Wez Furlong, the author of WezTerm terminal. It provides a trait-based, cross-platform PTY abstraction that works on Linux, macOS, Windows, and — with a patch — Android.

Claude helped patch portable-pty to add #[cfg(target_os = "android")] detection. The Android code path avoids forkpty() entirely and instead uses lower-level POSIX primitives that Bionic does support:

// The Android PTY allocation sequence
// Each step uses primitives that Bionic implements correctly

// 1. Open the PTY master device
let master = open("/dev/ptmx", O_RDWR | O_NOCTTY);

// 2. Grant and unlock the slave side
grantpt(master);    // Set ownership/permissions on slave
unlockpt(master);   // Allow the slave to be opened

// 3. Get the slave device name (e.g., "/dev/pts/3")
let slave_name = ptsname(master);

// 4. Open the slave side
let slave = open(slave_name, O_RDWR);

// 5. Fork a child process
match fork() {
    Ok(ForkResult::Child) => {
        // In the child: set up a new session
        setsid();              // Become session leader
        ioctl(slave, TIOCSCTTY); // Set controlling terminal

        // Wire stdin/stdout/stderr to the slave PTY
        dup2(slave, STDIN);
        dup2(slave, STDOUT);
        dup2(slave, STDERR);

        // Execute the shell
        exec("/data/data/com.termux/files/usr/bin/bash");
    }
    Ok(ForkResult::Parent { child }) => {
        // In the parent: use master fd to communicate
        // Read from master = see what the shell prints
        // Write to master = send keystrokes to the shell
    }
}

The key insight: forkpty() is just a convenience wrapper around these individual operations. Every one of these primitives — open, grantpt, unlockpt, ptsname, fork, setsid, ioctl(TIOCSCTTY) — works correctly on Android's Bionic. The problem was never that Android couldn't do PTYs. It was that the standard convenience function was broken, and nobody had implemented the manual path.

// Using portable-pty in a Rust application
use portable_pty::{CommandBuilder, PtySize, native_pty_system};

fn spawn_shell() -> Result<(), Box<dyn std::error::Error>> {
    let pty_system = native_pty_system();

    // Open a PTY with initial size
    let pair = pty_system.openpty(PtySize {
        rows: 24,
        cols: 80,
        pixel_width: 0,
        pixel_height: 0,
    })?;

    // Spawn bash in the PTY
    let mut cmd = CommandBuilder::new("bash");
    cmd.env("TERM", "xterm-256color");
    let child = pair.slave.spawn_command(cmd)?;

    // Read/write via the master side
    let mut reader = pair.master.try_clone_reader()?;
    let mut writer = pair.master.take_writer()?;

    // Now pipe these to a WebSocket, HTTP stream, etc.
    Ok(())
}

What This Enables

With portable-pty working on Android, the entire architecture changes:

Rust web frameworks — axum, actix-web, warp — all compile and run natively on Termux. Combined with portable-pty, you can build a complete web terminal server that:

• Serves an xterm.js frontend over HTTP
• Accepts WebSocket connections from browsers
• Spawns real bash sessions via PTY
• Runs entirely on your Android phone

# Building a Rust web terminal on Termux — it actually works
pkg install rust
cargo new termux-web-terminal
cd termux-web-terminal

# Add dependencies to Cargo.toml
# axum (web framework) + portable-pty + tokio-tungstenite (WebSockets)
cargo add axum tokio portable-pty tokio-tungstenite

# Build natively on the phone
cargo build --release

# Run it
./target/release/termux-web-terminal
# Now open http://localhost:3000 in your phone's browser

This is a fundamental capability unlock. Web-based development tools, terminal sharing, remote access servers, pair programming tools — all are now possible on Android. The bottleneck was never the hardware (modern phones have 8+ cores and 12GB+ RAM). It was a single missing function in a C library.

Claude Code TMPDIR Fix

Even after solving PTY allocation, getting real development tools running on Termux exposed another class of problem: hardcoded temp paths.

Claude Code (Anthropic's AI coding CLI) hardcoded /tmp/claude/ paths throughout its codebase for subagent communication, background task state, and the Task tool. On Android, /tmp is not writable by non-root users. Termux provides $TMPDIR pointing to $PREFIX/tmp, but Claude Code ignored it entirely.

Multiple GitHub issues documented the problem over months:

The fix arrived in Claude Code v2.1.4 / v2.1.5 with a new environment variable:

# Set the Claude Code temp directory to Termux's writable tmp
export CLAUDE_CODE_TMPDIR="$TMPDIR/claude"
mkdir -p "$CLAUDE_CODE_TMPDIR"

# Add to your shell config so it persists
echo 'export CLAUDE_CODE_TMPDIR="$TMPDIR/claude"' >> ~/.bashrc
echo 'mkdir -p "$CLAUDE_CODE_TMPDIR"' >> ~/.bashrc

# Verify it's set
echo $CLAUDE_CODE_TMPDIR
# /data/data/com.termux/files/usr/tmp/claude

Setup

Termux:API requires two installations — the companion Android app and the CLI package:

# Step 1: Install the Termux:API app from F-Droid
# (Search for "Termux:API" in F-Droid — it must be from the same source as Termux)

# Step 2: Install the CLI tools inside Termux
pkg install termux-api

# Step 3: Test it
termux-battery-status

Device & Sensor Commands

# Battery monitoring — JSON output, perfect for jq
$ termux-battery-status
{
  "health": "GOOD",
  "percentage": 73,
  "plugged": "UNPLUGGED",
  "status": "DISCHARGING",
  "temperature": 28.5
}

# GPS location with provider selection
$ termux-location -p gps
{
  "latitude": 37.7749,
  "longitude": -122.4194,
  "altitude": 12.0,
  "accuracy": 3.5,
  "bearing": 0.0,
  "speed": 0.0
}

# Biometric auth for scripts that need security
$ termux-fingerprint
{
  "auth_result": "AUTH_RESULT_SUCCESS"
}

Camera & Media

# Take a photo with the front camera
termux-camera-photo -c 1 selfie.jpg

# Speak text aloud (pipes work)
echo "Build complete" | termux-tts-speak

# Toast with positioning and color
termux-toast -g middle -b white -c black "Server started on :8080"

Clipboard & Communication

# Copy command output to clipboard
pwd | termux-clipboard-set

# Paste clipboard into a file
termux-clipboard-get > pasted.txt

# Send an SMS
termux-sms-send -n "+15551234567" "Build deployed successfully"

# Read last 5 SMS messages
termux-sms-list -l 5 | jq '.[].body'

Notifications & Dialogs

# Send a notification
termux-notification \
  --title "Build Complete" \
  --content "Project compiled successfully in 42s" \
  --id build-status

# Notification with action button
termux-notification \
  --title "Server Crashed" \
  --content "Express server exited with code 1" \
  --button1 "Restart" \
  --button1-action "termux-toast 'Restarting...'; node server.js &"

# Remove a notification by ID
termux-notification-remove build-status

# Interactive dialog — text input
termux-dialog text -t "Enter project name" -i "my-project"
# Returns: {"code": 0, "text": "user-input-here"}

# Dialog — radio buttons
termux-dialog radio -t "Choose environment" -v "dev,staging,prod"

# Dialog — date picker
termux-dialog date -t "Select deadline"

# Dialog — checkbox list
termux-dialog checkbox -t "Select features" -v "auth,api,ui,tests"

Scripting Patterns

Every Termux:API command outputs JSON, making it ideal for scripting with jq:

# Low battery warning script
#!/bin/bash
LEVEL=$(termux-battery-status | jq '.percentage')
if [ "$LEVEL" -lt 20 ]; then
    termux-notification \
        --title "Low Battery" \
        --content "Battery at ${LEVEL}%  — plug in soon"
    termux-vibrate -d 1000
    termux-tts-speak "Battery low. ${LEVEL} percent remaining."
fi

# Location-based greeting
#!/bin/bash
LAT=$(termux-location -p network | jq '.latitude')
LON=$(termux-location -p network | jq '.longitude')
termux-toast "You are at $LAT, $LON"

# Clipboard monitor — log everything copied
#!/bin/bash
LAST=""
while true; do
    CURRENT=$(termux-clipboard-get)
    if [ "$CURRENT" != "$LAST" ]; then
        echo "$(date): $CURRENT" >> ~/clipboard-log.txt
        LAST="$CURRENT"
    fi
    sleep 2
done

# Build notification helper function
notify_result() {
    if [ $? -eq 0 ]; then
        termux-notification -t "Success" -c "$1 completed"
        termux-vibrate -d 200
    else
        termux-notification -t "Failed" -c "$1 failed with exit code $?"
        termux-vibrate -d 1000
    fi
}

# Usage:
cargo build --release; notify_result "Rust build"

Companion Add-on Apps

Beyond Termux:API, the Termux ecosystem includes several other add-on apps — all available on F-Droid:

# Termux:Boot — auto-start script
# Place scripts in ~/.termux/boot/
mkdir -p ~/.termux/boot
cat > ~/.termux/boot/start-sshd.sh <<'EOF'
#!/data/data/com.termux/files/usr/bin/bash
termux-wake-lock
sshd
EOF
chmod +x ~/.termux/boot/start-sshd.sh

# Termux:Widget — home screen shortcuts
# Place scripts in ~/.shortcuts/
mkdir -p ~/.shortcuts
cat > ~/.shortcuts/sync-notes.sh <<'EOF'
#!/data/data/com.termux/files/usr/bin/bash
cd ~/notes && git pull && git add -A && git commit -m "sync" && git push
termux-toast "Notes synced"
EOF
chmod +x ~/.shortcuts/sync-notes.sh

SSH Server

OpenSSH runs out of the box on Termux, but listens on port 8022 instead of 22. Unprivileged apps can't bind to ports below 1024, so Termux's sshd defaults to a high port. Password auth works immediately; key-based auth takes a minute to configure and is strongly recommended.

# Install OpenSSH
pkg install openssh

# Set a password (required for first login)
passwd

# Start SSH server (port 8022 by default)
sshd

# Check your phone's IP
ifconfig wlan0 | grep 'inet '

# Connect from your desktop (same Wi-Fi network)
# Username is always your Termux user — check with `whoami`
ssh -p 8022 $(whoami)@192.168.1.XXX

# Key-based authentication (recommended)
# On your desktop, copy your public key to the phone:
ssh-copy-id -p 8022 user@192.168.1.XXX

# Or manually append your key:
cat ~/.ssh/id_ed25519.pub | ssh -p 8022 user@phone "cat >> ~/.ssh/authorized_keys"

# Disable password auth after keys work
# Edit $PREFIX/etc/ssh/sshd_config:
sed -i 's/#PasswordAuthentication yes/PasswordAuthentication no/' $PREFIX/etc/ssh/sshd_config

# Restart sshd to apply
pkill sshd; sshd

# SCP files to/from phone
scp -P 8022 ./file.txt user@phone:~/
scp -P 8022 user@phone:~/output.log ./

Auto-Start on Boot

Termux:Boot is a companion app (install from F-Droid alongside Termux) that runs scripts from ~/.termux/boot/ whenever the device boots. Combined with a wake lock, this keeps your services alive through reboots.

# Create the boot directory
mkdir -p ~/.termux/boot

# Auto-start SSH with wake lock
cat > ~/.termux/boot/start-sshd.sh <<'EOF'
#!/data/data/com.termux/files/usr/bin/bash
termux-wake-lock
sshd
EOF
chmod +x ~/.termux/boot/start-sshd.sh

# Auto-start multiple services
cat > ~/.termux/boot/start-services.sh <<'EOF'
#!/data/data/com.termux/files/usr/bin/bash
termux-wake-lock

# Start SSH
sshd

# Start crond
crond

# Start a web server in the background
cd ~/www && python -m http.server 8080 &

# Log boot time
echo "Booted at $(date)" >> ~/boot.log
EOF
chmod +x ~/.termux/boot/start-services.sh

termux-services (runit)

For proper service management (start, stop, restart, auto-start), termux-services provides a runit-based supervisor. Services are directories under $PREFIX/var/service/, each containing a run script.

# Install the runit service manager
pkg install termux-services

# Restart Termux after installation (required)
# runit starts on next session

# Service management commands
sv up sshd           # Start sshd service
sv down sshd         # Stop sshd service
sv status sshd       # Check service status

# Enable a service (auto-start on Termux launch)
sv-enable sshd

# Disable auto-start
sv-disable sshd

# List all available services
ls $PREFIX/var/service/

# Create a custom service
# Service directory structure:
# $PREFIX/var/service/myservice/
#   run        — executable script that stays in foreground
#   log/run    — optional logging script

mkdir -p $PREFIX/var/service/mywebserver

cat > $PREFIX/var/service/mywebserver/run <<'EOF'
#!/data/data/com.termux/files/usr/bin/bash
exec python -m http.server 8080 --directory ~/www 2>&1
EOF
chmod +x $PREFIX/var/service/mywebserver/run

# runit picks it up automatically
sv status mywebserver

Web Servers

Any web server that runs on Linux can run on Termux — just remember to bind to a port above 1024.

# nginx — edit config to use high port
pkg install nginx
# Default config: $PREFIX/etc/nginx/nginx.conf
# Change: listen 8080; (not 80)
sed -i 's/listen       80;/listen       8080;/' $PREFIX/etc/nginx/nginx.conf
nginx                # Start
nginx -s reload      # Reload config
nginx -s stop        # Stop

# Python — instant static server
cd ~/my-site && python -m http.server 8080

# Node.js — with npx (no global install)
npx serve ~/my-site -l 3000

# Node.js — custom server
node -e "require('http').createServer((q,s)=>s.end('Hello from Termux')).listen(3000)"

Wake Locks & Battery

Android aggressively suspends background apps to save battery. A wake lock tells Android to keep the CPU running even when the screen is off. Without one, long-running processes (compiles, downloads, servers) will be killed within minutes.

# Acquire wake lock (keeps CPU alive, screen can be off)
termux-wake-lock

# Release wake lock
termux-wake-unlock

# Check wake lock status — look for Termux notification icon
# A persistent notification with a lock icon = wake lock active

# Pattern: acquire before long tasks, release after
termux-wake-lock
make -j4 && echo "Build done"
termux-wake-unlock

Phantom Process Killer (Android 12+)

The single biggest threat to Termux reliability. Starting with Android 12, Android monitors child processes spawned by apps and kills them when the system-wide count exceeds 32. This is the infamous Phantom Process Killer.

# Symptoms: random SIGKILL during compilation, servers dying
# You'll see this in Termux:
[Process completed (signal 9) - press Enter]

# Fix for Android 12-13 via ADB (run from desktop)
adb shell "device_config set_sync_disabled_for_tests persistent"
adb shell "device_config put activity_manager max_phantom_processes 2147483647"

# Verify the setting stuck
adb shell "device_config get activity_manager max_phantom_processes"
# Should output: 2147483647

# Fix for Android 14+
# Settings → Developer Options → "Disable child process restrictions" → ON
# No ADB required

Tunneling for Remote Access

Your phone sits behind NAT on a cellular or Wi-Fi network. To access Termux services from outside the local network, you need a tunnel.

# ADB port forwarding (phone connected via USB)
# Run on desktop — forwards desktop:8022 → phone:8022
adb forward tcp:8022 tcp:8022
ssh -p 8022 user@localhost    # Now connect to localhost

# cloudflared tunnel (free, no account needed for quick tunnels)
pkg install cloudflared
cloudflared tunnel --url http://localhost:8080
# Gives you a public https://xxx.trycloudflare.com URL

# ngrok (free tier, account required)
# Download arm64 binary from ngrok.com
./ngrok tcp 8022
# Gives you a public tcp://X.tcp.ngrok.io:NNNNN endpoint
# Connect: ssh -p NNNNN user@X.tcp.ngrok.io

# SSH reverse tunnel (if you have a VPS)
ssh -R 9022:localhost:8022 you@your-vps.com
# Then from anywhere: ssh -p 9022 user@your-vps.com

Common Problems

Android Version Timeline

Each Android release tightened the screws on what unprivileged apps can do. Here's the history of restrictions that affect Termux:

Quick Diagnostics

When something breaks, start here. These commands tell you exactly what Android version, API level, and configuration you're dealing with:

# Android version (e.g., "14")
getprop ro.build.version.release

# API level (e.g., "34")
getprop ro.build.version.sdk

# Full Termux diagnostic dump — paste this in bug reports
termux-info

# SELinux status (usually "Enforcing")
getenforce

# CPU architecture
uname -m       # aarch64 for most modern phones

# Available RAM
free -h

# Check if phantom process limit is set
# (run via ADB from desktop)
adb shell "device_config get activity_manager max_phantom_processes"

# List running Termux processes
ps aux

# Check Termux app version
cat $PREFIX/etc/motd 2>/dev/null || echo "Check: Settings → Apps → Termux → Version"

Useful Aliases for .bashrc

Drop these into ~/.bashrc (or ~/.zshrc) to make daily Termux life faster:

# ~/.bashrc — Termux survival aliases

# Quick IP check (Wi-Fi)
alias myip='ifconfig wlan0 2>/dev/null | grep "inet " | awk "{print \$2}"'

# Battery status
alias battery='termux-battery-status | python -c "import sys,json; b=json.load(sys.stdin); print(f\"{b[\"percentage\"]}% {b[\"status\"]}\")"'

# Clipboard shortcuts
alias clip='termux-clipboard-get'
alias setclip='termux-clipboard-set'

# Quick TTS
say() { echo "$*" | termux-tts-speak; }

# GPS location (one-liner)
alias whereami='termux-location -p network | python -c "import sys,json; l=json.load(sys.stdin); print(f\"{l[\"latitude\"]}, {l[\"longitude\"]}\")"'

# Wake lock toggle
alias wl='termux-wake-lock && echo "Wake lock ON"'
alias wul='termux-wake-unlock && echo "Wake lock OFF"'

# Package shortcuts
alias pkgi='pkg install'
alias pkgs='pkg search'
alias pkgu='pkg update && pkg upgrade -y'

# Start SSH server + wake lock
alias startssh='termux-wake-lock && sshd && echo "sshd on :8022"'

# tmux persistent session — reattach or create
alias t='tmux attach 2>/dev/null || tmux new -s main'

Key File Locations

Termux uses a non-standard filesystem layout. This table maps the paths you'll need most often: