HSTS Support in Flash Player 23


By Vivek Negi

HSTS is an Internet Engineering Task Force (IEFT) standard that enforces the user-agents like browsers to use the secured HTTPS protocol for communication instead of the HTTP protocol. The HTPPS response header from a host may have a ‘Strict-Transport-Security’ (STS) header field, which requests the user-agent to always make subsequent requests to access that host using the HTTPS protocol only. Beginning with version 23, Flash Player supports the HSTS standard. Flash Player now acknowledges an STS header in the HTTPS responses received from the HSTS hosts.

HSTS support is particularly helpful in those Flash applications where an SWF calls another SWF (child) and this child SWF is located in an HSTS enabled host. When the parent SWF tries to access the child SWF, the host sends an STS header in the HTTPS response. This STS header is acknowledged by Flash Player. Therefore, all the subsequent requests for the child SWF by the parent SWF can be made only through the HTTPS protocol.

The figure below depicts a workflow of how the HSTS enabled hosts and the non-HSTS enabled hosts interact with the browsers and Flash Player.


In the figure above, the browser is loading a Flash application that has two SWFs ─ outer.swf denoting the parent SWF and inner.swf denoting its child SWF. The non-HSTS host doesn’t enforce the browser (user-agent) to use the secure protocol, that is, HTTPS. The workflow, as depicted in the figure above, when the browser accesses content from the HSTS enabled host is described below:

  1. The file container.html loads outer.swf in the HSTS Host (hsts.host.com).
  2. The browser sends out request #4 through the non-secure transport as the URI for outer.swf is specified with HTTP scheme in container.html.
  3. The browser receives a 301 Moved Permanently response from hsts.host.com as the server is an HSTS host and stops communicating using the non-secure HTTP protocol.
  4. Browser now sends out request #6 through the secure HTTPS protocol based on the Location header field as shown in the response #5 301 Moved Permanently.
  5. Browser receives the response #7 200 OK and notes hsts.host.com as a ‘Known HSTS Host’ as the response message has a Strict-Transport-Security (STS) header field. From this point onwards, any subsequent request to this host by the browser will be made using the HTTPS protocol.
  6. Browser passes the outer.swf stream to Flash Player with the response headers.
  7. Flash Player also notes hsts.host.com as a ‘Known HSTS Host’.
  8. Flash Player loads outer.swf and runs ActionScript in it.
  9. outer.swf loads inner.swf using URLRequest with the parameter http://hsts.host.com/inner.swf.
  10. The earlier versions of Flash Player, in the absence of HSTS support, would have made the request through the unsecured HTTP protocol. Flash Player 23, however, sends request #11 through secure transport as hsts.host.com is a ‘Known HSTS Host’.

HSTS support in Flash Player can be very useful in various aspects, but most importantly it makes Flash Player more secure than its previous versions.

Running Adobe Flash Builder on Mac with Java 7/8

By Krati Rastogi and Vivek Kumar

Adobe® Flash® Builder® 4.7, which is an Integrated Development Environment (IDE) for developing games and applications using ActionScript and Flex framework runs on Java 6. If you do not have Java 6 on your machine Flash Builder does not launch and instead displays this error.


Steps to follow

  1. Set your JAVA_HOME to Java 7 or Java 8 as per the correct paths on your machine.
  2. export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.7.0_79.jdk/Contents/Home
    export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk1.8.0_91.jdk/Contents/Home
  3. Open JVM’s Info.plist at $JAVA_HOME/../Info.plist and add the highlighted lines to JVMCapabilities array:arrays
  4. Create a symlink for libjvm.dylib as follows:
  5. sudo mkdir –p /Library/Java/JavaVirtualMachines/jdk1.7.0_79.jdk/Contents/Home/bundle/Libraries
    sudo ln -s /Library/Java/JavaVirtualMachines/jdk1.7.0_79.jdk/Contents/Home/jre/lib/server/libjvm.dylib /Library/Java/JavaVirtualMachines/jdk1.7.0_79.jdk/Contents/Home/bundle/Libraries/libserver.dylib

    Note: Correct the version number (in jdk1.7.0_79.jdk) path in the above example to make it point to the correct path on your machine.

  6. Set java.library.path by adding the following lines at the end of “/Applications/Adobe Flash Builder 4.7/Adobe Flash Builder 4.7.app/Contents/MacOS/Adobe Flash Builder 4.7.ini”.

Restart your machine and launch Flash Builder.

Possible error

