Today you can see that Microsoft is an open-source company and really does build open-source software with all the essential elements of open source, like accepting pull requests from the public. More Microsoft employees contribute to open source projects on GitHub than any other company in the world. Building open source software via GitHub is the way a lot of programmers at Microsoft make their living now.

To some, it may appear that this move to open-source development started back at the Build conference in 2014. That was the day that Anders Heljsberg took the stage during the keynote to publish the Roslyn compiler on GitHub as an open-source, cross-platform tool. Or perhaps it started in the fall of 2014 with the announcement of.NET Core. But those events were hardly the beginning, although you could consider those events as the “end of the beginning” of a new Microsoft, A Microsoft that embraced open source.

Going back to the actual beginning of Microsoft in 1976, when Bill Gates and Paul Allen created the company, Bill had a great insight into the future of software. In those days, software, at least software for the early microcomputers, was almost entirely free. It was also unique to the particular microcomputer: Each new microcomputer needed new programs. The sharing of code was common.

In that period of rapid innovation of microcomputers, companies often competed with their own earlier products or announced new products so early that it sabotaged existing sales. The lack of software was a constant problem, and developers had to pick their favorite hardware to develop for, only to have the company make a new computer that the old software wouldn't run on - or go broke.

Bill Gates saw the need for software to be a product unto itself, especially software that could be coded once and executed on a variety of computers. In 1976, he wrote an open letter to the hobbyists at the Homebrew Computer Club, encouraging them to stop sharing software, specifically commercial software. In the letter, he pointed out that if no one can make a living from software, why would anyone go to the effort to write and maintain it?

The idea of retail software in microcomputers was novel, and it required legal protection. The protection came in the form of the End User License Agreement (EULA), which changed the definition of ownership of software: You never actually own software, just a limited license to use it. Included in those limits is protection for the developer for liability. Any compensation for harm caused by the software is limited to the price of the software, typically.

With software as the business and protection in the form of the EULA, commercial software for microcomputers snowballed, and Microsoft was one of the leading companies making software manufacture into their business and staying (for the most part) out of the hardware business.

As a developer at Microsoft, you not only wrote proprietary closed-source software that the company sold but also filed patents for any innovative aspects of the software. The number of patents you secured around your code affected how much Microsoft paid you. The creation of software patents is part of a broader “IP-Moat” strategy that led to numerous patent-based lawsuits around software between the various software players in the 1980s and 90s until eventually, the cross-licensing of patents between the companies became normal.

Building software that ran on many microcomputers was an early strategy at Microsoft, and it expanded when they moved into the operating system business, first with MS-DOS and ultimately with Windows. When combined with the IBM PC architecture that allowed multiple hardware manufacturers to make compatible PCs, Microsoft grew to dominate the microcomputer market by the end of the 1990s with operating systems and development tools.

Microsoft wasn't the only beneficiary of its dominance; a vast ecosystem of vendors and independent developers made their living building software and products for Windows.

The dominance in the marketplace came with consequences also, ultimately leading to a court case brought by the U.S. Department of Justice around monopolistic behavior at Microsoft. By November of 1999, Judge Jackson declared Microsoft a “predatory monopoly.” The judge ordered the company broken into two: One company would be an operating system company and the other company would be everything else.

The breakup never happened. In January 2000, Steve Ballmer took over as CEO of Microsoft, Bill Gates stayed on as chairman of the board and also moved into a chief architect role, overseeing all of the products that Microsoft made. Steve's first mission as CEO was to keep the company together, and as we know, he succeeded, resulting in the consent decree with the US government in November 2001.

Part of that consent decree included Microsoft being more open about its source code. Some of the complaints from the industry around Microsoft that led to the DOJ court case had included concerns that Windows was hostile to some third-party software. Although there was never any evidence of this being true, Microsoft, as part of the consent decree, did agree to share part of the source code of Windows with these third-party companies so that they could better understand how Windows interacted with their software.

