We've all been there. You build a slick web dashboard for a client — maybe an AI chat interface, a document analyzer, or a project management tool. Then they ask: "Can I just double-click an icon to open it?"
Your options in 2026 are… not great. You could wrap it in Electron and ship a 200MB behemoth that eats RAM like it's an all-you-can-eat buffet. You could teach your client to use Chrome's "Add to Desktop" feature. Or you could spin up a whole Tauri project, learn Rust, configure GitHub Actions, and spend a weekend on toolchain hell.
None of these feel right. Especially when you're distributing customized apps to SMB clients who just want something that works.
That's where PakePlus (recently rebranded as PacBao) enters the chat — and it might be exactly what you've been looking for.
PakePlus is an MIT-licensed, open-source tool built by Chinese developer Sjj1024 that packages literally any webpage — or any compiled Vue/React frontend, or even Cocos/Unity games — into a native desktop and mobile application.
The numbers are what grab your attention first:
| Metric | PakePlus | Electron |
|---|---|---|
| Output Size | < 5 MB | 100–300 MB |
| Startup Time | Milliseconds (Rust) | Seconds (Chromium) |
| Memory (idle) | ~30–50 MB | ~150–300 MB |
| Local Dependencies | Zero (or 1 GitHub Token) | Node.js, Chromium, native modules |
| Mobile Support | Android + iOS | Desktop only |
That's not "slightly better." That's a 20x–60x reduction in binary size and a 5x–10x reduction in memory footprint. For SMB clients running on whatever hardware they have lying around, this isn't a nice-to-have — it's the difference between "this feels snappy" and "why is my computer so slow?"
The tool itself is about 10 MB, and you can use it two ways: download the desktop client from the GitHub releases page, or use the web version directly in your browser. Both produce the same <5 MB output.
If you've been following the desktop app space, you know that Tauri has been eating Electron's lunch for a couple of years now. Tauri swaps Chromium for the operating system's native WebView (Edge WebView2 on Windows, WebKit on macOS, WebKitGTK on Linux) and replaces Node.js with a Rust backend. The result: apps that are 600x smaller and use 50% less RAM.
The catch? You need Rust installed. You need Node.js. You need to understand Tauri's configuration system. You need to set up GitHub Actions for cross-platform builds. It's a real development environment, and for many web developers, it's a barrier.
PakePlus eliminates all of that.
Behind its clean GUI, PakePlus is orchestrating Tauri 2 under the hood. When you click "Publish," it forks a template repository to your GitHub account, triggers GitHub Actions for cloud compilation across all platforms, and delivers signed, installable packages. You don't write a single line of Rust. You don't configure a Tauri.toml. You don't even need Node.js.
And if you don't want to use GitHub at all? Local packaging takes about 30 seconds with zero dependencies — no token required. PakePlus handles the entire Tauri toolchain transparently.
This is what makes it fundamentally different from the original Pake CLI (by tw93), which requires a full Rust + Node environment. PakePlus is Pake with a GUI, cloud builds, mobile support, and a dramatically lower barrier to entry.
This is where things get interesting — and it's exactly what Steve flagged in his email. Let's talk about distributing customized AI applications to SMB clients.
Here's a scenario: you've built a custom AI assistant for a chain of dental clinics. It's a web app — React frontend, talks to an LLM API, handles appointment scheduling, patient FAQs, and insurance lookups. The clinic owners aren't tech-savvy. They want:
With PakePlus, here's the workflow:
Step 1: Build your AI web app as you normally would — React, Vue, Svelte, whatever. Compile to a dist folder.
Step 2: Drop it into PakePlus. Either point to the URL where it's hosted, or drag in the dist folder for local packaging.
Step 3: Inject custom JS. This is the secret sauce. Write a small JavaScript file that:
Step 4: Configure the icon, app name, and window settings. Give it the dental clinic's branding. Set the window size to something appropriate for a reception desk monitor.
Step 5: Click publish. PakePlus builds for Mac, Windows, Linux, Android, and iOS from that single configuration. In a few minutes, you have five platform-specific installers — all under 5 MB each.
Step 6: Distribute. Email the installer, host it on a download page, or put it on a USB stick. No app store approval needed for desktop. The clinic staff double-clicks and they're in.
This pattern works for any vertical AI application:
The key insight is that PakePlus turns your web-based AI tool into something that feels like a professional software product — without the overhead of Electron, without forcing clients to use a browser, and without requiring you to become a Rust developer.
Let's put PakePlus in context with what else is available:
| PakePlus | Electron | Native Tauri | Pake CLI | Neutralinojs | |
|---|---|---|---|---|---|
| Output Size | < 5 MB | 100–300 MB | 2–10 MB | ~5 MB | 2–5 MB |
| Dev Setup | Zero (GUI) | Node.js + npm | Rust + Node | Rust + Node | Node.js |
| Mobile Support | ✅ Android + iOS | ❌ | ✅ (v2) | ❌ | ❌ |
| Cloud Build | ✅ GitHub Actions | ❌ (DIY) | ❌ (DIY) | ❌ (DIY) | ❌ |
| JS Injection | ✅ Built-in | ❌ (manual) | ❌ (manual) | ✅ Limited | ❌ |
| System APIs | ✅ (download, exec, window) | ✅ Full Node.js | ✅ Rust commands | ⚠️ Limited | ✅ Limited |
| Learning Curve | Near zero | Medium | High | Medium-High | Low |
| License | MIT | MIT | MIT/Apache 2.0 | MIT | MIT |
When to use PakePlus:
When to use Native Tauri instead:
When Electron still makes sense:
No tool is perfect, and PakePlus has its share of rough edges worth knowing about:
The front-end is no longer open-source. Due to individuals using PakePlus to package illegal software, the author closed the GUI source code. The packaging engine (the Tauri template that does the actual compilation) remains open-source, but the UI you interact with is now closed. This is understandable but worth noting if you care about full-source transparency.
Mac signing headaches. Like any unsigned app, PakePlus-packaged apps trigger macOS Gatekeeper warnings. The fix is the familiar sudo xattr -r -d com.apple.quarantine dance. For client distribution, you'll want to either sign with an Apple Developer account ($99/year) or provide clear installation instructions.
Your packaged code lives in a public GitHub repo. When using the GitHub Token method, PakePlus forks a template to your account and stores your project configuration there. If the repo is public (the default for free GitHub accounts), anyone can see your app's configuration. For sensitive projects, use a private repo or local packaging.
It auto-stars the project. Using a GitHub Token triggers an automatic star on the PakePlus repository and sends anonymous compilation statistics. This is disclosed in the README, but it's the kind of thing worth knowing upfront.
Security considerations for AI apps. If you're injecting API keys via JS, remember they'll be embedded in the app bundle. While this is more secure than exposing them in browser JS (no DevTools access), a determined user could still extract them from the binary. For production SMB deployments, consider a backend proxy that handles API key management server-side.
The fastest path:
dist folderIf you prefer the desktop client, grab it from GitHub Releases. The client offers more features (preview mode, better debug support) and is the recommended experience.
For the official guide with screenshots and detailed configuration options: pacbao.com/guide.
PakePlus occupies a narrow but incredibly useful niche: it lets web developers ship native-feeling desktop and mobile apps without becoming Rust developers, without bloated Electron bundles, and without convincing SMB clients to "just use Chrome."
For the specific use case of distributing customized AI applications to SMB clients, it's hard to beat. The combination of <5 MB binaries, cross-platform support, custom JS injection for AI integration, and near-zero learning curve makes it a pragmatic choice for indie developers and small consultancies.
Yes, there are rough edges. Yes, you give up some control compared to native Tauri. But in exchange, you go from idea to installable app in minutes instead of days.
In a world where every megabyte of download size and every second of startup time erodes your client's trust, PakePlus makes a compelling argument: your AI app doesn't need to carry a browser to feel like a real application.
Now the question is: what will you package first?