Why Licensing + Payments Matter

When you’re ready to sell and distribute your desktop app, you need two things:

‍

1. a way to process payments, and
   ‍
2. a licensing system that ensures only paying customers can use your app under the terms you set (duration, features, seats/devices, etc.) - including offline use across Windows, macOS, and Linux.
   ‍

Options: Roll-your-own / Platform Stores vs. Devolens

Roll-your-own

Full control, but you must build/maintain key generation, node-locking (HWID), offline tokens, renewals, machine swaps, floating seats, and audits - across three OSes.

‍

OS / store ecosystems (Microsoft Store, Mac App Store, Linux repos/stores)

‍

• Built-in distribution and updates.
  ‍
• Plan/feature/seat enforcement is often not provided natively; offline and advanced models typically require extra work.
  ‍
• Payment options and policies are tied to the store channel.

‍

Devolens (third-party licensing)

‍

• Use any payment processor or invoice for B2B.
  ‍
• Monetize in more ways: node-locked, floating/concurrent seats, per-seat/device, per-feature/edition, usage-based, subscriptions, trials.
  ‍
• Offline and constrained environments supported (incl. air-gapped workflows).
  ‍
• You can still list on app stores for discovery while running licensing/payments independently.
  ‍
• Works with common packaging formats: .exe/MSI/MSIX (Windows), .app/.pkg/.dmg (macOS), .deb/.rpm/AppImage/Snap/Flatpak (Linux).
  ‍

Tip: Many teams distribute directly (and/or via stores) and unlock paid features with Devolens for consistent licensing across OSes.

Implementation: License Verification

Desktop stacks we see most: C#/.NET (WPF/WinUI/MAUI), C++/Qt, Python (PyInstaller), Electron/Node, Java, Swift/Objective-C (macOS), Rust/Go - all supported.

Start with the Key Verification quickstart to verify a license and read its properties. Teams report first integration in ~1 hour (customer-reported; varies by codebase).

Python example (cross-platform, simplified):

‍‍

RSAPubKey = "enter the RSA Public key here"
auth = "access token with permission to access the activate method"

result = Key.activate(token=auth,\
                   rsa_pub_key=RSAPubKey,\
                   product_id=3349, \
                   key="ICVLD-VVSZR-ZTICT-YKGXL",\  
                   machine_code=Helpers.GetMachineCode(v=2))

if result[0] == None:
    # an error occurred or the key is invalid or it cannot be activated
    # (eg. the limit of activated devices was achieved)
    print("The license does not work: {0}".format(result[1]))
else:
    # everything went fine if we are here!
    print("The license is valid!")

Benefits You Get With Devolens

‍

1. Protect executables from unpaid use; enforce node-locking or floating seats on Windows, macOS, and Linux.
   ‍
2. Offline-capable flows with signed, time-limited tokens and configurable grace periods.
   ‍
3. More models out of the box: per-seat/device, feature-gated editions, usage-based, subscriptions, trials.
   ‍
4. Cross-OS consistency: one licensing approach for multiple binaries and package formats.
   ‍
5. Analytics & control: activations, versions, seats/devices, geography, renewals, and policy automation.
   ‍
6. Payment-agnostic: plug in your processor or your ERP/invoicing for B2B.
   ‍

Practical approach: Ship a single build per OS; unlock editions/modules via entitlements—no separate “Pro” installers, no OS-specific licensing code paths.

‍

Common Desktop Scenarios

‍

• Node-locked: bind a license to a specific computer for single-user tools.
  ‍
• Floating/Concurrent: ideal for labs and teams that share a seat pool.
  ‍
• Per-feature/Edition: Pro vs. Enterprise, or modular add-ons - no separate installers.
  ‍
• Usage-based: charge by runs, credits, or compute - fair for niche scientific apps.
  ‍
• Trials: ship a trial that converts in place - no reinstall required.
  ‍

FAQ

Will it work if my users are offline?

Yes. Provide offline activation files/tokens with an expiry. They refresh when the app is online again.

What if a user changes machines?

Admins (or users, if you allow) can release a seat and re-activate on the new device - within limits you set.

Can I keep selling through my existing processor?

Absolutely. Plug in your current payments - or sell direct to enterprises with invoices and quotes.

Do I need multiple installers for different editions?

No. Ship once and unlock features through license entitlements.

Can I support teams that share licenses?

Yes. Use floating/concurrent seats with timeouts and seat recycling.