Rouge is a high level GUI toolkit. It interprets a XUL-like XML GUI description language, as well as providing native Ruby API. Rouge is designed to be a front-end for multiple back-ends, allowing users to choose from a number of native GUI toolkit implementations to match their own tastes.
This software is distribute under the Ruby license.
Every once in a while, someone starts a discussion in comp.lang.ruby about how they'd like to see a GUI toolkit that really follows the Ruby Way of ease of use. They then begin talking about what sorts of features they'd like to see, how it should work, what they don't like about current toolkits, and generally end with a call to arms to build such a beast. Inevitably, this sparks a huge thread about what a Ruby GUI toolkit would look like, filled with arguments about the relative merits of abstracted GUIs vs. purely native GUIs, speed issues, and the occasional ass saying "Give it up; use TK like the rest of us."1
I, too, once started one of these threads. Frustrated with the state of the Ruby GUI, I launched into a rhapsodic account of what my personal vision of Ruby GUI heaven looked like. This resulted in the formation of a mailing list and a Wiki page, which saw a lot of traffic, some really nice ideas, and some test code by various people. I'm not sure what happened, but traffic stopped rather suddenly, and things sort of ran to a halt. I think a major holiday was responsible, along with the fact that I lost my cushy job and (ironically) no longer had time to work on the project or tend to the mailing list. I'm also pretty sure that around that time our server, which was hosting the mailing list, lost a hard drive, and in the process of upgrading the machine, the mailing list broke.
The forces of Evil, it seems, were determined to keep us from entering Ruby GUI heaven.
Well, hold on to your carbuncles, because we're back. Rouge is alive.
This is very beta! Be warned! In fact, stop reading now and go read the README.
Check out the architecture diagram. This was put together by the folks on the Rouge mailing list, and it is still a great architecture. In this diagram, Rouge (this project) is the Alpha and Delta layers. It is an API; it interprets the GUI layout and the bindings that the developer specifies (the Alpha layer), and translates these into a generic GUI language (the Delta layer). Various native bindings are employed to actually render the GUI (the Omega layer).
Please keep in mind that this is all experimental. I have, and will, drop anything that becomes as unwieldy as any GUI toolkit that currently exists for Ruby. I've already thrown out two other stabs at the API. Feedback is very important, but the mailing list has had a huge amount of discussion about design and implementation that I'm not going to repeat here. Someday, someone will cull the mailing list and create a document that describes the philosophy and goals, and describes the architecture and reasons for the design choices. Until then, please submit your questions to the Rouge mailing list.
Currently, only the FXRuby native binding is available. This is only because I'm a busy person, and only have so much time. If you wait long enough, eventually other Omega layers will emerge... or, you could make a stab at writing your own. They're pretty easy, and one of my goals is to keep the implementation of Omegas as simple as possible.
The other requirement is REXML. This is for the XUL interpreter.
FXRuby is in the works. TK should be next, and I'd like at least one other, to prove the concept. The biggest obsticle to implementing an Omega layer is a lack of layout managers. With sufficient layout manager support, the back-ends are easy.
I'm fairly certain that if I work on any Gamma layer, it'll be an SVG based GUI. Either this, or SDL, but I'm leaning toward SVG. librsvg is a starting point.
My first priority is to get XUL mostly supported; with this comes the native Ruby API, as a gimme. I need people using this and giving me feedback before I can move forward, and I really need people contributing input, direction, and bits of code -- and Omega layers. Unlike REXML, this (I'm of the opinion) must be a community project.
XForms. Boy, the coup-de-grace would be an Alpha layer that interpreted XForms. We'll see.
There is a mailing list dedicated to Rouge. Sometimes it has a lot of traffic, sometimes it has none.
An RSS file http://www.germane-software.com/software/Rouge/rss.xml