A URL in. An Android, Windows or Linux app out.
Package an HTTPS site as a locally signed Android WebView APK, an unsigned Windows app, or a Linux Flatpak, AppImage or tarball, entirely in your browser. No account, no cloud build.
Built with
Kotlin and Android System WebView on the Android shell side; Rust and Tauri with WebView2/WebKitGTK on the desktop side; Hono, Vite, Tailwind CSS and Cloudflare Workers on the web side; Rust/WASM with backhand for per-app AppImage metadata and ostrya for classic Flatpak bundles; WebCrypto for the Android key and signature. IBM Plex Mono is self-hosted under the SIL Open Font License.
Static screenshots: light · dark · mobile
Also searched as website to app, web to desktop app, URL to APK, website to APK, HTML to APK, PWA to APK, WebView wrapper, or a local app generator. It is a browser-only alternative to PWABuilder, Bubblewrap, Tauri CLI and Electron Forge.
Firefox on Android can add a site to the home screen, but it stays a browser-badged shortcut. A real PWA install usually means Chrome, Digital Asset Links and often a cloud build. URL to App started as a local Android answer to that: a prebuilt Kotlin WebView shell, patched and signed in the tab.
The shell-plus-data model generalised, so we took it further. Windows and Linux reuse the same build-once, patch-in-the-tab idea with Tauri shells, and Linux now defaults to a Flatpak on the shared GNOME runtime. Android remains the most complete target.
No login, no queue, no server-side build.
Android, Windows and Linux are live. macOS is not supported yet; contributions are welcome.
- Open url2app.yasogan.dev.
- Paste a full HTTPS URL, e.g.
https://example.com/. - Choose the app name and icon (letter, upload or fetch).
- Generate the package. Android builds ask for a backup password for the signing key; desktop builds are unsigned and skip the key step.
- Save the
.p1xkey backup on Android and install the output.
The first Android build creates an RSA-2048 key, downloads the encrypted backup and signs the APK. Later builds reuse the non-exportable key in IndexedDB; keep the .p1x file safe.
- Android: a launcher icon, app-drawer entry and its own window. Uploads, downloads, camera, microphone, geolocation and fullscreen video. A local error/retry screen and safe back navigation. Your key, your signature, your package.
- Windows: a per-app
Setup.exewith per-user or system-wide install, and a portable.zip. One app per site, with its own shortcut, window title and isolated WebView2 profile. The installer takes its title from the generated app name and installs under<app-name>-<short id>instead of an opaque internal ID. - Linux: a classic Flatpak
.flatpakbundle, a Flatpak OCI archive, a system-WebKit AppImage and a.tar.gz, with x86_64 and aarch64 builds. The classic.flatpakis a local bundle built by a small Rust/WASM OSTree writer in the tab; the OCI archive is the fallback for Flatpak 1.18+. Both use the shared GNOME runtime, so WebKitGTK security updates arrive with the runtime instead of a per-app rebuild. The AppImage and tarball use the host WebKitGTK. - Every target: the URL, name and icon are data. The shell is built once and reused, so no per-site compiler run.
- Not a browser. It is a WebView wrapper around the live URL; there is no offline copy.
- Google sign-in will fail. Google blocks OAuth in embedded WebViews.
- No Web Push, browser extensions or Firefox profile on Android.
- No App Links or domain capture; links to the site still open in your default browser.
- DRM L1 and passkeys are limited, and some sites block WebView.
- Windows builds are unsigned and will show SmartScreen warnings. They do not update themselves.
- The classic Flatpak needs the GNOME 50 runtime and a Flatpak that supports local bundles. The Flatpak OCI archive needs Flatpak 1.18+ for
oci-archive:installs. The system-WebKit AppImage still needs FUSE;--appimage-extract-and-runand the tarball are the fallbacks. Downloads need the executable bit. - macOS is not supported yet. The current builder will show a contribution note instead of a macOS download.
- A prebuilt shell per platform. Android uses a Kotlin WebView shell (minSdk 24, targetSdk 36, Android System WebView, no AndroidX). Desktop uses a Tauri v2 shell with a native WebView and no IPC for remote content.
- Data, not compilation. Android uses fixed template slots for the package, label, version code and icon paths. Desktop uses a sidecar
config.json(including the window size), or a 64-byte trailer appended to single-file artifacts such as the AppImage and the Windows installer. - The browser does the patching. Android patches the binary manifest,
resources.arsc, every launcher PNG andassets/config.json, then builds a locally signed APK. Desktop patches PE icons/version info for the portable exe, rewrites the Flatpak OCI archive or builds a classic.flatpak, appends the config payload for the AppImage/installer, and packs the tar or zip with the right modes. - Artifacts are built once in CI. Shell binaries and installers live as versioned static assets with a SHA-256 manifest. The browser fetches the base for the selected target, verifies it, patches it and downloads the result. Nothing is compiled per site. The Flatpak base is a small OCI archive containing the shell. The browser rewrites it into a per-site OCI bundle with a URL-derived app ID, desktop entry, icon and config, and recomputes every OCI digest. For the classic
.flatpakit passes the patched app tree to a Rust/WASM OSTree writer that builds the file, dirtree, dirmeta, commit and empty-base static delta, then wraps them in the Flatpak bundle metadata. A small GVariant encoder handles the OCI commit labels. AppImage bases use gzip squashfs and a small Rust/WASM repacker replaces the embedded desktop entry and icon before the config trailer is appended. The Android template and desktop bases share theurl2app-shells-v1CacheStorage cache; the template is refreshed after 24 hours with a stale fallback, and the selected base is only fetched when a build starts. - A reverse-domain package for Android.
example.com→com.example,www.example.com→com.example,news.ycombinator.com→com.ycombinator.news. A leadingwwwis dropped when it is a subdomain.
- Android: 136 unit tests, lint clean, 100% line coverage gate.
- Web: 625 tests; all
src/**is under a 100% statements/branches/functions/lines gate. Lighthouse CI enforces budgets on the homepage. - Desktop: the Windows and Linux shells, browser packaging, installer, AppImage metadata repacker, classic Flatpak OSTree writer, Flatpak OCI patcher and release workflow are implemented. The live builder is on release v1.6.2; the Windows installer has been validated on Windows. macOS is deferred.
- Live: url2app.yasogan.dev on Cloudflare Workers.
Requirements: JDK 17, Android SDK 36 + build-tools 36.0.0, Node 24 and pnpm 12. Desktop shell builds additionally need Rust and the Tauri prerequisites for the target OS. Rebuilding the optional WASM modules (the AppImage metadata repacker and the classic Flatpak writer) needs the wasm32-unknown-unknown target and wasm-bindgen-cli 0.2.129; the generated modules are checked in for normal web builds. Installing a generated classic Flatpak needs the GNOME 50 runtime from Flathub; the OCI archive also needs Flatpak 1.18+. The classic .flatpak is generated locally by the Rust/WASM writer.
cd web
pnpm install
pnpm dev
pnpm typecheck
pnpm test:coverage
pnpm build
pnpm deploycd android
./gradlew :app:check :app:assembleRelease
tools/export-template.shcd desktop
cargo test -p url2app-shell-core -p url2app-installer-helper
cargo check -p url2app-shellweb/public/shell.apk is a generated local test fixture, not a checked-in file; run android/tools/export-template.sh before pnpm test:coverage or pnpm build. The release stages the exported template into web/public/shells/<sha>/shell.apk and records it as android in shells.json; the client loads that URL instead of the site root. pnpm deploy needs a Cloudflare login and deploys the Worker and static assets.
The web APK integration tests find aapt2, zipalign and apksigner under $ANDROID_HOME (or via AAPT2, APKSIGNER, ZIPALIGN) and skip when they are absent. CI installs them.
To rebuild the checked-in WASM modules after changing their Rust sources, run ./build.sh in web/wasm/appimage-repack and web/wasm/flatpak-bundle.
| Path | Contents |
|---|---|
.github/workflows/ |
CI, WASM module, desktop coverage and tagged-release/deploy workflows. |
android/ |
Kotlin WebView shell, Gradle build, tests and the template export script. |
desktop/ |
Tauri shell, core, installer helper, NSIS scripts, base-packaging tools and tests. tools/build-flatpak-base.sh builds the Flatpak OCI base. |
web/ |
Cloudflare Vite + Hono app, Tailwind UI, favicon proxy and the browser packaging pipelines. |
web/pages/ |
HTML entry pages for the builder, guides and the 404 page. |
web/src/client/ |
Browser-side packagers, including the APK, PE, AppImage, Flatpak OCI and classic Flatpak paths. |
web/src/client/apk/ |
ZIP writer, AXML/ARSC patchers, icon layers, key vault and v2 signer. |
web/src/client/desktop/ |
Windows, AppImage and Flatpak builders, tar/GVariant helpers and the shell manifest client. |
web/src/worker/ |
Cloudflare Worker routes, headers and the favicon proxy. |
web/wasm/appimage-repack/ |
Rust/WASM AppImage metadata repacker source and build script. |
web/wasm/flatpak-bundle/ |
Rust/WASM classic Flatpak OSTree writer, its native validation helper and tests. |
web/wasm/backhand/ |
Vendored backhand dependency for the AppImage repacker. |
web/public/wasm/ |
Generated browser modules for the AppImage repacker and classic Flatpak writer (checked in). |
web/public/shell.apk |
Generated local Android test fixture (ignored by Git). The release publishes the staged copy under web/public/shells/<sha>/. |
web/public/shells/ |
Generated desktop shell bases and the Android template (ignored by Git; produced by CI). |
web/public/shells.json |
Generated shell manifest, including the Android template (ignored by Git; produced by CI). |
web/test/helpers/ |
Synthetic AXML, PE, ELF, PNG and tar helpers for the packaging tests. |
web/tools/ |
Static-site response checks, CSP hash verification and the Lighthouse budget checker. |
docs/ |
README screenshots and the demo GIF. |
Android identifies an app by package name and signing certificate. This builder writes version code 1, so it is designed for a fresh install on each device; keep the same key if you rebuild, or uninstall the old app before installing one signed with a different key.
The private key is generated with WebCrypto and imported as non-extractable; it stays in IndexedDB. The portable copy is a .p1x file encrypted with PBKDF2-SHA256 + AES-GCM. Lose the key and the backup and you cannot install a replacement over the app; you would have to uninstall it and lose its data. Store the backup.
Desktop packages are unsigned. They do not use the Android key and do not auto-update. Regenerating the app is the only update path for the shell. The release workflow builds the shell bases, both NSIS installers, the system-WebKit AppImage, the Flatpak OCI base and shells.json; it needs the CLOUDFLARE_API_TOKEN and CLOUDFLARE_ACCOUNT_ID secrets to deploy.
Flatpak WebKit updates come from the shared GNOME runtime. The per-site Flatpak bundle itself only carries the shell and its config, so a runtime update fixes WebKitGTK without rebuilding or redistributing any generated app. Existing generated apps still need to be regenerated for shell changes. Install the classic .flatpak with flatpak install --user <file>, or the OCI archive with flatpak install --user --image oci-archive:<file>; the runtime is supplied by Flathub.
These are personal sideloaded builds. Android will warn about unknown apps, Play Protect may flag them, and Google's developer verification is rolling out (30 September 2026 in Brazil, Indonesia, Singapore and Thailand; global in 2027). Unverified sideloads may need ADB or the advanced flow. Do not publish these wrappers to Google Play; they do not meet the minimum-functionality policy.
Windows builds will trigger SmartScreen until they earn reputation; users need the "More info" flow. Linux tarballs preserve the executable bit, while AppImages need chmod +x after a browser download. Classic Flatpaks need the GNOME 50 runtime; the OCI archive needs Flatpak 1.18+. macOS is not supported yet.
No accounts, analytics, telemetry or third-party scripts. HTML responses stay revalidated and compressible; a strict CSP blocks injected analytics and third-party scripts. HTTPS responses send a two-year Strict-Transport-Security policy with includeSubDomains and preload. The package is assembled in the tab. The only third-party request is the optional favicon lookup through this deployment's /api/favicon endpoint; it rejects private hosts and revalidates redirects. Desktop builds download their prebuilt shell from this deployment and nothing else.
Wrap only sites you have the right to use. Do not impersonate a brand or distribute an app you do not own.
Apache-2.0. See LICENSE and THIRD_PARTY.md. Contributions follow CONTRIBUTING.md; report vulnerabilities through SECURITY.md.
