Hubbry Logo
Adobe AIRAdobe AIRMain
Open search
Adobe AIR
Community hub
Adobe AIR
logo
8 pages, 0 posts
0 subscribers
Be the first to start a discussion here.
Be the first to start a discussion here.
Adobe AIR
Adobe AIR
Adobe AIR
View on Wikipedia
from Wikipedia

Adobe AIR
Original authorAdobe Inc.
Developers
Initial releaseFebruary 25, 2008; 17 years ago (2008-02-25)
Stable release
51.1.3.8[1][2] / March 6, 2025; 8 months ago (2025-03-06)
Preview release
33.1.1.932 / N/A
Operating system
PlatformIA-32, x86-64, ARM, and MIPS
Available inChinese Simplified, Chinese Traditional, Czech, Dutch, English, French, German, Italian, Japanese, Korean, Polish, Portuguese (Brazilian), Russian, Spanish, Swedish, and Turkish[6]
TypeRuntime environment
LicenseProprietary[7]
Websiteairsdk.harman.com

Adobe AIR (also known as Adobe Integrated Runtime and codenamed Apollo) is a cross-platform runtime system currently developed by Harman International, in collaboration with Adobe Inc., for building desktop applications and mobile applications, programmed using Adobe Animate, ActionScript, and optionally Apache Flex. It was originally released in 2008. The runtime supports installable applications on Windows, macOS, and mobile operating systems, including Android, iOS, and BlackBerry Tablet OS.

AIR is a runtime environment that allows Adobe Animate content and ActionScript 3.0 coders to construct applications and video games that run as a stand-alone executable and behave similarly to a native application on supported platforms. An HTML5 application used in a browser does not require installation, while AIR applications require installation from an installer file (Windows and OS X) or the appropriate App Store (iOS and Android). AIR applications have unrestricted access to local storage and file systems, while browser-based applications only have access to individual files selected by users.[8]

AIR internally uses a shared codebase with the Flash Player rendering engine and ActionScript 3.0 as the primary programming language. Applications must specifically be built for AIR to use additional features provided, such as multi-touch, file system integration, native client extensions, integration with Taskbar or Dock, and access to accelerometer and GPS devices.[9] HTML5 applications may run on the WebKit engine included in AIR.

Notable applications built with Adobe AIR include eBay Desktop, Pandora One desktop,[10][11] TweetDeck,[12] the former Adobe Media Player,[12] Angry Birds,[13] and Machinarium,[14] among other multimedia and task management applications.[15] According to Adobe, over 100,000 unique applications have been built on AIR, and over 1 billion installations of the same were logged from users across the world, as of May 2014.[16][17] Adobe AIR was voted as the Best Mobile Application Development product at the Consumer Electronics Show for two consecutive years (CES 2014 and CES 2015).[18][19]

In June 2019, Adobe announced it would begin transitioning ongoing support and development of Adobe AIR to Harman. Adobe continued to provide support for versions 32 and earlier until the end of 2020, as support would be managed by Harman.[20]

Features

[edit]

Using AIR, developers can access functionality including text, vector graphics, raster graphics, video, audio, camera, and microphone capability. AIR also includes additional features such as file system integration, native client extensions, desktop integration and access to connected devices. AIR enables applications to work with data in different ways, including using local files, local SQLite databases (for which AIR has built-in support), a database server, or the encrypted local store included with AIR.

Developers can access additional functionality by building AIR Native Extensions, which can access full device functionality being programmed in the native language.[21]

Desktop features

[edit]

On desktop platforms, AIR supports:

  • Window management – Opening multiple windows, minimizing, maximizing and resizing AIR windows.[22]
  • Menu bar – Adding a native menu bar to AIR windows, with sub menus and custom menu items.[23]
  • File management – Discovering drives, files and folders on the PC, creating and deleting files, renaming, copying and moving files.[24]
  • Console applications – Executing native applications with command-line arguments, and receiving feedback via standard I/O & error streams.[25]
  • Multithreading – Managing multiple threads, to execute ActionScript 3 code in the background without freezing the user interface.[26]
  • Web browser – View HTML web pages with full CSS and JavaScript support within applications, with the integrated WebKit-based web browser.[27]
  • Clipboard access – Programmatically copy or paste text, bitmaps or files into the system clipboard.[28]
  • Drag-and-drop – Allows users to drag text, bitmaps or files into AIR applications.[29]

Mobile features

[edit]

On mobile platforms, AIR supports many mobile hardware features:

3D graphics

[edit]

In 2011, the addition of Stage3D allowed AIR apps access to GPUs for hardware acceleration. Several third-party frameworks have been developed to build upon the functionality of Stage3D, including the Starling Framework and Away3D. These frameworks are also compatible with AIR, and provide vital performance improvements to AIR apps published for mobile devices.

AIR Native Extensions

[edit]

AIR apps can be augmented in functionality with the usage of AIR Native Extensions (ANEs). Native extensions are plug-in code libraries that contain native code wrapped with an ActionScript API,[34] allowing developers to access native features not otherwise usable in AIR, such as Apple Game Center or Google Cloud Messaging.

Native extensions may be developed by anyone using publicly available tools;[35] some are distributed for free or even as open source, while others are sold commercially.[36]

Native extensions may be programmed in the native language on each platform, allowing access to the full set of platform APIs provided by the developer. (C++ for Windows, Java and C++ for Android, Objective-C for iOS).[21]

Availability

[edit]

AIR is a cross-platform technology and AIR applications can be repackaged with few or no changes for many popular desktop and mobile platforms. Different installation options exist for each platform.

AIR applications may be published with or without the AIR runtime. Applications packaged with the AIR runtime are larger in file size, and are known as "captive runtime" applications.[37] If the runtime is not embedded in the app, it must be installed separately.

In January 2009, Adobe claimed that there were over 100 million installations of Adobe AIR worldwide, and that "the majority of AIR runtime installations occur at the time the first AIR application is installed by a user".[38] In May 2014, Adobe claimed that over 100,000 unique applications were built on AIR, and over 1 billion installations of the same were logged from users across the world.[16][17]

Platforms

[edit]

Adobe AIR, version 32, contains Adobe Flash Player 32, and is available for Windows 7 and later, as well as OS X 10.9 and later.[6] Desktop Linux distributions were available until June 2011 with version 2.6, which ended Linux support.[39]

