Comprehensive Component Library
Galileo RIA Web Edition provides a comprehensive set of rich UI components that includes all the elements offered by the basic HTML element set, plus an array of additional components common to desktop applications and Rich Internet Applications. The following components are included in the Galileo framework:

Open Source Controls
In addition to the components that are built into the Galileo framework, Galileo will also provide a library of open source controls individually downloadable from our website. These controls will be more specialized and therefore not part of the standard library avoiding unnecessary bloating of our framework byte-code. These controls can be integrated into your own application code - used as-is or freely modified to suit your needs.

Modules (future)
Modules will be sophisticated groups of controls that provide the UI functionality of a common website service such as a blog, message board, wish list, etc. These will separate libraries available from our website that can be plugged into your existing Galileo application just like any other component.

Extensions (future)
Extensions will be additional code packages providing extended capabilities for Galileo such as data graphing.

Scriptless AJAX and SPI
Traditional web pages rely on the web browser to send and receive HTML requests generated by user interaction. Whether the purpose of the request was to simply modify the interface or to retrieve a small or large amount of data, the browser paradigm requires that an entire web page be loaded in response to the request. This is referred to as a Multi-Page Interface(MPI). AJAX (Asynchronous JavaScript and XML) is the term that is used to refer to the technique that allows web pages to perform asynchronous HTTP requests using the JavaScript XMLHttpRequest object. Web pages that are developed using AJAX can retrieve text, HTML, or XML data from a web server without causing the browser to reload a new web page. In most cases this allows web sites to operate much more efficiently by updating only the portion of the web page UI that was affected by the request. Web pages that operate in this manner are referred to as Single Page Interfaces (SPI) or Single Page Applications (SPA) because they behave more like applications than traditional web pages. Galileo provides the same ability to transfer text, HTML, and XML data asynchronously through HTTP requests as AJAX does, but does so using the Java programming language instead of JavaScript.

Smart Navigation
Galileo's Smart Navigation is a great feature; it allows developers to create links to application components that are similar to HTML hyperlinks. When a user clicks on a Smart Navigation link the framework locates the targeted UI component and displays it no matter where it's located in the application's UI. For instance, if the component that is being navigated is embedded several levels down in your UI component tree and none of the component's ancestors are currently visible, the Smart Navigation system will adjust the display state of all the components in the referenced component's ancestor tree in order to display it. We think this is pretty powerful stuff. It allows developers to create very loosely coupled components that can be restructured in any way they see fit, without having to update any links to those components. It also allows developers to provide end users with the ability to jump from one location to another in the application's UI without requiring them to remember any elaborate navigation paths and dismisses the need for developers to explicitly program UI navigation paths into their application. The Smart Navigation feature also allows Galileo applications to behave like traditional websites in reference to browser navigation actions (back, forward, and bookmarking) making Galileo application navigation behavior indistinguishable from traditional website navigation from an end user's perspective.

Drag and Drop
Galileo's Drag and Drop capabilities bring a common feature available to desktop applications to your website. Drag and Drop adds a level of convenience to your application for end users by reducing certain input steps that might require several user actions to a single user action. While Drag and Drop gives your application a sophisticated look and feel, its real benefit is utilitarian in nature allowing graphical representations of your data to be easily manipulated by your end users.

Style Sheets and Application Skinning
Galileo provides CSS-like styling features that allow easy styling of all application controls and the creation of application dkins that can be used to customize the look and feel of your application. Controls contain all the style attributes that are available to HTML elements via CSS and many additional attributes which aren't available in HTML. Galileo style attributes include Shape (rectangular, elliptical, and rounded rectangular), Shadow (depth, transparency, angle, and blur), Background (color, color gradients, images, and code-generated graphics), Font (color, size, family, and weight), Border (color, thickness, and style), Transparency (full or background-only), Padding, Overflow, Cursor type, and various sizing and positioning attributes. Additionally, Galileo controls have built in state which allows different style attributes to be assigned to different states giving controls inherent dynamic behavior.

Animation
Galileo provides a simple, but powerful animation package that allows you to apply time-lapsed changes (Effects) to any component. Basic effects such as resizing, moving, and fading are provided in addition to more sophisticated effects that can be used to give your applications Mac or Vista-like behavior. In addition to Effects, there are several other classes that can be used with Effect classes to apply multiple effects to a component or to create complicated sequences of effects on multiple components to create animated scenes.

Custom Graphics
Galileo provides components that allow the integration of low-level AWT graphics programming for applications that require advanced or custom graphic generation. Graphic components are also a convenient alternative to using images for graphics that may be dynamic in nature.

Intuitive and Efficient API
Galileo's API was designed to be intuitive, efficient, and flexible. Most classes in the Galileo framework have what we refer to as a Dual API. By this we mean that most classes have two sets of methods. One set, the Simple Interface, is a high-level interface that allows developers to do the more common and basic operations with a single call. The Simple Interface makes it extemely easy to start using Galileo. Developers can jump-in and start creating applications with only a basic understanding of the framework. The second set, the Advanced Interface, is a low-level interface that gives developers more control over the fine-grained details, but may require a little more code and a better understanding of the framework.

Robust Architecture
Galileo has a robust architecture that was designed explicitly for the following purpose: to quickly and easily build highly customized, dynamic, and interactive browser-based internet applications. But quickly and easily does not mean you have to sacrifice software quality. With an object-oriented design that has evolved over many iterations, Galileo's architecture supports modular, loosely coupled designs that promote generalization and highly extensible, maintainable, and reusable application components. This makes Galileo ideal for Enterprise applications that require a significant amount of collaboration between team members allowing easy integration of software components and application content.

Cross-browser Congruity
Galileo applications run in all major browsers on all major platforms. Unlike HTML/JavaScript-based frameworks which have problems displaying RIAs consistently on different browsers, Galileo applications look and behave identically on all the major browsers (Firefox, Internet Explorer, Safari, Chrome, Konqueror, and Opera).

Client-Based
Galileo applications are client-based which means that your application code is downloaded to the end-user's machine and executed via the Java web browser plugin. All user interface processing is handled by the application itself and therefore processed by the end user's machine. This is in contrast to server-based applications which send user interface events to a web-server for processing, having to wait for the server to handle the events, make the decisions for any UI updates that are needed, and to finally send the response back to the browser. Client-based RIAs tend to be much more responsive then server-based applications since UI changes do not require a client-server round trip to fetch the new UI code. In addition, client-based applications reduce the overall load on your web server since server responsibility is reduced to data-serving only, increasing the scalability of your RIA. Client-based applications are also independent of your back-end technology allowing you to use any server-side technology that you choose to handle your data requests.

Inherited Java Features
In addition to all the features that we have explicitly built into the Galileo framework, developers also get all the standard features of the Java programming language and its core libraries: inheritance, polymorphism, and encapsulation; strong type checking; enumeration types; multi-threading; exception handling; dynamic collection classes; XML parsing, translation, and validation; regular expressions; advanced graphic capabilities; internationalization and localization; and security features.

Free for Non-commercial Use
Galileo costs nothing to download and use for non-commercial purposes. For commercial purposes you can download Galileo and develop applications with it for free, but a deployment license is required to deploy those applications. Please see our Licensing page for more information.