WebToApp

Build Android APKs from web projects, directly on your phone.

WebToApp is an on-device APK builder for websites, HTML apps, media projects, and local server runtimes. Turn a URL, a project folder, or a media library into an installable Android app you can preview, sign, install, share, or export without sending the build to a remote service.

English · 简体中文

Why WebToApp · What you can build · Highlights · Module Market · Feature map · Build

Most "website to app" tools stop at wrapping a URL. WebToApp is closer to a pocket-sized APK workshop: it combines a configurable WebView, local server runtimes, APK signing, extension modules, project import/export, and app management in one Android app.

• Build on the device - package and sign APKs inside the app, with no remote build queue.
• Go beyond static pages - package websites, HTML/front-end builds, Node.js, PHP, Python, Go, WordPress, media apps, galleries, and multi-site apps.
• Keep control of the output - choose package name, icon, permissions, signing key, signature schemes, runtime options, and export format.
• Extend after shipping - add JS/CSS modules, userscripts, or MV3 Chrome extensions without rebuilding the host app.
• Stay inspectable - the Android client, module catalog, and build logic live in this repository.

Supported AppType values include Web, HTML, Frontend, WordPress, Node.js, PHP, Python, Go, Image, Video, Gallery, and Multi-Web.

1. Create an app from a URL, project folder, media set, or local runtime template.
2. Customize the WebView, toolbar, splash screen, modules, permissions, signing, and runtime behavior.
3. Preview on the phone before producing the final APK.
4. Build and sign the APK on-device through com.android.tools.build:apksig.
5. Install, share, export, or back up the generated app and its project data.

Releases are published on GitHub Releases.

The WebToApp host app pins targetSdk = 28 deliberately — not as a limitation, but as the enabling choice that lets generated apps run Node.js, PHP, Python, Go, and WordPress as native binaries straight from app storage, the way Termux does. Most "URL to APK" tools can only wrap a WebView; running full server runtimes on-device is the hard part, and 28 is what makes it possible. Because of this, the host ships through GitHub Releases.

This trade-off only applies to the host and to fork-based runtime apps. Generated Web, HTML, front-end, and media apps are fully publishable to Google Play: the on-device AAB exporter rewrites targetSdk to the Play-required level (currently 35) and signs the bundle locally, so they ship to the Play Store directly. Apps that fork local native runtimes (Node.js, PHP, Python, Go, WordPress) stay APK-only, since Play Store apps cannot fork binaries on modern Android.

WebToApp has a GitHub-backed module market for community JS/CSS extensions. The catalog is just files in this repository, so contributions use a normal pull request flow.

modules/
├── registry.json        # app-facing catalog
├── submissions.json     # CI-generated PR / submitter metadata
├── README.md            # contributor guide
├── hello-world/
├── night-shift/
├── reading-mode/
├── floating-search/
└── auto-scroll/

The app fetches both registry.json and submissions.json, and only shows modules that appear in both. That keeps the in-app catalog aligned with PRs that have actually been merged.

• Users open Extension Modules and tap the storefront icon.
• Contributors add a folder under modules/, update registry.json, and open a PR.
• The default client cache is one hour, so merged modules propagate without an app update.

Module contributor guide · General contributing guide

The full app has many switches. The sections below group the important ones without making the top of the README feel like a settings dump.

• The repository has two Gradle modules: app is the full builder and host; shell is the runtime host embedded into generated APKs.
• Runtime code is authored in app and synchronized into shell, so shared WebView/runtime behavior has one source of truth.
• The APK builder patches template APKs at the binary AXML/ARSC level, injects config/resources, prunes permissions, and signs with apksig.
• The host pins targetSdk = 28 deliberately — it is what lets generated apps fork and exec native runtimes (Node.js, PHP, Python, Go, WordPress) from app storage, a capability URL-wrapper tools lack; the AAB exporter separately rewrites targetSdk for Play Store distribution.
• Server runtimes and optional GeckoView native runtime are downloaded on first use instead of bundled into the base APK.

• Kotlin, Jetpack Compose, Material 3
• Koin for dependency injection
• Room 2.7.2 + KSP for persistence
• OkHttp 4.12.0 + okhttp-dnsoverhttps
• com.android.tools.build:apksig 8.3.0 for APK signing
• protobuf-javalite 3.25.5 for AAB metadata
• GeckoView as an optional browser engine
• Coil for image/video/GIF loading
• AndroidX Security Crypto + DataStore for stored secrets
• Vico Compose-M3 for charts
• ZXing for QR sharing
• Apache Commons Compress + xz for project import and website scraping
• Native C++ through JNI for node_launcher and go_exec_loader
• Robolectric for unit tests

See app/build.gradle.kts for the complete dependency list.

Requirements: Android Studio Hedgehog or newer, JDK 17. The Gradle wrapper pins Gradle 9.4.1.

git clone https://github.com/shiaho777/web-to-app.git
cd web-to-app
./gradlew assembleDebug

For release builds, configure signing through local.properties and app/build.gradle.kts.

Developed by shiaho.

The Unlicense.

Advanced features such as forced run, BlackTech, device disguise, and Icon Storm are intended for technical demonstration and must only be used with informed user consent.