Was this open source? Far from it. It was shared source, and that sharing took place under specific circumstances.

It was into this world that .NET was born. Steve Ballmer announced the development of .NET the PDC conference in 2000. Steve talked about .NET at the keynote as “a new platform based on Internet Standards.” He also announced the publication of the C# specification and the Common Language Infrastructure as ECMA specifications. It's important to remember that this was in the middle of the consent decree negotiations with the DOJ. Microsoft was very focused on showing that it was a more open company than it had been in the past.

Those ECMA specifications would inspire a young man by the name of Miguel de Icaza. Reading those specifications, he decided that he liked C# and the whole concept of .NET. In July of 2001 at an O'Reilly Conference, he announced the development of Mono: An Open-Source implementation of .NET for Linux.

It's interesting to note that the month before (June 2001), Steve Ballmer said in a newspaper article that “Linux is a cancer.” He would, much later (2016), change his position on that statement.

Microsoft continued opening up its source code around .NET in 2002 with the release of the Shared Source Common Language Infrastructure that was code-named “Rotor.” Rotor included the .NET Runtime, base class libraries, and a C# compiler, but removed all the Windows-centric technologies.

Rotor had what Microsoft called an “academic research license,” so it wasn't open source - more like source open. Anyone with academic credentials could request a copy, so Rotor was more broadly available than the source code for Windows. Academics were only able to read the .NET code to understand behavior. There wasn't any way to compile the code for .NET or to use it in an application directly.

The open-source story of .NET goes quiet for a few years after the release of Rotor, but .NET itself evolved rapidly, releasing 1.0 in February of 2002, 1.1 in April of 2003, and 2.0 in November of 2005. Microsoft was doing its best to be a more open company with the advent of things like Channel 9, presenting the face of the developers at Microsoft who built products like .NET. Another aspect of openness was the willingness to show off the earliest bits of its next operating system, code-named Longhorn, although one could argue that they showed those bits off a bit too soon.

By 2006, .NET 2.0 was a relatively mature product, and developers had built large applications in ASP.NET WebForms. There were challenges around the maintainability of WebForms: The architecture of WebForms had focused on making Web development feel like WinForms development, hiding a lot of the metaphors of Web development. It was easy to learn and code in, but creating maintainable and testable Web applications was very difficult.

In the same time frame, David Heinemeier Hansson (DHH) was developing Ruby on Rails, first released as an open-source project in July of 2004. Developers fell in love with the Ruby on Rails approach to building Web applications, with lots of built-in automated testing and rapid development features.

There was pressure for ASP.NET WebForms team to offer something that could compete with Ruby on Rails. The focus on modern Web development led to the Mix conference, which first ran in Las Vegas in March 2006. The subtitle of Mix06 was “the next Web now.” It was at the Mix06 conference that Microsoft announced the creation of CodePlex as a so-called “source forge” for open-source projects. One of the first successful projects created on CodePlex was the AJAX Control Toolkit that brought the power of asynchronous JavaScript programming to mainstream Microsoft web developers .

Also announced at Mix06 was Internet Explorer 7 almost five years after Microsoft shipped Internet Explorer 6 and WPF/E, or Windows Presentation Foundation Everywhere, which would eventually be known as Silverlight. The first CTP of Silverlight would ship in December 2006.

In 2007, the energy around open source and Microsoft technologies peaked with several different fronts opening at once. The first was ASP.NET MVC, based on the Model-View-Controller software design pattern. Built to address the challenges of ASP.NET WebForms, MVC would also work alongside WebForms while offering a more maintainable approach to Web development.

The next front in open-source at Microsoft was a movement of open source-minded .NET developers, a group that would eventually be known as ALT.NET. At the time, a lot of developers building on the Microsoft stack didn't consider open-source libraries or tools at all. That point of view existed within Microsoft as well: Perhaps a form of Not-Invented-Here syndrome, Microsoft tended to build tools for developers even when there were excellent open source tools available.

