Tutorials, extensions, and source files for ActionScript, Flash, and other Adobe products.


Versions in the Flash Platform


There are many different versions to deal with when working with the Flash Platform. They're not always easy to follow and their complexity has been changing over time. This document attempts to outline many of the different types of versioning and how they relate to one another.

Four groupings will be used in covering Flash Platform versions: Runtimes, Content, Source, and Tooling. Source and tooling represent the developer side of the platform. Runtimes are more central to users. Content bridges the two; it being what the developer creates with source and tooling to be viewed by users in the runtime.


Table of Contents


Everything in the platform hinges on one specific technology, the runtime. Historically, there has only been one Flash runtime, Flash Player. That changed in 2008 with the introduction of the Adobe Integrated Runtime, or AIR. Both represent the core technologies on which the entire Flash Platform is based.

Runtimes define where the Flash Platform starts for the user. They're the applications users have on their computers used to run the Flash content that developers create. A user's version of the runtime determines whether or not such content is supported on the user's computer. As such, it is one of the more important versions to pay attention to in the platform.


Flash Player

Format major[.minor]
Example 10.1 (
Type Application
Latest http://get.adobe.com/flashplayer

Flash Player is an application and core technology that is used to display and execute SWF files, the primary content format used in the Flash Platform. Flash Player usually runs through a browser as a plugin but can also be run as a separate application, either as a stand alone executable (sometimes called "projectors") or embedded within other applications. Flash Player is also a core component of AIR.

About Flash Player Versions

The version of Flash Player determines what content (SWF) is supported. Older versions of Flash Player, for example, may not contain the features newer content expects it to have to function. When Flash Player identifies content that is newer than itself (defined by the SWF version) it will attempt to run the content as best it can, but will eventually fail if and when the content eventually attempts to use features that don't exist in that version of the player.

Newer versions of Flash Player also improve security. In fact, most Flash Player releases are security releases, released to help protect users against attacks from malicious web sites and content.

Everyone should make sure they have the most up-to-date version of Flash Player installed, not only to support of the latest and greatest features used in newer content, but also to ensure your safety and security.

Flash Player versioning follows the major.minor.build.revision format. Up until Flash Player 10, releases would be versioned using only the major and build versions, with 0 used for the others (major.0.build.0). Each major release would start with a new the major value increased by 1 from the previous, and be accompanied by a new, arbitrary build number. Dot-releases would increment only the build number, and do so by an arbitrary amount.

8 Releases
9 Releases

Most dot-releases during this time were for bug fixes and security patches. There were not many, if any, feature releases that weren't released as new major versions. There was an exception to this rule with Flash Player 8.5, but it was a beta-only release targeted at getting ActionScript 3.0 into the hands of developers.

For Flash Player 10 and future versions of Flash Player, version numbering was changed. The format now more strictly follows major.minor.build.revision with minor and revision having the possibility of being non-zero (though minor will be zero for the first releases of a major release). For backwards compatibility, the old behavior where the build value always increases within a major release still applies, even when the minor value changes.

10 Releases

Minor value increases represent feature dot-releases. These are releases of Flash Player that includes a small set of new APIs or other Flash Player features which might have otherwise had to wait for a full release. Each new feature dot-release will increment the minor version by one with the first of a major release starting at 0.

Other releases that don't affect the minor version are for bug fix and security patches. These will only change build and revision. The revision value is completely arbitrary while, as was the case before, build steadily increases (by an arbitrary amount) throughout a major release.

Flash Player 10.1 is a unique version in that it is the only substantial feature release that didn't also include a SWF version revision.

Flash Lite

Flash Lite was a variation of older versions of Flash Player that targeted mobile devices. Flash Lite was implemented by OEMs and offered a subset of the features of the standard, release Flash Player. It's worth mentioning Flash Lite exists, but with Flash Player 10.1, a feature-complete version of Flash Player has been brought to many of the newer mobile devices, the need for Flash Lite has been greatly reduced.

Additionally, in terms of versioning, Flash Lite can be all over the place depending on how OEMs treated their build. This document will not cover specifics around Flash Lite.

What's Your Flash Player Version

The Flash Player About page contains a version detection script to identify your current installed version of Flash Player as well as information on what the current version of Flash Player is:
About Adobe Flash Player

Additional information about your Flash Player version can be found at the following go URL:

As of Flash Player 10.2, you can also right-click in a Flash Player movie window and see the current version of Flash Player in the context menu.

Flash Player 10.2 Context Menu
Context menu in Flash Player 10.2 showing Flash Player version

ActionScript can be used to determine the current version of the player using the following:

// ActionScript 1.0 and 2.0
// ActionScript 3.0
import flash.system.Capabilities;


Format major[.minor]
Example 2.5 (
Type Application
Latest http://get.adobe.com/air

AIR stands for Adobe Integrated Runtime. It's (among other things) a combination of enhanced versions of Flash Player and the Webkit (browser) rendering engine that allows either or both to be used to run web content as a local, stand alone application on your computer. The versions of Flash Player and Webkit used in AIR include a superset of features and APIs that are specific to the desktop environment supported by AIR.

AIR content is distributed as an AIR installer known as an AIR file. Launching an AIR file will install the content on your computer via the AIR runtime as an application executable that's native to that computer's operating system. This executable is a stub for launching a SWF or HTML page within the AIR player using an XML file known as the application descriptor XML to define various characteristics of the application including its version.

About AIR Versions

As with Flash Player, AIR versions determine what features in content is supported and how secure a user is in playing content. Having the most up-to-date version of AIR ensures the best compatibility with applications built for AIR and helps best protect users against any possible security issues.

Unlike Flash Player, AIR does not attempt to run content that was built for newer versions AIR. If the installed version of AIR is lower than what an AIR application needs, that AIR application will not run.

Though a large part of AIR is developed around Flash Player - Flash Player being at the core of its feature set - the AIR runtime maintains a separate version specific to it's own build. This version is much lower than Flash Player's own version because it's a much younger product compared to Flash Player.

AIR runtime versioning is slightly different than Flash Player's, using the more standard for applications format of major.minor.maintenance.build. Publicly, this is often shortened to major.minor.

Probably the most confusing aspect of AIR versioning is that, even though AIR is built on top of Flash Player, major versions are out of sync with the Flash Player releases that came out at about the same time.

Flash Player Release AIR Release
Flash Player 9 (mid-cycle) AIR 1.0
Flash Player 10.0 AIR 1.5
Flash Player 10.1 AIR 2.0
... ...

Because Flash Player is a core component of AIR, major releases of Flash Player add new features to AIR. Though these features are worthy of a full release of Flash Player, they've historically come into AIR as dot-releases. AIR's own major releases include new features that are specific to AIR only and do not necessarily affect Flash Player.

What's Your AIR Version

The following knowledge base document can help you find what version of AIR is currently installed on your computer:
How to determine what version of Adobe AIR runtime is installed (Mac, Windows, and Linux)

In an AIR application, you can get the current AIR runtime version with ActionScript using:

// ActionScript 3.0
import flash.desktop.NativeApplication;

Using ActionScript 3.0 in any Flash Player, even outside of an AIR application, you can also get the current AIR version using (undocumented and therefore not officially supported):

// ActionScript 3.0
import adobe.utils.ProductManager;
var airPM:ProductManager = new ProductManager("airappinstaller");


Content refers to the distributed end product released to end users after the development of a project. When dealing with Flash, this is almost exclusively in the form of files in, or in some way containing, the SWF file format. While AIR files are installers for native applications to be run on the desktop, they ultimately end up running a SWF file (or HTML) as content once the application is launched.



Format major
Example 10, SWF10
Type Document
Latest http://adobe.com/devnet/swf/

SWF is the binary, tag-based file format used by content running in the Flash platform played by Flash Player. SWF stands for Shockwave Flash, though is also known as Small Web Format or Small Web File.

As a binary format, the contents of a SWF file are not human readable like that of an HTML file. But like HTML, SWF files use tags to identify content. SWF tags start with an identifying tag name, or ID, followed by the contents of the tag. In HTML, the <title> tag contains of the page title. In a SWF file, a FrameLabel tag (43) is used to identify the title or name of a frame in the timeline. ActionScript is contained in its own tags, DoAction (for ActionScript 2.0) and DoABC/DoABC2 (for ActionScript 3.0) but has a separate format known as ActionScript Bytecode, or ABC.

Before tags begin in a SWF file, there's the file header. The header contains the basic information that identifies what the file is. A SWF file's version is contained here.

About SWF Versions

SWF versions represent the target or minimum Flash Player version that the SWF is designed to run in. This usually means that the SWF uses features that only exist in that version of Flash Player or later. But, ultimately, it's up to the developer to decide what version to use when creating a SWF. It is quite possible that a developer isn't using features in, for example, Flash Player 10, but had decided to make a SWF targeting Flash Player 10 by giving it a SWF version of 10.

In a SWF file, the version number is defined in the fourth byte of the header. As a single byte, it can contain up to 256 different integer values (0 - 255). Flash Player uses SWF versions primarily for compatibility. This comes in the form of determining feature behavior and the exposure of version-specific ActionScript APIs.

For feature behavior, Flash Player uses a SWF's version to ensure content does not change as new versions of Flash Player are released. If a new version of Flash Player changes the behavior of a certain feature, for example as the result of a bug fix, it has to make sure older content using the old behavior does not change or break as a result. These bug fixes are known to be version checked. Version checked bug fixes require that, in order for the content to recognize the fix, the SWF version of that content is equal to or greater than the version of Flash Player that fixed it. So, for example, if Flash Player 10 fixed a bug that was broken in Flash Player 9, a SWF would have to have a SWF version of 10 or greater for that bug fix to be applied. Flash Player 10, even though it fixes the bug, will still use the old, incorrect (buggy) behavior for SWF files with a version of 9 or less to make sure they play as they were designed to play when that behavior existed.

In terms of ActionScript APIs (ActionScript 3.0 only), Flash Player uses the SWF version to know what APIs should be exposed to a SWF. For more information on this, see API Compatibility.

ActionScript API exposure is always based on the first SWF loaded into Flash Player. Other SWFs loaded by that SWF will use the API set defined by that first, root SWF. Version checked behaviors may or may not use the root SWF. That depends entirely on the implementation of the version check. The rule of thumb is: if it can be avoided, don't mix and match SWF versions when loading SWFs into one another. If that can't be helped, be sure to fully test your content.

There is only one number in a SWF version. It historically maps exactly to the major version of the Flash Player version it targets. For example, a SWF published with a SWF version of 10 is said to target Flash Player 10 and should only be run in Flash Player 10 or greater. This has changed starting with Flash Player 10.2.

Flash Player 10.2 marked the first release of Flash Player that supported a SWF version that was different than it's own major version. While Flash Player 10.2 has a major version of 10, it supports all SWFs versioned 11 and below.

Note: Tooling and SWF Versions

You may notice that with some tooling, you may only see the Flash Player version when specifying a SWF version of 11 for Flash Player 10.2 or greater. So instead of explicitly indicating a SWF version of 11, you'd instead specify a SWF that targets Flash Player 10.2. Other tooling, specifically the Flex SDK, may require that you specify the SWF version (11) rather than the player version. Be aware of these differences and try not to be confused.

SWF versions will continue to increment independently of Flash Player. From Flash Player 10.2 and moving forward, a SWF version may increase with any dot-release of Flash Player.

What's Your SWF Version

Given a SWF, you can determine the version of ActionScript it uses through the services provided by http://swfversion.com.

Manually, the SWF version can be identified by checking the value of the fourth byte in a SWF file's header. This can easily be done by opening the SWF in any hex editor. For example, consider a SWF file starting with the hex string of:

43 57 53 0A 5B 1F 00 00 ...

This indicates the SWF has a version of 10 since the fourth byte is 0A which is equal to 10.

With ActionScript you can determine the current SWF version using:

// ActionScript 2.0
// within context of a MovieClip
// ActionScript 3.0
// within context of a DisplayObject


Source files are used to create content. Source files used for the Flash Platform can vary depending on tooling. Flash Professional, for example, uses a proprietary format known as a FLA (which used to be binary, but is now defined in a more open, XML-based format). Flash Builder, based on Eclipse, uses Eclipse-based projects which consist of a collection of different files. Common between each, and most pertinent to the topics here, are ActionScript files. These are source files used for the programming language of Flash, ActionScript.



Format major[.minor]
Example 3.0
Type Language/Document
Latest http://adobe.com/devnet/actionscript/

ActionScript is the programming language used by the Flash Platform. Its current style, for each version, is largely based on ECMAScript (JavaScript) though newer revisions of the language are starting to move away from its ECMAScript roots.

About ActionScript Versions

There are currently three versions of ActionScript:
  • ActionScript 1.0
  • ActionScript 2.0
  • ActionScript 3.0

Though different in name and version number, the three different versions of ActionScript actually boil down to what is essentially known as the two versions of ActionScript: ActionScript 2.0, which encompasses ActionScript 1.0 and 2.0, and ActionScript 3.0.

Flash Player started with what is effectively known as ActionScript 1.0. This became pretty well defined as the scripting language for Flash around Flash Player 5, when it took on a format very similar to JavaScript. ActionScript existed before Flash Player 5, but in a simpler format, one that was almost a different language in its own. No versioning was associated with the language at that time and it was simply known as Flash Actions.

ActionScript 2.0 was the first versioned revision of the language. This revision didn't change anything in the existing ActionScript 1.0 language. Rather, it introduced an additional class syntax that supplemented the language. This syntax provided a clearer and more organized way to write code. But in the end, the code compiled to the same machine code, or ActionScript bytecode (ABC), used by ActionScript 1.0. The additions to the language with ActionScript 2.0 were entirely compiler-based. So while ActionScript 2.0 was introduced with the release of Flash MX 2004 (Flash Professional 7) and Flash Player 7, it could still be used to write code that worked with Flash Player 6.

ActionScript 3.0 was the first dramatic change made to the language. It was introduced with Flash Player 9 (or, more specifically, Flash Player 8.5, though it was a beta-only release). ActionScript 3.0, unlike ActionScript 2.0, is a completely new language. It is based on the same APIs used in ActionScript 2.0 making it look and feel very similar, but it requires an entirely new virtual machine, the component in the Flash Player application that processes ActionScript, to function.

ActionScript 2.0 is run in what is known as ActionScript Virtual Machine version 1 or AVM1. ActionScript 3.0 is run in ActionScript Virtual Machine version 2 (AVM2, a.k.a. AVM+). Flash Player 9 includes both virtual machines in its codebase to allow it to play both kinds of SWFs, those that use ActionScript 2.0 and those that use ActionScript 3.0.

ActionScript versions themselves are very generalized and used mostly for marketing, though ActionScript 3.0 now also distinguishes between which of the virtual machines is needed to execute the code. It is likely the version numbers used for ActionScript will never change unless another entirely new version of the language is released.

What's Your ActionScript Version

The version of ActionScript to be used in a SWF is usually defined by tooling. Flash Builder and the Flex SDK focus on ActionScript 3.0. Flash Professional can use either ActionScript 3.0 or ActionScript 2.0. The version a Flash Professional source file (FLA) uses is made available in the publish settings.

Both ActionScript 2.0 and 3.0 source files have the same extension, .as, so extension alone cannot determine the version of an ActionScript file; the file contents would have to be checked. For includes, there may be no way to determine the version. And in fact, depending on the code, because the APIs are so similar, an include may work for both versions of ActionScript. Class files do have a different format however. Specifically, ActionScript 3.0, includes a package block which does not exist in ActionScript 2.0. The package block defines the package path for ActionScript 3.0 class files. ActionScript 2.0 package paths are defined in the class name.

// ActionScript 2.0
class com.senocular.MyClass { ...
// ActionScript 3.0
package com.senocular {
	class MyClass { ...

Given a SWF, you can determine the version of ActionScript used through the services provided by http://swfversion.com.

For anyone familiar with the SWF file format, the ActionScript version, or more specifically whether or not the SWF uses ActionScript 3.0, is defined by the ActionScript3 field in the FileAttributes (69) tag of a SWF document.

ActionScript API

Format Based on runtime
Example 10.1 (Flash Player), 2 (AIR)
Type Language/Application
Latest http://adobe.com/go/as3lr
(AS2: http://help.adobe.com/.../actionscript/2/)

In ActionScript, APIs, or Application Program Interfaces, represent the classes and functions that are made available to developers for use in creating SWF content for the Flash Platform. APIs in Flash are constantly added as new features are added to Flash Player and other parts of the runtime. The APIs made available to developers depends on the Flash Player version being targeted for content.

About ActionScript API Versions

Flash Player and AIR APIs are constantly changing. New classes and functions are being released within almost every release of Flash Player. Note that these changes are not tied to the ActionScript version, however. ActionScript 3.0, for example, has had many new APIs added to it over time, but has not increased in version from 3.0 to anything else. Similarly, the move from ActionScript 1.0 to 2.0 was not about API as it was about syntax. APIs aren't so much about language as they are about enabling a language to interact with its runtime environment.

API versions are tied to runtime versions since it's the runtimes that provides and implements the APIs. If you need to identify an API version for some source code, it would be done through the runtime version that supports it. The language reference distinguishes API versions through runtime versions in the format of major[.minor]. For example, the NumberFormatter class is indicated as being supported by "Runtime Versions: Flash Player 10.1, AIR 2".

API Compatibility

A concern with respect to APIs is compatibility, especially backwards compatibility. If old content unwittingly defines a custom class or method that may ultimately becomes part of a new, native addition in Flash Player, the conflict could cause that content to break. There are two approaches used to fight this, package namespaces and compatibility modes.

Packages are named paths used by classes in ActionScript to define a package namespace for a class. Namespaces are essentially prefixes given to names that help prevent conflicts between other objects or data using the same name. The idea is that each name is unique, if not by its local name, then at least by it's fully qualified name which includes the local name and the namespace. All (or at least, most) of the native ActionScript 3.0 APIs in Flash Player are defined functions and classes using a package path starting with the term "flash". (A few in ActionScript 2.0 are as well, starting with new classes introduced in Flash Player 8.) When creating your own definitions, you should never place them in a package path beginning with "flash" in order to help ensure conflicts won't occur.

Packages do not resolve all conflicts. Conflicts may still occur when extending native classes. For example, if a custom subclass of a native class were to add a custom class property and a new version of the native superclass added that same property in a future release, a conflict would arise. Flash Player prevents these conflicts by controlling API exposure based on SWF versions (ActionScript 3.0 only) with a compatibility mode.

All ActionScript 3.0 APIs are defined in Flash Player with an associated SWF version. When launching a SWF, before executing any ActionScript, Flash Player reads the version of the SWF to determine which APIs it will expose to the SWF based on the version associated with each API. Only those APIs with a version equal to or less than the version of the SWF will be exposed to ActionScript when the SWF is run. For example, a version 9 SWF will not be able to access the GraphicsPath class even if run in Flash Player 10 (GraphicsPath is a class that was introduced in Flash Player 10) because that class is only available for SWFs whose version is 10 and above.

Flash Player 10.1 released with many new features and APIs. However, it did not support a new SWF version. As a result, older Flash Player 10 content will inherit new, unexpected APIs when played in Flash Player 10.1. The impact of these APIs should be minimal, so conflicts are not likely to occur. Nevertheless, it may be necessary for a SWF to validate the Flash Player version before attempting to use APIs that are specific to Flash Player 10.1.

AIR additionally uses a namespace in its application descriptor XML file that regulates APIs at a more granular level. AIR namespaces take the format http://ns.adobe.com/air/application/<major.minor[.maintenance]>. The following are examples of AIR namespaces:

  • http://ns.adobe.com/air/application/1.0
  • http://ns.adobe.com/air/application/1.1
  • http://ns.adobe.com/air/application/1.5
  • http://ns.adobe.com/air/application/1.5.1
  • http://ns.adobe.com/air/application/1.5.2
  • http://ns.adobe.com/air/application/1.5.3
  • http://ns.adobe.com/air/application/2.0
  • ...

This namespace is used by AIR to determine which APIs are made to the content running in the application. The namespace works in conjunction with the SWF version for APIs where the namespace does additional filtering on top of SWF version. This is especially important for AIR APIs that have been added in AIR feature releases that are not differentiated by SWF versions.

AIR also uses the namespace version to determine whether or not a SWF of a specific version should be played within the AIR runtime. If the application specifies a namespace version of 1.0, but includes a SWF with a version of 10, that SWF will not be allowed to play since the 1.0 release of AIR is specific to Flash Player 9 and should not have any features that may be made available through a version 10 SWF.

SWF Version AIR Version
9 1.0


When a SWF-based AIR application launches, the following logic is used:

  1. Read the application descriptor XML
  2. Get the AIR namespace version
  3. Verify the namespace version is equal to or less than the version of the AIR runtime
  4. Identify the content SWF
  5. Verify that the content's SWF version is not greater than the AIR namespace version (based on release, not numerical value)
  6. Allow SWF version to dictate core Flash Player APIs
  7. Restrict AIR-specific APIs based on the AIR namespace version

If for some reason an AIR application is packaged with a SWF that is of a higher version than the application's namespace version, or that namespace version is greater than the current installed version of AIR, then the application will not run and an error will occur.

AIR does not have the same problem with Flash Player 10.1 APIs that Flash Player does since its namespace versioning can correctly distinguish 10.1 APIs from 10.0.

What's Your ActionScript API Version

Because ActionScript API versions are based on the runtime version, refer to What's Your Flash Player Version and What's Your AIR Version to see what API set is available for your particular runtime.

In development, tooling (specifically the compiler, though most tools manage what API versioning is used by the compiler) determines the version of the API will be used by your content. APIs with respect to tooling are dependent on two things:

  1. Recognizing APIs what APIs are available in the target runtime
  2. Creating content that exposes the expected APIs when played in the target runtime

ActionScript compilers need to understand what APIs are presumed to exist within a targeted runtime environment when compiling source code that will ultimately run in that environment. ActionScript uses stub definitions to do this, also known as intrinsic (ActionScript 2.0) or native (ActionScript 3.0) definitions.

ActionScript 2.0 intrinsic definitions reside in a collection of ActionScript files. These files contain interfaces for all the globals and class members available in the language, each marked with the keyword intrinsic to let the compiler know that these definitions are not to be compiled into the SWF and are instead part of the native API that will be available to the SWF once it's run in Flash Player.

ActionScript 3.0 is handled in a similar fashion. Instead of the intrinsic keyword, though, ActionScript 3.0 uses native. Additionally all definitions reside in a single, pre-compiled package called playerglobal.swc, rather than individually exposed class files.

New versions of tooling include updated versions of these definitions for native classes allowing content to be created that can make use of them. Older tooling can generally also be updated with newer versions of the definitions to be able to target the new APIs as well. Flash Builder does this fairly easily by allowing you to point to different versions of the Flex SDK. Flash Professional is a little more obscure. You can update the version of playerglobal.swc that it uses, having downloaded a newer one from a recent version of the Flex SDK, but you'll have to find and manually replace it yourself within the Flash Professional installation directory.

Once an authoring tool can recognize new APIs, it still needs to be able to create content that will allow the runtime to release those APIs once its actually being run. Since SWF versions determine API availability (and for AIR, the application namespace) tooling will need to target the correct SWF version to allow the expected APIs to be made available. Tooling makes this option available to the developers; in Flash, for example, through the publish settings dialog.

Flex Framework

Format major[.minor[.update]]
Example 2.0.1
Type Library
Latest http://opensource.adobe.com/wiki/display/flexsdk/Flex+SDK

The Flex Framework is an ActionScript-based library developed by Adobe that is to be used to help develop rich internet applications (RIAs). The framework includes GUI components, data components, and just about anything else you need to create an immersive web or desktop application using Flash technologies. As a library, it adds new ActionScript APIs to Flash Player but does so through a collection of classes that are added to your SWF file rather than being part of Flash Player itself which is the case for the other native APIs.

The Flex Framework is available with the Flex SDK. Flash Builder, which depends on the Flex SDK, is tightly integrated with the features of the Flex Framework and depends on it for many of its features. When working in Flash Builder, it is likely that you'd also be working with the Flex Framework, though it is not required. ActionScript projects in Flash Builder, for example, do not depend on the Flex Framework and can be built without using it. The more standard Flex projects, however, do.

Flash Professional can also be linked to the Flex SDK to make use of some of the classes in the Flex Framework.

About Flex Framework Versions

The first version of the Flex Framework (1.0) was actually developed in ActionScript 2.0. It was part of an enterprise-level server-side solution for dynamically creating SWF content on demand.

Version 2.0 of the Flex Framework brought it out of the enterprise space and integrated it into the Flash Builder development tool, which at the time was called Flex Builder, or simply, Flex. This was more consumer oriented and designed for anyone wanting to build a RIA with the Flash Platform.

Most Flex Framework versioning is restricted to the major or major and minor version numbers. Version 2.0 of the Flex Framework did have an update moving it to 2.0.1, but updates since have not changed the update version.

Unlike native APIs in Flash Player, new releases of Flash Player do not affect the behavior or exposure of APIs in the Flex Framework. They are compiled into a SWF and remain consistent for that SWF until that SWF is recompiled with an updated version of the framework. This greatly helps with compatibility concerns, though the Flex Framework still implemented its own compatibility checks for different versions of the framework.

What's Your Flex Framework Version

Flex Framework versioning is divided among Flex SDK versioning and compatibility versioning. The Flex SDK version is tied to each class of the framework in the VERSION property and represents a the more specific form of versioning.

// ActionScript 3.0
import mx.core.Application; // or any other Flex class

Also refer to What's your Flex SDK Version.

The Flex Framework also maintains a compatibility version which specifies a less specific version but one more specific to compatibility and functionality. This is managed in the FlexVersion class. FlexVersion maintains versions for major releases of the Flex Framework that affect functionality. The current version is indicated by FlexVersion.CURRENT_VERSION.

// ActionScript 3.0
import mx.core.FlexVersion;

This version in its unsigned integer (uint) format specifies version as (hex) 0xMMNNUUUU where M is the major version, N is the minor version and U is the update version.

Compatibility versions in FlexVersion do not always match the respective Flex SDK version. Flex 4.1, for example, specifies 4.0 in its FlexVersion version (i.e. FlexVersion.CURRENT_VERSION in Flex 4.1 is the same as Flex 4.0). Though the framework version is technically different with feature additions and bug fixes, no changes were made that affected compatibility enough to warrant a new compatibility version so one was not included.


There are a number of different authoring tools available for creating SWF content. Some are designed specifically to output SWF files, while others can export to SWF as a secondary format. Those developed by Adobe specifically for SWF creation for the Flash Platform, especially when considering programming with ActionScript, include IDEs (Integrated Development Environments) Flash Professional and Flash Builder, and the free Flex SDK.


Flash Professional

Format Varies
Example Flash 5, Flash MX, Flash Professional CS5 (
Type Application
Latest http://adobe.com/products/flash/

Flash Professional is the standard IDE for producing most Flash Player content. This was the first tool created for Flash with roots beginning with SmartSketch and FutureSplash. Currently it is the only tool offered by Adobe capable of complete ActionScript 2.0 development.

About Flash Professional Versions

With just about every major release of Flash Player comes a new release of Flash Professional to allow developers to take advantage of the new features in the player. Up until the introduction of Flex Builder 2.0, Flash Professional and Flash Player were developed together and released at the same time. With the introduction of a new development tool, Flash Player was separated from Flash Professional, developed as a separate product with each tool targeting the runtime independently.

Though developed independently, at the time, Flash Professional was still in version parity with Flash Player. This changed with Flash Professional CS5 (11). It was the first release Flash Professional had become out of sync with Flash Player which was still in a major release of 10 at the time. Similarly, Flash Player CS5 is the first major release of Flash Professional that did not target a new SWF version, though it was updated to recognize the new Flash Player 10.1 APIs.

Marketing and company ownership has had a somewhat disruptive influence over this application's naming and versioning as seen through its history of releases:

  • FutureSplash Animator
  • Flash 1
  • Flash 2
  • Flash 3
  • Flash 4
  • Flash 5
  • Flash MX
  • Flash MX 2004
  • Flash 8
  • Flash CS3 Professional
  • Flash CS4 Professional
  • Flash Professional CS5
  • ...

Under the covers, however, Flash has always maintained a consistent variation based on major.minor.maintenance.build. As part of the Creative Suite (CS) the marketed version of Flash Professional had dropped from 9 to [CS]3 with Flash CS3 Professional, but the actual application version remained at 9 (major).

What's Your Flash Professional Version

In Flash Professional, use the About dialog to view the current version of the application. For Windows use Help > About Adobe Flash Professional; for Mac use Flash > About Adobe Flash Professional (terminology may differ based on version).

You can also determine the version by checking the file properties (Windows) or file info (Mac) of the Flash executable.

If a SWF was published to include XMP metadata, the version of Flash Professional would also be included there in the CreatorTool tag. XMP support for SWFs was added with Flash CS4 Professional.

Flash Builder (Flex Builder)

Format major[.minor[.maintenance]]
major.minor[.maintenance] build build
Example Flex Builder 2.1, Flash Builder 4 (4.0 build 272416)
Type Application
Latest http://adobe.com/products/flashbuilder/

Flash Builder, originally named Flex Builder, was designed specifically to develop Flash content with the Flex Framework and the Flex SDK. It can be used with, or as an alternative to Flash Professional. Where Flash Professional excels at animation and visual development, Flash Builder instead focuses more on ActionScript programming and application development.

About Flash Builder Versions

The first version, Flex Builder 1.0, was based on Dreamweaver and targeted the enterprise edition of the Flex Framework. With Flex Builder 2.0, and the move over into a more consumer user space with the Flex branding, the tool was migrated over to use the Eclipse platform.

Flex SDK releases are often accompanied by Flex Builder updates. So far, their major versions have also been the same, much as was the case (until recently) with Flash Professional and Flash Player. There's no guarantee that this synchronous nature will continue in the future for Flash Builder and the SDK.

Flash Builder versioning can be different depending on where you look. The marketed version usually focuses on either the first two or first three version values, major.minor or major.minor.maintenance. The application itself can indicate a version of major.minor build build or major.minor.maintenance build build (as seen in the About dialog). In the end, it ultimately comes down to the standard major.minor.maintenance.build format, but it can take a little digging around to get to.

What's Your Flash Builder Version

In Flash Builder, use the About dialog to view the current version of the application. For Windows use Help > About Adobe Flash Builder; for Mac use Flash Builder > About Adobe Flash Builder (terminology may differ based on version). In that same menu, you can also use the Product Details... option to get additional information. The Installation Details button in that dialog will give you a specific major.minor.maintenance.build version as well as versions for other components of the tool.

Flex SDK

Format major[.minor]
Example 4.1 (
Type SDK
Latest http://opensource.adobe.com/wiki/display/flexsdk/Flex+SDK

The Flex SDK (Flex Source Development Kit) is a free download of resources made available for developers for the creation ActionScript 3.0-based SWF content. It contains libraries, compilers and (optionally) versions of Flash Player. Developers can use the Flex SDK to create SWF files for free without having to purchase potentially costly tools.

Though the Flex SDK uses Flex in it's name, and includes the Flex Framework in its contents, you do not have to use the Flex Framework to create SWFs using the Flex SDK. The SDK can be used to create SWFs that does not include any part of that, or any other framework.

Parts of the contents of Flex SDK are used internally by Flash Professional, particularly the ActionScript 3.0 Compiler, and are included with the standard Flash Professional installation. Flash Builder depends even more heavily on the Flex SDK, including a full version with each installation of Flash Builder.

About Flex SDK Versions

The Flex SDK is a combination of many different pieces, each of which contains their own, individual versions. However, as a whole, the release of each SDK is given it's own version number.

As an open source project, many more builds of the Flex SDK are made available to the public compared to other products. Most are considered unstable. Stable, milestone releases are often released with new versions of Flash Builder.

Because parts of the full Flex SDK are not open source, Flash Player builds, for example, the SDK is separated into two separate variations. The "Open Source Flex SDK" version consists of completely open source components while the "Adobe Flex SDK" consists of the open source components as well as closed source extensions (e.g. Flash Player) provided by Adobe.

Flex SDK versioning follows the standard application format of major.minor.maintenance.build though is more commonly referred to through major.minor or simply major.

What's Your Flex SDK Version

When you download and unpack the Flex SDK, its contents are in a folder with a name that includes the version of the SDK, e.g. "flex_sdk_4.1.0.16076_mpl".

The version is also more well defined in an XML file in the root directory of the SDK called flex-sdk-description.xml. Its contents contain the version of the Flex SDK; it looks something like this:

    <name>Flex 4.1</name>

In the Flex Framework, the Flex SDK version can be identified through ActionScript using the VERSION property defined in all Flex classes.

// ActionScript 3.0


Format major.minor build build [for ASC]
Example 1.0 build 14159
Type Application
Latest http://opensource.adobe.com/wiki/display/flexsdk/Flex+SDK

ActionScript, though syntactically very similar than JavaScript, is not executed from its text source as is the case with JavaScript. ActionScript is compiled into binary bytecode called ABC (ActionScript Bytecode) which is read by and executed by the ActionScript Virtual Machine (AVM). The application that handles this conversion from source to bytecode is known as the ActionScript Compiler (ASC).

There are effectively two versions of ASC, one for each version of ActionScript (2.0, which includes 1.0, and 3.0). However, in general, when referring to ASC, it's in reference to the Java-based compiler written as an open source, cross-platform solution for compiling ActionScript 3.0 source code. ActionScript 2.0 is only supported by Flash Professional and is compiled by an ActionScript 2.0 compiler internal only to that tool. This is generally known simply as the ActionScript 2.0 compiler.

About Compiler Versions

As a part of the tooling, new versions of the compiler are included with new versions of the tools. This is especially the case with the ActionScript 2.0 compiler given that it is built directly into Flash Professional. Similarly, ASC is a core component of the Flex SDK. New releases of the SDK drive new releases of ASC, though other tooling also include new releases of ASC. These versions of ASC are likely not as up to date with whatever the current version is within the SDK, however, given the more aggressive release schedule of the SDK.

New versions of compilers most often include bug fixes and optimizations. New versions can also support additions to the ActionScript language (not the API). ActionScript 2.0, with its new class syntax, is a prime example of this. That addition was added with the Flash MX 2004 version of the ActionScript 2.0 compiler. An example for ActionScript 3.0 is the Vector literal syntax. This is a new, short form syntax for defining Vector instances in code that was added to the language after support for the Vector object.

// ActionScript 3.0

// old syntax
var first:Vector.<int> = new Vector.<int>();
first[0] = 1;
first[1] = 2;
// or (conversion)
var second:Vector.<int> = Vector.<int>([1,2]);

// new syntax
var third:Vector.<int> = new <int>[1,2];

This style of Vector definitions can only be used with Flash Professional CS5 and later, Flash Builder 4 and later, or Flex SDK 4 and later because only those versions of the tool contain a version of ASC where support for this syntax was added.

ASC's versioning scheme relies on your standard major and minor version numbers with an additional build value. The version of ASC does not correlate to any other versions of products in the Flash Platform such as Flash Professional or the Flex SDK.

The ActionScript 2.0 compiler has no real version of it's own. Versions of it are instead linked to the version of the Flash Professional tool in which the compiler is built.

What's Your Compiler Version

To get the version of the ActionScript 3.0 compiler, ASC, use the command line to run asc.jar with the -? flag.

java -jar asc.jar -?

For the version of ASC used by Flash Professional CS5 (available in Adobe Flash CS5\Common\Configuration\ActionScript 3.0), this results in:

ActionScript 3.0 for AVM+
version 1.0 build 14159
Copyright (c) 2003-2007 Adobe Systems Incorporated
Copyright (c) 1998-2003 Mountain View Compiler Company
All rights reserved

For the ActionScript 2.0 compiler version, see What's Your Flash Professional Version.


The following contains summaries or additional information related to the topics already covered.


Flash Player:

  • Flash Player 8.5 (beta) - First public release of Flash Player to support ActionScript 3.0. The final, non-beta release became Flash Player 9.
  • Flash Player 9 - First release in AIR.
  • Flash Player 10 - Versioning scheme for Flash Player changes. All values in major.minor.build.revision will now be used.
  • Flash Player 10.1 - First substantial feature release of Flash Player not to increase the SWF version (10).
  • Flash Player 10.2 - First Flash Player release where the supported SWF version (11) does not match the major player version (10).

Flash Professional:

  • Flash MX 2004 (7) - First release of ActionScript 2.0.
  • Flash 8.5 - First release of ActionScript 3.0.
  • Flash Professional CS5 (11) - First release of Flash Professional to have a major version different than it's supported Flash Player version (10.1)

Flash Builder:

  • Flex Builder 2 - First release supporing ActionScript 3.0.
  • Flash Builder 4 - Flash Builder is renamed from Flex Builder.