A revolutionary fork of termux/termux-app that eliminates traditional package bootstrapping entirely and includes comprehensive AI development tools. Instead of complex zip extraction and package installation, Termux AI embeds native executables directly into the Android APK as .so files, leveraging Android's automatic library extraction for instant availability.

🤖 Multi-AI Support: Gemini CLI, Claude CLI, and Codex CLI built-in
🎬 FFmpeg Integration: Complete multimedia processing capabilities (v7.1.1, 100% dependencies resolved)
⚡ Instant Development: Node.js, Git, and 400+ tools ready immediately

Traditional Termux: Complex bootstrap process with zip extraction, package installation, and manual permission setup.

Termux AI: Native executables (binaries + scripts) → Add .so extension → Place in jniLibs/arm64-v8a/ → Android automatically extracts to read-only /data/app/.../lib/arm64/ → Symbolic links provide instant access.

✅ No bootstrap required - Launch and code immediately
✅ Multi-AI powered - 3 AI assistants built-in (Gemini, Claude, Codex)
✅ Multimedia ready - FFmpeg v7.1.1 for professional video/audio processing
✅ W^X compliant - Executables in read-only system locations
✅ SELinux compatible - Uses Android's native library mechanism
✅ Faster startup - No extraction or installation delays

Termux AI running with Node.js v24.7.0 and AI assistance

ttyd web terminal interface accessible at localhost:7681

Gemini AI CLI authentication setup with Google login and API key options

Download v1.8.0 | Size: 262.5 MB | SHA256: 1bafcb40111f43e6b9043bfddb6ff28aae47ac669cdc823ea2fdafdc15501eac

• ✅ Complete AI Integration - Gemini CLI, Claude CLI, and Codex CLI ready-to-use
• ✅ FFmpeg Multimedia Support - Complete video/audio processing with ffmpeg v7.1.1 and ffprobe (100% dependencies resolved)
• ✅ 100% Package Integration Success - All 89 packages fully integrated
• ✅ Clean Naming Convention - Removed lib prefix from 100+ executables
• ✅ Fixed Android Asset Packaging - Resolved __generated__ directory exclusion
• ✅ Enhanced Security - Removed OAuth secrets from repository history
• ✅ Improved Consistency - Executables use .so suffix without lib prefix (e.g., apt.so, dpkg.so, git.so)
• ✅ Fixed Multicall Binaries - coreutils.so properly handles 100+ commands (ls, cat, cp, mv, etc.)

• Android: 14+ (API level 34+)
• Architecture: ARM64 (arm64-v8a) devices only
• Storage: ~262MB APK with complete development environment

1. Download APK from Releases - Latest: v1.8.0 (Clean Executable Naming)
2. Install on ARM64 Android device
3. Launch app - all executables configured automatically
4. Ready for development and AI assistance

# 🤖 AI Development Tools
gemini --help          # Google Gemini AI CLI v0.3.3
claude --help          # Anthropic Claude AI CLI
codex --help           # AI coding assistant
codex-exec --help      # Non-interactive AI execution

# 🎬 Multimedia Processing
ffmpeg -version        # FFmpeg v7.1.1 multimedia framework (100% dependencies resolved)
ffprobe -version       # Media file analyzer (complete library support)

# 💻 Core Development Stack
node --version         # Node.js v24.7.0
npm --version          # Package manager v11.5.1
git --version          # Version control v2.51.0
gh --version           # GitHub CLI v2.78.0

# 📦 System Management
apt --version          # Package management v2.8.1
curl --version         # Data transfer tool v8.15.0
ls /usr/bin            # 400+ available commands

The Core Principle: Any ARM64 executable can become a "fake shared library" by simply adding .so extension.

# Traditional approach
node (binary) → Extract → Install → Set permissions → Symlink

# Termux AI approach  
node (binary) → Rename to node.so → Place in jniLibs/ → Android handles everything

Step-by-step process:

1. Binary executables (node, git, gh) → Add .so postfix → node.so, git.so
2. Script files (npm, npx) → Also become .so files → npm.so, npx.so
3. Android APK build → Automatically includes all .so files from jniLibs/arm64-v8a/
4. App installation → Android extracts to /data/app/.../lib/arm64/ (read-only, executable)
5. First launch → TermuxInstaller.java creates symbolic links in /usr/bin/
6. Ready to use → node --version, npm install, git clone work instantly