Adobe AIR applications can be published as native phone applications on certain mobile operating systems, such as Android (ARM Cortex-A8 and above[40]) and Apple iOS.[41] In May 2017, Adobe stopped releasing AIR for Android, and the app was eventually removed from the Play Store in September 2018, but it can still be downloaded through their website.[42] After Adobe's transition of AIR to Harman, they resumed support for Android and the latest version is only available there.[3]

Platform Installer file support App store support
Windows .air, .exe and .msi[37][43] None
macOS .air and .dmg[43] App Store (with captive runtime)[44]
Android .apk[45] Google Play[45]
iOS .ipa[46] App Store[46]
Playbook .bar[47] App World[47]

The following table explains to what extent Adobe AIR can run on various mobile operating systems:

Operating system Prerequisites Latest Adobe Flash Player AIR Framework
Android Android 2.3+, ARM Cortex-A8+[48] or Android x86[49] AIR 3.6.0.597 (uses Flash Player 11.6)[50] Option 1: The AIR player can be embedded as a 'captive' runtime, which increases APK size but makes the application standalone.[51]

Option 2: The runtime is not included with the app, and must installed as a separate app from the app market.[52]

Apple iOS iOS 4.3 or later AIR 3.6.0.597 (uses Flash Player 11.6)[50] Not applicable: each app includes its own 'captive' runtime.[53]
BlackBerry Tablet OS None AIR 3.1 (uses Flash Player 11.1)[54][55] Already pre-installed on each device.[53]
BlackBerry 10 Blackberry 10.2 and lower (no longer supported from 10.3)[56] AIR 3.5 (uses Flash Player 11.1)[citation needed] Already pre-installed on each device.

Application development

[edit]

AIR runs applications within a contained Flash Player instance. It runs web applications via WebKit rendering engine. Multiple instances of the browser can be started within a single AIR application, but JavaScript content executes with some security limitations.

AIR does not provide direct access to native GUI elements such as navigation bars or controls. Native extensions can be used to access additional native resources.

Development tools

[edit]

SDK

[edit]

The AIR SDK is available as a free standalone download for software developers to make AIR applications.[57] SDK users do not need to install any commercial software to use the SDK, although several options are available. AIR apps can be compiled from the command line using the AIR compiler included in the SDK; the compiler can also be called from an IDE to eliminate the need for the command line.

AIR can also be used with Adobe Flex.[58] Flex is an integrated collection of stylable graphical user interface, data manipulation and networking components, and applications built upon it are known as "Flex" applications. Flex GUIs are defined in MXML, similar to how Android and Microsoft Visual Studio define GUIs; however, Flex does not give access to native GUI components.

AIR applications built without the Flex framework allow greater flexibility and performance, and are known as "pure ActionScript" applications.[59][60][61] Video games built on the AIR platform are typically pure-Actionscript projects. Various open-source component frameworks are available for pure ActionScript projects, such as MadComponents, that provide UI Components at significantly smaller SWF file sizes.[62][63]

Software

[edit]

Adobe distributes three commercial software products for developing of AIR applications in ActionScript:

Third-party development environments that target the AIR runtime are also available, including:

  • Moonshine IDE, a free IDE built with Apache Flex and Adobe Air. It can be used to create ActionScript 3, Apache Flex, Apache Royale and Feathers projects from Moonshine. It also provides cloud support.
  • FlashDevelop, an open-source Flash ActionScript IDE, which includes a debugger for AIR applications
  • Powerflasher FDT, a commercial ActionScript IDE
  • CodeDrive, an extension to Microsoft Visual Studio 2010 for ActionScript 3 development and debugging
  • IntelliJ IDEA, a commercial IDE supporting ActionScript 3 development and debugging
  • AS3 & MXML for VSCode, a powerful extension capable to turn the popular Microsoft free editor Visual Studio Code in a complete AIR IDE

Adobe Flash Builder is the premium tool for Flex application development, since it includes an integrated drag-and-drop user interface builder, not found in competing tools like FlashDevelop.[64]

JavaScript applications

[edit]

Adobe provides for AIR, HTML5 and JavaScript development with Adobe Dreamweaver CS5, although any other HTML editor or text editor can be used.[65]

AIR can run a subset of JavaScript, with no ability to dynamically execute code when running in the application sandbox. According to Adobe, this restriction is designed to prevent malicious remote content from attacking a user's system.[66] Because of this restriction, JavaScript frameworks that make use of dynamic JavaScript functions like eval() were not initially compatible with AIR. However, several frameworks including Dojo Toolkit,[citation needed] jQuery,[citation needed] and ExtJS[citation needed] were updated to run in AIR's application sandbox. Some frameworks like MooTools were already compatible.[citation needed]

Dreamweaver CS4/CS3 requires an additional extension to compile AIR applications,[67] as does Flash CS3 in the form of an update.[68]

References

[edit]
[edit]
Revisions and contributorsEdit on WikipediaRead on Wikipedia

Adobe AIR

View on Grokipedia
from Grokipedia
Adobe AIR is a cross-platform runtime environment developed by Systems that enables developers to create, package, and deploy standalone desktop and mobile applications using familiar web technologies such as HTML, CSS, , and , without requiring a . It combines the flexibility of web development with native application capabilities, including access to local file systems, device hardware, and offline functionality, allowing for rich internet applications (RIAs) that run seamlessly across multiple operating systems. Originally released in 2008 under the name Adobe Integrated Runtime (AIR), the platform was designed to bridge the gap between web and desktop development, building on 's Flash and Flex technologies to support cross-operating system deployment. In 2019, Adobe announced it would transition ongoing support and feature development to HARMAN, a subsidiary, effective June 2019, with the handover completed by late 2020; this shift ensured continued maintenance while Adobe provided basic security updates for legacy installations. As of 2025, Adobe AIR remains a mature framework widely used for multimedia applications, games, and , with HARMAN releasing regular updates to the SDK and runtime. Key features of Adobe AIR include its support for both HTML-based and ActionScript-based development, integration with tools like for animations and interactions, and the ability to incorporate native extensions for platform-specific features such as in-app purchases or hardware sensors. It provides a browser-like environment with a WebKit-based HTML renderer, JavaScript engine, and (DOM), while extending capabilities to native APIs for file I/O, networking, and user notifications. Developers can use the AIR SDK, which includes the AIR Package Manager (APM) for dependency management and project configuration, to build applications that install like native software. Adobe AIR supports deployment on Windows and macOS for desktop, as well as Android and for mobile devices, allowing a single codebase to target multiple platforms with minimal modifications. A local AIR simulator facilitates rapid testing and debugging without physical devices, enhancing development efficiency. The runtime is free for end users, and the SDK is available at no cost for personal or low-revenue projects, with commercial licensing options for larger enterprises. In its current status as of November 2025, Adobe AIR is actively maintained by HARMAN through community-driven resources on and the AIR SDK website, with the latest stable release being version 51.2.2.5 in October 2025, incorporating security fixes and performance improvements. This ongoing support has sustained its relevance for legacy applications and new projects requiring offline-capable, cross-platform RIAs, particularly in sectors like gaming and .

