I think the mess we're in with GUIs is because we've failed to find a way to convey at a very high level what the inputs and outputs of software are. In a utopian world, you'd define what you want the user to see and how the user can interact with the information. Something would then work out how to lay that for you (in a way that makes sense to a human) and construct a GUI using native OS APIs.

Instead, we have only three options that I'm aware of:

* Use a framework that ignores the native APIs, throws away the OS design language and does all the rendering inside

* Build separate applications for each platform

* Use Electron and potentially reuse work you already did on the web version

When looking at it this way, it's easy to see why Electron is popular. Not that I'm a fan of it in any way.

I think what we need is a lot of really smart people to come together to reinvent the presentation layer.

So the solution for cross-platform apps is to use a non-native chroma which is the same for each OS. But that brings you to Qt or JavaFX or Electron.

However the solution to this problem needs:

  * To already be installed on every updated OS
  * Work, mostly, the same across every OS
  * Include the widgets we know from the last 20-30 years.

I'd be happy enough if, across all the major OS today, I could use a pipe or localhost socket to talk to the browser and use it to render a webpage within a basic OS window (ZERO other browser decoration or interactions, still OS decorated). If THAT alone worked on every operating system that would be enough of a basic step for 99% of the CRUD style apps out there. Small extra bonus if a message-passing interface worked between the two.

RAD Studio 11 just got released and allows native development for "all platforms" from a single codebase and GUI at the click of a button. [0]

I have ranted about and harshly criticised Embarcadero's misguided product policies as much as the next guy but that doesn't change the fact that Delphi is still the most mature and versatile Rapid (sic) Application Development environment out there, especially if UX and UI are important to you.

And the twenty-year old adage that you can knock out an MVP with a really nice and polished GUI in a Saturday afternoon is now even more true than ever.

In the end, a native binary with a small footprint (easily 1/100th the size of an Electron project) will fall out at the press of the F9 key and that's really something to behold...

The free Delphi community edition [1] might even offer all the features that you need, although I really wish Embarcadero would see the light already and sync its release cycle with the full version.

Delphi might not officially be regarded as hip or cool these days (mostly due to severely and ongoing errant product and community management by the company that makes it) but some great people and brilliant minds are associated with it and compared to the olden days Delphi is now somewhat of a secret underground Swiss army knife that ironically gets used now mainly in big and medium corporations.

