What I find must puzzling is that everyone seems to just be violating basic rules that had been in place for ages.

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.

> WPF was good

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.

The deeper problem is that Microsoft keeps trying to solve GUI consistency at the framework layer instead of the design system layer. WinForms, WPF, UWP, WinUI -- each one a new framework, each one eventually abandoned.

Apple solved this by treating the design system as the product and letting the framework be invisible. Microsoft has it backwards every time.

2 things Microsoft failed to do in the last 15 years are:

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.

I remember when ChatGPT exploded and Bing had it integrated, the idea was brilliant because unlike ChatGPT it didn't have information cut-off since it can access the web. I was very excited to ditch Google for AI chat with web access.

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.

There’s a poster on here who keeps posting and re-posting about their dinner with a Microsoft executive and how they were told Microsoft is all-in on enterprise. Waiting for that copy-paste to make its way over here.

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.

Desktop, especially Windows, is such a mess.

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).

I used to be a software test engineer at Microsoft in the late 90's and early 2000's. What I learned is that 60% of their business was International because of their language support. Also most of their customers are business customers locked in to using their Windows Server Domain system for corporations. These corporations also run office and Sharepoint and build custom apps using office. This is why they have so many different ways to build apps on Windows. We are not the users they are targeting, they target the enterprise.

Java wanted to run your code everywhere so they basically wrote a byte code compiler and then wrote one vm per OS/architecture

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.

.

The churn would have been much worse if Microsoft was rolling out successful GUI framework after GUI framework. As it is you can still write a Win32 app if that pleases you, or still write .NET (and damn that runtime download!)

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.

The problem is that they just could not commit to anything for more than 2 years after Win32.

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.

Wow, totally ignores the one framework Microsoft developed that was actually a pleasure to use (WinForms). Avalon sucked IMO; it was just a continuation of the fever dream at the time of making everything XML (or XAML in that case). MFC sucked because it was C++. WinForms was that brief Window of “modern programming language with simple, elegant GUI framework”.

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.

My coherent GUI strategy: just use JUCE.

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.

When a platform can’t answer “how should I build a UI?” in under ten seconds, it has failed its developers. Full stop.

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.

Having spent some time kicking around the Delphi space I got quite into WPF in 2007ish. By 2010 I had not just sworn off it, I'd sworn off Windows entirely. The constant stream of rug-pulls as one bit of MS managed to pull off a political heist over another and - oh no - yet another "latest and greatest" technology was effectively deprecated within 18 months of launch, invalidating all the effort you put in to staying up to date just became a pointless treadmill.

Fortunately Rails was taking off at that point so it was fairly easy to change horses and just ignore it.

Steven Sinofsky wrote this piece a couple of weeks ago about the same topic:

https://x.com/stevesi/status/2036921223150440542

Fun and sad. Garbage collected languages like .NET, Java, and Go are slow compared DIY languages like C, Rust, and Swift. So, no wonder the Windows team dislike them. However, it seems the Windows team had to live with a React start menu for quite some time. How does that fit into the over all battle between the teams and UI frameworks?

The answer is, clearly, Qt.