History

Origins and Initial Release

Adobe Systems conceived the Adobe AIR project in 2007 under the codename "Apollo," with the goal of bridging the divide between web-based rich internet applications (RIAs) and traditional desktop software by leveraging established web technologies including , CSS, , Flash, and . The initiative emerged from 's broader strategy to extend the reach of beyond browsers, enabling developers to create installable applications that combined the simplicity of web coding with desktop-level capabilities. This approach was motivated by the limitations of browser environments, which restricted access to local resources and offline operation, prompting to develop a dedicated runtime for cross-platform deployment. Key early objectives included providing offline access to applications, seamless integration with the local for reading and writing , and support for native window controls such as custom chrome and drag-and-drop functionality, features absent in standard browser-based RIAs. Developed primarily by Adobe's engineering teams, the project emphasized compatibility with /Vista and macOS 10.4 or later as initial target platforms, ensuring broad accessibility for desktop users without requiring platform-specific recoding. A public alpha release of the Apollo SDK occurred on March 19, 2007, offering developers early tools for prototyping applications via command-line utilities. The project advanced to a public beta on June 11, 2007, coinciding with its official renaming to Adobe Integrated Runtime (AIR) to reflect its role in integrating web runtime environments with desktop execution. This beta introduced enhanced support for /AJAX alongside Flash-based content, broadening its appeal to diverse developer communities. The stable version 1.0 launched on February 25, 2008, marking AIR's formal debut as a production-ready runtime that transformed browser-centric RIAs into standalone desktop executables, complete with installation packages and digital signing for secure distribution.

Adoption and Milestones

Adobe AIR experienced rapid adoption shortly after its launch, surpassing 100 million installations worldwide by January 2009. This growth was bolstered by its bundling with the runtime, which expanded its reach to millions of users already equipped with Flash for web applications. Early notable applications included Desktop, launched in 2008 as a dedicated client for auction monitoring and bidding with real-time notifications. Similarly, TweetDeck debuted in 2008 as a multi-column client, leveraging AIR for cross-platform desktop deployment and seamless updates. Key version milestones marked significant enhancements during Adobe's stewardship. AIR 1.5, released in November 2008, introduced native installers for easier distribution and support for multi-monitor configurations, improving usability on extended desktop setups. AIR 2.0, released in 2010, added capabilities for printing directly from applications and access to devices like USB drives, enabling more robust file handling. By 2011, AIR 3.0 expanded to mobile platforms, providing support for Android and to allow developers to package apps for app stores with native performance. Adoption continued to accelerate through the mid-2010s, enabling thousands of applications across creative tools, interfaces, and . By May 2014, Adobe reported over 100,000 unique applications built on the platform. The final major update under direct control, AIR 32 in 2019, focused on security hardening against emerging threats and performance optimizations for modern hardware.

Transition to HARMAN and Current Status

In May 2019, Adobe announced the transition of ongoing platform support and feature development for to , effective June 2019. This shift allowed Adobe to focus on other priorities while ensuring continued maintenance through a licensing agreement with HARMAN, who assumed responsibility for the SDK and runtime in 2020. Adobe provided basic security support, limited to fixes for vulnerabilities, for AIR version 32 and earlier on desktop platforms until the end of 2020, after which all support transitioned fully to HARMAN. HARMAN has since released versions starting from 33, incorporating community-driven updates and new features such as the (apm), a tool for simplifying application descriptor creation and dependency management. As of November 2025, Adobe AIR remains actively maintained under HARMAN, with the latest stable release being version 51.2.2.5, issued on October 2, 2025, addressing various fixes and improvements. An upcoming release in the 51.2 series is anticipated to include additional updates, supported through HARMAN's official AIR SDK website and repository for developer resources and issue tracking. Licensing has evolved to keep the runtime free for end-users, while the SDK is available at no cost for personal use and low-income developers; enterprise users require a commercial license for full access and support. This model sustains ongoing viability for AIR applications across desktop and mobile platforms.

Overview

Core Purpose and Architecture

Adobe AIR is a cross-platform runtime environment designed for building, packaging, and deploying standalone applications that leverage web development standards such as , CSS3, and , as well as Adobe-specific technologies including and Flex. It enables developers to create rich applications (RIAs) that extend beyond browser constraints, delivering native-like experiences on desktop, mobile, and other devices while reusing existing web skills. By packaging applications as self-contained executables, AIR overcomes limitations like restricted access and lack of offline capabilities in traditional web apps, allowing for custom user interfaces, persistent storage, and direct hardware integration. At its core, the architecture of Adobe AIR is a sandboxed runtime built upon the Flash Player engine, which provides a secure, isolated environment for executing application code. For ActionScript-based applications, it incorporates the ActionScript Virtual Machine (AVM2), the same just-in-time compiler used in Flash Player, to interpret and run bytecode efficiently. HTML and JavaScript content, on the other hand, is rendered and executed via a WebKit-based browser engine, similar to that in Safari, enabling compatibility with standard web technologies while supporting AIR-specific extensions. The runtime exposes a suite of APIs for local storage (including SQLite databases), networking, file I/O, and hardware access, bridging web code with native system resources in a controlled manner. Key components of the AIR architecture include the application installer, which bundles into platform-specific native executables such as .exe for Windows, .app for macOS, or .apk for Android, allowing apps to run independently without requiring a browser. An integrated updater facilitates seamless background updates to maintain application and . The security model enforces sandboxing to separate application from other system resources, with digital signatures—either self-signed or from trusted certificate authorities—required to establish trust and prevent tampering, ensuring that only verified applications can access sensitive APIs. This design allows AIR applications to execute web-based within a contained, native-wrapped environment, providing the performance and integration of desktop software.

