A scientific performance comparison: Flex/Flash vs. JavaFX vs. Silverlight vs. JavaScript

I finally finished my diploma thesis I mentioned before about performance comparisons between Flex/Flash, JavaFX, Silverlight and various JavaScript engines.

Why this analysis?

During an internship at IBM Germany back in 2009, I had to develop a Visualizer based on Flex that heavily relied on its charting library API. Even on strong machines, it was not possible to create more than 20 charts on one screen at the same time. If tried, the application terminated with a timeout exception after 60 seconds because it simply took the rendering engine to long to draw all the charts at once. These experiences lead to thoughts about questions why the Flash Player sometimes performs so slowly and if other technologies like JavaFX or Silverlight could do any better. While looking for answers, I encountered two benchmarks. One is Alexey Gavrilov’s Bubblemark test which moves around bitmaps on the screen capturing the current fps. The other one is Sean Christmann’s GUIMark, which simulates a common website layout and lets it scale up and down. While Gavrilov’s attempt is rather simple, Christmann’s benchmark is a bit more complex including aspects like transparency and overlapping layers. Both tests include technologies like Flash/Flex, JavaFX, Silverlight and Javascript. All these attempts have one thing in common though: They represent only one big benchmark instead of cutting down the issue into multiple aspects. This leads to the problem that one cannot clearly see what the reason is why solution A is faster or slower than B.

For example: Moving around bitmaps, as shown in Gavrilov’s Bubblemark benchmark, may sound simple but heavily relies on multiple aspects of a RIA runtime: First, to display images, a graphic-buffer needs to be filled with the bitmap data. Then it needs to be drawn to a canvas-like component and finally shown on the screen. To move around the images, mathematical calculations are required to let the balls bounce from the walls. Furthermore, some kind of data structure like (dynamic) lists or arrays must be used in order store each ball-object in. While running the test, one never knows what was the cause for performance decreases. Was it the »physics engine«, the image processing calls, the array/list operations or something else?

This lead to the idea of developing a series of tests to drill down to the core of performance issues, which leads to two benefits: One is that developers who already know their requirements for their applications can choose the RIA technology that fits best for their needs, based on the result of these test series. The other one is that RIA manufacturers can optimize their virtual machines and browser plug-ins based on the conclusions of this thesis.

The tests

Run the tests, download the source and view the results here.

Feel free to download everything and play around with it. Most of the sources are released under the MIT license. Some others use GPL or BSD so make sure to check the license agreement in the header sections of each project/file but in general you don’t really have to worry about them since they’re all open source licenses. Just watch out for the copyleft agreement in GPL.

OpenLaszlo: A new old rival for Adobe Flex

Around two years ago, I wrote a little article about OpenLaszlo, a promising RIA framework, for richability.com in which I compared it to Adobe’s Flex platform.
Since a lot of time has passed and many things changed since then, I think it’s time for an updated sight on this technology.

Back in the days when I wrote that article, my main arguments were (summarized):

  1. Flex can only target the Flash Player while Laszlo offers both, a Flash compiler as well as a DHTML version.
  2. Flex is much more popular than OL (OpenLaszlo).
  3. Costs for OL development are lower since Adobe’s Flash Builder (formerly known as “Flex Builder”) is quite expensive while OL does not require a dedicated IDE.

While arguments 1 and 2 still apply, I need to correct my statements about #3:

Both, Flex as well as OpenLaszlo, are frameworks, which include a compiler and a component library. While Flex utilizes a combination of MXML and ActionScript3, Laszlo requires LZX and JavaScript knowledge. There is no much difference regarding the basic concept between these two but the developer must be aware that it’s the compilers job to transform these languages into plain ActionScript3 code. The reason for this is that the Flash Player, which runs these applications, cannot understand MXML, LZX or JavaScript. The only language it can process is ActionScript, which is the reason why a compiler is required.
Now, regarding argument #3 from above, it must be said that actually no money is required in order to develop Flex or OpenLaszlo applications, since both compilers can be invoked from command-line, similar to the “javac” command in Java. In order to create the source code, a random editor of choice can be used. In my arcticle on richability.com, I must admit that it looked like if OpenLaszlo development was completely free of charge while Flex always requires money. This was not correct. It is possible to create both, Flex and Laszlo applications, without paying a single cent.

