GTK 4.0 Released
blog.gtk.org
blog.gtk.org
I understand breaking backwards compatibility a first time, maybe out of a failure to plan ahead, but not multiple times.
It would be easy enough to add new subroutines to add more functionality. Is there a reason to change or remove old subroutines of which I’m not aware? Otherwise this is just causing extra work for application developers for no good reason and in many cases killing old stable applications which are no longer developed.
If it's too much work for application developers, the can keep on an old version of the library or maintain a shim. (There are still a lot of GTK2 applications out there, although distros seem to be removing them because nobody is interested in maintaining a shim or backporting things)
https://github.com/libguestfs/virt-p2v/blob/master/gui-gtk2-...
https://github.com/libguestfs/virt-p2v/blob/master/gui-gtk3-...
And that's just one very small and limited application.
¹ 2007 and 2010 respectively, not sure off the top of my head what versions of Gtk those have, but old.
² It's not just Gtk, but glib and dozens of other libraries.
Of course they do not have to care about backwards compatibility since GTK is just a library that happens to be popular enough to be widely available but not really part of any platform. The OS itself (Linux) is binary compatible going back decades.
It is a bit frustrating though, but really if you want a stable GUI API either write against pure xlib or use something like Motif which even though it barely gets any updates probably wont go away any time soon as it is used in several long standing scientific and enterprise applications (ie. the unsexy stuff you rarely hear about but still work behind the scenes).
It might be interesting to see what it'd take to make Motif a bit more themeable though.
Jumping to pure Xlib or Motif is a bit beside the point, to that end you might as well use GTK1 or GTK2 if you don't mind using an old stable API that is not really being updated anymore.
That sort of "backwards compatibility" is useless in the long run and a big source of waste of time for the developers who rely on their library - see XFCE or even Gimp as examples of projects wasting tons of time just to do the same stuff just with a different API.
In addition it isn't what the thread is about which should have been obvious from the Win32 as an example. When you use Win32 you get the latest fixes and features even in applications that haven't been updated for two decades - for example you get new common dialogs and access to shell extensions (e.g. TortoiseSvn/Git integration) that didn't exist back when those applications were made.
Backwards compatibility isn't just about keeping the old stuff running as they were back when they were released - that is just the absolute minimum. It is also about adding new features and fixing bugs that all applications - both old and new - can benefit whenever possible.
> Jumping to pure Xlib or Motif is a bit beside the point, to that end you might as well use GTK1 or GTK2 if you don't mind using an old stable API that is not really being updated anymore.
Xlib and Motif are not equivalent to GTK1 and GTK2 since they do receive updates and bugfixes, even if they rarely receive new features (though both do receive new features too).
I get what you're saying, but asking "why doesn't my old API get new features" is a different thing than asking for backwards compatibility because that entails actually modifying the old applications to support new API features, not just maintaining compatibility with them. If someone really wants to step up and backport features to GTK2, that's always possible, you don't need to wait for the GTK4 developers to figure it out.
If what you're looking for is a way to roll out some new widgets one by one and transition to a new version slowly, I agree that's something that could be worked on. But it requires a bunch of additional work that's mostly orthogonal to just shipping a new toolkit and it may not make sense for it to happen upstream.
If GTK3's API was backwards compatible (both in binary and source form) with GTK2's API then the developers of all the applications that relied on GTK2 wouldn't have to spend any time changing their applications to work with GTK3 nor make any "weighting" between doing these changes or staying on a library that wont receive any further updates and features after a while. And in practice this isn't really much of a choice unless the GTK developers also committed to updating, fixing and improving (ie. adding new features) to the previous library - at which point why bother with the new version at all?
This is a waste of time because the developers of those applications could have spend their (often limited, since they're not paid to make those applications and instead make them in their free time) development time on fixing bugs and adding features to these applications that directly benefit the end users instead of trying to catch up with whatever stuff GTK3 broke (and now will be broken again in GTK4).
> I get what you're saying, but asking "why doesn't my old API get new features" is a different thing than asking for backwards compatibility because that entails actually modifying the old applications to support new API features, not just maintaining compatibility with them.
No, this is exactly backwards compatibility in the best way: the old applications get new features without even having to recompile them. This is how it works, e.g. in Win32 where as i wrote above you get new features in applications that were compiled 20+ years ago.
You only need to modify existing applications so that they can use new features when it makes sense for those new features to be requested by the application. But, for example, you do not need to modify existing GTK2 applications to add Wayland support in GTK2, or to improve the a common dialog like the file picker, or to add an emoji picker in text editing areas (which, btw, is also a feature that Windows applications got in Windows 10 which works even in applications compiled many years ago before emoji was a thing outside Japan), or a bunch of other stuff.
What you describe would only be an issue if someone statically linked against GTK but the overwhelmingly vast majority of applications link against GTK dynamically and on Linux they all pretty much use the distribution's libraries instead of bundling their own.
> If someone really wants to step up and backport features to GTK2, that's always possible, you don't need to wait for the GTK4 developers to figure it out.
Yes, of course anyone could improve GTK1, GTK2, etc but what is being discussed here isn't if it is technically possible to improve these libraries without breaking backwards compatibility (it obviously is) but about what the (official) developers of these libraries are actually doing with regards to backwards compatibility.
If someone really wants to backport things like wayland support or emojis to GTK2, or make a shim layer to support all the old GTK2 APIs in GTK3, you could probably get people on board to take those patches somewhere. I know adding wayland support would not be simple and would probably break things as there are a lot of things in GDK2 that were direct mappings onto X11 APIs that have no analog in wayland. As the backports pile up you would have to weigh the cost of doing that versus just porting the application and getting the additional benefits of porting to a newer version. It would only be a total waste of time if there were no benefits to porting, but this is not the case.
I just doubt any of the GTK4 developers are going to want to drop what they're working on now to do these things given the risk it carries combined with the fact that there are workarounds for these missing features.
As i wrote a few messages above, that is the absolute minimum to call "backwards compatibility" so i'm not sure why you need to be clear since we agree on that part
> Adding new features is often at odds with this because it can break things in subtle ways.
You take that into consideration when you decide to add new features, it isn't like features come as demands from the gods in what and how to implement. And if you break things in subtle ways, you can fix them down the road if that is a problem - it isn't like broken code has to remain broken.
> You might be able to make some small backend changes, bringing back some of the major breaking changes to widgets or to the rendering model is out of the question.
The idea is to not make breaking changes to widgets in the first place. And changing the rendering model should also happen in a way that doesn't break the existing code (e.g. add a compatibility layer for custom widgets that use the previous rendering model and either make any customized widgets -e.g. buttons- to detect that they are customized and use the older rendering model in that case so they remain compatible but the new rendering model for newer code or create new widgets that use the new rendering model with an API that is as drop-in as possible so that 99% of the changes can be a search and replace in codebases).
Yes, that makes things harder than simply ignoring backwards compatibility and expecting every single application that uses your library to change their own code and break any applications that cannot update to the new APIs/ABIs, but that is the price for doing backwards compatibility properly.
Of course that is too late now for GTK and as i wrote previously (and later), the developers do not care about backwards compatibility anyway so i do not expect them to do anything about that when GTK5 comes around and instead they'd just expect everyone to waste time changing their working GTK4 code to use GTK5.
> If someone really wants to backport things like wayland support or emojis to GTK2, or [...] this is not the case.
You are missing the point, my message wasn't about what could or not be done by 3rd parties to improve GTK2 or whatever, but about what GTK developers themselves decided to do. What someone else would do is absolutely irrelevant to the topic.
> I just doubt any of the GTK4 developers are going to want to drop what they're working on now to do these things given the risk it carries combined with the fact that there are workarounds for these missing features.
I do not expect that to happen either, after all my first message in this submission even began with "Because the GTK developers do not care about backwards compatibility."
The GTK developers are just ordinary people like you or I who volunteered to work on it, if you want to change this situation then you or someone else can step up and become a GTK developer and work on this. Then you can say they care about it :) I think it is incorrect to say they don't care about backwards compatibility anyway, you seem to agree that they would meet that minimum required to claim backwards compatibility.
The GTk developers aren’t ordinary people. They comprise an organization of trusted individuals and leaders. Not to mention, Many of them are employees are large companies like Red Hat and Canonical. They have resources. The likelihood of a random strangers contributions being upstreamed are low, let alone them setting project direction around backwards compatibility.
Hundreds if not thousands of apps have been left behind in GTK2 and GTK1 before that. Those are all apps that could be part of the current GNOME ecosystem, now they will look like bad foreign apps. Tens of thousands of man hours completely wasted.
This will kill the GNOME desktop. It’s a dead end for anyone but GNOME developers. Everyone sees it. GTK4 is just the latest demonstration of their incompetence and disregard for other developers.
Please don't use this type of hyperbole, I've heard this type of thing often in various contexts, and while it may be fun to say, it's inaccurate and it's thoroughly unproductive in getting the actual issues solved. What you view as incompetence and disregard is more accurately described as "lack of time." IIRC there are only really 2-3 people working full time on GTK, and most of their efforts are focused on getting new releases out the door. It's not as many resources as it may seem from the outside and they don't have time to do everything that people want. They depend on volunteer contributors to handle the long tail of issues and edge cases that come up with older applications.
If you'd like to improve GTK2 and GTK1 applications, please find a way to contribute and help out! I can help to point you in a direction if you want. (I don't think it's really much of a big deal if older applications look weird, the main concern with them is usually that they don't break. From this angle, GTK1 and GTK2 apps are not being left behind, they work perfectly fine even on a modern system) I'll warn you though, it's not trivial to get a legacy app to look and act native on a modern platform. If you really want to do a good job at it, you have to manually redesign each of the apps individually and it gets time-consuming.
I personally think it would be great if XFCE/Mate/Budgie/Cinnamon/etc had the resources to pay more full time developers to contribute upstream and collaborate more with the GNOME people, but we are not there yet unfortunately.
Wrong, GTK 1 was removed from Debian over 10 years ago: https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=520441
Again, this isn't about what can be technically possible. As the other poster wrote, it is a criticism towards the decisions of the GTK developers. That someone else could take the code and change it, is completely, absolutely, 100% irrelevant. It has nothing to do with the comments here, they aren't about if it is technically possible to add a compatibility layer on GTK3 or GTK4 or whatever nor who will make it.
It is ALL about the GTK development team's decisions, including the decisions that make a backwards compatibility harder.
Also caring about backwards compatibility isn't something that can be bolted on top by a 3rd party, it is something the library has to keep in mind in the design phase. And it isn't something that can be thought as a separate component, it is something that has to be at the same level as everything else. Expecting that it is something that "shouldn't hold up a GTK release" is a completely wrong way of thinking about backwards compatibility - a project that cares about being backwards compatible considers it as important as any other change (new features, bug fixes, etc) and not something to be an afterthought.
> The GTK developers are just ordinary people like you or I who volunteered to work on it, if you want to change this situation then you or someone else can step up and become a GTK developer and work on this. Then you can say they care about it :)
Sure, they may be (i do not know) and they have all the rights to ignore backwards compatibility - it isn't like i'm paying them to work on their library or be in a position to make any demands out of them. But that doesn't mean i wont say they do not care about backwards compatibility.
> I think it is incorrect to say they don't care about backwards compatibility anyway,
It is absolutely correct because this is what they have repeatedly shown.
> you seem to agree that they would meet that minimum required to claim backwards compatibility.
No, i do agree with that, what i agreed with is the definition that keeping code running is the absolute minimum one would do to provide backwards compatibility, but i never claimed that the GTK developers care about it. These are two different things: one can not care about backwards compatibility, yet still provide that minimum amount for it for practical and strategic reasons to entice people move to the next version.
>Expecting that it is something that "shouldn't hold up a GTK release" is a completely wrong way of thinking about backwards compatibility
Why? Once you decide to refactor an API you have to maintain an extra piece to translate the old to the new, there is no way around that. Developers can spend time before the release working on this translation piece alongside the new features or they can just release it now so people can test the new API before deciding to invest in developing that. For an open source project I can't see how the first option really makes sense, and if your argument is that they should have been developing it the whole time, that is essentially what they were doing for the entirety of the GTK3 development cycle.
That is being generous in assuming that it's even possible to do this, sometimes a design is so flawed that you can't even make it work at all with the new stuff. At some point you have decide to cut deprecated APIs or you are left with an infinitely growing pile of technical debt. I referred to this elsewhere, but old GTK1/2 applications that use raw unscaled pixel buffers are an example: there is no backwards compatibility that is going to work here that makes them function correctly with high dpi. It simply cannot work if the application is hardcoded to use an old API that has no concept of dpi or scale and assumes a pixel is always the same size. (Maybe someone can cheat with AI upscaling algorithms but those are usually pretty slow :)
I guess to put it another way: I don't see any way that GTK4 could have been designed differently to do something like make it easier to compile GTK1 apps against it while reaping all the benefits of GTK4. If somebody wants to make a GTK1 shim for GTK4 that translates GTK1 API calls into GTK4 API calls, they can go do it now, it would probably be a pain and it's probably not going to magically get you all the new benefits that would come from just porting the application to GTK4 and refactoring to use its new techniques along the way.
What you're describing is not backward compatibility, it's forward compatibility.
The OS is backward compatible with old applications that continue to run. The old applications are forward compatible with newer versions of the operating system including some of the new features that are added.
Achieving backward and forward compatibility (the combination is often called "full compatibility") is actually quite difficult. The resources Microsoft throws at this problem and the related coordination costs are massive (and conversely, the progress any individual developer sees on their particular tasks is often glacial)[0]. In the open source world, I think only web browsers typically see anything resembling a similar level of effort applied to evolving the platform while maintaining compatibility with extant (and often buggy) code, and that's still a much smaller problem (though it might not be after another decade or two), since for all intents and purposes, the web as a whole is a "rolling release" system with bugs and incompatibilities popping up and being fixed constantly.
[0] http://moishelettvin.blogspot.com/2006/11/windows-shutdown-c...
Conversely, Microsoft is rather notorious for not making many of its own offerings forward compatible with themselves. For example, old versions of Office cannot open or edit files saved by newer versions. And while new versions of Office will open older format files, they then save the file in the new version of the format by default. This one-way ratchet "strongly encourages" upgrades in lockstep.
The price of backwards compatibility is keeping backward design. Microsoft stated a few times that they couldn't keep the exact interfaces of Win32 without leaving security problems inherent in the mis-design of original interfaces. I have no idea if they intentionally broke the interfaces, but Wine is sometimes more compatible with old win32 than windows.
And for older games there are often alternatives in Windows (e.g. dgVoodoo2 which reimplements older DirectX and Glide versions under Direct3D 11 and i think nowadays 12) that provide even better compatibility and features.
Binary compatibility is mostly irrelevant, any sane distribution scheme is based on static binaries.
Now, breaking source backwards compatibility is a real tragedy.
Microsoft has introduced just as many new toolkits during the same time, but nobody expects WinForms to be backwards compatible with MFC.
That would have given application developers a better chance to keep maintaining the toolkit long after GTK developers lost interest.
GTK3 became "final" in 2016 with 3.22. That was when GTK4 development started. And many applications just started to be ported to 3. Then 3.24 as a maintenance release came out in 2018. And in almost exactly 4 years 4.0 is ready for general availability, but it's likely far from "final" and stable.
So GTK3 continues to be maintained for a good while. (Though GTK2 is now EOL.)
One of the main reasons we abandoned Pinta (https://github.com/PintaProject/Pinta) is we had to rewrite a significant portion of the app if we wanted to move to GTK3, as we had many custom UI needs.
See also: GIMP, still on GTK2. Inkscape released on GTK3 just within the past year or 2
At this point I cannot imagine a sane third party application developer choosing to build on top of GTK. The clock starts ticking on the life of your application the moment you choose GTK.
The ticking clock you're referring to is real, but it applies to any open source library you're depending on that you aren't contributing anything to, not just GTK. It can't be avoided just by switching to another open source toolkit. If it really bothers you, start contributing and help out!
Realistically, most people who decide to ditch GTK seem to switch to Qt and either start contributing there or pay for consulting/LTS/commercial licenses eventually, because that is the only comparably modern option for native widgets on Linux/BSD.
So yes, jumping from dependency to dependency is not a viable option long term. Luckily you only need to jump away from GTK once.
As far as contribution processes go, both upstreams are equally tedious to work with. I doubt GTK would be willing to accept your code contribution if you added systray icons support back to GTK4 for example. So while the contribution process does matter, it doesn't matter as much as you make it out to be.
AFAIK the systray icon support in GTK was removed because nobody was willing to maintain it. I don't think that's a great example because it doesn't even need to be in GTK anyway, it relies entirely on platform-specific functionality and has little to do with the toolkit. Someone can just make a library for that. (And I think Ubuntu did, but it was not upstreamed for a few reasons, one of them being that it didn't support multiple platforms) Regardless, that is the point I was getting at. The upstream policy is really not that different between these projects, you can't avoid it just by jumping ship.
It’s simply false that retaining API backwards compatibility prevents refactoring and necessarily causes technical debt to balloon.
The parent thread is comparing a runtime API (Win32) with a compile-time library (GTK).
You can run two applications with GTK3 and GTK4, and maybe 10 years into the future GTK10 in parallel. They will just look different, but nothing else will change. It's not as if the old application built with GTK3 will crash or not start.
But if you break the Win32 API, a whole lot of desktop applications will crash.
Porting is encouraged because GTK2 isn't maintained anymore and lacks features expected in 2020, like hidpi support.
If that’s the case then you have failed as a library developer.
Make a thought experiment and imagine that each new major GTK (or Qt) version had a different name. You'd still have old GTK, which wouldn't be maintained anymore as the devs moved on, and new NTK or whatever, which would be what was still developed and used these days. Somewhat similar to old GTK since that was its roots, yet distinct.
And that's exactly what happens, they just reuse the name because well, why wouldn't they. You can still use GTK2 just like you can use Win32 API, but nobody does modern apps in either GTK2 or Win32 API or expects them to smoothly blend into modern desktop these days.
Not even speaking about the fact that The GIMP is a very special case that makes it probably the hardest GTK app to port to newer versions in existence.
My 20 year old projects run perfectly on Linux with WINE
Now there is Lazarus to port Delphi code to a native Linux version, but it is using GTK2 and that is running much worse. (or through qt4 but that is even worse) The good thing is, if Lazarus gets a GTK3/4 update, my old code is supposed to run on the new GTK unchanged. The bad thing is, Lazarus is not popular so hardly anyone is working on those updates.
> GTK is the core of the GNOME development platform, but it can also be used to write applications for other Linux environments, as well as applications targeting Microsoft Windows and Apple macOS.
I'd love for some hn folks to share feedback on portability and overall value of using GTK for multiple platforms.
What other engines/platforms exist? I know of Kotlin for mobile/web but besides Electron, I'll have a hard time picking something for desktop apps, should portability be a requirement...
PS: I have a love-hate relationship with Electron. I guess I'm not the only one, so I won't elaborate.
All cross platform frameworks are a compromise though so you should avoid them unless you know you will definitely need it.
While less than popular, I'm more inclined to just target Electron or Carlo and leave it at that for my UIs. I know that it's much higher overhead, and if I was doing something with a minimal UI, or something that persisted in a tray I'd probably reach for something more minimal. It really depends on the use case.
React Native options may be another target that I might look into if I needed native, thought he UI kits aren't quite as interoperable as I'd necessarily like, it's a pretty decent option.
I mostly do full-stack service layers with react/web ui these days so anything that leans on what I already do is likely the best use of my time. A browser surface, while massive, memory hungry etc, is still often the best option for any app UI work as it solves so many issues and can run everywhere. It's the combination of those two that make it so appealing. Reducing friction. Of course it's also why we have mobile devices with 4gb+ ram on them these days.
edit: would also consider uno with .Net 5 - https://platform.uno/
I used to think there was value in being well aligned with the native Desktop UI. Now I don't really know what that is any more and I no longer really care. I care that a given application serves it purpose and the degree of an application's alignment with the latest native UI trend is well down on my list of concerns. Coping with the delta between applications is a small problem I try not to get hung up on.
I was always a huge believer in native UI, following the platform HIG, never reinventing controls just to satisfy graphic design caprices; but Apple has essentially given up on these things.
The Mac UI is now just Windows 10 with rounded corners instead of sharp.
What shall we conclude from all of this? I propose that simultaneously expecting a) an operating system to host a limitless diversity of graphical applications with origins that transcend platforms, programming paradigms and decades and b) that they all precisely align with your chosen operating systems ever changing GUI conventions and c) all of this be delivered at at least affordable if not no cost -- is simply unreasonable.
* Inkscape has a macOS version that looks, feels, and functions fairly nicely
* Documentation for how to ship a GTK app for macOS is severely lacking (not sure about Windows)
* Many cross platform apps choose Qt over GTK
I suspect that Qt is a slightly better (both look and dev ergonomics) and more portable solution, but not sure.
There are lightweight electron alternatives - HTML/CSS engines with a scripting DSL. Sciter is a paid option but I know there are free options depending on your language of choice
I’ve been working on a cross platform music player and went with GTK over QT because I preferred the Rust bindings, QT seemed to have a lot of non UI code I didn’t need, and I was skeptical of dealing with QT licenses (but a lot of people seem to work with it just fine - I just didn’t put the research in to see if it was right for me).
Compiling linux / mac was very easy for me. Cross compiling linux -> windows via mingw64 was also pretty easy. I had some trouble compiling mingw64 on windows, but that was due to SQLite / MSys issues that I never really figured out.
The very definition of an oxymoron... ;)
I suspect a parse error somewhere.
Maybe they made that claim because an alternative to Electron probably still uses HTML5 and JavaScript, and HTML5 and JavaScript are huge so it's hard to believe such a thing could be lightweight.
Are there? I know of alternatives, but none that are particularly 'lightweight.'
I started a new project based on gtk-rs for exactly the same reasons as you.
My gtk-rs project is intended to replace a small, self contained win32 application. The application is 132KB. So although 5MB is small it's an oom larger than my benchmark.
However, my gtk-rs hello, world GUI application is 14.6MB in release mode and that does not include the GTK DLLs that are also needed. Yikes. That's crazy.
Perhaps 5MB is a reasonable price to pay for cross platform GUI. Not taking 7+ seconds to build a GUI hello, world would be nice as well.
(that's a Rust-specific framework, but the underlying webview library is just a C library)
Not really. Gtk UX just isn't an acceptable standard outside Gnome and seems to have approximately ~nil cross-platform share apart from GIMP and perhaps one or two more apps. There are really only two cross-platform toolkits that enable an acceptable level of UX: Qt Widgets and wxWidgets. wx has a smaller and generally more limited selection of widgets and some quibbles (awkward APIs, poor rich text support, docs aren't that great), while Qt Widgets is more on the "does it all" side of things, but that means it's less simple. E.g. a model-backed list is pretty darn simple in wx, but wx is also quite limited. Meanwhile Qt requires you to understand a relatively large model API and more code for basic models, but on the flipside it's also much more powerful. For anti-bloaters, Qt has a larger binary size than wx. wx has a bunch of stuff that only works on one platform or the other and there are a number of behavioral differences as well, since it mostly wraps an underlying toolkit. Qt tends to have largely uniform behavior and features across all platforms.
FWIW all of these (Qt, wxWidgets, Gtk) are LGPL.
1.) I've written only a little bit using GTK, starting over this past month, and it has been very pleasant. The real issue I have is not knowing what documentation to use, or being a bit confused by the tooling. The existing open source projects using GTK I've been poking at over the last month written using JavaScript, Python, or C are all pretty (relatively) easy to grok and start working on. I'll definitely be back for more... FWIW- I do tend to learn by reading code; so for me, jumping into something totally foreign or unknown is pretty normal.
2.) I'd highly recommend trying Flutter+Dart for cross platform desktop applications. I've been writing my first, for about a month now, on Linux, and it has been fucking great mostly because it works. It uses Skia under the hood so rendering is fast and applications aren't totally bloated. I can speak nothing to building Flutter projects for the mobile or web variants but it seems neat in theory.
I'd definitely prefer to not write Dart, but I also accepted long ago, when you want to write GUI you pretty much have to learn a new language. It's close enough to JavaScript and/or Java learning it is pretty much just figuring out "WTF? Is X called?"
It's also a lot nicer, IMHO, than things like Electron because there's an actually useful SDK [1]. Electron, like the web, will require to you DIY a lot of really boring shit like wiring up list views to only use/reuse the displayed elements. Flutter, like most desktop GUI SDKs, brings a useful set of widgets to the table you can easily customize.
[1] No hate on Electron here; there's zero fault to be had for the web SDKs lacking useful APIs for making web apps... but that's a wholly different conversation I'd rather not have right meow.
Are you using another language for your app, or is your entire stack in Dart and not just the UI?
Nothing against the idea of server-side Dart, I just don't see a reason to bother with it. I've never really been sold on the idea of using the "same language" for both frontend and backend. I (try to) prefer the right tool for the job; which for my requirements, this time, is mostly how I ended up with Dart and Flutter... and I've been pleasantly surprised. It is the first cross-platform desktop language & sdk pairing I've used that I, personally, don't totally hate. Every other time, I've just said "fuck this" and gone and implemented it whatever the native SDKs were.
I certainly like it well enough to continue to learn and use both it and Flutter :)
It makes me wonder if the message-passing system may have performance concerns.
I tend to see a lot of developers think of Eclipse Platform UI/JFace[2] when they see SWT. Eclipse Platform UI is Eclipse's abstraction over SWT that allows them to make consistent components across platforms. SWT is lighter weight and it's just platform native components. Also since you are dealing with native components you get easy access to platform accessibility.
Eclipse has some great documentation for the platform as well as loads of snippets[3] and examples[4] to pick apart.
There is also an incredibly useful charting library[5] that is used heavily by OpenChrom(Uses Eclipse platform)[6].
I have only tried it with some small samples, but SWT does work with GraalVM native-image[7]. This should allow you to develop a nice little statically link executable instead of deploying a jar if needed.
[1]https://www.eclipse.org/swt/
https://github.com/eclipse/eclipse.platform.swt/tree/master/...
[2]https://github.com/eclipse/eclipse.platform.ui
[3]https://www.eclipse.org/swt/snippets/
[4]https://github.com/eclipse/eclipse.platform.swt/tree/master/...
[5]https://github.com/eclipse/swtchart
[6]https://lablicate.com/platform/openchrom
https://lablicate.com/static/media/openchrom-GC-MS.722d5aa3....
Nowadays the situation is completely different. Swing looks and performs great compared to SWT. IMO it would make much more sense to just use Swing.
JavaFX never happened. People just went web instead. No one uses it and it's officially deprecated.
If you are looking to build a fully themed app similar to a web app Swing or JavaFX are definitely the way to go. Swing still uses an emulated native look and feel and it is pretty decent. If you are planning on building something with real platform UI I would still go with SWT, especially if accessibility is on the table.
[1]https://openjfx.io [2]https://github.com/search?q=javafx&ref=simplesearch
To save me the clone/compilation time, any approximate numbers of how small the binary is for a SWT app?
I should note I am using Haxe here instead of pure Java, so a pure Java app might be a few kilobytes smaller.
Screenshot: https://imgur.com/3otiHA2
We had tons of problems and they where almost never easy to fix. Layouting in SWT is hard. Custom widgets are hard. SWT did not play nice with Swing/AWT on Linux so it would crash if you needed to use both. I remember I spent a lot of time getting automated testing working reliably (on mac) but eventually just gave up.
Things might have improved since I worked on this 7 years ago but I would not bet on it. SWT is basically a support library for Eclipse and therefore Eclipse is more or less the sole driver for any development.
I would rather just use Swing. Compared to when SWT was started Swing has evolved a lot and IMO the rationale for going with SWT does not exist anymore.
You can always roll your own layout system using Control setBounds and moveAbove. I have toyed around with a custom layout system on top of SWT that uses Cassowary Constraints (in fact the imgur link in my other comment shows a sample).
As for custom widgets it really depends on how you want to do it since there are so many options. SWT can embed Swing or JavaFX components, so it allows the developer to make custom widgets in whichever tech they feel most comfortable. In this case I would stick with Swing since JavaFx can be a decently sized dependency, where as Swing is built into the jre.
The eclipse nebula project is also a pretty big repository of community made custom widgets. These can be really helpful for figuring out how to implement custom widgets in pure SWT. https://github.com/eclipse/nebula
I have never implemented automated testing with it though, bummer it was such a hassle.
Also SWT does grant access to a bit more of the underlying OS than Swing does with its org.eclipse.swt.internal.* package. For example I've had to embed a GLFW window inside a SWT window. This is done with the following api in GLFW: https://www.glfw.org/docs/3.3/group__native.html
Using the internal apis you to map GLFWs native window handle to something SWT understands pretty easily. Then it's just a matter of writing the platform specific code to reparent the GLFW window into App which was 3 or 4 lines of code per platform. Then once the GLFW app was inside the SWT App it was a matter of creating a dummy Composite that when resized would overlay the GLFW app. I don't believe this would have been possible in Swing without addition JNI. I know this is a pretty obscure use case, but the internal package can be extremely handy.
Lastly, SWT has a built in browser component that uses the OSs browser or there are optional embedded V8 and webkit packages. The feature set of SWT just blows other Java toolkits out of the water. Unfortunately, this does lead it to be a bit more complicated than the others. I'm sorry about your experience, but give it another whirl sometime maybe you'll be pleasantly surprised.
Tk has language bindings for Tcl, C, C++, Ada, Common Lisp, Perl, Python, Ruby, Haskell, etc.
Tk also provides the standard GUI framework for Python: https://docs.python.org/3/library/tk.html
If anyone has used GTK in their Windows applications, I'd love to hear about it.
We would like to move away from all desktop toolkits in theory (GTK and Qt as the prime examples) because they really don't offer us a lot. Unfortunately, they do offer:
1. Treeviews
2. File Selector
3. Text Entry
4. Menus
Edit > Preferences > Appearance > [ ] Possibly Improve Slow Graphics Performance
We will not be moving to a new version of GDK at any time in the foreseeable future.
I couldn't find the second option, even grepping for it in git master.
[0] https://medium.com/flutter/announcing-flutter-linux-alpha-wi...
because otherwise I'm still going to go out of my way to avoid using anything based on GTK
Unlike your desire for effects, I prefer KDE because you can still completely disable effects and the compositing that make it performant and get excellent, glitch free remote desktop performance over a fast local network using VNC; almost no perceptible lag in normal development actively.
KDE has matured. They took the 4.x fiasco to heart and now KDE development is highly conservative and unobtrusive. I'm frankly amazed; popular Linux desktop environments have such a long history of design failures due to iconoclasts blowing everything up that the current state of KDE seems almost miraculous.
At the time it did look somewhat dire.
Important note from Bryce Harrington:
[On a personal note, this will be my last release for Cairo. My Cairo time availability has been non-existent (particularly this crazy past year). The release process is well documented and hopefully will help whomever picks up the baton from here.]
Looks like that the situation was mitigated for this release, but the situation will be more dire the next time someone needs a new Cairo release cut.