Apache Flex
Apache Flex
Main page
2094840

Apache Flex

logo
Community Hub0 subscribers
Read side by side
Apache Flex
View on Wikipedia
from Wikipedia
Apache Flex
DevelopersApache Software Foundation and Adobe Systems
Initial releaseJune 20, 2004; 21 years ago (2004-06-20)
Stable release
4.16.1 / November 23, 2017; 8 years ago (2017-11-23)
RepositoryFlex Repository
Written inActionScript, Java[1]
Operating systemWindows, macOS, Linux, Android, iOS, BlackBerry Tablet OS
Available inVarious between websites
TypeSoftware development kit application
License2012: Apache-2.0
2008: MPL-1.1
WebsiteApache Flex and Adobe Flex

Apache Flex, formerly Adobe Flex, is a software development kit (SDK) for the development and deployment of cross-platform rich web applications based on the Adobe Flash platform. Initially developed by Macromedia and then acquired by Adobe Systems, Adobe donated Flex to the Apache Software Foundation in 2011[2] and it was promoted to a top-level project in December 2012.

The Flex 3 SDK was released under the MPL-1.1 license in 2008. Consequently, Flex applications can be developed using standard Integrated development environments (IDEs), such as IntelliJ IDEA, Eclipse, the free and open source IDE FlashDevelop, as well as the proprietary Adobe Flash Builder.

In 2014, the Apache Software Foundation started a new project called FlexJS to cross-compile ActionScript 3 to JavaScript to enable it to run on browsers that do not support Adobe Flash Player and on devices that do not support the Adobe AIR runtime.[3][4] In 2017, FlexJS was renamed to Apache Royale.[5][6] The Apache Software Foundation describes the current iteration of Apache Royale as an open-source frontend technology that allows a developer to code in ActionScript 3 and MXML and target web, mobile devices and desktop devices on Apache Cordova all at once.[7] Apache Royale is currently in beta development stage.[8]

Overview

[edit]

Flex uses MXML to define UI layout and other non-visual static aspects, ActionScript to address dynamic aspects and as code-behind, and requires Adobe AIR or Flash Player at runtime to run the application.[9]

Versions

[edit]

Macromedia Flex 1.0 and 1.5

[edit]

Macromedia targeted the enterprise application development market with its initial releases of Flex 1.0 and 1.5. The company offered the technology at a price around US$15,000 per CPU.[10] Required for deployment, the Java EE application server compiled MXML and ActionScript on-the-fly into Flash applications (binary SWF files). Each server license included 5 licenses for the Flex Builder IDE.

Adobe Flex 2

[edit]
Adobe Flex (old icon)

Adobe significantly changed the licensing model for the Flex product line with the release of Flex 2. The core Flex 2 SDK, consisting of the command-line compilers and the complete class library of user interface components and utilities, was made available as a free download. Complete Flex applications can be built and deployed solely with the Flex 2 SDK, which contains no limitations or restrictions compared to the same SDK included with the Flex Builder IDE.

Adobe based the new version of Flex Builder on the open source Eclipse platform. The company released two versions of Flex Builder 2, Standard and Professional. The Professional version includes the Flex Charting Components library.

Enterprise-oriented services remain available through Flex Data Services 2. This server component provides data synchronization, data push, publish-subscribe and automated testing. Unlike Flex 1.0 and 1.5, Flex Data Services is not required for the deployment of Flex applications.

Coinciding with the release of Flex 2, Adobe introduced a new version of the ActionScript programming language, known as Actionscript 3, reflecting the latest ECMAScript specification. The use of ActionScript 3 and Flex 2 requires version 9 or later of the Flash Player runtime. Flash Player 9 incorporated a new and more robust virtual machine for running the new ActionScript 3.

Flex was the first Macromedia product to be re-branded under the Adobe name.

Adobe Flex 3

[edit]

On April 26, 2007, Adobe announced their intent to release the Flex 3 SDK (which excludes the Flex Builder IDE and the LiveCycle Data Services) under the terms of the Mozilla Public License.[11] Adobe released the first beta of Flex 3, codenamed Moxie, in June 2007. Major enhancements include integration with the new versions of Adobe's Creative Suite products, support for AIR (Adobe's new desktop application runtime), and the addition of profiling and refactoring tools to the Flex Builder IDE.

Adobe Flash Builder and Flex 4

[edit]

Adobe released Flex 4.0 (code named Gumbo) on March 22, 2010.[12] The Flex 4 development environment is called Adobe Flash Builder,[13] formerly known as Adobe Flex Builder.

Some themes that have been mentioned by Adobe and have been incorporated into Flex 4 are as follows:

  • Design in Mind: The framework has been designed for continuous collaboration between designers and developers.
  • Accelerated Development: Be able to take application development from conception to reality quickly.
  • Horizontal Platform Improvements: Compiler performance, language enhancements, BiDirectional components, enhanced text (Flex 4 includes the new Text Layout Framework[14]).
  • Full Support for Adobe Flash Player 10 and above.
  • Broadening Horizons: Finding ways to make a framework lighter, supporting more deployment runtimes, runtime MXML.
  • Simpler skinning than the previous versions.
  • Integration with Adobe Flash Catalyst.
  • Custom templates

Flash Builder is available in two versions: Standard and Premium,[15] the premium adds the following features;

  • Testing tools
  • Memory and performance profilers
  • An automated testing harness to connect to all the leading testing tools
  • FlexUnit support
  • command-line build capability

Adobe Flash Builder 4.5 and Flex 4.5

[edit]

May 3, 2011, Adobe shipped Flash Builder 4.5 copying Flex 4.5 (SDK only) which delivers full support for building Flex and ActionScript applications for Google Android, as well as support for building ActionScript applications for BlackBerry Tablet OS and Apple iOS. An update to Flash Builder 4.5 and Flex 4.5 adds support for building Flex applications for BlackBerry Tablet OS and Apple iOS.

Flex 4.5 SDK delivers many new components and capabilities, along with integrated support in Flash Builder 4.5 and Flash Catalyst CS 5.5. With the Adobe Flex 4.5 SDK which is governed by three main goals:

  • Allow developers to use Flex for multiscreen application development
  • Further mature the Spark (skinning) architecture and component set which was introduced in Flex 4

Adobe Flex 4.6.0

[edit]

In November 2011, Adobe released Flex SDK update 4.6, with the following changes:

  • More Spark mobile components including: SplitViewNavigator, CalloutButton, Callout, SpinnerList, DateSpinner, and ToggleSwitch
  • Better performance
  • Updated platform support
  • Enhanced Tooling – Flash Builder 4.6
  • Text Enhancements

