Compare

Six solutions for WordPress plugin distribution, each with a different philosophy. See how Troy compares.

Six Tools, One Goal

There are several ways to distribute WordPress plugins outside WordPress.org. Each tool takes a different approach β€” some embed a library into every plugin, others replace the entire ecosystem.

Troy takes a middle path: one client plugin, one server plugin, full control. Your plugins update from your infrastructure, with WordPress.org coexistence built in from day one.

Use the comparison table below to see exactly where each solution stands.

Troy

Private distribution

Low complexityv1.7.1184

Freemius

SaaS monetization platform

Medium complexity~11 years

EDD + SL

Easy Digital Downloads + Software Licensing

eCommerce + licensing + updates

Medium complexityv3.3+ (~12 years)

PUC

Plugin Update Checker

Per-plugin update library

Medium complexityv5.6 (~15 years)

FAIR

Federated and Independent Repositories

WP.org replacement

High complexityPre-release (also targeting TYPO3)

Git Updater

Git-hosted updates

Low complexityv12.22.0
Rotate your phone for easier comparison reading.
Feature
Plugin distribution
Theme distribution
Private plugins
Cost model
Per-plugin integration effort
WordPress.org coexistence
Free→Pro funnel via WP.org
Secure from WP.org
Data privacy from 3rd parties
Security patch propagation
Dependency management
Server-side PHP/WP checks
Multiple plugin versions
Server capacity
Update check batching
Server required
Self-hosting complexity
Multi-server/failover
Client-side install
Scales with more plugins
GitHub/WP.org import
Readme parsing
Changelog display
Banner/icon support
Composer repository support
Admin UI
Logging UI
Analytics dashboard
Per-plugin statistics
Global statistics
Rate limiting concern
Client-side auth
WP-CLI support
Translation updates
License
Troy
⚠ Planned
Free (MIT, self-hosted)
2 headers
Complete
Own servers
One update covers all sites
Automatic (server-resolved)
50k–500k clients
Single batched request
WordPress
Low
⚠ Planned
One shared plugin (Troy Client)
Same single client, any number of servers
~30 seconds
Native Composer 2 repository (Bedrock-ready)
Full UI with auto-refresh
PHP/WP/locale breakdown
Your server, no limits
Public API (by design)
⚠ Planned
⚠ Planned
MIT
Freemius
⚠ ~7% of sale revenue
⚠ SDK (~147 files)
⚠ Free/premium split required
⚠ Plugin data leaks to WP.org
⚠ Freemius SaaS (collects site + user data)
⚠ Each developer must update SDK (~147 files)
⚠ Checks, but won't serve older compatible version
Unlimited (SaaS)
Per-plugin
SaaS
None (SaaS)
Built-in (SaaS)
~147-file SDK embedded in each plugin
⚠ Extra SDK copy per plugin added
Manual SDK integration
⚠ Via WP.org (free version)
⚠ Via WP.org (free version)
⚠ Via WP.org (free version)
SaaS dashboard (full)
SaaS dashboard
Detailed (opt-in, individual-level)
No limits (SaaS)
License key per plugin
Proprietary (SaaS, ~7% rev share)
EDD + SLEasy Digital Downloads + Software Licensing
⚠ $199–999/yr (addon)
Updater class (~620 lines)
⚠ Exposes your plugin to WP.org
⚠ Developer must build upgrade flow
⚠ Exposes your plugin to WP.org
⚠ Sends site URL to store on every update check
⚠ Each developer must update updater class
⚠ Checks on site only, no compatible version fallback
Your server dependent
Per-plugin
WordPress + EDD + SL
Medium (WP + EDD + SL)
~620-line class embedded in each plugin
⚠ Extra updater per plugin added
Manual upload + product config
Full eCommerce UI
Sales data only (no site-level insight)
⚠ Sales only
⚠ Sales only
Your server, no limits
License key required (no key = no updates)
Via WP-CLI
GPLv2+ (addon $199–999/yr)
PUCPlugin Update Checker
Requires your own server or private Git repos
Free (MIT)
⚠ ~60+ files bundled
Prevents WP.org interference
Developer must build upgrade flow
Prevents WP.org interference
⚠ Depends on setup: your server or Git host
⚠ Each developer must update bundled copy
Git host dependent
Per-plugin
⚠ Optional
None (Git) or Low (JSON)
~60-file library embedded in each plugin
⚠ Extra library copy per plugin added
Manual JSON or Git setup
From readme.txt in repo
No UI (library only)
⚠ Git hosts: ~60 req/hr without auth token
Tokens/OAuth per Git host
Via WP-CLI trigger
Built-in
MIT
FAIRFederated and Independent Repositories
Mirrors the WP.org directory
Free (MIT/GPLv2)
N/A
Replaces WP.org entirely
AspirePress servers
N/A
N/A
Single redirect
Laravel stack
High
One shared plugin (AspireUpdate)
One plugin, one mirror
Scraping only
From WP.org
From WP.org
From WP.org
Web app
Database logs only, no UI
Your server, no limits
Public API
MIT / GPLv2
Git Updater
⚠ Only via private Git repos
Free core, Pro paid
Git headers
⚠ Exposes your plugin to WP.org
⚠ Leaks plugin data to WP.org
⚠ Plugin data leaks to WP.org
⚠ Git host sees all requests
One update covers all sites
⚠ Via Git tags only
⚠ ~60 req/hr without auth token
Per-plugin per host
None
Via Git host
One shared plugin (Git Updater)
One plugin, any Git host
N/A (is the source)
Settings
⚠ GitHub: ~60 req/hr without auth token
⚠ Git tokens for private repos + rate limits
GPL-3.0

