This post is mostly a rant to get out my frustrations in relation to my quest to write Linux desktop applications using GTK. I’ve tried two and a half languages so far and have had challenges with each. Those languages have been / are rust, vala, and D which is the one I’m currently trying out. There will be four sections of this post. Three sections (one for each language) each containing a short writeup of my experience with the language followed by a “like” and “dislike” section. The last section is for my concluding thoughts.

Rust

My relationship with rust is easily compared to that one guy, you know, the one who breaks up with his girlfriend every so often, but they always get back together for some romantic reason or another and hope that this time will be different.

Every time I come back I have an “Aha!” moment where I think I understand the borrow checker or how to solve a particular problem which I couldn’t solve before, only to find there is another thing I can’t do. The answer is usually something like “You shouldn’t be trying to do it that way in rust” (the object oriented way). But what would be really helpful is having a document explaining the design patterns I should be using in rust. I haven’t had much formal training in design patterns and most of the stuff out there is for object oriented programming languages.

Things I Like About Rust

• The borrow checker model - or at least the idea of it.
• The package ecosystem (cargo / crates.io).
• The syntax is quite nice too.
• There exists good editor support for it - such as rls.

Things I Dislike About Rust

• I haven’t found a good clean and concise source for learning common design patterns to use in rust.

Vala

Vala is an interesting one. This is my first time trying it and I was able to get way further on my project with less looking up how to do things and less frustration. At first. The interesting thing about vala is that it doesn’t compile down directly to machine code. What it does is it compiles down to ‘C’ which then compiles down to machine code. Sorta like how TypeScript compiles down to JavaScript.

This is also where I started learning how to use the meson build system which I found to be really cool and interesting, and also fast. It builds really fast. It is pretty easy to understand and there is a lot of good documentation and support out there.

The vala syntax is great! They borrow a lot from C#, which despite Microsoft’s best intentions (I’m sure) is a decent language with a lot of good design choices and a large community which can aid you.

Vala doesn’t have a large community though. Well, except for Elementary OS it seems. But even then that’s only because Elementary OS is built on GTK. Vala isn’t useable without GTK.

The main reasons I decided to look elsewhere are mainly:

• The library json-glib is a pain to deal with and has almost no examples of how to use on the internet.
• I cannot create a class that has a property called ‘type’. This is a problem for me because, as far as I know, ‘type’ isn’t a keyword and any other modern language would allow me to do use that word in this context.
• I started getting build error’s that I couldn’t find a clear answer of why it was happening or how to solve it.

I think most of these issues are related to how vala compiles into C GObjects.

Things I Like About Vala

• The language is familiar to me by being so much like C#.
• I like that it can communicate with C libraries natively.
  • One of the future dependencies of my project is a library written in C.
• composite-templates are really easy to work with.

Things I Dislike About Vala

• Unexpected and unexplained restrictions.
• The language is designed for a very specific purpose.
• No package manager or package repository.

D

There were a few things that lead me to try this.

• gtk.org’s new site no longer lists vala as a language for GTK.
  • perhaps this isn’t fair, but I took it to mean something about the state of vala.
• gtk.org’s new site lists D as a (supported?) language with bindings.
• I watched a (likely biased) Dconf 2017 talk on youtube suggesting that D should be the new defacto GTK language.

Since I don’t have much experience let me jump into the likes / dislikes.

Things I Like About D

• It has a package manager and central package repository.
• Meson-build supports it.
• There are - in fact - GTK bindings for it, which are maintained and have been for a while.

Things I Dislike About D

• As far as I’ve found, no composite templates 😭.
• The way meson relies on dub for package dependencies is a little strange (but it does work).
• I’ve been having a rough time finding any GTK program (other than tilix) written in D which I can use as an example of how to do things.

Conclusion

You may be wondering “Why GTK? why not QT? or some other GUI toolkit?”. The answer is really quite simple. I like the GNOME desktop environment and I use it. GNOME is built with / on GTK and so it makes sense to write my app to fit in with it. In addition I like the look of phosh and I want my app to look good on that particular mobile interface.