# openclaw-termux: Running the OpenClaw AI Gateway on Android Without Root

> A Flutter app and an npm CLI that install Ubuntu through proot, then run Node.js 22 and the OpenClaw gateway on the phone itself. Here is what the setup actually does, what it costs in storage, and where it stops being the right tool.

**mithun50/openclaw-termux** — Run OpenClaw AI Gateway on Android — standalone Flutter app with built-in terminal, web dashboard, and one-tap setup. Also available as a Termux CLI package.

- Repository: https://github.com/mithun50/openclaw-termux
- Website: https://github.com/mithun50/openclawd-termux#readme
- Stars: 1,720 · Forks: 256
- Language: Dart
- License: MIT
- Published: 2026-09-14 · Updated: 2026-09-14 · Language: en
- Canonical page: https://hysenlabs.com/projects/mithun50-openclaw-termux

## The problem openclaw-termux solves on Android

The upstream OpenClaw project is an AI gateway: a process that holds provider credentials and routes requests to models from Anthropic, OpenAI, Google Gemini, OpenRouter, NVIDIA NIM, DeepSeek, xAI, MiniMax and Ollama. Running it normally means a Linux host with Node.js. Android is not that host. Termux gives you a shell, but the gateway still expects a conventional Linux userland, and the README notes the package is built for Termux "with Bionic Bypass", a reference to Android's Bionic libc differing from glibc.

openclaw-termux targets people who want the gateway on the device in their pocket: someone testing agent workflows away from a laptop, or someone who wants a local endpoint on a phone. The repository ships two front ends for the same job. A standalone Flutter app under flutter_app/ builds to an APK or AAB, and an npm package named openclaw-termux installs a CLI called openclawx. Both drive the same underlying setup. Neither requires root, which is the central constraint the project is designed around.

## How proot, Node.js 22 and the gateway fit together

The mechanism is layered. The installer downloads an Ubuntu rootfs and runs it through proot, a userspace chroot that needs no root privileges. Inside that Ubuntu environment it installs Node.js 22, then installs OpenClaw itself. The gateway process runs inside the proot environment, not as a native Android service.

On top of that sits the management surface. In the Flutter app, a foreground service keeps the gateway alive in the background with uptime tracking, a built-in terminal emulator runs commands directly, and an embedded WebView loads the dashboard with an authentication token captured during onboarding. The README states the dashboard is served at localhost:18789 in the Termux CLI path, with the app loading the same page in a WebView instead of a browser. Logs stream into a viewer with search and filter.

The app can also register itself as a node, exposing Android hardware to the AI over a WebSocket node protocol. The README lists nine capabilities spanning 21 commands: camera (camera.snap, camera.clip, camera.list), flash, location, screen recording via MediaProjection consent, sensors, haptics, and canvas (canvas.navigate, canvas.eval, canvas.snapshot). Permissions are requested when the node is enabled. Note the README's own annotation on canvas: permission is listed as none and the capability is marked "not implemented". A capability appearing in the table does not mean it works.

## Installing openclaw-termux: APK or npm CLI

There are two installation paths, and the README presents them as a choice between an app and a shell workflow. The APK route is the shorter one: download the release from the releases page, install it, and tap through the setup wizard. The README describes setup as one tap, after which the app downloads Ubuntu, Node.js 22 and OpenClaw automatically. Nothing to type.

The CLI route assumes Termux is already installed. The package requires Node.js 22 or newer (the engines field sets node >=22.0.0) and declares os as android and linux. Install it globally:

```bash
npm install -g openclaw-termux
```

The package exposes two binaries, openclawx and openclawx-setup, both pointing at bin/openclawx. A postinstall script runs lib/postinstall.js. Then run setup and start the gateway:

```bash
openclawx setup
openclawx start
```

The README's comparison table maps these to the app's buttons: "Begin Setup" and "Start Gateway". After starting, the dashboard should be reachable in a browser at localhost:18789. In the app, the equivalent view is the built-in WebView, which loads the dashboard with the authentication token already applied, so there is nothing to paste.

## Optional packages and what they cost you

After the base setup finishes, the app offers three optional development tools. The README gives their install methods and sizes: Go via apt install golang at roughly 150 MB, Homebrew through its official installer with a root workaround at roughly 500 MB, and OpenSSH via apt install openssh-server at roughly 10 MB. They surface in three places: package cards in the setup wizard after setup completes, a "Packages" card in the dashboard's Quick Actions, and an installation status line under System Info in Settings.

Homebrew is the one to think about. The README describes it as the official installer with a root workaround, and root workarounds inside a proot environment are where things tend to break in ways the project does not document. The README does not describe a rollback path for a failed Homebrew install, nor does it say what the root workaround actually does. If you do not need a package manager inside the Ubuntu layer, skipping Homebrew saves half a gigabyte and one of the less predictable steps.

The app also exposes an SSH server with a settable root password and copyable connection commands. That is useful for driving the environment from a desktop, but it also means the phone is listening. The README does not discuss hardening the SSH server.

## Where openclaw-termux is the wrong tool

The clearest limitation is the platform. The Flutter app targets Android 10 and above, and the npm package declares its OS as android and linux. There is no iOS path in the README. If your team is on iPhones, this project is not a candidate.

