@eniko my theory: when .NET was created, Windows still ran on one non-x86 machines: the DEC Alpha.

I think the goal behind it, other than "make a better Java", was "everyone should be running Windows, but they might not be running it on x86-compatible hardware"

@eniko This is a really good question. There's a lot of interesting speculation, here. What's also interesting is that the information available *at the time* also feels like speculation. I did a DDG search for "pc magazine microsoft dot net" between 12/1998 and 12/2002 and all the stuff I found was really vague and markety. I think the most concrete claim I found was this: https://www.zdnet.com/article/the-evolution-of-the-net-technologies/ which claims it was written to promote "open standards" for servers(???)

Wild stuff. 

@eniko the whole point of .NET and C# were to have Java without having to follow the rules to say it was Java

Because heaven forbid that the Mighty Microsoft should ever need to follow rules set by anyone else

@eniko In the late ‘90s, Microsoft was worried about threats to the desktop monopoly. The biggest ones were from the web, because people who could replace a Windows app with a web app could then replace Windows with Macs, Linux, BeOS (which was about to be the next big thing briefly) and so on. Windows is not a great OS. Few people buy Windows because they want Windows, they buy Windows to run Windows apps.

They undermined Netscape in various ways, including bundling IE4 and building a load of Windows-only things into IE.

Java was another threat. Microsoft built J++, which was a good implementation of Java (faster than Sun’s) and also bundled a load of Windows-only things. In particular, it didn’t clearly mark the extensions (which Java implementations were required to do), so it was easy to think you were writing a portable Java App when you were actually writing a Windows app. Sun sued Microsoft over this, leaving them with good VM technology that they couldn’t put in products (the lawsuit wasn’t settled until a year or so after .NET was released but the writing was on the wall long before).

At the same time, Intel told everyone that Itanium was the future. x86 was going to die. An architecture transition had a risk of undermining the Windows monopoly because moving to a new architecture would reduce the value of legacy apps (if you are emulating the ISA, you might also emulate a legacy OS and run shiny new apps on a different system). Having an architecture-agnostic executable format would have made it easier to move.

Finally, looking as if you are able to transition to a different architecture gave Microsoft more leverage in talks with Intel. This made it easier to get features into the x86 architecture that Windows wanted (which is part of the reason why x86 is so awful now. The Windows team does not have good taste when it comes to proposing new architecture).

@eniko Because they thought that having a memory-safe, JIT compiled, multi-language VM and tools was something that could sell copies of Visual Studio, which would lead to more windows software, which would sell more copies of windows.

It’s not really more nefarious than that- make it nicer to write windows software so that there’s more of it so people keep buying windows. Cut off some of the reasons people might want to use Java for that purpose.

@eniko Microsoft first built J++ (their Java version) but the anti-trust settlements caused them to start over with something new: C# and what became known as .net, the idea being it would replace Win32 *finally*. But instead it became a divergent thing.

Thankfully and incredibly dotnet today is amazing and genuinely cross platform.

RISC-V is in progress which is really interesting, but Arm and x86 are stable. I doubt you’ll get MIPS or Sparc or PowerPC though.

@eniko when it came out there was support for more than just x86. MIPS, Alpha, PowerPC, and Itanium were all supported (for some capacity of supported) at one point in time

You can find some of this in things like "Rotor" (aka SSCLI - the shared source CLI) which was source available (not open source) .NET from back in the day

It just wasn't until much later that it became widespread enough to be more meaningful in production