HN Distilled

Essential insights from Hacker News discussions

Classic GTK1 GUI Library

Original Article

Hacker News Discussion

This Hacker News discussion centers on the perceived decline in usability and maintainability of the GTK toolkit, contrasting its early versions with its later iterations, particularly GTK3 and GTK4. A recurring theme is the frustration with API breaking changes and the perceived lack of foresight from maintainers.

API Breakage and Maintainer Philosophy

A significant portion of the discussion revolves around the constant breaking of the GTK API and the philosophy behind these changes. Many users express dismay at what they see as unnecessary API churn, alienating developers and users.

  • the_biot states, "The non-compatibility has over the years become the defining feature of GTK/Gnome. The maintainers seem to go out of their way to break API, for no reason at all."
  • Expanding on this, the_biot provides an example: "I submit as evidence gtk_hbox_new(), there since the very first version of GTK, and deprecated in 3.2, in favor of gtk_box_new(GTK_ORIENTATION_HORIZONTAL). It's a prime example of something that was entirely unnecessary, could have been hidden from the user with a macro, or (pointlessly) added but keeping the old API in place. They do this all the time. It's not just the idiocy, it's the blatant hostility towards their users that gets me."
  • thw_9a83c offers a slightly more nuanced view: "I wouldn't say that maintainers break API, 'for no reason at all', but surely they don't make the stable API a priority either. The fact is, that every API breaking change is an insult to developers/users of that API."
  • freedomben acknowledges the frustration but also defends the maintainers to some extent: "I absolutely share your frustration at breaking API changes, and the older I (and my software) gets, the more it irritates me. It can be downright enraging to have (my) perfectly working code suddenly broken due to an irrelevant (to me) API change, especially when it requires hunting down a ton of compiler errors. I absolutely wish they would prioritize stability more. Now that said, I do not think the truth is 'The maintainers seem to go out of their way to break API, for no reason at all' or 'These are not thoughtful people, with a vision for the future. They are idiots that inherited something great (GTK 1), and have spent decades thoroughly fucking it up.'" He adds, "Having worked on numerous long-lived APIs in the past, there is always a tension between backwards compatibility and future development, especially consistency between calls. Especially when there are a lot of different contributors, it's very easy for annoying inconsistencies to pop up, and it feels really great to fix those. It's a constant balancing act between the past and the future, and a tilt too far in one direction comes with some significant downsides. I also think some grace is warranted for people giving their code away freely with no expectation in return."

Nostalgia for GTK1 and GTK2

Several users express a fondness for earlier versions of GTK, particularly GTK1 and GTK2, contrasting their perceived strengths with the perceived weaknesses of later versions.

  • badsectoracula states, "IMO Gtk2 is better than Gtk1 as it did a significant number of improvements both in terms of features and usability. Later versions though aren't as great. And TBH i do not think Gtk was ever 'great', it was just fine and its main feature was availability because of the C API. For some time it was the de-facto GUI API (during Gtk2 times) for Linux until Gtk3 broke that."
  • joz1-k shares a similar sentiment: "Nice to see that someone is still maintaining the original GTK1 toolkit. It's like the classic Win32 UI API for the Linux/Unix. Linux UI libraries are a constantly moving target and one can be easily more occupied by adapting to those toolkit API changes instead of focusing on the features of the application itself."
  • pferde directly criticizes the direction taken from GTK3 onwards: "Yeah, I think GTK2 would be a better candidate to keep maintaining. GTK3 is where it started to go to hell in a handbasket."
  • zokier provides historical context on GTK2's longevity: "Gtk2 also had exceptionally long lifetime, initial release in 2002 and last release in 2020. In contrast Gtk1 was initially released in 1998 and last release was 2001."
  • roschdal is quite direct with their preference: "GTK1 is the best GTK."

Technical Limitations and Modernization Issues of GTK1

While some users pine for GTK1, others highlight its significant technical limitations compared to modern standards, making its continued maintenance a challenge.

  • joz1-k raises a key concern about GTK1: "On the other hand, I think GTK1 doesn't even support Unicode."
  • WesolyKubeczek corroborates this and adds other drawbacks: "It doesn't support Unicode, doesn't support font antialiasing, and instead of fontconfig, you need to grapple with X11 core font support, using ttmkfdir and friends, and make the X11 server aware of where the fonts are. It's some experience I definitely don't miss from those days."
  • Findecanor points to the underlying technology: "GTK 1.x used GDK which was a thin veneer on top of Xlib, and I think it defaulted to use Xlib calls for text rendering. If the X server supported antialiased text (and subpixel rendering) then GTK should have done too."
  • floam provides a link to a patch, gtkaa, that enabled antialiasing for GTK1, indicating that the capability was "hacked" in rather than being a native feature.
  • jandrese mentions a different kind of technical limitation: "One thing that GTK lost in the transition to GTK2 was working well over slow Internet connections. I remember how even on a dial up modem you got pretty acceptable performance out of a GTK1 app, so long as it wasn't shoving big bitmaps around. GTK2 on the other hand was always dog slow over remote X connections for no apparent reason." This is later attributed by xantronix to "pixbuf/pixmap font rendering on the client side rather than X server side text rendering."

