Desktop Insights scans thousands of macOS applications to identify every SDK, framework, and library they bundle. But how do you actually figure out what's inside a .app bundle? It turns out that Electron apps and native macOS apps require completely different extraction strategies.
Electron Apps: A Treasure Trove of Metadata
Electron apps ship a full Chromium runtime plus a Node.js environment, and that architecture makes them surprisingly transparent. Here's what we extract and how:
package.json
Every Electron app includes a package.json listing its npm dependencies. We extract this from the app's resources/ directory or from within the .asar archive. This gives us the complete dependency tree — framework versions, utility libraries, and everything in between.
CREDITS.html
Chromium bundles a CREDITS.html file listing every open-source component compiled into the browser engine. We parse this to identify which Chromium version the app ships and which upstream libraries it includes (ICU, V8, Skia, etc.).
Asar Archive Analysis
Electron apps typically bundle their application code in an .asar archive — a tar-like format. We extract and inspect the archive contents to find bundled modules, configuration files, and any additional dependency manifests that package.json might not fully capture.
Native macOS Apps: Reading the Binary
Native macOS apps don't come with a convenient package.json. Instead, we use a combination of macOS-specific tools to infer their dependencies:
Framework Plists
macOS frameworks include Info.plist files with version numbers and bundle identifiers. We scan every .framework directory inside the app bundle and extract these metadata files to identify frameworks like Sparkle, Sentry, Realm, and others.
CocoaPods and SPM Bundles
Apps built with CocoaPods or Swift Package Manager often include resource bundles with identifying metadata. We look for .bundle directories and their associated plists to detect pod and package dependencies.
Binary String Analysis
When all else fails, we run strings on the app's binary and look for known SDK signatures — version strings, class name prefixes, and API endpoint patterns that uniquely identify specific SDKs. This is how we detect analytics providers like Amplitude, crash reporters like Bugsnag, and feature flag services like LaunchDarkly.
Putting It All Together
Each extraction produces a structured snapshot: app name, version, a list of dependencies with their versions, and the frameworks bundled inside. We store these snapshots over time so you can see exactly when an app added Sentry, upgraded Electron, or dropped a legacy framework.
The result is a version-by-version history of every tracked app's technology stack — something that simply didn't exist before for desktop applications.