The macOS Licensing Glossary: 25 Terms for Mac Developers
A reference glossary for Mac developers — license keys, activations, leases, refund flows, signing, and SDK runtime terms, each linked to deeper reading.
Licensing, distribution, and shipping Apple apps outside the App Store.
A reference glossary for Mac developers — license keys, activations, leases, refund flows, signing, and SDK runtime terms, each linked to deeper reading.
Your Stripe dashboard shows revenue. It says nothing about whether licenses activate, validate, or quietly fail. Here are the nine licensing metrics worth watching.
How checkOnLaunch() resolves the license on a SwiftUI Mac app and the six states your UI needs to handle: trial, licensed, limited, freeTier, expired, and invalid.
How to choose between a keyless free tier, a time-bound trial, and paid tiers for a Mac app — and the Keylight configuration that maps to each.
Add offline licensing to a JUCE plugin with Keylight — activate from the editor, gate pro features in processBlock via a lock-free atomic, no backend.
Three activation tickets indie Mac devs answer on repeat and how the Keylight portal handles each without your involvement — plus the canned redirect email template.
Add offline licensing to an Unreal Engine game with the Keylight C++ plugin — drop it into Plugins/, configure UKeylightSubsystem, and activate from Blueprints or C++.
A step-by-step guide to licensing an Electron app with Keylight — run the SDK in the main process, bridge activation over IPC, and gate features by entitlement.
How to add license keys to a Tauri v2 app with the Keylight plugin — register it in Rust, grant its capability, and call activate and validate from your frontend.
How to license a cross-platform app from one Keylight tenant — the same signed-lease format and Ed25519 verification across the Swift, JavaScript, Rust, and Tauri SDKs.
How to move your app licensing off Gumroad to Stripe and Keylight without breaking existing keys — import your customers, switch new sales, and bootstrap devices.
How offline license validation works in Rust with the keylight crate — verify an Ed25519-signed lease locally with no network call, bounded by an offline grace window.
One-time vs subscription licensing for your app — how each affects revenue, support, and trust, and how Keylight models perpetual keys and renewing subscriptions.
How Keylight models a Mac app subscription — the lease, the Stripe subscription, the renewal boundary, and the upgrade or downgrade path between tiers.
Tauri vs Electron for a desktop app you plan to sell — the real differences in core language and bundle size, and where license verification should live in each.
A Keylight lease is a signed JSON document, not an opaque license string. Here is the field-by-field anatomy and how Ed25519 verification protects every field.
The fastest way to add licensing to a Mac app: a payment provider for money, Keylight for licensing, a Swift SDK you drop in. The alternatives too.
Inside the pipeline that turns a Stripe Checkout payment into a signed license key in seconds — what fires, what gets minted, and what idempotency you get for free.
Import an existing customer base into Keylight from a CSV — preserve the keys customers already have, skip duplicates, and avoid forcing anyone to repurchase.
Switching your licensing shouldn't break a single customer. Here's how to migrate license keys into Keylight while every existing key keeps working.
Keylight is Swift-first and now cross-platform — Swift, Rust, and JavaScript SDKs today. Where it's headed: a public REST API and one dashboard for every license.
Why Keychain-stored licenses survive when a .app bundle is replaced by Sparkle or any auto-updater — and the three-step test to verify your update path before shipping.
How Keylight handles macOS App Sandbox: Keychain access, required entitlements, and the edge case of accepting direct license keys in a Mac App Store build.
A step-by-step playbook for launching a Mac app outside the App Store — signing, payments, licensing, updates, support, and launch day.
How indie Mac apps can use device activation limits to reduce license sharing without punishing customers who own a laptop and desktop.
A practical guide to storing a signed license token in the macOS Keychain, what belongs in Application Support, and how offline validation uses it.
How Paddle, Lemon Squeezy, and Stripe fit into Mac app licensing, where checkout ends, and why license keys still need a dedicated layer.
Developer ID and license keys solve different Mac app problems: safe installation, paid access, device activations, offline validation, and refunds.
How Stripe webhooks turn a Mac app purchase into a license key: checkout completion, idempotent key creation, subscriptions, refunds, and Keylight.
A step-by-step guide to adding license keys to a Swift macOS app — trial, activation, entitlement checks, and the UI states, using the KeylightSDK.
How to price an indie Mac app in 2026 — one-time vs subscription, tiered pricing, lifetime deals, and structuring pricing that scales with your audience.
The simple license check you wrote at launch quietly becomes a liability as an app grows. Here is where licensing breaks at scale, and how to design around it.
If your licensing server goes down, can your customers still open their apps? How to design licensing so an outage never becomes a customer-facing failure.
Paywall design patterns for developer tools and Mac apps — placement, messaging, tier presentation, and reducing friction so the purchase feels fair, not hostile.
Keychain, UserDefaults, or a file: where should a Mac app store license data? A look at the options, their security tradeoffs, and a sensible default.
How to convert free-trial users into paying customers for a Mac app — trial length, reminder timing, in-app prompts, and the licensing that makes it all work.
A founder note on why Keylight exists — the licensing gaps in Paddle, Gumroad, and Lemon Squeezy that pushed me to build a dedicated layer on top of Stripe.
Merchant-of-record platforms bundle licensing into a revenue share that looks small. Here is the real math, and the lock-in cost that never shows on the invoice.
How to license AI apps the right way — separating the app license from metered AI usage, signed keys for on-device models, and seat-based licensing for teams.
A practical guide to migrating from Paddle to Stripe — what changes, how to handle tax and licensing, and how to move customers without breaking their apps.
How device activations work in software licensing — fingerprinting, activation limits, the activate and deactivate flow, and idempotency that keeps it fair.
What should happen to a license key after a refund or chargeback — automatic revocation, how it reaches the app, and why offline apps revoke on a delay.
How to prevent license key sharing without punishing legitimate customers — device activation limits, fingerprinting, and choosing graceful limits over hard blocks.
A plain-English explanation of how offline license validation works — verifying a signed license locally with a public key, and why desktop apps need it.
A clear explanation of how modern license keys work for desktop apps — from old checksum keys to cryptographically signed leases your app can verify offline.
Why and how to migrate your app's licensing to Keylight — from a merchant-of-record service or a homegrown system — and the tradeoffs to weigh before you switch.
A practical walk-through of selling a Mac app directly — distribution, notarization, payments, and licensing — and an honest look at the tradeoffs against the App Store.
A practical comparison of Stripe, Paddle, and Lemon Squeezy for indie app developers — fees, tax handling, customer ownership, licensing, and which to pick when.
A short introduction to what the Keylight blog is for — practical writing about licensing, distribution, and shipping desktop and AI-native apps.