javeline platform

From Wikipedia, the free encyclopedia
Jump to: navigation, search
Javeline Platform
Developer(s) Javeline
Stable release
2.1 / April 6, 2009 (2009-04-06)
Written in JavaScript
Type Web application framework
Website http://www.ajax.org/


In 2000, Ruben Daniels and Rik Arends anticipated the browser would become the free platform for all. However the different browsers needed to be optimized and solve their compatibility issues, to truly become the platform of choice. The only way forward was to optimize the code (JavaScript & XML) to extend the reach of the browser. In 2005, the term Ajax (acronym for Asynchronous JavaScript and XML) was born, to describe this well needed process. Ruben and Rik founded Javeline in January 2005 and started working on Ajax, although the term was yet not quite defined. They both identified the actual hype surrounding Ajax was to be short lived. Whilst both understood how Ajax would transform the interaction with the browser; eventually changing most applications into interactive online applications. Both Ruben and Rik identified the need for simple and flexible tools and libraries to operate in this new online world.


Javeline PlatForm is an application development framework (also called a library, or toolkit) aimed at developers for building applications that run in web browsers, but look and feel like conventional desktop applications. These Rich Internet Applications (RIAs) are a combination of the best of both worlds.

Because an RIA runs on the Web or an intranet, these type of applications are usually installed on a server: everybody always has the latest version. It's far easier to maintain because it doesn't need to be deployed or installed on hundreds or thousands of workstations, and user environments can be rapidly updated simultaneously. JPF has the desktop advantages of quick response time - the client handles a majority of the processing load, and generally only a small amount of data has to be fetched from the server (usually a web service).


  • Separation between data, view, controller, style, state, language, layout
  • Standards compliant (DOM, DOM Events, XForms, CGI, SOAP, XMLRPC, XSLT, XPath, XML Schema, JSON, HTTP, HTML, CSS)
  • Javeline Markup Language with W3C DOM support (including DOM Events).
  • Single interface for any webservice protocol (SOAP, XMLRPC, JSONRPC, CGI, etc.)
  • State management of non databound states
  • Property binding / Dynamic attributes
  • Smartbindings - Two-way databinding to local and remote data.
  • Support for locking remote resources
  • GUI transaction support (experimental)
  • Authentication abstraction
  • Skinning abstraction, including unique javeline platform skin
  • Three layouting methods (Alignment, Anchoring, Grid)
  • Dockable layout
  • Native undo / redo support
  • Realtime skin switching
  • Realtime language switching
  • Auto generation of language files, at any time during or after application development.
  • Collaboration support using remote smart bindings (over xmpp). (experimental)
  • Deep offline support, allowing serialization of the complete state of the application, with completely abstracted retries of any data messaging (incl. remote smartbindings). (experimental)
  • JSLT templating language for silky conversion from xml to html
  • HTML5 form validation with validation grouping and form automation
  • Data instruction format for easy retrieval and storage of data
  • Drag and drop automation between components
  • Resizable and draggable components for runtime UI customization
  • Offline storage solution using all popular providers (incl. html5, gears, flash)
  • Decent animation library
  • Back button control abstracted for all browsers implementing onhashchange
  • Sorting, printing and date library
  • Debug tools including in debug package (including data viewer, log viewer and profiler)
  • Browser abstaction offering same API for all browsers (for xml dom, xpath selection, etc.)
  • Advanced focus handling between components and between browser and operating system
  • Several rendering methods for easy integration in existing web projects
  • Namespace support for in HTML documents loading
  • Tight memory management by caching, reuse and cleanup
  • Fully optimized renderer
  • Package size is completely controllable by using the free javeline packager
  • Virtual viewport abstraction to support large datasets (experimental)
  • Application wide settings
  • Fully generalized API's by using element traits. This means that each attribute works in the same way for each element.
  • 60 Components

Release history[edit]