Anyone who has built an Adobe AIR app with extensions from distriqt (airnativeextensions.com), the largest catalogue of commercial AIR extensions, knows the routine: you want push notifications, and you get a dozen ANEs. com.distriqt.Core, AndroidX, Google Play services, Firebase, Kotlin, Guava, OkHttp. To keep all of that in step there is APM, the AIR package manager distriqt distributes its extensions with. It downloads the extension, its dependencies, and their dependencies.
We know this from the inside: until 2026, our own apps ran on distriqt extensions installed with APM. Our Android app had 45 ANEs, 35 of them from distriqt or their dependency chain, most of them helper ANEs.
That looks like convenience. In fact it is a symptom.
Where the dependency chains come from
Most AIR extensions on the market, including much of distriqt's catalogue, don't implement the feature themselves. They are wrappers: a thin ActionScript layer around somebody else's SDK. Push is Firebase. Ads are AdMob. Sign-in is the Google or Facebook SDK. Billing is Google's or Apple's library, sometimes with a vendor library on top.
The real work, and the know-how, sits in those third-party SDKs. The extension translates function calls from ActionScript into the SDK and back.
That has consequences:
- Every SDK brings its own libraries. Firebase alone needs a whole tree of Google and AndroidX packages.
- The wrappers share those libraries. Two extensions that both use Google Play services must use the same version of it.
- So the shared libraries become ANEs of their own: one per library, kept in step by version numbers.
- And because nobody can keep that tree consistent by hand, you need a package manager.
APM exists because the architecture produces dependency chains. Not because AIR needs one.
Why the chains block each other on updates
As long as nothing changes, the chain holds. Then Google raises the minimum Play Billing version, Apple changes a requirement, or Android ships a new target SDK:
- The wrapper vendor (for most AIR developers: distriqt) has to wait for the SDK vendor, then rebuild its core and helper ANEs.
- Then every wrapper that uses the shared library needs a new version, because they all have to agree on it.
- You can't update one extension alone. A new push extension needs a new core, which needs new AndroidX ANEs, which need a new billing extension, which you didn't want to touch.
- Build conflicts appear ("duplicate class", mismatching versions), and every combination has to be tested again on every platform.
Your app gets updates it didn't need, and waits for updates it urgently needs. Meanwhile every helper ANE is packaged into the app and loaded at start, including the parts you never use.
What AIR can do on its own
The irony: AIR doesn't need any of this.
- Android: since AIR 50.2, an extension can declare its Maven libraries directly in its platform descriptor (
<gradle><dependencies>). At packaging time, ADT resolves them with Gradle, exactly like a native Android app. One extension, one file; Google's library is fetched in the right version at build time. No separate AndroidX ANE, no core ANE, no package manager. - iOS and macOS: the system frameworks (StoreKit, AVFoundation, UserNotifications, AuthenticationServices, …) are part of the operating system. An extension that uses them directly needs nothing else.
An extension that implements its feature natively, on the platform APIs, is self-contained by design.
How we build extensions
Our extensions don't wrap third-party SDKs. They implement the feature on the platform APIs themselves:
- KlugMedia: camera, H.264 encoding and decoding, RTMP, Opus voice and echo cancellation in one native session. AVFoundation and VideoToolbox on Apple platforms, Camera2 and MediaCodec on Android, and its own native implementation on Windows 10 and 11. No video SDK, no helper ANE.
- KlugBilling: StoreKit on iOS and macOS, Google Play Billing on Android. The Play Billing library is resolved by Gradle at packaging, not shipped as an ANE.
- KlugPush: APNs directly on Apple platforms, Firebase Messaging resolved at build time on Android.
The result in our own apps, measured on real devices:
| before (distriqt + APM) | after (Klug) | |
|---|---|---|
| ANEs in the Android app | 45 (35 third-party, mostly helpers) | 13 |
| App size | −6.5 MB Android, −5.9 MB iOS | |
| App start | about 2× faster | |
| Update conflicts | regular | none: each extension updates alone |
AIR as the shell – not as the engine
Because our extensions need no APM and implement their features natively, they don't depend on what the AIR SDK can or can't do. We use AIR as the shell: the user interface and the app logic in ActionScript, packaging for every store. Everything that has to be reliable runs in native code: camera, video, two-way voice, push, purchases, sign-in, the app lifecycle.
That makes us largely independent of the AIR SDK and its release cycle:
- AIR weaknesses don't reach the app. Two examples from our own production apps: on iOS, AIR's own
NetConnectioncan crash the app when it opens a connection without network; and AIR reports pressing the home button, opening Control Center and pulling down the notification shade as one and the same "deactivate" event. Our native code covers both: it checks the network before reconnecting and reports the real app background separately. - A new AIR SDK is an update, not a migration. We switched our apps from AIR 51.4 to 51.5 in an afternoon: copy the SDK, rebuild, done. No dependency tree to resolve, no extensions waiting for each other.
- When Apple or Google change something, we fix it in our native code, without waiting for AIR, a wrapper vendor or a package manager.
What this means for you
- Installation: copy one ANE, add its extension ID. That's all.
- Updates: you update the one extension you need. Nothing else moves.
- New platform requirements: we ship our own apps with the same extensions, so we hit new Apple and Google requirements first and fix them before you notice.
- Tested in real apps, not only shown in code examples: every extension runs in our own apps on the App Store, Google Play and the Mac App Store, and KlugMedia also in our Windows app, before it is released to you. A sample project proves that a call works; a published app proves that the extension works.
- Observed in live operation, every day: our apps run on our own streaming servers; server logs, connection statistics and the crash and error reports from the App Store and Google Play are evaluated daily. Problems show up in our numbers first.
- No package manager, no core library, no helper ANEs. You just keep your Adobe AIR SDK up to date.
A package manager is useful when a system really consists of many shared parts. For AIR native extensions it is the answer to an architecture that wraps instead of implementing. Fix the architecture, and the package manager isn't needed.
Self-contained native extensions for Adobe AIR on iOS, Android and macOS, and KlugMedia also on Windows: klughomesolutions.com
More articles
- Shipping an AIR app to the Mac App Store and TestFlight
- One app, many native extensions – and they have to work together
- Two-way voice with echo cancellation in Adobe AIR
- Camera and H.264 live streaming in Adobe AIR, without AIR's camera
- Sign in with Apple and Google in an Adobe AIR app
- Adobe AIR on iOS 27: the launch crash and how to ship anyway
- A distriqt alternative for Adobe AIR native extensions