GitHub under Microsoft and WSL inside Windows the decade when the world's most corporate software company decided it could not afford to lose its developers

In 2018, when Microsoft announced it was buying GitHub for seven and a half billion dollars in stock, a certain generation of engineers did a double take they would have bet against a decade earlier. The company that once treated open source as a competitive threat had just purchased the town square of open source. Two years earlier the same company had shipped, inside Windows, a way to run real Linux command lines natively, and then improved it until a full Linux kernel ran comfortably alongside the Windows kernel on millions of developer laptops. Skeptics read a hostile embrace into both moves; the people making the decisions read something much simpler: the developers were leaving, the developers had to stay, and whichever platform kept the developers would keep, eventually, everything else. This is the strategy behind the strangest decade of Microsoft's relations with people who write code, and it is less remote than it looks.
## The problem that no enterprise revenue could hide
The backdrop of the story begins with slow, unglamorous numbers. Through the late 2000s and early 2010s the gravitational center of software development drifted away from Windows. New frameworks were born in the open web's command line culture, the startup scene standardized on inexpensive Unix-like machines or Apple hardware that provided the same shell comforts, and server side computing consolidated around Linux to a degree that turned "cloud" and "not Windows" into near synonyms among the young. Developers pick stacks by where the documentation is fresh, the tooling is native, and the tutorial ends in success rather than apology, and by those criteria Windows had become an increasingly eccentric place for the fashionable kinds of work.
The company could tolerate losing consumer buzz; it could not tolerate losing the people whose daily habits decide what the next decade of software gets written on. Enterprise agreements, the machine's dependable engine, are sold to developers' employers, but only while developers still want the platform's tools inside those employers. When a generation of engineers begins its career unable to imagine working without a Unix shell, the corresponding generation of procurement choices follows a few years behind it, and procurement is where the money regroups. The threat was invisible on the quarterly sheet and perfectly visible in any university computer lab, and that is exactly the sort of threat that produces seven billion dollar decisions a few years late but finally decisively.
## Buying the town square and what the money actually purchased
GitHub in 2018 was already the default workshop of the open source world: tens of millions of repositories, an entire generation's muscle memory for pull requests, and the social fabric through which developers decide which tools are respectable. Acquiring it was therefore not really buying a product; it was buying adjacency to the world's working files of code, and, more importantly, proof of seriousness addressed at the audience that had trusted the company least. The price tag, paid in shares rather than cash, made the message sturdier still, because stock is what you use when you want the other side to share your future rather than take your money and leave.
The predictions of enclosure and ruin, which circulated instantly and in volume, failed for an instructive reason: the asset loses value the moment the community decides it has been captured, and everyone in the deal understood that. The new owner kept the site's culture broadly intact, made private repositories free within generous limits, folded in a continuously integrated build runner that became standard industry plumbing, and shipped a machine assisted coding tool trained on public repositories that moved the entire industry into a new argument about autocomplete. None of these moves required developers to love Windows. They required developers to keep living inside services owned by the company that makes Windows, which was always the point.
Critics called this embrace and worried about the second and third stages of that old saying. Time has been kinder to the observation that ownership of the town square does not require occupying the shops. The square is valuable precisely because everyone passes through it voluntarily. Post a guard at the gate, and the town relocates, which is why none has been posted and why the fences, carefully, remain more suggested than built.
## Building a Linux that needed no dual boot
If GitHub was adjacency by purchase, the Windows Subsystem for Linux was adjacency by engineering. Its 2016 debut replaced an ugly binary choice, your Windows laptop or your Linux tooling, with a single environment in which bash lived a short command away from PowerShell. The first generation accomplished this by translating Linux system calls into Windows equivalents, an audacious compatibility feat that ran impressively and then hit stubborn corners wherever translation grew thorny, most notoriously around the file system.
The second generation took the bolder path of simply running a real Linux kernel in a lightweight virtual machine deeply integrated with the host. File I/O between the two worlds got fast enough to stop being a tax, the Linux side could be updated like any other component, and the developer who needed Docker style containers, native grep pipelines, the true behavior of the toolchain their servers would run, could do it all without leaving the Windows desktop their company issued them. By the early 2020s the arrangement had become pedestrian in the best sense: another developer environment, only this one left nobody outside.
Why does the platform owner subsidize this? Because the war for developer attention is a war for defaults, and defaults are drafted at the moment a young engineer picks a laptop. A platform that says "bring your shell, your package manager, your containers; leave nothing behind" keeps the seat, the license ecosystem around the seat, and the cloud account these workloads will one day deploy to. The cloud vendor who also owns the developer's morning routine has quietly booked the future deployments those routines produce.
## The pattern: defaults, tools, cloud
Once GitHub and WSL are seen together, the surrounding pieces of the decade arrange themselves with the clicking neatness of a finished puzzle. The free, hacker-friendly editor that became the world's most popular coding tool lowered the barrier to writing code on Windows at the exact moment the friction was highest elsewhere. The package manager, terminal app and improved store story rounded off the remaining roughness. Azure supplied the destination the whole apparatus was always subtly steering toward, where the company's real margin lives. Identity, compliance and management tooling did the quiet work of making organizational adoption unremarkable.
The revenue strategy here is not subtle once stated: it is hard to be certain exactly which dollar follows which developer habit, so the only robust policy is to make every habit comfortable inside your walls and to let the dollars sort out their own routes. This is why the offerings skew free at the point of individual use and priced at the point of organizational dependence. It is also why executives speak about developers in the register of long term relationships rather than segments; the audience in question hears pandering instantly and forgives usefulness forever.
The pattern is old enough to have ancestors. Engines once paid for tools; seat licenses paid for ecosystems; the hosted era pays for both with attention and stickiness. What is distinctive about Microsoft's version is simply its completeness: source hosting, code writing, command line culture, and deployment target, all continuously available without leaving the house. Competitors own pieces. For a stretch of years, only one vendor owned the full morning of a working programmer.

