[opensourcedex]

Capgo is a free, open source build & deployment project written in TypeScript and released under AGPL-3.0. It has 206 GitHub stars, 135 forks and 41 open issues, and was last pushed 5 hours ago. On this registry it ranks #59 of 59 tracked projects in Build & Deployment, with 5 head-to-head comparisons available.

What is Capgo?

Capgo is an open-source console and updater for shipping over-the-air bundle updates to Capacitor apps on Android and iOS, built for mobile teams that need to release fixes without waiting on app store review.

What it is

Capgo is a TypeScript project in the Capacitor ecosystem, published under the AGPL-3.0 licence and tagged for android, capacitor, cordova, and ios. It provides a console to manage and distribute live updates, an updater plugin that the app consumes, and an open-source backend that can be installed in your own infrastructure. The console covers bundle management — download, assign to channel, rollback — together with channel support for different environments, automatic updates, delta updates, and update encryption and signing. It supports Capacitor 8, 7, 6, and 5, on both Android and iOS.

The concrete problem is release latency: a fix that is ready today still waits for app store review before users receive it. Capgo replaces Ionic Appflow for this job — the README describes the Capacitor updater plugin as "the official alternative to Ionic Appflow." Teams that adopt it can run the hosted service at capgo.app or self-host the backend, rather than routing every live update through a commercial vendor.

Key capabilities

  • Bundle management: download bundles, assign them to a channel, and roll back.
  • Channel support for managing different environments, including setting a channel on a specific device to QA or debug one user.
  • Auto update, which automatically downloads and sets the latest bundle for the app.
  • Rollback that resets the app to the last working bundle when an incompatible bundle has been set.
  • Delta updates that download only the changed files to make updates instant.
  • Security through encryption and signing of each update.
  • Deployment statistics for viewing how a release is rolling out.

Who uses it and how

  • The README reports use in more than 3000 projects, with the production Capgo deployment operating at a scale of roughly 50M devices.
  • Teams running staging, QA, and production builds use channels to keep environments separate.
  • QA and support workflows set a channel on one specific device to debug a single user without touching the wider rollout.
  • Projects shipping frequent small changes rely on delta updates so only changed files are transferred.
  • Release engineering uses rollback as the safety net when a bundle turns out to be incompatible.

Getting started

Use the hosted Cloud service at capgo.app, or self-host the backend from the Cap-go/capgo repository, where installing only Supabase is sufficient.

How it compares

The named competitor is Ionic Appflow, which the README positions the Capacitor updater plugin against. Capgo is AGPL-3.0 open source, and its backend can be installed in your own infrastructure, whereas Appflow is a commercial hosted service. Self-hosting means the bundles and update traffic stay on your own Supabase instance, and the cloud option is offered directly rather than being the only path.

When to use it — and when not to

Self-hosting requires operating Supabase as the required backend piece; the production deployment also runs Cloudflare Workers, which carry 99% of traffic, through the Hono adapter. Teams not building on Capacitor should look elsewhere, since the updater is Capacitor-specific. Note that the AGPL-3.0 licence carries copyleft obligations worth reviewing, and the repository currently holds 41 open issues.

project readme (upstream, from github) — read inline

Console to manage and distribute your live update

Capgo - Instant updates for capacitor

Bugs Security Rating Maintainability Rating Code Smells Lines of Code Technical Debt Reliability Rating Duplicated Lines (%) Vulnerabilities CodSpeed Known Vulnerabilities GitHub license Bump version Build source code and send to Capgo semantic-release Commitizen friendly


➡️ Get Instant updates for your App with Capgo

Missing a feature? We’ll build the plugin for you 💪


Features

  • ☁️ Cloud / Self hosted Support: Use our Cloud to manage your app updates or yours.
  • 📦 Bundle Management: Download, assign to channel, rollback.
  • 📺 Channel Support: Use channels to manage different environments.
  • 🎯 Set Channel to specific device to do QA or debug one user.
  • 🔄 Auto Update: Automatically download and set the latest bundle for the app.
  • ✅ Official Appflow alternative: our Capacitor updater plugin is the official alternative to Ionic Appflow.
  • 🛟 Rollback: Reset the app to last working bundle if an incompatible bundle has been set.
  • 🔁 Delta Updates: Make instant updates by only downloading changed files.
  • 🔒 Security: Encrypt and sign each updates with best in class security standards.
  • ⚔️ Battle-Tested: Used in more than 3000 projects.
  • 📊 View your deployment statistics
  • 🔋 Supports Android and iOS
  • ⚡️ Capacitor 8/7/6/5 support
  • 🌐 Open Source: Licensed under GNU AFFERO GENERAL PUBLIC LICENSE
  • 🌐 Open Source Backend: Self install our backend in your infra

Usage

