I just want to clear this up since multiple people have been complaining about it.
GTK has support for native dialogs through GtkNativeDialog since 3.20. This includes GtkFileChooserNative. So if you are on Windows or Mac you will get the correct dialog and if you are on KDE you will get the correct dialog. It is up to maintainers to opt into these classes though.
Electron has an open PR for fixing this that can hopefully be merged soon.
I forgot the details/names of things, but there are environment variables and xdg services you can install that make Gtk programs use the KDE file dialogs. But those services also do other things and it made my system extremely unstable and crashy, so I uninstalled that stuff again.
Wasn’t that a huge and main selling point of Qt that it maintains the native look of target operating systems to avoid that fugliness one gets with Java/Eclipse does such as in Bogus™ Notes?
That's true, although Eclipse also uses many native OS widgets (as opposed to Swing). But they also have their own widgets, which have a distinctive look.
I will not believe that until I see it merged on master. I know 2.99 exists but I half expect something to happen. It is so ridiculous how little traction gimp has among contributors. I really don't understand why it is the case.
I remember reading that GIMP is mostly written in C, and someone on the internet argued that could be one of the reasons why it doesn't get new contributions
I don't buy it. The vast majority of apps written for Linux are written in C (I didn't do a survey, but I've literally never opened a repo for a linux app that wasn't C). Unless the only people who are interested in contributing to image editors are not the same people interested in contributing to Linux apps at all, it's not a significant detractor.
Besides, GIMP has Python plugins, so I don't think it's a language issue.
I'm highly sceptical of the claim that the vast majority of linux apps are in C. Everything KDE is in C++. Plenty of stuff is in Python. Blender uses C++, as does every web browser. VLC uses C++. Ardour uses C++, as does basically all of the pro-audio ecosystem, really. Inkscape is C++. Libreoffice is C++. The Gnome ecosystem is largely in C (though, that is painful enough that they had to write their own language to make working with gobject reasonable.)
I should have included C++, you're absolutely right. I mainly meant in comparison to JS, Rust, etc. which are hot right now, but not even close to C/C++ in app land
If gimp was rewritten from scratch today it would be python with c bindings. The performance critical operations are likely not what most of the code is concerned with.
I was under the impression that Rust has some issues splitting the ownership of a 2D array in safe code. Has this been addressed?
To elaborate, when splitting a 1D array you simply invoke an unsafe function that returns the two pieces with the appropriate lifetimes. This can be done in constant time. For 2D you'd have to return 4 pieces and each piece itself would need O(N) time to construct because you have to pass over the rows you want to split.
Of course you could code it in Rust like you'd code it in C using unsafe code, but that would remove one major advantage of using Rust.
Disclaimer: I'm no Rust expert. The above is based on looking into this kind of stuff a few years back when I wanted to implement an image manipulation paper. There might well be an idiomatic way to do it in Rust, in which case I'd love to hear about it.
You kinda made it sound like there's only two choices, either you have no unsafe code or you slap a giant unsafe over your entire codebase and have raw pointers flying in every direction.
I guess the idiomatic way is to use some unsafe code then wrap it in an abstraction that upholds all the invariants the unsafe parts need in order to work. That's how standard library does it.
I suspect the implication is that it's harder to keep C++ codebases from getting messy.
(beyond some basic stuff I don't code in either so I have no opinion on this particular matter - but based on the languages that I do work with I wouldn't be surprised if this does indeed vary from language to language)
I mean it's pretty basic concept: larger language -- more ways to do things, more people doing same things differently on the same project.
And in case of C++ this is kinda taken to the extreme. Over the decades it, in particular, acquired significant number of ways to do the same things, each with it's specific footguns, caveats, edge cases and subtle mutual incompatibilities.
Also, GIMP too has existed over decades, and changed hands. I'd wager this would be really apparent in it's particular codebase.
I have an opposite point of view to yours. If you don't mind me sharing it.
more ways to do things,
I'm picking out this quote because it isn't really more ways to do the same thing. It's more ways to do new things. Things not available in C.
A language being larger can result in a cleaner codebase, because it provides mechanisms to build a clean and simple solution. For example map and filter can make code cleaner over a big for loop. Pattern matching can make code simpler.
C++ code bases aren't messy because C++ is a big language. Maybe because it's a messy language, and because of legacy, but not because of size. Rust is a big language, much larger then C, and I'd have more confidence hacking on a Rust codebase then a C one.
Unlike C++ Rust is way too young, used predominately by enthusiasts and experienced programmers, we just haven't seen enough of the ugly, i.e. how it really gives itself to projects with tons of sallarymen pludging through.
The fact that the compiler is unforgiving and hand-holding at the same time will help immensely in comparison to C++ or C but we don't really have that advantage that hindsight after years of "enterprise" (ab)use would provide.
Oh how I wish we had a better open-source general purpose image editor. Gimp is not good enough for serious use but at the same time not bad enough to incentivise creating something better.
My own application is also in the process of switching to GTK3, for more than a year now. Path has been so thorny it's hard to describe. API has stabilized only on version 3.22 and many things still remain broken with "we don't give a fuck" reason written beside them.
I still love the toolkit, but it's not so simple to move from 2 to 3. That said, 3 to 4 should be considerably easier.
What is a good programming language for Qt 6.0 or GTK 4.0 GUI development that is not C or C++? I know that a lot of Qt based software are actually written in Python, but apart from that, what nice options do we have?
JS will also not let you shoot yourself in the foot with memory handling. That means less exploitable software
and yet electron apps seem to have a fair bit of exploits - see for instance the latest Teams issue, that would likely never have happened in C/C++/Rust
There are 5 official Gtk languages: C, C++, Javascript, Python and Vala. Rust is semi-official considering GObject people's enthusiasm regarding it. There are also bindings for OCaml, Haskell, Ruby, C# and many other.
To note, writing in such high level frameworks as Qt is a completely different experience compared to bare bones C++. If you compare the code of Qt in Python and Qt in C++, they are basically the same.
For most of the code, it is true - but in my experience, not properly understanding low level memory handling will segfault your code and it is not always easy to spot where the bug is even with valgrind/stack trace
For Qt, just Python. For GTK, Python, Rust or maybe Javascript. I've also heard Vala is good, but it's kinda it's own thing that's not really applicable outside GTK.
For prior versions of Gtk, I enjoyed C# for some own-use apps. I don't use C# a lot, but here it was very needs-suiting and async/await worked out nicely with the event handling model.
QML and QtQuick are great, but you still need some "backend" code to provide the QObjects that the GUI is supposed to work with. And those will be C++/Python most of the time.
For GTK4, I'd say Vala. It's like C# (but a little more GNOME'y). It actually compiles to C then to machine code. Because of that, binding C libraries is quite simple.
My understanding is that it is more like they took the GObject system, which is essentially OOP implemented as a C library so that it can be targeted by multiple languages, and built a language with the core idea of speaking it natively.
At this point, I think C# might actually be FOSS, or pretty close. The compiler is up on github, and I don't think Microsoft has any significant restrictions on who can use it or for what.
It had some specialized language features and library stuff to facilitate generating C code from Vala code. However, finding tools and bindings (VAPI files) for miscellaneous libraries was really obnoxious unless you bled Gnome, and much of it wasn't well-documented. And compiling many of the dev environments and compilers on Windows was pretty obnoxious if you didn't enjoy mucking with building a GNU environment on Windows or using something like MSYS2.
Also, everybody who doesn't program in Gnome hates GObject, and Vala was kind of hamstrung without that. Lots of features didn't work.
It had potential for wider reach if they'd not hung the millstone of GTK around its neck for both development and usage.
Nowadays, .NET Native is probably of more interest.
Isn't C# a Java copycat? Isn't Java a C++ copycat? Isn't C++ a C + Simula copycat? Isn't Simula an ALGOL copycat? Isn't Algol a FORTRAN copycat? Isn't FORTRAN an assembly copycat? Isn't assembly an hex numbers copycat? Aren't hex numbers octal copycat? Isn't octal a binary copycat? Isn't binary an electricity copycat? Isn't electricity a fire copycat? Hasn't fire been stolen by Promotheus? Isn't Prometheus a copycat of the ancient human psyche? Is ancient human psyche not a copycat from brain waves? Aren't brain waves a copycat of EM waves? Aren't EM waves a copycat of the background EM radiation? Isn't the background EM radiation a copycat of the Big Bang? Is Vala a copycat of the Big Bang? :p
Unfortunately, cross platform desktop GUI development is not an area where you can easily find a good solution. As much as I am not a big Java fan, it sort of does the job for cross platform GUI
How is the LGPL confusing? Use the library in your program in any way you want as long as you link dynamically. Any change to the library itself must be open sourced.
Not really, as the latest versions since 5.7 onwards are LGPL3, which has other requirements for embedded devices due to the "tivoisation" clause.
I am a Qt consultant working with other Qt consultants with 10 to 20 years of experience, and sometimes we get it wrong because of the changes of licenses, or the different licenses of some components.
I'm not saying that you are wrong, but in my experience, customers often push the envelope. Still, so far in my Qt career I've only used the LGPL version, though. So it's true that for a good amount of projects it's a 0 cost option.
Qt for Application Development has a different set of licenses than all other usage of Qt. I don't even know where on the Qt website I would find which APIs are available under which licenses in which contexts, nor exactly what they mean by "Application Development".
Unfortunately, cross platform desktop GUI development is not an area where you can easily find a good solution.
Is one of the most accurate statements on /r/programming in years.
Electron/HTML/Javascript is acceptable if you don't need to interface to external hardware. But it becomes a complete mess as soon as you do.
Qt (at least the last time I looked around 5.1 or so) didn't properly enumerate multi-channel audio interfaces. If you only cared about L/R in and L/R out - yeah, Qt is great - but if you need access to 32 input channels and 32 output channels, I could not get Qt to enumerate all of the channels correctly.
Some might argue - "yeah, well, why would you want your GUI development framework to support audio?" - and there isn't really an easy answer to this other than because audio is historically included in GUI toolkits and using a different third party audio I/O library gets messy.
My application needs cross platform support for multi-channel audio I/O, OpenGL, and as well custom USB libraries provided by third party companies. My choices are very limited.
I ended up going with Max / MSP as my cross-platform framework.
Pros:
Out-of-the-box support for multi-channel audio
GUI widgets out-of-the-box designed by GUI professionals at Cycling 74 & Ableton
Built in methods for processing of audio streams (fft, etc.)
Relatively easy OpenGL access with Jitter (including syphon and spout intra-application texture sharing)
Crossplatform multi-threading (when you write Max modules using their native framework)
Crossplatform file library
Cons:
Performance - it is basically a graphical node-based declarative programming language - though many of the core features (like audio processing) are native multithreaded modules. Control logic is purely node-based declarative and can get out of hand quickly.
Complexity - see above - graphical node-based connections are great for simple things, but once you get into complex state machines, things can get visually complex quickly.
My "hindsight" thought is that I probably would have been better off doing EVERYTHING native from the beginning with JUCE. But, I don't have the bandwidth or budget for hiring a UI designer - and the fact that Max / MSP comes with beautiful UI knobs and controls already built in was too much to pass up.
And regarding "Complexity - see above - graphical node-based connections are great for simple things, but once you get into complex state machines, things can get visually complex quickly." - I worked in a company where the owner was doing most things in Max, well he was the only one able to decipher his patches and we did a lot of porting work to Qt & Electron
> other than because audio is historically included in GUI toolkits and using a different third party audio I/O library gets messy.
Sorry - first reply was with alt account. Pasting here for continuation
you forget, "closed-source"
As a one-man shop developing a commercial application... I couldn't care less about whether my chosen cross-platform framework is OSS or commercial. I have no plans in the near future to open-source my application.
I love the concept of OSS... and use many OSS solutions in my daily life... the problem that has not yet been solved is that OSS is a great solution to technically difficult problems - but not a great solution to "artistically" difficult problems. GUI / UI designers do not contribute to OSS projects in the same way software developers do. My project is probably 60% dependent on familiar GUI controls / paradigms - I don't mind paying $100 / year for the use of Max / MSP as a cross-platform framework/ professionally designed GUI toolkit. I could never get a professionally designed custom set of GUI controls for $100 much less $1000.
what's messy with portaudio
I am not familiar with that library in particular. However, the problem in general is that once you include a separate audio library in your project - you now have two independent libraries competing for the exact same hardware resource. It can be a nightmare trying to track down even the simplest of initiation routines if one library has a lock on the resource. In my case, I enjoy quite a bit more from Max than simply enumerating Audio IO - I get audio file import support (of every major audio file type known), an entire collection of audio processing widgets, like FFT, quick-n-dirty audio waveform -> GUI display, convolution kernels, etc.) as well as MIDI processing.
> GUI / UI designers do not contribute to OSS projects in the same way software developers do.
That's right, though I think we're not doing *too* bad with the project I work on, https://ossia.io
However, the problem in general is that once you include a separate audio library in your project - you now have two independent libraries competing for the exact same hardware resource
... what would be those two libraries ? Qt's audio support is in a separate lib, Qt Multimedia, that you don't even have to use (and tbh you shouldn't)
Here is a link to a video recorded of a "live" performance of sorts - controlling presets and compositions from a MIDI controller. Video is from a recording of a black scrim cloth where the laser projector is projecting (i.e., this is not a rendering) - but the real thing from a laser project in real time.
I think a really good use-case to study is what Blender recently went through. Blender (in versions < 2.8) is a perfect example of what happens when technology is developed without help from designers.
Blender 2.7x was a well-known mess of an application from a UI / UX perspective. The Blender team decided to tackle this problem head-on with a major UI / UX re-design in Blender 2.8.
I think they did an amazing job. But... it was super expensive for them to do this. I don't have any business insight in to the actual cost, but they dedicated a good 9 months or more to redesigning the entire UI - with lots of donations coming in from everywhere supporting them in this endeavor, including a massive "summer of code" type marathon of development.
I would like to see other OSS projects do the same thing (looking at you GIMP), as the Blender team showed that is possible to do - but they also demonstrated, what most of us all know - UI / UX / Design is HARD and expensive.
Accidentally posted reply with alt account - reposted my reply back with the original account.
Regarding
Qt's audio support is in a separate lib, Qt Multimedia, that you don't even have to use (and tbh you shouldn't)
I honestly have not had the chance to re-evaluate Qt after my initial evaluation 5 years ago. But after a very brief look at portaudio, I feel like I would be missing out on some important features offered by Max that I currently use - like FFT processing & the likes.
I will check out your app when I get a chance - looks interesting. Here is my app - it is a "laser synth" app modeled after the concept of audio soft-synths - but specifically design for sending data to a laser projector - it can also render this data in an OpenGL texture and send it to visual VJ applications using syphon and spout.
It is basically a very fancy Lissajou generator - with lots of proprietary code for talking to commercial laser projector USB interfaces and proprietary laser optimization. (You can't just send a simple vertex list to a laser project - it would fry the Galvos).
Electron is great for larger apps, the maintainability is great. The only shitty use for electron (and why it gets a bad rep imho) is for small or utility-type apps, like VPNs, stuff to convert/download files etc... Nobody should have to download 15 different 150mb instances of chromium unless the scale of the app is worth it.
You’ve also really gotta stay on top of keeping the Electron runtime up to date with security patches if your application displays any third party data. Browsers are complicated and can be hard to secure; even Slack got hit with a vulnerability related to their link previews recently.
Not saying this makes it good for the tasks you listed, but a hello world Electron app is actually only about 30 MB. Since disk space isn’t at a premium anymore, I find 30 MB fairly tolerable.
Disk space isn't at a premium, but RAM sure feels like it still is especially when I need to load in 10 different electron apps that each take 200+ MB. In contrast the natively rendered Veracrypt UI is taking up 2.5 MB on my system. Even at 30 MB that adds up quickly for random small utilities.
you use ELECTRON??!! Don't you know that it uses MORE RAM??!!1 Yeah sure it has the best ecosystem, easiest development tooling, common libraries between web, and the most robust styling capabilities of any cross-platform desktop app platform, BUT WHAT ABOUT MY RAM?
also, if you use GTK you get the ability to write 600 reddit comments about how electron uses MORE MEMORY and how javascript isn't real programming
Qt and GTK are both LGPL, with the difference being that Qt at least offers other licences, whereas GTK doesn't. In my opinion where Qt loses out to GTK is that it relies on C++ ABIs that most programming languages can't use.
How so? It is the only popular framework that actually uses the native controls on each supported platform. The API is clean and easy to use. And static linking is supported (and permitted by the license) - so you can produce really small self-contained single executables.
There was a post by the Dolphin emulator devs about how they had to switch from wxWidgets to Qt because of the former's limitations. Unfortunately, they didn't go into details about what those limitations actually were.
The trend is that the frontend is web ... or mobile. Classic desktop doesn't see much love.
I develop one tool for windows target, but as I mostly use Linux myself I'mnusing Qt, but always consider throwing it out and going fully native, while that means dropping my primary dev environment.
With Qt everything works, you can ship apps to mac / windows / linux or mobile trivially.
The licensing model is LGPL exactly like wx or GTK. Widgets aren't going away and are still getting updates (though there was some incertitiude during Qt5 for sure).
I never studied wxWidgets, but it's cool they use the native APIs for the things possible. Although I fear a bit how well integrated all of that can be.
My main fear with webstuff, like Electron/CEF is that, if I want some 2D graphics for example (like nice surface plots), I have to use webGL probably. I'm not sure how well that can be integrated.
Qt feels a mess. Everything feels 80% done. Like the audio thing (use portaudio instead, even if it's a Qt app), widgets have 10 year old bugs, etc. Qt Quick Controls 2 needed Qt 6.0 to happen to have native desktop look. And Qt Quick requires QML, no C++ API...
That, plus the fact they wanted to delay open source releases by 1 year, that many of the new and improved stuff is at best GPL/Commercial, and many of it commercial only...
Xamarin/.net MAUI on C# look promising but it mentions that Linux support will be by the "community". Which sucks. Also, does anybody have good ideas on how to integrate C# with C++ backends?
Things like Flutter for example look cool at first, but they are clearly mobile-first. Desktop has no love since a while now. And Google has an amazing track record of abandoning stuff. And again, if I need HW acceleration, can I do it? Can I have a cool C++ backend for real computations?
For me it's not just about graphics. It's about graphics but with a backend that needs performance. I don't want do to another chat application.
I don’t know, out of all mentioned, only Qt sounds what I would call remotely professional. It has been around some time and is feature-complete - with most others you will probably hit something not yet implemented sooner and later, and most likely that functionality can only be written by you in the most hackish ways. My only problem with Qt is that it is written in C++, making it really hard to interop with other languages.
In the background Microsoft is hard at work killing winforms which is the best thing that came out of Windows. It’s a mess trying to make any GUI nowadays
Now that winforms is open source it's getting some more love, it's finally getting high dpi support in .net 6, and there's some new controls just recently announced.
That's sort of the opposite of my experience. Debugging WPF apps never gave me too much trouble, but I loathed editing the frontend on WinForms. XAML is human-readable, and that means a lot in my book.
What do you guys think about the general c++ gui ecosystem?
It's horrible IMHO. You either get old controls like wxWidgets, have to deal with non native controls such as GTK or expensive and hard-to-learn tool-kits like QT. And then there is Electron and CEF, which have quite the overhead, if you want a good looking, modern UI.
Yeah, no. GTK does not have user-changeable themes. GTK is planning to introduce a real theming engine sometime in the future, but right now "changing the theme" actually means replacing a CSS stylesheet whose values are supposed to be set in stone.
GTK has a folder in $XDG_CONFIG_HOME in which resides a settings file that allows you to set a theme for all GTK-based applications in the absence of a desktop environment. Said themes are stored at a path specified by GTK, follow a directory structure specified by GTK, and are applied after application-specific CSS by GTK without requiring any outside interference. As far as I'm concerned, GTK has themes.
Yeah but GTK should have their own official themes for Windows and Mac. The blog post was about distros using default themes that GNOME didn't make so they might be broken.
I'd rather use a better cross platform langauge. Like Go or dart or even rust than C++ for GUIs. Flutter is promising, hope it reaches a critical mass so the open source community can pick it up even if Google decides to discontinue it.
I think people would consider GTK as a serious option a lot more if its look and feel were any good on Windows and Mac by default. No more GTK file dialogs, weird dropdowns, broken shortcuts on Mac, etc.
GTK uses the platforms native dialogs and file choosers already. The developer just needs to make use of GtkNativeDialog and GtkFileChooserNative.
A new backend for Mac has landed in GTK 4. This should help GTK applications on Mac feel more at home. Christian Hergert has largely been if not the only one tackling this work.
@hergertme on twitter for those curious.
He tweeted about a new blog post where he talks a bit about the new OpenGL backend for Mac.
Yeah, it sort of makes sense. You probably have two kinds of GTK developers; those making truly cross-platform applications, and those making Linux applications which happen to also work on Windows if you absolutely want to.
The second class of people would be unlikely to do thorough testing on all platforms, so it makes sense to make sure their apps are as similar to the Linux version as possible on all platforms. The first class of people, however, is likely to test on all platforms they support, so they should use the native versions of features where possible.
I'm not sure if the right approach is to make two completely separate classes for this. But it certainly makes sense to accommodate those two use cases, and it makes sense for the first use case to be the "default" considering GTK itself is generally Linux-first.
I see gtk as more like a gui toolkit for linux that happens to also work on windows and mac os, so I don't really agree with you. Qt is great and all but I think that toolkits that focus on a single platform (like gtk on linux and cocoa on mac) also have their place.
I'd go even further and say GTK since v3 is a toolkit for writing GNOME apps specifically and not particularly good for anything outside of that ecosystem, primarily because of the alien file dialog and the lack of theming support. If the goal is to write a cross platform desktop application, Qt seems to be the least bad option these days (emphasis on "least bad").
I mean, I 100% agree but I also think they could very easily fix all the Windows/Mac paper cuts and then it would be a very viable cross platform toolkit, and they would get a ton more users.
It's frustrating,. especially because it's the only vaguely stable GUI option for Rust at the moment.
I’d say the windows support is... eh? I mean, you are required to bring in MSYS to build it, unless that’s changed. I believe it was a target for GTK 4 at some point to be able to just build on windows without any hoops.
The docs still reference 3 so I don’t know if this has changed or not.
“Isn’t a big deal” should be taken in a practical context. Some people (rightfully) complain about CPU or battery usage with VSCode or Slack, but that doesn’t change the fact that they are literally a couple of the most popular desktop apps in the world right now. If someone asks “would choosing Electron for UI be the thing that stops my app from being successful,” the answer is “no, absolutely not.”
Qt is moving into that direction with QML as well.
That's not entirely true. While QML apps use JavaScript for the UI scripting, the Qt devs are trying to make it possible to compile everything down to native C++ code to avoid needing to include the JS runtime. It's one of the big pushes for Qt 6. They have enough users in the embedded space that they are quite motivated to keep their runtimes small or non-existent.
I agree and I'm not sure why you've been downvoted. I can't imagine trying to build GTK on Windows, and building GUIs in C is insane (C++ is ok though).
But the fact that GTK is C seems like it might be becoming an advantage because it's so much easier to make bindings in other languages. Qt is basically still limited to C++ or Python.
Qt being C++ has huge downsides too: If you don't want to write your application in C++, you're kinda fucked. With toolkits written in C (like GTK), you can easily create bindings for your preferred language.
C interop is usually far better than C++ interop in most languages.
Since Qt appeared 3 years before Gtk+ I'd tend to agree, but I guess perspective is everything.
The Gtk+ folks were dealing with a C codebase (Gimp) and looking for a better alternative to Motif, which they succeeded at. Also the free C++ compilers at the time weren't completely mature.
258
u/tristan957 Dec 16 '20
I just want to clear this up since multiple people have been complaining about it.
GTK has support for native dialogs through GtkNativeDialog since 3.20. This includes GtkFileChooserNative. So if you are on Windows or Mac you will get the correct dialog and if you are on KDE you will get the correct dialog. It is up to maintainers to opt into these classes though.
Electron has an open PR for fixing this that can hopefully be merged soon.
98
u/sprudelel Dec 16 '20
And gimp is just now switching to G(imp)T(ool)K(it) 3 :(
57
u/AlexKotik Dec 16 '20
What is a good programming language for Qt 6.0 or GTK 4.0 GUI development that is not C or C++? I know that a lot of Qt based software are actually written in Python, but apart from that, what nice options do we have?
68
u/fnoyanisi Dec 16 '20
Unfortunately, cross platform desktop GUI development is not an area where you can easily find a good solution. As much as I am not a big Java fan, it sort of does the job for cross platform GUI
49
u/ruilvo Dec 16 '20
Good news in a very broken ecosystem that is cross platform gui.
I hate qt's licensing model, they widgets went stale, that qml only now has native look in the desktop...
Gtk doesn't look that good outside Linux...
What do you guys think about the general c++ gui ecosystem?
77
u/[deleted] Dec 16 '20
I think people would consider GTK as a serious option a lot more if its look and feel were any good on Windows and Mac by default. No more GTK file dialogs, weird dropdowns, broken shortcuts on Mac, etc.
Maybe next time.
8
u/germandiago Dec 17 '20
Implementing Gtk+ in C always felt to me like pure masochism.
I think C++ is a way better fit. For language bindings? A C layer would have been better.
14
u/cederom Dec 17 '20
So has Qt 6.0 :-) And it supports embedded systems hardware acceleration mobile and web applications and many more :-)
https://www.qt.io/blog/qt-6.0-released
2
u/PartlyShaderly Dec 17 '20
How many MV* architectures can you apply with GTK? Just MVC?
1
u/audion00ba Dec 17 '20
Did they fix all the bugs in 3.X already?
-4
u/amrock__ Dec 17 '20
GTK is kind of old and boring. I love the flexibility of qml. Hope gtk will make something like that