ShinyApps

English | 简体中文 | Wiki

ShinyApps is a desktop app store for R/Shiny apps. It ships one lightweight Electron shell, lets users install, run, update, and uninstall bundled Shiny apps on demand from an online catalog, and runs them one at a time inside a shared R runtime.

Instead of packaging every app into its own heavyweight desktop installer, ShinyApps separates a thin shell from installable app bundles: any Shiny app can be added later without rebuilding or redistributing the shell.

Browse the live app catalog for the current list of available apps.

The AI-based automated scouting and app-listing workflow has stopped. Developers can now submit their apps independently by following the developer documentation. Of course, you can also just shoot me an email, and I’ll be happy to help you set it up.

If you already have an app on the store and want it taken down, I will gladly do so upon request. That said, I really believe this project is a great way to promote your app and make it easy for users to run on their desktops.

---

✨ Features

• App-store model — a card launcher with Install → Run / Uninstall, plus per-app Update.
• Bring any Shiny app — bundle it as app/ + rlib/ + manifest.json, publish it as a GitHub Release asset, and register it in the catalog. No shell rebuild needed.
• Auto version check on every launch — at startup ShinyApps compares each app's catalog version with what is installed, so new app versions show a one-click Update.
• Shared R library with reference counting — packages used by ≥ 2 apps live once in a shared library; app-private/conflicting versions go to a private library. (In a real run, 133 of 160 packages were shared between two apps.)
• Reproducible bundles — apps ship prebuilt binary R packages pinned to R 4.6.1, each with a sha256. No compiler or R toolchain on the user's machine.
• Robust downloads — HTTP Range resume, retries, idle timeout, size + sha256 verification, real progress, zero-npm-dependency ZIP extractor.
• Two independent update channels — the shell updates via electron-updater; each app updates via the catalog.
• Clean process lifecycle — only one app runs at a time; returning to the launcher kills the whole R process tree (Windows taskkill /T /F).
• Cross-platform — Windows (win-x64) and macOS (mac-arm64).
• Card links to each app's homepage — hover an app name for “click to learn more”; click it to open the app's homepage in your browser.
• Visible install pipeline — the card shows the current step (download % → verify → install) and, on failure, exactly which step failed and why (e.g. “size mismatch: catalog 12934112 bytes, downloaded 0 bytes”).
• Per-app Help / About — the App menu label, Help > Documentation, and the About dialog (including Visit Website / Email / Check for Updates) follow the running app, using its catalog docs / homepage / email / author / copyright.

🚀 Quick start (users)

1. Download shinyapps-Setup-<version>-x64.exe (Windows) or .dmg (macOS) from Releases.
2. Launch ShinyApps — the launcher shows a card per available app.
3. Click Install, then Run. Use Apps → Back to Launcher (or Ctrl/Cmd+L) to return; unsaved work is confirmed first.
4. Every time ShinyApps starts, it automatically checks each app's latest version against the online catalog. If a newer version is available, the card shows Update — click it for a one-click upgrade (the app is stopped, fetched, verified, and swapped in place).

Shell auto-update only installs on signed builds; unsigned builds can download but Windows/macOS will refuse to apply the update.

🧩 For app developers: add your Shiny app

Two ways to integrate:

A. Store / on-demand (recommended). In your own repo, add a bundle workflow that produces <id>-<version>-<platform>.zip (per platform) and publishes it to a Release, then register the app in this repo's catalog/apps.yml. Users install it on demand. No change to the shell.

<id>-<version>-<platform>.zip
└─ app/         # your Shiny entry (app.R)
└─ rlib/        # prebuilt dependency closure (binary R packages)
└─ manifest.json

B. Bake-in. Put your app.R and dependency tarballs under apps/ and dependency/ in this repo and rebuild the shell. The app ships inside the installer (offline, no download) but a larger installer and a shell re-release per change.

The app must satisfy a small contract: its entry returns a shinyApp object (it must not call runApp() itself), build as a standard R source package, and target R 4.6.1.

👉 Full guide: User Manual (EN) · 使用手册（中文）. 🛠️ Automation: use the reusable onboarding toolkit — fentouxungui/shinyapps-onboarding — to go from any Shiny-app repo to a published store entry (fork → bundle workflow → release → catalog entry → PR).

🏗️ How it works

Three layers

Tier 0  Shell + portable R 4.6.1 + minimal deps      shipped once, never uninstalled
Tier 1  Shared R library   <userData>/lib             packages needed by >= 2 apps (ref-counted)
Tier 2  Private R library  <userData>/private/<id>    single-app or version-conflicting packages