The second limitation is the proot layer itself. Running a full Ubuntu rootfs through proot on a phone is heavier than running the gateway natively, and the README's own framing of "Bionic Bypass" is an acknowledgement that Android's libc is not the target environment. Anything that assumes real root, kernel features, or glibc-specific behaviour is a candidate for failure, and the README does not enumerate which packages survive that boundary.

The third is the device as a server. A phone sleeps, gets throttled, and loses network when it moves. The app mitigates this with a foreground service and battery optimization settings, but those are mitigations, not a substitute for a machine that stays up. If the gateway is meant to serve other people or run unattended jobs, a small Linux box is the better answer. openclaw-termux is for a gateway that lives with you.

Finally, the canvas capability is listed but marked unimplemented. Treat the capability table as a roadmap mixed with a feature list.

## How it differs from installing OpenClaw on a server or desktop

The straightforward alternative is installing OpenClaw directly on a Linux server or desktop, following the upstream project's own instructions, with no proot layer at all. The difference is not cosmetic. On a server you get a real filesystem, a real init system, standard Node.js installation, and no translation layer between the gateway and the kernel. You also get an always-on host with a stable address, which is what you want if other clients connect to the gateway.

What you give up is portability and setup effort. The server route assumes you have a server, know your way around a shell, and are willing to manage the Node.js version yourself. openclaw-termux trades that for a wizard: it fetches the rootfs, pins Node.js 22, installs OpenClaw, and gives you buttons for start, stop, logs and configuration. The cost is the proot environment and the phone's constraints. If you already have a Linux host, the proot path adds a layer to solve a problem you do not have.

Within the project itself, the app and the CLI are also alternatives to each other. The app adds the terminal emulator, WebView dashboard, foreground service, node capabilities and optional package installers. The CLI gives you openclawx in a Termux shell and the dashboard in your browser. If you are comfortable in Termux, the CLI is the smaller surface.

## Maintenance, licence and what to check first

The repository is not archived, and the last push was on 2026-09-14, the same day as the v2026.9.14 release. The version scheme tracks upstream OpenClaw: v2026.9.14, v1.8.7 in April 2026, v1.8.6 in March 2026. That gap between April and September is worth noting if you depend on prompt upstream tracking. The package.json version is 2026.9.14, matching the latest release tag.

The project is MIT licensed, and the LICENSE file sits at the repository root. MIT is permissive: it allows use, modification and redistribution with the licence and copyright notice retained. That is a summary of the licence text, not legal advice, and the sponsored section in the README is a commercial placement rather than a licence term. The npm package pulls three runtime dependencies (chalk, inquirer, ora) plus a postinstall script, so an install runs code at install time. Review lib/postinstall.js if that matters to your environment.

Upgrade cost is the part the README does not cover. There is no documented procedure for upgrading the OpenClaw version inside an existing proot environment, and no documented rollback if an upgrade goes wrong. The Settings screen offers a re-run setup option, which suggests the recovery path is to redo the environment rather than patch it. Verify that assumption on a device you can wipe before you rely on it.

## Conclusion

Adopt openclaw-termux if you want the OpenClaw gateway reachable from a phone or tablet, you accept Android 10+ and a proot Ubuntu layer, and you would rather tap through a Flutter wizard than assemble the stack by hand. Skip it if you need iOS, if you want the gateway on a machine that stays powered and networked, or if you cannot spare roughly a gigabyte for the environment plus optional Go and Homebrew. Before committing, check that the gateway starts and serves the dashboard at localhost:18789 on your device, confirm the nine node capabilities you plan to use are implemented rather than listed, and read the MIT licence text in LICENSE.

## FAQ

### What is OpenClaw?

OpenClaw is an AI gateway, the upstream project that openclaw-termux brings to Android. The gateway holds provider credentials and routes requests to models from providers including Anthropic, OpenAI, Google Gemini, OpenRouter, NVIDIA NIM, DeepSeek, xAI, MiniMax and Ollama.

### Can I run OpenClaw on my phone?

Yes, that is what openclaw-termux is for. It sets up an Ubuntu environment through proot, installs Node.js 22 and OpenClaw inside it, and provides either a Flutter app with a built-in terminal or a Termux CLI called openclawx to manage the gateway. No root is required, and the app targets Android 10 and above.

### How do I install openclaw-termux in Termux?

Run npm install -g openclaw-termux, which requires Node.js 22 or newer and installs the openclawx binary. Then run openclawx setup followed by openclawx start, after which the dashboard is served at localhost:18789. The alternative is downloading the APK from the releases page and tapping through the setup wizard.

### Does openclaw-termux need root on Android?

No. The README states the setup uses proot to create the Ubuntu environment, which works without root privileges. It also describes the package as built for Termux with Bionic Bypass, a reference to Android's libc differing from glibc.

### What are the node device capabilities in the openclaw-termux app?

The app can connect to the gateway as a node and expose Android hardware to the AI, listing nine capabilities across 21 commands: camera, canvas, flash, location, screen recording, sensors and haptics among them. Permissions are requested when the node is enabled, and the README marks the canvas capability as not implemented.

## Sources

- [License: MIT](https://github.com/mithun50/openclaw-termux/blob/main/LICENSE)
- [mithun50/openclaw-termux on GitHub](https://github.com/mithun50/openclaw-termux)
- [Project website](https://github.com/mithun50/openclawd-termux#readme)
- [README](https://github.com/mithun50/openclaw-termux/blob/main/README.md)
- [Releases](https://github.com/mithun50/openclaw-termux/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/mithun50-openclaw-termux