Alternatives and the State of Linux Desktop Development

The discussion touches on the lack of stable alternatives and the broader context of desktop environment development on Linux.

  • spookie expresses frustration with the lack of good alternatives to deprecated features: "The best part is having no good alternative to the deprecated stuff. In the end I just stopped giving a damn and use either a modified microui or lvgl."
  • thw_9a83c relates a personal experience with KDE development, drawing parallels to the GTK situation: "This is sad. Actually, a long time ago I stopped working on two Linux desktop applications that used KDE framework libraries. I managed to port them from KDE1 to KDE2, but I got frustrated and lost my patience with KDE3 changes which had nothing to do with my application and I just gave up. Sorry to hear that GTK is the same constantly changing target. After this experience I actually like Web-UIs and CLI apps a lot more."
  • hulitu generalizes the problem: "This is also true for KDE and, unfortunately, a lot of modern software. People just don't like building and fixing things."
  • rcarmo laments the loss of the "art" of creating sensible native GUI toolkits: "I'm so happy to know this exists because every single cross-platform UI toolkit I've used in the past few decades is more complex and weird. (Not that GTK1 can't be complex and weird, more that we've lost the art of creating native GUI toolkits that make sense.)"

Legacy Software and Current Usage

A side discussion emerges about the practicality of using GTK1 in modern times and its presence in niche applications.

  • vintagedave initiates this by questioning the use of GTK1 in 2025: "I never followed the history of GTK very much but reading about non-compatibility between versions surprises me, just as a matter of software engineering re a critical dependency. I am unsure from the page, just that it implied: is there software in 2025 still using GTK v1?"
  • gary_0 notes its absence in current Linux Mint repositories, but points to Slackware as an exception: "apt search libgtk on Linux Mint 21.2 doesn't show it. Only versions 2, 3 and 4. Searching https://pkgs.org says that most distros don't have a gtk 1 package... except for Slackware!"
  • badsectoracula mentions Lazarus (an IDE for Free Pascal), which has a GTK1.2 backend: "Lazarus[0] has a Gtk 1.2 backend that i occasionally fix (though it has been a while since i tested it), but you need to install the Gtk 1.2 libraries from source[1] since no current distro aside from Slackware (from where i got the sources and patches) packages it."
  • itomato humorously notes that Cinepaint, an image editor, was brought up in relation to this discussion.
  • HexDecOctBin inquires about a lightweight GTK2 distribution, finding the Windows distribution to be unnecessarily large.
  • thedumbname highlights build system challenges: "Tried to build on Windows, Mac, Linux: different errors on each platform."
  • dsijak confirms its removal from Ubuntu's standard repositories.

Older UI Toolkits (Motif, Xaw)

The discussion briefly compares GTK1 to even older Unix UI toolkits like Motif and Xaw.

  • bbanyc suggests "The 'classic API' would probably be Xaw or Motif. Those haven't changed since practically before there was Linux."
  • joz1-k agrees on Motif being classic but not Linux-specific: "Then I would vote for Motif. But since it predates Linux, it is a classic Unix look, not Linux."
  • thw_9a83c offers a more balanced perspective on Motif and GTK1: "Motif was the real 'classic' API. But let's do a little justice to GTK1. Motif was still a proprietary library when GTK1 was released. GTK1 was also already easier to develop with, and the default look&feel was somehow better. For some reason, all the widgets in the Motif UI were huge. Given the small resolutions of that time, it was very space inefficient."
  • moregrist adds to this dichotomy: "If I remember correctly, Xaw was part of X and predated Motif although it’s hard to really call Xaw a full UI; it was pretty bare bones and limited. It’s worth keeping in mind that there were other Unix UIs that didn’t make it. For example, Sun NeWS was quite interesting (based on PostScript). 'Huge and IMO quite ugly. Also slow. Not that Xaw was pretty ( or even that functional). GTK1 was definitely a step in the right direction.'"
  • jandrese criticizes Xaw's programming model: "Xaw was also really awful to program in. When I tried using it once I ended up reverting to just plain Xlib and was much happier, even having to build my own widgets out of low level primitives."
  • Findecanor mentions LessTif as a free Motif clone and discusses GTK1's theming capabilities: "The free clone 'LessTif' already existed when 'GTK+' 1.x came along. I agree that GTK was much easier to program, and had a better feel but the look was mimicking Motif except that every widget instead used a shaded button-style border — and that looked very ugly IMHO. However, GTK 1.x supported theme engines. Back in the day, my theme for GTK 1.x was one of the most popular, giving programs a look reminiscent of NeXTStep and Windows 95."