At runtime: R_LIBS = private lib : shared lib.

Data flow

App repo CI ──publishes──▶ GitHub Release  (bundle zips + sha256)
                                │
ShinyApps catalog/apps.yml ─▶ publish-catalog.yml ─▶ gh-pages/catalog.json
                                │
Client shell ──fetch catalog──▶ install bundle ─▶ run with R_LIBS(private:shared)

Repositories

Repo	Role
ShinyApps (this repo)	Shell config, catalog, schemas, icons, build script, workflows
shinyelectron@multi-app-store	Electron main process, launcher, store engine, R backend
SeuratExplorer, scConvertShiny	Apps + their bundle CI

Key files

_shinyelectron.yml          # shell config (runtime strategy, deps, apps[], updates)
build-suite.R               # build the shell; version derived from the release tag
catalog/apps.yml            # the single hand-maintained app registry
schemas/*.json              # catalog / manifest / state contracts
.github/workflows/
  build-desktop.yml         # build shell installers + release
  publish-catalog.yml       # generate catalog.json + publish icons to gh-pages

Workflows

Workflow	Trigger	Output
Build ShinyApps desktop	tag v* / manual	Shell installers + latest*.yml → Release
Publish catalog	every 10 min / manual / bundle-updated dispatch / edits to apps.yml or icons/	catalog.json + icons/ on gh-pages
Build app bundle (each app repo)	Release published / manual	<id>-<version>-<platform>.zip → that app's Release

⚖️ Pros and cons

✅ Pros

• Extensible without redeploying the shell — new apps are just new catalog entries + Release bundles.
• Small first download — users only fetch the apps they choose; the shell is shared.
• Real disk savings through sharing — one shared library, reference-counted (two apps shared 133/160 packages in testing).
• No compiler on the user machine — prebuilt binaries + pinned R runtime; installs are fast and offline-capable after download.
• Reproducible & verifiable — every artifact carries a sha256; the catalog is the single source of truth.
• Clean isolation — per-app private libraries resolve version conflicts without forcing upgrades.

⚠️ Cons and trade-offs

• One app at a time — returning to the launcher stops the current app; unsaved analysis is lost (a confirmation dialog guards this). It is not a multi-window hub.
• Install-time downloads can be large — each app bundle is tens to hundreds of MB (it contains compiled dependencies). Shared packages reduce the incremental cost for later apps, but the first install of a heavy app is still large.
• Per-platform builds required — Windows binaries must be built on Windows; each platform needs its own bundle. Only win-x64 and mac-arm64 are produced today.
• Tight version coupling — every bundle must be built against the same R version as the shell (currently 4.6.1).
• Native dependencies are the hard part — e.g. on Windows, scConvert conversion is limited by the CRAN hdf5r/HDF5 1.12 stack.
• Infrastructure-bound — relies on GitHub Actions, Releases, and Pages, and requires code signing for shell auto-update.
• License obligations — the shell builds on AGPL-3.0 shinyelectron; bundled apps bring their own licenses (e.g. GPL-3.0, MIT).

📦 Apps

All available apps — with description, version, supported platforms, license, availability, and download links — are listed in the live app catalog, which is regenerated automatically on every publish:

👉 https://fentouxungui.github.io/ShinyApps/

• Machine-readable manifest: catalog.json
• Register a new app in catalog/apps.yml; it appears in the catalog after the next publish.

🗺️ Roadmap

• Code signing for shell auto-update (Windows / macOS)
• Trim disk duplication (remove bundle rlib/ after linking; prune download cache)
• Auto-refresh the catalog on app release (repository_dispatch)
• Resolve the Windows scConvert HDF5 limitation
• Additional platforms and apps

📚 Documentation

Full manual on the Wiki — available in English and 中文:

• 👉 User Manual (EN) · 使用手册（中文）
• User Guide — install, launcher, run/update/uninstall, data locations
• Developer Guide — bundling contract, catalog registration, icons
• Maintainer Guide — repository layout and each workflow
• Release process — ship a shell, ship an app, update icons
• FAQ / Troubleshooting — known issues and fixes
• Known limits / roadmap — open issues and planned work

🙏 Credits & license

Built on shinyelectron (AGPL-3.0). The ShinyApps repository also bundles/calls third-party components — see shared-library-policy.md and each app repository for details. Add a top-level LICENSE and third-party notices before distributing.

---

Maintained by Zhang Yongchao. Contributions and new app bundles are welcome.