I invested a significant amount of time and effort developing C and C++ applications with GTK+ and Gtkmm. The consideration given to application developers when making repeated incompatible changes, along with a seemingly endless stream of bugs in both, forced me to move to Qt, and I've been using that exclusively for GUI work since the Qt5 timeframe. There's no upgrade path for older Glade project files. Basic widgets have been deprecated and removed. A fairly trivial maintenance cost has instead been imposed upon the entire developer base, in most cases for little or no tangible benefit.
In 2022, where are the "network objects"? GNOME started with a fairly revolutionary and interesting premise of interconnected services using CORBA. CORBA of course died a slow death, but there are modern replacements (not dbus), which could be used to great effect. Over the last 15 years, GNOME seems to have been primarily driven by appearance and usability (by their definition), but the technical underpinnings of the whole thing are fairly shallow and limited compared with what might have been.
In practice D-Bus is functionally similar to many other IDL schemes and can be trivially tunneled over SSH. But yes, it has mostly become used for local applications to communicate with system daemons, and the networked case is not particularly relevant.
The modern replacement for networked objects is to write a web server and communicate using XMLHttpRequest/fetch/websockets, which is outside the scope of a desktop environment.
At least the lower levels of the desktop stack hasn't succumbed (yet) to the backwards compatibility breakage found in the higher levels.
The backwards compatibility i refer here is having libraries, binaries and code work with the very latest version of Gtk (not Gtk1, Gtk2, Gtk3 or Gtk4, but *Gtk*, no numbers or anything) always work, just like a Win32 binary made in Windows 95 using the Win32 API can work in Windows 11 and even get new functionality introduced in the same APIs since then or just like an ELF binary compiled in a 1997 Linux i386 distribution can work on a modern x86_64 Linux distribution (assuming no dependencies to broken userland libraries, of course) and use new functionality introduced to the same APIs in kernel since then.
If the suggestion is that GTK should somehow get the same budget that Microsoft has to put towards backwards compatibility, you know very well this is not possible. It would probably not even be wanted, GTK is a lot less popular than Windows.
Gtk programs from 2000 do not work on the latest Gtk, regardless of if the functionality they used from the APIs they relied on would be found in the latest Gtk. Instead they have to be "ported" to the new Gtk, assuming the source code is available, the developers are available and someone is willing to waste effort and time to do the porting.
Which has been my entire criticism! Gtk major versions being "new APIs" is what breaks backwards compatibility and causes existing applications, libraries to waste time keeping up.
It actually worse than Win32 vs WPF because the latter is something you can ignore as Win32 is still receiving improvements with bug fixes and new functionality, but Gtk development for any previous major version eventually stops all development. Not only that but even with new APIs, under Windows there is always some official way to use the previous APIs together with the new (e.g. mix Win32 with WPF) but there isn't anything like that for GtkN-1-with-GtkN (and even if there was it'd be pointless in long term as GtkN-1 would eventually stop working, unlike Win32).
Then your actual criticism is that those previous versions have stopped development, not that backwards compatibility was broken. The whole thing about "backwards compatibility" is a distraction. And again, it is not a waste of time keeping up if they actually want the new features. If they do not want them then they are free to spend their time maintaining the old versions.
The only areas where i see WPF doing better is that at least it allows merging Win32 and WPF code, so an application can improve partially if they see WPF as a valid path forward - and it doesn't present itself as Win32 v2 so that Win32 development can continue independently (remember that i wrote that WPF is something you can at least ignore). None of these are the case with Gtk though.
But again, mentioning WPF here serves no purpose, what i wrote so far should be clear enough by itself.
That Joel article is more of a rant than a coherent statement, it is not reasonable to ask developers to stop working on new APIs and libraries.
>None of these are the case with Gtk though.
But this is incorrect, development can continue independently on old versions of GTK.
I brought up Win32 because it retains backwards compatibility for decades and still gets bug fixes and new features, WPF is as relevant to the discussion as Qt would be.
> The drawing part of the Win32 API is actually probably closer to Xlib and Xaw than it is to GTK.
The Win32 API provides way more functionality than Xlib (Xaw is a separate toolkit and unrelated to Gtk) and is closer to a toolkit like Gtk.
> That Joel article is more of a rant than a coherent statement, it is not reasonable to ask developers to stop working on new APIs and libraries.
What Joel asked (well, he didn't ask, jut put forward) was about wasting developers' time chasing new APIs that do the same things like the old APIs because they are afraid they're going to remain behind and the old APIs will stop getting any form of support or development.
Like what Gtk does to older major versions, basically.
> But this is incorrect, development can continue independently on old versions of GTK.
The entire idea of having an "old version of Gtk" that some 3rd party developer(s) continue on to keep backwards compatibility could only be a possibility because the actual Gtk developers do not care about keeping backwards compatibility.
I haven't read anything about them leaving behind extensions yet, do you have any more info?
I was never found of MSHTML and Active Desktop, nor of its FOSS clones.
See the readme on the repo, they basically use Gtk rendering into browsers.
>Ideally I would use an embedded Wayland compositor widget instead of a webview and broadway, but unfortunately there is only an old non working prototype called Wakefield and finishing it is a project on its own. In any case replacing the webview with a wayland compositor widget would be trivial.
In those days I still believed that GNU/Linux would eventually gather around one main desktop solution.
Nowadays I focus on Apple, Google and Microsoft platforms, while GNOME does yet another reboot with Gtk4, leaving behind Glade, extensions and whatever else.
That C++ code for the article has nothing to do with "modern" Gtk.