Apache Flex 4.8.0 - incubating

[edit]

Jul 25, 2012, Apache Flex community releases Flex 4.8.0-incubating and it as a parity release with Adobe Flex 4.6.0. This is the first release under the incubator of the Apache Software Foundation and represents the initial donation of Adobe Flex 4.6 by Adobe System Inc.[16]

Differences and highlights include:

  • Flex trademark issues are largely cleared up
  • Bug-tracking / issue-tracking system (JIRA) transferred from the Adobe bug tracker to Apache bug tracker
  • Mustela test suite is donated to Apache

Apache Flex 4.9.0

[edit]

Jan 11, 2013, Apache Flex community releases Flex 4.9.0. This is the first release since Apache Flex became a top level project of the Apache Software Foundation.[17]

Differences and highlights include:

  • New locales for Apache Flex including Australian, British, Canadian, Greek, Switzerland (German) and Portuguese
  • Apache Flex SDK can be compiled for any version of the Flash Player from 10.2 to 11.5
  • New PostCodeFormatter and PostCodeValidator classes for international postcode formatting and validation
  • New VectorList and VectorCollection classes for lists and collections of vectors
  • New version of the TLF (Text Layout Framework), the TLF 3.0.33 source code is now included as it is now part of the Apache Flex donation
  • Can use Java 7 to compile SDK (see README for instructions)
  • Many improvements and updates to Mustella tests
  • An SDK installer has also been created and is the recommended way of installing the Apache Flex SDK in an IDE
  • Various important bug fixes

Apache Flex 4.9.1

[edit]

Feb 28, 2013, Apache Flex community releases Flex 4.9.1. This was a minor update to 4.9.0.[18]

Apache Flex 4.10.0

[edit]

Aug 6, 2013, Apache Flex community releases Flex 4.10.0.[19]

Differences and highlights include:

  • Support for latest versions of Flash Player (up to 11.8) and AIR runtimes (up to 3.8)
  • Improved support for older Flash Player versions (down to 10.2)
  • Linux support
  • 15 new Spark components
  • Advanced telemetry support
  • Improved international support for dates
  • 480 dpi mobile skins
  • Over 200 bugs fixed

Apache Flex 4.11.0

[edit]

Oct 28, 2013, Apache Flex community releases Flex 4.11.0.[20]

Differences and highlights include:

  • Support for Flash Player 11.9 and AIR runtime 3.9
  • mx:AdvancedDataGrid and mx:DataGrid speed improvements
  • Updated OSMF to latest version
  • mobile datagrid component
  • 120 and 640 dpi mobile skins
  • Desktop callout component
  • Over 50 bugs fixed

Apache Flex 4.12.0

[edit]

Mar 10, 2014, Apache Flex community releases Flex 4.12.0.[21]

Differences and highlights include:

  • Support for Flash Player 12.0 and 13.0 beta and AIR runtime 4.0 and 13.0 beta[22]
  • Improved mobile memory usage/performance
  • Improved iPad and iOS7 support
  • mx:AdvancedDataGrid and mx:DataGrid performance improvements
  • New MaskedTextinput component
  • JSON support for ArrayCollection and ArrayList
  • Over 80 bugs fixed

Apache Flex 4.12.1

[edit]

May 3, 2014, Apache Flex community releases Flex 4.12.1[23]

Differences and highlights include:

  • Support for Flash Player 13.0 and AIR runtime 13.0
  • Fixed Adobe Flash Builder bug, which inserts an incorrect attribute while creating a new project that uses Apache Flex SDK
  • Extended mobile media query support
  • Over 20 bugs fixed

Apache Flex 4.13.0

[edit]

Jul 28, 2014, Apache Flex community releases Flex 4.13.0.[24]

Differences and highlights include:

  • Support for Flash Player 14.0 and AIR runtime 14.0[25]
  • FDB supports debugging ActionScript Workers
  • percentWidth for GridColumn
  • Add Chinese translations for all the installers of Flex
  • Over 30 bugs fixed

Apache Flex 4.14.0

[edit]

Jan 28, 2015, Apache Flex community releases Flex 4.14.0

Differences and highlights include:

  • iOS 7+ and Android 4.x+ mobile theme support
  • New Spark components skin: FlatSpark
  • Spark RichTextEditor
  • Native support for tables in TLF
  • Promises/A+
  • 54 bugs fixed

Apache Flex 4.15.0

[edit]

Jan 11, 2016, Apache Flex community release Flex 4.15.0[26]

Differences and highlights include:

  • Support for Flash Player 18, 19 and 20
  • Support for AIR 18, 19, 20
  • 30 reported bug fixes

Apache Flex 4.16.0

[edit]

Mar 14, 2017, Apache Flex community release Flex 4.16.0[27]

Differences and highlights include:

  • Support for Flash Player 21, 22, 23 and 24
  • Support for AIR 21, 22, 23 and 24
  • Support for FontAwesome 4.7
  • 37 reported bug fixes
[edit]

LiveCycle Data Services

[edit]
Main article: Flex Data Services

LiveCycle Data Services (previously called Flex Data Services) is a server-side complement to the main Flex SDK and Flash Builder IDE and is part of a family of server-based products available from Adobe. Deployed as a Java EE application, LiveCycle Data Services adds capabilities to Flex applications.

BlazeDS

[edit]

Previously available only as part of Adobe LiveCycle Data Services ES, Adobe plans to contribute the BlazeDS technologies to the community under the LGPL v3. BlazeDS gives Adobe developers free access to the remoting and messaging technologies developed by Adobe.

Concurrent with pre-release of BlazeDS, Adobe is publishing the AMF binary data protocol specification, on which the BlazeDS remoting implementation is based, and is attempting to partner with the community to make this protocol available for major server platforms.

Flex and ColdFusion

[edit]

Flex 2 offers special integration with ColdFusion MX 7. The ColdFusion MX 7.0.2 release adds updated Flash Remoting to support ActionScript 3, a Flex Data Services event gateway, and the Flex Data Services assembler. Flex Builder 2 also adds extensions for ColdFusion providing a set of wizards for RAD Flex development. A subset of Flex 1.5 is also embedded into ColdFusion MX 7 middleware platform, for use in the ColdFusion Flash forms feature. It is possible to use this framework to write rich web applications, although its intended purpose is for rich forms only.[citation needed]

Application Frameworks

[edit]
Main article: List of Flex frameworks

