Ostensibly, grading by impact is fine: they want people who make a positive difference. In reality, it means that creating is better than finishing. Now add in the cold realities that at any given time in Microsoft, some groups are on the up and some on the down. What's a great way for a group to regain some status? Launch something. Jazz it up for the Build or Ignite crowd. Get some dev evangelist to talk about it. Then get on the job board and slide over to another team ASAP. You're a High Impact person. Who wouldn't be happy to have you?
I need to ignore those and do D,E,F instead to get promoted.
Windows and Mac in the 90s had very consistent GUIs with such consistency in things like keyboard shortcuts that apps could easily be learned. The term “intuitive” was king in the realm of UI design.
Then the web hit and all that died.
If you really enjoy worse Windows XP UX with hamburger menus in recent versions then by all means go ahead, it does function.
I could use Konqueror, I guess, but its ad blocking plugin (and plugins overall) seems to never have progressed much since KDE 2.
Then there's a lot of legacy stuff that needs to continue working because otherwise you end up with a non backwards compatible windows.
Then you have to get everyone at microsoft across all their bajillion products to change the UI from Task manager to the 5th level of settings for some obscure ODBC connector.
It's not going to happen I suspect
Did they even try to make it look like the new context menus?
1. Drop all its GUI stacks apart from legacy Win32
2. Port KDE Plasma to Windows (with aliased bindings to support traditional explorer.exe calls so as to not break user apps)
That's it. There really aren't many significant apps that use the rest of Microsoft's stack apart from Win32 that won't recover from this, and Microsoft itself will just see a massive drop in its own costs with a massive rise in user satisfaction.
Everything that came later was basically a struggle to make something that Electron actually delivered.
Updated apps look fine, but the majority aren't. And with that bizarre "Show More Options" nesting in the Windows 11 context menu it almost seemed like Microsoft is no longer capable of upgrading old components in place.
It's worth noting though that Apple is on a similar trajectory and is now in a very nearly as bad position given all the serious issues with SwiftUI and how badly it has fragmented/degraded Mac desktop application development.
It's almost like the major desktop platform vendors have all given up on supporting high-quality native desktop applications.
Apple (and Next before it) have been iterating on Appkit/UIKit for three and a half decades.
Now they have added SwiftUI as a second option and have been iterating on it for a bit over half a decade.
This is in no way similar to Microsoft creating and abandoning another UI framework every couple of years.
If Microsoft had been steadily improving Win32 all these years, where would it be today?
I got to the point that I could create windows and controls, and had a basic message loop working.
I then started dabbling in painting in non-client areas. It was buggy and didn't work well (my fault), but then I could see 2-3 different Windows UI styles competing to draw the window chrome.
The amount of crumbs hidden under the Windows carpet is incredible.
Microslop should have been dismantled decades ago, it's now too late, we need a paradigm shift so that Microsoft no longer affects our society
That AI image at the end was more amusing than informative. Almost lost it at "Win15" and "Chrondum + frade.js".
I still think WinForms is one of their best UI framework. As for WPF, intentionally avoided it since day one. I’m not fiddling with no XAML.
I’m not sure what Microsoft can possibly do when the closest thing to a collection of power users is this painfully repetitive.
> That silence is the story.
These LLMs are just awful at writing.
Dead silence. Here's what 3 people said (the opposite of silence). Then the meeting went sideways (also the opposite of silence).
The silence is the story.
>introduced a level of cognitive complexity that makes Kierkegaard read like Hemingway.
and I fucking lost it.
Every WPF program was laggy and took ages to even start up (is everyone forgetting hard disk speeds?), partly due to it being managed code. The components didn't feel native either, and the coupling to managed code and garbage collection basically ensured all those would be perpetual issues. Yeah the programming model was beautiful and all, but you're supposedly developing to make your customers happy, not to make yourself or computer scientists happy.
You can see how terrible it would've been to base Windows's shell on WPF by looking at how much users have loved the non-Win32 windows since then.
- WinForms applications also took visibly longer to load than Win32. I didn't dread loading them nearly as much as WPF, yes, but I still did. They weren't what I'd call "snappy", but they were... usable enough.
- WinForms also stuttered (in my experience) with the GC. Again, not "snappy" in my experience, but this was more dependent on your use case.
- WinForms were .NET 2.0 rather than .NET 3.0, with fewer modules to load. It certainly felt more lightweight, which from my memory (of how the hard disk behaved) correlated with that.
Well yes, I do agree with this. Internally it's mostly consistent, at least more so than Windows. Never analysed its UI structures though.
> I don't want my desktop UI to dictate how an app draws its UI (or games would be impossible).
As a platform, ensuring applications running on top of it stay consistent to varying degree is the job of the desktop/OS IMO. To what degree depends on the context, https://asktog.com/atc/principles-of-interaction-design/#con... is a great read.
Even games need it, missing input field features has plagued PC games for decades and can be crippling for input method users, Skyrim's console needs mods to support copy and paste. Custom mouse acceleration curves is the reason everyone disabled it, zero acceleration is the easiest way to make different games handle mouse input consistently.
A shame Linux isn't standardised enough.
I think it really abuses the assumption of good faith and the default to generous interpretation, because it forces you to divorce the author from their own published work in order to view them seriously. I suspect most of the comments here are generously ignoring the included graphic. But in the most generous view possible, the author is fine with publishing wildly inaccurate statements.
I think this makes HackerNews much worse, and posts like these should only be flagged.
When I last used Windows, on a fresh install, I saw a mixture of different frameworks used for core OS components from the same vendor.
When I last used OS X, it was pretty consistent but I hear complaints from friends that its no longer the case.
The cleanest design I came up with works like this:
1. At Layer_1 OS provides panes or windows to which apps can render whatever graphics using OS gpu lib (think Raylib, but maybe a bit simpler). This is good for apps that want performance, games, text editors, things like that - so this is maximum control.
2. Next Layer_2 would be based on the browser engine (which, to some degree, would have to be developer - not a full browser, but just enough to render more or less modern html/css with a DOM-aware JS engine). Then provide some XML schema that would automatically translate into HTML/CSS to render various UI-widgets (defined by XML/HTML elements). This would eventually suggest a JavaScript UI framework on top, but no a requirement. This layer is flexible enough that it uses widgets defined by the system, but allows custom CSS and JavaScript.
3. Layer_3, or more like Layer_2.5 would basically allow custom HTML/CSS without relying on system widgets and XML schema.
Obviously you can mix all three layers into one GUI too. Finally layers (2) and (3) would require some client/server architecture, but instead of shipping it like a webapp, I'd probably provide some JavaScript API to talk to the backend (which in this case is accessible via a socket of some sorts). Apps themselves could still be single binaries that include html/css/js assets which are provided at launch time to the system UI renderer, which then uses them to render the UI via a webview in said pane or window.
I think it's pretty slick and it only gets complicated gradually, but it also requires solid OS plumbing and machinery to make this process smooth. None of the modern systems are capable of it in the way I described it, so people end up shipping nodejs/react apps with webview inside gigabyte-binaries.
I wonder if we attended the same conference session!
What's still missing is deeper integration with native OS concepts and programming languages other than JS. Frameworks like Electron are a step in that direction but they come with notable drawbacks. Applications often struggle with things that should feel natural like managing multiple OS-level windows.
Another PITA: Electron apps repeatedly bundle large portions of Chromium, leading to unnecessary overhead. Those duplicated modules lead to bloated RAM usage: every app has its own Chromium copy and OS must keep all that zoo in RAM without a possibility of reusing the otherwise shareable parts.
Orders of magnitude more BS, plumbing, awkwardness, head scratching, etc.
In no universe is HTML performant compared to actual desktop applications. It sucks big time.
Could have been Ballmer getting a quick snack in before anger-presentation.
It's all win32 underneath except for UWP, which is now deprecated.
so the answer is win32, raw winproc.
The issue is they haven't made a new GUI API (only frameworks) since win32.
The issue was they didn't give you an alternative they just said don't do that.
so inevitably at some point you decide to just write it in win32, don't ship in the store, etc so you can get things done.
Jobs, Musk, Edison, whoever.
Someone who will enforce their design decisions, get stuff done. And take the hit when they are wrong.
The layers of outdated and conflicting documentation, fragmented logins, the naming (365, live, .net [both naming everything that and the .net core naming labyrinth], copilot), Teams never made sense, Windows had levels and levels of settings (win10 preferences all the way back to dialogs predating the mammoth).
MS was, is and always be a blight upon this earth.
To be brutally honest, if you were a serious Windows developer in those days (and you were even the sort who'd have sat through a conference session on the topic); there is absolutely no way in hell you'd not understand the difference between OLE, COM, and ActiveX. Conflating these things as some sort of confusing mess either shows a lack of actual experience, a lack of competency, or a desire to falsely make things seem more confusing than they were to add some meat to an article.
This article dances with some good points, but opening up with this sort of hyperbole (and then ending it with an unabashed AI slop image filled with brand new hallucinated characters of the alphabet) just totally tanks the author's reputation.
Also, the AI smell in this article is just too much.
>> Jon Udell found a slide from Microsoft labelled “How Do I Pick Between Windows Forms and Avalon?” and asks, “Why do I have to pick between Windows Forms and Avalon?” A good question, and one to which he finds no great answer.
And:
>> Which means, suddenly, Microsoft’s API doesn’t matter so much. Web applications don’t require Windows.
What he didn't see is, however, Azure would become the money printer for Microsoft and made all these no longer matter.
[0]: https://www.joelonsoftware.com/2004/06/13/how-microsoft-lost...
Moreover, there isn’t much in the way of alternatives. Everyone likes to hate on MS —for decades this has happened and nothing came of it.
But "That silence is the story." is still a pretty telling non-sequitr, and it doesn't seem like the kind that comes from sloppy editing.
The punchy "Thing. Thing. Thing." is used constantly. We see it constantly in this article:
> 852 pages. Win16 API in C.
> Message loops. Window procedures. GDI.
> One OS, one API, one language, one book.
But those are minor sins. But in the end of the article, Snover states that Microsoft pitched C++ in 2012. That's so incorrect! The contents of this blog post are at least partially falsified.
Plus, the thesis statement is nonsense:
> When a platform can’t answer “how should I build a UI?” in under ten seconds, it has failed its developers. Full stop.
"Full stop" is a pretty heavy thing to end a nonsense statement with. How an inanimate software platform can "answer" things is not implicitly obvious, either. Is it a human representative? Are they the docs? Is it through a good UI?
The post is about Petzold's / Reccold's "Programming Windows", but it is apparently 852 pages, so that certainly wasn't answered in under 10 seconds either.
I'll grant you that the lack of good WYSIWYG designers for working on web/electron apps is appalling, it's like RAD peaked in 1998 with VB6 and it's been downhill ever since.
Not having to deal with state management.
Not having to deal with browser compatibility issues (and mobile vs desktop).
Not having to deal with weird input validation stuff dual layer stuff that is inherent in web apps, but not a big deal elsewhere.
Not having to deal with laggy and unstable connections at the UI layer.
Etc, etc.
Xaml and styling and all sorts to try and compete.
Trouble is, it made desktop development harder, and it didn't win against the web. It left the simple and safe formula of standard and common controls for a designer's playground, but the designers preferred the web. And if you make something for the web, you can package it in Electron and get cross platform cheaply.
Microsoft keeps footgunning things so hard I think even enterprise might be reluctant to go with them moving forward [0]. I don’t have Netcraft numbers in front of me but I doubt things have notably improved even if they do have a strategy shift to enterprise which includes crapping all over Windows for no good reason.
I’m personally glad FOSS is going strong but that’s a complete aside.
[0] We got burned by Azure as I’m sure many other enterprises have, and they did exactly nothing to remedy/compensate the situation, SLAs be damned. At this point our strategy is to move off of reliance on any Microsoft/windows tech. We moved off of ActiveDirectory not too long ago. Bing/Edge/etc honestly who cares.
Any trade-off that favors the enterprise in lieu of the user actually benefits nobody in the long term.
That Bill Gates?
Seems he might have other priorities these days?
Before that he had a role as a technical advisor and sat on the board of directors.
I also found it interesting that Steve Ballmer owns considerably more of Microsoft than Bill Gates (4% for Steve Ballmer while Bill Gates owns less than 1%).
Microsoft has been developer first, then cloud first, now AI first. It has never been design first. And when something does work, the pattern is always the same: force it everywhere. Metro was genuinely good on mobile, then they pushed it onto desktop where it didn't fit. Now Fluent UI is repeating the cycle.
Fluent UI is on its third major rewrite (Fabric, then Fluent UI React v8, then v9). Each one brought breaking changes. v9 appeared around the same time Microsoft released their new Teams client, and it shipped with performance and accessibility issues that are still being worked through. Signs already point to the next throwaway Fluent UI version. In practice, Fluent seems to be first-party only. It's 'open source' in the sense that you can look but don't touch. In SharePoint alone, the same UI elements look different across pages, lists, document libraries, and settings panels.
The irony is that the web platform itself has caught up. You can build a fully themed, accessible component library in plain HTML and CSS today. No framework dependency, no version lock-in. I did exactly that with hTWOo (https://htwoo.io/), an open-source alternative that matches the Fluent design language without any of the React coupling.
The real problem isn't that Microsoft can't pick a GUI strategy. It's that they keep rebuilding from scratch instead of creating a design system flexible enough to sustain across platforms and product generations. The web platform already provides the primitives. You just have to commit to them.
Unreal that MS bet the farm in Windows on so many other turds instead of boring old WinForms/Win32.
It took them more than 2 decades to finally support pure native binaries (via NativeAOT). And it's fantastic for servers on Linux.
Itanium was the heir apparent but importantly basically vaporware. How do you develop software NOW and more importantly sell and ship software NOW that'll work on a CPU you don't have access to and for which good compilers don't really exist yet? I remind you in the days where online updates were a luxury at best.
Processor agnostic CIL/JIT code was the prescribed solution at the time. Java had lit the way, and it was the only "clear" path forward for better or worse.
Little did we know Itanium would implode, and x86-64 would rise and give 20+ more years of binary compatibility.
This led to one of the trickiest things for early .NET consumer apps- getting the latest runtime installed.
Perhaps if WPF really did stay at the presentation level, or used VMs or something to keep it away from the Windows core, it would have panned out better. But is it goes with "paradigm shifts", when a company thinks it has a great idea, it wants to suddenly do that great idea everywhere.
Has it become unreasonable to use an image editor for anything? At least to stamp some readable text on top of your slop??
He's claiming Microsoft pitched "WitdFT" (sic), "HTMLAl5" (sic), and "C++" sonuitaneously (sic) at Build 2012.
HTML5 was released in 2008 and the C++ reference was released in 1985. How is this acceptable?
Windows Native App Development Is a Mess
Microsoft developed VS Code and Teams in Electron. That says a lot about how they see the future.
If Microsoft hadn’t been preoccupied with a failed mobile bet then this wouldn’t have happened. It’s a lost decade followed by a (much more successful) cloud pivot. The reason desktop is ignored is because it can be. No one is eating their lunch on desktop.
From a user's perspective, I don't really see where the problem is. All my apps look like Windows apps to me, and I also think that includes apps that do their own thing and look their own way. For as long as Windows has been around we've had apps that just don't follow the rules, from RealPlayer to WinZip to iTunes to Spotify.
This idea that all applications must be consistent with each other on one platform is generally a good idea but the downside of not having it that way is not very tangible to most users.
E.g., Steam looks different than every other Windows app. Same with Spotify and Slack and Discord. How does that negatively impact users? Well, not really at all. The consistency is within those apps themselves. I'm comfortable with Steam because I've been using it for 20 years and it's evolved on its own terms.
I could see it being an accessibility problem, but can't figure out any other potential downside.
I also don't think any other platforms have this figured out. See the window corners in macOS Tahoe. Remember how Mac Catalyst apps first looked when that came out? They didn't follow OS conventions at all. Remember when Final Cut Pro 6 didn't look anything like a Mac app? Or GarageBand etc. and their skeuomorphic looks? Linux is no better with a mix of desktop environments, Wayland versus Xorg, etc. Then we look at mobile apps and it's one of the least consistent environments imaginable: you've got a mix of native and frameworks like React Native and Flutter and the rest.
People who play this corrosive game either refuse to believe that they are at fault for not changing what they were doing at that time or speaking up about what they were observing then, or they know they're at fault and want to deceptively distract us from that fact. Either way, ask yourself this: "Aren't they sorry?" If they're not, just move on.
> WinRT (2012) - it (or the embodiment in Windows 8) failed in the market but it also showed both the problem and potential solution to building for new markets while respecting the past
I can't express how wrong this is. WinRT was the most destructive thing that the Windows team ever did to the OS. It drove a hard stake into Windows, splitting it in half and declaring that anything previous to Windows 8, oriented toward desktop, or using primary input through mouse and keyboard over touch was dead. Microsoft basically told all existing Windows developers that if they weren't building a new, touch-oriented, mobile-style app specifically for Windows 8, they didn't matter and wouldn't get any support whatsoever, which is exactly what happened every time they broke existing desktop functionality. Calling this "respecting the past" is a crass insult and taking no responsibility for damaging the Windows development experience and accelerating development away from native Windows apps.
"Sandbox-first" even made some sense as a direction to work because it is harder to add a sandbox after the fact than to start with one, which is one of the core lessons learned from XP trying to sandbox some of the insecurities in Win32 and getting caught in a lot of complications. (The "sandbox-first" of UWP wasn't even that different under the hood from the XP "sandbox" of Folder/Registry Redirection, just a little better hardened.) Microsoft needed a lot better messaging up front if they had expected to allow more apps to leave the sandbox eventually. But Microsoft probably did believe the UWP sandbox was a better and safer experience for consumers.
But yeah, what's left of Package Identity outside of the sandbox feels like it includes several classic mistakes from .NET's CAS/GAC era, and also seems to point out that Sinofsky was wrong about WinRT "respecting the past" when it failed to learn from that era because it didn't trust .NET's history.
It's true that there is no great answer for how to add capabilities and sandboxing after the fact. But what Windows did was build an incredibly restrictive sandbox and then tell everyone who couldn't accommodate even one of the restrictions was "sucks to be you". The result was that developers, when confronted with "all or nothing" for Metro-style apps, were forced to choose nothing. It was also not a good look that Microsoft's own flagship applications like Visual Studio and Office did not show any progress toward adopting UWP, and in the latter case, was specifically exempted from the Windows RT restrictions to continue using Win32 on that platform.
If there had been a better strategy for easing in UWP technology, we might have seen better progress on adoption of Windows Runtime APIs and capabilities so new programs could gradually move toward the new technologies and away from HWNDs. Unfortunately, the technical barriers that were put in place between Win32 and UWP are so large that progress toward breaking them down in the Windows App SDK has been slow.
For example, Windows classic desktop apps still have no equivalent to the UWP app lifecycle. Your UWP app's processes can be suspended and resumed without you writing code to force the suspension and request when to be resumed later. Instead, you are expected to appropriately handle event notifications for suspend, resume, and the app entering and leaving background state.
This system-managed UWP app lifecycle makes life harder for UWP app authors, but I think the net win for battery life is much better for the user experience, which is why mobile apps operate the same way. Yet the docs for the Windows App SDK, which is supposed to bring the best of the UWP to desktop apps, explicitly say that WinAppSDK apps control their lifecycle just like other desktop apps, and the only power friendliness in the WinAppSDK API is voluntary (aka no one will use it). [1, 2]
I'll probably write more soon in response to other parts of the original link's comment thread. Overall, I feel like UWP is being unfairly maligned here, and that while its introduction was unforgivably arrogant, Steven Sinofsky is also right that it was daring and necessary to fix the mistakes and outdated decisions of 16-bit Windows and Win32.
[1] https://learn.microsoft.com/windows/apps/windows-app-sdk/app...
[2] https://learn.microsoft.com/windows/apps/windows-app-sdk/app...
That's an extreme scenario but today's politicians are not very keen into redistribution of wealth or prevention of excessive accumulation of economic power leading to exceeding the power of the state itself. I see nothing preventing that scenario from happening.
‘I wanted a machine to do the dishes for me so I could concentrate on my art, and what I got was a machine to do the art so now I’m the one doing the dishes’
The GAC and certain CAS configurations would require paid certificates, too. Certainly the requirement of paid certificates can be seen as a part of how both of those eventually fell out of favor. That is another of the things I felt UWP missed learning from .NET. Developers do generally dislike code signing certificates and try to avoid them.
Also to be fair, UWP had a rather streamlined certificate system if you targeted only the Store and let the Store manage your certificate chain. It was even a little bit easier to use than Apple's similar App Store management of XCode certificates. Not that that was a high bar to clear.
> It was also not a good look that Microsoft's own flagship applications like Visual Studio and Office did not show any progress toward adopting UWP
There was some progress. Office involves a lot of teams working at different paces and sometimes extremely different codebases. OneNote was fully UWP for a while and was at one point considered a flagship and testbed for UWP "Fluent Design" (both before and after the shift from touch-first to the over-correction to "it's just a desktop framework that sometimes is touch friendly"). Several new Office apps were written UWP first, including the "Office Hub" app that became called just "Office" and now is even more confusing called "Microsoft Copilot 365 app". "Outlook (New)" has always been React Native, but as a React Native project, it ran entirely in UWP, too, for a while. It was said to have been one of the drivers for deep UWP support in React native at the time. There were also the React Native-based Word, Excel, and PowerPoint "mini" versions that ran entirely in UWP. Those are said to have influenced more of the real codebases pushing towards React Native, but did not try to replace the original codebases in the same way that "Outlook (New)" today is overtaking "Outlook (Classic)".
There were a lot of strategy problems with UWP, but adoption was further along in some areas than it looked.
That relates to some of my criticism that maybe UWP could have used more .NET veterans because that was one of the problems with the CAS sandbox. For the most part the CAS sandbox was "opt-in" and yeah software developers through ego, hubris, and everything else will most often declare "my app/library is a special snowflake and needs access to everything!" So even if things opt-in to additional security controls like CAS, no one tests or builds for Production in a CAS sandbox so even things that claimed to support CAS threw runtime exceptions all over the place to the point no one could trust CAS to the point were CAS died for being practically useless overhead because no one both opted in and knew how to test it.
UWP had a lot of good ideas. It's insistence that it didn't have much to learn from .NET's mistakes was not one of them.
Things like:
- If you can't respond to a UI event wait until you can
- Menus should be tree structures
- Pressing alt should underline the hotkeys you need to access anything clickable
As well as just basic responsiveness or predictability. A 2000 era windows application may not have been pretty, and may well have several different styles all imitated from office, but at least I knew what everything did and when it was slow at least it did what I expected.
This meant I could start the computer, log in, potentially start and use several applications and only then turn on the screen. Nowadays that has no chance of working because even to log in I need to press enter or click some button (which one depends on how I logged in previously, maybe) before I can even start typing and doing so eats a random amount of keystrokes while the damn log in screen loads to do its one damn job.
We've lost design idioms, which is a huge tax on users everywhere. I've been mad about this for years: https://essays.johnloeber.com/p/4-bring-back-idiomatic-desig...
I personally love dense UIs and have no expectation of doing certain kinds of work on a phone or low-powered device like a chromebook, phone, or bottom-barrel laptop. But if you're a company trying to sell products to a broad user base, you want to try to design in a way that works for those kinds of users because they still might be end-users of your product. And there's a good chance that those platforms may be where someone first evaluates your product (eg from a link shared and accessed on a mobile device) even for the users who do plan on using more powerful desktop devices to do their work.
So instead we get these information poor, incoherent (because it turns out proper cross-platform, cross-user design is much more difficult than just getting something that works cross-platform for all users on its surface) interfaces. I guess I'm writing this just to add, web/mobile have complicated things partially because more than just requiring their own distinct patterns, they each represent a distinct medium that products try to target with the same kind of design. But because they're different mediums, it's like trying to square a circle.
Any system that needs a straightforward UI for kicking things off, stopping them, logging them, and dragging data files into them..... WinForms.
Bugfree, hardened by the test of time, works on Windows X, Y and Z.
Everything else is just consumer silver sprinkles, and involves faffing around with multiple config files and obscure layout issues.
I am going to add my favorite here, just to rant into the void. A dialog box's options must never be Ok/Cancel. These are not the same sorts of things. "Cancel" is a verb, "Ok" is a noun (in this context). Even if "Ok" is taken to mean the verb "acknowledge", it is still not an alternative to cancelling.
99% of these dialogs should be "[Verb]/Cancel": Change "Ok" to a verb or short phrase indicating the action that will be taken if you press it. Don't do the action if the user hits "cancel". The verb should be something specific like "Delete file" or "Terminate process" and not something useless like "proceed".
We've got big screens now! use more words! Save changes/Discard changes/Don't quit.
This is one that I hold my devs accountable for. No, I shouldn't have "put it in the spec", because it is the fucking spec.
I would argue that desktop is the platform for power users, and its future depends on them. The keyboard shortcuts, the micro-interactions, the window management -- this stuff is all important when you're using a system for 8+ hours per day.
Yet we risk desktop experiences becoming less useful due to the UI becoming "dumber" as we keep shoehorning websites onto the desktop. Website UI is dumb. It's mouse driven, keyboard is an afterthought. There's no consistency, and you have to re-invent the wheel every time to get the details right (almost never happens).
I think its more like the OS vendors have stopped being operating system vendors, and are now - instead - vendors of eyeballs to advertisers.
The less the user is GUI'ing, the more they are just watching, placid, whatever else is on their screen.
For native apps to survive, they need to not be platform-specific - i.e. web apps, which require a browser and all its responsibilities - but rather cross-platform, reliable, predictable on all platforms - i.e. dissuaded from using native, but rather bespoke, UI frameworks.
This is attainable and there are many great examples of apps which are in fact, old wheels not re-invented, which still work for their particular user market.
I have the most respect for apps I can use on MacOS, Windows, and Linux - with the same hotkey/user experience on all platforms, equitably - and the least respect for apps which 'only run on one of them', since that is of course nonsense in this day and age.
The cognitive load of doing a web app that can do all the things a native app can do, is equivalent to the load required to build a cross-platform app using native frameworks, so ..
Power users are less susceptible to suggestion and therefore less profitable. They have largely moved to OSes that do not interfere with their wishes, allowing them to make their own choices about what they can or can't do/run (Eg. Linux).
I think the world changed. "Power users" in the traditional sense use Linux and BSD now. Microsoft and Apple dropped them when they realized how lucrative it would be to dumb things down and make computers more like cable TV.
*well, that seems to have been their goal in the past; nowadays it just seems like they've been trying to funnel windows users to their other products and forcing copilot into everything.
The web is not consistent itself. Lots of sites, and most web apps, invent their own UI.
Hopefully /s
I mean... well... responsiveness matters to me too, and I am impressed by such inspired productivity, but... I'm also confused. Why not turn on the screen - the monitor, right?
Now thinking about how gui lag might impact the sight-impaired, tangential as that is...
Anyway the real point is that it's just easier to use something if you don't need constant visual feedback. Being able to use something blind is more than just an accessibility issue it is just better in general.
As someone who saw what impact WPF had on average users running average hardware in the late 2000s to early 2010s, I disagree.
In 2011, my brother was in seminary, using an average Windows Vista-era laptop that he had been given in 2008. When he was home for Christmas in 2011, we were talking about his laptop, and he told me that the Logos Bible software ran sluggishly on that laptop. He said something about how, for reasons unknown to him, the current version of Logos required advanced graphics capabilities (I forget exactly how he phrased it, but he had learned that the slowness had something to do with graphics). Bear in mind, this is software that basically just displays text, presumably with some editing for adding notes and such. At the time, I just bought him another laptop.
A few years later, I happened to read that Logos version 4 was built on WPF. Then, remembering my brother, I found this Logos forum thread:
https://community.logos.com/discussion/6200
This shows that Logos users were discussing the performance of Logos on machines with different graphics hardware. For a program that was all about displaying and editing text, it shouldn't have mattered. WPF had made a bet on then-advanced graphics hardware for reasonable performance, and that was bad for these users. And that's just the one example I know about.
How did MS actually implemented it though? After a few messages the chat is blocked because MS did not choose to walk the extra mile and maybe compact the context so that their product can be actually usable.
Of course OpenAI, Perplexity and others later implemented that properly and its integral part of modern AI chat and I actually ditched Google for the most part. Had Microsoft done it, they might have had a shot in replacing Google and maybe becoming the AI Chat provider. But no, Microsoft can't have a well thought UI to provide a delightful UX.
IMHO it's a culture thing. Lack of cohesion is a result of it, I used to be annoyed by Apple that doesn't allow to ship its own UI libraries together with the app so to support old versions etc. but Apple had it right, thanks to the limitations UI is coherent.
You can just render on a canvas like flutter and KMP. Most end users don't care
Apple solved this by treating the design system as the product and letting the framework be invisible. Microsoft has it backwards every time.
1) They abandoned their mobile phone, tablet, and wearable strategy. So, today if you develop a native Windows application, it will only work on desktops and laptops. That is it. It is not attractive for a developer to learn a whole new UI framework just to target a single form factor. And I don't know if there is any solution for this at this point, they shouldn't have completely abandoned those markets.
2) They did not back 1 UI framework for a long time (I mean 10 years+), instead they did significant changes to their UI framework strategy every 3-4 years. It takes a huge time for developers to trust, learn and develop complex and polished apps in a UI framework. Also it takes a long time for a UI framework to become mature. If you change your UI strategy every few years, you will never have complex and polished apps written with it.
To be honest I am not sure if Windows will ever be able to recover in the long term and keep its market share. The only reason it seems to be alive is because enterprise runs on Windows and it is hard to change that.
I feel like an Apple + Google dominance will be more likely in the long term for desktop operating systems. I am not sure if Google will be able to avoid the first mistake I wrote above but they are working on bringing Android to desktop. It is a good idea but it requires at least 10 years of supporting and polishing it despite not getting much traction. But if Google persists, we might be all using MacOS and Android on desktop 20 years from now.
Microsoft has bought into ‘make a web app’ since 1988, they introduced AJAX, they got flexbox and grid into CSS and numerous HTML 5 features to support application UIs. They ‘frikin bought npm!. I use Windows every day but I almost exclusively develop cross-platform systems based on the WWW, Java, Python, etc. Whenever I have developed with .NET it has been for a cross-platform front-end like Silverlight or Unity/itch.io.
I can’t say I have a desire to make a native Windows GUI app when I could make a web app: like if it worth doing from my computer isn’t it worth doing it on my iPad from anywhere with Tailscale? For all the complaints about modern JavaScript it gives you the pieces to make a very pleasant world in terms of DX and UX and you certainly don’t need to ship an Electron runtime for many applications.
They had something reasonably good in WinRT. They should have stuck to that. But Nadella came in, said Azure Cloud is the future and abandoned the Windows platform.
It's 2026. We're running 8+ cores and 32gb ram as standard. We can run super realistic video games at high frame-rates.
Yet on the same machine, resizing a window with rectangles in it is laggy on every platform except macOS (where there's a chance it's not laggy).
Fortunately Rails was taking off at that point so it was fairly easy to change horses and just ignore it.
I don't see the reason to use any of the new ms ui frameworks. Especially if ms themselves don't even really use them.
As far as I know visual studio is still a WPF project so I'm not super worried about it no longer working.
Win32 -> message loops & GDI
Winforms -> managed C# via P/Invoke
WPF -> throwse all away and uses DirectX
UWP -> Appcontainer sandboxing
WinUI -> decouples from OS entirely
This visual breakdown helped me to see it clearly - https://vectree.io/c/evolution-of-windows-gui-frameworks-fro...
I never understood.NET's purpose. What problem it exactly went out to solve? Did Microsoft want developers to be able to run their applications everywhere too? Absolutely not.
Sidenote - MFC is the ugliest thing you'll see. Yet they didn't mention another piece of work called ATL. Active Template Library.
WinForms were really decent and that was enough. Keep Win32 API and a managed wrapper around it as WinForms and that would have been more than enough.
.
(This isn't even a joke. Assuming you're not going Electron.)
Part of the reason here is that it's their main business. They can't afford letting it languish and/or changing direction every 6 months.
That's fine, except no platform answers this.
Obviously Linux doesn't, but the Mac doesn't either. Apple of course has it's recommendation, but most developers do not take Apple's recommended path because of course, it's Apple-only, most developers make cross-platform apps these days.
Even if Microsoft decreed the one-and-one Windows development path, most developers are not taking that path.
It used to be the case that Mac developers used Apple tools, Windows developers used Microsoft tools, but those days are gone. Developers want to use Electron, or Qt, or some other system to support multiple platforms in one codebase.
Microsoft has less to do with this than the article makes out. I'm a desktop developer. I don't care what Microsoft recommends, or what Apple recommends, because neither work in the real world where supporting only their platform just isn't realistic.
But I gather from your comment that you don't actually care to ask that question, since you have a different need, and already have a solution which works for you. Which I guess is fine if you're happy with the compromise.
But this is about people who actually still care to have "native" applications.
I am a desktop app "believer" I like desktop apps, I like native desktop apps, but I also have to make software that makes economic sense, and following Apple's guidelines just doesn't make any sense for me, and a lot of other companies too.
- windows forms in .net
- flutter
All the rest always presents itself with a sheer aura of "It was a great idea but we couldn't finish it".
Without ever discussing with anyone from MS about it, I think they stopped improving/working on this because of electron.
Any web developer can build a good enough website and a good enough desktop app with electron.
Invested in it, shipped it, seen it solve the cross-platform problem beautifully.
Can just write C++, and see it running everywhere.
The JUCE GUI capabilities are more than adequate for many, many things.
There are other platform-scaffolded cross-platform frameworks. JUCE is cromulantly FNORD.
A few years ago, I wanted to prototype something quick and I wrote it in Windows Forms over C# (all code, no visual editor).
Apparently, you do too, since what you said is basically the same as what the article said (.NET wrapper for C#, fastest prototyping to date)
It wasn’t all roses though, the high dpi support was atrocious.
I know it’s not a popular opinion, and I am sure there were reasons Microsoft abandoned it, but that was a brief few years when I actually enjoyed building GUIs on Windows.
EDIT: just dug out a "memory magic" winforms app I wrote sometime in the early 2000's and ran it no problem, no weird looking non-native UI or long electron startup...
Most embarrassing failure in the company’s history that far.
Er… The author perhaps never used it? WPF was the worst framework I ever used. It was unbearably verbose, brutally unforgiving, used 2-way bindings that created updating nightmares, ans not the least it was incredibly slow.
WinForms was not the best for sure, but at least you can get stuff done. It was for a long time the right answer to the question the author asked. .Net + WinForms worked well.
When WPF shipped was when the shit hit the fan.
This is the common thread of all their frameworks since, and in my mind the reason they are stuck in an absolute quagmire. For a while it was possible to use HTML/JS in UWP (I think), but it didn't stick due to everyone already needing to move over their LOB apps with crazy amounts of XAML so that's what the focus was on.
"Hey, let's make something that's vaguely HTML but not really at all."
Big mistake.
Avalonia and Uno are repeating that mistake, even though with Uno, at least, there's a blessed way to do unidirectional data flow/reactive stuff.
Two-way data binding is the devil.
Fast forward to now, and KDE Plasma is state of the art Linux desktop that I've been daily driving for years. It's also built on Qt.
It is a fantastic book, I learned everything I know on Win32 from it. Wrote real time scientific software in windows for ~10y! We did it all, external hardware control, custom UIs, etc. Thanks Ryan Geiss for your timing info.
Right about VC6 was the sweet spot imo, C/C++ with lightning fast UI for docs and more. Tools got out of the way. Once other languages got involved (C#?) the docs got out of control and harder to use, and the UI started to get a little overloaded.
The snappiness of those old windows systems was pretty great.
It's ok. I give it pretty high marks. There is a good deal of "lowest common denominator" in it, naturally due to cross platform abstraction. But, it's generally nice, and commercial licenses are affordable.
Thankfully I have been mostly insulated from it by sticking to Qt and C++ for the last 25 years.
OTOH WPF is today surprisingly strong GUI platform if you just want to get your Windows GUI out there.
It runs really nicely even on low end hardware. All the nice styling and blending techniques now _just work_ even on the most cheap low end laptop.
The fact it's over decade old means all the LLM:s actually know really well how to use it.
So you can just guide your LLM to follow Microsoft best practices on logic development and styling and "just add this button here, this button here, add this styling here" etc.
It's the least annoying GUI development experience I've ever had (as a dev, non-designer).
Of course not portable out of the box (avalonia is then the ticket there).
If you want 3D, you can just plug in OpenTK with OpenGL 3.3. Decades old _but good enough for almost everything_ if you are not writing a high perf game.
Really, WPF plus OpenTK is a really robust and non-surprising development platform that runs from old laptops (eg. T14 Gen 2 per my testing) onwards.
I've been doing a sideproject using WPF and OpenTK - .net works really great - here is a sample video of the whole stack (from adashape.com)
I recall wasting a lot of time staring at decompiled .NET bytecode trying to understand how to work around many problems with it, and it was clear from the decompiler output that WPF's architecture was awful...
But if you read books from the 2000s, there was much discussion about the performance overhead of a VM and garbage collected language; something like WinForms was considered the bloated lazy option.
I’m sure in a few years computers will catch up (IMO they did a while ago actually) and Electron will be normal and some new alternative will be the the bloated option - maybe LLMs generating the UI on the fly à la the abomination Google was showing off recently?
FWIW Apple has made a similar transition recently from the relatively efficient AppKit/UIKit to the bloated dog that is SwiftUI.
[1] - https://arstechnica.com/gadgets/2008/03/the-vista-capable-de...
Can't find the original blog post about it but here's a couple mentions of it:
- https://www.edandersen.com/p/evernote-has-no-patience-drops-...
- https://www.reddit.com/r/csharp/comments/x0nu7h/comment/im9k...
Fortunately for me, I had mostly switched to Linux by that time already, where it was at the time relatively easy to just enable grey scale AA with full hinting.
In recent years this has gotten worse again with modern software incorrectly assuming everyone has a High DPI monitor. My trick has been to use bitmap fonts with no AA, but that broke in recent versions of electron, where bitmap fonts are now rendered blurry. So I had to stay on an old version of vscode from last year, and I will be looking to switch to another editor (high time anyway for other reasons).
These were finally improved for WPF 4, since Visual Studio 2010 switched to it and had a near riot in the betas due to the poor rendering in the text editor.
Displaying text is surprisingly hard, as one can easily find out if ones dives into the big rabbit hole of font rendering.
But they just plain failed to execute well on this idea.
I really don't think that's the fundamental issue.
TFA points out, and I agree, that the fundamental issue is political: competing teams across different divisions coming up with different solutions to solve the same problem that are then all released and pushed in a confusing mishmash of messages.
I haven't written a line of code for a Windows desktop app or extension since early 2014, when the picture was already extremely confusing. I have no idea where I'd begin now.
My choice seems to be either a third party option (like Electron, which is an abomination for a "native" Windows app), or something from Microsoft that feels like it's already deprecated (in rhetoric if not in actuality).
It's a million miles from the in the box development experience of even the late zero years where the correct and current approach was still readily apparent and everything you needed to move forward with development was available from the moment you opened Visual Studio.
There's just so much friction nowadays, starting with the mental load of figuring out the most acceptable/least annoying/most likely still to be supported in 5 - 10 years tech to use for solving the problem.
All of people’s modern desktop woes begin and end at the browser. Here’s why: the late 2010’s push into the cloud made JavaScript all-the-rage. A language the creator made in pretty much a weekend coding session.
There naturally is major business incentives powering this. SaaS made things MUCH easier for delivering software.
Fast forward 15 years and MSFT is full in on TypeScript. It’s a disease that starts with MsOffice and percolates to the whole OS (same as what’s happening in copilot).
.Net is actually elegant in many ways. You have PowerShell, VB .Net, C#, F# etc. languages of many paradigms all targeting the same bytecode (and supported by the OS).
And this is being replace by a fun little JavaScript thingy.
Meanwhile in MacOS they dumb things down without a fallback.
The only people who appear to make serious attempts at improving the usability of computers are the likes of KDE and other Linux desktop environments. It used to be the way that Linux was the thing you used despite its shortcomings compared to commercial OSs..
What a laugh, do you want the examples on Apple's side?
Basically it's been Objective-C and Cocoa since around 2000, later on Swift and then also SwiftUI. That's not too bad for 25 years.
And in contrast to MS, you didn't get abandoned when you were sticking to the official frameworks. Quite contrary, you basically got the switches from PowerPC to x86 to ARM almost for free for example.
Apple is not perfect by any means, but in this regard I truly think they are ahead of Microsoft.
Even though Wine exists, Win32 calls can only be made from Win32 programs, not native Linux programs. So a WinForms app using the latest dotnet would need to run the Windows version of dotnet under Wine, and not use the Linux version of dotnet.
This comment written before Tahoe
Even if you take away subjective opinions on Liquid Glass, the point is that the core system updates things across the board.
Unless apps have implemented custom drawing, you get a consistent-ish UI (for better or worse) across the system, whereas with windows you are beholden to whatever hodge podge of UI frameworks were chosen at the given time.
What do I chose with Windows? Who knows. It literally changes every time I look into it.
That's just insane.
It's gotten so bad that probably the right way to do a modern windows desktop app is react native. At least you could predict that it will stay up to date with the ever shifting decisions at MS to create and abandon UI frameworks.
I will boldly claim Windows Forms is more stable than Gtk and Qt. Don't let random teams at Microsoft confuse you because they released yet another unrelated framework that you don't have to use. They are engineer-sirens trying to lure you from the true path. Let them pursue their promotions in peace while we rely on a stable workhorse.
They had great devices before iOS/Android and then again after. That Lumia phone was awesome. They had one of the best cameras. Their live tiles they had on the phone & desktop OS were really good. Even Windows 8 had a cool CRM app in its infancy that tried to link all your social media & email accounts together.
They killed all of that even with multiple chances to win people over. It seemed they wanted to win the new markets in less than a year.
For as much flack as Google gets for short lived awesome products, Microsoft is right up there. Which is why when they've announced new things like Blazor, MAUI, etc., no one expects them to live long enough to trust their apps on.
I also strongly question their enterprise MOAT when most kids are growing up on Apple & Google devices the past decade. Microsoft seems to lack long term strategy.
There aren't really that many apps that make sense to work in a full-fat form all the way from wearable to phone to tablet/laptop/desktop.
Tablet/Laptop/Desktop is probably solvable by a single toolkit set (remember the brief era of Windows 7/8 tablets, many of which had fold-back or snap-on keyboards and pointing devices if you needed precision beyond what a touchscreen could offer?) but I don't really want to run KiCAD on my phone or a smartwatch, for example.
Saying outright "we have different tooling for big and small devices" (or even three sets-- large device/handheld/wearable) should steer developers into providing tools built to the task and purpose. Maybe the phone/wearable version only has limited tools that work well on a tiny screen and is as a result smaller and more efficient?
They were way too late to make a dent. Ballmer made the mistake when the iPhone came out to not get their ass in gear to compete. Microsoft's first potential real competitor to the iPhone came with Windows Phone 7 at the very end of 2010. The iPhone was announced in January 2007 and they didn't have anything to compete until almost 4 years later. I'm not sure how they could have recovered from that by the time they gave up on Windows Phone/Mobile in 2017. Anyone who worked in mobile sales at that time knew most people who did buy a Windows Phone ended up returning it when they realized none of their apps were there. They could have had apps if they recognized the iPhone's threat earlier and reacted appropriately.
Also worth mentioning that in their time competing for mobile they did a fairly hard reset of the platform 2 more times for Windows Phone 8 and Windows 10 Mobile. Go find what developers who tried to keep up have to say
Then they acquired Nokia that already had an almost-ready ecosystem of apps, with good snappy UI. And then spent two years building a (shitty) framework on top of the long-neglected Windows CE kernel. Which was known from the start to be a stopgap solution before they port the full WinNT kernel.
MS ended up where it was at because there was basically NO upgrade path between the few different GUI frameworks they had. They broke the whole thing in 2002 when they decided .NET was the way.
You had to basically retool your whole GUI for whatever they were pushing at the time. Then they basically abandoned win32 GUI items and put them in mothballs. Then change their minds every other year.
No sane person is going to pick that model of building an application. So the applications kinda stagnated at whatever GUI level they came into being with. No one wanted to touch it. If I am doing that why am I sticking with windows? I can get the same terrible effect on the web/mobile and have a better reach.
Even their flagship application windows is all over the place. If you click on the right thing you can get GUI's that date back to windows95. Or maybe you might get a whitespaced out latest design. It is all over the place. It has been 10 years at this point. They should have that dialed in years ago.
I do not think Google will be able to pay attention long enough to have a stable GUI. Apple maybe. As for MS you can see it from the outside there are several different competing groups all failing at it.
MS needs another 'service pack 2' moment. Where they focus on cleaning up the mess they have. Clean up the GUI. Fix the speed items. Fixup the out of the box experience (should not take 4gig of used memory just to start up). Clean up the mountain of weird bug quirks.
I'm a developer who has built and published several apps. I want the biggest possible audience for those apps. Why would I limit those apps to Windows? (Or even to any single platform/OS?)
Web apps work everywhere. The web has grown increasingly powerful and capable. Why would I invest in a technology that can only run on a single OS? Doesn't make sense.
Just build for the web. You can package web apps for all the major app stores using PWABuilder[0], no Electron needed. Just fast, lightweight apps distributed by app stores and accessible from the web.
[0]: https://pwabuilder.com. Disclaimer: I work on this
For me, I see these following advantages:
- Performance; Native & compiled is king.
- Ram usage; Kilobytes vs Mega(giga?)bytes.
- UI control which integrates with the rest of the OS (and updates when the underlying OS tweaks the UI)
From a business standpoint, I get your point that these points don't really matter. Users have shown to not care in the slightest at the bloat in programs.
However for code I write in my spare time, I would much rather write my native Linux program in compiled code than to ship a subpar experience to the few who will interact with it.
You mean the hypertext platform that has been shoehorned into Java's paradigm, suffering from the same boof-o-rama as Windows, and whose lowest common denominator to support must be Safari for iOS?
There are other options besides "web app" and "only one OS". A cross platform app which uses something like GTK or QT will be a massively better experience for your users, one a web app cannot hope to equal.
Why write an anything-specific app?
On the web if I want to publish a web app... I publish the app. If Apple things my app isn't good for their business... tough luck for them.
If I want to update a web app... I update the app.
If a user wants to use an app... They visit a URL and the app is there! No having to face id, go looking for the app in an interface that's designed to hide the search function, that is filled with spammy trash imitation apps (that somehow get approved by the app store anyway)
All the time I hear somebody crying that their developer account got canceled and I want to say "what did you expect? the contract for a developer account is a suicide pact for your business." Stay free!
[1]: https://learn.microsoft.com/en-us/previous-versions/ms536495...
There is no such thing as pleasant UX in a web app. The best experience will always be a native app, a web app is at best a port in a storm solution.
When MacOS wants to nag you it pops up a Liquid Glass vandalized version of the 1999 retread of the modal confirm dialog from the 1984 MacOS.
I wish both of them had NEVER OPEN A MODAL DIALOG THAT I DIDN'T ASK FOR EVER AGAIN button that took 80% of the space and a tiny little greyed-out link at the bottom that said "maybe just maybe I want to hear about this in three years" but from a graphic art viewpoint I laugh at MacOS.
Nonsense. The best experience is the one that solves user’s issue. Technology choice is orthogonal to that.
Microsoft used to be the Windows company (after being the BASIC company, then the DOS company). Then it became the Office company. Now it’s SharePoint and Office365 and Azure, a utility. Windows is a relatively small part. Office is both desktop and web (and spacecraft, where they have two versions of Outlook and none of them works). If you are confused at this point, so am I. There is no vision as to what Microsoft is. If Satya Nadella knows what Microsoft is, he isn’t communicating it properly. It’s not Azure, because there is also Office and Windows. And on-prem server products. And a line of hardware products. And stores (do they still exist?).
MS has always been a software application company. Windows was never anything more than a way to sell MS applications--and Windows 3.0 and later wouldn't even have existed in the first place if IBM hadn't dawdled so long over OS/2. Even in the MS-DOS days, when MS was reaping the benefits of IBM's previous bonehead decision to hand the PC OS market to them, MS was selling Office applications--on the Macintosh.
The basic Windows API, in all of its many incarnations, has always been a second-class citizen; MS Office applications have always done their own things that other Windows applications couldn't do without using undocumented features that MS could change at any time (and often did). One could argue that the only reason MS even allowed third-party Windows developers to exist was so that they would, in the words of one of PG's essays, do market research for MS. When a third-party dev came up with something that got enough traction, MS would simply incorporate it into their apps.
IMO Microsoft's best long-lived products have always been both finished solutions to your problems and platforms to help you develop more solutions, and Microsoft leadership has always recognized this. Examples: Windows. Office. Dynamics (their Salesforce competitor).
But even if a product doesn't meet that "why not both?" ideal, there is always going to be room for it at Microsoft, as long as it is not only a good or at least mediocre product by itself, but also works to sell you on the whole Microsoft ecosystem. Sometimes that is a bad thing (see all the Windows adware for Bing, Copilot, and M365). But that at least is where Microsoft remains consistent.
I still don't understand why the windows store search sucked so badly. It isn't like they had billions of apps. So why did it suck?
But then they rioted internally to kill C++/CX (the only time they had something comparable to C++ Builder), Project Reunion got announced and misused from the original goal, porting WinRT back into Win32 killed .NET Native as well, most of the key team members left to Amazon and Google, Azure or AI teams, the team is now mostly interns or juniors from Microsoft India, no direction, and is a mess, naturally.
I went from a WinRT advocate, to pointing out devs to stay away from it, this is how bad they treated those that actually believed WinRT could be it.
Painful and nonsensical from a desktop standpoint but also kind of impressive in a way.
I would not be surprised if you still cannot launch a fricking .exe.
Another example is startup time. Time to first frame on screen should be less than 20ms. That doesn't mean time until first content is rendered, but time until _all_ content is rendered (loading dialogs, placeholders, etc are better than nothing but entirely miss the point of being fast).
The second example is why even though I understand why developers pick tauri/electron/webviews/etc I can't get over how fucking slow the startup time is for my own work. None of them could show a blank window in under a second the last time I tried.
They range from old laptops to a Ryzen 7 9800X3D workstation.
Just yesterday a friend's father needed help setting up their second-hand old laptop with an old i5 processor. I slapped KDE and there was no lag to be seen.
Bonus point that Windows and some Linux distros have sane, intuitive window management. Whereas with macOS I keep seeing someone suggesting some arcane combination of steps to do some basic things with replies to the effect of "OMG thank you so much, this needs to be known by more people!!!"
On MacOS, meanwhile, Finder refuses to update any major changes done via CLI operations without a full Finder restart and the search indexing is currently broken, after prior versions of Ventura where stable functionality wise. I am however firm that Liquid Glass is a misstep and more made by the Figma crowd then actual UX experts. It is supposed to look good in static screenshots rather than have any UX advantage or purpose compared to e.g skeuomorphism.
If I may be a bit snarky, I’d advise anyone who does not see the window corner inconsistencies on current MacOS or the appealing lag on Windows 11 to seek an Ophthalmologist right away…
KDE and Gnome are the only projects that are still purely UX focused, though preferences can make one far more appealing than the other.
But most nontrivial apps can't re-layout at 60fps (or 30fps even).
They either solve it by (A) allowing the window to resize faster than the content, leaving coloured bars when enlarging [electron], or (B) stuttering or dropping frames when resizing.
A pleasant exception to this I've noticed is GTK4/Adwaita on GNOME. Nautilus, for me at least, resizes at 60fps, even when in a folder of thumbnails.
On the Mac side, AppKit, especially with manual `layoutSubviews` math easily hits 60fps too. Yes it was more complex, but you had to do it and it was FAST.
I am also baffled by the multiple control points. I can log in to mail in 3 places. Settings have 3 with different uis....it is gross.
In the ideal world, Win32 applications would have automatically run in a sandboxed WinRT environment with granular permissions. A program thinks it's accessing a USB webcam, but it is actually accessing a Win32 shim that goes to the WinRT that first prompts the user to obtain the necessary permission and then goes to the real Win32 USB API to interface with the camera. A program is trying to access a file that hasn't been selected in the "Open file" dialog or dragged into it or passed as a command line argument? Raise a "malicious access" warning.
Overly complicated programs like antiviruses would have been able to get a "hall pass", either by registering their builds with Microsoft or asking for an administrator-level exception.
Of course, this would've been terribly hard to implement. Doing it natively would be supremely complicated, much harder than just designing a whole new userland API like WinRT. And sandboxing every application in something similar to Sandboxie would've been too taxing on the PCs from that time.
I was in DevDiv during his great WinRT push and the overall feeling I remember was that the guys in Windows had zero clue as to what the devs actually wanted, but were hell bent on scorching all the ground that wasn't theirs. My team actually did some prototyping for Python/WinRT support, and we had it working to the point of the visual WPF designer in Visual Studio even. Unlike JS, it was full fledged - you could use anything in WinRT same as C#, extend classes etc, while JS limited you to a "consumer" surface of the API. That prototype was killed because Windows (i.e. at the time = Sinofsky) said they didn't think developers cared about anything but JS so they didn't need another high level language.
It was also when Windows was aggressively pushing their Metro styling on everything in the company, sometimes to ridiculous lengths - e.g. Visual Studio at the time "aligned" with Metro by, I kid you not, making the main menu bar ALL UPPER CASE so that it looked like Metro tabs! You can still see the blog posts announcing this "feature" when it shipped in the first public beta of VS 2012, and the comments on them.
And then there was Windows RT (not to be confused with WinRT, because Microsoft product naming!). Aka the Windows-on-ARM that ditched decades of backwards compatibility because Sinofsky decided that rebooting the ecosystem is the only way to compete with iPad or whatever. What actually happened was that the users went WTF because none of their native apps - which, contrary to his take, were very much alive and kicking! - worked there, and devs went WTF because they were told that they'd need to rewrite everything yet again in some new thing that was kinda sorta but not quite like WPF, because Windows just hated .NET that much and couldn't accept that the devs liked it over their stuff. So the app store was a barren waste, and without apps there would be no users.
Some of the technical details in there are plain wrong, too. For instance, .NET 3.0 actually shipped in Vista, contrary to his claim that it was shipped in Win7 (and that it was the first time .NET shipped in consumer Windows - in fact, that would be .NET 1.1 shipping in WinXP SP1).
Yeah, he's talking about WinForms like it was a whole new thing, but it was a very transparent OO layer over Win32 and extremely similar both to VB and Borland Delphi. It was one of the reasons why .NET survived at all when Linux servers became the default option.
Also, Windows division is shipping a subpar product now.
In a sane world developer division and Windows division would think things together, developer division would produce the tools and the same tools would be used by Windows, other Microsoft products such as Office and third party developers.
Why that doesn't happen at Microsoft, I don't understand.
And I don't understand why Nadella doesn't do anything about it.
I think you're being a bit unfair to the Windows division during the Win8 lifecycle. Maybe that's just my rose-tinted glasses though. I know there are some HN/proggit commenters who like to harp on the supposed toxic rivalry between the Windows orgs and Microsoft developer tools orgs and how it has made Windows' developer platform much worse over the years, but I have always thought we had a better relationship than that, since my group's product was the main reason for yours for many years, and your group delivered so much for us in turn. Clearly your side had at least some reason to see things differently. On behalf of all of us, yes even up to stevesi, I'm sorry.
Now let me completely undermine my apology by nitpicking your comment :)
[continued in my replies to this comment]
I think one of his main points is server .net was (and is) great.
But the UI part of it was cloudy.
I see it as complimentary to the post not contradicting it.
I remember that. Especially silly.
> Windows RT (not to be confused with WinRT, because Microsoft product naming!)
The gold standard will always be "Xbox one series X", designed to be confused with Xbox one series S.
Windows RT had one other anti-consumer and anti-developer feature: it was locked down like a Chromebook, so you could only use Store apps on it.
Targeting the broadest possible variant of x86-64 limits you to SSE2, which is really not very capable outside of fairly basic float32 linear algebra. Great for video games, but not much else.
Also keep in mind that .NET originated right at the cusp of x86-64, which again is a whole different architecture from its 32-bit predecessor. Most native apps used to ship separate binaries for years.
And of course, I think Microsoft was aware of their intrinsic dependency on other companies, especially Intel. I can see how the promise of independence was and is enticing. They also weren't interested in another dependency on Sun/Oracle/whoever maintains Java at the moment. While Windows on ARM64 is still in a weird spot, things like .NET are useful in that transition.
Lastly, the CLR is different from the JVM in a number of interesting ways. The desktop experience with the JVM is not great, and Java is a very bad language. It makes sense to do your own thing if you're Microsoft or Apple.
Additionally, such applications that want to exploit certain underlying processor's instruction set have no way to do so without detecting CPUID and landing into so called "unmanaged code" because .NET is all about very high level IR that even has object oriented features as well.
So .. initially it was "Microsoft Java", a managed language with tight integration into the Windows APIs, and non-portable. That was .NET Framework. A while ago they realized that even Microsoft didn't want to be tied to one platform, and moved to the cross-platform ".NET Core". It now occupies a similar role to Java but is IMO nicer.
Java. Java is the problem .NET attempted to solve.
Ugh that brings back bad memories. I remember it was supposed to be the answer to MFC. I did an internship where my boss wanted me to use it. It was very painful because it had basically no documentation at all.
It means "To obsolete a unique feature in third-party software by introducing a similar or identical feature to the OS or a first-party program/app." The term stems from Apple's 2002 release of Sherlock 3, which made a popular third-party app named "Watson" irrelevant.
I'm already very familiar with JUCE in VST plugins, I have hundreds of VSTs made with JUCE and I love their UIs. But I don't think I've ever seen it for a standalone business application?
The JUCE pricing is certainly far more reasonable than Qt.
You can configure your JUCE project to build to any of the standard audio plugin formats, or for it to build a standalone app for the target platform (i.e. plugins, desktop, mobile, embedded) or indeed to build all of these targets, at once, in one build.
However, during app (i.e. non-plugin) development I often switch between linux and macos environments as part of my workflow, and during testing after I've pushed to the proper branch, the build server plops out the .exe/.pkg/.app/.tar.gz bundles as needed for the test group to crack at it.
JUCE, being at heart a C++ framework intended to be the engine of a very diverse swath of different OS, plugin, and packaging standards, does all the glue to get you there - how you use it, is up to you. (All of this can happen in github actions, btw, really easy to set up..)
Yes, there are 'business'/'productivity' UI elements in JUCE app targets, and yes they are consistent across all platforms. And yes, you can for example build a UI from an .xml form, with cross-platform datastore and so on, easily enough.
Here's a nice place to start, if you wanna understand JUCE capabilities from a 'productivity'-app perspective:
https://www.youtube.com/watch?v=3IaMjH5lBEY
David Rowland, a core JUCE developer, explaining the guts of things.
Basically, the scope is high performance applications, and there are no really good reasons for why a high performance application cannot also be a productivity app - the distinction is arbitrary - except of course you ask, for the GUI!
But: JUCE' GUI is pretty darn good, I have to say, in face of the onslaught of platform vendor fuckery. You can embed a WebView if you really need it, and wire it up to the rest of the cross-platform event handing system, etc. But I think its not really needed, given the plethora of 'normal' UI controls, out of the box.
If you're serious about looking at JUCE for a variety of application types, then a lot of the questions you're going to have about JUCE' GUI suitability for standalone business applications can be answered by running the DemoRunner application that's built-in to the JUCE codebase.
Clone the repo, build the DemoRunner project for your platform (or all of them), and you'll see - there are plenty of business-like cross-platform UI elements in the kitty. A huge collection of business-/productivity- like UI elements, right out of the box. (High-performance plugin UI's are there with the business UI stuff, too.)
And .. once you've marvelled at the glory of DemoRunner(.exe,.app,.apk)[etc.] .. please do yourself a favour and spend an extra hour parsing the awesome-juce list:
https://github.com/sudara/awesome-juce/
JUCE is marvelous, and awesome-juce is awesome.
If sliders are vertical in the real world, there’s a reason for it that Bruce “Tog” Tognazzini summarizes perfectly:
“Most of us […] have our forarms mounted on a pivot we like to call our elbow. That means that moving our hand describes an arc, rather than a straight line. Demanding that pivoted people move a mouse pointer along in a straight line horizontally is just wrong.”
Source: https://www.asktog.com/columns/022DesignedToGiveFitts.html
1) VB7 (VB.NET) entirely split the VB developer community.
2) VB6 IDE has not worked well and is entirely unsupported in every Windows after XP. It's generally recommend to build VB6 apps in an XP VM and XP being out of security support it's now a huge "Use at your own risk" and "Do your best to isolate the VM from ever having an internet connection". (Not to mention that installers like Install Shield that still understand VB6' super messy version of COM are generally also out of support and security support.)
It was alleged that Microsoft almost dropped the runtime components for VB6 in Windows 11. It starts to feel like only a matter of time before they do.
It's just that it's a piece of tech from back when Microsoft corporate dominance on the desktop was at its peak, and many large companies bought into the then-current tech stack, including VB6. So now Microsoft is stuck maintaining it because those are the customers that bring consistent revenue.
I would agree it should have degraded much more gracefully and more readily than it did, but I'm quite confident we hadn't hit the point of minimal returns on improvements in hardware that would be necessary for such an argument yet.
Hell, I probably wouldn't make that argument until large amounts of RAM and VRAM (or unified RAM) are ubiquitous, because so many workloads degrade so badly with too little of either.
I have one application at work that loads a table with 40,000 rows into a data grid that works really well on Chrome and lags on Firefox, that's the one case where the performance difference matters.
This year I've been interested in biosignals applications that read data with the Web Bluetooth API and Web Serial API which are ordinarily Chrome-only. I was about to get one of my junk Android tablets out of mothballs when I found there is Bluefy for iOS which supports the Bluetooth API so I have no problem going to labs where they have a really klunky HRV system based on a PC and show them something sleek on my iPad and in 20 minutes i can demonstrate to you, with your own physiology, everything you actually need to know out of a big review paper on HRV.
[1] https://faithlife.codes/blog/2019/06/improving-wpf-text-disp...
That's the problem.
And what makes matters worse is because of all the shifts, the documentation throughout MS is in just varying states of outdated. For example, this document which recommends using UWP [1] to handle high dpi problems. But of course, UWP (which was the right way to do gui in Win 10) is now defunct for win ui.
[1] https://learn.microsoft.com/en-us/windows/win32/hidpi/high-d...
Btw Linux UI is not by any measure stable. It is the furthest thing from stable.
The biggest disappointment has been that all new OS features require a new runtime and are not accessible from just pure Win32 any more. Heck the pipeline for developing UWP/WinUI3 apps requires extra steps to register and install the application just to run it inside a debugger.
That was such an amazing mission statement. It was a real measurable goal, and progress towards it was quantifiable. And Microsoft actually did it! That mission statement drove actual strategies (lower costs, don't complete with Apple on the high end, force OEMs to compete against each other on price, etc) that resulted in its ultimate fulfillment.
Windows CE/Mobile was heavily shaped by the corporate presence. People didn't queue up at midnight at Best Buy to buy CE devices, they were sent down from IT and ran a handful of bespoke line-of-business apps. People associated them with big clunky barcode scanner devices, not sleek hi-fi media players. It had all the consumer charm of a corporate lanyard and ID badge.
I'm not sure they could have respun the existing product to get that to "sexy consumer facing item" without a huge rework anyway. And the rework was excellent-- I liked Windows Phone enough to own 3 (a Lumia 1020, then replacing it with a 530 after the screen broke, and a bargain 640 as a modest upgrade) The experience was smooth even on the bottom-range device and it felt more holistically designed than contemporary Android.
The problem microsoft has is instead of making "Win32, but with these extentions or these APIs removed", heck even as a separate "framework". What they did instead was "You know what's hot right now? XML. So let's make an XML based UI framework. Actually, it's javascript and css, so let's do that. Actually, people really like electron so let's do that."
That is to say, it is possible and I dare say easy to migrate an application from GTK 3 to GTK 4. It's basically impossible to migrate a WPF app to UWP. You have to rewrite the whole thing.
Its income? Around $500 a month.
Linux is a mess, but at least it's unapologetically so.
The fact that there are multiple platforms for UIs* is a huge failure of the industry as a whole. Apple, Microsoft and Google could have had a sit down together at any point in the last 20+ years to push some kind of standard, but they decided not to in order to protect their gardens.
*: a standardized UI platform doesn't necessarily mean a standardized platform. Just standardization of UI-related APIs and drawing.
Nothing beats Windows 11+WSL2; literally the best of both worlds.
Actually what does "surprisingly smooth" mean? Better than you expected? Or actually smooth?
To satisfy my interest, I've tried creating WinUI app (aka UWP/WinRT) in Visual Studio 2026. And this is what I've got on the first app launch after compilation:
"This device needs to be set up correctly to develop this type of app for Windows. If you don't, then you can't install and test your app before you submit it to Windows Store"
I don't want to install/submit, I just want to be able to run my fricking .exe. Period.
So why are you calling this issue solved? To me, it's still right there in the plain sight - the same voodoo dances and delusional expectations of subordination to Windows Store.
That was at least in part due to the aforementioned obsession with iPad and generally mobile. One thing that Sinofsky is not wrong about in his post is that the classic Win32 app model is not conductive to good battery life - there's very little there to properly handle things like automatic background suspension or low-power push notifications. WinRT was designed with that in mind, but that would make no difference if the apps would just ignore it, hence the heavy-handed push for WinRT apps only (AFAIR it wasn't restricted to Store, although you had to jump through some "developer mode" hoops to deploy apps directly).
When I first started porting programs to Windows ARM64, I didn't have an ARM64 device and had to test in QEMU. It ran extremely slowly, probably 1/50th of real time. All UWP programs like Calculator ran like a slug. But which programs still ran reasonably? Classic WinDbg and Task Manager. Two programs that were still plain Win32.
There are significant issues with Win32, namely its lack of a permissions and isolation and lack of hardware acceleration in the old windowing UI (User/GDI). But the idea that Win32 is inherently power inefficient is, IMO, just BS. Its roots go back to CPUs that were orders of magnitude slower than modern CPUs and there is nothing difficult about making a Win32 program that idles at 0% CPU when not in use.
With WinForms, we actually got something that was convenient without shackling you. And the whole cross-language story was great, too, especially around .NET 2.0 - with C++/CLI you could very easily wrap any random native code C or C++ library for consumption from .NET, with end-to-end integration in the build system, IDE etc.
From the native code side, it was not so great. The .NET 2.0 CLR had very poor support for hosting from the native side and really wanted you to make a program that was .NET first, it didn't work well if you wanted something like primarily a C++ program that hosted a C# UI in the same process. Reverse P/Invoke via native exports wasn't exposed, so creating DLLs for consumption by non-.NET programs was difficult. Mixed mode debugging was and still is painful, with the debugger being glacially slow at some operations like OutputDebugString() processing and blocking some native features like data breakpoints, and the CLR eating access violation exceptions from native code so they couldn't be debugged properly. Build-mode wise, we had to ban C++/CLI assemblies depending on C# assemblies because the C# project system didn't handle incremental builds properly and forced the dependent C++ assembly to rebuild all the time.
These issues still largely exist and are an issue with WPF. It's a great UI framework, but it's unusable unless your front end is primarily a C# program.
But Qt has the bonus of also running on HaikuOS, and I've definitely seen more business apps in Qt (pretty sure 010 Editor is Qt).
The UI in Rowland's demo at 32min is feeling a little DearImGui / Reaper-ish, kinda bland while also being non-native. But I've seen all the UIs that Arturia & everyone else makes with JUCE, even what Valhalla does with it with their NASA inspired interfaces, so it can clearly make amazing stuff.
I can't believe we're now looking to PACE of all companies to help indie devs. I hated iLok for so long even though I have two iLok dongles now ;)
Which, I hope, you do.
(PS; - the default UI skin is, imho, intentionally a tad bland in order to promote developer uptake of JUCE' pretty amazing skinning/UIBehaviour system...)
It’s still dependent on the OS it runs on AND the SDK it compiles against (not the OS it was was compiled on).
But that is legacy bridging behaviour, and is not compiled into the app. Apple can and do change those with time.
For example apps that compile against macOS 15 are not opted into Liquid Glass when run on macOS 26 but will be once on macOS 27 according to their transition docs.
That doesn’t really negate the OPs point.
As a consumer I prefer Apples approach. If I were an industrial customer relying on old software to operate my machines i would prefer Microsoft’s approach.
Think about it: it transpiles to JavaScript. Even if it’s the most elegant language in the world doesn’t change the fact that it’s a world of bloat.
Stacks on stacks on stacks. And yet people are complaining about .Net? Come on. Lol
Remember we’re talking about GUIs. Typescript is great for the browser but it should stay there.
Now, JavaScript can be okay for example: Qt Quick/QML it works quite well in the desktop. But that’s purpose-built scripting.
The reboot of frameworks based in OpenGL with the Metal rewrite.
And many other things I am not bothering with since all those OS System N releases, A/UX UI framework, Teligent based documents,....
There are just more people encountering them because the developers are concentrated on using one thing.
It’s not perfect, but a compared to Microsoft, calling Apple out for having bugs is a little rich isn't it?
I pose to you, if the Microsoft offerings are so compelling, why are the serious players using 3rd party wrappers like QT and Avalonia?
It’s because the first party offerings are not compelling. They’re a disaster dumpster fire. And buggy.
My point was don't throw stones when having a big glass roof as well.
Apple isn't the perfection you make out to be, also has a rich history of failures, and only did not went bankrupt due to sheer luck of doing the right decision when there were not many remaining to take.
Neither are SwiftUI and AppKity.
But for sure they used WineLib.
Sure it is a hassle to get notifications working, but my take on that for years as a desktop user was "I need another source of spam about as much as I need to get raped". For years I had bottom of the line Android Tracfones and wondered "how is it people get so excited about apps?" because they just didn't work but once I got an iPhone I started to appreciate that the McDonald's app would send me a notification when my food was ready. Recently it was pointed out to me that the application behind these cards
https://mastodon.social/@UP8/116086491667959840
really would benefit from notifications ("your photos are ready!") and I am looking at the hurdles I can jump through and it looks possible but weird. Like why would I want people to install my app on the homescreen where it will get lost on page after page of twisty little app icons that all look alike?
Then there is that PWA boondoggle, there is another app in that system that I can use to register those cards and it is a clear case where I might want to do it outside of cell coverage (say I was in the woods) save a form submission and upload when I get back in range.
What can I say? That service worker system is insane, something like Kubernetes that only Google could subject us to. I mean, Google could have worked out the math for synchronizing a local database to a remote database, by then the Lotus Notes patents were mostly expired, we could have gotten something good. Or Google could have added an API to control the behavior of the browser cache. Instead we got something half baked and barely reliable and then Apple went out and made something a little bit worse. Had it been a good standard to begin with the outcome could have been entirely different.
Slack is, in fact, one of the worst offenders. It is so incredibly sluggish. And it doesn't need to be, when I compare it to the speed (and memory consumption) of Pidgin with the Slack plugin.
That is, uh, controversial.
Along both "alleged replacement" and "alleged superiority" axes.
Display PostScript did not have GPU acceleration, as far as I know.
https://en.wikipedia.org/wiki/Quartz_Compositor?#Quartz_Extr...
Back in the day there was a card called an S3 Virge, which we affectionally called a 3D decelerator card, because of its lacklustre 3D performance.
GPU-accelerated GUI usually refers to using the texture mapping capabilities of a 3D accelerator for "2D" GUI work.
It _still_ is not trivial to render high-quality 2D graphics on the GPU.
https://wiki.preterhuman.net/Apple_Macintosh_Display_Card_8-...
And he probably wonders why it is never "the year of the Linux desktop" but hey it is OK because Red Hat Linux is something enterprises subject their users to and if it had the slightest bit of flair customers would complain.
So when I hear GTK I think Nein Danke!
In general Linux has the kind of fanbois problem that MacOS had maybe 10 years ago. There are so many things that still "just don't work" after years and they never get fixed because you can live without them. For instance I can tell you how to install some package like
sudo apt-get install mypackage
[1] and you still might misunderstand it and need intensive tech support
This thread comes to mind: https://www.0xsid.com/blog/wont-download-your-app With Slack that’s trivial, Telegram impossible.
This can have a huge effect on a wide range of applications, not just those using particular CPU features. For example, each libc implementation typically has a separate implementation `memcpy()` for each set of CPU features.
https://devblogs.microsoft.com/dotnet/performance-improvemen...
To further argue your original point: chrome & electron are the only reason desktop is still around, both Microsoft and Apple tried their very hardest to build a walled garden of GUI frameworks, rejecting the very idea of compatibility, good design, and ease of use, until they were surpassed by the web, and particularly Google, showing that delivering functioning applications to a computer does not require gigantic widget libraries, outdated looks or complicated downloads & install processes, but is in fact nothing more than a bit of standardization and a couple MBs of text.
All this electron & web hate is so incredibly misplaced I don't even know where to begin. Have you tried making a cross platform mac/win native app? I have, its like being catapulted into the stone age, but you're asked to build a skyscraper.
It's quite possible that this attributes too much intentional strategy to MS, and also treats them as a single entity with a single strategy more than they deserve. The MS internal teams that were bending over backwards to maintain backwards compatibility were not the same as the teams that were churning out new APIs, building Azure, etc., and quite likely had very different incentives.
In the sense of being marketed as a single integrated package, yes, I agree. I was using the term loosely to refer to the apps themselves (Word & Excel were the first two, as you note, the others came after).
No. I want things like keyboard shortcuts to reflect the platform norms of where the app is running (macOS in my case). A shared core is fine, but the UI framework must be native to be acceptable. Ghostty is a "gold standard" there.
This is why most web apps are lowest-common-denominator annoyances that I will not use.
There are plenty of examples of cross-platform UI's surviving the hotkey dance and attaining user satisfaction. There are of course poor examples too, but that's a reflection of care, not effort.
Based on my experience, I would be quite reluctant to rely on any non-native cross-platform desktop UI framework that is not web-based. These tend to be either less performant, look outdated or are bug-ridden.
It is (1) performant (C++-based), (2) does not look outdated, and (3) not bug-ridden.
On Linux, Qt apps feel a bit off in GNOME, though you can never satisfy everyone as its the wild west.
I think Qt also suffers from not really being anyone's favourite.
On the one hand, you have web developers who tend to not really appreciate the nuance of the desktop as a platform. They're not going to advocate for Qt, it's not CSS/HTML/JS.
On the other hand, you have native Mac developers who love Apple's toolkits (AppKit, maybe SwiftUI). They're not going to advocate for Qt either.
Lastly, you have native Windows developers who have been burned so many times they don't advocate for anything in life anymore.
Developing UIs without hot reloading is too painful.
- Qt Widgets worked fine, but looked like a piece of software made in 2013;
- QML looks stylish and is a very nice language, but had a lot of weird bugs.
Neither of these are issues I'd run with if I were to make a web app.
I currently have open Chrome, Spotify, Discord, Aseprite, and Zed. All of them look completely different, and that's actively helpful for me, the user.
It's nice to follow the system's light/dark setting, and obviously the behavior of basic UI controls should be unsurprising, but beyond that there's no point in "consistency".
Who says the system theme is well designed at all? Back in the 1980s you could count on most text color combinations on a Commodore 64 or an IBM 3279 or a PC with a CGA working.
Today it is absolutely normal to type
ls
As a web developer it pisses me off because I am expected to follow
https://www.w3.org/WAI/standards-guidelines/wcag/
and regularly my management gets legalistic looking documents from customers complaining that we only have 6.5:1 contrast on something and you know what I do... I fix it. I wouldn't send anything to my tester that was unreadable and if I did I'd expect her to put in a ticket and I would... fix it. When MUI computes the coordinates wrong and something draws 20px right of where it should be... I fix it.
Whenever I've put similar tickets to the various parts of the Linux desktop mafia they close it as "won't fix" and often give me a helping of verbal abuse. Even Microsoft occasionally fixes something (even if half a decade late) and their people are polite.
for the dedicated more native stuff dioxus is kinda cool if you don't want a web stack in the mix.
i'm enjoying golang and wails though paired with whatever front end i want, all apps i've made perform execellent on windows. bottom line = yeah i can't really think of a scenario where i personally would ever write an app for windows specifically.
i, like you, used to get hung up on native vs web framework. i'd encourage you to give it a go, possible you cede that mayhaps the native thing isn't as important as you thought.
At the risk of getting my Microsoft history wrong, I'm fairly sure that Steven Sinofsky wasn't working on Windows or even MFC (i.e. what he did as one of you guys) in .NET's early days of 1999-2003. He was leading Office at that time. Office of that era was transitioning from the Windows XP look that still persists in Windows Forms to the early Ribbon, and was then (as now?) using very custom GUI code that didn't correspond to any specific higher-level Windows app framework.
Mac OS Office apps had just separated their codebase again from Windows apps after being unified in the mid-90s to get to feature parity (which annoyed Mac users who felt they now had non-native-feeling apps that were slow and bloated), and the "Office framework" was still quite distinct from any single-platform Windows app as a result of that.
So if Sinofsky did not understand why people went from USER/GDI to WinForms, that may just have been the fact that nobody working for him had felt the need to make that transition.
The fact that UWP XAML was its own new thing and not a extension of an existing Microsoft GUI app framework like WPF was not necessarily a "we hate managed code" thing, or even a "we hate those guys who invented managed code and want to screw them because we're Windows" thing. After all, .NET managed code had equal access to UWP through the .NET WinRT projection!
And to me at least (I didn't work on UI-facing stuff in Win8), it was absolutely conceivable that UWP could have just delivered Windows Phone 7 Silverlight's version of XAML to native code apps, with a thin adaptation layer to let even unmodified WP7 app binaries run on the desktop Windows .NET Framework with the WinRT projection and to allow slightly modified WP7 apps to look good in landscape mode on both Windows 8 and WP8. If we had done that instead of making UWP XAML its own thing, and if we had integrated the Windows Store with the Windows Phone Marketplace from the beginning so that Windows and Windows Phone apps could be sold as variants of each other through a single Store/Marketplace product entry on Windows 8 GA day, then I think we could have brought a lot of people forward who were already making good WP7 apps, and the Store wouldn't have been so empty.
Furthermore, IIRC much of the original UWP XAML implementation was done by the original people who built WPF and Silverlight the first time, and they would have known what they were doing in separating UWP XAML from Phone Silverlight. That they didn't go in the direction of extending Phone Silverlight was not necessarily shortsightedness on the part of provincial Windows people. Maybe they thought Phone Silverlight actually demonstrated fundamental limitations of WPF or Silverlight XAML or the Silverlight "coreCLR", or they wanted to make breaking changes as lessons learned from Phone Silverlight, which was put together about as hurriedly. (Windows Mobile 6 -> Windows Phone 7 first previews = 1.5 years; Windows 7 -> Windows 8 first previews = 1.5-2 years, tending toward 1.5 years if you account for the frantic re-planning after iPad came out in early 2010.)
It's important to remember the specific reasons why Windows RT 8 chose to not support third-party desktop apps. The most important aspect of "iPad compete" that we wanted on Windows for ARM was not "all app UXes look and work well on touchscreen tablets" but "you can't ship malware, not even by rebuilding your x86 malware from source." Thus, every 3rd party app on Windows RT would have to live in the AppContainer sandbox that UWP apps are in by default, and the requirement that you ship through the artist formerly known as the Windows Store would be a second line of defense against malicious apps. And with the forced-enabled Secure Boot, subverting the user-mode controls by secretly installing a bootkit would be hard even with physical access to the PC.
Even within the Microsoft world only, Windows Phone 7 had proven the success of this approach of locked-down apps only available through an app store that checked apps on submission and afterward for security. It was not unreasonable to think that similar lessons might also benefit users of "big" Windows, which is why Windows 10 and 11 have the opt-out "S mode" which defaults to the Windows RT restrictions.
I do wish though that Windows 8 had learned different lessons from WP7 (about which more in another point).
fair. but that struck me as strange even then. if anything, visual studio should have adopted the all-lowercase typography of the original metro-style design language from zune and windows phone 7, not AN ALL-UPPERCASE ONE.
Perhaps that was just another way that Windows 8 Metro-style apps' design and developer platform was like Windows Phone 7's Metro style, yet different in seemingly gratuitous ways. That is something I would attribute to internal Microsoft politics. Steven Sinofsky and Terry Myerson (leader of Windows Phone at that time) never really got along, and in the Microsoft philosophy of that era where engineering divisions were completely locked down from each other by default, that rivalry would have discouraged what little natural collaboration would have happened anyway.
Win7 Metro also had ALL CAPS in a few places, which is where I believe this was copied from since it was used there on the top of the screen, so where the menu bar is in a desktop app. The MSDN blog post that announced it also specifically cited Zune: https://devblogs.microsoft.com/visualstudio/a-design-with-al.... That said I have no idea why they actually did this, only that it was not a popular decision among devs working on VS at the time - so much so that they snuck in that registry key that'd let you disable it (I bet the management really appreciated that when they had to back out after overwhelmingly negative feedback). The monochrome icons were also unpopular on the team, but there was little they could do about that one.
I think the real mistake there was not so much that a particular projection of the Windows Runtime was stopped, but the more general idea that developers should be forced to consume what became known as the Universal Windows Platform or author custom WinRT components through only Microsoft-made WinRT projections.
In the name of winning over new or inexperienced Windows developers with "simpler, safer" projections, we in the Windows division almost completely failed for about 5 years to document or even explicitly say that WinRT was essentially just "COM: The Good Parts, Version 2012". (Martyn Lovell's Build talks on the origin of WinRT were a notable exception to this.) This discouraged people from using their existing COM skills to develop Metro-style/UWP apps or to gradually adopt features from UWP APIs that were accessible to them in their existing desktop apps. Other people have written that "WinRT=COM" thinking is actually a bad idea because it forces people to deal with COM and its more annoying ideas (separate IDL etc.); I disagree because we should have reached out to people who live in COM world to get a ready developer base.
That mistake was a key part of the still larger mistake you touched on of trying to make the UWP and desktop worlds 2 completely different developer platforms that happen to co-exist on the same desktop edition of the Windows OS. That was the key "we didn't listen to developers" mistake that set up UWP for its market failure. Another example: Even today, you can't adopt the battery-friendly UWP app lifecycle using Windows App SDK, which is supposed to be the UWP successor for desktop app developers. So much for WinAppSDK (or indeed UWP/Metro-style apps in Win8) enabling a true no-compromise user experience.
It took real tours-de-force like Kenny Kerr building C++/WinRT and blogging about it, Raymond Chen blogging about using WinRT APIs through the unprojected "ABI" interfaces, or the VideoLAN organization building a Win8/Win10 UWP version of VLC in C, to get the word out that the UWP world wasn't some alien thing with dark magic that only Microsoft wizards had full access to. And it doesn't help that the wizards really do have a few special powers that they jealously guard even now.
I'm the person who wrote this StackOverflow answer: https://stackoverflow.com/questions/7416826/how-does-windows...
You might note that I had to forcibly reiterate that, no, Win8 apps don't have to be written in HTML/JS, because people genuinely got that impression from what they saw at BUILD back then. It's not that the "COM 2.0" and the "this also works on .NET" parts were completely missing, but they (.NET especially!) were de-emphasized to the point where it genuinely created confusion and alarm among the developers. And, ss far as I can tell, this was entirely Sinofsky's idea, and one that he still refuses to admit was an epic failure.
Can you expand on this, because I'm not seeing it myself. The DOM, html+css is very flexible. It easily encompasses most UI. Most UI is some kind of data display, so lists, trees, tables, forms.
The need for JS might be what you're complaining about. I think we might be stuck with it as a UI control language forever.
Also with most GUI frameworks, there's some difference between widgets like label, button, menu, checkbox,... and containers that does layout management. And there are not a lot of elements in both sets. This is the reason why React Native has a very sparse components library. With simpler implementation, you have a simpler rendering path, and the developer have less elements to deal with.
Also some have ready-made implementation of really useful widgets, like tree, grids, tables, lists, and other dynamic things. You can find libraries for those on the web, but the web implementation of scrollable container is janky.
> Lastly, you have native Windows developers who have been burned so many times they don't advocate for anything in life anymore.
DotNet WinForms has been rock solid for 15 years. And there are so many good 3rd party widgets if you need them.
If you prefer C++, then Windows Template Library (WTL) is also rock solid and released more than 20 years ago.
It's much better than how GTK apps feel under Qt-based DEs - at least Qt tries to adapt to the DE style.
Gates did this with Windows, Office, XBox among other things. Ballmer failed to do this this with Windows Phone. Nadella did it with Azure, but he needs to do it once again with AI. You can see that he's pushing hard with Copilots everywhere, what's missing is a manager that has a coherent vision of what AI at MS should look like. ScottGu is in charge of both Azure and AI at MS, but I don't know if he can deliver.
Which bubble are you talking about? Even if you remove everything after January 1 2020, it’s still up 4x since nadella took over. And that follows a decade of stagnation under Balmer.
What numbers do you know of that show that Microsoft hasn’t been successful since nadella took charge?
Complain all you want about the products, but the stock under nadella has been a success.
Microsoft’s net income is up roughly 5.4x from ~$22B in 2014 to $119B today. Profit margin also expanded, from ~25% net margins in 2014 to over 36% today.
He maybe never had a strategy for Windows but he wasn't hired to have a strategy for Windows.
I wonder if they ever stopped to think that power users are the ones that disable telemetry immediately upon install.
Considering Firefox market share trends all decisions at Mozilla should be by default considered textbook material for what not to do.
To hell with it and then some. Also to ignore uncertainty means you will be wrong. There is no "perhaps" or "likely" here.
Firefox has nothing to differentiate itself from Chrome at this point.
Not only that, but for a time, Firefox seemed to be copying everything Chrome did, maybe as a way to stop the exodus of users. But people who wanted Chrome-y things were already using it, and people who didn't might as well, because Firefox was becoming indistinguishable from it.
God I wish Mozilla would be made great again. It's tragic how mismanaged it is.
Is it mismanaged? Sure, they spend a fair amount on administration. Sure, they spend about 10% on Mozilla Foundation stuff. But they still spend ~2/3 of revenue on software development.
And they're somewhat stuck between a rock and a hard place.
If they try to evolve their current platform, power users bitch. If they don't evolve their current platform, they lose casual users to ad-promoted alternatives (Chrome and Edge).
And they don't really have the money to do a parallel ground-up rewrite.
The most interesting thing I could see on the horizon is building a user-owned browsing agent (in the AI sense), but then they'd get tarred and feathered for chasing AI.
Part of Mozilla's problem is that the browser is already pretty figured out. After tabs and speed and ad blocking, there weren't any killer features.
Almost nobody chose Chrome. Microsoft had to change how defaults were managed because Chrome kept stealing defaults without even a prompt.
People use "the internet", they don't give a fuck about browsers. Firefox only got as high a usage as it did because of an entire decade of no competition, as Internet Explorer 6 sat still and degraded.
Chrome was installed as malware for tens of millions of people. It used identical processes as similar malware. It's insane to me how far out of their way lots of "Tech" people go to rewrite that actual history. I guess it shouldn't be surprising since about a thousand people here probably helped make those installer bundling deals and wrote the default browser hijacking code.
It should be a crime what Google did with Chrome. They dropped Chrome onto unsuspecting users who never even noticed when malware did the exact same thing with a skinned Chromium a couple days later. Microsoft was taken to court for far less.
How was Mozilla supposed to compete with millions of free advertising Google gave itself and literal default hijacking?
Being able to keyboard through menus as standard. Focus being deeply considered and always working as expected.
Compact UI elements -- in the 90s/00s we decided buttons should be about 22px tall. Then suddenly they doubled in size.
[1] Maybe I've just been blindly ignorant for 30 years, but as far as I could tell, 'GPU' seemed to emerge as a more Huffman-efficient encoding for the same thing we were calling a 'video card'
In the context of the discussion, the point is that you don’t need high-powered graphics hardware to achieve a fast GUI for most types of applications that WPF would be used for. WPF being slow was due to architectural or implementation choices.
But tdesktop is really well-made Qt piece of software, snappy, feature-rich and multi-platform.
Being open-source is kinda even better in that regard.
Qt had bindings to many languages, C++ is a choice, not a demand, if you'd like to use Qt.
Inside HTML 5 you can find facilities for rendering documents and you can find facilities for rendering applications, including those forms. There is not a clear line between one and the other.
HTML have a lot of tools for devex, but if you’re going for a good codebase and simple implementation for a desktop application, QT is way easier.
By all means, I'd be happy to be proven wrong. Last effort I saw on this direction was node-gui + React. I believe that project isn't being maintained. Being able to use something like Vite to build desktop programs would be a blessing.
That's too bad, because I prefer software which looks like it was made in 1999.
This experience put a major dent in my perception of the "Apple has the most intuitive UI" narrative.
Case in point: The YouTube app for Apple TV. Everything (pausing, playing, changing subtitles) has been done opposite to the standard player found in every other app. You cannot use the main button to pause and resume, for example. Recently they broke swiping. Normally, you swipe the remote to navigate between UI elements such as squares in a grid or in lists with a light touch. It's very fluid, like a touch screen. But the YT app has added severe "inertia" to touch gestures, and you now have to "fling" your finger on the remote trackpad to navigate. Everything feels syrupy and stuck.
YouTube and Amazon's Prime TV app are the two worst apps I've ever used on Apple TV. I believe they both use some non-native UI toolkit that doesn't respect native OS conventions and doesn't even try to. Pretty incredible given the size and budgets of these companies.
Androids do have universal back button at the bottom on the phone or the same swipe gesture if you want but iphones do not.
Sometimes swipe (the direction and position is a guessing game), sometimes and x (right or left ) and the behavior is inconsistent too (back or close)
There are some guidelines but more often than not seems like every app has it's own method and you need to get used to it
You swipe up and remove the application from the stack, all processes of the application is killed.
Background processing has strict limits, and you need permissions to run longer than that, and for some use cases, there are no recourse. OS swaps you out or freezes the app.
If you want an app to work in the background, don't kill it, period. Push notifications are handled by the OS and is not hindered by this.
It's not "getting used to", I feel like that gesture is less practical. It involves or using the "circle" to assist on how to use the gesture (creating a black void on the screen that you need to plan your use of the phone around) or having the swipe that 1) is not as reliable in my opinion and 2) can be triggered accidentally
For me is like claiming that touch screens on cars are the future and people are too old to get used to it.
Swipes are of course nice because they allow for the same interactions without taking any screen real-estate. And I have to say it quite consistent across the iOS apps I use.
Meanwhile when there's an X button or arrow to the left I always know what it's going to do aside from one or two overly creative Android apps.
When I get handed iPhone I have no clue on how to even open an additional tab in Safari and any finger gestures do not do the things what I expect nor there is a lick of indication on how to do something. It's all just a memorized magical incantations at this point. But hey you are familiar with them so it's easy to bash on everyone who is not in yours eco-system.
Why change what works fine? Maybe that's the definition of being too old, can't be bothered to change to new things.
Is a fantasy you invented to argue against.
Microsoft’s 1st party offerings are an embarrassment.
Apples first party offering isnt amazing either; it’s just “ok”; but its not a total embarrassment.
That is not how the decision making for cross-platform works. You choose those alternatives knowing that they are crap in many respects, yet accept the trade offs because you want to save money on dev hours.
I'm just saying that in my personal opinion and experience, the ones from Apple have the best yay-to-wtf ratio. Your mileage may vary.
Think for example reddit, you open a thread, how do you go back?
You open the "reply window, now ho you ho back? Maybe close it directly?
I Android this is all handled by the same function and is often ranked as the most frustrating design choice in IOS
They all are very different applications and have very different designs, yet the arrow is there.
To be honest, I baffled at your question for a second or so, because I never thought about that, yet the method is so universal that I was not thinking about it at all.