jd:/dev/blog

I just found this blog post on LXDE blog while reading LWN.net.

It made me smile because that's what Ohloh says for awesome:

Over the past twelve months, 70 developers contributed new code to awesome. This is one of the largest open-source teams in the world, and is in the top 2% of all project teams on Ohloh. For this measurement, Ohloh considered only recent changes to the code. Over the entire history of the project, 99 developers have contributed.

So awesome project is roughly twice bigger than LXDE. Impressive!

I've just announced it.

I've started to develop awesome more than 18 months ago, and somehow I feel it's time to stop a bit and think where we come from and where we are going to.

The motivation

I never though I'd be written a window manager one day. That seems kinda stupid when you see how many window manager there's around.

As many people, I've tested and have been using tons of window manager: Window Maker, Fluxbox, etc.

In August 2007, I was using fvwm since 2004 and was quite happy with it. I used the famous fvwm crystal as a configuration starter and then rewrote lots of stuff. Digging into fvwm configuration files was boring, and since I'm lazy, I never really configured it to fit entirely my needs.

The thing is that, in July 2007, my workstation died. I bought a new one based on the amd64 architecture. Too bad, with this new box, fvwm decided that it will not longer runs and was segfaulting almost every time I logged in.

I was really upset. Another failure in the window manager world. So I decided to get the yearly ride of testing many window managers. I went on the no more developed stuff like the *boxes, ion3, etc… but well, I did not like them, there were not powerful enough, too bugged or upstream was insane.

Then I found xmonad. The Haskell configuration file format made my cry. I did not want to learn Haskell, it seemed too obfuscated to me. At that time it was even not packaged for Debian, so I gave up. But I found dwm in the meantime, and I loved it. It was simple, and the source code was almost understandable and easy to hack.

I subscribed to the dwm mailing-list, in order to participate to its development, etc… But I got really disappointed. No patch were welcome and the development seemed to be almost finish in this sight. People patches were lying around, but no one really care. Each user was managing its own set of patches.

That's not what I learnt and what I love in free software. So, as many users, I began to maintain my patches in my corner. But I began to have more ideas…

The jdwm

I just added a 'j' in front of dwm and started to hack it days and nights to add many feature I missed, like multi-head, etc… On 5th September 2007, I created a git repository to host my code.

That's gonna be… awesome.

Five days later, on 10th September, I finally found a name for my new pet: awesome, borrowed from Barney Stinson who heavily uses and abuses this word.

The 1.x branch

The first releases until December were noted 1.x. It was just a better dwm with a simple flat configuration file.. The configuration file used libconfig, but it was a very poor choice. And I was not able to put in into Debian because of name clash.

The 2.x branch

The 2.x branch came in January 2008 with a brand new configuration file format based on libconfuse, which was a bit more powerful. Many concepts and features that have been added in this branch are still used in the current 3.x branch.

At this time, between December 2007 and April 2008, the community was growing smoothly.

But as I said, awesome 2 was based on a flat configuration file. That raised a problem very soon: users expectation were growing and the development team (me and a couple of regular contributors) was unable to cope with them.

One of the event that started to change my mind was the support for titlebars.

When I've added titlebar support, it was minimal. It was on top of a window, with the window title. Dot. Then I've started to add a lot of options, like the application icon drawing, the position (left, right, bottom) etc.

And then users started to ask for more, like: "add titlebar on windows only when the window is floating".

That's ok, but that's complicated: that's again another option to do some stuff conditionally. And then, why don't add titlebar on windows when <insert random events here>?

The 3.x branch

Why

At that time, around April 2008, I'd totally stopped development. I was trying to find a solution which was simple and powerful. But after 2 weeks of thinking, I was not able to find anything else than: use a real language for configuration.

So, I've started prototyping awesome 3 using Lua. The choice was not obvious, and despite the problem Lua might suffer, it's one of the easiest language to integrate into an existing application. There's still a video of a first version here.