Now, regarding coding comfort, it must be said that a special IDE for Flex/OL development would be nice. This is actually where things change: While Adobe offers the so called “Flash Builder”, a pretty expensive (but in the same time awesome) Eclipse-based tool for creating Flex applications (which is also available as a plugin-version), the OpenLaszlo founders do not offer a comparable IDE. There is a free 3rd-party alternative available though called IDE4Laszlo.

To sum it up: Flex development does not have to be more expensive than Laszlo, but it probably will be since serious application developed cannot be done without a good IDE these days.

Flex benefits

As already mentioned, application logic in OpenLaszlo is being written using JavaScript, which is a waay inferior programming language compared to ActionScript3. I know, JS is object-oriented and all but it lacks some very important features, like:

  • Static type-safety
    In ActionScript3, we have static types (except for arrays, but vectors are a good replacement), which means that a compiler can give warning/error messages regarding type incompatibilities before runtime. In JavaScript, this is not possible.
  • Interfaces
    In huge projects, the concept of interfaces is often important. ActionScript3 supports these. JavaScript does not.

I really wished, OpenLaszlo would support a better programming language, like for example Java or C#.

Update: Thanks to P T Withington for the note below:

“OpenLaszlo as of version 4.2 (currently at 4.7) supports extensions to Javascript modelled on Actionscript3. You can create classes and declare interfaces and types just as in as3. When compiling to DHTML, the type declarations are not (currently) enforced, but they are if you compile to Flash.”

OpenLaszlo benefits

Some days ago, a guy called Femery Arnaud from France sent me an email asking why the Flash-compiled versions of Flex are so much bigger than the ones from OpenLaszlo. According to a test made by him, a sample project consisting of a DataGrid, a tree component and an image required 2.5MB on Flex and only 250KB in OL.
To be honest, I didn’t really have a quick and smart answer since I never had a closer look into file-size related issues between both technologies. My guess was that this has something to do with the efficiency of the framework-compilers as well as the complexity and size of the UI component libraries but I couldn’t say for sure.
However, it seems like OpenLaszlo applications require much less space then their Flex-pendants if they are compiled into Flash. This fact should not be disregarded since there are still many users out there with small bandwidth internet connections.

The rise of the underdog

Due to the hype about HTML5, recent debates around Flash have probably made some developers feel uncomfortable about their future and rised some questions like for example: “Will Flash still exists in 4 or more years and is there still going to be a demand on Flex developers as there is today or is it better to switch to HTML5/JavaScript development now?

To be honest, I have similar thoughts going around my head and I don’t have a real answer to this, but there are some facts which we are already aware of today:

  • HTML5 definitely has the capability to be a replacement for many use-cases which made Flash required on the web.
  • HTML5 is still in its baby-shoes. Neither is its specification finished, nor are the implementations in today’s browsers perfect.
  • There are still some users out there surfing the web with HTML5-incompatible browsers.
  • Flash requires a plugin which implies the fact that some users, who do not have it installed, are being prevented to access Flash content.
  • Many people do not like Flash due to instability reasons. I know, this is not a hard fact, but I hear this complaint pretty often.
  • HTML5 has no support for binary sockets and web-cams.

Keeping these informations in mind, I wouldn’t say that Flash gets completely “killed” by HTML5 but I think it’s reasonable to say that it will probably reduce the demand of Flash (and their developers) in the future. It is just a matter of time.

Now, here comes the bridge to OpenLaszlo since its one huge advantage compared to Flex is its compiler feature of giving the developer the opportunity to choose between Flash and DHTML output. According to rumors, even Silverlight and SVG output is being planned.
So, what does this mean to the developers? – Actually quite simple. Learning OpenLaszlo gives one the ability to target different platforms with one code base. Your customer does not want Flash? Flip the DHTML switch and you’re done. This feature makes the requirement of learning multiple additional technologies like GWT or Silverlight redundant and could give Laszlo a big boost regarding popularity among RIA developers.

There is no HTML5 vs. Flash

Ok, hands down. Sooner or later, Flash will not be relevant to the WWW anymore. Flash videos will be replaced by <video> while animations will use <canvas> and <audio> in HTML5.

There are a few things Flash can do, but HTML5 cannot, like:

  • Webcam support
  • Binary sockets (not web-sockets!)

But these features will sooner or later be covered by HTML as well, so there is no need for Flash anymore on the web.