Supported Technologies

Adobe AIR primarily supports development using ActionScript 3.0, which runs on the ActionScript Virtual Machine 2 (AVM2) for executing bytecode in applications. This language enables with strong typing, event handling, and access to AIR's runtime APIs for desktop and mobile features. Developers often use (formerly Flash Professional) to create user interfaces, animations, and assets, exporting them as SWF files that integrate seamlessly into AIR projects. For model-view-controller (MVC) architectures, provides a framework to build robust, data-driven applications with reusable components and data binding. In addition to ActionScript-based development, AIR supports web standards including , CSS3, and through an embedded engine, allowing developers to build applications using familiar browser technologies. This environment includes support for AJAX for asynchronous data requests, for data interchange, and DOM manipulation for dynamic content updates, providing a near-browser experience within native applications. AIR includes built-in integrations for local data storage and . It features native support for databases, enabling structured (SQL) operations for offline data management with features like transactions and indexing. For PDF generation, third-party libraries such as AlivePDF allow developers to create and manipulate PDF documents client-side without server dependencies. Multimedia capabilities encompass (FLV and F4V formats with H.264 encoding) for video playback and native audio support via the Sound class for streaming and embedded audio. While AIR does not provide native integration for modern JavaScript frameworks like React, these can be incorporated by bundling framework code and libraries into HTML-based AIR applications for rendering via the engine.

Features

Desktop Capabilities

Adobe AIR provides robust integration with desktop operating systems, enabling applications to behave like native software while leveraging web technologies for development. This includes access to OS-level services such as window management, local storage, and system notifications, allowing developers to create immersive desktop experiences without requiring platform-specific coding. These capabilities are supported across Windows and macOS, with APIs available in both and HTML/JavaScript environments. Native windowing in AIR allows developers to create and manage multiple windows with customizable chrome, supporting standard, utility, or lightweight types via the NativeWindow class. Applications can remove system chrome for custom designs, including transparency and non-rectangular shapes, and handle multi-window scenarios where owned windows remain in front of a master window. Drag-and-drop operations are facilitated through the NativeDragManager , enabling seamless interaction between application windows and the desktop. System tray (or ) integration is achieved by minimizing windows to the system tray on Windows or on macOS using NativeApplication properties. File system access in AIR grants full read/write permissions to local directories and files via the File class, permitting operations like creating, deleting, and modifying content without user prompts for standard locations. Drag-and-drop from the desktop to the application is supported using the drag-and-drop API, which handles file transfers in formats like FileList for multiple items. Clipboard operations are managed through the Clipboard class, allowing of text, images, and files between the application and the OS clipboard. Printing capabilities enable direct access to system printers using the PrintJob class, which captures display content or offscreen bitmaps and paginates output for high-quality prints. Desktop notifications and alerts can be implemented via lightweight NativeWindow instances that appear as pop-ups or , with support for updating / icons to indicate new events or counts through NativeApplication APIs. updates allow visual cues, such as unread message counts, on the application icon in the system tray or . Networking in AIR supports full socket programming with TCP and UDP via Socket and DatagramSocket classes, including secure connections over using URLLoader with SSL/TLS. Peer-to-peer communication is enabled through RTMFP for real-time media and exchange, facilitating low-latency connections like video streaming or multiplayer gaming without a central server. These features ensure AIR applications can handle robust, secure network interactions comparable to native desktop software. A key enhancement for desktop USB integration was introduced in AIR 2.0 in June 2010, with the allowing detection and mounting of removable storage devices for seamless file access.

Mobile Capabilities

Adobe AIR introduced mobile support with version 2.5 in November 2010, enabling deployment to Android devices and initial compatibility with through enhanced runtime capabilities for touch-enabled hardware. This release laid the foundation for cross-platform mobile applications by integrating device-specific APIs for sensors and input. In June 2011, AIR 2.7 extended these features with significant performance optimizations for , including up to four times faster rendering in CPU mode, allowing smoother execution on iPhones and iPads. AIR provides robust support for touch and gesture interactions on mobile devices, essential for intuitive user interfaces on smartphones and tablets. Developers can handle single-touch events via the TouchEvent class, while multitouch input—such as simultaneous finger contacts—is managed through the flash.ui.Multitouch class by setting the inputMode property to TOUCH_POINT or GESTURE. Gesture recognition, including rotations, pans, and zooms, is facilitated by GestureEvent and TransformGestureEvent, enabling applications to interpret OS-processed multi-touch sequences without excessive resource overhead. These APIs ensure compatibility across Android and iOS, though performance considerations recommend fallback to mouse events for simpler interactions to optimize battery life and CPU usage. Access to mobile hardware sensors and peripherals is facilitated through dedicated ActionScript APIs, allowing applications to leverage device capabilities beyond standard web content. The Accelerometer class from the flash.sensors package captures motion data in three dimensions (x, y, z axes), updating at a configurable rate to detect tilts, shakes, or orientation changes for features like or gaming controls. Geolocation services, via the Geolocation class in flash.sensors, provide GPS-based position data, including latitude, longitude, altitude, and accuracy, subject to user permission prompts on both Android and . For media capture, the Camera class supports access to front- and rear-facing cameras on mobile devices, enabling video recording with encoding options, while the Microphone class handles audio input with enhanced noise suppression via getEnhancedMicrophone() for real-time applications like video calls. Permissions for these features must be declared in the application descriptor file, with runtime checks like isSupported ensuring graceful fallbacks. Orientation handling and fullscreen modes adapt AIR applications to mobile form factors, supporting dynamic adjustments to device rotation. The Stage class's autoOrients property enables automatic rotation based on device tilt, reorienting the entire interface—including the —while developers can lock to specific orientations like or using setAspectRatio(). Fullscreen immersive modes are configured via publish settings in tools like Animate, hiding system UI elements for tablet or phone experiences, with support for auto-launch in the device's current orientation when set to "Auto." These features ensure responsive layouts without manual recalibration, though excessive rotations may impact performance on lower-end devices. Background services and multitasking in AIR are constrained by platform policies, prioritizing resource conservation on battery-powered mobiles. On Android, applications support true multitasking, continuing execution when minimized, with events like Event.DEACTIVATE signaling background transitions for tasks such as data syncing. limits this to specific modes like audio playback or location updates, suspending apps otherwise to UIApplicationState.Background, though silent push notifications can invoke the app via the InvokeEvent from NativeApplication. icons on app launchers—displaying unread counts—are managed through push payloads on (via ) and Android (via ), with AIR handling receipt but requiring native extensions for full integration; silent updates enable background fetches without user alerts. Packaging AIR applications for mobile app stores involves generating platform-specific bundles with mandatory certificate signing for security and distribution. For iOS, the AIR Developer Tool (ADT) produces .IPA files, which bundle the app binary, resources, and provisioning profile; signing uses an iOS distribution certificate from Apple Developer Program, applied via -storetype pkcs12 options in the descriptor. Android packaging supports .APK for direct installation or .AAB for Google Play submission, requiring a keystore certificate valid until at least 2033; the Deployment tab in Animate or ADT commands like -target apk handle signing with -storetype pkcs12 for release builds. Both platforms enforce to verify authenticity, with debug variants using self-signed certificates for testing.

