A licence is not legal paperwork at the end of a project — it is a constraint on the product itself: whether you can sell it, keep the source closed, and what you have to publish. Here is the map we use, including a model we had to rip out of a shipped product.

Not legal advice. This is what actually affects the build.

The licence map

Licence Sell Closed source Obligation
MIT / BSD yes yes keep the licence text and copyright
Apache 2.0 yes yes same + keep NOTICE, patent grant
LGPL yes yes, but not the library allow replacing the library, provide its source
GPL 2/3 yes no publish the sources of the derivative work
AGPL yes no publish sources, including for network use
Proprietary per contract yes do not redistribute separately, follow vendor terms
CC BY-NC 4.0 no — non-commercial use only

This covers code and weights. Fonts and media follow their own rules.

Five questions that decide everything

  1. Am I selling the product? If yes, non-commercial (NC) licences are out immediately.
  2. Is my code closed? If yes, GPL/AGPL dependencies are out, LGPL is questionable.
  3. Am I distributing a build? Linking GPL code for personal use is one thing; an APK in a store is another.
  4. Library or service? Running someone else's program as a separate process often untangles licences.
  5. Am I modifying someone's code? Copyleft forks require publishing changes.

MIT and Apache 2.0: why nearly everyone uses them

They allow commercial use, closed source and modification. They require one thing: keep the copyright notice and licence text. Apache 2.0 additionally grants patent rights and requires keeping the NOTICE file if present.

Practice: an About screen or a THIRD-PARTY-NOTICES.txt file with name, version, licence and source link. Twenty minutes of work and one question closed for good.

Where projects break: GPL, AGPL, LGPL

  • GPL in a mobile app. Statically link a GPL library and ship the APK — formally the whole APK becomes GPL. Unacceptable for a proprietary product.
  • AGPL and a server. If an AGPL-based service returns results over the network, users of the service are entitled to the sources.
  • LGPL. Your code stays closed, but the user must be able to replace the LGPL component. In a single Android APK that practically means "no".
  • "It is an internal tool, we are not selling" — internal use usually is not distribution, but publishing to a store is.

The rule is simple: a closed commercial product must not contain GPL dependencies. The exception is a separate process or a separate service.

The separate trap: models and data

This is the most common way to get caught in 2026: the app code is MIT, but the model weights are not.

  • Whisper — MIT, commercial use allowed.
  • faster-whisper, CTranslate2, M2M100 — MIT, fine for commercial products.
  • Helsinki opus-mt — models under CC BY 4.0: allowed, with attribution.
  • NLLB — CC BY-NC 4.0: non-commercial. Cannot be used in a commercial product.
  • Datasets under "research only" make a model unfit for production even if its code is clean.

In our own subtitle tool, NLLB was initially part of the translation pipeline — and it had to be removed, replaced by M2M100 (MIT) and Helsinki opus-mt. Check a model's licence before it becomes part of the architecture, not before the release. That mistake cost us a week.

Fonts, icons, sounds, SDKs

  • SIL OFL — may be embedded and sold, but the font itself cannot be sold separately.
  • Commercial fonts — read whether embedding is allowed: a desktop licence usually does not cover a mobile app.
  • Music and sound effects — "royalty free" does not mean "no conditions": credit may be required.
  • Proprietary SDKs (store billing, maps, push services) have their own terms, often banning reverse engineering and inclusion in open-source projects. Keys and proprietary binaries never go into an open-source repo.

Pre-release checklist

  1. The dependency registry is collected and current.
  2. No GPL/AGPL code in a closed product.
  3. No NC models or datasets.
  4. MIT/Apache/BSD notices preserved.
  5. Fonts and icons are licensed for embedding.
  6. Proprietary SDKs are used per vendor terms.
  7. Vendor keys and binaries did not leak into open source.
  8. Attribution for CC BY models is present.
  9. Licences were checked before the architecture, not after.
  10. A named person is responsible for the check.

Ten items that are cheaper at the start than rewriting a pipeline a week before release.

The full version of this article, with the detailed tables and the vendor-SDK section, is on our site: Licences in an app: MIT, GPL, proprietary. We are a small studio building apps, bots and desktop tools — TenLux.