iOS, Android, or cross-platform. Your app is compiled and distributed through app stores. This page walks through each layer of your stack and explains your obligations at each level.
App store distribution counts as distribution. Every copyleft condition in your dependency tree is triggered.
Your IDE (VS Code, IntelliJ, Xcode, Android Studio), linters (ESLint, Prettier, SwiftLint, clippy, Pylint), formatters (Black, Prettier), build tools (Gradle, Make, Cargo, go build), bundlers (Webpack, Vite, Rollup, esbuild), transpilers (Babel, TypeScript), test runners (Jest, Vitest, pytest, XCTest), and version control (Git). These are all development tools.
None of these tools ship with your final product. They run during development and build time, not at runtime. Their licenses impose no conditions on your output.
Some bundlers inject a small runtime snippet into your output (e.g. Webpack’s module loader). These snippets are typically released under the same permissive license as the bundler itself (MIT for Webpack, Vite, Rollup). The condition is simply to include the copyright notice, which is usually embedded as a comment in the output.
Swift, Kotlin, Dart, Java, TypeScript, Go, Rust, Python, Node.js, C/C++.
No license obligations apply. Compilers transform your code but do not embed themselves in the output. GCC includes a Runtime Library Exception that explicitly permits this. Java’s Classpath Exception permits proprietary applications that use the Java runtime. All major language runtimes are permissive or include exceptions for proprietary code.
If you package a runtime with your binary (e.g. Python via PyInstaller), the runtime ships with your tool. Python’s PSF license is permissive. Check the bundler’s terms too.
React Native (MIT), Flutter (BSD), SwiftUI (proprietary), Jetpack Compose (Apache 2.0).
License conditions apply. All major mobile frameworks use permissive licenses.
Include framework license notices in your app’s acknowledgements or open source licenses screen.
When you distribute your product (app stores, binary downloads, Docker images), every dependency ships with it. Each library’s license conditions apply.
Include each library’s copyright notice and license text in your product’s acknowledgements screen.
Make your complete source code available under the GPL and include copyright notices.
LGPL permits proprietary use only if users can replace the library with a modified version — this is the “relinking” requirement.
Mobile apps (iOS, Android): Static linking is the norm. When the LGPL library is linked statically into your binary, users cannot swap it out. LGPL’s conditions therefore apply to your entire app, equivalent to GPL.
CLI tools in Go or Rust: Both languages produce statically linked binaries by default. The same consequence follows — LGPL behaves like GPL for your distributed binary.
Switch to dynamic linking, replace the dependency, or release your app under the LGPL.
Dynamic linking: If you dynamically link the library (e.g. a shared .so or .dll), users can swap the library without recompiling your binary. The LGPL conditions apply only to the library itself, not to your application code. You must ship the library’s source and allow relinking, but your proprietary code stays private.
Same as GPL for distributed software, plus the network use clause. For distributed products, the distribution clause already applies, making AGPL equivalent to GPL.
Make your complete source code available under the AGPL and include copyright notices.
Fonts, icons, images, and other media bundled into your product.
SIL OFL — Permissive for commercial use and web embedding. Google Fonts and most open source fonts use SIL OFL. Fonts cannot be sold standalone.
Proprietary fonts — Check the specific license. Some require a commercial license for app embedding or web use, and may have pageview limits, seat limits, or domain restrictions.
License varies by source. Include attribution where required by the license.
Read the font license. If proprietary, verify that your usage tier complies with the license terms.
Your product runs on the user’s device — Android (Linux GPL), iOS (proprietary), macOS, Windows, or Linux.
No license obligations apply. Your product is a user-space application and is not a derivative work of the kernel. The Linux kernel’s license does not extend to programs that run on top of it. Android’s C library (Bionic) uses a BSD license, not glibc (LGPL), specifically to avoid imposing conditions on app developers.
If you distribute Docker images, the OS packages inside carry their own license obligations — but your application code remains independent.
App Store and Google Play distribution counts as distribution in the legal sense.
Because you distribute your app to end users, every copyleft condition in your dependency tree is triggered. Permissive licenses require only that you include notices. Copyleft licenses may require source disclosure.
Both iOS and Android have standard patterns for this.
com.google.android.gms:oss-licenses-plugin) to auto-generate from Gradle dependencies.react-native-oss-license or create a dedicated screen.This satisfies the “include copyright notice and license text” condition for MIT, BSD, Apache, and most permissive licenses.
Scan your dependency tree to identify all licenses before you ship.
license-checker (npm)flutter pub depsIf your audit reveals GPL or AGPL dependencies, you have a decision to make. Either comply with the source disclosure condition, or replace the dependency with an alternative under a permissive license. This is a business decision, not a technical one.