But, let's go a little back: in January 2008, Arnaud Fontaine contacted me because he was interested to use awesome as one of its school project. He decided to port awesome from Xlib to XCB, a modern asynchronous X library.

His work took some time, but in May 2008, Arnaud did finished to port git master version of awesome to use XCB.

Consequently, I decided to start a new major branch, using XCB instead of Xlib (no change for users in this regard) and Lua instead of our previous flat configuration file format.

Development

It took me a while to get from here to there, but in September 2008, it was ready. We had a simple Lua API, and the XCB port was working perfectly.

It took us some time to release and have something totally working, because we had to work on XCB and contribute back to the project. It was really not ready to use by an application, but we did great work in this area and it's now really fine.

We're still here

Releases continue to happens, 3.1 around December 2008, and 3.2 around March 2009. 3.3 should be here in June.

One of the drawback we had, is that we moved many stuff from C to Lua. Why? Because writing things in Lua is quicker and easier to maintain than C, and makes thing more configurable for the user.

For example, the layout algorithm used to organize window were written in C until 3.2 came out. At that time, users had no choice than using a set of predefined layout to organize their windows.

Starting with 3.2, if they have minimal knowledge about geometry, they can start writing a layout function organising windows on the screen.

But this kind of API changes was a bit rough for users, since they had to port some part of their configuration file to the new API. The thing is that the project was still a teenager at that time, not really knowing were it will go. But I'm happy to announce that API breakage are more and more rare (so far only one minor between 3.2 and 3.3), and anyway always for the Good.

But I admit that it built a bad reputation around awesome 3.x during its first month of existence.

Future direction

I am currently working on 3.3 development. We have still many things to do. Time passing, we get more idea, and more users. And more users bring more ideas. We also have many more contributors, and some guys are even taking maintainer-ship of some code area.

Conclusion

My post title is "Taking the other direction" because I feel this way.

I've got that feeling that some approaches in projects like GNOME are sometimes bad. Please don't misread me, I know we are not playing in the same yard.

When adding a key shortcut for starting an application makes you dig into gconf, I wonder how this is a win for the user.

Well, it's probably a win for the end-user, but I surely am not one of them. And I don't intend to target them with my software, anyway.

And now, when I hear things like GNOME 3.0 and the "desktop shell" approach, that makes me smile. Guys, it was time, but have luck. What I see from here, is that any desktop control interface is wrong somehow, and that there's no approach that can fulfill all users wishes.

I think that we, the awesome development team (no pun intended) took the direction of building a frame-work window manager rather than a solution written in marble.

We (partially) solved the issue of UI ergonomic by not writing one and allowing the user to write his own. I don't say that's easy to do for most of users, but it's doable.

And I think it's worth it: I use window managers since I use Linux, around 1998. If something like awesome came 5 years ago, I'd be using it so far, because you can write Fluxbox or WindowMaker using awesome in a hundred of Lua code. And you can write your own version of it. And it starts in less than 3 seconds, supporting almost all standard desktop specification (ICCCM, EWMH, XDG, system tray, message notification, D-Bus, etc), whereas many of the window mangers do not.

You can even write and play space invaders.

Finally, I'm happy about the the road we took so far, and hope we will continue into that direction. The rants I read about our project are not that big, compared to the kudos we received.

We're working since several month on awesome 3.2, and here is what you'll get soon:

• By wibox X cursor;
• New mousegrabber infrastructure;
• Client move with mouse is now in Lua;
• New D-Bus hooks; you can also watch D-Bus events to get information like the song played in Audacious, or things like that;
• naughty (notification library) now supports notification via D-Bus, following standard notification protocol;
• Layout code moved to Lua;
• Client gets a new mouse_leave hook;
• Floating state is now handled on Lua side;
• Windows groups are handled and exported to Lua API;
• Various awesome markups have been removed in favor of widgets properties (simpler);
• Shadow support has been removed (too buggy);
• Add new telak module (draw image from the Web on your root window);
• Add mouse move code for wiboxes;
• Add functions to move clients with mouse to tags via the taglist;
• Add support for key release events in keybindings;
• Add support for input faking into client via XTest extension;
• Add support for X selection retrieval (clipboard);
• Add support for real transparency attribute on wiboxes;
• Replace tile layout by a new layout (originally called 'vile') which supports resizing of slaves clients.