(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.

The biggest issue in my opinion is that Microsoft is chasing web devs. XAML is pita, just like css and html markup. They need to pick a lane and just use it. Allow other frameworks access to the default low level api such as Win32, but document it to the same level as Google does on Android and Apple with SwiftUI

As of today, I only use 2 solutions for Windows GUI :

- 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.

I remember I was trying to learn GUI programming in late 2000s. I took an attempt at MFC but no matter how hard I tried, it just didn't make any sense. Then I found out about Qt 4 and it felt like magic immediately. I ended up working as a professional Qt software developer for 3 years.

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.

This barely mentions Windows Forms, which is the cleanest and fastest way to code Windows GUI apps.

A few years ago, I wanted to prototype something quick and I wrote it in Windows Forms over C# (all code, no visual editor).

> From their perspective, gambling on a new managed-code framework had produced the most embarrassing failure in the company’s history

Most embarrassing failure in the company’s history that far.

I would bet in Avalonia UI. It's like WPF but cross-platform. https://avaloniaui.net/

At Redmond, there was also the Patterns & Practices group (P&P) that tried to make sense of the dev products, and built extra libraries “to show customers how to use them”. They followed the bouncing ball of the frameworks releases from the main development teams. It suggests that it wasn’t clear exactly how you’d use the main products: so P&P said, ‘try it like this.’ I also think the article didn’t say much about MS in the web era. The company survived webdev IMO, but it definitely wasn’t the leader

As an outsider, it always felt that 'internal team politics' were the root cause of Microsoft's technological downfall. This went far beyond the GUI. In 'flagship' offerings like SharePoint or Skype/Lync/Teams you could see the unmixable partial code-bases brutally forced together under a single product name an foisted upon a user-base baffled by how this could have gone so wrong.

Microsoft GUI development is a mess. They don't seem to care. Just look at the mishmash of different GUI styles in Windows 11.

Thankfully I have been mostly insulated from it by sticking to Qt and C++ for the last 25 years.

This article smells so strongly of AI that I'd be surprised if the author did much of any writing.

Windows frameworks got web envy.

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.

I stuck with WinForms and complemented it with DevExpress since their first release and never looked back.

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.

So the windows team hates .NET, so they use react webviews and put them in explorer and start menu???

Microsoft's biggest mistake was .Net being a Java competitor when it should have just been like golang producing native binaries. Especially since .Net was realistically only going to succeed on x86/64 at that point (late 90s and 2000s). This shut the door on C# for consumer UIs, and people stuck to Visual Basic and MFC.

It took them more than 2 decades to finally support pure native binaries (via NativeAOT). And it's fantastic for servers on Linux.

A couple of years ago I played a bit with Go and Win32.

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.

I very much dislike WPF. If I have to do a windows UI (and usually when I do it's a simulator for some piece of hardware), I honestly just grab WinForms. It's stupid simple.

Winforms is still compelling to me. Now that we have WebView2, building complex hybrid apps is trivial. I know I could easily go pure web, but something about having proper native chrome feels better as a user. All of my clients/users are on windows so I stopped fighting this battle years ago. I've recently been using .NET10 + Winforms + WebView2 to build custom ai assistants for others. I cannot imagine how much it would suck to iterate the presentation of a conversation history in pure win forms. The hybrid stuff is crazy productive.

To quote Steve Jobs: "The only problem with Microsoft is they just have no taste. They have absolutely no taste. And I don't mean that in a small way, I mean that in a big way, in the sense that they don't think of original ideas, and they don't bring much culture into their products. "

Given how bad windows has become since windows 7, I’ve been wondering. Does Bill Gates still use Windows? Does he put up with the horribleness?

Today i still use C# with Windows.Forms. All my old knowledge is still usefull. People know how to use a Windows.Forms program.

This is what happens when one's performance is measured by "impact".

A decade or so ago, I had a clear idea of what a "native ui" should look and feel like, even if there were multiple routes to get there. I don't know any more.

An honest accounting of this history has to call out Sinofsky's role, and it's not pretty. He nearly killed the company in pursuit of power, insisting that everything be brought under his control. Who pushed in 2005 that online and search had to be organized under Windows? That was Sinofsky. He forced the engineering team that most needed to move fast onto three‑year product cycles--sheer insanity, and just one of a 1000 bad calls that ultimately contributed to his ouster from Microsoft. And when it came time to plan his own exit from Microsoft, who did Sinofsky turn to? Jeffrey Epstein, of course, because that's what normal people do. Treat everything Sinofsky writes as an attempt to launder his reputation--then add another layer of skepticism on top of that--because Steven Sinofsky does not live in the same moral universe as the people whose careers and products he derailed.

The writing style was really poor. Too many words saying too few things.

> I sat through a conference session in the late nineties trying to understand the difference between an OLE document, a COM object, and an ActiveX control.

I wonder if we attended the same conference session!

The roadmaps look messy if you look at them as coming from one company. But if you remember that windows and .net (or DevDiv) are more like competing companies then it makes more sense. Then for one side it’s Win32, MFC, WinSDk and for the other it’s Win32 (WinForms), WPF, MAUI

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.

For some reason I associate this with this article

https://blog.hiler.eu/win32-the-only-stable-abi/

That illustration at the end of the article is quite something.

The root of the problems seems to be trying to find a holy grail design that works across all their businesses. Surface tablet mode, touchscreen laptop, touchscreen desktop (surface studio), mouse and keyboard PC, stylus input, etc.

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

Microsoft has a very coherent strategy, described aptly in "fire and motion" by Joel spolsky 24 years ago: keep changing the API/GUI every 2 years:

https://www.joelonsoftware.com/2002/01/06/fire-and-motion/

Both this blog post and the Steven Sinofsky response really set my blood boiling, because they both reek of retired-executive score settling, a kind of blame game that gets played out decades after the fact between ex-high-ranking people in hopes that whoever writes last is able to cement the conventional wisdom.

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.

I used the more recent Petzold examples to successfully bind DirectWrite to Direct3D, but yeah it’s been a crapshoot otherwise. Still have the Windows Programming (5e?) bible around here somewhere. Took awhile to grind through it. I dread modern-day windows programming it seems like every OS release some new API is going to overtake the others. I moved on.

I blame "Impact". That's what you are graded on at Microsoft. Every performance review ('Connect'), every stock award, every promotion run: did this person have that magical impact.

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?

Programming Windows is THE authoritative source on Win32 programming: https://www.charlespetzold.com/books.html

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.

Petzold is a legendary programmer. His book Code is worth reading: https://en.wikipedia.org/wiki/Code:_The_Hidden_Language_of_C...

Microsoft itself is a business driven by a consistent strategy of striving for market dominance no matter the means. looking for coherence in the resulting DX is missing the forest for the tree.

Not just Windows. If you use an Android smart phone (and it might be just as bad on iPhone I just don't know) you see AI features occupying the last scraps of user interface real estate in the form of edge gestures that half the time get me an unwanted AI overlay UI when I was looking for the app switcher. Steve Jobs is spinning in his grave, and the people who authored the original Mac UI guidelines are cringing. Nobody seems to be willing to say that there's no room at the inn, or that somebody's idea has to get evicted before a new idea can occupy space.

This 2018 video from TechAltar discusses the same topic: Why Microsoft Can't Design A Consistent Windows (https://youtu.be/hn5QjtpjW_U)

MS Windows is walking joke for at least a decade, UI consistency isn't it biggest problem. Unfortunately both Linux and MacOS have their own deeply seated issues. This leaves users in an unenviable situation and encourages experimenting, with AI encouraging more and faster attempts. When AI are getting better... I hope this question will become unimportant sooner rather than later.

Worth mentioning a discussion on a similar blog post two weeks ago;

Windows Native App Development Is a Mess

https://news.ycombinator.com/item?id=47475938

Reading this was such a trip. I remember "Programming Windows" had to bribe my uncle to buy it for me. I built my first app using it.

One could argue the 17 solution summary is actually correct? Why should an os be limited to just one way of doing things. I don’t believe my own words 100% but it is a thought that maybe diversity is the eventual outcome. Ubuntu and MacOS are kinda fighting the same battle. Is that just the way it is?

It's bad enough that Microsoft doesn't have a satisfying answer to this question, but what makes it worse is that WinUI feels weirdly non-native in ways that sort of uncomfortably result in Electron apps feeling more like real Windows applications.

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.

The web revolution is to Windows UI what vibe coding is to programming today. It brought in a massive group of people who didn't need to understand message pumps, or handles or non-blocking api calls. On top of that, it delivered incrementally more capable result each year. View source taught millions how to build modals, blurred overlay. Meanwhile, the old group of programmers were still worrying about how to protect the knowhow behind compiled languages.

Case in point after Edge updated this morning:

https://imgur.com/a/dWp5Ohj

Did they even try to make it look like the new context menus?

I was recently exploring "an OS from scratch" architecture with ChatGPT. Apart from the central idea that I wanted it to be a capability OS, I also started thinking about how I'd make GUI apps and what layers would naturally make sense.

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.

Petzold literally had the Windows logo tattooed on his arm. He was a true believer.

The tl;dr is basically to stay with Win32 and ignore all the new and shiny.

That AI image at the end was more amusing than informative. Almost lost it at "Win15" and "Chrondum + frade.js".

While reading all these comments I keep asking myself if these are the same people who would get angry at another Election app because someone was lazy and didn’t make it native.

Has anyone tried turning Microsoft off and on again?

I had the displeasure to work with various MS systems over the years and coherence is not a concept in Redmond. It just isn't.

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.

I think that is an insult to MS Bob

The UI strategy of the future may very well be HTML. It's widespread, standardized, sufficiently performant, and pretty rich.

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.

I feel this so hard.

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.

> WPF shipped in late 2006. It was remarkable – XAML, hardware-accelerated rendering, real data binding. If Microsoft had made it the definitive answer and invested relentlessly, the story might have ended differently.

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.

Talk about UI without pictures!

Good tech solutions need ONE champion.

Jobs, Musk, Edison, whoever.

Someone who will enforce their design decisions, get stuff done. And take the hit when they are wrong.

The funny thing is that Joel Spolsky predicted most of it 20 years ago[0]:

>> 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...

Why tie your app to Windows at all?

Microsoft developed VS Code and Teams in Electron. That says a lot about how they see the future.

I stuck with WinForms. It was the last tech that made your app look and feel like Windows app.

Everything that came later was basically a struggle to make something that Electron actually delivered.

IDK, it kind of sounds like from the article's own prose that Project Reunion / WinUI 3 is an overall good thing and that Microsoft actually does have a pretty good vision for the past 5 years at least.

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.

This will never change. All large orgs are this way because at the end of the day, unless its preventing them from making profits, there is no incentive to change it.

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.

They have a strategy of adding as many dumb slow abstractions as possible so the multi trillion dollar company can minimize the devs on their payroll.

Anyone else sit through one of those Microsoft "Project Reunion" and wonder "what the hell is even this?" Microsoft has had a completely confusing UI strategy for years.

WPF marked the end of well thought-out UI’s and standards. It’s been web-inspired slop ever since.

I'm not sure I can take such an article seriously if it doesn't mention that the WinRT/UWP/WinUI stack is also based on XAML, and that a fundamental design goal of WinRT was to let people use either C++ or C# according to taste.

Also, the AI smell in this article is just too much.

Couldn’t someone do a similar story about scripting on windows, and make Jeffrey Snover one of the punchlines?

Starting with Metro every Windows UI framework has been beyond ugly. there's just something so backwards over how nice the UI was in Windows 7, I simply can't understand it.

"I looked at the presenter like they had a rat’s tail hanging out of his mouth for the entire hour."

Could have been Ballmer getting a quick snack in before anger-presentation.

Nobody really has. Apple comes the closest but they keep rug pulling it in weird ways.

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.

At this point I don't get why they don't open source Windows and developer tools, make a foundation to steer the code, accept contributions and borrow ideas from other operating systems.

Honorable Mention: Lazarus

Every year the same debate, every year the same Microslop apologists in the comments, every year nothing ever changes, every year Microslop's market cap keeps groing, every year the same problems

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

funny thing is, with AI, it's become really easy to put win32 apps together, and they load fast and are super responsive!

Here's how I think Microsoft can get a quick and sustained longterm win in GUI (/s but only partially) -

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.

s/\sGUI\s/\s/g

The slop image at the end made not read anything in this article.

OLE objects are just like disk images.

It’s web. Just use electron or Tauri.

Oh hey look, another chance for HN to dunk on Microsoft. I’m sure there will be some fresh new perspecti…oh darn, it’s just a rehash of the exact same snark the last time HN had a chance to dunk on Microsoft.

I’m not sure what Microsoft can possibly do when the closest thing to a collection of power users is this painfully repetitive.

> Dead silence. One person suggested WPF. Another said WinUI 3. A third asked if they should just use Electron. The meeting went sideways and we never did answer the question.

> That silence is the story.

These LLMs are just awful at writing.

This is a problem with all the OSes.

WPF was atrocious from the beginning and Microsoft absolutely did the right thing by not basing everything in Windows on 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.

I'm planing on switching over to QubesOS - way more secure (especially considering rogue LLM-agents) and visually not much worse from windows ... maybe even more cohesive.

I would recommend Flutter, if Google would not have abandoned it. 12000 open issues on GitHub speak for themselves.