The licensing tools for indie desktop apps — and the one I shipped with

I needed to license a paid desktop app I sell outside the app stores, so I worked through every option. Here's the honest comparison — what each tool is good at, where it stops, and why I ended up building and shipping on Keylight. (Full disclosure: I now build Keylight. I'll be straight about where the others are the better call — that's the only kind of comparison worth reading.)

Two questions decide it

1. Do you need real offline verification? Desktop apps run on planes, behind firewalls, on air-gapped machines. If your licensing breaks without a network, it isn't licensing — it's a liability. This rules out the "license key is a string you check over HTTP" options for anything serious.
2. Do you want payments handled too, or do you already have Stripe? Some tools are licensing-only; some are merchant-of-record that bolt keys on.

Hold those two up against each tool and the field sorts itself out fast.

What I shipped with: Keylight

The gap I kept hitting: the serious licensing tools hand you primitives and make payments and client code your problem, while the payment tools treat licensing as a thin afterthought. I wanted the middle — real offline licensing and payments, done, across every stack I ship on.

That's Keylight. Finished SDKs for Swift, Rust, JavaScript/TypeScript, C#, and C++, so the same licensing behaves identically across native macOS/Windows/Linux, Tauri, and Electron. Offline checks run on Ed25519-signed leases the SDK verifies on-device — no network, with entitlements signed right into the lease. Connect Stripe and licenses mint themselves on payment, no webhook code. I drop in the SDK, switch over .licensed / .trial / .expired, and I'm done — no signing server, no key management, no licensing backend.

For an indie shipping a paid desktop app who wants to get back to building the actual app, that's the whole point: licensing stops being a project.

When another tool is the better call

I'd rather be useful than oversell, so here's where I'd genuinely point you elsewhere:

• Keygen — the most flexible, language-agnostic licensing API; open-source and self-hostable. If you want maximum control, an unusual policy model, or to own the whole stack on-prem, Keygen is the pick. The cost is assembly: you bring payments, wire webhooks, and write the client code.
• Cryptolens — classic key + activation-count model with offline verification and strong .NET heritage. Good if you're deep in Windows/.NET and want the traditional approach.
• LicenseSpring — enterprise-grade: floating licenses, air-gapped activation, node-locking. Overkill for a solo app, right at home selling into companies with dark-site requirements.
• Lemon Squeezy / Polar — payments-first, merchant of record (they handle worldwide tax) with a basic license-key API attached. Reach for these if getting paid across borders is the priority and licensing is secondary; the offline story is thin.
• Gumroad — the simplest possible "sell a thing, verify a key over one endpoint." Fine for a cheap utility where piracy isn't worth fighting.
• StoreKit — only if you ship through the Mac App Store and want Apple to run purchases. Outside the store, it doesn't apply.

How to choose, in one line each

• Want it done — offline licensing + Stripe, across Swift/Rust/JS/C#/C++? Keylight.
• Want primitives + max control / self-host, any language? Keygen.
• Enterprise air-gapped / floating needs? LicenseSpring.
• Windows/.NET classic keys? Cryptolens.
• Just need to get paid globally, licensing secondary? Lemon Squeezy / Polar.
• Cheap utility, piracy not worth fighting? Gumroad.
• Shipping through the Mac App Store? StoreKit.

For most indie devs shipping a paid desktop app outside the stores, the bottleneck isn't control or payments — it's time. That's exactly the case Keylight is built for. There's a free tier here if you want to try it.