We've done a nice job. Thanks to all contributors! See you soon for the first release candidate version…

Since version 3.1, awesome is bundled with naughty, a notification library which allow to raise pop-up in front of the screen to display information you chose. A sort of notification-daemon, but not plugged into D-Bus.

Last days I've began to work on awesome 3.2 (aka the 'next' branch in awesome repository). I've started to chat with Leon Winter on IRC about the possibility to implement notification specifications into awesome.

awesome had since version 3.0 a very light D-Bus support, since it only allowed to evaluate Lua remotely, without getting an answer anyway.

I've hacked it so now there's a D-Bus hook, which is called upon a D-Bus message received. This, plus the possibility to return various data type (not all are implemented as of this day) allowed Leon to enhance the naughty library and to add support for a primary notification support.

I just have to add more D-Bus data type support, and we may be able to support all the specs, with icons support, etc.

A lazy morning again, so you'll enjoy another short list of changes in the upcoming awesome 3.1 (first one is still here):

• Text can now be spread across multiple lines, using pango ability to wrap text;
• New full screen layout;
• awful.clients.swap.bydirection function;
• Images get crop_and_scale() method;
• New module: invaders, a space invader game;
• New module: naughty, notification module (like GNOME's notification-daemon);
• More hooks: "clients" for client list changes, "tags" for tag list changes and "tagged" for client's tag list changes;
• Wiboxes's widgets can now be composed of arrays of arrays, specifying a DAG structure, unless of a simple array. A reference is kept to it so it can be retrieved later. Any array can be modified with awesome being notified using a proxy table system.
• Taglist and tasklist widgets are gone from core and are now written in Lua, using the above system.

Not too much changes, I've spent something like a week thinking and writing the 2 last points. I've now a bunch of things to finish and I think we'll go for a RC release in something like a couple of weeks.

I'm lazy this morning, so I'll write a quick changelog about what's coming next in awesome 3.1, as of now.

• awesome-client is now a true REPL: so it now returns things like errors;
• mouse events now support button release;
• awful has been splited in several modules;
• the window stacking has been reworked and handled special windows (dock, desktop) much better;
• window type is now exported and correctly handled;
• any window can go fullscreen;
• widget can get an event when the mouse enters in it;
• placement (smart, under_mouse, etc) has been move into awful;
• statusbars and titlebars has been merged in a common type: wibox;
• wibox can be floating (i.e. you can now write your own conky-like with wiboxes);
• _NET_WM_STRUT_PARTIAL is now supported so panel and dock automagically puts padding around the screen;
• sticky windows are handled like sticky windows and are not tagged anymore;
• windows that get reparented are now unmanaged (that fixes view of PDF etc in your browser);
• a new image type has been introduced so you can manipulate image directly in awesome and use them;
• a new imagebox widget has been (re)introduced to use image objects;
• a real minimize/iconify state is now available;
• awesome gets a --check to check Lua syntax file; restart is now also checked for syntax file by default.

And of course some bug fixes.

I had this books since 2 years under my screens to raise them at work. Never though of opening them, I just realized what they are some days ago.

That's probably why I became awesome without even knowing it. The truth is out there.

It's done! After more than 6 months of work, more than 1000 changesets, I managed to get out awesome 3 first release candidate version! I've done a quick announcement on the list.

I am very excited to get some feedback about it. So far all I got has been very good.

I've also changed the Web site design.

I've posted yesterday an overview of awesome 3 development state on the awesome mailing list.

To sum up, everything's fine. I hope this summer will see a good hacker-friendly window manager coming out.