Pear Runtime & CLI
Add Pear Runtime to any app and it becomes updatable and distributable peer-to-peer. Use the Pear CLI to build releases and deploy straight to users.
You don't have to use app stores or servers, just stage, release, and let the network do the distribution.
Download
Get Pear CLI
macOS / Linux
curl https://install.com/pear.sh | sh
Windows
irm https://install.com/pear.ps1 | iex
npm
npx pear
In practice
Ship an app in a handful of commands
Clone our boilerplate, then using the CLI touch, stage, and provision your app, then anyone with the Pear runtime can install your app from a single link. The Pear config in package.json describes how it runs.
bash
# Install the Pear CLI (macOS / Linux)
curl https://install.pears.com/pear.sh | sh
# Start from the official desktop template
git clone …/hello-pear-electron my-app
cd my-app && npm install
# Create the app's permanent pear:// link
pear touch
# Build a deployment folder
pear build --target my-app-1.0.0
# Stage it into the app's versioned drive
pear stage <link> ./my-app-1.0.0
# Compact onto the production line
pear provision <source> <target> <production>
# Anyone can now install it from the network
pear install pear://<your-app-key>package.json
{
"name": "my-app",
"main": "electron/main.js",
"upgrade": "pear://<your-app-key>",
"pear": {
"stage": {
"ignore": ["/node_modules", "/out"]
}
},
"dependencies": {
"pear-runtime": "latest"
}
}Over-the-air updates without app stores
With peer-to-peer Pear apps you can send app updates directly to users. In desktop apps you can bypass app stores entirely.
Instant rollout
When you release an update just the changes, not the whole app, go to users.
No gatekeepers
Skip app-store review entirely on desktop apps.
Resilient delivery
Updates replicate peer-to-peer, so popular apps get faster to distribute, not slower.
Trust
Multisig & release security
Releases are cryptographically signed then verified before they run. You control who can ship, and users always know exactly what they're running.
Releases
Keep independent staging and production releases, each are addressable and versioned.
Multisig releases
Require multiple maintainer keys to co-sign a release, so no single compromised key can push code to your users.
Security by design
Every release is signed by the app's key and verified on users' machines before it runs. No unsigned code ships.
Addressing
pear:// links
Every Pear app has a stable, cryptographic address. Share it as a pear:// link and anyone with the CLI can install it instantly.
bash
# Inspect what a link points to before installing
pear info pear://<app-key>
# Install the app straight from its link
pear install pear://<app-key>Frequently asked questions
- How do updates reach users without an app store?
- A Pear app is itself a versioned peer-to-peer drive. pear provision prepares a staged version for production, the multisig quorum signs it, and connected peers replicate only the changed blocks. There is no upload step and no store review.
- What does pear stage actually do?
- It synchronizes your project into an append-only drive behind the app’s pear:// link. Re-staging writes only what changed, so builds stay fast and every version remains addressable.
- Are pear:// links permanent?
- Yes. A link is derived from the app’s public key, so it never changes. Every version of the app lives behind the same address.
- How does multisig work?
- You can require several maintainer keys to co-sign a release. A release is only valid once enough trusted keys have signed it, so a single leaked key cannot ship code to your users.
- Can I ship to desktop, mobile, and terminal from one project?
- Yes. The same Pear project targets all three: pair it with Electron for desktop UIs (start from the hello-pear-electron template), a native shell for mobile, or run it directly in the terminal.
- Is Pear free and open source?
- Yes. The runtime and CLI are open source and free to use. Apps you publish are yours, distributed peer-to-peer with no hosting bill.
Continue through the stack
Pear ships what the layers below it create. Drop down to the data suite or the runtime that powers it all.
Ship your first Pear app
Install the CLI, start from a template, and have a peer-to-peer app live behind a pear:// link in minutes.