I've being using Gtk 1.2 + patches[0] (which i made by combining the last release with a few patches from Slackware) to occasionally check Lazarus' Gtk1 support. It is also neat if you want to make self-contained binaries, for example this little animation utility i wrote some time ago[1] has a Gtk1-based build with Gtk1 linked statically on it and the tool relying on just X11 and OpenGL.
GTK1 interests me as it is necessary to build retro apps I like. CinePaint being one, and also dozens of other classic GTK apps. A technical reason to care about GTK1 is code size. GTK2 is much larger than GTK1. GTK3 is much larger than GTK2.
> it seems to be based on Gtk1.2 but it is its own thing.
Yes. Historically, GTK1 was maintained as 3 separate projects across the 3 major operating systems by three different teams, not a single codebase. I created the Windows port. Later I took over the MacOS port that someone had started, but had abandoned before completion. After gtk.org deprecated Linux GTK1, I took on that code, too.
As I combine code from different versions of GTK1 from different operating systems, it breaks things. My current effort is to complete integration of the MacOS and Linux code with my Windows code, and remove resultant bugs.
> maintain the legacy API and upgrade the internal architecture to use more modern approaches.
GTK1 is of a GTK 1.2 flavor plus some enhancements. Yes, I want to smooth off old rough edges, to make GTK1 better with fonts and pixbuffers.
> I present you gtkaa [GTK1 anti-aliasing patch]
Thank you! Will take a stab at integrating that. I previously integrated the GTK1 dark-mode patch. If there are other interesting GTK1 patches in the archives somewhere, let me know. I’ve heard that gtk.org wasn’t very welcoming to GTK1 patches.
> Is there a lightweight distribution of GTK2?
Maybe in the future.
CinePaint conditionally compiled with GTK1 or GTK2 using an #ifdef. Not a lot of changes to make it build either as GTK1 or GTK2. The GTK2 API broke GTTK1 compatibility in some silly ways. For example, changing the order or arguments in function calls of the same name. Or, making an API that took one call in GTK1 take 2 calls in GTK2, or vice versa. Minor stuff, at least in the calls used by CinePaint.
Are other GTK1 apps as easy to port to GTK2 as was CinePaint? I want to add common GTK2 APIs to GTK1 to see how that goes. Doing so would make GTK1 into a very lightweight implementation of the GTK2 API.
On the other hand, I think GTK1 doesn't even support Unicode.
It's some experience I definitely don't miss from those days.
I think I have some rusty memory of LD_PRELOAD my own .so with AA enabled (special patch? I don’t recall) with a game’s installer I shipped to get the statically linked GTK+1.2 Loki Games setup utility looking modern. That plus a QUITE SPIFFY looking splash bitmap slapped onto it would hopefully let the installation complete before anyone realized it was a creaky old thing.
https://web.archive.org/web/20231129124306/http://alx14.free...
As someone who used to build Mozilla suite back when their gtk2 support was experimental, I’d say this is too much faff.
If the X server supported antialiased text (and subpixel rendering) then GTK should have done too.
I'm not questioning that it'd be possible to render antialiased fonts server side as there's nothing in X that really prevent it, I just don't recall that being a thing, rather than upgrading apps to use Xrender to render fonts client side and send the servers and atlas of pre-rendered glyphs the way we currently do.
I could very well be wrong - I didn't do much X programming in the brief period it'd have been relevant.
https://tldp.org/LDP/LG/issue28/ayers1.html
That was what I was looking for.
> Even though xfstt doesn't do any anti-aliasing of the fonts (since there's no support for this in X)
The page it links to for xfsft as well, says this:
> Although FreeType does support font smoothing, the modified libfont.a does not. Adding font smoothing to X would require a major change to the system: in X, glyphs are (monochrome) bitmaps, and there is no support for using pixmaps as glyphs. Changing this would require the design and implementation of an extension to both the X protocol and the font server protocol, and changing applications to use the extensions.
It goes on to link to the Xrender extension as a solution.
It'd have been a logical extension to figure out the changes to support AA for them as well, so it's a reasonable assumption, especially given the short cutover before Xrender took over and we started getting AA most places. Indeed, Xrender provides all the server-side infra that'd have made it easy-ish to do, by allowing glyph sets with depth...
In retrospect it's also surprising that it wasn't done, because it wouldn't instantly given AA to a lot of applications "stuck" on server side font rendering...
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. The engine also (optionally) hacked the GTK widgets, adding triangular tabs and subtly improved menu behaviour. When GTK 2.0 came along, it had a much improved default look that felt like its own thing, and also the new menu behaviour so my theme wasn't needed any more.
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).
> For some reason, all the widgets in the Motif UI were huge.
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.
It is also the nomenclature when talking about RDP, VNC, and many others,
[1] https://github.com/tschoonj/GTK-for-Windows-Runtime-Environm...
(Not that GTK1 can't be complex and weird, more that we've lost the art of creating native GUI toolkits that make sense.)
I am unsure from the page, just that it implied: is there software in 2025 still using GTK v1?
I recently found a GTK API call that was deprecated in GTK 3.0, only for its replacement to be deprecated by 3.16. 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.
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 also the de-facto GUI API (during Gtk2 times) for Linux until Gtk3 broke that.
Also, it is easy to call people idiots, but calling people who GIVE you software you can choose to use or not that is not very productive or even nice.
I could call you names but that would only make this discussion worse.
This is also true for KDE and, unfortunately, a lot of modern software. People just don't like building and fixing things.
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." 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.
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.
The change adds zero value. It's a deliberate API break. And it could have been made a non-breaking change all for the sake of a single one-line macro or inline function.
This isn't unintentional. It's a deliberate choice they have made. And not just this one, it's happened repeatedly over the years.
The thing that really gets me, as an end-user/developer, is that it forces incompatible changes not only in my codebases, but in every other application developer's codebases worldwide. A small change in GTK+ imposes hundreds of thousands of man-hours of maintenance work upon every application developer. And this burdensome work not only takes time, effort and money, it doesn't improve our applications one iota, and on top of that, it breaks backward compatibility so our code will not longer build with older GTK+ versions. Most of us won't be chasing the latest development release, applications might need to target a wide range of distributions with a wide range of GTK+ versions. So it's a logistical nightmare as well.
The lack of concern for the needs of actual application developers is why I eventually had to give up on it entirely. At some point it doesn't make any sense either commercially or for free software development, it's just masochism.
In the end I just stopped giving a damn and use either a modified microui or lvgl.
I'm not sure if GTK1 (the linked one) is backwards and/or binary compatible with Gtk 1.2 though.
Searching https://pkgs.org says that most distros don't have a gtk 1 package... except for Slackware!
small example have error (memory leak) in valgrind
GTK doesn't implement garbage collection, you need to clean up by destroying widgets and other resources that you have created. Of course, the operating system will free all resources used by your process when it ends, so that kind of final cleanup is often omitted (and even more so in example code).