PakePlus-Android: Package Any Website into a Mobile or Desktop App via GitHub Actions

What PakePlus Wraps and How It Differs from Electron

PakePlus-Android packages websites and local HTML projects into native apps for Android, iOS, macOS, Windows, and Linux. The README claims the resulting apps are approximately 20 times smaller than Electron and 10 times faster. Electron bundles a full Chromium browser and Node.js runtime, which typically results in apps over 50 MB.

For desktop targets, PakePlus uses Rust-based Tauri 2 as the packaging layer. For Android and iOS, the README states it uses native OS frameworks rather than Tauri 2, which produces apps smaller and faster than a Tauri 2 mobile build. The README names these use cases: turning a website into a branded app, packaging a Vue or React project as a desktop app without buying a server, wrapping a Cocos game for cross-platform distribution, and creating a custom client for an internal company platform.

How the GitHub Actions Build Works

The build process requires no local development environment beyond the PakePlus app itself. The workflow is:

1. Download and install the PakePlus desktop app from the GitHub Releases page. 2. Configure a GitHub Token with the required permissions. 3. Create a new project in PakePlus, set the URL or HTML path, and configure options. 4. Click the publish button to trigger a GitHub Actions workflow. 5. Download the built app from the GitHub Releases page of the generated repository.

The README explains the token permission requirements. For the beta version, the token needs permissions for: all repositories (to fork the template), Actions, Administration, Contents, and Issues. For the classic token, `repo` and `workflow` scopes are required.

The GitHub Actions workflow compiles the app in the cloud. The build output is a release on a GitHub repository that PakePlus creates on the user's account. The user downloads the compiled binary from there. No local Rust, Android SDK, or Xcode installation is needed.

The repository structure reflects the split between the builder tool and the Android target. The app/ directory contains the Android application code. The packages/ directory holds the packaging scripts. The scripts/ppworker.cjs file is the main worker script invoked by the pnpm pp:worker command defined in package.json. The Gradle build files (build.gradle.kts, settings.gradle.kts) manage the Android build configuration. The pnpm-workspace.yaml ties the workspace together. This structure means the repository is both the PakePlus-Android app source and the template that GitHub Actions forks to build user projects.

Supported Targets and Project Types

PakePlus supports a range of source types: any publicly accessible URL, local HTML projects, Vue build output (dist folders), React build output, Cocos game exports, and Unity project exports. The README lists these as explicit use cases. Static file packaging accepts a compiled dist folder or a single index.html.

Output targets include macOS, Windows, Linux, Android, and iOS. Android and iOS use native frameworks, which the README distinguishes from Tauri 2 mobile targets. The builds are produced by GitHub Actions and are available as release assets in the generated repository.

Additional features documented in the README include: custom JavaScript injection into the loaded page, internationalization support that follows the system language automatically, support for Chinese names in packaging, a debug mode for development, and immersive window configuration for desktop targets. Data security is addressed: the GitHub Token is stored locally only and the project code stays in the user's own GitHub repository.

The repository root includes a CLAUDE.md file and a package.json with the project's scripts, confirming that the build tooling is managed with pnpm and Node.js alongside Gradle for the Android targets. The app-icon.png in the root is the default icon. Custom JavaScript injection is documented as a feature that lets users modify the behaviour of the loaded web page, for example by removing unwanted elements or automating interactions on the page.

Platform-Specific Installation Notes

On macOS, apps packaged by PakePlus may trigger a "damaged app" warning because they lack an Apple developer signature. The README documents the workaround:

sudo xattr -r -d com.apple.quarantine /Applications/PakePlus.app

For apps built with PakePlus, the same command applies with the generated app name:

sudo xattr -r -d com.apple.quarantine /Applications/YourAppName.app

The README notes that official Apple code signing costs $99 per year, which is why PakePlus does not sign its builds by default. This is a practical limitation for users distributing macOS apps to others who are unfamiliar with the workaround.

The README also notes that versions built before 2025 used Tauri 1.0. In 2025, the project upgraded to Tauri 2.0. Users encountering issues should download the latest version rather than troubleshoot older builds.

Limitations: Token Scope, App Signing, and Build Wait

PakePlus builds happen in GitHub Actions. Each build takes time. The README names a target of 9 minutes per build, but GitHub Actions queue times and runner availability are variable. Teams that need fast iteration loops during development should be aware that each change requires triggering a new CI run.

The GitHub Token must have broad repository permissions, including the ability to fork repositories and manage GitHub Actions workflows. For users in organisations with strict GitHub token policies, these requirements may conflict with existing security controls.

PakePlus wraps web content in a native shell. It does not transform a web app into a native UI. Users see the same web interface they would see in a browser. The advantage is app distribution and the ability to inject custom JavaScript; the limitation is that the user experience is browser-based, not a platform-native design. The README uses a web page approach as a feature for internal or developer tools, but it is not suitable for distributing consumer apps that users expect to feel native.

PakePlus vs Nativefier and Electron-Based Wrappers

Nativefier is the older well-known tool for turning websites into Electron apps. It runs entirely locally and produces a large app bundled with Chromium. PakePlus uses Tauri and native frameworks instead, targeting a much smaller output size. The trade-off is that Tauri requires a GitHub Actions environment to build rather than running natively on a developer machine without any setup.

Electron Forge and other Electron toolchains also produce browser-wrapped apps. All Electron apps bundle Chromium, which adds at minimum 50 to 100 MB to the binary. PakePlus's sub-5 MB target is achievable because Tauri uses the OS's built-in web view rather than bundling a browser.

The repository's last push was on 2026-09-16. The initial release of PakePlus v0.0.1 was published on 2026-05-07. The project is MIT licensed.

Editorial conclusion

PakePlus-Android is a good fit for developers who have a web app, static site, or local HTML/Vue/React project and want a native-feeling wrapper without setting up a local Tauri or Electron build environment. The cloud-build approach removes most of the environment setup burden, but it requires a GitHub account and a GitHub Token with repository and workflow permissions. The app size under 5 MB comes from using native OS frameworks for Android and iOS rather than a bundled browser engine. macOS users distributing the packaged app to others will need to handle the quarantine workaround manually, since PakePlus builds are unsigned and require running `sudo xattr -r -d com.apple.quarantine` to bypass the damaged-app warning.

Frequently asked questions

Official sources

1. License: MIT
2. Project website
3. README
4. Releases
5. Sjj1024/PakePlus-Android on GitHub