I like to think its versatility combined with the fact that it's technically uncool and against the mainstream to do projects in Delphi these days might fit a hacker's (and HN user's) mindset very well...

[0] https://www.embarcadero.com

[1] https://www.embarcadero.com/products/delphi/starter?aldSet=e...

[1] https://www.lazarus-ide.org/

Lazarus is Free Software, which is awesome, and its feature set is also mature and impressive (I wouldn't have thought that the project also has a 20+ year history already).

I do recommend it highly if you can't get your hands on Delphi, don't want to support Embarcadero's antics, or work with an open-source project anyway. Several major component developers, including the great guys at TMS with their cloud pack and Raspberry Pi components [0] make a ton of awesome components that are available for both Delphi and Lazarus and I can highly recommend them.

If you're operating in the commercial space and have a budget, a bigger team, strong network, database or certain other commercial requirements, you might appreciate the support options and greater choice of 3rd party components which can be installed in Delphi with just a click and that save just so, so much time in getting your product to market.

If you're learning or teaching the language, working in a small team or alone, or require a feature set fully supported by Lazarus or just like free software, I wholeheartedly recommend Lazarus as a great alternative indeed. If you're somehow in the middle, check out the Delphi Community Edition too and just find out what suits you better. I guess it also comes down to what you're used to...

[0] https://www.tmssoftware.com/site/products.asp?t=lcl

Yeah no kidding. Last year I tried to download the trial of their paid C++ IDE. The licensing tool wouldn't work, and support never returned my emails. People complained in the official forum, no company response their either. I took that to mean "We see you as such a low-value potential customer, we won't lift a finger to get our own demo to work for you".

For a moment I was tempted to look into Delphi again, as I have spend many years in that environment. However, I see now its free until you hit USD 5.000 revenue per year. Not 0 USD, not USD 50.000, but only USD 5.000. Yes, that is the Embercadero that I knew. Probably this 'free' edition is canceled next year. Would not be the first time...

Edit: yes, still only runs on Windows

> Delphi Community Edition is a full featured IDE for building iOS, Android, Windows and macOS apps ...

But looking at the feature matrix for the full product it says:

> deploy to the platforms you need to support and with RAD Studio that includes Windows, macOS, iOS, Android and Linux!

> Build Linux client / server applications (includes FMX GUI for Linux) The RAD Studio Linux Compiler enables compiling applications to popular Linux platforms. FireMonkey GUI for Linux extends the FireMonkey UI framework to provide full Linux GUI support.

Only offered on Enterprise ($4K) / Architect ($6K) editions.

Qt [1]

The main codebase is C++, but bindings are available for Python and several other languages. I have developed and shipped multiple cross-platorm applications using Qt, using both C++ and Python. Documentation and source code examples are readily available.

JUCE [2]

Another C++ framework, with Python bindings. The focus is on music and audio apps, but a cross-platform GUI framework is also part of the library.

Blazor Desktop [3]

I have developed C# web applications using Blazor and WASM and moved them to the desktop easily. Using C# and the Dotnet ecosystem is really interesing and worth looking at.

Flutter for Desktop [4]

Still in beta, but has the support of Google, for better or worse.

JavaFX [5]

A Java cross-platform still under active development. I think it is pretty nice if you like Java.

Red [6]

Let's add an outsider just to keep things interesting!

This github site seems somewhat current about other Electron alternatives as well. [7]

Good luck! You will find there are lots of alternatives out there.

[1] https://www.qt.io/

[2] https://juce.com/

[3] https://visualstudiomagazine.com/articles/2021/02 /17/net-6-preview-1.aspx

[4] https://flutter.dev/desktop

[5] https://openjfx.io/

[6] https://www.red-lang.org/p/about.html

[7] https://github.com/sudhakar3697/electron-alternatives

Here's an example of what it could do on macOS four years ago: https://www.red-lang.org/2017/07/063-macos-gui-backend.html

Edit to add: You can build cross-platform GUI apps in Red now but, while they're very close to the finish line, and making progress every day, there are still a few missing pieces yet to complete on the 1.0 roadmap.

[1] https://mudblazor.com/

[2] https://mudblazor.com/components/table#api

If your funding or revenue is $50k and under, there is no cost, but there is a "Made with JUCE" splash screen.

If your funding or revenue is $500k and under, $800 one time fee and there is no splash screen.

You can pay $2600 once with no revenue or funding limit and no splash screen.

Free for education.

Cross platform done right (native code, no intepreter, no VM). Both IDE and generated code run native just about everywhere, from small ARM boards to virtual machines, and of course x86. As fast as C, decent sized executables, lots of built in or available libraries and components to do a lot of things, from managing databases to low level access to hardware, graphics, sound, etc. And of course it's 100% FOSS.

My last use case was a few years ago when a friend needed to monitor some security cameras, but they were of different brands and needed either their crappy Android/iOS app or a even more crappy XP-only ActiveX control on Internet Explorer, while he wanted to monitor them from a single screen on a Windows 7 PC. As soon as I discovered the right URL for each one to grab their video feed, I arranged a window container in Lazarus dropping there a bunch of media player components, each one linking to a camera, a few other controls and bingo, he could fire up the application and have the mutiple camera view on a monitor.

If it compiled more modern languages such as Nim, Rust or Crystal it would be perfect, but even by current standards Object Pascal it's still really powerful.

https://www.lazarus-ide.org/

https://wiki.lazarus.freepascal.org/Screenshots

https://wiki.freepascal.org/Projects_using_Free_Pascal

https://www.devstructor.com/index.php?page=tutorials

https://wiki.lazarus.freepascal.org/fpcupdeluxe

VLC can understand ONVIF RTSP and tile the video's into a mosaic

https://www.youtube.com/watch?v=qV-S4LMePVk

https://wiki.videolan.org/VLC_HowTo/Make_a_mosaic/

Id love to try lazarus one day all the same

They don't integrate Qt widgets or other frameworks properly.

[0] https://docs.nodegui.org/

[1] https://react.nodegui.org/

[2] https://vue.nodegui.org/

[3] https://svelte.nodegui.org/

I've probably written GUI apps in C, Java, Ruby, Objective-C, Swift, JavaScript, and probably a couple I forgot about. Dart+Flutter come the closest to being "good" and correct. There's some missing documentation for Desktop development with regards to Flutter + Dart but nothing is totally intractable if you're willing to read through issues. My only caveat is that Google is truly an awful company to depend on for your business; since, they 100% do not give a a single fuck about you unless you're paying them ~$100 million or more a year, or an EXTREMELY high profile client.

I've been getting ready to give Pascal a solid try but I still totally lose my mind when working in Lazarus (like where did the thing I just used go? Ah yes, tiny, free-floating window, of course). I have a feeling Pascal is probably the real diamond in the rough of UI application development these days.

Qt is probably fine but their licensing turns me off from ever using or considering it.

If I may ask why? They provide GPL and LGPL, and this last one is quite permissive.

See: https://www.qt.io/licensing/open-source-lgpl-obligations

> In case of dynamic linking, it is possible, but not mandatory, to keep application source code proprietary as long as it is “work that uses the library” – typically achieved via dynamic linking of the library. In case of static linking of the library, the application itself may no longer be “work that uses the library” and thus become subject to LGPL. It is recommended to either link dynamically, or provide the application source code to the user under LGPL.

But flutter looks like a good option.

1: https://sciter.com/

It's open source, the code has always felt reasonably clean to me, and it gives your apps native look and feel.

And it is ridiculously fast compared to alternatives.

I'd like to know what the "native experience" is supposed to be, but I have no idea which of the numerous Microsoft UI APIs is officially current. So far I've just punted and I'm using macOS shapes and sizing and using the colors from the Metro? style; at least it will look tasteful and not stand out too much color-wise.

That's the one. Everything else has never gained enough traction.

> Free and open source: https://www.lazarus-ide.org/index.php

> Other 30+ cross-platform GUI toolkits / frameworks: https://www.slant.co/topics/983/~best-cross-platform-gui-too...

Lazarus has the opposite problem of all the other UI toolkits - relatively awesome UI across all platforms (especially if you're a fan of WinForms) but stuck with only support for Pascal.

However, keep in mind that desktop apps have the major disadvantage of figuring out distribution (separately for each platform!!), which includes the following two steps: 1) packaging the application in some format (e.g. an MSI installer for Windows and a Disk Image Bundle for macOS), and 2) distributing that package (including auto-updates). I have written a number of articles about this topic, see https://www.augmentedmind.de/2021/05/30/distributing-windows... and https://www.augmentedmind.de/2021/06/13/distributing-macos-a... . You get rid of all that if you just built a PWA or other kind of web app.

In addition, if you use Python, you also need to choose a "freezing" solution, such as PyInstaller (more details at https://www.augmentedmind.de/2021/05/16/distribute-python-ap... ).

I really liked it. It was awesome to use something I'm familiar with (Next.js) and have it drive the UI. Resulting application was indeed about 1MB after all said and done.

The whole reason electron was created is because using a random unknown browser on the OS has random results.

The platform abstraction code is here: https://github.com/solvespace/solvespace/tree/master/src/pla...

There is no other platform specific code anywhere in the app, but like I said above we don't support widgets.

There is also an emscripten port in a branch, but it doesn't want to build recently.

What would you change it to? I've implemented a GUI toolkit from scratch a couple times, and text editing was the hardest part by far.

I have no idea. The biggest problem with it now is that it's not resizable. We could use pango or something to render text at different sizes but that'd be a new dependency.

Also forgot: we do use a platform specific text entry widget.

Also2: when I say "we" I mean the previous maintainer did all the cross platform code. Since then it just works.

There's a decent GUI markup editor (Scene Builder). There's no need to manually connect your handlers from XML markup to code - you can use annotations for that. There's HiDPI scaling that you can override if need be. There are Observable properties that you can bind to each other.

It's nice! Canvas and DrawingContext are a bit of a pain to use for my specific use-case, since it draws straight to buffer with no underlying Image, but I make do for now.

And you can take advantage of jlink to trim your JDK to modest sizes. There are also tools like Graal Native and Liberica Native Image Kit to compile your Java app down to binary, but I haven't toyed with those yet.

The cons are obvious: non-native look (you can try to style it with CSS, but there are no ready-made native looking solutions, I think, only different themes) and JVM startup time.

However, if you're willing to write C++, I'd argue Qt is the best choice right now. I just refuse to touch C/C++ with a ten-foot pole

[0] - https://docs.gluonhq.com/#_gluonfx_plugin_for_maven

There’s really 3 choices that I see, and have done all of them:

1) just build native UIs for each platform. This is the most time consuming, but the best end result in my opinion. The apps _feel_ the best on each platform

2) make a web app. Electron apps are still web apps.

