Glimmer DSL for SWT

JRuby Desktop Development GUI Framework

Gem Version Travis CI Coverage Status Maintainability Join the chat at

(The Original Glimmer Library Handling the World’s Ruby GUI Needs Since 2007. Beware of Imitators!)

Glimmer DSL for SWT is a native-GUI cross-platform desktop development library written in JRuby, an OS-threaded faster JVM version of Ruby. Glimmer's main innovation is a declarative Ruby DSL that enables productive and efficient authoring of desktop application user-interfaces by relying on the robust Eclipse SWT library. Glimmer additionally innovates by having built-in data-binding support, which greatly facilitates synchronizing the GUI with domain models, thus achieving true decoupling of object oriented components and enabling developers to solve business problems (test-first) without worrying about GUI concerns, or alternatively drive development GUI-first, and then write clean business models afterwards. Not only does Glimmer provide a large set of GUI widgets, but it also supports drawing Canvas Graphics like Shapes and Animations. To get started quickly, Glimmer offers scaffolding options for Apps, Gems, and Custom Widgets. Glimmer also includes native-executable packaging support, sorely lacking in other libraries, thus enabling the delivery of desktop apps written in Ruby as truly native DMG/PKG/APP files on the Mac, MSI/EXE files on Windows, and DEB/RPM files on Linux. Glimmer was the first Ruby gem to bring SWT (Standard Widget Toolkit) to Ruby, thanks to creator Andy Maleh, EclipseCon/EclipseWorld/RubyConf speaker.

Featured in JRuby Cookbook
and Chalmers/Gothenburg University Software Engineering Master's Lecture Material

SWT (Standard Widget Toolkit) is a very robust GUI toolkit that is most famous for building the Eclipse IDE, a free and open-source general language Integrated Development Environment that was the first to provide a high-performance pause-free Java IDE (unlike earlier versions of NetBeans and other Java IDEs), thanks to its very smart software architecture. Additionally, Eclipse RCP (Rich Client Platform, built on top of SWT) has been used by NASA to build Mars Rover operational software. So, Eclipse technologies are not only very highly proven, but are also considered some of the best in the world. In fact, it took CSS decades before it finally caught up with one of SWT's very effective ideas, the GridLayout. Glimmer DSL for SWT makes Eclipse Technologies available in Ruby via JRuby.

Eclipse SWT RCP NASA Mars Rover

Glimmer DSL for SWT includes SWT 4.22, which was released on November 24, 2021. Gem version numbers are in sync with the SWT library versions. The first two digits represent the SWT version number. The last two digits represent the minor and patch versions of Glimmer DSL for SWT. Note that SWT now supports AARCH64/ARM64 on Mac and Linux!

Starting in version, Glimmer DSL for SWT comes with the new Shine syntax for highly intuitive and visually expressive View/Model Attribute Mapping, relying on <=> for bidirectional (two-way) data-binding and <= for unidirectional (one-way) data-binding, providing an alternative to the bind keyword.

Please help make Glimmer DSL for SWT better by providing feedback and contributing whenever possible. Any feature suggestions that are accepted could be implemented within weeks if not days.

Other Glimmer DSL gems you might be interested in:


Hello, World! Sample

Glimmer GUI DSL code (from samples/hello/hello_world.rb):

include Glimmer