There are a number of application frameworks available which help the developer solve some common tasks and set up the application structure according to best practices.

Notable sites using Flex

[edit]

See also

[edit]

References

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

Apache Flex

View on Grokipedia
from Grokipedia
Apache Flex is an open-source application framework and software development kit (SDK) designed for building expressive, cross-platform applications that run consistently across browsers, desktops, and mobile devices using a single codebase.[1] Originally developed by Macromedia in 2004 as Flex and acquired by Adobe in 2005, the technology saw widespread adoption for creating rich internet applications (RIAs) that leveraged the Adobe Flash Player for web deployment.[2] In November 2011, Adobe announced its intention to donate Flex to the Apache Software Foundation (ASF) to ensure its long-term viability amid shifting priorities away from Flash.[2] The project entered the Apache Incubator on December 27, 2011, received the software grant from Adobe on January 17, 2012, and graduated to top-level ASF project status on December 19, 2012, with the release of Apache Flex SDK 4.9 as its first official version under Apache governance.[2] Key features of Apache Flex include its use of MXML, an XML-based declarative language for user interface layout, combined with ActionScript 3.0 (an ECMAScript-based scripting language) for application logic and behavior.[3] The framework supports compilation to SWF files for browser deployment via Flash Player (support ended in 2020), as well as to native installers for desktop and mobile platforms using Adobe AIR, targeting operating systems such as Windows, macOS, iOS, and Android.[1] Development tools compatible with Apache Flex encompass integrated development environments like Flash Builder (now Eclipse-based), Flash Develop, and IntelliJ IDEA, alongside text editors for lighter workflows.[3] Released under the Apache License 2.0, the project emphasizes productivity through reusable components, data binding, and styling via CSS-like mechanisms.[1] As of 2025, Apache Flex remains an active ASF project, though with reduced activity focused on maintenance rather than major innovations, following the deprecation of Flash technology. The latest SDK release, version 4.16.1, dates to November 2017, and for modern web applications without Flash, the community recommends transitioning to Apache Royale, a related project that transpiles ActionScript to JavaScript for HTML5 deployment.[1] Despite these shifts, Apache Flex continues to serve legacy applications and non-web targets, valued for its cross-platform code reuse and simplified deployment in enterprise environments.[4]

Introduction

Overview

Apache Flex is an open-source software development kit (SDK) designed for creating rich internet applications (RIAs) and cross-platform applications for web, mobile, and desktop environments. It enables developers to build expressive user interfaces using declarative MXML for layout and styling, combined with imperative ActionScript for application logic and behavior.[3] This framework supports a component-based development model, where reusable UI components such as buttons, forms, and data grids can be customized with skins, themes, and dynamic interactions to deliver consistent experiences across platforms.[3] The primary purpose of Apache Flex is to allow a single codebase to deploy applications to multiple targets, including web browsers via Adobe Flash Player (end-of-life December 31, 2020), mobile devices on iOS and Android through Adobe AIR, and desktop platforms like Windows and macOS.[3][5] Core components include the Flex SDK, which provides the compiler, runtime libraries, accessibility features, and an automation-testing framework, while optional integrated development environments (IDEs) such as Adobe Flash Builder offer enhanced tooling for productivity.[3] This cross-platform compatibility reduces development overhead by abstracting platform-specific details, enabling native-like performance and deployment without rewriting code for each environment.[3] Originating from Macromedia's Flex toolkit released in 2004, the project was acquired by Adobe Systems and later donated to the Apache Software Foundation in 2011, becoming a top-level Apache project in 2012.[6] The latest stable release, Apache Flex SDK 4.16.1, was issued in November 2017, with subsequent updates to the SDK installer facilitating easier access to the framework's components.[1]

Key Features

Apache Flex enables declarative user interface development through MXML, an XML-based language that allows developers to define layouts, components, and styling in a structured, tag-based format, which is then compiled alongside ActionScript code to produce applications. This approach simplifies the creation of complex interfaces by leveraging pre-defined components and declarative syntax, reducing the need for imperative code in UI construction.[3] The framework incorporates strong data binding mechanisms and adherence to model-view-controller (MVC) patterns, facilitating reactive user interfaces where changes in data models automatically update views without manual intervention. Built-in support for animations via classes like Animate in the spark.effects package, along with charting capabilities in the mx.charts package (including types such as AreaChart, BarChart, and PieChart), and advanced UI controls like the DataGrid for tabular data display and the AdvancedDataGrid for hierarchical data visualization, enhance developer productivity in building interactive and visually rich applications.[3][7][8][9][10] Apache Flex supports cross-platform compilation, targeting web browsers via SWF files (Flash Player end-of-life December 31, 2020), mobile devices through APK for Android and IPA for iOS using Adobe AIR, and desktop applications as EXE files on Windows or equivalent for other platforms.[3][5][11] It integrates seamlessly with web services via protocols like SOAP and REST, as well as offline capabilities enabled by the AIR runtime for native application deployment. Released under the Apache License 2.0, the framework permits free modification, distribution, and commercial use without restrictions. Performance is optimized through the runtime's just-in-time (JIT) compilation, which dynamically compiles ActionScript bytecode to native code for improved execution speed.[3][11][12]

History

Macromedia Foundations (2004–2005)

In 2004, Macromedia developed Flex as a framework to address the limitations of Java applets and early dynamic web technologies in delivering rich, interactive user interfaces for enterprise applications, aiming to enable developers to build more responsive web-based experiences without the performance issues and deployment complexities of applets.[13][14] Flex 1.0 was released on March 29, 2004, introducing MXML as a declarative, XML-based language for defining user interfaces and early elements that would influence ActionScript 3.0, with a focus on server-side compilation of MXML and ActionScript code into Flash SWF files for browser deployment.[14][15] The release targeted enterprise developers by providing tools for creating data-driven applications, including Flex Data Services for backend integration. In late 2004, Flex 1.5 was released in November, enhancing the platform with built-in charting components for data visualization, support for runtime shared libraries (RSLs) and SWC compilation, and the introduction of Flex Builder as an improved integrated development environment based on Eclipse for visual design and coding.[16][17] Key innovations in these early versions included a tag-based UI declaration in MXML reminiscent of HTML, which simplified layout and component assembly, alongside seamless integration with backends like ColdFusion via Flash Remoting and J2EE servers through Flex Data Services for real-time data binding and messaging.[18][19] Macromedia's acquisition by Adobe Systems, completed on December 3, 2005, for $3.4 billion in stock, marked the end of the Macromedia era and paved the way for Flex's rebranding and further evolution under Adobe.[20][21]