3) hybrid approach, where part of your logic is shared across different native UIs, let’s say with a C++ / Rust / Java / Kotlin library. This is also a spectrum. Your library can just have common glue / networking code, all the way up to drawing its own graphics before turning a full screen over to the native UI framework.

I guess there’s also 4, which is Flutter, but that’s really just a pre-packaged #3.

If you ask me, web just has the best delivery model, and that trumps everything. Responsive web app plus a native option via Electron is the way to go.

You mentioned getting data to a GUI application using the web, this seemed like an ideal small project that could give you a firmer idea of just how Lazarus might fit your needs.

Notes:

I've never done anything like this (https/json) before but I suspect I'll be done in a day or two. Once it works, I'll then focus on getting it to also run in Ubuntu. I don't have a Macintosh, so that's out.

I've GPL 3.0 licensed it.

I'm not near the MVP yet, but it does manage to fetch the data and count the JSON objects in it for the main body of this thread.

With Debug info, the windows executable is 25 megabytes, without it 3.1 megabytes.

Here's the github link: https://github.com/mikewarot/WatchHN

Formatting, adding dates, etc... will be a bit more still.

Electron: Bloat, non-native, highly questionable language

Other cross-platform solutions: Obscure, (most often) non-native, undesirable language constraints, often far behind with regards to UI paradigms

