Announcing Open Source of WPF, Windows Forms, and WinUI
blogs.windows.com
blogs.windows.com
"We will typically not accept contributions that implement support for an OS-specific technolology on another operating system. . . We also do not intend to accept contributions that provide cross-platform implementations for Windows Forms or WPF."
https://github.com/dotnet/wpf/blob/master/Documentation/cont...
Microsoft seems to be actually refusing to accept contributions that could make WPF cross-platform - it's a bit beyond "no official plans for cross platform".
I think I'd prefer that approach, anyway - I'd guess it's cleaner and ultimately more maintainable than introducing a whole bunch of conditional logic for handling all the cross-platform issues into an already complicated piece of software.
I wouldn't be surprised if there were abstractions to make porting to openGL easier.
where did they notate their goals for wpf and winforms to be cross-platform? they specifically mentioned they open-sourced them to open up windows development.
Nobody should be submitting pull requests for cross-platform support into WPF's main Windows repository. Instead they should branch WPF, make a platform specific version (e.g. WPF-Linux, WPF-MacOS, etc), and submit pull requests upstream that are platform agnostic (e.g. bug fixes).
If they were starting WPF again today they might create an agnostic master, which has a Windows specific branch. But they aren't restarting WPF, they're just open sourcing what they already have.
Suppose someone came up with .NET bindings for MacOS GUI controls, or Gnome. Would you expect a Microsoft to adopt those into .Net Core?
MicroSoft have two roles here. On the one hand they are the custodians of the cross platform .NET Core system. In the second role they are the Windows platform owner and provider of .NET bindings for some platform specific features.
If you decide to contribute to .NET Core, you join them in the first effort. If you come up with Gnome bindings or such, you are in the latter role but just because you are creating those bindings you’re under no obligation to port Gnome to Windows or anywhere else. Bindings for existing platform specific features are clearly in a separate category from shared cross platform features.
I actually think MS did a great job by saying that. The purpose is to literally make the source public but they don't have resources to make a long commitment. Then it's better to not say it clearly and later got accused as not well performing.
> Open source doesn't mean open development and liability & commitments.
Right. We are stating up-front what we intend to achieve. We will sart with making WPF on .NET Core have parity with .NET Framework and then expand from there. We'll stick to Windows as the OS for the project.
> The purpose is to literally make the source public but they don't have resources to make a long commitment.
We are not saying that. We intend to continue working on WPF. In fact, we are talking about moving some of Microsoft's 1st-party apps to WPF on .NET Core, just like how we're moving 1st-party web sites/services to ASP.NET Core and .NET Core. Same playbook.
Keep it contained in Windows! WPF apps are shoddy.
I know, because I did this before with Mono, and the changes would be highly disruptive to the codebase.
And their whole .Net is full of patents.
Who's going to pay to buy the new CI machines they need to run someone's macOS backend that they contribute for example?
Be reasonable.
These frameworks have been around for many years, and many (if not most) of the applications built on those frameworks make heavy use of third-party control libraries. Those libraries, whether open source or propriety, often include at least some win32-specific interop code that has also been around for many years. Most of those libraries are now in “maintenance only” mode, if they’re even being maintained at all. Realistically, most Windows GUI applications built on .NET will never run on any platform other than Windows, even if the core UI frameworks become cross-platform.
As soon as Microsoft says, “WPF is cross-platform now”, they’d get flooded with bug reports that aren’t even related to their code.
My guess is that desktop apps will come back with pwa+wasm. Then you can have a rich client that is fully cross platform, single code base, same behavior everywhere, easy to deploy, written in the language of your choice. But that doesn't involve wpf...
I understand that the open source WPF can be freely used as a reference from where to borrow a few things.
People can always fork and work on it, Microsoft is just sending the message that they won't do any work to incorporate any of it. Open-sourcing something is not an obligation to keep maintaining something.
This project collects usage data and sends it to Microsoft to help improve our products and services. Read Microsoft's privacy statement to learn more.
For more information on telemetry implementation see the developer guide.
https://privacy.microsoft.com/en-US/privacystatement
https://github.com/Microsoft/microsoft-ui-xaml/blob/master/d...
Looks really easy to disable, but probably something some folks need to be aware of. Love the license and effort Microsoft put into this.
It's sending back arbitrary data to someone else without explicit authorization. This data can contain anything including information about the running environment, the contents of files on the computer, other running programs.
It doesn't matter that it's Microsoft instead of an Estonian teenager doing it. You own your computer. You explicitly decide what data comes from it. NO EXCEPTIONS.
You are giving very explicit authorization by agreeing to the EULA.
> You own your computer. You explicitly decide what data comes from it. NO EXCEPTIONS.
That's still true. And by installing a product and agreeing to a EULA which includes a section on telemetry you are doing just that. Thus, your options are "don't install the software" or "opt-out".
It's also unlawful under the GDPR.
It doesn't appear to say clickwraps are non-binding, only that it has to be "conspicuous" and basically that a user knew they were agreeing to something. Unfortunately that too is open to interpretation. As with most things of this nature, if someone wants to sue, they can sue, and it's a resource fight in the courts.
[0] https://en.wikipedia.org/wiki/Specht_v._Netscape_Communicati....
GDPR does not make collecting aggregate data unlawful, so unless you can prove that the data collection is identifiable then GDPR doesn't apply.
Bullcrap. Many people's Win7 installs were upgraded to Win10 without their consent.
To claim otherwise is blatantly dishonest.
I just moved into my rented house and discovered the CCTV outside my front door, in public view, but also on my property, is actually monitored by the landlord, not me.
- you = me
- software = house
- telemetry = CCTV
I just entered a new mall and discovered that they monitors how many people come in and out (and at what time) in order to ensure they have enough cashier.
- you = me - software = mall - monitoring basic metrics in order to improve the service = counting people in/out
This is completely OK, and somehow everybody likes that they increase the number of cashier during busy time. Just like the mall, you do not own the software, you juste have the right to enter/use it.
Indeed, human greed is faster moving than regulation, so its no wonder we are in the transition phase.
And if you tell me all this identifiable data about me is safe, this is simply not true. Safe from motivated 3rd parties, then this is also not true.
Unfortunately, we do not live in this ideal world where data is used for only good.
We live in a world where people get away with undetected overreach all the time.
This is specifically about telemetry in an open source code. If you want to know what data it sends, you can look for yourself.
> my property
Those two things don't jive. It's your property OR you rent it. Not both.
1. Unclear boundaries of data. How many points of data are being collected and sent 'home'? CPU performance? OK. Device name, pc username, usage duration, times the program is opened and closed. System account email address, IP address, hostnames contacted (i.e. websites visited), WiFi-based location, webcam stream for inference of end-user mood, microphone for emotion analytics? These are all examples of telemetry that could be argued are 'needed' for purely for product improvement.
2. Even if only a couple of data points are collected, it is very possible to identify the real name of the end user through analytics of the data. This inferred information is very valuable, and definitely is then a privacy issue.
I hope the vast majority of developers and company execs don't intend to 'do evil' with this information, but unfortunately we have seen examples of this from public companies, despite auditing etc.
Oh, I forgot, OSS contributors are vital state resources targeted by foreign governments and drug gangs alike, and both of them have access to how you use open source Winforms. I get it, now.
(Sarcasm complete. My points here are that you aren't a target of any totalitarian regime, and that totalitarian regimes don't need telemetry to make you disappear.)
Are you switching the conversation topic from open source software telemetry to mobile phone tracking? That's a whole other thing, and doesn't contribute to the in-progress discussion on open source software telemetry, nor does it prove me (or anyone else) wrong.
Making something like this opt-in is equivalent to not having it at all. Not just because of how little pick-up there would be on the telemetry, but also because the type of people who would opt in are a skewed sample not representative of the larger user-base they wish to learn about. It’s like the bias introduced by doing an opinion poll by asking people to do a one-hour opinion poll over the phone: you filter out the average person who doesn’t have time to do a one-hour poll, and get responses only from people with too much time on their hands (= unemployed; teenagers pretending to be adults; old people who just want attention; etc.)
People who say opt in, would generally opt out. People who say opt out, would generally opt in. This applies to anything.
In this case, given its about collecting my data and processing me, I say Opt In. Not having it at all is a good thing.
And no, the people who want opt-out would not generally opt in in an opt-in system. That'd be their preference, yes, but you’re underestimating people’s laziness in practice. There are things I’d grant telemetry access to, but I don’t know how and don’t have time in the day to learn how, especially since it grants very little advantage to me personally.
You get something, better software because developers can know what is being used and what it is not, what feature is bugged, etc etc.
/s
EDIT: The proverbial "you", not you in particular.
Newsflash: The latter requires the former, especially in large-userbase installations with tons of features.
I say this as a huge defender of privacy: Telemetry is not evil in and of itself and I wish people would give it a rest when it comes to yelling about opt-in telemetry, because it seriously harms the cause in cases where it matters, such as actual transmission of personal data.
Seriously, things like "Do you click the Edit menu a lot" is not useful data to anyone but the devs of the software, for development reasons.
The vast majority of computing history argues for exactly the opposite.
In fact, with it's new "all in on telemetry regardless of reputation damage" approach, MS's software often does not work. Clearly MS have taken a wrong approach, and seem completely unwilling to rethink it.
Do you not remember using software back then? Waiting years for simple bugfixes?
As I said, please please focus on privacy issues that matter. Trying to be snide about inconsequential telemetry is a waste of time and of public awareness.
You want to complain about Windows 10's privacy practices instead, go ahead, because that is a good example of abusing telemetry and not respecting the user. But sometimes, "telemetry" is just "anonymous UUID + software version sent every 7 days" and people still complain about that. Then those same people will go and complain about the software vendor dropping support for an old version when "users are still using it". Again, newsflash, that's stuff you know because of that tiny bit of telemetry.
I'd highly encourage people complaining about telemetry to do actual devops for a few weeks or something and understand how blind you are without instrumentation.
Agreed. When they're present, I do make use of them.
It's just sleazy + abusive companies like MS that do it so, so poorly.
> ... that's stuff you know because of that tiny bit of telemetry.
Ugh. Decision making of product features based on telemetry sounds really narrow-minded and likely to go badly.
Shouldn't they be actually talking to their customers & users instead to understand their needs?
There's wrong ways to use telemetry, but overall they are positive, especially in large apps where gaining insights on tiny percentages of your userbase is both important and impractical. That does mean Windows, Android, Chrome, Firefox, etc.
It's the same in game dev. You might see through telemetry that 80 percent of your churn is right after one specific quest. Without telemetry, this might not be something you notice, because churn rarely ever talks and when they do they're not accurate.
I can see how that would be the case for games. They're special purpose one-offs, and aren't tools for getting a job done.
For business applications though, the concept of "data talking far better" than actually talking to customers seems very wrong headed to me.
It's very common for business application users to follow processes that are effectively workarounds for missing or broken functionality in their tool set.
When they're able to communicate with the vendor and describe what they're actually needing to do, the tools can be changed to achieve the desired result properly.
I've never heard of telemetry being able to address "how the tool should be working" rather than sending a stream of data showing what a user did. Maybe good for support issues, but pretty useless for product planning and addressing actual user needs.
You're missing the point here. I don't care about the quality of Microsoft's metrics. I care about the privacy of my data.
The results of your arbitrary one hour opinion poll don't mean anything to me. You wanted that data. It doesn't benefit me, as much as you want me to think it does. Infact, if I had the choice between not taking the poll and not having you call me in the first place guess which one I'm gonna pick.
And Microsoft only cares about the privacy of your data inasmuch as it has to, it DOES care about the quality of its metrics.
> The results of your arbitrary one hour opinion poll don't mean anything to me. You wanted that data. It doesn't benefit me, as much as you want me to think it does. Infact, if I had the choice between not taking the poll and not having you call me in the first place guess which one I'm gonna pick.
Sounds like you want to have your cake and eat it to. There's already global means to opt-out of telemetry data: don't use products that have it. Alternatively you can take the couple of minutes to turn it off yourself.
Seems you think you're entitled to this, which is fine, but that entitlement should be brought to the attention of your government.
Microsoft were doing opt-in telemetry in Office, Visual Studio and the .NET framework for a long time, so it must have provided value for them. The installer used to politely ask you to consider opting in to help improve the product.
JetBrains products still follow this approach of respecting the customer and asking politely.
There’s a third kind of system for polling preferences, which I’ll call “opt-forced” for lack of a better make: it’s where you are required at some point to decide whether to opt in or opt out, and neither option is the default. (Picture two radio buttons, neither selected, and you can’t proceed until you click one.)
Nagging opt-in is a lot closer to opt-forced—you’re required to either press “OK” or “Cancel” to the opt-in dialog box. Except, since it just keeps asking whenever you “opt out”, you haven’t really opted out at all. Thus, this dark pattern is actually closer to the “opt-out” side of the fence, in terms of the number of people who end up in the program even though they’d actively prefer not to be (but this preference is weaker than their preference to stop being nagged.)
What I'm proposing isn't either of those things though. It doesn't rely on just promises of other people. I can see the code I'm compiling and running on my machine and, as long as I don't let anyone else modify it arbitrarily, I can be sure it's doing what the code said. Yes, mistakes happen and sneaky code happens but, for a vendor that actually wants to play nice, too many mistakes or even a single attempt at sneaky code will ruin their reputation.
And, again, I know this won't fix closed source code or malware.
Do you want the high school kid in his bedroom to go to prison because he wrote a "site" and his friends data got leaked?
It's no different than requiring, e.g., farmers to limit how and when they apply fertilizer and pesticides so as to limit runoff and down stream pollution.
That said, statutory civil penalties (fines per occurrence) for the effects of the bug in production _would_ fix the problem. Who is going to keep giant data-lakes around when they are the business equivalent of toxic waste? The developers are still able to write code, but they are incentivized to not collect extraneous user data.
Opt out telemetry is NOT an option. Opt in is. I've been fighting this position since they added it to .Net Core and will continue to do so.
Now after 16 years of using .Net and building a lot of massive products this is the status quo of how I have been treated all along and it hasn’t changed one little bit other than the marketing so it’s time to get off the ride.
At this point I firmly believe that the “open source” drive here is part of a new market domination strategy rather than something for altruistic good. Fair enough but I don’t have any love left to give now. If you ship some stuff on every platform it looks like you are an attractive option and once you’ve bought in you can’t get off the crack smoking schizophrenic rollercoaster. I want off.
I do the same.
(For the record I'm not saying they're perfect and that everyone should trust them!)
that's not interesting. the interesting question is: will there be a SQL Server Management Studio for GNU/Linux?
Then they could charge for a subscription to the "pro" features and take a cut from apps on the Windows store.
But that would only work if it's legally possible to open source even that much of it in the first place, which may not be the case.
Linux distros already do exactly that for other “open source but non-redistributable” things Microsoft offers, like the MS Core Fonts. The distros’ packages for the fonts don’t contain the fonts, but rather a wizard that goes and gets them from Microsoft’s servers on behalf of the user, and then installs them.
This seems legitimate enough, as an approach; nobody’s ever been sued for this. So I’m not sure there would be much difference in the legality of it if it were the whole OS.
I doubt it. That kind of first-time user experience would probably do more $ worth of damage to the company's reputation and sales than what OEM licensing costs.
Linux vendors may be able to do it just fine, but Linux PC vendors cater to a very different target market from Windows PC vendors.
It's likely most of the nuts and bolts of Windows can be open sourced without threatening their business model, as competing OSes are pretty architecturally incompatible, and there will always be some closed source parts of Windows. Bear in mind, Microsoft is working heavily on shifting their revenue to being services-based as well.
Isn’t Windows 10 already more or less free? You can download it on their site, install it, skip the activation and that’s it. There is a message “Activate Windows” at the bottom right of the screen but it doesn’t matter for most people I guess.
source: https://blogs.msdn.microsoft.com/oldnewthing/20180515-00/?p=...
If it was released without the third-party code, then it'd be a research project, which'd be pretty neat but not something most probably expect from "Windows is open source".
But I don't doubt there is other code that is not so easily replaced.
Yes, that's also the reason Raymond Chen gave when people asked Microsoft to open source the Pinball game that was removed from Windows Vista: https://blogs.msdn.microsoft.com/oldnewthing/20121218-00/?p=...
In the comments, a reader traced the chain of ownership and apparently Electronic Arts now owns the Pinball source code: https://blogs.msdn.microsoft.com/oldnewthing/20121218-00/?p=...
And it's not like Microsoft is Red Hat vs Oracle, they can bury anyone making a "hostile" distro.
select(), which originally appeared way back in the day in 4.2BSD, is a way to not spin — it only returns when a descriptor is ready.
In contrast, select(), from 4.2BSD through the current day, cannot be used for async IO on regular files. It simply returns immediately. If used naively this could result in a busy loop, I guess, although getting stuck in a blocking disk operation seems more likely to me.
EVFILT_READ Takes a descriptor as the identifier, and returns
whenever there is data available to read. The
behavior of the filter is slightly different
depending on the descriptor type.
Sockets
[Non-listen] socket descriptors return when there is
data to be read, subject to the SO_RCVLOWAT value
of the socket buffer.
Vnodes
Returns when the file pointer is not at the end
of file. data contains the offset from current
position to end of file, and may be negative.
The Unix async model based around fds and select was really only designed for sockets, and has been extended to socket-like objects (pipes/fifos). Linux has added support for some other sources in the form of e.g. signalfd(), eventfd(), timerfd_create(); the BSDs just added it all to kqueue/kevent. Neither supports async file operations in the fd model (basic operations like read/write; nor more complicated operations like syncing a range, renaming a file, creating a file, etc).
Sounds about like the days it took to boostrap up Gentoo+X+KDE+etc back in the day.
A machine like that can be had for only 2-4$ hour on your favorite cloud computing platform.
And hopefully the code is sanely enough structured that you don't have to do a complete rebuild too often.
Lots of projects take a long time to build, so it's not a show-stopper by any means. I imagine you could also mix precompiled parts with parts you compiled from source too.
Just not to scare someone off, from building gcc. :] It's fun.
I agree it is unlikely, or at least would require a huge amount of work. Then again, Sun did it with Solaris, so who knows what the future holds?
If somebody had told me ten years ago that Microsoft would open source their .Net runtime, port SQL Server to Linux, replace their proprietary browser engine with Chromium, I would have asked that person to give me some of whatever they were smoking. ;-)
Shoutouts to Oracle re-closing Solaris. That was an incredibly pointless move.
Last time I heard anything about Oracle Solaris, they fired more than a thousands developers at once, and some people commented that Solaris development at Oracle was more or less dead. (I have no clue if that is true, however.)
It's still an unfortunate blow. A lot of open-source projects are only as popular and widespread because of companies that effectively champion them in a way that convinces other people or companies to jump on the bandwagon. IllumOS, by way of being the pet project of some fairly unknown software company, is hiding in obscurity at this point when it could have been a serious contender as Solaris.
This probably sounds silly, but I find it sad, personally, because Solaris is probably the second coolest name ever given to an operating system, after Siemens' BS2000.
IIRC, illumos is a loose community full of former Solaris devs, there's no one company behind the illumos kernel.
Joyent, the company behind the SmartOS distribution, I'd say is far from "unknown" — they started that whole node.js thing after all!
I have been using GNU/Linux and BSD on my personal machines since 2000, so the first part would not have blown my mind that much. For my needs (and Google's), quality operating systems were a commodity back then.
The second part, I don't know. Microsoft has been trying to move to a subscription-based model for a long time. Google Docs, GMail, Google Calendar were around back then, smart phones were becoming a thing. Microsoft moving away from traditional desktop and on-premises server software to a cloud-based model that would allow them collect "rent" instead of one-time license payments, that would not have sounded crazy. (Who knows - if they had tried to create a competing offer to Google's services that you did not have to pay for in sensitive data, they could have hit the Jackpot big time...)
Under those conditions, it makes much less sense for Microsoft to hold on to their code as they have done traditionally. But going from the company whose CEO publicly called FLOSS a "cancer" to a company that actively embraces it, that is a pretty huge change. When Nadella became CEO, I joked to a coworker that Microsoft was as good as dead, trying to go "cloud". I was obviously wrong on that one, and now I think if Ballmer had stayed as CEO, Microsoft would probably be much worse off.
[0]: http://googlepress.blogspot.com/2004/04/google-gets-message-... [1]: http://googlepress.blogspot.com/2006/10/google-announces-goo... [2]: http://googlepress.blogspot.com/2006/04/google-calendar_13.h...
You are correct, of course, none of that stuff existed in 2000. 2000 was just the year I started using GNU/Linux. ;-)
Ultimately, they'll still be able to sell windows like redhat, and it's the stuff that runs on Windows which is more important anyway.
At first, I was thinking that it would only be bad for the non-technical folk (i.e. other 99%) who wouldn't know how to re-install a better windows. But then, I remembered that even MS is having a hell of a time rolling out updates without breaking machines. All the different branded flavors of windows would just make getting windows updates that much harder or terrifying, I think.
Why not just reserve the trademark Windows to Microsoft? If other OEMs want to muck up their own builds they would have to brand it their own and risk their own reputation.
It's the same with Android. A very small percentage of people buy phones with pure Android OS on them. The rest of the non-Apple crowd buy whatever looks good at the store and calls it Android.
I would absolutely love to be proven wrong on all of this. I rarely use Windows (mostly for gaming) and otherwise a linux is my daily driver, so either way I'm not likely to be impacted much. Perhaps I'm just too cynical after all of the utter nonsense Lenovo and gang have pulled with windows in the past as it is.
If it was open source, it wouldn't be long before there were hundreds of forks that removed the telemetry, advertising etc. That's by far a net win.
That would be a change I’d love to see. But I think a better change would be for newer games not using DirectX and choosing Vulkan instead.
Would that ever happen? Well, if they can drop EdgeHTML..
The sad thing is Vulkan and DX12 are not gaining traction even on PC. Very few games support these low level apis , so adding support for Vulkan on Xbox seems pointless first and foremost.
Many critical components are deep inside Windows kernel, in dxgkrnl.sys, they are very hard to unbundle from the rest of the kernel.
Other critical components are in vendor-implemented drivers, both user mode (this part compiles shaders and implements many per-game compatibility hacks) and kernel mode (this one talks to actual hardware).
Fortunately, there’re already third-party implementations of D3D on top of something else.
Gallium 9, the main downside is no Intel GPU support.
DXVK currently only supports D3D 10-11 and WPF is based on 9, but apparently some people are working on D3D9 support.
There’s also VK9.
They could give away desktop licenses, even in the enterprise, and still rake in the cash from Active Directory and Exchange server licensing.
They probably make more from CALS than Windows desktop now.
They have zero interest of Mac software running elsewhere. They do have an interest for other software to be runnable under macOS / iOS without a major porting effort, but not a very great interest, I suppose.
However in 10 years no one has cared enough to start a project to do this, so I'm not too optimistic.
So I tried using the old GUI framework and boy was it a nightmare to customize anything. I remember having to override the default Button class and add like 50 lines of code just so I could get a custom background. This and the fact that C# back then couldn't do high scalability servers were what forced me to learn C++ and in my opinion QT is a much easier library to use than the old WinForms was.
Since WinForms' existing styling was the style of applications of the day, there was little reason to heavily restyle it. Honestly, if someone ran with the new open source WinForms and introduced a Windows 10 style that I could build with the same incredibly easy editor as the existing WinForms, I'd be set.
That's mostly because you're not supposed to be doing that sort of thing in the first place. Customizing widgets = inconsistent look and feel. Custom widgets = Inconsistent LAF, inconsistent interaction, no accessibility etc.
The idea of Win32 UI, WinForms etc. is that you have a look and feel dictated by the system, not by individual app developers, with the ultimate goal being not just a consistent look and feel of the whole system (including applications) but consistently applied patterns of interaction. This in turn makes computers easier to use.
Of course, modern UI frameworks, whether in the browser (JS) or outside the browser (QML, UWP, JS, ...) run completely counter to that.
I was trying to write a poker client so same thing, using normal buttons just wouldn't have made any sense. It would've been ugly as hell.
Modern UIs stray from a standard because standards are boring and if your app is boring then your not so boring competitor will snatch your users.
I actively judge apps with non-platform-standard UIs as worse than an equivalent with a standard UI.
That covers about 90% of Hollywood's output, and the reason for that is that you want a wide audience to purchase tickets. Only people that are good at navigating new interfaces appreciate novelty. That's a niche audience, but it intersects with the gamer audience (they're good at exploring new environments).
There are enough exceptions that whatever API you are using should accomodate developers in those cases. If people want custom UIs they'll get them somehow, you putting unnecessary roadblocks in the way will only annoy developers.
Managers don't care how you do it, they just want it done.
That's because the underlying widget set is as ugly as hell.
Ohh, the good old days...
That always puzzled me, even though I've seen some of Microsoft's reasoning and blog posts about it.
Microsoft has repeatedly stressed that you can't assume any particular version of Windows comes with a specific version of .NET preinstalled (or VC++ runtime, for that matter).
Windows already bundles various things, and the major .NET frameworks seem like the thing to bundle and preinstall, and they actually do[0], just not consistently or universally.
And, Windows Update can already update the .NET frameworks, in fact I recall that some new major .NET versions were treated as "recommended" installs by WU in the past and were automatically installed on systems that didn't already have them, but they aren't doing that consistently and universally either.
[0] https://blogs.msdn.microsoft.com/astebner/2007/03/14/mailbag...
Of course, that is a system-level change, which can potentially break other applications on your machine (if they're written badly and/or poorly supported). .NET Core removes that by supporting side-by-side versions and versions packaged with the app, but it certainly wasn't critical to assume a given machine already had a .NET Framework version in question.
Honestly, with Windows 10 now including .NET Framework updates along with feature upgrades every six months, and the fact that pre-Windows 10 versions of Windows haven't that many more years to live, it feels like that advantage isn't as big as it used to be anyways.
My concern is .NET Core may lead to a lot of unnecessary software bloat. Where Windows has the current .NET Framework, but we still have to have six versions of .NET Core installed, and then half the programs on the computer don't use those and have their own bundled versions as well. I find .NET Framework already being on-system to be a big perk of writing my app with it: My software is a 7 MB file because most of the code is already built into Windows.
I think Lazarus[0] is easier, especially when it comes to automatic layout stuff, but WinForms is very close. They're somewhat related as both are descendants of the classic Visual Basic RAD approach and Lazarus is basically an open source and cross platform clone of Delphi while WinForms implements a very VCL-like (VCL is Delphi's framework) API - which is natural since both Delphi and WinForms were designed by the same person :-P.
Beyond the above (which i think are all what WinForms provide, at least from the visual designer) the anchors can also be set so that instead of just "sticking" to a designed edge, they are set relative to some other control in the parent container with customizable gaps. For example you can configure (using a dedicated anchor editor window) that the left edge of an input box is 5 pixels away from the right side of the label control and the label control's top edge is aligned so that the label's center matches the edit box's center. Note that any control can be anchored to any other control, so if you have a form with 10 input fields you can anchor their left side to the same control (e.g. the longest label or a "guide" control) so that they align neatly.
The align property is enough for most cases and the anchor system covers almost the rest of the layout cases. Where those do not suffice, there are a few more dedicated options like the TFlowPanel container that flows controls in various formations as well as the ChildSizing property that allows for specifying some automatic layouts. TBH personaly i never had to use those though. Note that most of them can also be combined.
Finally each control also has constraints (min/max size) and spacing (margins) for each edge as well as an overall spacing.
Somewhat related, but you can also make pretty much any control dockable by setting its DragKind property to dock and DockMode property to automatic. Docking happens in "dock sites" which are basically any container (like a panel) that has its DockSite property set to true (and preferably, although not required, its AutoSize also to true) and since containers are regular controls they themselves can be laid out using any of the above options or be anchor targets for sibling controls. The framework handles the whole drag/drop, docksite resizing, creating popup windows for tearoff docks, etc. In fact the whole docking system is modular itself and there are a couple of different docking managers that provide quite advanced options.
Note that all i've mentioned so far are done with the visual designer, there is obviously more fine grained control by writing code.
The stuff with anchors being relative to other controls, though, sounds like it should be roughly equivalent to Java GroupLayout in expressive power. Which is neat!
MS’ problem is that Visual Studio is the only “real” software they produce that uses WPF - which also happens to be a flagship product. They need WPF to stay up-to-date but they can’t afford to invest their own FTE resources into it either when other products are more important as far as the C-levels are concerned.
I’m curious what this means for UWP XAML - as it has its origins in WPF. Can Microsoft use open contributed WPF code in UWP?
WinUI included in the announcement above is the UWP XAML controls and their "XAML Islands" wrappers, so Microsoft is directly taking UWP open source contributions now, too.
They can, because the open source version of WPF is MIT-licensed.
WPF, Windows Forms, and UWP are listed under the Windows-Only Desktop Packs section in the diagram.
https://blogs.msdn.microsoft.com/dotnet/2018/05/07/net-core-...
Things are a bit more complicated than that, I guess that's specifically why Microsoft is open sourcing "the desktop pack", because it is not multi-platform.
[1] https://blogs.msdn.microsoft.com/dotnet/2018/12/04/announcin...
I'm sure it wouldn't be impossible to kitbash this release with WINE and get it working on Linux.
Now that it's open source, the process should be even easier.
- quite buggy
- quite ugly
- does not support Wayland
- does not support accessibility
- is literally WinForms. It's a 90s era GUI toolkit.
I fail to see how this is a problem, mostly because the job it was designed to do (build guis for desktop applications) has seen little innovation since the 90s.
Also MS's lawyers may not be 100% clear about whether these libraries already include patented technology from other patent holders that MS may have licensed years ago.
MIT punts on the whole issue, so may seem "safer" to a lawyer when used with a giant existing code base. Apache is clearly the right choice for new development (for those who don't like GPLv3, anyway -- let's not get into that argument).
I've used WPF for about a day, and I never went back to using it. Not 'hating' on it, I just want to understand WPF and the incentives to open source it (I get it for .NET though).
I'd be interested in any association that can be made against previous versions of such libraries, and the newly released open source libraries. Are the 'releases' between the old closed source and that of the newly open source significantly different?
If so, and either way; I'd be interested in knowing what kind of changes were applied in direct action of the source being released. Was it just cleaning/linting of the code? Were there features that were otherwise inappropriate (security? quality?) that needed attention before release.
Things like alignment with child dependency license agreements, or overall quality (in code, testing, and deployment) are things I find extremely interesting. Was there some interesting 'inappropriate' language in the source from developers long gone. Could this have effectively been the opposite spectrum of what happened with event-stream https://github.com/dominictarr/event-stream/issues/116
I'm not explicitly saying it's any of my business. I can imagine a multitude of reasons that this history would never be provided. But... as above.. I can consider reasons, perhaps; it should..?
I don't mean to discourage release. I really appreciate it. Just some thoughts..
Edit: Minor readability
IIRC, while Paint.NET was under the MIT license at that time, porting to Mono was not possible because of the lack of WinForms. Not sure where I read that, maybe here: http://www.osnews.com/story/22843/Introducing_Pinta_a_Gtk_Cl...
Secondly, Paint.NET includes quite a bit of non-WinForms/WPF code by now, talking directly to DirectWrite and Direct2D in places and probably other things as well. It's very much a Windows-only application and porting it would require rewriting a lot of important core code of the application.
It reminds me of when the Windows 2000 source code was leaked and it showed how vulgar a lot of the comments were.
Start a new OS, along side Windows, based on Linux/Unix.
Make it as stable as Windows for the every-day user, because let's be realistic, even Ubuntu can't manage it.
Ship all new laptops/PCs with this new OS.
Continue supporting Windows/Server for the enterprise.
That would be so awesome.
As of automatic detection check my question on SO: https://stackoverflow.com/questions/51334674/how-to-detect-w...
I myself implemented the modern black menu style for a tray icon, so that the menu looks like the native tray icons. It's "just" a matter of owner drawing everything. Unfortunately, there is no secret "make my app dark" api in WinForms / WPF.
But as a long-time Windows programmer, I would liked to see parts of Win32 open-sourced, because it's the far more interesting (and efficient) part of what makes Windows... Windows.
Currently, the linked WPF repository is almost empty. Very little code, and not a single .cpp file. WPF's native layer is huge, wpfgfx_v0400.dll, PresentationNative_v0400.dll, etc., lots of complexity between .NET and Direct3D 9.0c.
I’m not going to say it can’t be done, but I will venture a guess that it’s going to be difficult and probably a lot of effort.
More effort than simply forking and porting to be X11/Wayland native? Not sure, but I wouldn’t dare to exclude the possibility.
I work at Microsoft and use WinUI but don't directly work on it other than reporting bugs :)
In the meantime, Uno is the closest thing we have:
It's based on WinRT, which is based on COM.
It would be mich easier to port it if the source code was available.
Personally I think it's too little and too late, Desktop development has had its day.