But what about the Desktop?

As I already stated, Flash could become the next-gen Java-replacement for Desktop applications.

The reason why I think so is simple:

  • Flash/Flex applications are easier and faster to develop than Java (thanks to MXML). This improves workflow and thus reduces costs for software companies.
  • There is already a wide range of developers that have experience with Flash development, so there is no new programming language/technology to learn for these people. They can start develop rich desktop applications right away.
  • Flash-based desktop-applications simply provide a nicer user-interface and their look ‘n’ feel is “smoother” than Swing.
  • The Photoshop/Illustrator-Catalyst-FlashBuilder workflow is great and definitely enhances work of designers and developers. There is nothing compared to that in classic software development.

So, what I want to basically say is:

HTML5/Ajax for Web and Flash/Flex/AIR for the Desktop!

That’s why I think that both are not competitors. Their future lies on two difference battlefields.

Please, Adobe. Give us the Ajax Builder!

I think, I already mentioned that I really like Adobe’s products for creating animations and rich internet applications, which are namely Flash Professional, Flash Builder, Catalyst and Illustrator. What I don’t like is the target platform: The Flash Player. So, after all these debates about Flash, isn’t it time to simply drop the Flash Player and add an additional compiler option for Flash Builder and Flash Professional? Yes, you guessed right. I am talking about HTML5 deployment. Wouldn’t it be great if one could build rich internet applications using technologies like ActionScript3 and MXML, which are both superior to JavaScript and pure HTML, without being forced to target the Flash Player? Flash Professional could simply render into HTML5’s <Canvas> element. It has already been shown, that this is possible. Flash Builder could simply transform the code base into HTML/Ajax, similar to the client-side part of GWT. I know that I might sound a bit childish here but, I’d call this “Ajax Builder” :-D

Don’t get me wrong. I didn’t say: “Replace the Flash compiler option.” – This is important since there are still some things HTML5 can’t handle, like webcam support for example.
=> No Flash, no ChatRoulette.
So, til HTML5 is ready to completely replace Flash, both compiler options must be offered.

Also, the whole Illustrator-Catalyst-FlashBuilder workflow should be kept and optimized for HTML5. Although Catalyst is still in its baby-shoes and has some serious mis-concepts, the basic idea is great. Adobe should keep working on this.

Further, AIR shouldn’t be canceled if Flash gets (ever) dropped. Instead, AIR could be a great way to bring Ajax-based rich internet applications to the desktop (and mobiles).

The benefit is clearly visible: Flash-developers can keep using their knowledge about AS3, MXML and Adobe’s software products, but simply target a Flash-free platform.
In the same time, all this Flash-sucks-no!-Flash-is-great-blahblah would finally come to an end.

Update: Seems like, Adobe heard me :-)

Google Chrome Flash debugger not connecting to Flex/Flash Builder?

If your Flex/Flash Builder has suddenly problems connecting to your Flash debugger, you might be using Google Chrome.

It seems like Google started bundling the Flash Player together with Chrome, which has an automatic updating engine (in the background) and thus you probably didn’t notice the update. This integrated version of Flash Player is the standard version of the plug-in and not the debugger version. Hence, whenever you view Flash content through Google Chrome, the used runtime is not the one you installed on your local operating system.

Currently, there are two workarounds for this:

  1. Manually replace the Chrome Flash player with the debugger version (Thanks to Josh for the how-to).
  2. Use a different browser for testing your Flash applications in.

Workaround #1

Follow these steps:

  1. Go to chrome://plugins
  2. (For Google Chrome version 6.x and higher only: Click the “details” link in the top right corner.)
  3. Find the entries that say “Flash”.
  4. On Windows 7, deactivate the entry, which has the following path:


    On MacOS X, the path is:

    /Applications/Google Chrome.app/Contents/Versions/chrome_version/Flash Player Plugin for Chrome.plugin

    This will disable the integrated Flash Player bundled with Google Chrome. Watch out not to disable your operating system’s default Flash Player (debugger). You can see the difference in the installation path: The global Flash Player is not installed into a directory associated with Chrome.

workaround #2

In Flex/Flash Builder (or Eclipse), simply go to Preferences -> General -> Web Browser and hit “Use external Web Browser“. Then pick Safari, Firefox or whatever you prefer. This choice will then be your “development test browser”, while you can use Chrome for your daily surfing needs.