Choosing the Right Cross-Platform Desktop GUI: Beyond Electron's Bloat

The quest for a cross-platform desktop GUI framework that is lightweight, uses native controls, supports accessibility, and offers long-term stability often leads to a few strong contenders and some emerging alternatives.

When seeking an alternative to Electron due to concerns about filesize and memory bloat, while still avoiding the pitfalls of C++ memory leaks or webviews with unpredictable OS updates, several frameworks come to the fore.

Established Solutions

Qt (C++ / Python): This framework is frequently cited as a robust choice. Using Qt with C++ offers the lightest footprint and best performance, making it suitable for larger, performance-critical projects. For quicker development or projects where C++ is less desirable, Python bindings like PySide6 or PyQt provide a productive alternative, though they introduce a slightly larger overhead compared to pure C++. Qt is known for its extensive feature set and ability to deliver truly cross-platform applications with a native look and feel.
Delphi: This option receives praise for its UI capabilities. While powerful, its ecosystem comes with caveats, including potentially tricky licensing for advanced features (outside the community edition) and a smaller talent pool for support and development.
JavaFX: Built on Java, JavaFX provides native bindings to the underlying platform. While it offers a comprehensive toolkit, be aware that applications built with JavaFX, especially when packaged as native images or fat JARs, might not achieve the smallest possible file sizes.

Emerging & Niche Alternatives

Kotlin with Compose Multiplatform: This modern framework from JetBrains is described as "shaping up" and presents a promising avenue for multiplatform development using Kotlin, leveraging a declarative UI paradigm.
Slint: Mentioned by one of its developers, Slint aims to tick all the boxes for stable, lightweight, and native-style UIs with accessibility support. Its impressiveness is noted, particularly when enabling its Skia rendering backend for optimized graphics.
Wails: Combining any frontend stack with Go, Wails offers minimal file sizes. While it still leverages web technologies for the UI, its integration with Go for the backend logic allows for a different balance of performance and development speed compared to Electron.
Tk (with ttk widgets) and WxWidgets: These older, more traditional toolkits are also options. Tk with its themed ttk widgets offers a lightweight solution, though its accessibility features might require closer inspection. WxWidgets provides native controls but can sometimes exhibit quirky behavior.

Beyond Traditional Cross-Platform

Native OS Widgets: For the absolute minimum in terms of executable size and maximum stability (working for decades), using the OS's native UI widgets (e.g., Win32 widgets with C/C++ on Windows) is an unparalleled approach. An executable can be incredibly small, often under 8 kilobytes. The trade-off, however, is a complete lack of cross-platform portability, as each OS requires its own specific implementation and widgets differ significantly across platforms. This perspective challenges the very notion of a "truly cross-platform GUI" in the purest sense.
Progressive Web Apps (PWAs): For some applications, sidestepping the desktop app entirely and simply deploying as a PWA in a browser is presented as a safe and fast alternative, leveraging existing browser infrastructure.

The Electron Argument

While the search often focuses on alternatives, it's worth acknowledging the counter-argument for Electron. Despite its reputation for bloat, it offers significant advantages for developer productivity, especially for companies that don't have a desktop app as their core product and lack resources for dedicated Windows, Mac, and Linux developers. Tools like VS Code demonstrate that powerful, widely used applications can be successfully built with Electron. The decision often boils down to a trade-off between absolute resource efficiency and development expediency.

Choosing the right framework depends heavily on project-specific priorities, balancing development speed, resource usage, native look and feel, and long-term maintainability. Each option presents a unique set of trade-offs that developers must weigh.