Glimmer - using JRuby and SWT for Eclipse RCP apps

JRuby allows to use Java's GUI libraries, which has already led to a host of different approaches to JRuby GUI APIs. Glimmer is a new library that uses the SWT toolkit.

We caught up with Andy Maleh, the creator of Glimmer to see what the project is about and where it'll go. Andy explains the design principles behind Glimmer:

The initial goal behind Glimmer was to facilitate desktop application development with Ruby by relying on a robust platform-independent UI technology. Eclipse SWT happened to fill that role, so it was reused through the JRuby implementation of Ruby.
Glimmer's API was designed with the following principles in mind:

• Concise and DRY
• Asks for minimum info needed to accomplish task
• Convention over configuration
• As predictable as possible for existing SWT developers

Additionally, the API is being designed to take advantage of every language technique available in Ruby that will ease desktop application development. Builder-style syntax happens to be one of these techniques, so it was utilized to allow developers to author desktop user-interfaces in a similar fashion to how they would author web user-interfaces with HTML. That is by writing code that visually maps to how the user-interface will look like once rendered.
Nonetheless, Glimmer's goals do go beyond providing a Builder-style syntax. For example, Glimmer comes with built-in data-binding support and smart customizable defaults. [..]
Glimmer is not only minimalistic in its syntax, but also in its architecture. It was designed to be very easy to extend, without requiring developers to hard-code every keyword they would like to contribute to the syntax. This is in fact the reason why Glimmer supports 3rd party widgets out of the box.

JFace is a layer of useful components built on top of the basic SWT widgets, among others. Glimmer also supports these:

Glimmer does currently work with JFace widgets. In fact, it supports any custom SWT/JFace widget as long as it has a (parent, style) constructor.
Glimmer can also be utilized to build RCP UI components such as views and editors. [..] As I started developing data-binding support for Glimmer, I did consider reusing the JFace Data-Binding framework. However, the latest API requires calling statically typed methods, which do not fit well with Ruby's dynamic nature, so it seemed simpler to develop data-binding support in Ruby from scratch.

Learn more about Glimmer's data binding approach.

One important aspect of GUI libraries is the layout of components, which is also addressed by Glimmer:

Glimmer currently has smart defaults for laying out composite widgets, such as Shell, Composite, and Group. When declaring a Composite for example, the layout automatically defaults to the commonly used GridLayout. Still, consumers of the API can change the defaults when the need arises.

Asked for existing features and future plans for Glimmer, Andy explains:

Glimmer currently supports:

• Rendering of SWT and JFace widgets with predefined smart defaults for commonly used widgets, such as Shell, Composite, Group, Text, Button, Spinner, and Label
• Data-binding of Text, Spinner, Check-box Button, Radio Button, and Table
• Ability to extend syntax by writing command handlers for newly contributed keywords

In the near future, Glimmer will provide data-binding support for other widgets, such as Tree, Combo, and List, and smart defaults for the rest of the widgets in SWT and JFace.
Future plans include:

• Exploring ideas on how to ease RCP development
• Augmenting Rails with Ajax component support when SWT starts supporting Ajax widgets.

Glimmer has been proposed as an Eclipse project. Andy explains the reasoning behind it:

There were several incentives behind creating an Eclipse project:

• Improve Glimmer's robustness and reliance on Eclipse technologies through the help of the Eclipse community
• Get exposure and feedback from veteran Eclipse developers
• Gain broader publicity, recognition, and support

While the GUI DSL is a good first step in easing Eclipse development with Ruby, it might just be the tip of the iceberg. Future plans do include exploring ideas on how to simplify RCP development, and creating Eclipse plugins from JRuby scripts may actually be one of them.
I have not given much thought yet to current problem areas in plug-in development, but two areas that could potentially benefit from Ruby's expressive syntax are definition of extension points and configuration/integration of plug-ins.