I wish all platforms gave access to their rendering engine similar to DOM on the web, imo SwiftUI/WinUI (or WPF, but they are very similar) are not that good.
Haven't built anything native on Linux, though, no idea how good those are.
But good point, I actually think AppKit might be a good abstraction level. I'll play with it a bit and see if I can abstract it behind a good component model.
Windows definitely shot themselves in a foot with building multiple renderers while building them on top of each other.
PS C:\Windows> get-childitem -path . -include "moricons.dll" -recurse
Directory: C:\Windows\System32
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a--- 01.04.2024 09:22 12288 moricons.dll
Directory: C:\Windows\SysWOW64
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a--- 01.04.2024 09:22 2560 moricons.dll
Third-party tools have tried to reimplement it but it's either been by bastardizing the native W11 horizontal taskbar to be vertical (eg: Windhawk) or just restoring the old W10 taskbar code (eg: StartAllBack).
Yes, but this was when computer were less capable. Now, you are not able to choose colors or fonts, the taskbar is fixed and the programs need at least 2 seconds to start. Terrific evolution.
The news being discussed is not about explorer being open sourced.
Like I’m searching for an installed app. I don’t need news articles about that and never expected a file system ui to be a web portal.
What's the source for this?
All I want is something simple to work with to make applications for Windows, and so far I'm still using Win32 with WTL.
I think that's because you chose "packaged" application, these apps need to be installed so that capabilities are handled correctly.
To be fair, macOS has the same issue, although they won't show in Launchpad, they still can be indexed by Spotlight.
These days if I were to switch from Win32 I might try some custom rendered framework which a lot of apps seem to use, or Qt.
What you are looking for is "unpackaged, framework-dependent". This will build an application like an old-school WinAPI executable, one which expects the relevant DLLs to be installed on the host system (or distributed in the same directory).
What I'm looking for is old-school AOT compiled executable where UI framework dependency is statically compiled and trimmed.
I haven't tried it, but there's ImGui.NET (or a bit easier ImGui.Forms) immediate mode GUI. Downside is no accessibility.
Avalonia uses Skia to draw controls, although it primarily uses XAML to define UI.
The issue with self-drawn controls is that creating such framework is a lot of work, so smaller projects often have issues with things like accessibility.
EDIT: Just did hello world test with ImGui.Forms. Self-contained AOT compiled result was 7 MB.
In my case I'm looking for a C++ UI library, not .Net. Also not a fan of immediate mode GUIs either, so would want something more traditional.
I don't want to write my own, so will probably try Qt again, but might switch to a custom library in time.
winui3 was abandoned the moment it was conceived.
I really wonder what they expect from open-sourcing it. Just to pretend how open they are? Or is there any real benefit to developers who target windows?
MAUI is not exactly a competing product and is more about enabling cross platform UI development. Different intent.
WinUI is actually ok tech. It’s evolved over the years through a few iterations, now on WinUI 3.
Im mostly with you though. Until they rebuild the entire OS in it, including all of the administrative controls and tools, I don’t trust the longevity.
UWP came along in windows 10.
UWP is built on WinRT, and acts as a fully managed app container, similarly to how phone apps exist on your phone. It allows WinRT apps to be deployed to any Microsoft platform, Windows, XBox, Windows Phone, etc, but also Android and iOS, and also as PWA, and are guaranteed to run identically on any of those platforms. UWP apps must be written a fully managed language that runs on the CLR (ex: C# runs on the CLR, but C++/WinRT does not). UWP also uses the second generation of WinUI-family XAML UIs, which means all UWP apps use completely native UIs, instead of slow non-native Javascript shit in a web canvas.
The WinUI family of XAML UIs started with WPF, and a slightly incompatible version of it also appeared in Silverlight (WPF = WinUI 1.0), then was brought to UWP (= WinUI 2.0), and is now its own stand alone thing that any app can use, managed or not, as 3.0.
WinRT is not an attempt to move beyond .NET, instead it is their way of allowing .NET to natively call code, and make .NET languages first class in Windows.
Or not. I haven't thought about this stuff for years. Definitely possible I forgot the ordering of things.
C++/CLI and C++/CX are semi-managed, you only need to use the extensions when interacting with WinRT, although you're free to write your entire app in that dialect.
WinRT is a mechanism to express APIs in a way that is amenable to cross-language usage. It is built on top of COM, and is not a replacement for COM.
Its now a WinUI 3.x program, apparently, and now the Store no longer requires UWP programs, so WT now only needs to make the "ships inside of Windows release images" guys happy, which apparently is harder than making the UWP-era Store guys happy.
I don’t trust WinUI at all.
I was surprised, when I spoke to a former colleague, to find that an internal tool I wrote 25 years ago is still being maintained. Win32 as well.
Just remember, cobol is still in active use, today
You can observe this looking at the state of old outlook.
Also, it looks better, in my humble opinion. It's probably lacking features that I'm uninterested in.
Visual Studio's + sign expanders have had this bug for years that was finally fixed by changing to a chevron shape in 2022. Clearly this problem bugged someone on the dev team hence the fix. =)
WinUI 3's big changes (to get a 3.0 version number) is not with the XAML stack itself, but its new ability to be called by unmanaged apps as a normal UI toolkit, so it can finally be used by all apps. No more using Shell UI like we're writing Win 3.1 apps.
And yes, some stuff in Win11 still isn't WinUI, which is kind of annoying, but some of those dialogs hidden away in Windows are at least 20 years old, and probably would need to be entirely rewritten, not merely have their UI's updated.
Also, fun fact: The Win8/10 taskbar's code predates Avalon (the prototype/codename for WPF), and trying to change/fix it at all usually ended up breaking it. It's one of the few binaries on Windows that would not be recompiled to build a new release image in fear of breaking it. Rewriting the taskbar made sense, GETTING RID OF SMALL MODE DID NOT, GODDAMNIT MICROSOFT.
The taskbar that underwent a major redesign in Windows 7 (released after WPF)? Also, that binary is explorer.exe, surely it got rebuilt quite often for new ads. features, and fixes?
Also, the taskbar technically exists as a dll, not an exe, explorer.exe would link to it and run it if it was being ran as the UI shell. This is now split out to its own exe (Shell Experience Host iirc), and explorer.exe is now only File Explorer.
Since it exists as a dll, btw, this is how the Win10 taskbar injectors work, they just call the dll (which still ships in Win11) instead of letting Shell Experience Host do the Win11 thing.
The sane way of handling this, btw, is just use Shell Experience Host injectors to get the desired behaviors, such as using Windhawk and use m417z's taskbar height and icon size plugin (the third most popular Windhawk plugin); to match Vista/7 era small, set to height 32, icon size 16, taskbar button width 28.
> small mode
I recently noticed that they introduced an option for small icons. Not that it changes much, as the height of the bar stays the same, but hey. Personally I've been fine since they added back the option not to combine buttons unless full.
And this is hard to do. These dialogs often are _dynamic_, with third-party settings rendered as ActiveX controls.
The WinUI map component is a Webview2 instead of proper native component, Win2D is only a subset of the UWP one, ink is yet to be migrated, and lots of other issues.
Github repos are filled with thousands of issues, and they already did a cleanup a year ago where they simply closed enough tickets to bring it under 2000.
https://learn.microsoft.com/en-us/windows/apps/winui/winui3/...
https://learn.microsoft.com/en-us/windows/apps/develop/platf...
I think this is completely independent. You can simply use WinRT APIs, because Win32 Apps can use them now. WinUI3 apps are win32 apps.
> but also not a completely new tech.
Not sure about this. UWP APIs work out of the box. For WinUI3 you need the Windows App SDK, and it is much slower and heavy than UWP (out of curiosity I created a very simple app and it was fast just a few dozen kbs big)
Or go with Qt, though that doesn't use native controls.
Compare with wxWidgets' equivalent to QPushButton, wxButton, where there is a backend-specific header[1] and implementation[2] where 99% of the wxButton functionality is there (there is a `btncmn.cpp` under `common` that is shared across backends but that has very little code itself).
[0] https://github.com/qt/qtbase/blob/dev/src/widgets/widgets/qp...
[1] https://github.com/wxWidgets/wxWidgets/blob/master/include/w...
[2] https://github.com/wxWidgets/wxWidgets/blob/master/src/msw/b...
Add a QButton with no styling, you will have a standard button widget in macOS and Windows (or a KDE styled one in Linux). Now have an event that modifies the button in some way (adding a CSS style to it is common, but also changing the sizing manually will usually do it) and the style of the button will immediately change to a QT-style one. The difference is so obvious in Windows and macOS, that it would be laughable to claim otherwise; but you can also just ask the QT Group devs or the community, they've reiterated/experienced this behavior plenty of times.
All the other "countless" frameworks are iterations of one of two lines: Win32/Native (WinAPI, MFC, WinRT, WinUI3, etc) and WPF/Managed (Avalon, WinUI2-3, etc). WinUI3 exists to bridge the gap.
This just sounds like another Microsoft UI stack
> WinUI is an evolution of UWP which is an evolution of WinRT
> WinUI 3
> WinUI 3 still supports WinRT
> XAML
> Shell UI
> Avalon
> WPF
> WPF = WinUI 1.0
> Project Reunion
> UWP
> Win2D
> ATL/MFC
> Just go for MFC FTW
> wxWidgets as it is kinda MFC-y
> Or go with Qt
> MFC/Win32 + XAML Islands
So what you got?
- kexts
- Cocoa
- UIKit
- Carbon
- SwiftUI
- MSL
- XPC
- ARC
- plist
- CoreData
- CloudKit
- SpriteKit
- SceneKit
- RealityKit
Do you think anyone that never bothered with Apple's developer ecosystem has any clue of those names are for?
And that is a very small overview.
It's not like external contributions will suddenly turn it into something usable, and they'll just have a skeleton crew maintaining it, like they do WinForms and WPF.
People are tired of Microsoft and their ever growing graveyard of ill thought out, half-baked, "native" UI frameworks.
But also Apple "totally not deprecating" AppKit and pushing everyone to the mess that is SwiftUI, Gnome breaking backwards compatibility as a sport, and Qt messing around with QML, meant "native UI" became quicksand.
Even going HTML, CSS and JavaScript wouldn't be too bad if the browser engines provided by the OSes were any good, but it took Microsoft giving up and switching to rebranded Chromium as a browser for Windows to provide a usable one in WebView 2.
WebKitGTK is also terrible compared to the macOS version of WebKit, which hurts projects like Wails and Tauri. So everyone bundles a freaking copy of Chromium with their applications.
I should have studied mechanical engineering.
The web has continually added and removed features. It is absolutely not perfectly backward compatible. It’s not even close.
I said it was a closed standard, and I stand by that.
This is the comment you originally responded to. Flash never had anything to do with web standards, which do indeed strive for backwards compatibility, it's why that classic space jam website still works.
The comment was not that the "web" as a whole strives for backwards compatibility. If that were the case we would also be running ActiveX controls and Java web applets.
For Qt, the hard-coupling of C++ or Python for Widgets and Quick being JS-centric haven’t done it any favors. C++ and Python are fine, but not everybody wants to write either, and most people interested in writing JS are going to gravitate towards front end web stacks over anything else.
I think that for a cross platform desktop UI toolkit to see any degree of long term success, a high degree of bindability is non-optional even if it’s most capable when used with its native language. The toolkit needs to meet developers where they are, and that means being usable in the language of their choice.
Microsoft is the bad one here, unfortunately.
Or a 2 row taskbar?
So I can easily switch between my 40 windows open? What is good for productivity?
> We are being thoughtful about resourcing. This effort is happening alongside other critical responsibilities like security, platform stability, and support for existing products. Our current focus is on foundational work that unlocks value for contributors and increase transparency. We are aligning this work with Microsoft’s broader business priorities to ensure long-term support and impact.
I don't sense any benevolence in their words. They are just pulling off their resources and dumping the framework on the public, hoping passionate losers will contribute.
More seriously, a desktop UI toolkit is hardly a moat by now, especially a Windows toolkit, Windows having 3-4 very different look-and-feels mixed and shipped with the official distribution.
OTOH security and stability are things that Windows critically depend on to stay on the laptops and desktops in medical, governmental, and financial institutions, and on devices of executives.
I don't watch Windows too closely. Have there been any other signals of waning investment into Windows? Has Nadella or the other leadership admitted to this?
Hasn't Microsoft also been pulling back from Xbox? IIRC, haven't they been trying to consolidate and use gaming to lionize Windows as a platform? After spending billions on multiple AAA studios? That would seem counter to a Windows pullback strategy. Is this a case of the left hand not talking to the right hand?
Wasn't there a story some while back about them crawling the web for PWAs and putting them on the Microsoft Store (or is it Windows store?) to make it into less of a ghost town? And if you go to their official website, browsing vaguely in the direction of UI development, you will see them advertising PWAs as first-class citizens of the Windows ecosystem. I also vaguely remember that Windows+Edge offers special APIs to PWAs for things like file system access and so forth that are unparalleled on other platforms.
I take this push for PWAs (combined with their own lack of dogfooding -- Office is not written with Win UI) as them basically throwing in the towel on Windows-native desktop software (outside of games, maybe).
But, to be fair, native desktop development has seen a lack of investment on all desktop platforms. JavaFX is a ghost town too.
All of that could change, depending on what happens next with Chrome, Bing, and Mozilla. -- The future of each of those seems to be hanging in the balance at the moment.
The web could become a mere implementation detail of the Google monopoly, rather than the open thing it is today. Couple that with a government-level push for digital sovereignty in the E.U. and other places (certainly China). Then, maybe, you will see renewed interest in desktop GUI apps.
On a side note: I think it's amazing what has happened in the open-source space with Rust-based UI frameworks (iced, egui, slint) and COSMIC. The future for cross-platform desktop UI development hasn't looked so bright, maybe since the introduction of Java Swing (was that in the early 00s?)
Apple is also doing just fine.
It is Microsoft that went south, as Satya apparently sees no value on Windows.
Note the drama on XBox, the console not the Microsoft Games Studios brand, as suffering from the same lack of interest from Microsoft's management.
Last time I looked into Uno, it seemed to me more like a mobile-first play (similar to Flutter), but maybe I missed something there.
Qt is still joined at the hips with C++, and I'm finding it hard to imagine that the next generation of developers will go in for C++ over alternatives like Rust. There is a QML/JavaScript story. But why, on earth, would you go there, if history hasn't forced your hand, as it did with the Web.
I hear good things about Avalonia, but: Why throw out the baby with the bathwater and build something "open" within a monopolist's walled garden.
> Apple is also doing just fine.
But "lack of investment" is still not entirely improper as a characterization of how they prioritize desktop versus mobile.
are not going to write code.
I don’t doubt that the amount of code will not reduce, it’ll just be easier and easier to get AI to fix it.
We are still less than two years into widespread use of this technology, and it’s surprising how good it is.
I am a ‘greybeard’ compiler guy and modern LLMs fix compiler bugs better than me, to a large extent. And it keeps slightly getting better every few weeks.
I firmly believe having LLMs generate code for current languages is a transition step, just like Assembly devs had to be convinced optimising compilers were generating the same kind of code they would write themselves.
They are not there yet, but the day will come.
But ignoring that for now, LLMs can already do better than modern compilers when it comes to optimizing code.
It has become a neat way of finding opportunities to implement in a compiler.
Give the LLM a compiler generated piece of assembly and it will sometimes spit out a slightly better version. Then you try and figure out if it's possible to implement it in the compiler. This works really well for blind spots in compilers like generating good vectorized code.
Yep, I guess you can train an LLM on a bunch of binaries to get it to mimic a SotA compiler with some accuracy, which may or may not improve over time, but come on. Times where there were free performance increases are gone, and this is not the area where shipping any bullshit real fast will get you any sort of advantage.
* Which are unlikely to happen again in the foreseeable future.
The next generation will not choose a language that is even more cumbersome to use and ugly.
Do you mean it is amazing how poor is an experience and how many features, widgets and controls they lack when compared with something like FPC/Lazarus and Qt?
Rust is a nice thing, but its UI ecosystem simply cannot even compare.
What's interesting is the speed at which Rust UI toolkits develop and maybe even mature.
It doesn't matter how many of Rust UI toolkits there are. Consider that there are a lot of Rust game engines, and pretty much zero games written in it, because even C++ gives you better trade-offs in that particular space.
I've tried using Qt (non QML, using rust-qt) last week... initially things were looking fine (despite unsafe everywhere)... but I found quickly that I need unsupported things (deriving from C++ classes), and the project isn't really maintained anymore, so I'll need to so some low level work myself if I want to proceed.
From google's ai result Windows ($25b) is 1/2 the size of Office (54.9b) and 1/3 the size of Azure ($75b) in terms of revenue.
Windows is definitely not the cash cow for Microsoft it once was.
Offloading the work to their victims. Maybe they will even make it usable again.
This is unduly meanspirited. Your passion projects are not even considered to probably the vast majority of the world; that doesn't make you a loser.
I have zero interest in the Win11 UI, and am even on board with the cynical view that this is purely a bean counter cost savings for MS rather than some benevolent outreach.
But I respect the people that take this on and want to keep it going.
Not OP but I understood this as "contributing for free to a project owned by a corporation worth more money than you could realistically spend in a lifetime is what makes you a loser".
And I do mean "prey" with a negative connotation. One of the biggest perks of Open Source from a company's perspective is that you can get developers to work on your project for free without paying them. However, those same developers have very little say in the direction of your product, and any forking of your project would have to compete the economies of scale that come from being a company. The only downside is that you have to worry about being out-scaled by a bigger company, as the developers of ElasticSearch, Redis, Docker, and others found out first-hand.
This is distinct from Free Software, which has different dynamics that are much more friendly to mutual benefit, collaboration, and forking, especially if there's no CLA that pools all of the copyright into one corporate or non-profit entity. But then again, this sort of Free Software moralizing is expressly the reason why Open Source was created as an alternative in the first place. The OSI even used to admit as such on their website:
https://web.archive.org/web/20021001164015/http://www.openso...
Viewing ones gains only through the lens of how it affects others seems like a hard way to live.
Maybe the biggest beneficiary will be AI/LLMs - which will become way better at creating Windows UX after this.
As has the rest of the world, and we will just put it on the list of UI frameworks Microsoft did not completly implement, fully support or considering "the default".
So we stay stuck with the status quo: There's no official UI for Windows, still.
No it's not? It's accurate.
>Your passion projects are not even considered to probably the vast majority of the world; that doesn't make you a loser.
A Windows UI project is not a "passion project" and the only """person""" that really benefits here is Microsoft.
>But I respect the people that take this on and want to keep it going.
Contribute to something else that doesn't only help the bottom line of a mega global corp?
Why are you defending this?
For any time a legitimate bug gets a "we always accept pull requests" comment from a $XXXK paid engineer, I really wish I had control of an orbital laser, or a deathnote with eyes that work with text.
Then I learnt that this company is valued at >$6 Billion
I don't get it.
> No it's not? It's accurate.
Ah, that settles it then I guess. <eye roll>
But I personally don't know why anyone would reach for this framework. Maybe if you're building a Windows app and you want a very consistent look and for your app to feel "native", but aren't there better options out there for doing this already?
Then Windows could pull a ChromeOS. The only place where a native UI is really needed is the lock / login screen; a tiny subset of any current UI toolkit would suffice.
Office on Windows relies heavily on COM and other Win32-only libraries to function.
I can't think of a valid reason to rewrite Office to that extent. They already have Office for the web and Mac Office; while not identical in features, they're often good enough outside of BI scenarios or highly complex Excel work.
Outlook is the lone exception where that team decided to have Outlook for the web, Windows Outlook, and Mac Outlook be identical, so those are getting their rewrites with removal of Win32-specific features where applicable.
I wish they didn't. Outlook on macOS is abysmal nowadays and I still find myself resorting to the legacy view just to change some settings that both iterations can read but only one exposes.
I significantly prefer using Thunderbird or the web views for Gmail and Zoho Mail over any version of Outlook. Is the integration across O365 apps nice? Sure, but the platforms themselves are miserable to use.
In a similar vein, I was cautiously optimistic about Teams V2 for unifying the client. But then they completely dropped the Linux client for their PWA which does not have feature parity with the "native" platforms and has a significantly worse UX.
I used Thunderbird for years, mostly to keep my NNTP feeds going, at some point, my mailboxes corrupted between versions (the NNTP site I was using didn't work right anymore) and I just kind of gave up at that point. It was in the dark time, before the more recent resurgence of dev activity, but NNTP didn't seem to be even a tangential focus.
I'd love to see a relatively easy open-source server for mail+contacts+calender that allowed the level of visibility, management and sharing that Outlook+Exchange/o365 offers. Right now, I have some of that, but not nearly the same.
Edit: Also, really sick of getting meeting change notifications in Teams for a meeting that is months away... just leave any meeting notifications beyond today/tomorrow in outlook, I don't need them in my workgroup app.
See BUILD recordings from 2018, I think, where they demo the new UWP controls contributed by the team, similarly to what happened before with the ribbon on Windows 7.
I would vouch they got as happy as the rest of us.
Too many questions that any Windows developer would know why the question was being asked, where they either couldn't answer or had puzzled looks on why the questions were being asked in first place.
That is also a reason why now there are Webview2 instances all over the place on Windows 11.
swift ui apps have some webkit views like the app store, music app etc
but swift ui apps are great and fast cause they're not electron monsters!
thankfully you can use safari webkit inside them, but that doesnt work cross-platform
Windows 98 introduced Active Desktop, and still, not as many webviews all over the place.
MSHTML was the first Electron.
Their "cloud lift" consists of putting vms into the cloud to run at 10x the cost. (Nothing else changed from The Old Ways)
And that's still where we are today for most enterprises.
That ecosystem has had them for 30+ years and shows no signs of going away anytime soon. If it doesn't have Active Directory and Office 365 or whatever they decided to call it today, they aren't interested.
It took a long time for this to become a cross-platform reality, but it did inspire me to ignore distractions like XAML and focus on the web.
[1] https://learn.microsoft.com/en-us/previous-versions/windows/...
It's hard to survive that. Honestly, I don't even know what the GP is talking about when they say the devs don't know "Windows".
WPF in comparison was slow, memory hungry, and difficult to learn.
I tried 5 times to make a WPF application but it didn’t even have all the same basic controls that WinForms supported.
I often feels modern Apple is the same. I mean we are 10 years into Swift, 6 years into Swift UI.
And it feels they are still in beta.
UNO Platform is basically WinUI.
Bonus points if it worked with C, C++ and Rust for those that want it in addition to .Net (C#).
I honestly think there's still too many old guard managers/exec at Microsoft to let that legitimately happen though. They're too busy trying to wrangle every last penny of value out of every Windows user along the way.
I can't help but feel like there is a happy median between Native UI and WebUI that we haven't quite figured out yet.
In the gaming space there is this library called RMLUI that I have used in anger quite a bit. It gives you something that is shaped a lot like HTML and CSS, but with a built-in data binding layer, and a scripting layer that supports Lua by default but gives you the flexability to roll your own language and API. It also is a much lighter dependency than Chromium and V8.
It's missing a couple of features from vanilla HTML and CSS, but also has a bunch of unique featurea that make it far more useful in other ways. For example, it doesn't have CSS background images, but image decorators are so much more useful. And don't get me started on sprite sheets and theme media queries.
I can't help but think that something similarly shaped and designed more for general desktop use would blow the doors off of electron. My workstation has 32 gigs of RAM and yet it's often a half to three quarters full mostly because of Firefox, Discord, and Visual Studio Code instead of more lightweight apps like Visual Studio 2022.....which sounds crazy when you say it out loud.
The coolest part was that it was baked into the .NET Framework installed on all newer Windows versions, so I could make a useful GUI app in like 30 KB.
Those were the days... I hated that job though.
Seems to me like the kind of thing that was forgotten about due to being joined at the hip with Microsoft, not necessarily because it was a bad idea.
Also how (IIRC) it’s compiled to pretty standard .NET view code (“partial”) you could extend in other parts of the app.
I’m still happy to have left it behind for the aforementioned, ecosystem & tooling reasons.
Windows 11 looks great if you just look at the press photos and stay a "very happy path" while using it but as soon as you start digging deeper you realize it's like that meme of Homer Simpson with clips on his back.
Though nothing from Apple in 1993 still runs.
in fairness rewrite it from scratch is literally easier than supporting compability since dawn of times but they forced to do it
Device Manager has that nice tree setup allowing me to see problematic devices a lot quicker.
Drive management has that nice table of physical devices on the top and then partitions on the bottom.
The old-school network adapter page shows me every network device in a single window, real or virtual, and I can mess around with their settings a lot faster with right-click properties.
And of course the services manager allows me to make sure that certain services arent running, like Windows search indexing - I use voidtools Everything instead.
That said, those tend to be the exceptions and not the rules. I've actually been quite pleased with the progression of the settings window over the course of Windows 10 and 11. A special shout out to the new fonts page as it is light years better than what came before.
Opening \Windows\Fonts instead gives you a nice view of all fonts, you Ctrl-select all you want, right click, uninstall, done.
That's most old large orgs who have been around for ~5 decades. Nothing special about Microsoft.
My take on why not ui? though is because they are so busy trying to justify saving their own skins. How could they possibly look outward into the future when they’re busy recreating lord of the flies?
You're overreaching. Business school doesn't need to teach that, that's just human nature being driven by greed and survival of the fittest, the base blocks of capitalism.
If I see an org start playing squid games, I’m out. I don’t care how much money I lose or what. I’m out.
Yes, and once the VC money dries out or the line goes down and the layoffs are on the table, they'll be at each other's throats to make sure the others go on the chopping block and not them.
Human nature is all about survival. People who are elevated beyond human nature are privileged people who don't live in a zero sum environment where every day is a fight for survival or those who are spiritually rich and can just as well adapt to homelessness as a lifestyle.
Let's take for example Nordic countries which are relatively peaceful and low crime due to welfare state, but if for example, all the food in their supermarkets were to suddenly vanish overnight with no way to replenish it quickly, then that peaceful society would flip into a survival of the fittest society where police and army would be the first to use their guns to secure food for themselves and their families.
You see this in the animal studies, where if they only give food to some monkeys, then the other monkey beat the others to steal their food.
The behavior you're seeing in the corporate world is an extension of that, not something needed to be taught. Never bet against human nature and the survival instinct, as all those who did, have been eliminated from the gene pool.
What a cluster.
What we got: Win11 dumpster fire, free for everyone to fix
They could go back to Win32 + WinForms and everything would be fine.
Microsoft is taking steps to open-sourcing Windows 11 user interface framework
Too many burned bridges since Windows 8 came out.
If anything, this is Microsoft confirmation that they are unwilling to fix all the broken issues, and hoping the community will somehow still care.
WinForms and WPF are currently the only viable frameworks for Line of Business application. I have yet to see a WinUI3 application in the wild.
On a side note, I still love WPF after working in it for 10 years. Maybe it's just familiarity, and it's a little verbose at times, but man it's a great framework when you know that you're doing.
One of the biggest problems with WinUI compared to WPF is that DependencyProroperty is implemented as native code, so for .NET developers, there is a huge performance penalty getting or setting any property on control.
https://github.com/microsoft/microsoft-ui-xaml/issues/1633#i...
I read through that github issue a few years ago and with a mix of surprise and disgust knew that I would not be learning WinUI.
Why use a busted incomplete framework missing basic features when there's entire ecosystems of open source cross-platform frameworks being actively maintained and which actually have all the features you need?
Really this is just another UWP destined to be forgotten and scorned.
UWP never had feature parity with neither Forms nor WPF, so already it has a hard sell to businesses.
Microsoft marketing always cool about cool experiences and design, without the actual meat in features.
That is why there were API reboots between Windows 8, Windows 8.1 and Windows 10.
Then comes along Project Reunion, which is supposed to properly unify Win32 and UWP execution models, instead a few months in, they do yet another reboot, that to this day is a shadow of UWP features, endless bugs, and a team that everyone thought was also part of the layoffs, has they were radio silence for months.
GDI32 you say? At least it works.
I've also tried WPF, but it's missing very basic controls that I just don't feel like recreating.
Tools like CsWin32 and modern C# (ref returns) make working with these APIs a lot more approachable today. It used to be the case that you had to create a nasty C++ project to do any of this. Now you can just list the methods you need access to in your nativemethods.txt file and the codegen takes care of the rest.
Win32 is a lot lower level than other things you'd typically consider to be a "UI framework", but the important tradeoff is that it is also a lot harder for Microsoft to remove or screw with in any meaningful way. I cannot come up with something that has been more stable than these APIs. The web doesn't even come close if we are looking at the same timescales.
Windows Runtime Components was a lost opportunity to level up the play field for .NET.
As such, if you want to do something like a shell extension, or context menu extension, it is C++ as always, or having your little C++ stub that calls out into a .NET process.
From a user's perspective, Win32 is high level. No other Windows toolkit is able to draw buttons or scrollbars properly.
It would be much cooler to discuss building a ground-up Windows UI stack as close to metal as possible which I guess would necessarily be using DirectX...
Microsoft is working on separating all of the above from Windows without losing too much control but it is going to take a while.
Exchange should be SaaS for 99% of businesses. There's a web version of Excel that's probably OK-ish. I'm not sure what Active Directory looks like in a world without Windows.
But Windows is where most people run Office, including all the back-end implications like Exchange and all the "Power" stuff.
It is a lot more than 10% of Microsoft revenue really (just not directly).
I agree though that they do not really care about the platform anymore. In fact, they care less and less every day about everything that is not AI on Azure.
My big idea to fix WPF is to rebuild the data binding system to use the .NET compile-time code generation feature instead of run-time reflection. I think that would solve a lot of problems. For one, projects could do an actual AOT build of their applications (right now, you either need to rely on an installed .NET runtime or "publish" the project with a lot of .NET libraries included for self-extract, bloating the final file size). Code generation would probably improve performance quite a bit too, maybe open up the possibility to compile for cross-platform, introduce type safety for XAML bindings (rather than getting vague runtime binding errors), remove the need for so much class scaffolding, etc... I've thought about starting an open source project to do it myself, but seems like a pretty big task and I would essentially be starting a project to help with my other project which I already don't have enough time to work on...
[0]: https://docs.avaloniaui.net/docs/basics/data/data-binding/co...
Maybe they're scared of WINE?
Windows: 72% Mac: 15% Linux: 5% ChromeOS: 2%
Windows share has been on a downward trend for at least 15 years. But it's a gorilla.
Others, like adobe software, only run on Mac or windows
Windows computers are generally cheaper than macs for the same hardware
Plenty of stuff annoys me about windows, but for now it's still what I end up going with every time I need a new computer
I hope nobody contributes to this, MSFT is a multi billion dollar company and they can afford to fix it themselves.
On the other hand it it is smpossibility that MS is working on something better, right ? They probably plan some worse UI prison...
ASCI was [business] enforced by some EU project, POSIX - the same and probably there are more examples of such things so we just need some sanity __OS with UI__ project from someone...
From memory, this first started during Vista, where 3rd party devs just weren't able to match the translucency of the new Aero UI. And the lack of articles being published by the MSDN group with titles like "Here's how you add this new feature to your app" with examples in C, C# and Visual Basic.
That being said, I'd point out that the situation has been (and still is) unfortunately far from satisfying on the cross-platform and open-source side as well: GTK has also been a mess for quite long; Qt has - aside from the bloat - an increasingly repulsive licensing model for professional use (too bad the hopes from the early Nokia adoption days got smashed by MS mole Elop and the later owners of Qt), …
… and while there are some nice solutions for specific niches (e.g. Dear Imgui), the overall situation in general-purpose cross-platform native UI frameworks looks quite bleak and unsatisfying imho. There's a huge gaping opening for a permissive-licensed open-source cross-platform UI/Widgets framework that compiles to native, has a good set of widgets and gives access to Vulkan contexts for 3D rendering.
Microsoft could’ve made a real impact in this area with a great advantage to themselves, but both efforts I’m aware of were so half hearted they could never have worked out.
DHH pushing desktop Linux for developers, Pewdiepie making videos about Linux and GrapheneOS, there's definitely an accelerationist argument to be made here.
I suppose this coincides with software development becoming much cheaper.
BoorishBears•6mo ago
Windows and an absolutely baffling array of UI frameworks with various pitfalls, uncertain futures, and no clear winners.
(honorable mention to WinForms though.)
politelemon•6mo ago
jiggawatts•6mo ago
A framework that has just one show-stopper missing feature or problem is... unusable. You can't embark on a large, complex application development journey if you even suspect that you'll be painted into a corner.
For example, many of WPF-derived frameworks had atrocious performance, with fundamental mistakes in their design that made them incompatible with list virtualization. It wasn't until they had to eat their own dogfood and use WPF for Visual Studio that they started fixing these issues.
Win UI 3 meanwhile dropped all support for HDR, wide-gamut, etc... going backwards to SDR sRGB only in an era where all mobile phone manufacturers were starting to standardise on OLED HDR displays. The logic behind this decision? Microsoft wanted a UI framework that is "mobile compatible"!
brokencode•6mo ago
pjmlp•6mo ago