Windows native app development is a mess(domenic.me) |
Windows native app development is a mess(domenic.me) |
Having never written Windows apps, I am surprised to learn how disorganized and chaotic this all is.
1. Wow you have great knowledge of windows. Congratulations
2. Boy windows API is a mess.
If the system is simple and you don't give a shit about performance, it's very very easy to make C++ safe. Just use shared_ptr everywhere. Or, throw everything in a vector and don't destroy it until the end of the program. Whatever, who cares.
Meanwhile editions of Gnome come with Gnome Builder and Flatpak has solved the distribution problem. Things are so much better today on Linux than most people who have used Windows will even remember.
Well, if I remember correctly, the Godot editor is written in Godot.
CRUD apps are non-trivial.
If Unity were to ship platform native replacement for WPF equivalent (hell or even winforms) it would become a really enticing app development platform.
Aren't these pretty much the most trivial UI apps possible? E.g. compared to other native apps like Photoshop, Blender, Visual Studio or Office, CRUD is mostly just about banging together custom UI frontend for a database.
Unity's editor is implemented in its own (old) UI system, same with Godot, so in both engines it's possible to create 'traditional' non-game UI applications.
I mean, not like this brings Windows development anywhere close to "modern", if anything, it feels like you're moving into the opposite direction, but at least this solves the "The modern APIs don't provide the specific functionality I need" problem that plagues all of Microsoft's "nice", "modern" abstractions…
Unless, of course, you tend to whine about "complex licensing", i.e. people wanting to make money as you do.
I needed recently to make an exe that would work on anything from 32-bit Windows 95 up to and including Windows 11 (to accommodate some old machines on production lines), and the only language that made that easily achievable was FreePascal. I think it can also handle the older Windows NT if that is a requirement. There are lots of architectures supported with a single code base.
But for many the Pascal language is just to be laughed upon. Well, I make fast money using it and laugh from JavaScript.
https://www.grc.com/freepopular.htm
Just scroll down the page and look at the size of the completely self-contained executable programs. THIS is what Win32 is capable of. Something we always had with Win32 that was thrown away with .Net and C#.
And _please_ just spare me your opinions of how Steve Gibson "doesn't know anything about security". That's not what's important here. What's important is how freakin' small his full-on GUI stand-alone executables are.
EDIT: Just noticed this on his page.
Total Historical Count of files downloaded from this page: 52,292,601
And if you don't have to drag the runtime around, .NET binaries are even smaller than that, since the bytecode is more compact.
I originally had ATL in there, but my proofreading squad (Claude and ChatGPT) told me that ATL was a more niche thing for COM, and looking at the Wikipedia article I was convinced they were right.
But WTL was what I was thinking of---the step between the MFC and .NET that I forgot.
With all due respect (seriously): fuck off man
This is why you don’t use these stupid fucking tools for this
With Delphi creating of Native Windows Desktop Applications is a piece of cake (also does MacOS, iOS, Android and partially Linux). Yes it is by now obscure and expensive tool but I still use it to maintain my existing native GUI desktop applications. It is incredibly easy to use / develop with and single exe no dependencies deployment mode is superior. Compatibility between Windows versions is stellar as well.
There is also an opensource version of Delphi called Lazarus which is way less polished.
It might be nice if the article could add screenshots, a few of the Wikipedia links have a screenshot, but again I’m not sure if you’re limited to that UI or not.
I also like the carousel in the article showing the tray menus, but again not sure what they are each “built-with”.
Now, I'm not 100% sure, since there are so many commenters in this thread saying "just use Win32/MFC like a real man". (Most of them ignoring the memory safety angle.) I might do a follow-up asking Claude to reproduce my UI in the various frameworks to test. But my strong guess is that we just have a bunch of HackerNews curmudgeons who are happy to foist pixelated Vista-era light-mode-only UIs on their users.
[1]: https://github.com/dotnet/winforms/issues?q=is%3Aissue%20sta...
https://learn.microsoft.com/en-us/dotnet/desktop/winforms/wh...
"Dark mode Windows Forms has fully integrated dark mode support.
Windows Forms for .NET 9 introduced preliminary dark mode visual styling, but in an opt-in preview mode where you had to suppress Compiler Error WFO5001 to use the feature. This feature is no longer guarded behind this compiler error starting with .NET 10.
The Application.SetColorMode(SystemColorMode) API is no longer considered experimental."
I would say Java Swing is still the peak of GUI development. Works flawlessly at close to native speeds (GPU acceleration and all) on all platforms including Risc-V that did not exist when it was developed!
The JVM is the emulator!
You dont have to use MVVM or AXML for example Uno allows for C# Markup[3] to be used instead or MVUX instead of MVVM.
I personally hate MVVM and AXML but you are not forced to use them.
For Avalonia I dabbled in creating my own replacement[4] for MVVM and AXML using Flecs.Net.
In Avalonia I created a tray icon for the trash bin. So I can see how big it is and clear/open it with a small menu[5].
Both Avalonia and Uno should at least be looked at when judging which framework to use. They are both quite mature and have many great controls and features built in.
[1] https://avaloniaui.net/ [2] https://platform.uno/ [3] https://platform.uno/docs/articles/external/uno.extensions/d... [4] https://github.com/AyanamiKaine/Ayanami-sTower/blob/main/Ava... [5] https://github.com/AyanamiKaine/Ayanami-sTower/blob/main/App...
- Windows 11 Hardening utility - made it because all existing ones are not updated to handle all the new AI telemetry + new updates + I made it differently and more powerful than anything that exists currently
- Windows Admin/ Security / Networking Utility built for my needs
- Windows 11 Anti Virus Nuker - Completely shuts off windows defender without disrupting system performance or zombie files
- and more
I think they spent all their mana for that on pre-.NET Visual Basic and then had nothing left.
But imgui is a breeze of fresh air for internal stuff
Bit I still never bothered with the later approaches because it looked like I was going to lose out on speed and ease of development. WinForms may have looked ugly but you could bang things together pretty quickly.
And if you set a native theme for TTK in your code (literal two lines), your software will stop looking Motif-Industrial, the widgets will have the classic Win32 themes. It will look native from XP and up.
[1] https://en.wikipedia.org/wiki/Tcl_(programming_language)
No it doesn't? That's "the latest", but not "the greatest", and as "a Windows guy" you should know both the meme "wait until sp1" and the principle behind that about the inverse relationship between the two factors in that phrase
> what is the point of using Microsoft’s latest and greatest, if half your code is just interop goop to get at the old APIs?
Good point! Don't, wait until they realize their newest toy isn't popular enough, throw it away and create a new one - use that instead!
> One might think that an advantage of controlling C# would be that Microsoft has carefully shaped and coevolved it to be the perfect programming language for Windows APIs
No one using anything of theirs would ever think that!
I am developing Sciter[1] engine that works on all desktops: Windows, MacOS, Linux (3 distinct backends: pure X11, pure Wayland and GTK4).
Among all those, Windows API is still the most consistent and stable.
Whole of Windows functionality can still be accessed by plain C. For some things (COM) is better to use C++ but C works too.
Just in case: I am in this business for 20+ years.
[1] sciter.com
Haven't used Qt in a while, but at first glance, seems simpler: https://github.com/fltk/fltk/blob/master/examples/menubar-ad...
Nobody likes web technologies for desktop except lazy developers who know only that and try to make everything fit their world. WinUI3 is so buggy that not even their UI controls samples app can run for more than 5 minutes without crashing.
Pinvoke is reality on Windows and it is fine. COM is garbage but that's what we've got to maintain compatibility across 30 years. Windows is held by duct-tape and chewing gum and that is just reality
Most web programmers fall into that bucket for example. If you're the type to recoil at XMLHttpRequest, reaching to fetch or other even newer stuff. Then you'll balk at Win32 and be in a never ending pit of new Windows technology. I'd argue this is true of basically all new software. It's worth starting with whatever the oldest most compatible version of your target and ignoring the advertising and hype.
Developers being forced to use horrible Microsoft products is the logical consequence of that.
As a software engineer, most of my job exists to give credibility to the narrative that Microsoft is useful... And I don't even work for Microsoft. It's clear that there are deals behind the scenes which force many large companies into Microsoft contracts. The engineers have to work with what they get and pretend the tech is OK but behind the facade, it's clear from the jokes on the Microsoft Teams chats that they think differently!
I’m was thinking about building native windows UI, wrapping around cross platform library written in swift. I did not know it was that messy and complicated.
If you need low level access to the operating system and the hardware, you need Win32, so you need C/C++. And there's no way around it.
Expecting .NET apis to give you low level access in Windows is akin to expecting Go apis to give you low level access in macOS or using Haskell to interact with hardware on Linux.
I think programmers started wanting "real" languages (notice the quotes), and henceforth got more complexity and things take longer, although with GenAI, we may be back to the "draw as screen and do this" that we were with VB6. Just now the source generated should be considered the object code, and the prompt is the new source (at least for those types of apps)
If you mean native code then VB6 doesn't belong in this category (even if you compiled it to a standalone .exe it was still effectively bytecode).
> It was abandoned too soon.
This is probably a recurring theme for MS UI frameworks.
...but they were correct. The GP just didn't remember the proper name and asked about a different thing.
A Unity expert can correct me, but IIRC (possibly wrongly) at least the following limitations apply:
For example Unity does not have accessibility features (screen readers etc) nor I don’t think it’s DPI aware. I would _guess_ it does not support platform fonts. Not sure if it supports non-latin font layouts like arabic. Etc etc.
Classical Win32 C API surface, with some exceptions, is mostly stuck in Windows XP view of the world.
> Turning them off will cause Windows to spasm for several seconds and throw all your current window positioning out of whack.
Speaking as a long-time Win32 programmer, the requirements for your app are doable in a few KB (yes, kilobytes --- my vague estimate is less than 8KB) standalone executable. This is how I arrived at that:
Enumerating the machine’s displays and their bounds
A few API calls. Probably a few hundred bytes.
Placing borderless, titlebar-less, non-activating black windows
Creating non-functional windows is trivial. Another few hundred bytes at most.
Intercepting a global keyboard shortcut
A few dozen bytes to call SetWindowsHookEx.
Optionally running at startup
Write to the appropriate registry key. A few hundred bytes.
Storing some persistent settings
Ditto. Another few hundred bytes. You can use a .ini file too, for around the same size.
Displaying a tray icon with a few menu items
Most of this size of this will be the icon itself - a few kilobytes; the next biggest contributor will be text strings; and the rest is accomplished with a few hundred bytes of API calls.
Add another few hundred bytes of (not much) logic, round up to a kilobyte and add maybe another for general overhead.
But, in 2026, writing a greenfield application in a memory-unsafe language like C++ is a crime.
Don't be swayed by the propaganda. Especially if your application has essentially no untrusted input.
MacOS is slightly better but Apple's anti-competitive practices targeting developers makes it a tough sell. Linux is better still, technically, but due to the fragmented desktop environment landscape and distribution difficulties, it's also a hard sell.
I think it's fair to say that the entire story for native app development is a mess - which is most likely why Electron became so popular. There just isn't a practical sane alternative.
When I look at the apps on Windows, all I see are abandoned projects and MVPs with a borderline malware financial structure.
With electron this is much easier because nothing is native and it looks and feels just like the website.
Of course, if one is a web developer, even attempting such a feat this could result in a brain-melting experience.
MacOS is not quite so simple: https://news.ycombinator.com/item?id=40085237
> Don't be swayed by the propaganda. Especially if your application has essentially no untrusted input.
Even without untrusted inputs, in 2026 one should think twice before selecting C++ for a new project. There are still some reasons to do so, of course, but Win32 isn't one of them -- one can use it from a memory safe language just fine, e.g. https://github.com/microsoft/windows-rs
Using win32 from Rust is nonsensical. This is the kind of use-one-tool-for-any-job Visual Basic 6 programmers used to have, except VB6 would have actually been much better than Rust at Windows programming.
https://crates.io/crates/windows-sys
https://crates.io/crates/windows
Both seem to do the actual work in unsafe blocks, so I guess you could as well use C++, no? (only have limited Rust knowledge)
Yes, you may be harmed by proper IDE and debugging experience via Visual Studio.
https://github.com/microsoft/windows-app-rs#this-repository-...
I'd say it's confusing but I wouldn't expect any different from Microsoft.
IIRC Borland Delphi was the most popular tool back then for making Win32 apps since it was so easy to use.
Unironically the answer is yes. I've been watching this for at least 15 years.
I think one inflection point is when everybody who was coming up became accustomed to GC languages. Within a decade of that trend starting, nobody could reason about memory anymore.
With the AI boom we're going through another inflection point. When coding is synonymous with using an LLM, nobody will be aware of how anything works (or doesn't)
The average programmer back then was probably far more knowledgeable of the low-level details.
It was a matter of having access to the right (although limited) resources such as Petzold’s book, Codeproject and experimentation. There was no big rush, no start-up hustler mentality and most importantly hardware resources mattered a lot and it was a point of pride to create efficient software.
The development culture of present time is the opposite of that: developers are drowning in documentation, the default solution is technically inferior and the hustler mentality’s dominating.
The main function of the app being discussed here is to draw solid black rectangles on the screen.
Don't forget the "average person", I'm assuming someone relying on software as a tool, doesn't care about the stuff "designers" seem to obsess over, and will actively hate if you break their workflow by doing things like adding useless padding that makes them scroll more or shows less information in the name of "modernity". There's a lot of specialized niche software for various industries, often very expensive too, which looks like it came out in the early 90s. As long as it works well, users won't complain.
Several integration points like this have been removed, supposedly because third party software was just too bad in how they used them, causing issues. Or at least so goes Microsoft's perspective. Personally, I find that very believable! If by integration points the only thing one can imagine is calling into random third party code on the regular that the user has installed, bang spank in the middle of critical user flows, on the same thread and in the same process as itself, that's exactly the kind of grief I'd expect to occur...
If only there was a way to provide a way to craft e.g. custom flyout menus for the taskbar or custom pages in the Settings app, without invoking arbitrary third party code and possibly causing crashes and hangs in system apps and menus... or just not letting crashes and hangs affect the application (e.g. Windows Explorer) calling them in the first place.
Here's the source code for those who are interested: https://github.com/sergeax/stamputty
The hard parts were seeded by Claude Code. Happily maintaining and modifying it for close to 3 months now. Just a data point, especially about not needing C++.
> Don't be swayed by the propaganda. Especially if your application has essentially no untrusted input.*
Eh. I spent many years writing cloud/backend software on the JVM, in between stints writing desktop software. When I was first writing desktop software, it was all in C and C++, and I got used to it, but it wasn't pleasant.
When I came back to writing desktop software in C again (just a few years ago), after writing in memory-safe languages for so long (Java, Scala, Rust, Go), I found going back to C to be just so tedious and annoying. It's just incredibly unpleasant to be chasing down segfaults and data races and crap.
So I think saying it's a "crime" is hyperbole, but even for apps that don't have untrusted input, it's still much more pleasant writing in a language that doesn't let you write memory safety bugs.
(Absolutely agree with you on how it's possible to make nice, small, non-trivial Win32 apps, though I haven't done Windows app development in a couple decades. But I think a lot of people would save themselves a lot of time and headaches if they reached for .NET or something higher level.)
Recently had to add a new feature to and old program that was last updated in the XP era and two things to note:
1. The program did not need to be updated to run on Vista, 7, 10 and 11, shit just kept working throughout the years.
2. I loaded the project into Visual Studio 2022, it converted from VC6 and compiled without problems, added the feature, shipped a new .exe to the customer, and it just worked.
What other platform has that backwards and forwards compatibility success story?
Exception being the few APIs that have been introduced in Win32 that instead of COM, actually depend on WinRT like the new MIDI 2.0 or Windows ML.
Keep using Win32, MFC (yes it is in a better state than WinUI 3.0 with C++), WinForms, WPF, if using Microsoft only tooling.
Otherwise, Qt, VCL, Firemonkey, Avalonia, Uno, ImGUI,....
They were even forced to revamp WPF status at BUILD 2024, given how bad WinUI 3.0 was back then, and it isn't if it got any better, apparently it is in the process of being open sourced, to see if the community can take over the mess a $4 trillion valued company cannot fix.
Really, stay away from WinUI, unless you're a Microsoft employee on the Windows team without any other option.
[0] - Can explain by the nth time the differences, if one feels like it.
The lessons I've learnt building and shipping a few a Windows apps at scale are basically:
(1) Learn Win32 and use those ancient APIs if possible, they're extraordinarily stable and you'll probably need to reach for them anyway. They're not that scary.
(2) Don't use any Microsoft-owned UI toolkit, you'll get burnt. Literally anything is better. Ideally choose a toolkit that doesn't prevent layering in Win32 tweaks on top, otherwise you'll end up hitting cases the toolkit developers didn't think of and you can't fix. You're going to need a custom WindowProc eventually. You need to have access to the underlying Win32 window lifecycle and handles.
Clearly this is not an option for those who are just starting up with Windows GUI work, but with little experience it is really a matter of 2-3 weeks of ground work and then you have full control over all nuances of the UI, yours to extend and mend as you wish.
If there's one thing that Microsoft is really good at, it's ensuring deep backward compatibility. So anything that's based on Win32 API is going to be stable. If it works now, it will work later.
I have some examples from 10+ years of development updates accumulated here - https://bvckup2.com/wip
Well yes as a user I prefer native apps for their performance. It's clearly a mess to develop native apps as the article shows. But as a user I don't see that problem. I do see ever worsening apps though. Like the total mess that is new outlook and teams.
Web apps cause have lots of trouble emulating proper native look and feel and often have wierd issues with things like consistent focus and keystroke navigation. They have all the dumb issues of Java apps with no improvements beyond not being Java and are slower and more memory heavy to boot!
I disagree, the GUI layer is far from behind a safety critical component, and C++ is a battle-tested choice for everything from GUI, videos games, to industrial applications. If C++ is safe enough to control airplanes and nuclear reactors when used well, it is certainly safe enough for something as trivial a GUI.
The article also fails to mention frameworks like Qt, arguably the best way to write GUI apps in 2026. Qt is native (C++), has built-in memory safety features (but no GC), and is cross-platform.
Sure, embedded systems are a different anmial...
> Native means system libraries only.
Every non-trivial application will eventually use third-party non-system libraries.
I think "Native app development" has at least two meanings:
1. narrow meaning: the program uses a native UI toolkit (Win32, Cocoa)
2. broad meaning: the program targets one or more specific platforms and the UI is not not just a webview
Even with the narrow meaning, WxWidgets would qualify as "native development" (because it uses native UI toolkits under the hood), yet it is still a third-party library.
Since when? To me, anything not webview-based is native, though you have varying degrees of integration into the platform.
It's another example of how they have completely abandoned any attempt at providing a good user experience across their products
I first investigated the Windows native options and was pretty bamboozled; I wanted to use the "mainstream" "up to date" option (presumably c# and some framework) but as TFA describes, it wasn't at all clear which that was.
I ended up doing it in python with pyqt then finding out a clean deployment was a pain, so revisited the .Net options and remembered why I'd discarded them in the first place...
It is indeed a complete mess (at least coming in anew) and a very strange situation for the world's main desktop environment to be in.
But after I had the msi and dmg files, my non-techy colleagues couldn't install the apps because they weren't signed. The workaround for Mac was fine (remove the quarantine attribute on the installer) but for Windows my colleague had to disable Smart App Control (SAC), which cannot be re-enabled without re-installing Windows.
I get the point of these protections, but the difficulty of getting past them surprised me. I thought that on Mac you should just go to settings -> security and click 'Allow Anyway'. And that on Windows you'd get a GUI warning that would need admin privileges to get past. But MacOS needed a terminal command, and Windows needed a control panel setting change.
I'm glad people still care about stuff like this. It drives me insane that the simplest form-based software that I build and compile ends up being 50-100 MiB; several times video games from the 80s that I grew up with that did much more complex work, graphically and computationally, on a tenth of the space.
Also, I think C# is miles better than TypeScript, but that's just my preference.
.NET has new releases every year, supported for 2 or 3 years. That’s not really compatible with Windows release cycles. Also, if Windows 11 25H2 shipped .NET 8, and now Windows 11 26H2 would ship .NET 10, apps which depend on version 8 might break. Easier to just think of .NET as a runtime like Java or Python.
---
Regarding tray icons, 1Password, Signal, and Discord are all Electron apps, so they are using Chrome’s UI toolkit, and its menu component.
Myself, I’m happy with WPF. Starting with .NET 9, it comes with a really good WinUI-style theme.
Ideally they would just install newer .Net releases side by side and uninstall .Net releases as they drop out of support.
Automatically uninstalling .NET runtimes would break apps, and Microsoft will be to blame, not app vendors who failed to upgrade to the latest .NET. An app built for .NET 8 can run on .NET 10, assuming no backwards-incompatible changes in the runtime and system libraries, but this behavior is opt-in.
.Net 4.81 is the last one before .Net Framework was unified with .Net Core. It's very legacy by now, but there would be many enterprise/business apps that still require it.
[1] https://dotnet.microsoft.com/en-us/platform/support/policy/d...
My first thought was MFC. Basic, fast, well understood.
But then maybe WxWindows so we can cross-compile it (from Linux) and use the same UI on other platforms? It could probably be compiled statically although I've not tested it.
Or Mono, but that needs a runtime?
Edit: Some comments mention Qt which could also work although how large is the runtime? Can it be compiled statically?
The last time I had to do Windows development was about 15 years ago. I used a library called WTL (I think a couple comments here mention it). I couldn’t use any of the newer stuff that Windows 8-10 were pushing because it needed backward compatibility. It seemed way less bloated than MFC, but not as annoying to use as ATL or rawdogging Win32 APIs.
Ironically, I was developing a Win32 app to build a cloud bridge to a Rails app (talking to Quickbooks COM API which was hell on Earth, with XML and XML definitions) on Mac, using VMware on Mac to talk to Quickbooks Windows. I was so annoyed with Win32 development I used the Chrome Embedded Framework library to build the UI for the Win32 app so I wouldn’t have to wrestle WTL for UI and just have browser-based views to drive UI.
I think it was very tempting to drop C/C++ development for .NET code, but I didn’t want to drop off user adoption by requesting users to download a huge .NET runtime if their computer didn’t already have it.
This was when I was building Levion, a Quickbooks Windows to Cloud Rails app…
And if you think using it will let you port your app to other platforms, think again. There's no drop-in compatible equivalent of RNW for Linux, and the version for Mac is even worse than the Windows version.
t. works on a huge app written with React Native Desktop
Just do exactly what Apple does. Charge me $100 directly from you and let me build an .exe that I can distribute on my website.
Microsoft offers a service called Azure Artifact Signing (used to be called Trusted Signing) that manages code signing for you:
https://azure.microsoft.com/en-us/pricing/details/artifact-s...
It's $9.99/mo, and you don't need to worry about procuring or renewing code signing certs.
Hobby projects should not be built on a platform that is constantly changing underneath.
And the gap's going to keep growing - doing the upgrade now means future upgrades can be more frequent and incremental, rather than trying to move 4.8 to .NET 20 in a decade.
Basically the kind of customers that were affected by the breaking changes, between Framework and Core, decided to keep the old stuff running in Framework, and consider other alternatives going forward.
Not sure how much these kind of customers matter to the .NET team's upper management in customer acquisition, but they surely lost a few along the way.
And now there is even CoPilot based migration tooling on VS 2026, because most likely there aren't that few that are still chugging along with Framework.
.NET framework used to get new versions as well; it's just that it's not anymore. After moving on to newer versions, .NET framework feels clunky now. Also you end up missing out on a decade of new libraries.
To be fair it's been super simple to upgrade .NET versions the last few versions especially.
Such is the benefit and the curse, I guess, of having the Windows API being locked in the distant past for backwards compatibility.
I've always been surprised that Microsoft didn't do a full operating system refactor and provide a compatibility layer for running old binaries. Perhaps they figure it would be better to just transition everything to software as a service using web tech? But I just don't see how that strategy is gonna work long-term.
Just keeping a legacy system in working order is different skillset than writing a new system from scratch.
So you need a new team. Nothing from Windows maintenance transfers.
Maybe would require hiring someone who knows how to design an OS.
It would be a major undertaking, needing protection by CEO (and if it would not succeed CEO would loose a lot of prestige).
I'm not saying MS does not have the existing talent base. I don't _know_.
But I've been inside a house maintaining a monstrous legacy codebase.
I can tell you - it requires surprisingly little deep understanding just to keep an existing system going.
Running with html/css/js has benefits it really is open and free development based on international standards and not locked into any single big tech.
Open? You wish.
>and not locked into any single big tech.
DRM and propietary cody tells me otherwise.
In some ways, Microsoft is similar to that.
Apple on the other hand is fast paced so API can suddenly be deprecated and slashed and with Swift they’ve also made a language that is being changed from time to time in a breaking way.
While Microsoft’s approach similar to C++ it is a private company with no committee. This allows fast pace for ideas needed by a company in a competitive market. But, with ensuring backward compatibility, it makes each not throughly thought design -stick.
I guess Win32 is an exception since the first GUI concepts, our desktop designs hasn't changed that much. Window, Menu, Toolbar. Back then, The competition and pace was less intense allowing more time to think. There were other constraints of course being applied by the hardware and stack available back then requiring more abstract designs.
In that sense, it’s quite interesting to see Win32 is kept while Apple’s switch to NS/OSX made everyone eventually transition into Cocoa.
But that would not make me pick C++ over Rust. Other requirements may.
Pure C is not the native way to do application programming on macOS. As I mentioned elsewhere, you can bring up a window with a button with no code on macOS. You can make that button show a string on a label with a handful lines of code.
Anyway, Microsoft is the one providing the Rust crate(s) I linked, and according to the releases it seems they are using them internally too. I do not see what is "nonsensical" about using them, and I have used them in the past just fine, just like I used Win32 from C++ in the past.
AI has accelerated this because it's becoming harder to detect the frauds.
From Android to whatever web framework they’re peddling as development solutions, these are not designed for efficiency, but for time-to-market and consumption by front-end developers.
There is a certain amount of truth to that I think
I do not think anybody was “smarter”. There were smart and less smart people then and now.
But the “typical” practice changes. And that changes what you get. I think your “typical” programmer is more productive today in terms of what they can accomplish. But that work is going to be built at a higher level of abstraction and likely a lower level of run-time efficiency. As a percentage, fewer people understand or take into account the lower level details.
It is not just about new tech. After all, I can write all my code in RISC-V assembler. And I can manually allocate memory and manipulate pointers in C#. It is just not what people normally do these days.
The first thing you want to ensure is that you avoid unsafe in YOUR code. That is, after all, where you are going to create your bugs.
Ideally, there is no unsafe code in the crates you use. If there is, at least there are more eyes on that code to catch problems. You can inspect and debug that code, and others can do it for you. Others may battle test it and stress it far more than you will.
And at least the unsafe code is isolated to a few areas in the supporting libraries. Less to inspect. Less to debug. Fewer places to introduce memory related regressions.
It does not at all follow that, given an unsafe block, we may just have well used C++.
The unsafe code is written inside the library, which the user can contain in a safe API. With C++, the entire codebase is unsafe.
If you want something more custom, subclass NSControl and you’re off to the races.
And if Obj-C isn’t your cup of tea, one can use Swift instead, even in a codebase that had been only Obj-C prior.
If you were doing "classic" Cocoa in the way it was intended, you wouldn't need to subclass anything for a simple button.
You wouldn't even need to write a single line of code, you'd just instantiate said button in Interface Builder, hook it up to a delegate (e.g. a window controller) and off you go. You can create a hello world example with a handful lines of code.
And even if you'd rather create the button programmatically, it's not much more involved.
Sure, if you're coming from Win32 and expect to program Cocoa without learning Cocoa, you're out of luck. But I guess that applies to all frameworks.
Button(“Click Me”) { buttonWasClicked() }https://learn.microsoft.com/en-us/security-updates/securityb...
I mentioned in another reply the 12 different ways that you had to define a string depending on which API you had to call.
Can you imagine all of the vulnerabilities in Windows caused by the layers and layers of sediment built up over 30 years?
It would be as if the modern ARM Macs had emulators for 68K, PPC, 32-bit x86 apps and 64K x86 apps (which they do) and had 64 bit Carbon libraries (just to keep Adobe happy)
Once I became experienced enough to have opinions about things like my editor and terminal emulator... suddenly the Visual Studio environment wasn't nearly as appealing. The Unix philosophy of things being just text than you can just edit in the editor you're already using made much more sense to me than digging through nested submenus to change configuration.
I certainly respect the unmatched Win32 backwards/forwards compatibility story. But as a developer in my younger years, particularly pre-WSL, I could get more modern tools that were less coupled to my OS or language choice, more money, and company culture that was more relevant to my in my 20s jumping into Ruby/Rails development than the Windows development ecosystem despite the things it does really well.
Or to say differently: it wasn't the stability of the API that made Windows development seem boring. It was the kind of companies that did it, the rest of the surrounding ecosystem of tools they did it with, and the way they paid for doing it. (But even when I was actually writing code full time some corners of the JS ecosystem seemed to lean too hard into the wild west mentality. Still do, I suspect, just now its Typescript in support of AI).
The biggest problems were DAO (database) and a few COM controls that were not available in x64.
But then Large Address Aware (4GB limit) changes everything, and you can't do that anymore. In order for a program to be Large Address Aware, you need to not try to do things like check high bits of pointers, then every single library and DLL you use also needs to do the same.
Add high DPI to the mix and things get rough very quickly. Also the common control have weird input issues (try ctrl+backspace in an Edit control). All those little things need to be fixed carefully for something to be ok in 2026.
lol at them still bekng the best option. so much wasted effort trying to replace them
(tongue in cheek)
MFC has CWinApp, which you'd normally subclass, and a stock WinMain implementation that instantiates that, but it's not strictly necessary to subclass it, just convenient.
WinMain should create an instance of the app class and call Run.
"You're posting too fast." I never got that before. How fast is too fast? I tried to post this comment hours ago, but I couldn't. I guess I've been restricted because of this comment https://news.ycombinator.com/item?id=47473604 which feels pretty unfair
Fruityloops, now FL Studio, was written in Delphi and to my knowledge still is[1]. When ot launched there were no options but Win32 for Delphi.
That's just one example. Win32 makes it reasonably easy to skin things, and back in the 2000s a lit of programs did.
[1]: https://blogs.embarcadero.com/fl-studio-is-a-massively-popul...
It didn't go great. I gave a talk about it. https://youtu.be/HySQR0t_7CI?si=5sfKbb-7u-qqD65R . (Be gentle to my 2012 self's speaking skills.)
When it was announced at PDC, they only talked about WinJS and nothing else, the folks of .NET Rocks have a few shows where they mention they thought .NET was done, and they needed to refocus into something else.
The show where they interview Miguel de Icaza they go into this.
Anyone remember this one?
Microsoft Press: Learn Java Now (complete with J++ installation CD). https://www.amazon.com/dp/1572314281
[0] https://blogs.windows.com/windows-insider/2026/03/20/our-com...
Thus better leave WinUI to the Windows team.
- Win32: The original Windows API (since the 90s). Still widely used.
- MFC: Old C++ wrapper around Win32. Ancient, but still maintained.
- WPF: .NET desktop UI framework (XAML-based). Still very relevant.
- WinForms: Simpler .NET UI toolkit. Old but stable.
- WinRT: A newer API layer meant to replace parts of Win32.
- UWP: Microsoft’s attempt at unified apps (desktop + tablet + phone).
- UAP: Basically early branding/terminology around UWP (rarely used now).
- WinUI 2: UI layer for UWP apps.
- WinUI 3: Meant to bring that UI system to desktop apps outside UWP.
- Windows App SDK: The “new unified” toolkit tying modern Windows APIs together.
This is 100% true for all of their techs produced within the past ~20 years, but WPF and Winforms are extremely stable with no real issues.
It's so weird too because most of everything they've done in the past 20 years has basically just been incomplete remixes of WPF. If they just stuck with WPF and extended it onward, something like a UI toolkit equivalent of C#, it would 100% be the gold standard for Windows development today, and perhaps even UI development in general if they open source/standarded it.
Stable, but many issues. Stay away if you value your sanity and do anything nontrivial.
My take: Use Win32 for opening windows and interfacing with the OS. Use a different toolkit for actually drawing inside the windows.
Ideally a toolkit that can paint in sync with window open and resize, otherwise you'll get Electron-style window flickering. And something that supports multiple windows in a lightweight way, since you're going to want popups, menus etc. to extend outside parent window bounds
The colors were always slightly off and oversaturated, no matter what setting I used.
I migrated the app to Tauri and the PNGs of course rendered perfectly. The implementation was much easier overall.
Native toolkits are usually more advanced and tend to properly support the colour profiles and allow for wider gamut output. Whereas historically the web had poor handling and would assume sRGB, causing more "washed out" output.
On top of this, there are a small handful of system UIs that do support dark mode and make your program look inconsistent with dark mode regardless. Message boxes will switch to dark mode, and so will file dialogs -- which is a problem if you've used the Vista-style customization, as any syslinks will appear in a color of blue that's hard to read against the dark mode background.
Second, win32 is designed with the ability to change all the default colors and you used to be able to do this by right clicking the desktop and selecting "properties". If dark mode doesn't follow this - just another symptom of Microsoft's siloing incompetence. The team that wrote dark mode may not have been aware that this feature existed because parts of the platform are so disconnected from other parts.
Plus the whole thing is meant to work on ancient Windows versions (like, Vista and WS2008 ancient), so that ultimately defines the minimal common UI denominator.
Microsoft released it open source later on. Looking at the repository, looks like it has been kept up and maintained, up to version 10 now.
WTL delivers very small and efficient code, very close in size and speed to SDK programs, while presenting a more logical, object oriented model to a programmer.
For years we loaded up libraries and abstractions to minimize boilerplate. These hid the actual underlying mechanisms and often made specific customisations harder to do since you were taken away from the raw functionality.
These days AI is extremely good at writing boilerplate and in my opinion explicitly typed out boilerplate code is much easier to reason about than a library that abstracts things away to a one line annotation or similar.
A good example is that i've recently been leaning back to the raw Android apis for things like recyclerviews etc. It used to be 10+ files to changed to create an efficient scrolling view on Android with various resources and adapters required. So a whole bunch of libraries came out to try to abstract the complexity away. You know what though? I don't care about that anymore. I'm going back to the raw GUI APIs where possible because it's so explicit and clear even if it's 10x more code.
Wine is better at it than Windows itself. Especially for really old programs.
Also, they stopped caring about Windows because they want recurring service revenue. Making Windows a subscription service for consumers would outrage the users (even though they kinda already do this for business with Microsoft 365). So the consumer market is just viewed as a billboard for M365 and Copilot. So everything you see there is just lowball effort, even worse than their normal quality.
It's demonstrably possible. And further, why does what some portion of Microsoft, a huge, multi-headed beast, does qualify as the bar for what is reasonable for users to expect?
same expectation as always.
So many “let’s race-to-the-bottom along with the authority” comments on HN lately.
Dude: no! =]
It's a grave sin to have an app repo without a screenshot in the main README.md.
Note: Yes, I know that electrobun itself has videos on the README.md
The author does mention that .NET does have distribution options which don't require the user to install the runtime. You can have it package the full runtime with your build, either as a bunch of files, a self-extracting executable, or a standalone AOT-compiled native executable.
The author mentioned that the AOT-compiled executable is 9 MiB which is unacceptable to them. The other options will need even larger. Personally I don't see 9 MiB as a big deal especially when the author would rather go with Electron which is larger at worst (bundled Chromium) and only inefficient at best (system WebView).
It's just a bad idea. Today we just pack in the DLLs and it just works.
That's something which is MS' problem; they're supposed to be the company who is best at backwards compatibility, but clearly have strayed from that path.
First is that the security model changed with .net 5. Next is that they subsume Mono/.net core into the foundation of the language and this cost them them the ability to support Windows native development, specifically anything to do with Win32 API.
If you look at .net 10 and compare that to .net 5 you can see that they are trying to reintegrate the Win32 API but now it is in the all new Microsoft namespace.
The amount of change is too significant to act as a drop in replacement for the original .net framework. Maybe they could have gone a side-by-side installation, but the rapid development of The NET Framework I think made it too hard to tie to an operating system update. They wanted to free it from that update cycle of once a year or every two years and allow the development to progress rapidly at the cost of having to download it and install it each time.
I don't think the rapid development cycle argument holds water, when they're shipping a new WebView2 every month.
That’s why they had .NET 5im stead of .net core 5
- Multiple monitors - Non-full screen views - Sideloading outside of the Store - Offline installation - Explicit threads - thread pool only - Aligned memory allocation - malloc only - Any C++ compiler other than MSVC - Support for any version of Windows other than Windows 8 - Running apps as administrator - Running more than one instance of an app at a time - Runtime shader compilation
If any ONE of these things was a blocker, you could not write a Metro style app. And yet Microsoft pushed this extremely hard -- including almost completely ending any maintenance of Win32 APIs. And despite the many relaxations and extensions, UWP is still largely useless today, and now even itself seems to be going into maintenance mode. All of which has done a lot of damage to the state of Windows desktop platform development.
As an example of how bizarre UWP is, for some reason every time they published a list of new APIs added to it, they converted the list of API identifiers to lowercase in the documentation:
https://learn.microsoft.com/en-us/windows/uwp/whats-new/wind...
It's relatively insignificant, but... why? Just one of many things that showed how immature UWP was.
They already had Silverlight! For Windows Phone 7. Then they killed that off too and expected the "plethora" of WP7 apps to be rebuilt for WP8 (requiring the beloved Windows 8 desktop OS for this task). Then they again expected developers to throw that away in favor of UWP for Windows 10, which unified the desktop and phone OSes. By then it was too late.
Old apps still ran on the newer OSes but the SDKs became dead-ends.
I must've missed that one. What did they revert?
They'd lose too much enterprise software that's not being maintained any longer but still is business critical.
You can still run most programs from the Windows 95 era unmodified on a modern Windows 11 machine and a lot of things is relying on that under the hood.
Get started learning here: https://news.ycombinator.com/item?id=21459616
Two notable caveats:
1. Certain newer C# language features require runtime support that doesn't ship with older versions of .NET, which can include quite a few DLLs.
2. In-process COM components can only be instantiated in .NET runtimes runtimes with the same processor architecture, even if the .NET program itself is processor-independent (which by default will use the runtime matching the native architecture), so you may need to ship multiple executables to match multiple COM dependency versions even if your program is otherwise processor-independent or you only intend to ship it for a single processor architecture.
For example, if you build a processor-independent program that relies on the Microsoft Access DAO library, it will by default work correctly on 32-bit Windows if 32-bit Access is installed, and on 64-bit Windows if 64-bit Access is installed, but there's no way to get it to work on 64-bit Windows with 32-bit Access without shipping a second executable (that can be identical with the exception of the 32BITREQUIRED flag in the CLR header[1] that can be set as part of the build process or with the .NET SDK corflags utility).
Rather than ship separate "32-bit (or 64-bit with 32-bit <bar>" and "64-bit" versions of a program <foo> that interops with some in-proc COM component <bar>, I prefer to build a single executable <foo>.exe, then create a copy <foo>32.exe with the flag set as part of the build process, and ship both to be installed side-by-side.
Then, since the native COM DLL isn't loaded until you actually create an interop object referencing it, you can just try to create an Interop.<Bar>.<something> object at program start, catch ComException with HResult == REGDB_E_CLASSNOTREG, then in the exception handler, run <foo>32.exe as a subprocess with identical command-line arguments and exit with <foo>32's exit code, unless you're already running in a 32-bit CLR, in which case you just fail normally.
[1] https://ecma-international.org/wp-content/uploads/ECMA-335_5...
You need a commercial license for that, but yes you could. But since applications are typically distributed with install bundles that put into application-local program files directories, it's not super-important as long as you only cherry-pick the Qt libraries you need.
I've observed many people spreading this misinformation about only being able to dynamically link with the LGPL version of Qt. Please stop this.
[1] https://www.gnu.org/licenses/gpl-faq.html#LGPLStaticVsDynami...
Use self-contained to have everything together.
https://learn.microsoft.com/en-us/dotnet/core/deploying/sing...
MFC, wx, Qt .. it's all overcomplex pointless bloat for this task imo.
Meanwhile 4.8.1 is built int Windows and supports apps written over like the past fifteen years. Why wouldn't anyone just use that?
I'm sure modern .NET has some nice things but the release model is not one of them.
Microsoft has had even more people working on Windows software..
Microsoft has always had vastly more developers and development of software for Windows.
Apple still after all these years has a tiny market share of overall platforms, software, all of it really.
Not sure how you can suggest Apple is somehow the bastion of software development. If you write mac software, you'll be targeting a platform with 15-20% market share at best.
The era of 'macOS is a better media computer' is long gone.
It's funny that you think Android users are broke-ass nobodies. That's some reality-distortion-field fanboi nonsense. And it's also hilarious that you think phone apps are useful software that costs lots of money.
Most people in tech with high-paying jobs that I know are using Android, because it's actually pretty awesome compared to the locked-down walled-garden that is Apple. More than half my friends use Android or Windows. They use Android because it isn't as locked-down as iPhone. They use Windows because it runs all the software they want it to run. We also really don't care about Apple's blue bubbles.
No, Apple users are not the only ones with jobs. Plenty of Android users have plenty of disposable income. It's a ridiculous argument to make that Apple users have more money to spend.
>Do you believe that the vastly larger installed base of Windows guarantees more money for everyone?
I don't have to believe it, the market believes it. People vote with their dollars, and they aren't voting for Apple all that often worldwide. Plenty of wealthy people use Android and Windows. I'd wager that most big companies are still run on Windows - and I know this experientially, from back in the day setting up computers for major corps, it was 85% Windows, 15% Apple. Always was, always will be.
I've been a fulltime Linux user for years but there are tons of excellent Windows-only apps.
Here are some that I miss: Directory Opus, ShareX, Wiztree, Everything, AltDrag, AutoHotkey, Paint.NET, irfanview, SumatraPDF. I'd add Keepass2 as well but fortunately KeepassXC is a thing.
Those are all feature-filled (in the bloat-free good way) and they've all been around for over a decade (from memory). Most are free and open source to boot.
Also, I am pretty sure that SumatraPDF is available for Linux as well. I am not at a computer but I think it is in the AUR.
But I agree that most of the boutique stuff on Windows gets drowned in all the enterprise software a bit.
[1]: https://techcommunity.microsoft.com/blog/microsoft-security-...
Then there's the removal of title bars from Windows. You often have no idea what app you're looking at. Pull up a PDF in Acrobat and also in Edge. Now, at a glance, which is which?
Regressive garbage.
they did what??? [i'm still on 10 because 11 won't run on my laptop </3]
Case in point, the Dropbox Simplified Desktop App was a huge improvement for me. It nails just about everything I ever needed their app to do, and removes all the user-hostile fluff I never asked for. Similarly, I found Windows 11 Enterprise IoT LTSC to offer an improved desktop experience compared to traditional Windows, thanks to its exclusion of a lot of the cruft Microsoft otherwise shoves down the throats of users who, as far as I can tell from frank discussions with many of them, likewise actively don't want.
I'm not saying your desire to make your app look polished means it's crap, but beauty is in the eye of the beholder. Just like fashion, I wouldn't be surprised if we see a shift in the aesthetics trend as more people discover a retro feel sometimes signals a better user experience.
Also, modern compilers make this method much harder to use. It is much harder to stably relink object files like that than to just use the normal dynamic link method.
Until the next latest version?
1. Do not relay LLM output. If someone wanted, they would use it, ChatGPT is free. Post your own, human, meaty thoughts.
2. The blog post explains all these technologies, one just need to read it further than the title. It might be a big ask here on HN, I know, but still.
The multi-headed beast has been assimilated by web-tech. They can't code GUI C++ no more - except their compiler/graphics team. And even the latter are dying.
If doing native apps was realistic then I’d expect windows, Microsoft, etc to also do them.
I've been around long enough to remember MS and their fans banging on about how bad other OSs were for their inconsistent interfaces, so I feel justified in getting a little riled at the hypocrisy of how much of a mess UIs are in Windows these days.
And I don't see it getting any better - they'd rather spend the time finding new places to slip in adverts. And this is far from the fault of app developers, while they often do have something to answer for wrt consistency, because the worst culprit is MS themselves both in their apps and the OS.
I shouldn't have to click to make sure the right thing has focus for instance, particularly after switching from another virtual desktop, I should be able to see this information easily but there is no consistency in titlebars and other window chrome any more.
In the browser or the Windows Photos app they were looking correct, while WinUI was incorrectly oversaturated.
Not out of the box, but there are ways to do it, e.g. ILMerge.
> so you may need to ship multiple executables
OP's baseline is native code tho, so they are already planning to do that.
I get that if I post more than six replies in an hour.
Ironically, Microsoft nowadays not only has their OpenJDK based distro, they even host Java conferences.
MS Press used to publish some amazing references. I have a LOT of 'em.
Majority of applications on Linux are native applications. Maybe the problem is the platform?
Would that UI be hard to accomplish?
Win32 provides its own components which are basically Win95 style apps, and you can draw the components using some graphics APIs by yourself.
The whole native development area is a mess exactly because making your own (decent) renderer is a huge undertaking.
I came from the WinForms world so don't pretend I don't understand Win32 programming. The fault lies with Microsoft for not investing in it more.
But that "modern" style is... disgusting and repulsive. That whole dialog is bigger than one of my monitors due to how much wasted space it has.
We did a UI refresh at one point. It looked much nicer. People hated it. We had to hastily redesign it again and it looked far more like the original.
https://appleinsider.com/articles/24/06/05/app-store-just-ha...
If you mean Lazarus, it is fully open source. No restrictions but the ones of the software itself.
I stick to the LTS versions which are the even numbers and they are supported for 3 years each. after 2 years in, the next LTS is out and all I typically have to do is bump up .NET target number in the project and I haven't really had a problem. There were more changes back in the .NET Core 3 and .NET5/6 days, but that was like 5+ years ago now.
Also, you can build your apps with the framework included in a single executable even, and so anyone can use your app without having the framework installed at all if you are worried about whether the framework version is installed on their system or not.
Also if you wait the 3 years to upgrade the .NET version, then I doubt you would ever have a problem where the target system didn't already have the new LTS version after it will have been out for a year at that point.
If you really don't care at all about cross platform support which .NET offers really well now, then you could keep using Framework 4.8, but after nearly 10 versions of .NET the improvements to the C# language and runtime and everything are hard to ignore. Though I think there is some way with some package you can use the new C# language features with Framework 4.8.
When Windows builds in a modern .NET, I will use it! Bear in mind all of this above churn, while they claim is the new way things work, is inherently temporary: The reason .NET 4.8 is so well supported is Windows is built on it. So if Microsoft ever wants to use those newer things in Windows... Windows will have to build-in modern .NET features someday.
Actually it doesn't. Win32 skinning is either making a control completely from scratch or hacking into undocumented aspects of the native controls - i.e. what WindowBlinds does. AFAIK modern Delphi has some component that basically follows the WindowBlinds approach.
In almost all cases you just need to handle the drawing yourself, and you get fairly broad access through the API to do so through the various non-client and client window messages.
Now, Windows has gained some newfangled components over the years with more or less integration, I'm thinking basic Win32 controls.
And for HiDPI, https://learn.microsoft.com/en-us/dotnet/desktop/winforms/hi...
> WinForm or WPF, how to choose
and they were like: "the question I have isn't how to choose, but _why_ I have to choose".
https://github.com/dotnet/winforms/issues?q=is%3Aissue%20sta...
Winforms is also .NET based, so it's inaccessible if you don't want to write your UI in and take a dependency on .NET.
Naturally it is a bit more than just drag and drop controls from the toolbox.
HiDPI is supported in modern .NET, with additionally APIs, that aren't enabled by default only due to backwards compatibility.
You can pick one or the otherfor Windows too, so don't ask me why it's done that way. It was originally so you could compile for both the new hotness Unicode, and the old compatible ASCII.
Or, they could have implemented a UTF-8 code page for Win32 as soon as it was available and then most software could just use byte strings.
But in case you want to read yourself: https://blogs.windows.com/windows-insider/2026/03/20/our-com...
You can also hook a WebView up directly to a low-level language and skip Javascript entirely, so does that mean Rust + WebView = Native?
In practice, I guess most people realize because web tech just behaves different than native.
A better approach would be to not break backwards compatibility in the first place.
I've been a developer for a long time; I've built pretty large applications in all sorts of technologies and I now just prefer defining GUIs using text. Having a live GUI preview is great but actually dragging and dropping stuff is not more efficient to me.
To fit your analogy, using source code is like writing a song using musical notation. I'll write the song, then play it, and then go back to notation to fix it or expand on it.
And as a side-effect of that, merge conflicts become murder when your "Fix right-hand margins" commit with a 20 line readable +/- diff instead becomes a 1000 line +/- diff.
The one time I built an iOS app using the xCode IB so that I could get up to speed more quickly, I really came to regret it several years into the project.
And yet, most songwriters write the song, they don't record themselves playing notes.
Win32 controls ignoring system colors goes much farther back than dark mode being introduced in Windows 10. The theming engine that broke a lot of that functionality was introduced in Windows XP. Beyond that, there were always a few hardcoded colors like disabled gray text going back to Windows 95.
Dark mode ignoring Win32 system colors is not incompetence. It was _intentional_. Dark mode was introduced by the UWP side, which intentionally did not extend it to Win32. To this day, there is not even a Win32 API for desktop apps to query whether dark mode is even enabled. The official recommendation is to compute the luminance of the UWP foreground color setting:
https://learn.microsoft.com/en-us/windows/apps/desktop/moder...
>Dark mode is used by 81.9% of 2,500 Android users on their phones, in apps, and in other situations. 9.9% alternate between the light and dark
So it's the other way around. Only a very small minority of users actually care about light mode.
Intentional malice, in other words. A stupid attempt at pushing UWP.
Not at all. It became popular mainly because as part of the spread of the flat UI epidemic, the previously non-optional “light mode” OS UI themes all shifted away from midtone colors to blinding stark whites. This meant that monitor brightness settings that had previously been comfortable suddenly weren’t.
On top of this, modern flat UI light mode themes consistently have poorer contrast and delineation than their dark mode counterparts, because higher contrast with darker grays makes flat white UI themes appear “dirty”. So even if the brightness isn’t an issue, your eyes have fewer visual cues to guide them.
Aside from that, on IPS panel monitors lowering brightness past a certain point also greatly lowers color vividness which looks bad, which is why some of us like to keep it maybe not maxed but a bit higher than is comfortable with light mode.
There can be other valid perspectives than your own.
I don't think your brightness sentiment is universally shared by most people, hence the downvotes. I think this comes from one particular study that people just end up parroting, possibly via third-hand gossip.
While a sufficiently low-brightness screen might have some specific advantages to dark mode, I think the issue is more nuanced than that.
First, not everyone can set their brightness to an appropriate level.
If the user is prone to migraines or light sensitivity, light mode even at a low setting could trigger headaches.
Light mode also produces significantly more blue light, which can have health side-effects as well.
If you keep a white screen on at appropriately low brightness in a dark room, the relative difference between the screen and the surroundings is still massive. This creates pupil strain as the eye constantly adjusts. Dark mode aligns the screen's luminance closer to the room's, reducing this strain.
Dark backgrounds make colors pop more vibrantly and prevent the "washed-out" look that can happen when bright images sit on a white background. It can also reduce halos visible around bright objects in photography apps and make the UI less distracting.
For battery-powered/mobile devices, dark mode uses much less battery power on OLED screens.
It's pretty much impossible to embed properly without edge cases in GPU-based renderers as far as I know, if you want layering of widgets (for instance a platform widget in-between two flutter widgets in z-order)
Gtk on the other hand is absolutely terrible and its developers don't help by completely rewriting things every few years and breaking all existing code in the process.
The work around was 'simply' to switch to 100% DPI scaling before opening Visual Studio. On my macBook Pro built-in monitor, this was not cool.
Flutter is nicer to scale and maybe design but it is a massive overhead. Skia still has trouble with some drivers and causes lag or falls back to software rasterization. Hot replacement while coding is pretty neat though. It runs much better on mobile devices imho.
https://i.imgur.com/aHMHqSc.png
Handling merges (and other VCS functions) is also simple since you can edit the file manually if needed.
If you're building win32 you're not targeting android.
I would be astounded if a majority of general Android users used dark mode, as light mode is the default on most phones (all, IME).
