AIR, Titanium and webOS: 10 Things You Can’t Do in A Browser

You can't do that

In the past two years I’ve spent most of my free time working on desktop applications written in JavaScript, HTML and CSS. I write them on top of web runtime platforms like Titanium and Adobe AIR, and more recently Palm’s webOS. In this time, I’ve heard a misconception raised repeatedly: that “local” (desktop or mobile) applications written on top of web runtimes offer no advantage over remotely-hosted, browser based apps. Or, to paraphrase something I overheard recently:

HUH huh your app is written in JavaScript and HTML, why don’t you just load the web site DURRRR.

I suppose this kind of thinking comes from the JS+HTML+CSS being almost exclusively used for web site front-ends for so many years. It’s a knee-jerk reaction, much like the one that says “oh, you can’t use PHP in the ‘enterprise’” or “Oreos aren’t for breakfast.” Proved my mom wrong on that one.

So, I decided to make a list of what things you can do in a web runtime platform that you can’t do in a browser. Now some of these vary depending on the platform or the browser, and I’ll try to make note of them in my list:

  1. Cross-browser compatibility issues are a thing of the past
    I should offer a caveat here — even though the rendering engines are the same, you’ll sometimes run into OS rendering differences. AIR, for example, supported CSS3 box shadows on OS X until v1.5, but never did on Windows. But the differences are far, far smaller than you’d see between, say, Safari 3 and IE6. Trust me — you will love not having to worry about getting your layout working in some ass-tastic box model implementation anymore

  2. Advanced rendering features (CSS3, etc)
    Since you don’t have to worry about looking the same in different browsers, you can take advantage of the special features your runtime’s rendering engine supports. Titanium, for example, supports the same advanced CSS features that Safari 4 does, like box shadow, border radius, and CSS gradients.

  3. File system access
    On desktop web runtime platforms like AIR and Titanium, you can interact with the filesystem just like any other application: read, write, and create files and folders with the permissions of the executing user. webOS offers less freedom in this respect, but you can read and write files on a limited basis.

  4. Networking
    Both of the major desktop web runtime platforms provide much more advanced networking capabilities than are available within a browser. I’m not much of a networking programmer, but both platforms allow the developer to open TCP socket connections and communicate over them. Titanium seems especially well-prepared in this area, with its ability to leverage Python and its powerful networking capabilities.

  5. No same-origin policy restrictions
    If you want to pull data from a web site other than your own in the browser, you have to resort to JSONP — basically an XSS attack waiting to happen — or set up a proxy on your site’s server. Web runtime app platforms don’t have this issue, so you can make XHR calls to any domain you wish, and interact with any APIs.

  6. No need to support non-JS users
    This might seem like a small issue, but having to support users who have disabled JS was one of the major reasons I never did serious browser-based frontend programming before I started working on Spaz two years ago. Now the cool kids at SXSW will tell you that “nobody” disables JavaScript, but I think that’s kind of short-sighted.

    Nevertheless, this argument and the need for graceful degradation and “unobtrusive” JavaScript become moot in the web runtime app platform. JavaScript is there, it’s expected, and you can’t disable it. So go crazy.

  7. Using/interacting with platform-specific UI elements
    This includes things like window chrome, menu systems, Dock items (OS X), menulings (OS X) and the System tray (Win/Linux). Both major web runtime platforms display your application within the native window chrome, allow you to create native menus, and give you some access to the system tray and OS X’s Dock. Titanium is a bit better in this regard in that it inherits the native look of form widgets and scrollbars, and provides access to the OS X menubar (those little icons in the top-right).

  8. Sound playback without plugins
    Until HTML5 becomes standard in all browsers and bestows the grace of plugin-less media playback, we’re stuck <embed>ing <object>s in our gorgeously crafted markup. Funk dat. Web runtime platforms provide sound playback APIs that mean we don’t have to stick a Flash applet in our document and hope it doesn’t catch the CPU on fire. AIR has a particularly good playback API (probably because the whole thing is running in a Flash engine. Small victories).

  9. Interacting with other applications/shell interaction
    Being able to leverage other applications on the machine/device can be really valuable, especially on Unix OSes (Mac OS X, Linux, etc) that have a bevy of useful utilities available from the shell. Titanium is the only desktop web runtime platform that allows the developer full access to these capabilities; AIR is limited to interacting with other Flash-based applications at this time (although this may change in the future). Runtimes on mobile devices are typically much more limited, although webOS’s Application Manager service does let applications launch and pass arguments to other apps.

  10. Database support
    Typically this is implemented either via the HTML5-style database stuff (usually asynchronous) or a platform-specific SQLite (usually synchronous). Out of the box, support isn’t provided for external DB servers (MySQL, PostgreSQL, MS-SQL, etc), but with Titanium this should be possible by delegating to Python or Ruby scripts, or Titanium kernel modules. DB servers that provide HTTP interfaces (like CouchDB) will work fine, though.

All of this doesn’t mean web runtime platforms are going to replace browser-based apps anytime soon. There are clear advantages to remotely hosting an application (speed of updating comes to mind), and supporting an app on a user’s machine brings a new group of debugging headaches. But for applications already chafing at the limitations of the browser, web runtime platforms offer a compelling option.

  • Tim Wright
    07/13/2009 01:45:22 PM

    Great read, thanks

  • Richard Orelup
    07/13/2009 02:03:08 PM

    A great summary of a lot of the points missed by people on this subject.

    One thing I think a couple of these points show but is not explicitly said (or I missed it while reading through) is that these applications don’t need to be online. They can be created to be offline applications or apps that only need to be online part of the time but still function. Now with Gears or BrowserPlus you can gain some of this functionality but overall it’s not as smooth as Air or Titanium (especially for a fully offline application, though I haven’t written one of those in forever.)

    I think this is another strong point for these platforms and why I’ve been pushing them myself for the projects we have been doing.

  • Robert Peaslee
    07/13/2009 04:25:20 PM

    Wow, great write-up. I actually always wondered what the advantage of using something like Air was, now I know. I’m not even ashamed to admit that I want to play with it ;)

  • Scotty Delicious
    07/14/2009 07:52:23 PM

    Great post Funkatron. I have been playing around with Appcelerator Titanium recently and really digging it for many of the reasons you listed here.

  • David Dieguez
    07/17/2009 11:24:43 PM

    Very useful read. We’ve been using a couple of nice apps on AIR.

  • Cristian Acuña
    08/07/2009 08:45:23 AM

    Wow what great great write-up and just-in-time. I actually write a web-based desktop application using SWT, but I think to give a try to Titanium. Very thanks for this info. Best regards

  • foebits
    11/15/2009 10:41:00 PM

    I can’t see #1 in Firefox.

  • Nash Tsai
    02/11/2010 01:45:23 PM

    Adobe has limitation on multi-threading support , how is Titanium deal with multi-threading? Will Python Threads work?

  • funkatron
    02/11/2010 02:22:38 PM


    Generally, you’re in a much better situation with Titanium Destkop than AIR.

    Titanium supports the Web Worker API. I am not sure about concurrency within the Kroll kernel, which is where the scripting languages execute — I dunno if the different interpreters all execute in a single thread or not. You can also access and spawn external processes, which you can only do with native-built packages in AIR 2.