With SWT, the upside is that you get native widgets that look and work like they're supposed to on the platform, but on the other hand, if the same widget can appear with different sizes, looks and behaviours it's difficult to customize it, align it nicely and ensure the whole design behaves coherently.
With Swing, the other terrible Java GUI library, you get the same look and feel everywhere, but that look and feel is wrong on every platform. As well as slow, ugly and (still!) full of bugs.
Here's a fun Swing bug I noticed yesterday in IntelliJ:
1) Put IntelliJ somewhere in the middle of the window stack, i.e. with some windows under it and some above it.
2) Switch to a different virtual desktop. (Tested in Xfce on Debian.)
3) Switch back to the desktop with IntelliJ on it.
You will find (or I did, at least) that IntelliJ has moved
a) to the bottom of the stack, if using Jetbrains' bundled JRE;
b) to the top of the stack, if using Debian's JRE.
Some Java developers like to claim that it's just everyone using it wrong, but Swing is stuffed with these focus-related bugs. I've seen them in every Swing application now and then, for decades. (It also likes to create windows at the wrong position only to move them to the right position, and draw things initially with slightly wrong layout and then redraw them with the right layout. You can observe this as well in IntelliJ when it starts up.)
Romain Guy's team recently released Filament, https://github.com/google/filament
Back in the Sun days, Romain had a blog about writing nice looking Java UIs, which eventually lead to the "Filthy Rich Clients" book publication.
Swing[1] (especially in it's default Metal look and feel) isn't the prettiest, but it is skinnable. It's used because it's platform independent (because its predecessor wasn't), and supports more than Windows, Mac, and Linux (think things like Solaris, HPUX, IRIX, etc).
[0] https://duckduckgo.com/?q=javafx&t=ffab&iar=images&iax=image...
* Switching to a different window with alt-tab will have moved keyboard focus to the menu bar when you switch back.
* Holding down the mouse button, pointing at menus to open them and releasing to activate an item – the way people did it in ancient times and which has been supported everywhere forever – does not work.
* To avoid submenus disappearing as you try to move the cursor towards them, GUI toolkits use either a small delay or something more clever to keep the submenu for a bit while you try to reach it. Except for Swing and JavaFX, which do neither, leading to a frustrating user experience. Interestingly, they have documented the correct behaviour in the JavaFX wiki[1], but it's apparently not implemented. (They had similar design documentation on the Swing wiki, which I can't find now, which was also never implemented.)
(The Swing menu bar is broken in many similar ways, but in case someone is wondering why it works in IntelliJ, they implemented[2] the expected behaviour themselves.)
[1] https://wiki.openjdk.java.net/display/OpenJFX/Menu+User+Expe...
[2] https://github.com/JetBrains/intellij-community/blob/master/...
I do know what you mean though. Even "fast" Java applications have this vaguely clunky feel to them. I think this is the overhead of starting the JVM, or possibly GC. You see something similar with CPython desktop applications.
Why don’t we see this in say, .NET GUI apps like Paint.net? C# has all the same baggage as a Java runtime, but somehow just works without tuning a crapload of GC settings.
Even Electron apps seem hugely more responsive and useful than anything I’ve touched built with Java GUI frameworks (and I’ve touched a lot over the last 20 years).
I think that’s just Stockholm syndrome from the Java dev crowd. They still insist it’s perfectly rational for a 5-concurrent-user web app server to require a 500 MB .war with 40K files and 8 GB of runtime heap.
But it is also the most popular, even among the free IDEs. Apparently the community's UI preferences are different from yours and mine?
In any case, while there does appear to be a small latency penalty, there really is no rule that a Java based GUI has to be ugly. I find both the IntelliJ and Netbeans IDEs to be pretty nice.
At the end of the day, writing editors that perform well is a hard problem. Writing an editor that performs well on small files is an easy problem. People often confuse making the easy problem easier with having solved a general problem.
https://joshondesign.com/c/writings
Don't use library components like JGoodies, http://www.jgoodies.com/
Also many just write everything on the UI thread, thus making the application unresponsive.
Swing can be used to make nice looking applications, even if they aren't exactly 1:1 to native ones, but that requires good UI/UX programming skills, and yes the defaults do make it a bit harder to achieve it.
Having said this, JavaFX is much easier to work with for doing graphical customization, as it is quite similar to QML and WPF in spirit.
Just try the demo. It's amazing.
https://jaxenter.com/20-javafx-real-world-applications-12365...
Some of those applications are modern, nice looking and fast.
They're hugely clunky. Also, Java based applets that used to run on browsers were awful.
I'd love to know if this is something to do with Java itself or the way these apps are developed. I understand they're not using OS's native GUI APIs.