• W^X Policy: Executables in read-only /data/app system location
• SELinux Compatible: Uses Android's native library extraction mechanism
• Android 14+: Full support with foreground service permissions

Why Three AI Tools?

• 🧠 Different strengths - Each AI excels in different areas
• 🔄 Fallback options - If one is unavailable, others continue working
• 🎯 Specialized tasks - Choose the best AI for your specific needs

FFmpeg Power on Android:

• 🎥 Video Processing - Convert, compress, edit video files
• 🎵 Audio Manipulation - Extract, convert, enhance audio streams
• 📱 Mobile Optimized - ARM64-native for optimal Android performance
• 🔧 Professional Grade - Same tool used by YouTube, Netflix, and major platforms

🎉 PERFECT INTEGRATION: All 48 packages with executables/libraries are now fully integrated and working!

The Standard Operating Procedure transforms any Termux .deb package into Android-native executables:

# 🎯 One-command integration (recommended)
make sop-add-package PACKAGE_NAME=nodejs VERSION=24.7.0

# 🔍 Step-by-step debugging workflow
make sop-list LETTER=n                # 📋 Browse available packages
make sop-download PACKAGE_NAME=nodejs VERSION=24.7.0  # 📦 Fetch .deb
make sop-extract PACKAGE_NAME=nodejs  # 📋 Unpack contents
make sop-analyze PACKAGE_NAME=nodejs  # 🔍 Identify executables & deps
make sop-copy PACKAGE_NAME=nodejs     # ➡️ Transform to .so files
make sop-update PACKAGE_NAME=nodejs   # 📝 Update Java integration
make sop-build                        # 🛠️ Build & test APK

# 🧪 Package verification commands
make sop-check PACKAGE_NAME=nodejs    # ✅ Verify single package integration
make sop-check-all                    # 📊 Test all 89 packages (100% success)

# 🔄 Package update management
make sop-check-updates PACKAGE_NAME=nodejs  # 🔍 Check if package has newer version
make sop-check-all-updates            # 📊 Check all local packages for updates
make sop-get-packages                 # 📥 Download repository metadata

For complex packages like FFmpeg with extensive multimedia dependencies, use the SOP Loop for systematic resolution:

# 🎯 Dependency Resolution Loop (until all dependencies are satisfied)
make sop-ldd-test PACKAGE_NAME=ffmpeg    # 🔍 Identify missing libraries
make sop-find-lib LIBRARY=libssl.so      # 📋 Find package containing library  
make sop-add-package PACKAGE_NAME=openssl VERSION=3.5.2  # ➕ Add dependency
make build && make install               # 🛠️ Test integration
# Repeat until sop-ldd-test shows all libraries found

# 🧪 Comprehensive testing
make sop-ldd-test                        # 📊 Test all 17 executables for dependencies

Real-world example - FFmpeg multimedia integration required resolving 20+ dependencies:

• AV1 codecs: libaom, librav1e, libSvtAv1Enc, libdav1d
• Audio codecs: libopencore-amr, libmpg123, libtheora, libFLAC
• Security: libsodium, libvo-amrwbenc
• Formats: libwebp, libbluray, libudfread

Each iteration of the SOP loop identifies the next missing dependency, achieving 17/17 executables (100%) passing dependency tests with complete FFmpeg resolution.

What happens under the hood:

1. Download .deb from Termux repository
2. Extract using dpkg-deb to analyze contents
3. Transform binaries: usr/bin/node → jniLibs/arm64-v8a/node.so (No lib prefix needed for executables)
4. Update TermuxInstaller.java with new executable mappings
5. Build APK with integrated native executables

When you see runtime errors like "library libcharset.so not found", here's the systematic approach:

🔍 Step 1: Find the source package

grep "libcharset.so" packages/Contents-aarch64
# Output: usr/lib/libcharset.so.1 libiconv
#         ^^^ library file    ^^^ source package

📦 Step 2: Download & extract dependency

make sop-download PACKAGE_NAME=libiconv VERSION=1.18-1
make sop-extract PACKAGE_NAME=libiconv

➡️ Step 3: Transform library to Android format

cp packages/libiconv-extract/data/data/com.termux/files/usr/lib/libcharset.so.1 \
   app/src/main/jniLibs/arm64-v8a/libcharset.so
#  ^^^ Original versioned name                 ^^^ Simplified Android name

📝 Step 4: Update Java integration

• Add "libcharset.so" to baseLibraries array in TermuxInstaller.java
• This ensures the library is available when executables need it

🛠️ Step 5: Build and verify