Graphics and Multimedia Support

Adobe AIR provides robust support for 2D through its ActionScript-based drawing , which enables developers to create vector shapes, lines, and curves programmatically using the class. This allows for dynamic rendering of scalable vector content, such as custom UI elements or animated illustrations, by specifying paths with methods like lineTo(), curveTo(), and beginFill(). For applications built with and , AIR leverages the to handle 2D vector drawing and manipulation, offering compatibility with standard web technologies for interactive . Additionally, AIR supports manipulation via the BitmapData class, which permits pixel-level operations like copying, scaling, and applying transformations, while built-in filters—such as blur, glow, , and —enhance display objects for without requiring external libraries. For 3D graphics, AIR introduced the Stage3D API in version 3.0 in 2011, delivering low-level access to GPU-accelerated rendering for complex scenes composed of triangles as the primary primitive. This API abstracts underlying graphics hardware through a programmable pipeline similar to , utilizing on macOS, on Windows, and on mobile platforms to enable efficient 3D transformations, shading, and texturing. Developers can request a Context3D instance via Stage3D to manage vertex and fragment shaders written in Adobe Graphics Assembly Language (AGAL), supporting advanced effects like lighting and depth buffering. Frameworks such as Away3D for full and Starling for 2D-optimized graphics have been specifically adapted to leverage Stage3D, providing higher-level abstractions while maintaining in AIR applications. AIR's multimedia capabilities include hardware-accelerated video playback through the StageVideo , which supports full-screen mode for immersive viewing by scaling content to the entire display while preserving quality. It handles H.264-encoded video within MPEG-4 containers (such as MP4 and F4V files), enabling smooth streaming and playback of high-definition content with low latency. Audio support encompasses formats like for compressed playback and AAC/HE-AAC for higher-fidelity streaming, integrated via the Sound and NetStream classes for synchronization with video or standalone use in applications. For real-time communication, AIR facilitates WebRTC integration primarily through /JS content or native extensions, allowing audio and video exchange in hybrid web-native apps. Overall, Stage3D and related enhancements deliver up to 1000x faster rendering performance compared to prior software-based methods, significantly boosting frame rates for graphics-intensive AIR applications on supported hardware.

Native Extensions and Integration

Adobe AIR Native Extensions (ANEs) provide a framework for developers to integrate platform-specific native code into AIR applications, enabling access to operating system APIs and hardware features not exposed by the core AIR runtime. Introduced with AIR 3.0 in October 2011, this framework allows the creation of extensions using languages such as C, C++, Objective-C for iOS and macOS, and Java for Android, which are bridged to ActionScript via a standardized API. These extensions are particularly useful for implementing features like in-app purchases through iOS's StoreKit framework, connectivity for device pairing, access to advanced sensors such as accelerometers or gyroscopes on mobile platforms, and custom native UI controls that enhance user interfaces beyond AIR's built-in capabilities. By compiling native code into platform-specific libraries, ANEs allow AIR apps to leverage low-level OS functionalities while maintaining cross-platform compatibility where possible. ANEs are distributed as .ane files, which are ZIP archives containing the ActionScript library (typically a SWC file), native binaries for each supported platform, and an XML descriptor defining the extension's metadata, permissions, and initialization points. Prior to 2020, many community-developed ANEs were shared via Adobe's ecosystem, including forums and third-party marketplaces; following Adobe's transition of AIR to HARMAN, distribution has shifted to GitHub repositories and dedicated developer portals maintained by HARMAN and contributors like Distriqt. Security considerations for ANEs emphasize a , as extensions operate within the same process as the AIR application and inherit its permissions without additional sandboxing. Developers can optionally sign ANEs with digital certificates to verify authenticity and integrity, though the primary signing is handled by the enclosing AIR application's certificate. The Captive Runtime feature, which embeds the AIR runtime directly into the application package, further supports secure distribution of ANE-enabled apps by eliminating reliance on a separately installed runtime, reducing potential vulnerabilities from external updates. As of 2025, the community has developed over 100 ANEs, including specialized ones for augmented reality (AR) and virtual reality (VR) integrations, such as those enabling access to ARKit on iOS or ARCore on Android, reflecting ongoing adoption for immersive applications.

Platform Availability

Desktop Platforms