Native UI for each platform with common code: requires deep knowledge of each platform, probably more time consuming than the other alternatives, the seam between common code and platform-specific code is often a source of errors

Fully separated native applications: Likely to produce the highest quality UIs, but requires the most diverse knowledge and time, more difficult to remain consistent across implementations, team size becomes an issue depending on how many platforms are supported

As much as I dislike Electron-applications, it's understandable why they became adopted so widely - the alternatives are just quite simply not great.

If the app has a whole lot of dense UI screens, or if you don't particularly care about it looking nice and feeling platform native, something like Qt or many of the other frameworks suggested here work well, but do be aware that you'll be making it harder to use platform features. For example, on MacOS you wouldn't support the TouchBar and would have some extra complexity to support Metal graphics vs GL (which Qt supports).

You can also do something similar to Electron but much more lightweight using a platform WebView. Then you can have common controls built in a htmlish way, and still have custom and native controls mixed in. One example of an app I worked on that was built this way and worked well was an app to browse/view 100s of video clips, we had a common html-based widget to filter and display search results and thumbnails (which had a bunch of interesting layout requirements) but the video playback itself was in a native panel (it needed to play custom formats so using web for everything wasn't appropriate).

Flutter looks promising but it still feels a little early. Try it out if you're willing to take some risks and maybe bend your thinking a bit. I found it too indirect and felt like I had to give up too much design responsibility to the toolkit when I last tried it but maybe that's an advantage.

If you're thinking about Electron, why not make it a purely web app? Then you'll save yourself lots of hassles distributing and downloading.

Also, for graphically intensive or in-house tools (like a game level editor) i use Dear ImGui, it's very fast to develop and great cross platform support, but I wouldn't ship it to a customer.

Unfortunately, "well-integrated" and "cross-platform" are fairly mutually exclusive, kind of by definition. I'm not sure if the API model for Windows and macOS even have a generalizeable common model. (They might, they might not, I've not investigated, and it would depend on which of the many MS UI APIs you are using)