make build && make install && make run
# Test: Launch app, run command that needed the library

💡 Pro tip: The Contents-aarch64 file maps every file to its source package, making dependency resolution straightforward.

The SOP Check system ensures every integrated package works correctly on the Android device:

# Check a specific package integration
make sop-check PACKAGE_NAME=nodejs

What it verifies:

• 📦 Host Analysis: Identifies all executables, libraries, and scripts from the package
• 📱 Device Verification: Confirms each file exists and is accessible on device
• 🔧 Functional Testing: Executes commands to verify they run without errors
• 📊 Dependency Resolution: Checks all required libraries are present

Example output for successful package:

🔍 SOP Checker: Comparing nodejs files between host and device
============================================================================
📦 Host Package Analysis
🔧 Executables in /usr/bin:
  📄 node (NATIVE) - Expected in /usr/bin/ via jniLibs
  📜 npm (SCRIPT) - Expected in /usr/bin/ via assets
  📜 npx (SCRIPT) - Expected in /usr/bin/ via assets

📱 Device Verification
✅ node - EXISTS (symlink → /data/app/.../lib/arm64/node.so)
✅ npm - EXISTS (symlink → /data/data/com.termux/files/usr/lib/node_modules/npm/bin/npm-cli.js)

🧪 Functional Testing
✅ node --version: v24.7.0
✅ npm --version: 11.5.1

📊 Summary
✅ All 3 files from nodejs are present and accessible

Test all 89 integrated packages at once:

make sop-check-all

Features:

• 🔄 Auto-extraction: Downloads and extracts any missing packages
• 📊 Progress tracking: Shows real-time status for each package
• 📈 Summary report: Final statistics with pass/fail counts
• 🎯 100% Success rate: v1.8.0 achieves complete package integration

Example summary:

📈 Final Summary
================
📊 Packages checked: 89
✅ Passed: 89
❌ Failed: 0

🎉 All extracted packages are properly integrated!

The Magic: Transform a traditional Linux binary into an Android-native executable:

# 1. Download the Termux package
wget -O packages/git_2.51.0_aarch64.deb \
  "https://packages.termux.dev/apt/termux-main-21/pool/main/g/git/git_2.51.0_aarch64.deb"

# 2. Extract the package
dpkg-deb -x packages/git_2.51.0_aarch64.deb packages/git-extract

# 3. The key transformation: Binary → Fake shared library
cp packages/git-extract/data/data/com.termux/files/usr/bin/git \
   app/src/main/jniLibs/arm64-v8a/git.so
#   ^^^^^ ARM64 binary becomes git.so (no lib prefix for executables) ^^^^^

# 4. Handle missing dependencies (discovered at runtime)
# App crash: "library libcharset.so not found"

# 5. Find dependency source using Contents index
grep "libcharset.so" packages/Contents-aarch64
# Output: usr/lib/libcharset.so.1 libiconv

# 6. Add the missing dependency
wget -O packages/libiconv_1.18-1_aarch64.deb \
  "https://packages.termux.dev/apt/termux-main-21/pool/main/libi/libiconv/libiconv_1.18-1_aarch64.deb"
dpkg-deb -x packages/libiconv_1.18-1_aarch64.deb packages/libiconv-extract
cp packages/libiconv-extract/.../libcharset.so.1 app/src/main/jniLibs/arm64-v8a/libcharset.so
cp packages/libiconv-extract/.../libiconv.so.2 app/src/main/jniLibs/arm64-v8a/libiconv.so

# 7. Update Java integration code
# In TermuxInstaller.java:
# executables array: {"git.so", "git"}
# baseLibraries array: "libcharset.so", "libiconv.so"

# 8. Build, install, and test
make build && make install && make run
# Result: git --version shows "git version 2.51.0"

What just happened?

• Git binary (ARM64 ELF) → Renamed to git.so → Android treats it as a shared library
• Android automatically extracts to /data/app/.../lib/arm64/git.so with executable permissions
• Symbolic link /usr/bin/git → Points to the extracted location
• Dependencies resolved the same way → No complex package management needed

Key Insights:

• ✅ No lib prefix needed → Executables use simple naming: node.so, git.so, npm.so
• ✅ Executable rule → All executables (binaries, shell scripts, Node.js scripts) get .so postfix and go in jniLibs/
• ✅ JavaScript modules → Keep .js extension and place in assets/termux/usr/lib/node_modules/ for imports
• ✅ Libraries keep prefix → System libraries use lib prefix: libssl3.so, libcurl.so
• ✅ Assets for data → Large dependency trees and importable modules go in assets/