If you are trying to launch Flash Builder on Mac OS 10.12 and you see an error such as:

java.lang.RuntimeException: Application "com.adobe.flexbuilder.standalone.FlashBuilderApplication" could not be found in the registry. The applications available are: org.eclipse.ant.core.antRunner, org.eclipse.ant.ui.antRunner, org.eclipse.equinox.app.error, org.eclipse.equinox.p2.director, org.eclipse.equinox.p2.garbagecollector.application, org.eclipse.equinox.p2.publisher.InstallPublisher, org.eclipse.equinox.p2.publisher.EclipseGenerator, org.eclipse.equinox.p2.publisher.ProductPublisher, org.eclipse.equinox.p2.publisher.FeaturesAndBundlesPublisher, org.eclipse.equinox.p2.reconciler.application, org.eclipse.equinox.p2.repository.repo2runnable, org.eclipse.equinox.p2.repository.metadataverifier, org.eclipse.equinox.p2.artifact.repository.mirrorApplication, org.eclipse.equinox.p2.metadata.repository.mirrorApplication, org.eclipse.equinox.p2.updatesite.UpdateSitePublisher, org.eclipse.equinox.p2.publisher.UpdateSitePublisher, org.eclipse.equinox.p2.publisher.CategoryPublisher, org.eclipse.help.base.infocenterApplication, org.eclipse.help.base.helpApplication, org.eclipse.help.base.indexTool, org.eclipse.jdt.apt.core.aptBuild, org.eclipse.jdt.core.JavaCodeFormatter, org.eclipse.ui.ide.workbench, org.eclipse.update.core.standaloneUpdate, org.eclipse.update.core.siteOptimizer.
 at org.eclipse.equinox.internal.app.EclipseAppContainer.startDefaultApp(EclipseAppContainer.java:248)
 at org.eclipse.equinox.internal.app.MainApplicationLauncher.run(MainApplicationLauncher.java:29)
 at org.eclipse.core.runtime.internal.adaptor.EclipseAppLauncher.runApplication(EclipseAppLauncher.java:110)
 at org.eclipse.core.runtime.internal.adaptor.EclipseAppLauncher.start(EclipseAppLauncher.java:79)
 at org.eclipse.core.runtime.adaptor.EclipseStarter.run(EclipseStarter.java:344)
 at org.eclipse.core.runtime.adaptor.EclipseStarter.run(EclipseStarter.java:179)
 at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
 at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
 at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
 at java.lang.reflect.Method.invoke(Method.java:597)
 at org.eclipse.equinox.launcher.Main.invokeFramework(Main.java:622)
 at org.eclipse.equinox.launcher.Main.basicRun(Main.java:577)
 at org.eclipse.equinox.launcher.Main.run(Main.java:1410)

Locate a directory named “p2” at /Applications/Adobe Flash Builder 4.7/ and delete it. Flash Builder should now launch.

Beta News – Flash Player NPAPI for Linux

Flash Player and Linux

Linux users have access to both NPAPI and PPAPI versions of Flash Player.  However, for the last four years, the NPAPI version has been held at 11.2 and regularly updated with only security fixes while the PPAPI version (used in Chrome and Chromium based browsers), is in line with the standard Windows and Mac releases.

Today we are updating the beta channel with Linux NPAPI Flash Player by moving it forward and in sync with the modern release branch (currently version 23).  We have done this significant change to improve security and provide additional mitigation to the Linux community.

In the past, we communicated that NPAPI Linux releases would stop in 2017.  This is no longer the case and once we have performed sufficient testing and received community feedback, we will release both NPAPI and PPAPI Linux builds with their major version numbers in sync and on a regular basis.

Because this change is primarily a security initiative, some features (like GPU 3D acceleration and premium video DRM) will not be fully implemented.

If you require this functionality, we recommend that you use the PPAPI version of Flash Player.  That said, we believe that the new NPAPI build represents a significant step forward in functionality, stability, and security and look forward to hearing your feedback.

Currently we are distributing 32 and 64 bit binaries only, we will package these in proper installers after additional testing and feedback. Users should manually back-up their existing Flash Player plugin file from the appropriate system plug-in folder and copy the new binaries into place to use them.  Please note that our initial release does not support Fedora based distributions.  For more information, see our release notes.

You can download the new NPAPI binaries today by visiting the Adobe Labs download page.

Feathers 3.0: A New Major Version

Congratulations to Josh Tynjala and the Feathers open source project for the release of Feathers 3.0. Feathers offers a large collection of ActionScript user interface components and layouts for mobile and desktop. It is powered by both Starling Framework and Adobe AIR.