To me it makes sense from tne perspective of the work being done in HTML, CSS & JS to make an Electron app. Why not start as a website then desktop?

I get there are certain pieces of functionality not suited for a website; but based on the original post’s question and description it seems feasible.

https://github.com/sudhakar3697/electron-alternatives

We have a suite of framework-specific developer apps for tasks like packaging deployments, managing common database tasks, onboarding new clients etc. They were written on Linux using Lazarus, then recompiled on MacOS and Windows as required. There are occasionally OS-specific variations for small pieces of these apps, but Object Pascal has inline compiler switches to make this easy to manage.

http://fyne.io/

https://tauri.studio/

Their roadmap include, in some years I suspect, probably 5, to also target WASM at which point, if Embarcadero is smart enough to lower their ridiculous license pricing to under $300, will become the most powerful tool to write cross-platform applications.

The .NET ecosystem is another solid choice for cross-platform desktop app development (and nowadays even mobile, too). Avalonia² in particular looks promising, and is probably what I'd try using first should I ever be tasked with developing a desktop app again.

EDIT: Also, since you mentioned it already for Linux, GTK works well enough on Windows and (IIRC) macOS, too.

----

¹: https://build-system.fman.io/

²: https://avaloniaui.net/

https://dotnet.microsoft.com/apps/xamarin

Here is an example of an audio workstation software done in a mix of Java and C++,

https://www.bitwig.com/overview/

What most UI/UX projects don't need is programmer art.

AWT (Abstract Windowing Toolkit) probably not recommended for new projects

Swing

JavaFX

SWT https://www.eclipse.org/swt/ Unlike the others that draw their own widgets and don't use the OS components SWT uses the native platform controls

Something that was mostly native for all of them.

Currently the only alternative to Electron that is similar is a program that hosts a local webserver and the local browser is pointed at it, but that's a second class experience.

Hello World (GUI) shouldn't be a 50MB deliverable. If I'm providing someone with a toaster I shouldn't have to ship a whole mobile home. Nor should that end user need to park 300 mobile homes on their hard disk.

There are other criticisms about wxW in specific linked from the wikipedia page... https://en.wikipedia.org/wiki/WxWidgets#Criticism

Dolphin's is illustrative of the pain involved in using that widget set. https://dolphin-emu.org/blog/2017/06/03/dolphin-progress-rep...

That said, QML and QtPython sound like a really great combo

As for Javascript, you can use Electron or React Native but I don't know how far along React Native on the desktop is compared to Electron.

Hope that helps and someone may come along that could speak in more depth on one or more of these packages for your use case.

It worked but the amount of effort is not worth it for most organisations.

https://sciter.com/

GTK feels right at home in the GNOME desktop environment (which I use, and like!) but for cross platform I don't really think it feels native at all. As a user, I've had much better native experiences with QT or WxWidgets to be honest (on Windows, at least).

That's not true since GTK3, where GTK started to look like GTK regardless of the platform.