Adobe AIR provides runtime support for desktop applications on several major operating systems, enabling cross-platform deployment with consistent performance across environments. The framework's compatibility emphasizes modern architectures, with ongoing updates from HARMAN ensuring alignment with current OS developments. On Windows, Adobe AIR supports 10 and later, encompassing both 32-bit and 64-bit architectures, up to Windows 11. The latest runtime, version 51.x, maintains compatibility with these platforms through bundled installers that integrate seamlessly with the OS. Developers are recommended to use the bundling option for application distribution to avoid reliance on shared runtimes, which are still provided but not advised for new deployments. As of AIR SDK 51.2.2.3 (August 2025), builds use 14.0 Update 3, compatible with +. For macOS, support begins with version 10.13 (High Sierra) and extends to the latest releases, limited to 64-bit applications. Intel-based systems run natively, while (ARM) devices utilize Rosetta 2 for compatibility, with universal binaries introduced in AIR 33.1 (2021) to facilitate smoother transitions and dual-architecture execution. Distribution of AIR applications on macOS requires notarization by Apple to meet security standards, ensuring approval and user trust. The runtime is available as a 64-bit installer, with bundling preferred over shared installations. Linux support for AIR initially concluded with version 2.6 in 2011, as Adobe shifted focus to mobile platforms, leaving legacy .deb packages for earlier distributions like . However, under HARMAN's stewardship, support has been reinstated and expanded; the current runtime (51.x) accommodates x86_64 (built for 16 compatibility) and arm64 (requiring 2.34+, 22 compatibility), delivered via zip archives rather than shared runtimes. GTK3 is utilized for UI rendering, though features like StageWebView remain unavailable. The AIR runtime is installed via standalone downloads from the official HARMAN website, with options for Windows (.exe), macOS (.dmg), and Linux (zip). An integrated auto-update mechanism notifies users of new versions and facilitates seamless upgrades when launching applications, reducing manual intervention for end-users.

Mobile and Device Platforms

Adobe AIR provides support for mobile development on Android operating systems version 5.0 and later (API level 21 and higher), encompassing smartphones, tablets, and foldable devices. Applications are distributed as .APK or .AAB files, with signing and packaging options integrated through Android Studio for compliance with Google Play Store requirements. As of AIR SDK 51.2.2.3 (August 2025), the target SDK is 34. For iOS, Adobe AIR targets devices running iOS 12.0 and later on iPhone and iPad hardware. Development involves packaging applications as .IPA files using Xcode, which is mandatory for building and submitting to the Apple App Store. iOS integration employs UIKit bridging to enable native UI components within AIR applications. As of AIR SDK 51.2.2.3 (August 2025), it uses iPhoneOS SDK 18.2 with Xcode 16.2; 32-bit iOS support is discontinued. Hardware requirements for mobile AIR applications include a minimum of 1 GB RAM, with GPU essential for advanced features like Stage3D rendering. Support for smartwatches ended after 2020, while TV platforms ( 12.0 and later) remain supported. The captive runtime feature embeds the AIR runtime directly into the application bundle, facilitating offline installation and deployment without relying on a separately downloaded runtime, which can streamline by reducing additional downloads. On Android, AIR Native Extensions (ANEs) utilize the Android Native Development Kit (NDK) for accessing low-level native functionality and optimizing performance. Mobile feature APIs, such as those for touch gestures and sensors, extend AIR's capabilities on these platforms for enhanced user interactions.

Application Development

Tools and SDK

The Adobe AIR SDK is a free downloadable provided by HARMAN, available from the official website at airsdk.harman.com, enabling developers to build and package cross-platform applications for desktop and mobile devices. It includes core components such as the ActionScript Compiler (ASC 2.0) for compiling 3.0 code into files, the AIR Developer Tool (ADT) for packaging applications into installable formats like APK or IPA, and support for emulators to test applications on simulated environments without physical devices. The latest version, 51.2.2.5 released in October 2025, includes the AIR (apm), a utility for managing application dependencies, creating descriptor files, and handling libraries and extensions to streamline development workflows. For integrated development environments (IDEs), (formerly Flash Professional, part of the Creative Cloud suite) supports visual design and authoring of SWF-based AIR applications with timeline-based animation tools and direct export to AIR formats. The SDK provides command-line build capabilities for and MXML projects targeting AIR, allowing developers to compile and package applications without a graphical interface, particularly useful for automated builds. Additionally, extensions, such as the & MXML language support, enable JavaScript-based AIR development with features like , , and integration with the AIR runtime. Supporting utilities within the AIR SDK include the AIR Simulator for and testing of application behavior across platforms, certificate tools integrated into ADT for generating and managing digital signing certificates to ensure secure app distribution, and the AIR Debug Launcher (ADL) for runtime inspection, allowing developers to execute and debug applications directly from without full packaging. HARMAN maintains ongoing updates through open repositories, such as the Adobe-Runtime-Support project, where developers can report bugs, track issues, and contribute to the ecosystem. Community forums hosted at airsdk.dev facilitate discussions, troubleshooting, and sharing of best practices among AIR developers. In 2020, the AIR SDK was decoupled from Adobe's Creative Cloud distribution model, shifting to standalone downloads under HARMAN's stewardship, with certain elements like tools and runtimes incorporating open-source contributions for broader accessibility.

ActionScript-Based Development

ActionScript-based development for Adobe AIR applications primarily involves creating SWF-based content using (AS3), often in conjunction with tools like or the Flex framework. Developers typically begin by designing visual assets and user interfaces in , exporting them as files for integration into the application. The workflow then proceeds to writing AS3 code or MXML components, compiling them using the Flex SDK's compiler (mxmlc or compc), and finally packaging the application into an AIR installer (.air or .exe) via the AIR Developer Tool (ADT) command-line utility. Key APIs in enable core functionalities tailored to desktop and mobile environments. The flash.display package provides classes for building and managing user interfaces, such as Sprite and Stage for rendering graphics and handling display lists. For local , the flash.filesystem package offers File and FileStream classes to access the application's storage directory and read/write files securely. Networking capabilities are supported through the flash.net package, including Socket for custom TCP connections and URLLoader for HTTP requests, allowing AIR apps to communicate with remote servers. Best practices emphasize to create responsive applications, where developers register listener functions using the addEventListener() method on event targets to handle user interactions, timers, or system changes without blocking the main thread. Effective management of the application lifecycle is crucial; for instance, listening to NativeApplication's Event.ACTIVATE and Event.DEACTIVATE events allows pausing animations or saving state during focus changes, ensuring smooth transitions and . Code organization, such as placing scripts in dedicated classes or external AS files linked via Animate, promotes and . Debugging in AIR integrates seamlessly with Animate's built-in tools, where developers can launch the AIR Debug Launcher (ADL) to test applications in a debug environment, setting breakpoints in the Actions panel to pause execution and inspect variables via the Variables panel. Trace statements, invoked with the global trace() function, output debugging information to the console or ADL window for quick verification of logic flow. Remote inspection is supported by with debugging enabled in Animate's settings, allowing connection to a running AIR app on another device using the Debug Flash Player for cross-platform troubleshooting. A representative example is constructing a desktop note-taking application with local SQLite persistence, leveraging AIR's built-in SQL support. Developers create a simple UI with text input fields using flash.display components, then use the flash.data.SQLConnection class to open a database file in the application storage directory via flash.filesystem.File. SQL statements executed through SQLStatement handle inserting new notes (e.g., title and content) and querying/retrieving them for display, ensuring data persists across sessions without network dependency. The Flex SDK facilitates compilation of such AS3 code into a SWF, packaged via ADT for distribution.