What’s new in this release?

Many of the changes in Feathers 3.0 can be found under the hood, including bug fixes and architecture improvements. This version lays a foundation for new components and features in future versions.

Improved Performance When Idle

Feathers apps benefit greatly from the architecture changes in Starling Framework 2.0. CPU usage in static scenes has dropped to nearly zero with Starling’s new skipUnchangedFrames property. This means that apps built with Feathers should use less battery, which makes them better citizens on mobile devices.

Just take a look at this comparison made by Adobe Scout that shows an idle Feathers 2.3 app compared with the same app running on Feathers 3.0:



In Feathers 3.0, the developer experience gets better too. Let’s look at some of the skinning improvements.

The Scale9Image, Scale3Image, and TiledImage classes are no longer necessary in Feathers 3.0 because Starling 2.0 now supports these capabilities natively in the Image class using the scale9Grid and tileGrid properties.

Here’s an example of using the scale9Grid property with an Image:

var image:Image = new Image( texture );
image.scale9Grid = new Rectangle( 3, 2, 6, 3 );
image.width = 100;
addChild( image );

For components that have more than one state (such as a Button that can be up, down or disabled), Feathers includes a new ImageSkin class that accepts multiple textures.

ImageSkin works a lot like Starling’s Image class, but it adds a new setTextureForState() method that can be used to pass in additional textures. Take a look at this example of using ImageSkin to skin a Button component’s states:

var skin:ImageSkin = new ImageSkin( upTexture );
skin.setTextureForState( ButtonState.DOWN, downTexture );
skin.setTextureForState( ButtonState.DISABLED, disabledTexture );
skin.scale9Grid = new Rectangle( 3, 2, 6, 3 );
button.defaultSkin = skin;

Migrating from Feathers 2.x to 3.0

Feathers 3.0 includes many more improvements, and some of them may require changes to your existing Feathers apps. Please read through the Feathers 3.0 Migration Guide for complete details about upgrading to this new major version.


You may also want to review the Starling 2 Migration Guide because it provides specific hints about upgrading Starling.

Get started with Feathers 3.0.0

You can find the Feathers UI 3.0.0 release notes on the project’s Github page. Developers are encouraged to download the latest stable version from the Feathers website.

How to provide video rotation information to ActionScript as metadata


By Jason Lee

Prior to Flash Player and AIR version 20, the Flash runtime does not correctly process the matrix field values in the Track Header Box and the Movie Header Box, as defined in the ISO specification ISO/IEC 14496-12:2008. As a result, in some instances, the user experiences an incorrectly resized and rotated video when the video is played back with Flash. The problem is particularly pronounced when playing videos that are recorded in portrait mode with old Android or iOS devices. This happens because these devices save video in landscape mode along with a matrix representing rotation transformation, when the users record the video in portrait mode.

Flash Player and AIR version 20 introduce a feature whereby video rotation meta-data is provided through ActionScript. This feature mitigates the problem discussed above by providing the video matrix information to ActionScript as a part of the meta-data object of the onMetaData event, an event handler of the NetStream object. This allows the ActionScript developers to render the video in the intended rotation matrix. It should be noted that the Flash Player engine does not automatically apply the video matrix information to the rendered video output, so as to avoid any resizing or rotation that is not intended by the ActionScript developer.


The ActionScript code example below shows how to apply the rotation matrix to the Video object.

Note: The example assumes that the video is recorded along a matrix representing 90° clockwise rotation.

var video:Video = new Video();
 var nc:NetConnection = new NetConnection();
 var ns:NetStream = new NetStream(nc);
 ns.client = {};
 ns.client.onMetaData = ns_onMetaData;
 ns.client.onCuePoint = ns_onCuePoint;