Adobe Development (2006–2011)

Following the acquisition of Macromedia by Adobe Systems in late 2005, Adobe rebranded the technology as Adobe Flex 2.0 and released it in June 2006, making the Flex SDK available for free download to broaden developer access.[22] This version introduced Flex Builder, an Eclipse-based integrated development environment that streamlined application creation, and added support for modular applications to enable efficient loading of components in large-scale rich internet applications (RIAs).[23] Additionally, Adobe provided a free single-CPU edition of Flex Data Services for enhanced data synchronization and collaboration features without server-side dependencies.[24] In February 2008, Adobe launched Flex 3.0, which focused on improving runtime performance through optimizations in the Flash Player and introduced advanced CSS styling for more customizable user interfaces.[25] Key enhancements included runtime shared libraries for module loading, reducing application size and load times for enterprise-scale deployments, along with built-in support for Adobe Integrated Runtime (AIR) to extend Flex applications to desktop environments.[26] These updates also integrated Flex Builder 3 with Adobe Creative Suite 3, providing new skinning templates compatible with Photoshop, Illustrator, Fireworks, and Flash for seamless asset import and workflow efficiency.[25] Adobe released Flex 4.0, codenamed Gumbo, on March 22, 2010, alongside Flash Builder 4, introducing the Spark component architecture designed for scalable, declarative user interfaces with improved skinning and layout flexibility.[27] This version incorporated FXG (Flash XML Graphics), a declarative format for vector graphics that facilitated integration with design tools, and previewed mobile development capabilities through Flash Builder "Burrito," an early access build supporting AIR-based apps for emerging platforms.[28] The Spark framework decoupled layouts from components, enabling features like 2D rotations, scalability, and around 30 new UI components to handle complex, responsive designs more effectively.[27] The Flex 4.5 release, codenamed Hero, arrived in April 2011 with Flash Builder 4.5, emphasizing native mobile packaging for iOS and Android devices via AIR, allowing developers to compile Flex apps into platform-specific installers without relying on browser plugins.[29] Subsequent updates in Flex 4.6, released in November 2011, extended this with hardware acceleration for smoother graphics rendering on mobile hardware and additional components for cross-platform functionality, including BlackBerry Tablet OS support. These advancements solidified Flex's role in mobile and desktop development through AIR, targeting diverse devices with consistent codebases.[30] Under Adobe's stewardship, Flex adopted a commercial focus, bundling Flash Builder with Creative Suite editions starting from CS3 to leverage Adobe's design ecosystem for professional workflows.[25] Enterprise adoption grew through integration with Adobe LiveCycle, enabling secure data services, forms processing, and business logic execution in Flex applications for sectors like finance and government.[31] By 2011, the Flash Platform—including Flex—had attracted over 3 million developers worldwide, reflecting peak usage amid expanding AIR deployments for desktop and mobile apps.[32]

Transition to Apache (2012–Present)

In November 2011, Adobe announced its decision to donate the Flex SDK and related technologies, including BlazeDS, to the Apache Software Foundation to ensure continued open-source development amid shifting priorities away from the Flash platform.[33] The donation process culminated in the submission of an incubation proposal on December 20, 2011, with the Incubator PMC vote starting on December 27, 2011, and approving Flex's entry into the Apache Incubator on December 30, 2011, marking the project's formal transition to open-source governance under Apache.[2] Adobe provided the initial software grant on January 17, 2012, enabling the community to begin building upon the donated codebase.[2] The Apache Flex project released its first incubating version, SDK 4.8.0, on July 25, 2012, establishing parity with Adobe's final Flex 4.6 release while incorporating early community-driven improvements.[34] Following this, the project graduated to top-level Apache status on December 19, 2012, reflecting successful incubation and broad community engagement.[2] The inaugural top-level release, SDK 4.9.0, arrived on December 27, 2012, with subsequent minor update 4.9.1 on February 28, 2013, both highlighting initial community contributions such as enhanced build tools and bug resolutions.[35][36] Subsequent key releases focused on runtime compatibility and stability. SDK 4.10.0, released August 6, 2013, introduced support for AIR 4 and later versions, enabling better mobile and desktop deployments.[37] This trend continued through 4.12.1 in May 2014, which added AIR 20+ compatibility for improved cross-platform application distribution.[2] In 2016, SDK 4.13.0 (July 28, 2014) and 4.14.0 (February 3, 2015) primarily addressed bug fixes and performance optimizations to maintain reliability.[38][39] Further updates included 4.15.0 (January 12, 2016) and 4.16.0 (March 14, 2017), incorporating runtime enhancements for evolving Flash Player versions.[40][41] The final stable SDK release, 4.16.1 on November 23, 2017, ensured compatibility with Flash Player 29 and AIR 29, solidifying support for legacy web and desktop applications.[1] Under Apache governance, established as a top-level project in late 2012, the community has emphasized maintenance over major innovation, with a Meritocracy-based model guiding contributions through committers and podlings.[42] Efforts have prioritized compatibility with Adobe AIR for non-browser deployments, allowing Flex applications to persist in enterprise and desktop environments despite browser plugin limitations.[43] After 2017, core SDK development stagnated, with the Apache Flex SDK Installer updated to version 3.3.2 in July 2018 to streamline setup by bundling compatible runtimes and frameworks, though no new SDK features were added.[2] This halt aligned with Adobe's end-of-life announcement for Flash Player on December 31, 2020, which deprecated browser-based Flex applications due to security and performance concerns.[5] As of 2025, active development remains limited, with the project focusing on legacy support, occasional tool updates like the Flex SDK Converter (version 1.1.0 in February 2023), and guidance for migrating to AIR-based or alternative frameworks.[1] Community activity centers on sustaining existing deployments rather than new features, amid the broader shift away from plugin-dependent technologies.[43]

Technical Architecture

Core Languages: MXML and ActionScript

