Pake: Web App Packaging Without Electron
Pake turns any webpage into a lightweight desktop app with one CLI command, using Rust's Tauri to wrap the page instead of bundling a full Chromium runtime the way Electron does. Reach for it when you want a small, fast wrapper around a web app you already use — a chat page, a music player, a note-taking tool. Skip it if you need deep native integrations or the plugin ecosystem that Electron's maturity still covers better.
Converting Webpages to Desktop Apps
Pake is a Rust command-line tool that packages any URL into a standalone desktop app for macOS, Windows, and Linux. It runs on Tauri instead of Electron, rendering the page in the operating system's own webview rather than shipping a private copy of Chromium, which is why the README puts finished installers under 10M on disk. Point the CLI at a website, give it a name, and you get an installable app with its own icon and window controls — no Electron project required.
Core Features for Desktop Apps
- ✓Small installers: the README says Pake's output runs nearly 20 times smaller than a comparable Electron package, typically staying under 10M on disk
- ✓Rust-based Tauri runtime instead of a bundled Chromium engine, which the README credits with faster startup and lower memory use than JS-framework wrappers
- ✓One-command CLI packaging (`pake <url> --name <name>`), plus a no-setup GitHub Actions online-building path for people who don't want a local toolchain
- ✓Window and interaction extras baked in: shortcuts, immersive/frameless windows, drag & drop, style customization, and ad removal
- ✓Agent- and script-friendly interface: `--json` for machine-readable output and `--config app.json` for declaring an app instead of typing flags
- ✓Can package a local build folder directly with `pake ./dist --name MyTool`, not just a live URL
- ✓An official Claude Code plugin (`/plugin marketplace add tw93/Pake`, `/plugin install pake@pake`) for packaging from inside an AI coding agent
Examples of Packaged Web Apps
- •Put a web-based AI chat tool — ChatGPT, Gemini, DeepSeek, or Grok are all listed as ready-made Popular Packages in the README — into its own window instead of a browser tab
- •Wrap a site you already use daily, like WeRead, Notion, Flomo, or Excalidraw, so it gets a dock/taskbar icon and its own keyboard shortcuts
- •Package a personal or internal site that has no native client of its own, with a single `pake <url> --name <AppName>` command
- •Ship a local web build as a distributable desktop app via `pake ./dist --name MyTool`, without touching a URL at all
- •Let a script or an AI agent package a site automatically, using the `--json` output and `--config app.json` file instead of interactive flags
Installing Pake for Packaging
Install the CLI globally with `pnpm install -g pake-cli`, which assumes you already have a Node.js/pnpm environment set up. The first time you run `pake` to package a site, it sets up extra build tooling before it can compile, so that first run is slower — every build after it is fast, per the README. If you'd rather skip a local toolchain entirely, grab one of the ready-made Popular Packages from the README or use GitHub Actions online building, both of which need no environment setup. Cloning the repo for custom development is a separate, heavier path: it needs Rust >=1.85 and Node >=22 (the README notes >=18 also works).
Packaging Web Apps with Pake
The basic case is one line: `pake https://github.com --name GitHub`, which fetches the site's icon automatically and produces an installer. Add flags for more control — the README's own example is `pake https://weekly.tw93.fun --name Weekly --icon https://cdn.tw93.fun/pake/weekly.icns --width 1200 --height 800 --hide-title-bar`. You can point Pake at a local build folder instead of a URL with `pake ./dist --name MyTool`, and scripts or agents can drive it non-interactively with `--json` for output and `--config app.json` for a declarative app definition. Claude Code users get a dedicated path too: `/plugin marketplace add tw93/Pake` then `/plugin install pake@pake`.
Strengths
- ✓Small, fast output by construction — no bundled Chromium, so installers land under 10M on disk and use less memory, per the README
- ✓The basic workflow really is one command (`pake <url> --name <name>`), no Electron project scaffold or JS build pipeline to set up first
- ✓Covers both ends of the user spectrum: a zero-setup path (ready-made packages, GitHub Actions online building) and a scriptable one (`--json`, `--config app.json`) for automation
- ✓Feature set goes past a bare browser wrapper — shortcuts, drag & drop, immersive/frameless windows, and ad removal are built in per the README
- ✓Actively used: 60,471 stars and 12,320 forks on GitHub
Considerations for Pake Users
- △First-time packaging is slower than downloading a ready-made package — the README says it sets up build tooling behind the scenes before it can compile your first app
- △Touching Pake's internals instead of just wrapping a URL means cloning the repo and installing Rust >=1.85 and Node >=22, a heavier bar than the plain CLI install
- △GPL-3.0 comes with real terms: if you fork Pake into your own product, the README requires you to assign it an alternative name and attribute Pake as the source. Consequently, quiet white-labeling isn't really an option.
- △Pake packages an existing webpage as-is — it doesn't rewrite the site's UI or add offline behavior the source page doesn't already have, so the wrapped app is only as good as the website behind it
Pake vs. Electron and Alternatives
Common Questions About Pake
Pake is released under the GPL-3.0 license, plus an added 'Pake Output Exception' — the README is explicit that apps you build and distribute with Pake stay entirely yours to use and distribute.
Pake's README claims its installers run nearly 20 times smaller than a comparable Electron package — typically under 10M on disk — because it's built on Rust's Tauri and the system's own webview instead of bundling Chromium, with lower memory use as a result.
Pake supports macOS, Windows, and Linux, and its README lists ready-made Popular Packages — ChatGPT, YouTube, Notion, and others — built for all three.
Pake supports style customization, custom icons, and window settings like width, height, and title bar right from CLI flags, and its Advanced Usage docs cover deeper style and feature changes.
The README states that apps built with Pake are entirely yours to use and distribute; it only asks that if you fork Pake itself into your own product, you give that fork a different name and credit Pake as the source.
Not for the easy path — a ready-made Popular Package or GitHub Actions online building needs no environment setup. Installing the CLI needs Node.js/pnpm, and cloning the repo for custom development needs Rust >=1.85 and Node >=22, per the README.
The problem it solves
Wrapping a website as a desktop app usually means reaching for Electron, which bundles an entire Chromium browser and Node runtime into every single build — package ten sites that way and you're carrying ten duplicated browser engines, each one heavier on memory than the tab it replaced. Pake exists because its author, tw93, wanted the same 'webpage in its own window' result without that Chromium tax on every build, packaging through Tauri's Rust shell and the operating system's own webview instead.
Who should try it — and who should skip
Reach for Pake if you already have a website or web app you like and just want it to feel like a native window — a chat tool, a music player, an internal dashboard — without shipping a full Electron bundle to get there. Skip it if you're building an app from scratch with deep OS integration, background services, or a plugin architecture; that's a job for Tauri or Electron directly, not a one-command wrapper. It's also a good fit for AI agents and scripts, given the `--json` output and the Claude Code plugin, when you want packaging to be an automatable step rather than a manual click-through.