function ns_onMetaData(info:Object):void {
 video.x = 0,
 video.y = 0;
 video.width = info.width;
 video.height = info.height;
 varmatrix:Matrix = video.transform.matrix; // Read old transform matrix of video object.
 varoldSize:Point = new Point(video.width, video.height);
 varnewSize:Point = new Point(Math.abs(info.matrix.transformPoint(oldSize).x), Math.abs(info.matrix.transformPoint(oldSize).y));
 matrix.translate(-(oldSize.x / 2), -(oldSize.y / 2));
 if (info.hasOwnProperty("trackHeaderBoxMatrix"))
 matrix.concat(info.trackHeaderBoxMatrix[0]); // Apply the matrix of the Track Header Box of Video Track provided by this feature to video object.
 // trackHeaderBoxMatrix is an array of MatrixObject because there can be one or more video tracks.
 if (info.hasOwnProperty("movieHeaderBoxMatrix"))
 matrix.concat(info.movieHeaderBoxMatrix); // Apply the matrix of the Movie Header Box provided by this feature to video object.
 matrix.translate((newSize.x / 2), (newSize.y / 2));
 video.transform.matrix = matrix; // Set new matrix to transform matrix of Video object.
 function ns_onCuePoint(item:Object):void {

The feature works for NetStream objects using progressive download, which allows Flash runtime to download and directly parse a video file. However, this feature does not handle NetStream using RTMP or appendBytes, in which case, the matrix properties provided by this feature are not available. This feature provides the matrices for all file formats — MP4, M4V, F4V, and 3GPP in accordance with ISO specification ISO/IEC 14496-12:2008, when using progressive download. For all other file formats, such as FLV, the matrix properties provided by this feature are not available.

The matrix information provided by this feature can only be applied to an instance of the Video class. Therefore, with StageVideo, which uses GPU acceleration, for example, the matrix information is not applicable.

This feature introduces the following new properties of the object representing video meta-data, a parameter of onMetaData event handler:

  • Object.movieHeaderBoxMatrix: flash.geom.Matrix
  • Object.trackHeaderBoxMatrix: An array of flash.geom.MatrixtrackHeaderBoxMatrix is an array of MatrixObject because there can be one or more video tracks in a single video file.

If you are a Flash content developer and are having trouble getting a video to display in correct orientation, please try this new ActionScript functionality for handling video rotation meta-data.

TestFairy – A mobile beta testing platform

Have you been looking for ways to improve your mobile testing?  I’ve recently seen a demonstration from the folks at TestFairy and was blown away at the level of integration and functionality that they’ve made available to developers.  If you’re looking to improve the quality of the bug reports that you receive from your testers and you want easy integration into your AIR application, definitely check out TestFairy to see what they have to offer.  There are both free and paid plans available.

Check out the video below to see how easy it is to use and implement in your application!  The TestFairy ANE can be downloaded here.

Issues while downgrading from AIR 20 to a lower version on Mac OS X


By Eric Simenel

This tech note addresses the problems that you may face when attempting to downgrade from AIR version 20 to an older AIR version. Prior to AIR version 20, AIR was provided as a 32-bit Runtime dynamic Library for Mac OS X. However, with the release of AIR 20, only a 64-bit Runtime dynamic Library is provided on Mac OS X. See AIR 20 release notes for details.

Certain users who are running apps that require 32-bit ANEs may want to downgrade to a lower AIR version that supports a 32-bit Runtime dynamic Library. Prior to AIR 20, downgrading AIR to a previous version (let’s say AIR 19) is a simple process:

  1. Download AIR 19 runtime. For downloading any other versions, see Archived Adobe AIR SDK versions.
  2. Uninstall AIR 20 runtime. See Removing Adobe AIR for details.
  3. Install AIR 19 runtime. See Installing Adobe AIR for details.
  4. Run AIR Settings manager utility to disable further updates of the runtime.

However, these steps will not suffice when you are downgrading from AIR 20 to a previous AIR version as there are some additional steps required in this case. To meet this requirement, the additional steps or the solutions are explained below.

Downgrading from AIR 20

Starting with AIR 20, which is a now 64-bit Runtime (instead of the previous 32 bit AIR runtime), the process for downgrading is the same as mentioned above. But there are certain points, which require attention when attempting to downgrade.

After you install AIR 20, any previously installed AIR app using the Shared Runtime that is launched gets updated. So the app’s launcher code will now be a 64-bit binary. The previously used 32-bit launcher gets renamed with a ‘_32’ suffix.

Note: AIR Captive Runtime Apps are unaffected by this upgrade to AIR 20. See AIR 64-bit on Mac OS X for more details.


If you go back to a previous AIR version, for example, AIR 19, then after uninstalling AIR 20 and installing AIR 19, an attempt to launch the updated AIR app fails because the new 64-bit launcher is unable to find the 64-bit AIR Runtime.

This problem occurs only when attempting to downgrade to an older version.


You can use either of the three solutions to resolve this issue:

Solution 1: Move the application to the Trash, empty the Trash, and reinstall it from its .air package or custom installer as you did when you installed it the first time.

Solution 2: Rename the launchers at <AIR application>/Contents/MacOS/.

  1. For the launcher with no suffix, add a ‘_64’ suffix.
  2. For the launcher with the ‘_32’ suffix, remove this suffix.

Note: Here launcher refers to the name of your <AIR application>.

Solution 3: Edit the contents of the info.plist file so that its CFBundleExecutable key has the ‘_32’ suffix. The info.plist file is present at <AIR application>/Contents/.

Downgrading after an initial AIR 20 installation from a SideCar

There is another issue that a few users may face — specifically, those who install an AIR application with a SideCar AIR 20 installation; having never before installed an AIR shared runtime and then downgrading from AIR 20.

Note: An AIR SideCar Installation is one where an .air package is distributed alongside the AIR installer so that both AIR and this application are installed at the same time.

After an Initial AIR 20 installation from a SideCar, launching the .air package results in Mac OS X “blessing” the Adobe AIR Installer that sits next to it. Hence forward, Mac OS X remembers this application as the default launcher for an .air package. If you do not delete this directory after installing, then anytime you launch an .air package, this Adobe AIR Installer is launched. Checking that the AIR Runtime is now present, it goes on with the standard AIR App installation that is done by the AIR Runtime.


Now when you uninstall AIR 20, install AIR 19, and then try to launch an .air package, this attempt fails because the Adobe AIR Installer that is a 64-bit binary is unable to load the AIR Runtime that is now a 32-bit binary again. That Adobe AIR Installer (version 20) keeps its precedence over the Adobe AIR Application Installer (version 19) that is present at /Applications/Utilities because the Adobe AIR Application Installer has not been launched yet and is “invisible” to Mac OS X.


The solution to this issue is to simply delete the directory that contains the SideCar .air package and Adobe AIR Installer so that this 64-bit binary longer exists. Thus, it will not be launched by Mac OS X when .air launches. Instead, the 32-bit Adobe AIR Application Installer will be launched.


Feathers UI 2.3.0 Update

Congratulations to Josh Tynjala and the Feathers open source project for the release of Feathers UI 2.3.0!  Feathers offers a large collection of ActionScript user interface components and layouts for mobile and desktop.  Feathers is powered by both the Starling Framework and Adobe AIR.

feathers date time spinner

What’s new in this release?

In version 2.3.0, Feathers UI includes a new DateTimeSpinner component and a number of powerful new features that have long been requested by the community.

The DateTimeSpinner component is a mobile-style date and time picker built with a series of SpinnerList components.

List and GroupedList now support the ability to display more than one type of item renderer in the same list. It’s now easy to style the first or last item renderer differently or to choose the type of item renderer based on the values of an item’s properties.

TextureCache makes it possible to reuse textures loaded from URLs, instead of potentially recreating them multiple times. It’s perfect for lists that need to display many images. TextureCache can save bandwidth, but watch out because it can require more memory.

TapToTrigger, TapToSelect, and LongPress make it easy to add simple gestures to custom components, such as item renderers.

Text renderers now support the ability to automatically change font styles when their parent component changes to different states. For instance, a text renderer used by a Button component can now detect when the button is being pressed, and the color of the text will be updated. Unlike previous APIs like downLabelProperties and hoverLabelProperties, this new approach can be more strictly type-checked by the compiler, leading to fewer mistakes in your code. Additionally, this feature can be used by other components with states, such as a TextInput (which may be focused or disabled).

Finally, this version also includes a new TopcoatLightMobileTheme, which is based on a contribution by Marcel Piestansky.


Let’s look at a quick example of using a TextureCache class with a List:

var cache:TextureCache = new TextureCache(30);
var list:List = new List();
list.itemRendererFactory = function():IListItemRenderer
    var itemRenderer:DefaultListItemRenderer = new DefaultListItemRenderer();
    itemRenderer.iconLoaderFactory = function():ImageLoader
        var loader:ImageLoader = new ImageLoader();
        loader.textureCache = cache;
        return loader;
    return itemRenderer;

In the code above, every ImageLoader that appears in the List will share the same TextureCache. As the List scrolls, the newly loaded textures will be saved, but existing textures will be borrowed from the cache.

Get started with Feathers UI 2.3.0

You can find the Feathers UI 2.3.0 release notes on the project’s Github page. Developers are encouraged to download the latest stable version from the Feathers website.

AIR 64-bit on Mac OSX

By Nidhi Tanwar


With the release of AIR 20, the feature AIR 64-bit implies a major change for the AIR desktop developers. In the previous AIR versions, a 32-bit Runtime Dynamic Library was provided for Mac and Windows. However, with the release of AIR 20, only a 64-bit Runtime Dynamic Library is provided on Mac OS X. This means that all the new applications created by AIR developers will run on the 64-bit Runtime on Mac OS X. All the existing shared applications, captive applications, and native applications will continue to work on the 64-bit Runtime on Mac OS X.

Changes for existing applications

The existing AIR applications require the following changes when using AIR 64-bit.

Shared, Captive, and Native applications

These applications will continue to run on AIR 64-bit.

Native extension

All the native applications that use a 32-bit ANE need to add a 64-bit ANE to continue working with AIR 20 and beyond on Mac OS X. To create a 64-bit ANE, you have to provide the platform value as MacOS-x86-64 in the extension descriptor file and in the command used to create the ANE.

So, a native extension descriptor file for Mac OSX will have the following structure:

  <platform name="MacOS-x86-64">

And the command for creating the ANE will be:

adt -package  -target ane  path/where/you/want/YourANE.ane YourExtensionDescriptor.xml  -swc YourAIRLibrary.swc  -platform MacOS-x86-64  library.swf YourMacOSNativeLibrary.framework

Libraries and frameworks for Xcode

When you are creating the native code extension for 64-bit architecture using Xcode, the following libraries and frameworks have to be included in Xcode (see figure below):

  • Adobe AIR.framework
  • Adobe AIR_64














Note: If you do not add Adobe AIR_64, which is a 64-bit dylib inside the Adobe AIR framework, you may get link errors such as “ld: symbol(s) not found for architecture x86_64 error.”

Linking ANE using Flash Builder 4.7

If you are linking your AIR application with 64-bit ANE using Flash builder 4.7 by adding the ANE in ActionScript Build Path for the AIR project, you will notice that there is a red ‘X’ next to the ANE file entry in the Build Paths dialog box (see figure below). If you click the triangle, you will see the error “This ANE does not support air-native-macosx platform”. This is a quirk in Flash Builder 4.7; if you click the triangle next to Targets, you will see that MacOS-x86-64 is supported by the ANE.

Linking ANE using Flash Builder 4.7


The red ‘X’ issue is observed again when you are packaging the ANE by including the ANE in ActionScript Build Packaging.

Ignore the error and click OK.



When you are creating your native application from the Project >Export Release Build, Flash Builder displays a packaging error. To continue with app creation, check select Ignore Errors in Native Extensions tab and click Finish. Your application will be created successfully.



Related Documents

Flash Runtime v20 Release Announcement!

We’re pleased to announce the immediate availability of Flash Player and AIR version 20!  With this December release, we’ve added new features, important security updates and functional bug fixes for our customers.  Full details on this release can be found in our release notes and security bulletin.

Updates for Flash Player 20 have automatically started rolling out to those that have enabled “Allow Adobe to install updates (recommended)”.  If you’ve opted into this auto update mechanism there’s no work required on your end.   Over the next 24 hours we’ll be pushing this update out silently and automatically to computers connected to the internet.

Customers using Google Chrome or Windows 8.x/10 Internet Explorer or Microsoft Edge will receive the update through the Google and Microsoft update mechanisms.

Last week we made some exciting announcements around Flash Professional, now Adobe Animate CC, and a new partnership for the Flash Runtime.  The future is very bright for the Animate CC team and for the designers and developers that use this tool.  The changes and improvements they’ve made and have planned for 2016 are inspiring and we’re more than confident that they will continue to deliver the innovation that our customers need to succeed.

On the Flash Runtime side, we’re thrilled to announce our partnership with Facebook.  We know that our customers and developers rely on Flash content to work securely and reliably.  With this new partnership with Facebook, our ongoing collaboration with both Google and Microsoft, and our close work with Apple, Mozilla, Opera and others, we’re committed more than ever to making the Flash Runtime secure, reliable, and compatible for everyone.

As we close out 2015, Flash Player enjoys amazing ubiquity with full support from every major browser and operating system in use today.  Flash Player is built into every version of Google Chrome and ChromeOS.  Flash Player comes as part of both the Windows 8 and Windows 10 operating systems and works seamlessly with both Internet Explorer and Microsoft Edge.  Flash Player has full support from Mozilla Firefox, Apple Safari, and Opera.  This unprecedented level of support allows our developers to be successful and our customers to enjoy the content they want to use, view, and play.  We look forward to great things to come in 2016 and we wish everyone a happy new year!


Read past the break for the highlights of this release!

Continue reading…