Apache Flex primarily utilizes two core languages for application development: MXML, a declarative XML-based markup language, and ActionScript 3.0, an imperative object-oriented programming language. These languages work in tandem to separate UI declaration from business logic, enabling efficient creation of rich internet applications.[1] MXML serves as the declarative language for defining user interface components, layouts, states, and data bindings in Flex applications. It employs XML tags to represent visual elements, such as <s:VBox> for arranging child components in a vertical stack and <mx:Button> for interactive controls. MXML also supports embedding assets like images or stylesheets directly within tags and facilitates data binding through expressions enclosed in curly braces, for instance, {dataProvider} to link a list component to a dynamic data source. This approach allows designers and developers to focus on structure without delving into procedural code.[44] ActionScript 3.0, based on the ECMAScript standard, provides the imperative capabilities for handling application logic, event processing, and custom component implementation. As an object-oriented language, it supports classes, interfaces, packages, inheritance, and encapsulation, making it suitable for complex behaviors like user interactions and data manipulation. For example, developers can define event handlers in ActionScript to respond to button clicks or data changes, ensuring responsive application functionality.[1][44] The integration of MXML and ActionScript occurs through the Flex compilation process, where MXML declarations are transformed into equivalent ActionScript classes, allowing MXML to extend or interact with ActionScript code. Hybrid files with the .mxml extension can embed ActionScript directly via <script> tags, combining declarative UI with inline logic for concise development. This synergy enables, for instance, an MXML layout bound to an ActionScript data model, where changes in the model automatically update the UI via binding.[44][45] MXML originated with the release of Flex 1.0 in March 2004, providing an XML vocabulary for UI specification from the framework's inception. ActionScript 3.0 was introduced alongside Flex 2.0 in June 2006, replacing ActionScript 2.0 to deliver enhanced performance, stricter typing, and improved support for large-scale applications through its advanced virtual machine compatibility.[44] A representative example illustrates this integration in a simple application displaying a button that updates a label via data binding: 
<?xml version="1.0" encoding="utf-8"?>
<s:Application xmlns:fx="http://ns.adobe.com/mxml/2009"
               xmlns:s="library://ns.adobe.com/flex/spark"
               xmlns:mx="library://ns.adobe.com/flex/mx">
    <fx:Script>
        <![CDATA[
            import spark.events.IndexChangeEvent;
            
            [Bindable]
            public var message:String = "Hello, Flex!";
            
            protected function onButtonClick(event:MouseEvent):void {
                message = "Button clicked!";
            }
        ]]>
    </fx:Script>
    
    <s:VGroup horizontalCenter="0" verticalCenter="0">
        <s:Label text="{message}" />
        <s:Button label="Update Message" click="onButtonClick(event)" />
    </s:VGroup>
</s:Application>
In this code, the MXML defines a vertical layout (<s:VGroup>) containing a bound label and button, while the embedded ActionScript handles the click event to update the bound message property, demonstrating declarative UI tied to imperative logic.[45][44]

Compilation and Build Process

The Apache Flex SDK provides essential command-line tools for compiling applications, primarily the MXMLC compiler, which processes MXML files into ActionScript 3.0 code before invoking the ActionScript Compiler (ASC) to generate bytecode.[46] MXMLC serves as the main entry point for application compilation, handling inputs like .mxml, .as, and library dependencies, while ASC, based on the ASC 2.0 codebase donated by Adobe, focuses on compiling ActionScript into the final output.[47] The companion COMPC tool compiles reusable components and assets into SWC library files, which can then be linked into applications.[48] The standard build workflow begins with source code in MXML and ActionScript, which MXMLC compiles into a SWF file for web deployment or an SWC for libraries.[46] For desktop and mobile applications using Adobe AIR, the resulting SWF is packaged via the AIR Developer Tool (ADT) into an installable AIR file, with support for native extensions through ANE (AIR Native Extension) files that bundle platform-specific code.[49] This process ensures cross-platform consistency, as SWF outputs run in the Flash Player or AIR runtime, while SWC files promote modularity by encapsulating classes and resources without embedding them directly.[48] Configuration is managed through flex-config.xml, a central file in the SDK's frameworks directory that specifies paths to source code, libraries, themes, and optimization settings such as font embedding or metadata retention.[50] Developers can override defaults using command-line options like -load-config to include custom XML files, and the SDK supports incremental compilation via the -incremental flag, which recompiles only modified files to accelerate iterative development in large projects.[48] For advanced scenarios, modular compilation allows large applications to be split into separate SWF modules or leverage Runtime Shared Libraries (RSLs) to share common framework components across modules, reducing overall file sizes through options like -runtime-shared-libraries.[48] Post-Flash end-of-life, integration with the Apache Royale compiler— a fork of ASC 2.0—enables cross-compilation of Flex code to JavaScript outputs for modern web browsers, extending the build process beyond traditional SWF generation.[47] Common compilation errors include namespace conflicts, often arising from mismatched SDK versions or conflicting library paths, which can be resolved by verifying xmlns declarations in MXML and updating library-path options in flex-config.xml.[51] Runtime dependencies may trigger issues like unresolved imports or missing SWC linkages, typically addressed by ensuring all external libraries are included via -external-library-path and checking for version mismatches in the compiler output.[46] Strict mode (-strict=true, enabled by default) helps surface these during builds, preventing subtle runtime failures.[48]

Runtime and Deployment

Apache Flex applications traditionally run in the Adobe Flash Player runtime, which compiles applications into SWF files for deployment in web browsers. This runtime required a browser plugin and operated within a security sandbox model that restricted web-based applications from accessing local files, network sockets, or other system resources without explicit user permission or cross-domain policies, enhancing security for client-side execution. However, Adobe ended support for Flash Player on December 31, 2020, with major browsers blocking content starting January 12, 2021, rendering SWF-based deployments obsolete for new web projects.[52] For standalone and mobile deployment, Apache Flex leverages Adobe AIR, a cross-platform runtime that enables applications to run outside browsers with access to native device features such as file system operations, local notifications, camera/microphone integration, and geolocation services. AIR bundles the runtime with the application for self-contained distribution, supporting desktop platforms (Windows, macOS, Linux) and mobile (Android, iOS). The latest Apache Flex SDK 4.16.1 is compatible with recent AIR versions, such as AIR 51.2 from HARMAN (the current maintainer post-Adobe), allowing developers to target modern OS versions while aligning with Flex's compilation outputs.[1][53][43] Deployment targets include web via HTML wrappers embedding SWF files (now legacy), desktop executables (e.g., .exe for Windows, .dmg for macOS), and mobile packages (e.g., .apk for Android, .ipa for iOS) generated through AIR's packager tools. For mobile, applications can bundle the AIR runtime or rely on pre-installed versions, with iOS requiring runtime bundling due to App Store policies.[54][43] Performance in both runtimes emphasizes vector graphics rendering for scalable, resolution-independent visuals, with later Flash Player and AIR versions (10+) incorporating GPU acceleration via features like Stage Video and Stage3D for improved rendering of animations and media. Offline data persistence is handled through SharedObject, a local storage mechanism similar to cookies but capable of storing complex objects up to 100 KB by default, enabling stateful applications without server dependency. Following Flash Player's deprecation, Apache Flex development has shifted toward AIR-only deployments for new projects, with tools like AIR simulators and emulators facilitating testing across desktop and mobile environments without browser dependencies.[43][54]

