Robi Karp is CEO of Fluffy Spider Technologies.

The Autonomous User Interface (AUI) is a revolutionary approach to UI design and implementation that goes beyond the custom themes, icon sets, and color schemes common on many mobile phones and other intelligent devices. Through scriptable, autonomous UI coding, AUI lets OEMs, developers, integrators, and other ecosystem participants completely control and customize the look-and-feel of the end-user experience.

With traditional design methodologies, application code "owns" the particulars of UI implementation, determining the type, orientation, placement, and other attributes of objects on the display (buttons, widgets, etc.), the flow of their use and the callback code that powers those elements. The attributes of a UI design are thereby set in the original design and are only minimally mutable downstream, by channel partners, third-parties and end-users. Some UI and application frameworks support theming -- customization of color schemes, menu text styles, window frames, widget sets, etc. However, the fundamental structure and flow of an application UI remains set in stone -- a closed box as imagined by the original design team.

On the other hand, the concept of an Autonomous User Interface lets application developers specify generic or abstract presentation of controls, widgets and even content, giving downstream developers the freedom to brand and customize. Benefits to this approach include:

• Letting developers bind custom functionality to individual UI elements with run-time scripting
• Supporting addition and/or removal any item from an application UI, including images, videos, and widgets, without changing any application code (i.e., with binary program images)
• Enabling existing applications to integrate reaction with new device events and capabilities, like shaking and orientation (accelerometer), location and movement (GPS), and definable data and network events (calendars, stock quotes, sports scores, wireless traffic, etc.)
• Letting integrators, operators and end users easily add new UI personalities at run-time without changing shrink-wrap application code
• Supporting transformation of UI elements, including buttons, controls, images and videos with 2D/3D graphics effects, to scale, reflect, rotate, alpha blend, shadow, etc. with minimum pre-load or post-load software development effort

Autonomous UI Architecture

Breaking out application and presentation code doesn't require radical rethinking of the core application design. Application code can still solicit input and generate output. It is still up to the application design team to determine how much control resides inside the application itself vs. the amount exposed to subsequent modification. But decoupling does require specific support from the underlying graphical and multimedia framework.

Key enablers of an autonomous UI include:

• Providing safe binding between underlying graphical system APIs and an external, open programming environment
• Exposing inventories of (public) application objects that implement UI functions
• Supporting a protocol between presentation code and the application for information exchange

It is also important to provide an open high-level API for developer use. The API is of course the main point of entry for developers, and also simplifies translation of information between the language bindings using the protocol. At Fluffy Spider Technologies, we chose C for building FancyPants (our high-performance multimedia and graphics platform for embedded applications) and for underlying libraries. For enabling Autonomous UI code, we bind to the Lua scripting language at a high level, taking advantage of Lua features and rapid prototyping capabilities.

Lua Scripting Language

Lua is a powerful, fast, lightweight, embeddable scripting language. Lua combines simple procedural syntax with powerful data description constructs based on associative arrays and extensible semantics. Lua is dynamically typed, runs by interpreting bytecode for a register-based virtual machine, and has automatic memory management with incremental garbage collection, making it ideal for configuration, scripting, and rapid prototyping.