Integration Rules:

1. Executable Integration (for CLI commands):

   • ANY executable file (binary, shell script, Node.js script) → Add .so extension → Place in jniLibs/arm64-v8a/
   • Android extracts all .so files to system location with executable permissions
   • TermuxInstaller creates symbolic links from /usr/bin/ to the extracted executables

2. JavaScript Module Integration (for require/import):

   • JavaScript files intended for require() or import → Keep .js extension → Place in assets/termux/usr/lib/node_modules/
   • Allows other scripts to import: require('gemini.js') or import gemini from 'gemini.js'

3. Dual Integration (for Node.js tools that are both CLI and module):

   • Place same content in both locations: jniLibs/arm64-v8a/gemini.so (executable) + assets/.../node_modules/gemini.js (module)
   • Enables both CLI usage (gemini --help) and programmatic usage (require('gemini.js'))

termux_AI/
├── packages/                              # 📦 Downloaded .deb packages
│   ├── nodejs_24.7.0_aarch64.deb          # Source packages
│   ├── git_2.51.0_aarch64.deb
│   └── Contents-aarch64                   # Package index for dependencies
│
├── app/src/main/
│   ├── jniLibs/arm64-v8a/                 # ⚙️ EXECUTABLE DIRECTORY
│   │   ├── node.so                        # Node.js binary (24MB)
│   │   ├── git.so                         # Git binary (2.1MB)
│   │   ├── gemini.so                      # Gemini AI CLI script (12MB)
│   │   ├── libssl3.so                     # OpenSSL library
│   │   └── libcurl.so                     # cURL library
│   │
│   ├── assets/termux/usr/lib/             # 📋 MODULES & DEPENDENCIES
│   │   ├── node_modules/                  # NPM ecosystem
│   │   │   ├── npm/                       # NPM package manager
│   │   │   ├── corepack/                  # Node.js package manager manager
│   │   │   └── gemini.js                  # Gemini module for require/import
│   │   └── ca-certificates/               # SSL certificates
│   │
│   └── java/.../TermuxInstaller.java      # 🔗 Symlink orchestration
│
├── Makefile                               # 🤖 Automation commands
└── releases/                              # 📦 Generated APKs

The .so File Magic:

• Any ARM64 executable can masquerade as a shared library
• Android's APK installer automatically handles .so files
• No special NDK compilation required - just rename binary files

Why This Works:

1. Android assumption: .so files in jniLibs/ are native libraries
2. Reality: They can be any ARM64 executable with .so extension
3. Result: Android extracts them to system space with executable permissions
4. Access: Symbolic links provide traditional Unix PATH access

📱 Android System Locations (Read-only, W^X compliant)
/data/app/~~long-hash~~/com.termux/lib/arm64/
├── node.so             # Node.js v24.7.0 runtime (24MB)
├── npm.so              # npm package manager script
├── npx.so              # npx package executor script
├── git.so              # Git v2.51.0 binary (2.1MB)
├── gh.so               # GitHub CLI v2.78.0 (15MB)
├── libssl3.so          # OpenSSL v3.5.2 library
└── libcurl.so          # cURL v8.15.0 library

🏠 Termux Home Environment (Read-write)
/data/data/com.termux/files/usr/
├── bin/                # Symbolic links to Android system locations
│   ├── node -> /data/app/.../lib/arm64/node.so    ⚡
│   ├── npm -> /data/app/.../lib/arm64/npm.so      ⚡
│   ├── npx -> /data/app/.../lib/arm64/npx.so      ⚡
│   ├── git -> /data/app/.../lib/arm64/git.so      ⚡
│   └── gh -> /data/app/.../lib/arm64/gh.so        ⚡
├── lib/
│   ├── node_modules/   # NPM packages extracted from assets
│   │   ├── npm/        # NPM package manager
│   │   └── corepack/   # Node.js package manager manager
│   └── *.so           # Additional shared libraries
└── home/              # User workspace (projects, configs)

The Beauty:

• 🔒 Executables: Immutable, in Android system space, W^X compliant
• 📝 User data: Mutable, in app private space, writable
• ⚡ Performance: No file copying, just symbolic links
• 🛡️ Security: SELinux-friendly, uses Android's native mechanisms

The .profile automatically sources /data/local/tmp/android_sourceme if it exists, allowing for custom environment setup:

# Place custom configuration in /data/local/tmp/android_sourceme
adb shell "echo 'export CUSTOM_VAR=value' > /data/local/tmp/android_sourceme"

# The file will be automatically sourced on app launch
# See examples/android_sourceme_example.sh for configuration ideas

• TermuxInstaller.java: Replaced bootstrap with native executable verification
• TermuxShellEnvironment.java: Simplified PATH to /system/bin only
• AndroidManifest.xml: Android 14+ foreground service permissions
• TermuxActivity.java: Fixed broadcast receiver export flags

💡 Pro Tip: Try different AIs for the same task to get varied perspectives and solutions!

💡 Quick test: Run ls /usr/bin | wc -l to see total available commands (296+)

# Get help with complex code
gemini "Explain this Python function: def fibonacci(n): return n if n <= 1 else fibonacci(n-1) + fibonacci(n-2)"

# Code review and optimization
claude "Review this JavaScript code for potential security issues: const user = eval(input)"

# Generate boilerplate code
codex "Create a Node.js Express server with authentication middleware"

# Debug and fix issues
codex-exec "Fix the syntax error in my Python script"

# Convert video formats
ffmpeg -i input.mp4 -c:v libx264 -c:a aac output.mp4

# Extract audio from video
ffmpeg -i video.mp4 -vn -acodec copy audio.m4a

# Resize video for mobile
ffmpeg -i input.mp4 -vf scale=720:480 -c:a copy mobile.mp4

# Get video information
ffprobe -v quiet -print_format json -show_format -show_streams video.mp4

# Use AI to generate FFmpeg commands
claude "Generate an FFmpeg command to compress a 4K video to 1080p with good quality"

# Get coding help for multimedia projects
gemini "Write a Node.js script that uses child_process to run FFmpeg commands"

# Debug multimedia issues
codex "Why is my FFmpeg command producing corrupted audio output?"

make sop-user-test   # Automated UI testing via ADB
make sop-test        # Interactive command testing
make logs           # Monitor app behavior

Connect and test the magic:

# 🔌 Get shell access to running Termux AI
adb shell run-as com.termux
cd /data/data/com.termux/files/home

# 🧪 Test core functionality
node --version      # ✅ Should show: v24.7.0
npm --version       # ✅ Should show: v11.5.1
git --version       # ✅ Should show: git version 2.51.0
gh --version        # ✅ Should show: gh version 2.78.0
codex --help        # ✅ Should show: AI CLI assistance

# 🔍 Verify the architectural magic
ls -la /usr/bin/    # 🔗 All symlinks to /data/app/.../lib/arm64/
ls -la /data/app/*/com.termux/lib/arm64/  # 📱 Android-extracted binaries
echo $PATH          # 📋 Should include /data/data/com.termux/files/usr/bin

# 🏁 Real-world test
npm init -y         # 📦 Create package.json
echo 'console.log("Hello Termux AI!")' > hello.js
node hello.js       # ✨ Execute JavaScript
git init && git status  # 📁 Version control works

What's Included vs. What's Not:

• ✅ Included: Core development tools (Node.js, Git, AI tools)
• ✅ Available via APT: Additional packages from Termux repository
• ❌ Not included: GUI applications, X11 support, desktop environments
• ❌ Architecture limit: x86, x86_64, ARMv7 not supported in current build

• 89 packages integrated natively with 100% success rate
• Additional AI tools - Gemini CLI and Codex CLI for enhanced development
• 400+ commands available instantly without bootstrap
• Clean naming convention - No lib prefix for executables
• 262MB APK with complete development environment
• Android 14+ compatibility with foreground services
• Automated releases via GitHub Actions
• Zero bootstrap - launch and code immediately

• ✅ Clean Naming Convention - Removed lib prefix from 100+ executables
• ✅ 100% Package Integration - All 89 packages fully working
• ✅ Comprehensive SOP Testing - make sop-check-all verifies everything
• ✅ Fixed Multicall Binaries - coreutils.so handles 100+ commands correctly
• ✅ Enhanced Documentation - Complete command reference and examples

• SOP Documentation: Run make sop-help for complete package integration guide
• Build System: Run make help for all available commands
• GitHub Releases: Automated via make github-release
• Issue Tracking: Report problems via GitHub Issues

Follows upstream Termux licensing. See individual component licenses for native binaries.

Ready to develop? Download the latest release and start coding with Node.js v24.7.0 and AI assistance immediately!