Development Ecosystem

Integrated Development Environments

Adobe Flash Builder, formerly known as Flex Builder, is an Eclipse-based integrated development environment (IDE) provided by Adobe for developing Flex applications. It offers visual designers for creating user interfaces with MXML, intelligent code completion for ActionScript and MXML, interactive debugging capabilities, and a built-in profiler for performance analysis.[55][56] The last version, 4.7 released in 2013, remains compatible with Apache Flex SDK versions up to 4.14.0 through manual installation of the SDK and configuration in the IDE's preferences.[57] Community-supported plugins extend IDE functionality for Apache Flex development in environments like Eclipse and IntelliJ IDEA. For Eclipse, the Flex Development Tools (FDT) plugin provides syntax highlighting, auto-completion for MXML and ActionScript, code navigation, and deployment tools to compile and package applications.[58] In IntelliJ IDEA, built-in Flex support enables similar features, including project configuration for Flex modules, real-time error detection, and integration with build tools for deployment.[57] These plugins allow developers to use the Apache Flex SDK without relying on Adobe's proprietary tools, supporting cross-platform workflows on Windows and macOS. Alternative tools include FlashDevelop, a free and open-source IDE focused on ActionScript development with support for Flex projects through SDK integration, offering features like project templates, debugging, and SWF compilation.[58][59] Flash Professional, now part of Adobe Animate, serves as a companion tool for asset integration, allowing designers to create vector graphics, animations, and symbols in FLA files that can be exported as SWC libraries for import into Flex IDEs.[60] Setting up an IDE for Apache Flex involves downloading the SDK installer from the official Apache site and configuring the installation path in the IDE's preferences, such as under "Installed Flex SDKs" in Flash Builder or project settings in IntelliJ.[57] For mobile builds, integrate the AIR SDK by overlaying it onto the Flex SDK directory and selecting the combined path in the IDE to enable packaging for iOS and Android targets.[57] Best practices in Flex IDEs emphasize using built-in refactoring tools, such as renaming variables or extracting methods in Flash Builder, to maintain code maintainability without altering behavior.[56] For unit testing, integrate FlexUnit 4.x, an open-source framework mimicking JUnit, directly into the IDE to write, run, and debug tests for ActionScript components, ensuring reliable application logic.[61][62]

Supporting Tools and Libraries

Apache Flex developers have access to a range of supporting tools and libraries that enhance testing, application architecture, utility functions, 3D capabilities, build automation, and debugging. These extensions integrate with the core SDK to facilitate robust development workflows for rich internet applications. FlexUnit serves as the primary unit testing framework for ActionScript 3.0 and Flex applications, providing JUnit-like functionality including assertions, test suites, and support for mock objects to isolate components during testing.[63] Developed initially by Digital Primates and now maintained under the Apache umbrella, FlexUnit 4.x offers extensions for Flex frameworks and Adobe AIR, enabling automated testing in continuous integration environments.[64] For managing complexity in large-scale applications, dependency injection and MVC frameworks like Swiz and Mate are widely used. Swiz is a lightweight micro-architecture that simplifies inversion of control, event handling, and bean management in ActionScript 3 and Flex-based RIAs through declarative configuration.[58] Similarly, Mate employs a tag-based, event-driven approach to decouple event handling from business logic, allowing developers to map events to responders via MXML without extensive boilerplate code.[58] Both frameworks promote modular design, with Swiz emphasizing simplicity for rapid prototyping and Mate focusing on event-centric architectures for enterprise-scale Flex projects.[65][66] Third-party libraries extend Flex's capabilities in utilities and graphics. AS3CoreLib provides essential ActionScript 3 utilities such as JSON serialization, MD5 and SHA-1 hashing, URL encoding, and image processing classes, which are independent of the Flex framework and suitable for both web and AIR applications.[67] For 3D graphics, Away3D offers an open-source engine supporting GPU-accelerated rendering, materials, animations, and physics integration, enabling interactive 3D experiences within Flex SWFs or AIR desktops.[68] Build tools integrate Flex into modern CI/CD pipelines, with Flexmojos providing comprehensive Maven plugin support for compiling SWFs, SWCs, and AIR packages, including optimization, unit testing, and multi-module project management.[69] The Flex SDK also natively supports Apache ANT for scripted builds, allowing customization of compilation, packaging, and deployment tasks in automated environments.[58] Debugging utilities aid in runtime inspection and network analysis. Charles Proxy is a versatile HTTP monitor that parses AMF (Action Message Format) traffic for Flex/Flash Remoting, enabling developers to inspect, throttle, and modify requests/responses between Flex clients and servers.[70] For runtime inspection, tools like Flex Spy allow examination of component hierarchies and properties in live applications, complementing IDE debuggers without requiring recompilation.[58] Post-transition to Apache, community contributions have focused on AIR enhancements, including scripts like the Harman AIR overlay for seamless SDK integration, which updates AIR runtimes and resolves compatibility issues for desktop and mobile deployments.[71] Additional libraries, such as FluorineFx for remoting gateways, extend AIR's backend connectivity while maintaining open-source accessibility.[58]

Related Projects and Integrations

Backend Services: BlazeDS and LiveCycle

