Ask HN: What toolchains are people using for desktop app development in 2025?

Topping my list of GUI toolkit requirements are cross-platform and native look & feel. As far as I know, Qt still beats everything else in these areas on the desktop. It's mostly excellent.

However, I find The Qt Group's commercial licensing (and their tactics as reported by various people on HN) a little scary. If I were to go commercial, I think I would stick with LGPL Qt and link dynamically or give customers my object files for re-linking, because I get the impression that accepting a commercial Qt license could restrict my ability to use open-source Qt elsewhere. I suppose there might be some other way to safely navigate those waters, but from what I've read, The Qt Group has a reputation for making this far from hassle-free. It's not an immediate problem because I currently use Qt only for open-source and personal tools.

I have grown tired of C++, so I've been using Python to drive Qt. The bindings are very good, mirroring the C++ API so closely that I just use the C++ docs when I need to look something up.

I've also been watching for Qt bindings to other compiled languages, mainly for distributing non-Linux GUI apps more simply than Python allows. Such bindings often turn out to expose only Qt Quick, which lacks functionality that I sometimes need, but there are a few that expose Qt Widgets. For example, these Go bindings:

https://github.com/mappu/miqt

I hope we'll eventually see a cross-platform GUI toolkit rivaling Qt in a language more pleasant than C++ (and ideally easier to bind to other languages). The one being developed for internal use by the Zed editor has some promising ideas about how to render native-looking text, which I think is a good start:

https://zed.dev/blog/videogame

https://www.gpui.rs/

At work we use C#, .Net, and WPF. I've only used it at this company, and I can't say for sure if my dislikes are with WPF, or how our codebase is using it. Overall it's not terrible, except for being proprietary and Windows only.

Outside of work, I'm out in left field using Common Lisp for most of my projects, so I'm not sure how helfpul this is, but...

In the past, I used Qt4 because there was an amazing Common Lisp binding and it worked well on Linux, FreeBSD and OSX. It's increasingly hard to use Qt4 any more, though, and changes in the Qt project made the technique used by the Qt4 bindings impractical for Qt5 or Qt6 - at least that was my understanding when I looked into it.

For newer things I've tried LTK but don't really like the looks of it and I wouldn't say it's "modern". It seems to work across platform well enough, though, and for simple stuff it's okay.

More often than not I'm using a combination of the Slime tools in Emacs in combination with an GLFW/OpenGL window. Often I'll use the inspector to display data and make changes that show up in an OpenGL window, or run some commands in the REPL and pop up an image in an external viewer or load something in a browser. It only works for certain types of applications, and I won't even pretend it's practical for end users, but it works pretty well, and it's flexible as a developer.

I'm curious to see what other people say. It's been a while since I madea full blown GUI application.

Now that Chromium supports the File System Access API on desktop and mobile, I am building every software I need as HTML+JS+CSS.

Before that, handling files in the browser was cumbersome. You had to offer download and upload links for users to manage files. And handling whole directories was impossible.

But now web apps are like native software tools that you can use to edit and manage files on the file system.

And the bonus point is that what you build this way is fully functional on mobile too. Right away, without any changes. At least on Android.

Flutter is a super compelling framework (https://flutter.dev/multi-platform/desktop), but I’d live in fear of it randomly being sent to the Google graveyard.

Still plain old Swift (or when the itch strikes, Objective-C) and AppKit. I don’t really build for platforms other than macOS because I haven’t found toolkits that feel right elsewhere. I would do just about anything for multiplatform AppKit.

Qt with QML for a somewhat embedded use case. I think it hits a really nice intersection of native speed, GPU acceleration, interfacing with C++, and ease of development.

I wouldn't really recommend a career out of it.

On my projects [1][2], I use C# and Avalonia with Rider or Visual Studio. For extra performance, turn on AOT, which has the nice side-effect of making reversing your app to C# impossible.

I worked in WPF for a decade. I wouldn't go with it for a new project since it's Windows-only and doesn't support AOT.

At work we have a Blazor MAUI hybrid desktop app because it also has to run on the web. If we only needed a desktop app, I'd go with Avalonia.

[1] https://linklever.net/ [2] https://github.com/endurabyte/FitEdit

Within game development it's Dear ImGui. https://github.com/ocornut/imgui

Normally with the Windows DX12 backend, sometimes with the SDL+OpenGL backend if you want cross platform support.

Other frameworks are sort of disappearing. C++ all the way although some use it with C#.

As someone who loved Turbo Pascal, for the past 3 years I use Lua and LÖVE.

https://akkartik.name/freewheeling

Lazarus is the open source equivalent to Delphi these days, and for the most part it's awesome. (The documentation, on the other hand... just isn't fit for purpose)

I've been using Visual Studio Code and Github Copilot together, and it seems to work ok. I've not used it heavily, though, as I'm retired.

Tauri seems interesting. It combines a Rust core with the platform-native browser engine for presentation. Of course a potential downside is rendering incompatibilities between engines/platforms.

Avalonia - https://avaloniaui.net/

For Go, I've been using Wails [1] and Fyne [2]. The former uses a web view for the UI, the latter is Go only.

[1] https://github.com/wailsapp/wails

[2] https://github.com/fyne-io/fyne