HTML and JavaScript Development

Adobe AIR enables developers to create cross-platform applications using standard web technologies, allowing the construction of user interfaces and logic with , CSS, and . The workflow involves authoring these files in any or IDE, incorporating AIR-specific APIs to access native capabilities such as operations or networking, and then packaging the assets into a distributable .air file via the AIR SDK's Application Descriptor file and the ADT packaging tool. This approach maintains compatibility with practices while extending functionality to desktop and mobile environments. The rendering engine in AIR is based on , the open-source layout engine also used in , providing a complete browser-like environment with an HTML renderer, (DOM), and interpreter. This pre-Chromium implementation supports ECMAScript 5 (ES5) standards natively, enabling features like strict mode and handling, while polyfills can extend compatibility to modern constructs beyond ES5. Developers must account for the engine's fixed version, which does not receive ongoing updates, potentially requiring workarounds for newer CSS or elements. Key APIs in AIR are exposed through the air namespace, simplified via the optional AIRAliases.js script, granting access to runtime features without deep package navigation. For file input/output, the air.File class allows reading and writing to the local ; for example:

javascript

var file = new air.File("C:/example.txt"); var stream = new air.FileStream(); stream.open(file, air.FileMode.WRITE); stream.writeUTFBytes("Hello, AIR!"); stream.close();

var file = new air.File("C:/example.txt"); var stream = new air.FileStream(); stream.open(file, air.FileMode.WRITE); stream.writeUTFBytes("Hello, AIR!"); stream.close();

Networking is handled by air.URLRequest for HTTP communications, supporting both synchronous and asynchronous requests to remote servers. Event management and application lifecycle are controlled via air.NativeApplication, which dispatches events like invoke for command-line arguments or exiting for cleanup. is facilitated by air.Introspector, a console-like tool that provides runtime inspection, error logging, and script execution monitoring when included in development builds. This development paradigm offers significant advantages for web developers, as it permits the reuse of familiar tools, frameworks, and libraries such as or , easing the transition from browser-based projects to native desktop or mobile applications without learning proprietary languages. By embedding within AIR's sandboxed environment, applications gain offline capabilities, local data persistence, and hardware integration while retaining web-scale responsiveness. A representative example is adapting a web dashboard for data visualization into an AIR application: the core /JS/CSS structure remains intact for rendering charts via libraries like , while local storage is enhanced by combining browser APIs like IndexedDB for temporary caching with air.File for persistent native file exports, enabling offline access and seamless synchronization upon reconnection.