Apache Flex integrates with backend services through BlazeDS and LiveCycle Data Services to facilitate data exchange between client applications and server-side resources.[72][73] BlazeDS is an open-source Java-based remoting and web messaging framework that supports Action Message Format (AMF) for efficient binary data serialization between Flex applications and backend servers.[72] It enables remote procedure calls (RPC) and real-time data push via publish-subscribe messaging, allowing developers to connect Flex and AIR applications to distributed data sources such as Java EE servers.[72] The latest version, 4.8.0, was released on April 17, 2023, and requires Java SDK 1.8 or greater for deployment.[74] LiveCycle Data Services (LCDS), Adobe's commercial extension of BlazeDS, builds on its core functionality by adding enterprise-grade features for data-intensive applications.[73] These include offline data synchronization, which allows Flex applications to operate without constant server connectivity; data paging to manage large datasets efficiently; and automated conflict resolution during multi-user updates.[73] LCDS also introduces non-blocking I/O (NIO) endpoints for improved scalability and additional channels like RTMP for low-latency real-time communication.[73] However, Adobe discontinued core support for LiveCycle products, including LCDS, in March 2018, with extended support ending in March 2020; as of November 2025, it is no longer maintained, and users are advised to migrate to modern alternatives such as Adobe Experience Manager Forms.[75] Integration with these services occurs primarily through Flex's RemoteObject component for RPC, which invokes server-side methods exposed via AMF, and the Data Management Service (available in LCDS) for handling create, read, update, and delete (CRUD) operations on backend data.[76][73] Configuration is managed via the services-config.xml file, which defines channels, endpoints, destinations, and security settings for the MessageBroker servlet.[76] ColdFusion provides built-in support for Flex integration through BlazeDS, enabling seamless AMF endpoints for CFML-based backends without additional installation.[77] Developers can use ColdFusion components (CFCs) as data services, with automatic type conversion between ActionScript and CFML, supporting operations like synchronization and remote calls over RMI.[77] Security in BlazeDS and LCDS is handled at the channel and destination levels, with support for endpoint URL path constraints and role-based access.[76] Authentication integrates with Spring Security (formerly ACEGI), allowing custom login commands and filter chains to protect remote services and ensure secure AMF transmissions.[76]

Successor Frameworks: Apache Royale

Apache Royale emerged as a fork and evolution of the Apache Flex project, entering incubation under the Apache Software Foundation in 2017 and graduating to top-level project (TLP) status on September 20, 2017.[78] It builds directly on the Flex SDK's foundation, enabling developers to compile MXML and ActionScript 3.0 code into JavaScript, HTML, and CSS outputs for creating browser-native web applications without relying on legacy runtime environments.[79] This transition addressed the end-of-life of Adobe Flash by providing a path to modern web deployment while preserving the productivity of Flex's declarative and object-oriented programming model.[6] A primary distinction of Apache Royale from its Flex predecessor is the complete removal of dependencies on Flash Player or Adobe AIR, allowing applications to run natively in contemporary browsers via standard web technologies. It incorporates a component-based architecture reminiscent of modern frameworks, with support for reusable UI elements that facilitate declarative UI construction similar to React's component paradigm. Royale offers multiple UI component sets, including the legacy-compatible Canvas for layout containers and the modern, responsive Jewel set for themeable, mobile-friendly interfaces, enabling developers to target diverse web environments without runtime plugins.[80] As of November 2025, the latest stable release is version 0.9.12 (December 2024), with ongoing updates enhancing compatibility with ES6+ JavaScript features for improved performance and integration with current browser standards.[81] Migrating from Apache Flex to Royale leverages the shared heritage, allowing up to 80% or more of existing ActionScript and MXML code to be reused through the Royale compiler, which transpiles it incrementally to JavaScript without full rewrites. Tools derived from the original Falcon compiler, now integrated as the Royale Compiler, support this process by handling gradual conversion of Flex applications, minimizing disruptions for legacy projects. Due to significant community overlap between Flex and Royale contributors, it is the recommended framework for new browser-based developments originating from Flex ecosystems, ensuring continuity in skills and codebases while adapting to post-Flash web standards.[82][47]

Adoption and Legacy

Historical Use Cases

Apache Flex saw significant adoption in enterprise environments during its peak in the late 2000s, particularly for building interactive dashboards that required real-time data visualization and user interfaces. Financial institutions leveraged Flex to create sophisticated trading and portfolio management tools. For instance, Dexia Bank integrated Flex into its IT strategy, developing a sample portfolio application with Flex Data Services for remote procedure calls and messaging, enabling efficient handling of complex financial data and improving decision-making processes.[83] In the government sector, Flex powered data-intensive portals and visualization tools for public agencies, facilitating collaboration and analysis across large-scale operations. NASA's RECOVER system utilized a full-featured Adobe Flex Web Map GIS analysis environment, accessible on various platforms, to process and visualize environmental recovery data for disaster response and resource management.[84] Additionally, the CoreSHIELD framework supported Flex applications like FoodSHIELD and FERN Online, serving over 350,000 users from federal, state, and local agencies in food safety and emergency response efforts, with Flex enabling rapid deployment of personalized interfaces via Adobe Flash Builder and the Spark component library.[85] The Space Telescope Science Institute also adopted Flex for astronomy software applications, demonstrating its viability in handling scientific data visualization and user interactions in specialized environments.[86] Media organizations and e-commerce platforms incorporated Flex for dynamic content delivery, including video players and search interfaces, to enhance user engagement before widespread shifts to HTML5. BI tools like precursors to modern platforms integrated Flex for dashboarding; for example, AnyChart's Flex charting component enabled interactive visualizations and drill-down capabilities in enterprise reporting systems.[87] Early mobile applications built with Adobe AIR, Flex's desktop and mobile runtime extension, targeted interactive consumer experiences. By 2010, Flex deployments had proliferated, with Adobe reporting substantial growth in the RIA ecosystem across industries.[28] Flex's data binding and component architecture supported these use cases by enabling responsive UIs without deep dives into underlying Flash mechanics.

Current Status and Migration Paths

As of 2025, Apache Flex maintains an active open-source community under the Apache Software Foundation, primarily focused on sustaining Adobe AIR compatibility for desktop and mobile applications, though the core SDK has seen no major releases since version 4.16.1 in 2017.[1] The community continues to provide installer updates to ensure compatibility with modern operating systems and the latest AIR runtimes from HARMAN, but overall development activity remains low, with emphasis on stability rather than new features.[88][89] HARMAN has released updates to the AIR SDK in 2025, including version 51.2.2.4 in September, incorporating security patches, OS compatibility improvements, and Android build tool updates.[11] The end-of-life for Flash Player in 2020 has significantly restricted Apache Flex's web deployment options, as browser-based SWF playback is no longer supported by major browsers, shifting focus away from web applications toward AIR-enabled desktop and mobile environments.[1] AIR runtime remains viable for these platforms, offering cross-platform deployment on Windows, macOS, Android, and iOS, but its integration with browsers has declined, limiting seamless web experiences and prompting many users to seek alternatives.[11] Maintenance efforts center on security and compatibility, with HARMAN providing ongoing updates to the AIR runtime, including security patches to address vulnerabilities without a specified end-of-support date.[90] The Apache Flex community supports bug fixes through mailing lists, GitHub repositories, and forums, where developers collaborate on patches for legacy issues, though these are handled on a volunteer basis rather than through formal release cycles.[91][92] For organizations with legacy Flex applications, migration strategies include semi-automated conversion to HTML5 and JavaScript using tools that emulate SWF behavior, such as CheerpX, which allows existing Flash content to run in modern browsers without full rewrites.[93] Refactoring to Apache Royale offers a more direct path for web-focused apps, leveraging compatible ActionScript syntax to output HTML/JS/CSS while preserving much of the original codebase.[82] For mobile applications, native rewrites using frameworks like React Native provide long-term scalability, though this requires more extensive redevelopment.[94] Looking ahead, Apache Flex's role emphasizes legacy preservation for AIR-based systems, with potential applications in embedded environments where stable, offline-capable UIs are needed, supported by HARMAN's continued runtime maintenance.[11]