To my dismay, my company uses JavaScript, HTML, CSS with a custom Chromium-based web browser installed on your PC. The performance is shit: GUI performance that should take milliseconds takes seconds to render with constant pinging of corporate servers and user activity logging. Development mostly done in IntelliJ or VS Code.

Slint-ui with rust (they have bindings for cpp, Python and js).

Quite good, I've been building this Pomodoro:

https://github.com/reciperium/temporis/

I've also used nix to build the packages when possible.

One of the things I like about slint is that it has native components. They also have experimental support for Android and iOS.

The language is quite simple as well. Though it could benefit from something like flex

I’m using JUCE C++ which is very popular for audio software. But it can be used for more general purpose applications. The latest version has some kind of HTML based UI system but I’ve not migrated yet.

I'm personally aware and used few Desktop app building frameworks like Flutter, Tauri, Electron. I think you might have some luck with Electron support for LLMs since its early development and resources available. But I personally like to use Tauri recently, its backend is Rust but you can plug it in with any JS, CSS framework and develop your application.

Windows Forms are alive and well.

Still supported in latest .net versions.

Rust + egui, but it's a far cry from the convenience or iteration speed of the web. Wherever possible, I build webapps instead, just because it's so much faster to get results (especially with LLMs!)

With that being said, I'd like to try the modern .NET stack sometime. Shame that the UI side of things is still largely Windows-only, and even Microsoft themselves don't know which UI framework they're using this week.

Delphi was so ahead of its time (a mandatory remark)... I've used Delphi 1 to 4 then moved on to other things. Using .NET since 1.0 beta, and it still remains my favorite stack. The project I am currently building is a software infra for building E2EE applications, and it requires a little bit of everything - mobile apps for key management, desktop/cli apps/client libraries for actually encrypting data, sometimes a web based app, and a zero trust backend. Using Xamarin/MAUI for mobile apps, Blazor WASM for Web, Blazor Hybrid / MAUI / Avalonia UI for Desktop. All of the frameworks have their quirks, so it may take a bit of time to learn your patterns, build your base classes, but after that you pretty much enjoy the productivity of a modern high level language.

- What programming languages and frameworks are popular for desktop apps? - for me - Blazor Hybrid / MAUI / Avalonia UI / WinForms

- Are there any go-to IDEs, build tools, or libraries that make development easier? - I use MSVS 2022, VSCode for .NET, IntelliJ for $$$ at work. There are of course UI control libraries, I am using MudBlazor for Blazor WASM / Hybrid, other than that I use built-in controls that come with each framework. I try to use as little as possible of 3rd party libraries b/c my apps are security-sensitive.

- Do the above answers change if you care about code performance or efficiency (whatever that means to you)? - in my case no, I am able to find what I need in .NET ecosystem. Modern .NET supports ahead-of-time compilation compiling to native code, and that helps to reduce start-up time which is important for Desktop / CLI. Ironically, for a long running processes, like a web service, the just-in-time compilation sometimes produces code running faster than ahead-of-time compilation, b/c it learns most common execution paths at runtime, and is able to recompile on the fly, optimizing for most frequent execution paths, giving a non-trivial performance boost in some cases

- Is native desktop app development still viable as a career, or are most greenfield projects shifting to web-based alternatives - depends on the app/use case. For my project, desktop is the first class citizen, but I am building E2EE apps, i.e. end-to-end-encryption apps, aka client-side encryption, and native / Desktop / CLI is a better fit for E2EE in most of the cases compared to web apps. For those Web apps that I have it is still E2EE but in the browser (still client side encryption)

C#, dotnet core and Avalonia. Its awesome

Python & Gtk (& sometimes Glade)

Because I mainly work with python, I am using Kivy (https://kivy.org/).

Earlier I was HTMX, Jinja templates, Flask, Tailwind and little vanilla JS. It was too inelegant for my taste.

I am considering moving to either Swift, or JS/Svelete

Flutter builds pretty decent desktop apps these days.

.NET and whatever gui framework is appropriate (WPF, Avalonia, WinForms).

Rust + Egui for special cases like DAW plugins.

For both iOS and Android app: - Xcode - SwiftUI - Supabase - Claude CLI - Skip.tools (converts SwiftUI to native Katlin code)

Been developing mobile apps for over 15 years. This is by far the best stack for developing mobile apps. Speed, total control, native UI's. Love it.

I support Java software using a Swing GUI. It's fairly performant, but requires a fair bit of boilerplate for setting up the GUI and can take longer than typical web development.

Rust for backend + Qt via cxx-qt bindings.

Would consider flutter for smaller apps as I had a great experience before.

For Windows only (because that's the most common platform in the world): C# and .Net. The UI is mostly either WPF or WindowsForms.

For Mac only: new apps use Swift, legacy ones use Objective-C, both with AppKit.

Linux only: these are quite rare and there is a broad mix of them: C++, Java, etc.

Cross-platform: C++ with Qt seems to be the standard. Go and Rust seem to be rising. Rising UI libraries are Tauri, Slint and Iced. There are other alternatives like cross-platform .Net, Java or Flutter. But they don't look very solid and widely adopted.

Then there are other UI frameworks for some specific use cases (games, scientific applications, etc).

I have been recently playing with Dioxus and I kinda like it. I too am dismayed that we are using browser to target desktop but here we are I guess.

C++ and Qt.

Rust as a statically linked library where it makes sense.

Zte the hack