How Troy Compares

Troy vs. Freemius

Freemius is a SaaS monetization platform that handles licensing, payments, and updates. It takes ~7% of every sale. Each plugin must embed a ~147-file SDK. Your customers' site URLs, WordPress versions, and plugin usage data flow through Freemius servers β€” not yours. Troy is self-hosted, MIT-licensed, and collects nothing from end users. If you need built-in payments, Freemius is the only turnkey option. If you already handle sales yourself, Troy gives you the update infrastructure β€” no revenue cut, no customer data collected.

Troy vs. EDD + Software Licensing

Easy Digital Downloads is a full eCommerce platform. Software Licensing is a paid addon ($199–999/yr at renewal) that adds update delivery. Every update check sends the customer's site URL to your store β€” no anonymization. EDD also ships built-in telemetry that reports your server environment, sales data, and active plugins to Awesome Motive weekly. The onboarding wizard pre-checks the opt-in checkbox. Troy handles update delivery on its own β€” no storefront, no telemetry, no site URLs sent anywhere.

Troy vs. Plugin Update Checker

Plugin Update Checker is a free MIT library with ~15 years of production use. You bundle ~60 PHP files into every plugin that uses it. Ten plugins means ten full copies in memory, ten HTTP requests per update cycle, and ten independent copies to patch when a vulnerability is found. PUC also stops working the moment you deactivate a plugin β€” its update service lives inside the host plugin. Troy installs once as a shared client and covers all Troy plugins, activated or not.

Troy vs. Aspire Cloud (FAIR)

Aspire Cloud set out to replace WordPress.org with an independent mirror. It requires a Laravel stack with PostgreSQL and Redis β€” it's too heavy to run on a $10/month server. Key backers stepped away in February 2026, and the project is pivoting to TYPO3 and Drupal. Troy doesn't replace WordPress.org β€” it runs alongside it.

Troy vs. Git Updater

Git Updater pulls updates directly from GitHub, GitLab, Bitbucket, or Gitea β€” no server required. The tradeoff: your Git host sees every update request, unauthenticated GitHub requests cap at 60 per hour, and private repos require each site owner to configure API tokens. Troy routes all update traffic through your own server with no rate limits and no client-side configuration.

Quick Decision Matrix

Not sure which tool fits your use case? This matrix maps common goals to the best-fit solution.

Your Goal
Best Choice
Runner-up
Distribute private/commercial plugins
Troy
PUC (1–2 plugins, no server)
Keep future WordPress.org option open
Troy
Git Updater (public repos only)
Keep plugins off WordPress.org radar
Troy
PUC (also filters proactively)
Zero platform fees
Troy
PUC (also free, MIT)
Full data ownership (no 3rd-party SaaS)
Troy
EDD (self-hosted, but phones home)
Lowest barrier to entry
Troy
PUC (no server, but ~60 files per plugin)
10+ plugins at scale
Troy
Git Updater
Fastest plugin publishing (one-click import)
Troy
β€”
Multiple PHP/WP version support
Troy
β€”
Network effect (one client, many repos)
Troy
β€”
Built-in analytics dashboard
Troy
Freemius (SaaS, opt-in tracking)
Composer/Bedrock workflow
Troy (native Composer 2 repository)
PUC (manual composer.json config)
Full admin UI for plugin management
Troy
EDD (full eCommerce UI)
No dependency on external services
Troy
EDD (self-hosted)
Built-in licensing and payments
Freemius
EDD + SL
No client plugin on customer sites
PUC (but bundles ~60 files per plugin)
Freemius (bundles ~147 files per plugin)
No separate client install (at the cost of ~60 files per plugin)
PUC
EDD (updater class per plugin)
No server maintenance, Git workflow
Git Updater
PUC (Git mode)

Why Is Troy Winning in Almost Every Category?

Because we learned from the others. We spent many days tearing apart every tool on this page β€” including Troy β€” cataloguing every feature gap, every silent data leak, every architectural shortcut. We know where Troy falls short too β€” and we're fixing it.