The final front comes in the fall of 2007, Scott Guthrie began recruiting folks like Scott Hanselman, Phil Haack, and Rob Conery, all people with strong backgrounds in open source technologies (some people would call them “Scott Guthrie's Ninja Army”). On Phil Haack's blog at the time, he mentioned seeing a product that inspired him to want to be part of Microsoft. That technology was the prototype of MVC.

All of these fronts came together in October of 2007 at the ALT.NET Open Space Conference in Austin. Scott Guthrie had been invited to keynote at the conference and surprised the attendees with the first public demonstration of ASP.NET MVC. He also announced that ASP.NET MVC would be an open-source project published on CodePlex.

At the same time, Microsoft announced that the .NET Framework 3.5 libraries would be available under the Microsoft Reference Source License (MS-RSL). The MS-RSL opened up the source code of the .NET Framework to anyone who wanted to look at it, so in that sense, it was an expansion of the Rotor project back in 2002 that was for academics only. Still, the MS-RSL wasn't making the .NET Framework open-source; the primary purpose of the Reference Source was to help in debugging applications built with .NET.

The development of ASP.NET MVC did not take place directly on CodePlex. The developers at Microsoft working on MVC wrote code into internal source control, build, and test systems. Periodically, a version of ASP.NET MVC was published to CodePlex for the public to explore. On the positive side, a lot of external developers took MVC out for a spin and gave detailed feedback to Microsoft through CodePlex. On the negative, there wasn't any way for those same developers to directly contribute code to the MVC project.

But building MVC through CodePlex did make MVC better, if perhaps delivering it a bit slower; the first Community Technology Preview (CTP) of MVC arrived in December of 2007, with version 1.0 coming in March 2009. At that time, Microsoft chose to license MVC with its own Microsoft Permissive License (MS-PL). Microsoft eventually changed the meaning of MS-PL to the Microsoft Public License. Although quite a permissive license, the open source community heavily criticized Microsoft for creating separate licenses - they felt it unnecessary. Better to use one of the existing licenses than make a new one.

During the development of MVC 1.0, there were significant conversations on CodePlex about the problems of DOM tree traversal. The Web browsers of 2008 didn't make it easy to find HTML elements on a Web page. Tooling for DOM tree traversal started to be added to MVC, then proposed as a separate library. But the solution already existed in the form of the open source project called jQuery, created by Jon Resig back in 2006. It was community pressure on CodePlex that pushed Microsoft to resist Not-Invented-Here and consider using jQuery with MVC.

This push resulted in jQuery being included in the box for Visual Studio 2010 - the first time any Microsoft product had included an open source library. And Microsoft didn't just add it in Visual Studio; they committed to making contributions to the jQuery project. The MVC team and others needed features in jQuery to make their products work the way they wanted them to. The contribution process was a great educational moment for Microsoft's developers, contributing to a project they didn't control but on which their products depended.

Although the inclusion of jQuery was a point of celebration for fans of the open-source movement, it also created a lot of concern for more traditional Microsoft development customers. At the time in 2010, it was common practice for enterprises to have a strict “no open-source” policy for all software projects. Microsoft found itself in the remarkable position of having to defend open source technology to its customers.

The tide, as the saying goes, was turning.

The increasing popularity in open source libraries for .NET led to installation and versioning problems. A developer could end up using a dozen libraries from a dozen different sources, making building and maintaining an application very difficult. The solution to this problem is a package manager, for example, the Ruby on Rails world has Ruby Gems. Scott Guthrie tapped Phil Haack to lead the package manager project, which would eventually be named NuGet. NuGet shipped in October 2010.

In 2011, Damien Edwards and David Fowler, while working in the ASP.NET team at Microsoft, started a side project they called SignalR. The SignalR library took advantage of Web sockets in modern browsers to provide real-time functionality, while at the same time wrapping up the complexity of solving the same problem for older browsers. They also built SignalR as an open-source project on GitHub.

GitHub started back in 2008 as a source code repository over top of the Git protocol initially developed by Linus Torvalds for the development of Linux. As a distributed source code control solution, it worked well for open source projects with many contributors. GitHub was also great at helping developers and project leaders communicate about the projects they were working on - almost a kind of social media space for software developers. By 2012, the ASP.NET team would have a repository on GitHub.

2011 was the first time the public heard about Roslyn. Roslyn was a new C# compiler written in C#. This was standard practice for most programming languages, almost a sign of maturity. You know your programming language is grown up when you can build a compiler for your language in your language. The ability to create a compiler for C# in C# had been possible for years, but the demands on the C# team for new features kept pushing the compiler rewrite to the back burner.

One of the things that brought Roslyn to the forefront was Visual Studio. The Visual Studio editor analyzed your code as you wrote it, highlighting problems as it detected them. It was a powerful productivity feature, but to make the analyzer work, it required a separate C# language interpreter. As C# grew, writing every language feature twice got expensive, and any inconsistencies between the Visual Studio C# interpreter and the C# compiler were hugely confusing to developers. Roslyn became the solution as a “compiler-as-a-service” that could handle both roles. It also meant that the developers creating C# were coding in C#.

Although the team created Roslyn using internal tools, they did publish versions to CodePlex. It wasn't an open source project, but that would change.

Another significant change in the C# space was the departure of Anders Heljsberg - not from Microsoft, but rather from the C# team. Anders had been working on C# for more than ten years and was ready to do something new. His protègè, Mads Torgersen, took the helm of C# while Anders went to explore a new problem space and that space was JavaScript.

Although Anders had focused mainly on creating statically typed languages like Delphi (which was Object Pascal) and C#, he did have a fascination with dynamic languages like JavaScript. In his mind, the challenge was building sustainable software with them. Once projects written in dynamic languages get to a certain size, it becomes very challenging to maintain them.

In 2011, JavaScript was hot; the work happening in the various browser teams, including Internet Explorer (Chakra), Chrome (V8), and FireFox (Nitro) around JavaScript had made the language faster, more robust and more capable. NodeJS was gaining traction, letting JavaScript programmers write code on the server-side as well as in the browser. Anders was keen to make JavaScript even better. He assembled a team.

What came out of the team's efforts was TypeScript, a strict syntactical superset of JavaScript with the ability to add static typing to JavaScript. And it was open source from the beginning, initially released on CodePlex in 2012.

The open source community loved TypeScript from the start. Although there had always been critics of the various open source efforts that Microsoft had made, the principal complaint about TypeScript from the beginning is that it didn't support enough platforms or have enough declaration files for library support. But, being an open source project, the community could fix those problems faster than Microsoft - and they did.

Early on in TypeScript's life, Palantir Technologies contributed a plug-in so that the users of the Eclipse IDE could code in TypeScript. And contributors to JavaScript libraries of all kinds created TypeScript declaration files. The open source community loved TypeScript and helped to make it better.

The embrace of TypeScript by the open source community had a massive effect on Microsoft as well. It became the talking point that Microsoft could be an open source company.

The need to organize open source efforts at Microsoft led to the creation of MS OpenTech. MS OpenTech was created as a wholly owned subsidiary of Microsoft focused on open-source development. The most visible part of its efforts was making sure that important open source projects, like Redis and MemCacheD, for example, ran great on the Microsoft stack. Microsoft developers moved to MS OpenTech to contribute to these open-source projects.

MS OpenTech was also a place where Microsoft developers worked to make existing closed-source software into open source projects. Developers of the closed-source project would work with Microsoft patent lawyers to review all the patents filed for the project. Making that project open source meant invalidating the patents, so a lot of time was spent sorting good from bad, valuable from non-valuable.

An example of this transformation was Entity Framework, first released as a closed-source product with .NET Framework 3.5 SP1 back in 2008. In 2012, Scott Guthrie announced that Entity Framework Version 6.0 would be open-source, and it released under the Apache 2.0 license in 2013. This release came alongside the ASPNetWebStack that included MVC, WebAPI, and Web Pages, an entirely open source set of tools under the Apache 2.0 license with source code on GitHub and distributed via NuGet.

Microsoft had exercised its open source muscles in a variety of ways, starting projects from scratch, like MVC, as open source projects. They were distributing third-party open source libraries like jQuery as part of a product offering and making contributions to existing open source projects. And perhaps most remarkably, taking closed-source projects like Entity Framework and turning them into open source libraries. It was a huge change at Microsoft, but bigger changes were coming: The Cloud.

Back at the Microsoft Professional Developers Conference in 2008, chief architect Ray Ozzie announced Windows Azure as Microsoft's cloud offering. The first public offerings came in February of 2010 with support for SQL Azure, PHP, Java, and .NET. The cloud was new then, Amazon had gotten to market a couple of years before, but existing Microsoft customers were not in a hurry to move. At that time, Steve Ballmer said “For the cloud, we're all in.”

By 2013, the struggles around Windows 8 and the shifts in the marketplace had made it apparent that the future of Microsoft lay in the cloud. For decades, Microsoft had focused solely on building products and tools that sold copies of Windows. Now Microsoft was making Azure its primary focus. As part of the refocusing of Microsoft, Steve Ballmer announced his retirement: Thirteen years as CEO was enough, and the search was on for his replacement.

While that search was taking place, there were serious conversations about what development tools made sense in a cross-platform and open source Microsoft. Although .NET may have come into the world back in 2000 as “a new platform based on Internet standards,” it was also tooling to let enterprise developers build applications for Windows. Deep in the core of .NET was Windows: the Common Language Runtime was a thin wrapper over various Windows APIs.

A team formed to explore what a new .NET would look like.

In February of 2014, Satya Nadella became CEO of Microsoft. By April of 2014, he was keynoting at the Microsoft Build conference and announced that Windows would be free on all devices that have a screen nine inches across or smaller. And this is the same keynote mentioned at the beginning of this article where Anders Heljsberg published Roslyn to GitHub as a cross-platform, open source C# compiler-as-a-service. Version 1 of TypeScript also shipped at Build.

The .NET Foundation was launched at Build 2014 as well; similar to the Apache Foundation, it serves as a management point for .NET open source projects. At Build, numerous .NET projects were committed to the foundation, including ASP.NET MVC, Web API, and Web Pages, some of the original open source projects at Microsoft.

By the fall of 2014, Microsoft announced .NET Core: a complete rewrite of .NET as a cross-platform, open source development framework. It will take 18 months for version 1.0 to ship. Still, Microsoft succeeded in the goal to maintain as much compatibility with the original .NET Framework as possible while creating a new runtime environment that supported executing on Windows, OS/X, and Linux.

Not all of the .NET Framework came to Core: System.Web, the namespace where ASP.NET WebForms lives, wasn't rewritten. Profoundly intertwined with IIS, the rewrite of System.Web would have taken years and provided questionable benefit for the effort. Later, other libraries like WCF ended up in a similar situation. Developing a framework for twenty years means that some parts do get old.

In many ways, Microsoft became an open source company in 2014. On GitHub, the github.com/microsoft repository opened, and a vast array of projects from numerous Microsoft teams developed there. The new open source development style is very transparent: Some teams stream their team meetings, publish the notes of those meetings in the GitHub repositories of their projects, and interact continuously with internal and external developers about ideas and issues around the projects.

There are no secrets: Anything you want to know about an upcoming version of an open source product is there for you to read. Better still, you can contribute to the project with ideas and code. The cycle time from concept to code gets short: there is delight when you can discuss an idea for a feature in a Microsoft project with the team via GitHub and then see it show up as a preview build - sometimes in days!

The Build conference in 2015 saw the release of Windows 10: Microsoft announced it as the “last version of Windows.” Build 2015 also saw the release of Visual Studio Code. Based on the Electron framework developed at GitHub, VSCode is a cross-platform source control editor that has many of the favorite features of the Windows-only Visual Studio. But unlike Visual Studio, VSCode is not an all-encompassing IDE. Instead, it's a brilliant code editor with excellent extensibility. Programmers flock to it, and not just .NET developers - it became a favored tool for all sorts of Web developers, Python developers, and more.

2015 also saw the end of MS OpenTech, with all the technology and staff moved into Microsoft. Why do you need a separate subsidiary for open source development when you're an open-source company?

The growth of Azure brought Microsoft's relationship with Linux full circle. In the Azure marketplace, where users of Azure can select products and services, there are several flavors of Linux: SUSE, Ubuntu, and Debian, among others. In November 2015, Microsoft completed an agreement with Red Hat to bring Red Hat Enterprise Linux to the marketplace as well, providing direct support in Azure for all the major enterprise Linux flavors. So much for Ballmer's declaration of open-source being a cancer.

Another circle was completed in 2016 when Microsoft acquired Xamarin. Miguel de Icaza had embraced .NET in its earliest days, creating the Mono project as an open source implementation of .NET for Linux, the first version shipping in 2004. By 2011, Miguel, with his friend Nat Friedman, formed Xamarin to focus on building implementations of Mono for iOS and Android.

The idea that you could write mobile and tablet applications for iOS and Android using C# was hugely compelling for developers in the .NET space, and they flocked to the toolset. Bringing Xamarin into Microsoft not only expanded the team working on mobile and tablet development, but it also opened the doors for new opportunities for the Xamarin folks, including Nat and Miguel.

The business of open source projects changed the way that companies compete. An example of this new form of competition is Kubernetes. By 2016, building applications using Docker containers are becoming very popular, and there is an array of container orchestration tools available. As cloud vendors, Amazon, Microsoft, and Google all have container orchestration offerings: Amazon has Elastic Cloud, Microsoft offers Azure Service Fabric, and Google uses Kubernetes. Of the three approaches, only Kubernetes is an open source project.

There are also third-party container orchestration engines available like DC/OS and Meso. Most of the time, software developers like the idea of a choice of products, but there's also a point where it represents a fragmented market. Selecting the offerings from Amazon, Microsoft, or Google meant locking into a single cloud vendor. Going with other offerings meant more maintenance and effort dealing with potential incompatibilities.

Kubernetes may not have been the most sophisticated of the orchestration engines at the time but being an open source project meant that it wasn't difficult for Microsoft to implement a Kubernetes service on Azure. Hiring Brendan Burns, one of the founders of the Kubernetes project, didn't hurt either. Not long after Microsoft's move, Amazon, too, had an implementation of Kubernetes available as a service.

By 2017, folks from Amazon, Microsoft, Google, and more were contributing to the project, and Kubernetes was more of a consensus around orchestration than a competition. All of the energy poured into Kubernetes made its ecosystem snowball, creating a proliferation of tools for monitoring, deploying, and securing containers - and a growing pool of people skilled in working with Kubernetes.

Could you consider Kubernetes a monopoly? There are still other container orchestration engines, but Kubernetes is dominating. And no one company has control over Kubernetes; as an open-source project, anyone could fork the source and build a version of it. But there's an advantage to working together in the form of that growing ecosystem. That's one of the benefits of the open source world: the code isn't the asset, the service is. And the service is made more valuable with collaboration.

This collaboration and consolidation mantra spreads further when Microsoft commits to shutting down CodePlex, moving almost all the projects there over to GitHub. To this day, CodePlex is still running, but as an archive of the old projects. Should you visit those projects, you'll see that, for the most part, they say the same thing: Moved to GitHub!

Also in 2017, .NET Core 1.1 and 2.0 were shipped. Along with the expanding surface area of the cross-platform and open source version of .NET came a new maintenance strategy. For years, Microsoft built software with ten-year support agreements; that is, once development stops on a technology, Microsoft guarantees maintenance support, like security patches, for ten years. This model made sense when new versions of products shipped every 18-24 months. But at the modern cadence of shipping software several times a year, old versions need to be dropped.

For .NET Core, Microsoft alternates between a short-term version supported for three months after its final patch and a long-term support version supported for three years. The goal was to encourage developers to keep their applications evergreen, that is, to be able to build them with the new bits and have confidence that their software would keep working. Static software is dead software.

Microsoft's commitment to GitHub hit its crescendo in 2018 when it acquired the company. GitHub had never been a particularly profitable company on its own, but it was a vital part of the developer ecosystem. When word leaked that Microsoft was making the acquisition, there were some protests on popular open source forums: That was tamped down by other members of those communities saying, “Have you looked at Microsoft lately? This is the best thing that could happen for all of us!”

Nat Friedman, the former CEO of Xamarin, now became the CEO of GitHub, a wholly owned subsidiary of Microsoft. For the most part, the only change that Microsoft made at GitHub was to make unlimited private repositories free. Development at GitHub accelerated as more people were able to work on the products.

Effectively, the acquisition of GitHub let Microsoft protect a vital part of the open-source world, a part that Microsoft itself depended upon heavily.

Microsoft's moves around Linux continued in 2018 as well, when it joined the Open Invention Network (OIN), an open source patent group designed to protect Linux from patent lawsuits. Microsoft's library of 60,000 patents became open source and available to OIN members. The release wasn't of every patent that Microsoft held; lots of Windows and Azure related patents remain held close.

Protecting Linux made a lot of sense for Microsoft; after all, they were building their own flavor of Linux for the Azure Sphere product. Azure Sphere is part of Microsoft's Internet of Things offering, with a focus on building secure devices. The hardware, firmware, and Linux operating system maintain secure encryption and security, one of the key problems in the IoT space.

And the moves to cooperate around key technologies continued in 2019 when Microsoft rebuilt its Edge browser using the open-source Chromium rendering engine - the very same rendering engine that Google's Chrome browser uses. The switch to Chromium didn't come out of the blue; Microsoft and Google had collaborated for years over Web standards and often demonstrated new feature ideas in their respective browsers.

But the Edge browser never gained a large following. Chrome had been the dominant browser for years. By using the Chromium rendering engine, Microsoft could guarantee that this new Edge browser would render pages the same as Chrome, and that the competition in browsers would focus more on the other aspects of Web browsing, not just how the Web page looked on the screen.

In 2019, .NET Core 3 shipped two versions as well, bringing a new idea: platform-specific libraries. New versions of WinForms and WPF were released, available only for Windows but made available as an SDK for .NET Core 3. By separating off the Windows-specific parts, .NET Core kept being cross-platform but added new capabilities to help client-side .NET developers building apps for Windows. The new version of WinForms in the SDK supported high-DPI screens, a long sought after feature for WinForms developers.

It's 2020, and a new decade has arrived, and Microsoft is an open-source company. Not completely, but certainly where it matters.

There's a push to unify the .NET Frameworks. Developers building applications in the older Windows-only version of .NET are concerned that they'll be left behind at some point. Microsoft has announced that the next version of .NET is called .NET 5. The underpinnings of .NET 5 are .NET Core, preserving the cross-platform and open source aspects. On top of that, there'll be the various Windows-specific libraries that developers need. Not all of them: Some tools, like WCF, are too costly to make the migration.

The open source community can step up to help these potentially stranded libraries. Microsoft has released their prototypes of an open source version of WCF on GitHub - far from feature-complete, it's a start toward making an open-source version of WCF. But there's also a healthy conversation going on for moving to more modern communication approaches, like gRPC.

That's the nature of open source coming to Microsoft: Choices about how to move forward with any technology. And the community is better for it.