Capgo is deployed to production on Cloudflare workers and Supabase.

Cloudflare workers take 99% of the traffic. Supabase is used for internal calls, for internal tasks such as CRON jobs that call functions.

When self-hosted, installing only Supabase is sufficient.

Why Cloudflare Workers + Supabase

We support both deployments for practical reasons:

  • Supabase is the legacy backend and the only required piece for self-hosting.
  • Cloudflare Workers runs the same backend code (via the Hono adapter) but is much cheaper at Capgo scale. With ~50M devices, Supabase Edge Functions are cost-prohibitive because they follow AWS pricing. Cloudflare is ~10x cheaper for our traffic profile.

In production, we route most traffic through Cloudflare Workers for cost and scale, while Supabase remains the reference backend and the default for self-hosted deployments. Capgo cloud console and current CLI calls go to the Cloudflare API hosts (VITE_API_HOST / hostApi). Capgo cloud still publishes a small Supabase function allowlist for Postgres pg_net (triggers) and for legacy CLI compatibility via /functions/v1 through 2026-10-28. Self-hosted deployments keep using /functions/v1. Plugin hot paths and other unused Capgo cloud endpoints are not published on Supabase.

Project structure (self-hosting map)

If you're self-hosting, the key pieces live in a few top-level directories:

  • supabase/ - Primary backend for self-hosting
    • supabase/functions/ - Edge functions (Deno) that power the API
      • _backend/ - Core implementation used by both Supabase and Cloudflare
      • public/ - Public API routes used by customers and apps
      • private/ - Internal API routes for the console and ops tooling
      • plugins/ - Plugin endpoints (updates, stats, channel_self, etc.)
      • triggers/ - Database triggers and CRON functions
    • supabase/migrations/ - Database schema and RLS policies
    • supabase/seed.sql - Local seed data for tests/dev
  • supabase/schemas/prod.sql - Production schema dump (reference only)
  • cloudflare_workers/ - Optional Cloudflare Workers deployment (prod traffic)
    • cloudflare_workers/snippet/ - Geo routing for replicas
    • Worker entry points and deploy config live here
  • src/ - Frontend Vue 3 web console (Vite + Tailwind + DaisyUI)
    • src/pages/ - File-based routes
    • src/components/ - Reusable UI components
    • src/services/ - API clients and integrations
    • src/stores/ - Pinia stores
  • sql/ - Raw SQL helpers and maintenance scripts
  • scripts/ - Dev/build scripts used by CI and local tooling
  • tests/ - Backend Vitest tests (run in parallel)
  • playwright/ - Frontend E2E tests
  • docs/ - Extra documentation and guides
  • android/, ios/ - Capacitor native projects (mobile builds)

Quick self-hosting path:

  1. supabase/ is enough to run the backend locally.
  2. src/ is the web console you point to your own backend.
  3. cloudflare_workers/ is only needed if you want to run the Workers layer instead of (or in front of) Supabase.

Backend endpoints (what lives where)

The backend is split by responsibility to keep routes clear and access scoped:

  • supabase/functions/_backend/public/ - Public API exposed to customers. This is the documented API on the website for customers that want to interact with Capgo programmatically (apps, channels, bundles, devices, etc.).
  • supabase/functions/_backend/private/ - Private API used internally. The console (web UI) uses this heavily for admin/ops workflows. It is not publicly accessible. Some UI flows still use the public API where appropriate.
  • supabase/functions/_backend/plugin_runtime/ - Plugin API used by the @capgo/capacitor-updater plugin running inside apps:
    • plugins/updates - device update checks and bundle download flow
    • plugins/stats - upload usage stats from devices
    • plugins/channel_self - allow a device to opt into a channel (QA/debug)
  • supabase/functions/_backend/triggers/ - Triggers & CRON for automated backend jobs (queue consumers, scheduled tasks, DB-triggered flows).

When self-hosting, you generally expose public + plugin_runtime (via the plugin worker / Deno updates · stats · channel_self entries). private should stay internal and locked down. triggers runs automatically.

Production schema (prod.sql)

supabase/schemas/prod.sql is a schema dump of the production database. It is generated via bun run schemas (or bun run schemas:local) and is meant for reference/diffing, not as a source of truth. All actual schema changes live in supabase/migrations/.

Documentation

https://github.com/Cap-go/capacitor-updater/wiki/Capgo-Sandbox-App

Plugins

All the following official plugins are already installed and pre-configured:

readme truncated — read the full docs on github

Frequently asked questions

Is Capgo free to use?

Capgo is open source under the AGPL-3.0 licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does Capgo do?

OTA updates for Capacitor apps without app store delays

What is Capgo written in?

Capgo is primarily written in TypeScript. Its source is publicly available at https://github.com/cap-go/capgo, and it has 206 GitHub stars.