References

  1. Apache Flex® - Home Page
  2. Project History - Apache Flex
  3. About Apache Flex
  4. Apache Flex Reviews & Ratings 2025 - TrustRadius
  5. A bit of history - The Apache Software Foundation
  6. Animate - ApacheFlex API Reference
  7. mx.charts package - ApacheFlex API Reference
  8. DataGrid - ApacheFlex API Reference
  9. AdvancedDataGrid - ApacheFlex API Reference
  10. Adobe AIR SDK from HARMAN
  11. Licensing and Trademarks - Apache Flex
  12. Macromedia Aims To Woo Enterprise Developers With Flex - CRN
  13. Macromedia flexes Flash muscle - CNET
  14. Exclusive Review: Macromedia brings Flash to the enterprise
  15. Macromedia stretches Flex's features - CNET
  16. Macromedia Flex Version 1.5 Announced - E-ChannelNews.com
  17. Review: Macromedia Flex and Flex Builder - Digital Web
  18. Macromedia flexes development muscle - InfoWorld
  19. Adobe Buys Macromedia for $3.4 Billion - The New York Times
  20. Adobe to Acquire Macromedia - SEC.gov
  21. Adobe Launches Flex 2 - TechCrunch
  22. Adobe Flex 2.0 enriches the RIA development experience - InfoWorld
  23. Adobe frees software to win developers - The Register
  24. Flex Builder 3 Release Notes - Adobe
  25. Adobe Launches Flex 3 Public Beta | CreativePro Network
  26. Adobe Flex 4 Overview | PPT - Slideshare
  27. Adobe Flex: How have the Latest Developments Affected its ... - InfoQ
  28. Adobe Flash Builder 4.5 and Flex 4.5 Accelerate Mobile App ...
  29. Adobe's Flash/Flex 4.5 Supports Apps for Android, BlackBerry and iOS
  30. Adobe LiveCycle Data Services ES2 Version 3 Release Notes
  31. Adobe Launches AIR 2.5 for TVs, Mobile, Tablets and Desktops
  32. Adobe Donates Flex to Apache | PCWorld
  33. Apache Flex 4.8.0-incubating Released! - Blogs Archive
  34. Apache Flex 4.9.0 Released! - Blogs Archive
  35. Apache Flex 4.9.1 Released! - Blogs Archive
  36. Apache Flex 4.10 Released! - Blogs Archive
  37. Apache Flex SDK 4.13.0 released - Blogs Archive
  38. Apache Flex 4.14 Released! - Blogs Archive
  39. Apache Flex 4.15 Released! - Blogs Archive
  40. Apache Flex 4.16.0 Released! - Blogs Archive
  41. Flex Podling Status Page - The Apache Incubator
  42. Frequently Asked Questions - Apache Flex
  43. Adobe Flash Player End of Life
  44. [PDF] Getting Started with Adobe Flex - IBM
  45. [PDF] An Introduction To Apache Flex - ApacheCon
  46. About the compilers - AIR SDK
  47. Apache Royale Compiler - GitHub
  48. [PDF] Building and Deploying Adobe Flex® 3 Applications
  49. Using native extensions | AIR SDK
  50. Configuration files - AIR SDK
  51. Upgrade to Flex SDK 4.5.1 from 4.1.0 causes namespace compile ...
  52. End of life | Adobe Flash and Shockwave Player
  53. Download Adobe AIR SDK 51.2 - HARMAN International
  54. Adobe Flex FAQ - Confluence Mobile - Apache Software Foundation
  55. [PDF] Adobe Flash Builder 4.5 Datasheet - Zones
  56. Adobe Flash Builder 4.7 Premium - Supported File Formats
  57. Getting Started with Apache Flex
  58. Third-Party Tools & Solutions - Apache Flex
  59. 2.3 FlashDevelop - Confluence Mobile - Apache Software Foundation
  60. Using Flash components into Flex application - Stack Overflow
  61. Unit 1 - Introducing FlexUnit 4.2.0 - Apache Flex
  62. Mirror of Apache Flex Flexunit - GitHub
  63. FlexUnit
  64. Confluence Mobile - Apache Software Foundation
  65. Home - Swiz Framework - Confluence - Projects
  66. mate-framework - Google Code
  67. mikechambers/as3corelib: An ActionScript 3 Library that ... - GitHub
  68. Features > Away3D
  69. Home - Flexmojos - Confluence
  70. AMF / Flash Remoting / Flex • Charles Web Debugging Proxy
  71. How to install Apache Flex with Adobe AIR from HARMAN
  72. Mirror of Apache Flex BlazeDS - GitHub
  73. Blaze Data Services or LiveCycle Data Services? - InfoQ
  74. Download Apache Blaze DS
  75. Spring BlazeDS Integration Reference Guide
  76. About ColdFusion and Flex-Developing guide - Adobe Help Center
  77. Board Meeting Minutes - Royale - Apache Whimsy
  78. Apache Royale
  79. Features - Apache Royale
  80. Download - Apache Royale
  81. Migrate from Flex - The Apache Software Foundation
  82. [PDF] Adobe Flex part of our IT Strategy
  83. [PDF] WHITE PAPER Rich Internet Applications IDC OPINION - Adobe
  84. [PDF] NASA WRANGLER
  85. [PDF] Integrated enterprise framework - Adobe
  86. The use of Flex as a viable toolkit for astronomy software applications
  87. Pre-built media players - Adobe Help Center
  88. AnyChart: Flex Charting Component Samples and Tutorial
  89. Apache Flex® - SDK Installer
  90. Board Meeting Minutes - Flex - Apache Whimsy
  91. Support - Adobe AIR SDK from HARMAN
  92. Get Involved! - Apache Flex
  93. Mirror of Apache Flex SDK - GitHub
  94. How to convert your Flash application to HTML5
  95. Flex Migration to HTML - Moonshine IDE
User Avatar
No comments yet.