shell {
  text "Glimmer"

  label {
    text "Hello, World!"

Glimmer app:

Hello World

Learn more about Hello, World!.

Hello, Table! Sample

Glimmer GUI DSL code (from samples/hello/hello_table.rb):

shell {

  text 'Hello, Table!'
  background_image File.expand_path('hello_table/baseball_park.png', __dir__)
  image File.expand_path('hello_table/baseball_park.png', __dir__)

  label {
    layout_data :center, :center, true, false

    background :transparent if
    foreground rgb(94, 107, 103)
    font name: 'Optima', height: 38, style: :bold

  combo(:read_only) {
    layout_data :center, :center, true, false
    selection <=> [BaseballGame, :playoff_type]
    font height: 14

  table(:editable) { |table_proxy|
    layout_data :fill, :fill, true, true

    table_column {
      text 'Game Date'
      width 150
      sort_property :date # ensure sorting by real date value (not `game_date` string specified in items below)
      editor :date_drop_down, property: :date_time
    table_column {
      text 'Game Time'
      width 150
      sort_property :time # ensure sorting by real time value (not `game_time` string specified in items below)
      editor :time, property: :date_time
    table_column {
      text 'Ballpark'
      width 180
      editor :none
    table_column {
      text 'Home Team'
      width 150
      editor :combo, :read_only # read_only is simply an SWT style passed to combo widget
    table_column {
      text 'Away Team'
      width 150
      editor :combo, :read_only # read_only is simply an SWT style passed to combo widget
    table_column {
      text 'Promotion'
      width 150
      # default text editor is used here

    # Data-bind table items (rows) to a model collection property, specifying column properties ordering per nested model
    items <=> [BaseballGame, :schedule, column_properties: [:game_date, :game_time, :ballpark, :home_team, :away_team, :promotion]]

    # Data-bind table selection
    selection <=> [BaseballGame, :selected_game]

    # Default initial sort property
    sort_property :date

    # Sort by these additional properties after handling sort by the column the user clicked
    additional_sort_properties :date, :time, :home_team, :away_team, :ballpark, :promotion

    menu {
      menu_item {
        text 'Book'

        on_widget_selected {

  button {
    text 'Book Selected Game'
    layout_data :center, :center, true, false
    font height: 14
    enabled <= [BaseballGame, :selected_game]

    on_widget_selected do

Glimmer App:

Hello Table

Learn more about Hello, Table!.


Glimmer GUI DSL code (from samples/elaborate/tetris.rb):

shell(:no_resize) {
  grid_layout {
    num_columns 2
    make_columns_equal_width false
    margin_width 0
    margin_height 0
    horizontal_spacing 0

  text 'Glimmer Tetris'
  minimum_size 475, 500
  image tetris_icon

  tetris_menu_bar(game: game)

  playfield(game_playfield: game.playfield, playfield_width: playfield_width, playfield_height: playfield_height, block_size: BLOCK_SIZE)

  score_lane(game: game, block_size: BLOCK_SIZE) {
    layout_data(:fill, :fill, true, true)

Glimmer app:


Desktop Apps Built with Glimmer DSL for SWT

Are We There Yet LogoAre We There Yet? - Small Project Tracking App

Are We There Yet? App Screenshot

Math Bowling LogoMath Bowling - Elementary Level Math Game Featuring Bowling Rules

Math Bowling App Screenshot

Table of contents


Ruby is a dynamically-typed object-oriented language, which provides great productivity gains due to its powerful expressive syntax and dynamic nature. While it is proven by the Ruby on Rails framework for web development, it currently lacks a robust platform-independent framework for building desktop applications. Given that Java libraries can now be utilized in Ruby code through JRuby, Eclipse technologies, such as SWT, JFace, and RCP can help fill the gap of desktop application development with Ruby.

Software Architecture

There are several requirements for building enterprise-level/consumer-level desktop GUI applications:

  • Cross-Platform Support (Mac, Windows, Linux) without compilation/recompilation
  • OS Native Look & Feel
  • High Performance
  • Productivity
  • Maintainability
  • Extensibility
  • Native Executable Packaging
  • Multi-Threading / Parallel Programming
  • Arbitrary Graphics Painting
  • Audio Support

Glimmer provides cross-platform support that does not require Ruby compilation (like Tk does), thanks to JRuby, a JVM (Java Virtual Machine) faster OS-threaded version of Ruby.

Glimmer leverages SWT (Standard Widget Toolkit), which provides cross-platform widgets that automatically use the native GUI libraries under each operating system, such as Win32 on Windows, Cocoa on Mac, and GTK on Linux.

Furthermore, what is special about SWT regarding "High Performance" is that it does all the GUI painting natively outside of Java, thus producing GUI that runs at maximum performance even in Ruby. As such, you do not need to worry about Ruby dynamic typing getting in the way of GUI performance. It has ZERO effect on it and since SWT supports making asynchronous calls for GUI rendering, you could avoid blocking the GUI completely with any computations happening in Ruby no matter how complex, thus never affecting the responsiveness of GUI of applications while taking full advantage of the productivity benefits of Ruby dynamic typing.

Glimmer takes this further by providing a very programmer friendly DSL (Domain Specific Language) that visually maps lightweight Ruby syntax to the containment hierarchy of GUI widgets (meaning Ruby blocks nested within each other map to GUI widgets nested within each other). This provides maximum productivity and maintainability.

Extensibility has never been simpler in desktop GUI application development than with Glimmer, which provides the ability to support any new custom keywords through custom widgets and custom shells (windows). Basically, you map a keyword by declaring a view class matching its name by convention with a GUI body that simply consists of reusable Glimmer GUI syntax. They can be passive views or smart views with additional logic. This provides the ultimate realization of Object Oriented Programming and micro-level MVC pattern.

Thanks to Java and JRuby, Glimmer apps can be packaged as cross-platform JAR files (with JRuby Warbler) and native executables (with Java Packager) as Mac APP/DMG/PACKAGE or Windows EXE/MSI.

The Java Virtual Machine already supports OS-native threads, so Glimmer apps can have multiple things running in parallel with no problem.

SWT supports Canvas graphics drawing, and Glimmer takes that further by provding a Canvas Shape/Transform/Animation DSL, making it very simple to decorate any existing widgets or add new widgets with a completely custom look and feel if needed for branding purposes.

Audio is supported via the Java Sound library in a cross-platform approach and video is supported via a Glimmer custom widget, so any Glimmer app can be enhanced with audio and video where needed.

Remaining Challenges

Startup time is long. Thankfully, there are work-arounds that could make apps start as fast as instantly.

Contributors who appreciate Glimmer's ultra-high productivity, maintainability, and extensibility might want to help report and resolve remaining challenges in its software architecture.

Platform Support

Glimmer runs on the following platforms:

  • Mac
  • Windows
  • Linux

Glimmer's GUI has the native look and feel of each operating system it runs on since it uses SWT behind the scenes, which leverages the following native libraries:

  • Win32 on Windows
  • Cocoa on Mac
  • GTK on Linux

More info about the SWT GUI on various platforms can be found on the Eclipse WIKI and SWT FAQ:


Glimmer might still work on other versions of Java, JRuby and SWT, but there are no guarantees, so it is best to stick to the pre-requisites outlined above.

To change the SWT version to a custom swt.jar version that you have, simply set the 'SWT_JAR_FILE_PATH' env var.


Please follow these instructions to make the glimmer command available on your system via the glimmer-dsl-swt gem.

If you intend to learn the basics of Glimmer but are not ready to build a Glimmer app yet, pick Option 1 (Direct Install).

If you intend to build a Glimmer app from scratch with scaffolding, pick Option 1 (Direct Install) as well.

Otherwise, Option 2 (Bundler) can be followed in rare cases where you want to build an app without scaffolding.

Note: if you encounter any issues, please report and then install a previous version instead from the list of Glimmer Releases (keep looking back till you find one that works). Do not be disheartened as nearly everything is only a few days of work away. That said, keep in mind that this project is free and open source, meaning provided as is, so do not expect anything, but if you help with reporting and contributing, you could speed things up or even become part of the project.

Option 1: Direct Install

(Use for Scaffolding)

Run this command to install directly:

jgem install glimmer-dsl-swt

Or this command if you want a specific version:

jgem install glimmer-dsl-swt -v

jgem is JRuby's version of gem command. RVM allows running gem install directly as an alias. Otherwise, you may also run jruby -S gem install ...

Afterwards, you can use glimmer and girb commands.

On the Mac, you also have to run:


This ensures configuring required Mac jruby options before using glimmer and girb commands (adding export JRUBY_OPTS="$JRUBY_OPTS -J-XstartOnFirstThread" to ~/.zprofile and ~/.bash_profile).

If you are new to Glimmer and would like to continue learning the basics, you may continue to the Glimmer Command section.

Otherwise, if you are ready to build a Glimmer app, you can jump to the Glimmer Scaffolding section next.

Note: if you're using activerecord or activesupport, keep in mind that Glimmer unhooks ActiveSupport::Dependencies as it does not rely on it.

Option 2: Bundler

(Use for Manual App Creation)

Add the following to Gemfile:

gem 'glimmer-dsl-swt', '~>'

And, then run:

jruby -S bundle install

Note: if you're using activerecord or activesupport, keep in mind that Glimmer unhooks ActiveSupport::Dependencies as it does not rely on it.

You may learn more about other Glimmer related gems (glimmer-dsl-opal, glimmer-dsl-xml, and glimmer-dsl-css) at Multi-DSL Support

Glimmer Command


You can use the glimmer command to scaffold new apps, run apps & samples, package native executables, and list Glimmer community gems.

Glimmer (JRuby Desktop Development GUI Framework) - JRuby Gem: glimmer-dsl-swt v4.22.2.0

Usage: glimmer [--bundler] [--pd] [--quiet] [--debug] [--log-level=VALUE] [[ENV_VAR=VALUE]...] [[-jruby-option]...] (application.rb or task[task_args]) [[application2.rb]...]

Runs Glimmer applications and tasks.

When applications are specified, they are run using JRuby,
automatically preloading the glimmer Ruby gem and SWT jar dependency.

Optionally, extra Glimmer options, JRuby options, and/or environment variables may be passed in.

Glimmer options:
- "--bundler=GROUP"   : Activates gems in Bundler default group in Gemfile
- "--pd=BOOLEAN"      : Requires puts_debuggerer to enable pd method
- "--quiet=BOOLEAN"   : Does not announce file path of Glimmer application being launched
- "--debug"           : Displays extra debugging information, passes "--debug" to JRuby, and enables debug logging
- "--log-level=VALUE" : Sets Glimmer's Ruby logger level ("ERROR" / "WARN" / "INFO" / "DEBUG"; default is none)

Tasks are run via rake. Some tasks take arguments in square brackets.

Available tasks are below (if you do not see any, please add `require 'glimmer/rake_task'` to Rakefile and rerun or run rake -T):

Select a Glimmer task to run: (Press ↑/↓ arrow to move, Enter to select and letters to filter)
  glimmer list:gems:customshape[query]                       # List Glimmer custom shape gems available at (query is optional) [alt: list:gems:cp]
‣ glimmer list:gems:customshell[query]                       # List Glimmer custom shell gems available at (query is optional) [alt: list:gems:cs]
  glimmer list:gems:customwidget[query]                      # List Glimmer custom widget gems available at (query is optional) [alt: list:gems:cw]
  glimmer list:gems:dsl[query]                               # List Glimmer DSL gems available at (query is optional)
  glimmer package[type]                                      # Package app for distribution (generating config, jar, and native files) (type is optional)
  glimmer package:clean                                      # Clean by removing "dist" and "packages" directories
  glimmer package:config                                     # Generate JAR config file
  glimmer package:gem                                        # Generate gem under pkg directory
  glimmer package:gemspec                                    # Generate gemspec
  glimmer package:jar                                        # Generate JAR file
  glimmer package:lock_jars                                  # Lock JARs
  glimmer package:native[type]                               # Generate Native files
  glimmer run[app_path]                                      # Runs Glimmer app or custom shell gem in the current directory, unless app_path is specified, then runs it instead (app_path is optional)
  glimmer samples                                            # Brings up the Glimmer Meta-Sample app to allow browsing, running, and viewing code of Glimmer samples
  glimmer scaffold[app_name]                                 # Scaffold Glimmer application directory structure to build a new app
  glimmer scaffold:customshape[name,namespace]               # Scaffold Glimmer::UI::CustomShape subclass (part of a view) under app/views (namespace is optional) [alt: scaffold:cp]
  glimmer scaffold:customshell[name,namespace]               # Scaffold Glimmer::UI::CustomShell subclass (full window view) under app/views (namespace is optional) [alt: scaffold:cs]
  glimmer scaffold:customwidget[name,namespace]              # Scaffold Glimmer::UI::CustomWidget subclass (part of a view) under app/views (namespace is optional) [alt: scaffold:cw]
  glimmer scaffold:desktopify[app_name,website]              # Desktopify a web app
  glimmer scaffold:gem:customshape[name,namespace]           # Scaffold Glimmer::UI::CustomShape subclass (part of a view) under its own Ruby gem project (namespace is required) [alt: scaffold:gem:cp]
  glimmer scaffold:gem:customshell[name,namespace]           # Scaffold Glimmer::UI::CustomShell subclass (full window view) under its own Ruby gem + app project (namespace is required) [alt: scaffold:ge...
  glimmer scaffold:gem:customwidget[name,namespace]          # Scaffold Glimmer::UI::CustomWidget subclass (part of a view) under its own Ruby gem project (namespace is required) [alt: scaffold:gem:cw]

Learn more at:


Girb (Glimmer irb) Command

You can use girb as an alternative to irb when prototyping Glimmer DSL for SWT GUI DSL code.



Learn more at:


Glimmer GUI DSL Syntax


Here is a listing of supported widgets taken from the SWT website:

SWT Widgets

In a nutshell, the Glimmer GUI DSL syntax consists mainly of:

  1. Keywords

Example of a keyword representing a table widget:

  1. Style/Args

Example of a multi-line selection table widget:

  1. Content/Properties

Example of a multi-line selection table widget with a table column as content that has a header text property as 'Name'.

table(:multi) {
  table_column {
    text 'Name'

If you need more widgets, you can check out the Nebula Project (50+ enterprise-grade custom widgets)

Learn more at:


Glimmer Configuration

Glimmer configuration may be done via the Glimmer::Config module.

Learn more at:


Glimmer Style Guide



See a listing of samples including screenshots and explanations at:


Check the samples directory in glimmer-dsl-swt for examples on how to write Glimmer applications. To run a sample, make sure to install the glimmer-dsl-swt gem first and then run:

glimmer samples

(alternatively, you may clone the repo, follow instructions, and run samples locally with development glimmer command: bin/glimmer)

Glimmer Meta-Sample

In Production

The following production apps have been built with Glimmer.

If you have a Glimmer app you would like referenced here, please mention in a Pull Request.

Math Bowling

Math Bowling LogoMath Bowling: an educational math game for elementary level kids

Are We There Yet?

Are We There Yet LogoAre We There Yet?: A tool that helps you learn when your small projects will finish

Garderie Rainbow Daily Agenda

Garderie Rainbow Daily Agenda LogoGarderie Rainbow Daily Agenda: A child nursery daily agenda reporting desktop app

Glimmer Gab

Glimmer Gab Logo Glimmer Gab: Desktop App for


Connector Logo Connector: A minimalist open-source multi-engine web browser

The DCR Programming Language

Connector Logo Draw Color Repeat: A young boy programming language for Drawing and Coloring with Repetition

Befunge 98 Programming Language

Befunge 98 GUI

Packaging & Distribution

Glimmer simplifies the process of native-executable packaging and distribution on Mac and Windows via a single command:

glimmer package

Learn more at: docs/reference/

App Updates

Glimmer should have support for automatic (and manual) app updates via the Mac App Store on the Mac (not tested yet, so contributor help is appreciated). Getting on the App Store requires running the glimmer package command with the Mac App Store keys configured as per the Mac Application Distribution instructions.

Glimmer Supporting Libraries

Here is a list of notable 3rd party gems used by Glimmer:

  • juwelier: generates app gems during Glimmer Scaffolding
  • logging: provides extra logging capabilities not available in Ruby Logger such as multi-threaded buffered asynchronous logging (to avoid affecting app performance) and support for multiple appenders such as stdout, syslog, and log files (the last one is needed on Windows where syslog is not supported)
  • nested_inherited_jruby_include_package: makes included SWT/Java packages available to all classes/modules that mix in the Glimmer module without having to manually reimport
  • os: provides OS detection capabilities (e.g. OS.mac? or to write cross-platform code inexpensively
  • puts_debuggerer: helps in troubleshooting when adding require 'pd' and using the pd command instead of puts or p (also #pd_inspect or #pdi instead of #inspect)
  • rake: used to implement and execute glimmer commands
  • rake-tui: Rake Text-based User Interface. Allows navigating rake tasks with arrow keys and filtering task list by typing to quickly find an run a rake task.
  • rouge: Ruby syntax highlighter used in the code_text Glimmer DSL for SWT custom widget leveraged by the Glimmer Meta-Sample
  • super_module: used to cleanly write the Glimmer::UI:CustomWidget and Glimmer::UI::CustomShell modules
  • text-table: renders textual data in a textual table for the command-line interface of Glimmer
  • warbler: converts a Glimmer app into a Java JAR file during packaging

Glimmer Process

Glimmer Process is the lightweight software development process used for building Glimmer libraries and Glimmer apps, which goes beyond Agile, rendering all Agile processes obsolete. Glimmer Process is simply made up of 7 guidelines to pick and choose as necessary until software development needs are satisfied.

Learn more by reading the GPG (Glimmer Process Guidelines)


SWT Reference

Here is the SWT Javadoc API:

Here is a visual list of SWT widgets:

Here is a textual list of SWT widgets:

Here is a list of SWT style bits as used in widget declaration:

Here is a SWT style bit constant reference:

Here is an SWT Layout guide:

Here is an SWT Custom Widget guide:

Here is an SWT Drag and Drop guide:

Here is an SWT Graphics / Canvas-Drawing guide:

Here is an SWT Image guide:

Here is the Nebula Project (custom widget library) homepage:



You may submit issues on GitHub.

Click here to submit an issue.


If you need live help, try to Join the chat at

Feature Suggestions

These features have been suggested. You might see them in a future version of Glimmer. You are welcome to contribute more feature suggestions.

Glimmer DSL Engine specific tasks are at:


Change Log

Also: glimmer/


Contributors Wanted!

If you would like to contribute to Glimmer, please study up on Glimmer and SWT, run all Glimmer samples, and build a small sample app (perhaps from this TODO list) to add to glimmer-dsl-swt Hello or Elaborate samples via a Pull Request. Once done, contact me on Chat.

You may apply for contributing to any of these Glimmer DSL gems whether you prefer to focus on the desktop or web:


Click here to view contributor commits.



Copyright (c) 2007-2021 - Andy Maleh.


Built for Glimmer (DSL Framework).

Glimmer logo was made by Freepik from