References

  1. https://helpx.adobe.com/animate/using/publishing-adobe-air-desktop.html
  2. https://airsdk.harman.com/
  3. https://blog.adobe.com/en/publish/2019/05/30/the-future-of-adobe-air
  4. https://airsdk.dev/
  5. https://airsdk.dev/docs/development/html-content-in-air/about-the-html-environment/overview-of-the-html-environment
  6. https://airsdk.dev/news
  7. https://www.cnet.com/tech/services-and-software/adobe-ponies-up-for-apollo/
  8. https://www.networkcomputing.com/data-center-networking/adobe-apollo-gets-new-name-beta-release
  9. https://jacobfilipp.com/DrDobbs/articles/DDJ/2007/0711/071001og01/071001og01.html
  10. https://www.cbsnews.com/news/adobe-air-takes-productivity-offline/
  11. https://www.wired.com/2008/03/adobe-releases-air-for-linux-sees-better-linux-apps-on-horizon/
  12. https://www.infoq.com/news/2008/02/air-1.0-overview/
  13. https://www.crn.com/news/blogs/198001827/adobe-woos-web-developers-with-apollo-alpha
  14. https://www.infoworld.com/article/2207973/adobe-apollo-flex-betas-go-public.html
  15. https://www.infoq.com/news/2008/02/air-flex-release/
  16. https://knowledge.wharton.upenn.edu/podcast/knowledge-at-wharton-podcast/kevin-lynch-on-adobes-air-extending-the-web-beyond-the-browser/
  17. https://techcrunch.com/2009/01/29/adobe-air-is-flying-100-million-installations-accounted-for/
  18. https://www.adobe.com/content/dam/cc/en/investor-relations/pdfs/ADBE-10K-FY08-FINAL.pdf
  19. https://download.cnet.com/ebay-desktop/3000-6905_4-10837414.html
  20. https://www.engadget.com/2009-03-05-beta-beat-tweetdeck-ripe-with-potential.html
  21. https://www.theatlantic.com/technology/2013/03/tweetdeck-2008-2013/317756/
  22. https://www.eweek.com/cloud/adobe-advances-flash-platform-with-new-air-cloud-flex-solutions/
  23. https://www.mikechambers.com/blog/2008/11/17/adobe-air-15-is-out/
  24. https://techcrunch.com/2009/11/16/adobe-flash-player-10-1-air-2-0/
  25. https://www.adobe.com/support/documentation/en/air/2/releasenotes_users.html
  26. https://www.altoros.com/blog/air-3-0-migration-from-flex-to-mobile-with-less-limitations/
  27. https://kpdq.com/tech-wednesday/adobe-flash-is-dead
  28. https://github.com/airsdk
  29. https://airsdk.harman.com/faq
  30. https://airsdk.dev/docs
  31. https://catalogimages.wiley.com/images/db/pdf/9780470390443.excerpt.pdf
  32. https://airsdk.dev/docs/development/html-content-in-air/about-the-html-environment
  33. https://www.globalsign.com/en/code-signing-certificate/adobe-air
  34. https://airsdk.dev/reference/actionscript/3.0/
  35. https://airsdk.dev/docs/development/html-content-in-air/about-the-html-environment/air-and-webkit
  36. https://airsdk.dev/docs/development/appendixes/sql-support-in-local-databases
  37. https://github.com/riadvice/AlivePDF
  38. https://airsdk.dev/docs/development/rich-media-content/working-with-video/understanding-video-formats
  39. https://airsdk.dev/docs/development/html-content-in-air/programming-html-and-javascript-in-air
  40. https://airsdk.dev/docs/development/client-system-interaction/working-with-air-native-windows/basics-of-native-windows-in-air
  41. https://airsdk.dev/docs/development/user-interaction/drag-and-drop-in-air
  42. https://airsdk.dev/docs/development/files-and-data/working-with-the-file-system
  43. https://airsdk.dev/docs/development/user-interaction/copy-and-paste/reading-from-and-writing-to-the-system-clipboard
  44. https://airsdk.dev/docs/development/client-system-interaction/printing/basics-of-printing
  45. https://airsdk.dev/docs/development/networking-and-communication/basics-of-networking-and-communication
  46. https://airsdk.dev/docs/development/networking-and-communication/sockets
  47. https://airsdk.dev/docs/development/user-interaction/touch-multitouch-and-gesture-input
  48. https://airsdk.dev/docs/development/client-system-interaction/geolocation
  49. https://airsdk.dev/reference/actionscript/3.0/flash/media/Microphone.html
  50. https://airsdk.dev/docs/development/display/display-programming/stage-orientation
  51. https://helpx.adobe.com/animate/using/publishing-air-android-applications.html
  52. https://airsdk.dev/docs/development/client-system-interaction/application-lifecycle
  53. https://helpx.adobe.com/animate/using/packaging-applications-air-ios.html
  54. https://airsdk.dev/docs/building/air-developer-tool/commands/package
  55. https://airsdk.dev/docs/building/air-developer-tool/option-sets/code-signing-options
  56. https://airsdk.dev/docs/development/display/using-the-drawing-api
  57. https://helpx.adobe.com/animate/using/creating-publishing-html5-canvas-document.html
  58. https://airsdk.dev/docs/development/display/working-with-bitmaps
  59. https://airsdk.dev/docs/development/display/filtering-display-objects/creating-and-applying-filters
  60. https://airsdk.dev/reference/actionscript/3.0/flash/display3D/Context3D.html
  61. https://stackoverflow.com/questions/19551141/does-stage3d-use-opengl-or-direct3d-when-on-windows
  62. https://airsdk.dev/docs/development/rich-media-content/working-with-video/playing-video-in-full-screen-mode
  63. https://www.droid-life.com/2011/09/21/adobe-to-introduce-3d-games-and-cross-platform-hd-video-with-flash-player-11-and-air-3/
  64. https://www.cnet.com/tech/computing/adobe-releases-flash-11-air-3-0/
  65. https://help.adobe.com/en_US/air/extensions/air_extensions.pdf
  66. https://community.adobe.com/t5/air-discussions/not-supported-native-extensions-profile/td-p/5488491
  67. https://community.adobe.com/t5/air-discussions/air-native-extensions-includes-plist/td-p/5589711
  68. https://stackoverflow.com/questions/12907237/captive-runtime-bundle-with-air-native-extension
  69. https://github.com/airnativeextensions
  70. https://www.kickstarter.com/projects/1836143618/augmented-reality-air-native-extension
  71. https://airsdk.dev/docs/basics/install/windows
  72. https://airsdk.harman.com/api/versions/51.2.1.1/release-notes/Release_Notes_AIR_SDK_51.2.1.pdf
  73. https://airsdk.harman.com/api/versions/51.2.2.3/release-notes/Release_Notes_AIR_SDK_51.2.2.pdf
  74. https://airsdk.harman.com/api/versions/33.1.1.533/release-notes/Release_Notes_AIR_SDK_33.1.1.533.pdf
  75. https://ubuntuhandbook.org/index.php/2013/07/install-adobe-air-linux-mint-32-64-bit/
  76. https://airsdk.harman.com/api/versions/51.2.0.2/release-notes/Release_Notes_AIR_SDK_51.2.0.pdf
  77. https://airsdk.harman.com/download
  78. https://airsdk.harman.com/api/versions/50.2.1.1/release-notes/Release_Notes_AIR_SDK_50.2.1.pdf
  79. https://airsdk.harman.com/api/versions/51.1.1.4/release-notes/Release_Notes_AIR_SDK_51.1.1.pdf
  80. https://airsdk.dev/docs/building/application-descriptor-files/elements/android
  81. https://airsdk.harman.com/api/versions/51.1.3.12/release-notes/Release_Notes_AIR_SDK_51.1.3.pdf
  82. https://airsdk.dev/docs/basics/install-apm
  83. https://helpx.adobe.com/animate/kb/get-started-with-latest-airsdk.html
  84. https://flex.apache.org/community-3rdparty.html
  85. https://royale.apache.org/ides/
  86. https://airsdk.dev/docs/building/air-debug-launcher
  87. https://github.com/airsdk/Adobe-Runtime-Support
  88. https://airsdk.dev/community
  89. https://airsdk.dev/docs/development
  90. https://airsdk.dev/docs/development/core-actionscript-classes/handling-events/event-listeners
  91. https://airsdk.dev/reference/actionscript/3.0/flash/desktop/NativeApplication.html
  92. https://helpx.adobe.com/animate/using/best-practices-organizing-actionscript-application.html
  93. https://helpx.adobe.com/animate/using/debugging-actionscript-3-0.html
  94. https://airsdk.dev/docs/development/files-and-data/working-with-local-sql-databases-in-air
  95. https://airsdk.dev/docs/development/html-content-in-air/programming-html-and-javascript-in-air/accessing-air-api-classes-from-javascript
  96. https://www.oreilly.com/library/view/adobe-air-for/9780596518370/ch01.html
  97. https://www.sitepoint.com/learn-adobe-air-part-1/
Add your contribution
Related Hubs
User Avatar
No comments yet.