The supporting cast that made the claim believable

Grand strategy in software is only ever the sum of small courtesies to practitioners, and the supporting cast here mattered as much as the headline acquisitions. The free cross platform code editor that emerged from the company mid decade, Electron interiors and all, became the global default by being the easiest possible first download for a new programmer. The rebuilt terminal made tabs, panes and modern fonts part of the stock Windows experience instead of a weekend project. The package manager discussion, resisted for years, ended in a working tool because the practitioner press would not let it fade. Even the machine readable documentation culture changed shape, from reference pages that assumed enterprise staff to learnable paths addressed to the genuinely new. None of these items could carry a keynote, but they carry mornings, and mornings are where platform loyalties are written.

A useful litmus for this phase lies in what did not get said. The decade produced almost no public rhetoric about defeating Linux, converting developers, or winning hearts in parallel with the action. The doing was allowed to speak, which thoughtful observers took as its own message: whatever this was, it was not a demand for affection. It was an infrastructure play for continued presence, and infrastructure, unlike affection, submits to quarterly planning.

Whether it worked, and for whom By its own goals, the strategy has a favorable report card. The brain drain narrative softened; the company that developers once performed public disdain toward is now the dull respectable answer in a room full of laptops running a hundred flavors of shell atop one OS. GitHub grew under its new parent, kept its culture, and even expanded the notion of what "source control" means into a whole hosted workflow. WSL took a sentence that began "unfortunately we use Windows" and turned it into an unremarkable setup note. Azure's developers-first narrative acquired a plausible beginning, middle and morning routine. It is worth marking against the triumphalist read, though, that capture of a community remains a permanent negotiation rather than a conquest. The accommodations that keep GitHub trusted are obligations, and the usefulness that keeps WSL installed is an engineering treadmill with no finish line. The company bought the gym and must keep the equipment new; the moment the audience discovers the machines unmaintained, it moves its routines again, faster than they arrived. Empires of code are cheap to enter and expensive to hold, and the current owner would be the first to say so in a candid earnings call. ## The long memory of a toolmaker There is a pleasing historical closure to the whole arc. Microsoft began as a tools company for programmers, selling a BASIC interpreter before it sold anything else with broad recognition, and every generation of its leadership has found its way back to a version of that first instinct: the durable asset is never the box, it is the relationship with the people building on the box. The 2010s simply forced the company to extend that instinct across a frontier the founders barely imagined, one in which half the world's software culture lived outside the fence labeled Windows. The answer turned out not to be "make them come in," but "bring the fence along." Seen from that angle, buying the world's repository and embedding its shell were the same sentence written in two departments: you no longer have to choose between our platform and your habits; we will hold your habits until they are indistinguishable from our platform. Whether this reads as magnanimity or permanence engineering will be for each generation of new developers to decide, presumably without noticing they are deciding it, while their terminal opens on the first try in a host machine that once made such openness unthinkably strange.