Get AI summaries of any video or article — Sign up free
Microsoft Cracks Down On VS Code Forks thumbnail

Microsoft Cracks Down On VS Code Forks

Theo - t3․gg·
5 min read

Based on Theo - t3․gg's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

April 2025 introduced a restriction error that limits certain Microsoft language extensions to specific Microsoft products, breaking them in VS Code forks like Cursor and Windsurf.

Briefing

Microsoft’s tightening of licensing and distribution rules for Visual Studio Code extensions is breaking key language tooling in VS Code forks—most visibly C++ (and also .NET and other extensions) inside editors like Cursor and Windsurf—leaving developers suddenly unable to use extensions they previously relied on. The disruption matters because VS Code forks exist largely to inherit the VS Code extension ecosystem; when Microsoft restricts where certain extensions can run, those forks lose one of their core advantages overnight.

The immediate trigger is a new error message appearing in April 2025: certain Microsoft language extensions “may only be used” inside a defined set of Microsoft products (including Visual Studio, Visual Studio for Mac, Visual Studio Code, and Azure DevOps). The restriction is especially painful because the affected extensions are not open-source in the usual sense. Even when some parts appear under permissive licenses, key runtime components ship under more restrictive proprietary terms, creating a legal and technical barrier for forks that embed or redistribute the extension binaries.

At the same time, Microsoft has been reducing the ability to obtain extension packages directly from outside the official Microsoft Store. A previously available “download extension” button was removed from the VS Code marketplace browser flow in February 2025, and the change appears to have been motivated by internal version-handling issues—particularly around pre-release versus stable versions. That matters because many fork ecosystems depended on importing or manually installing extensions from the official marketplace; once the download path is removed, the workaround becomes harder.

The broader context is a long-running chain of “platform inheritance.” The transcript traces how modern extensible editors evolved from Sublime Text’s community marketplace model, through Atom’s Electron-based, JavaScript-friendly approach, into VS Code—positioned as Microsoft’s “Visual Studio light” built to capture the extensibility momentum Atom helped popularize. Cursor, in turn, is described as a fork-like product that rides on VS Code’s extension infrastructure: it moved from CodeMirror-based foundations to VS Code-based foundations (via VS Codium), and it previously relied on Open VSX for extension distribution before shifting toward a Cursor marketplace.

A key claim is that Cursor’s marketplace likely functioned as a wrapper around Microsoft’s official extension ecosystem, which may have sat in a gray area under Microsoft’s terms until stricter language was published in January 2025. After that, Microsoft’s later enforcement—removing download access and restricting extension usage—hits forks more directly. The transcript argues that this enforcement looks coordinated at the surface level, but likely came from multiple teams making separate decisions: the download-button change, the agent/MCP push in VS Code, and the extension restrictions may not share a single master plan.

Still, the practical outcome is clear: VS Code forks can no longer assume Microsoft language extensions will work the same way everywhere. The likely path forward, according to the transcript, is a mix of importing what still works, pushing more developers toward Open VSX publishing, and building open alternatives for proprietary pieces—especially in areas like C++ runtime components and .NET experiences. Developers are left balancing frustration with Microsoft’s enforcement against the reality that fork ecosystems may need to reduce dependence on Microsoft-controlled extension distribution and licensing.

Cornell Notes

Microsoft’s enforcement of new rules for Visual Studio Code extensions is breaking language tooling in VS Code forks such as Cursor and Windsurf. In April 2025, Microsoft language extensions (including C++ and .NET) began showing errors that restrict them to specific Microsoft products, and the extensions’ licensing is not fully open-source in practice. Earlier, Microsoft removed the marketplace “download extension” button in February 2025, making it harder to obtain extension packages outside the official store. The transcript places these changes in a timeline: Cursor moved from CodeMirror to VS Code-based foundations, then introduced a Cursor marketplace that may have relied on wrapping the official extension ecosystem. The result is a shift away from “forks inherit everything” toward forks needing more open alternatives and more reliance on Open VSX.

What changed in April 2025 that made C++ and .NET extensions stop working in Cursor and Windsurf?

A new restriction error began appearing stating that certain Microsoft language extensions “may only be used” within a specific set of Microsoft products—explicitly including Visual Studio, Visual Studio for Mac, Visual Studio Code, and Azure DevOps. That language blocks usage inside other editors that embed VS Code extension infrastructure, so extensions that previously worked in forks suddenly fail.

Why does licensing matter even when an extension page looks permissive (e.g., MIT)?

The transcript highlights that some parts of extensions may appear MIT-licensed, but key runtime components shipped inside official VSIX packages can be governed by more restrictive proprietary licenses. That means a fork that redistributes or embeds the extension binaries can accidentally violate terms or run into technical/legal barriers, even if the extension’s top-level license looks open.

How did Microsoft’s February 2025 marketplace change affect fork workflows?

Microsoft removed the “download extension” button from the VS Code marketplace browser flow. The transcript notes this had been gone for a while and that it complicates workflows where users or fork platforms download extension files outside the official Microsoft Store and then import them into the forked editor.

What role does the “Atom → VS Code → Cursor” lineage play in understanding the crackdown?

The transcript argues that VS Code forks rely on inheriting the VS Code extension marketplace ecosystem. It traces how Atom popularized community extensibility via Electron, then how VS Code executed a similar playbook with better performance and community alignment—especially as TypeScript surged. Cursor is then described as riding on VS Code’s extension platform; when Microsoft restricts extension usage and distribution, Cursor loses a core advantage.

Is the transcript’s view that Microsoft is deliberately trying to destroy Cursor and Windsurf?

It argues that while the changes look conspiratorial, they likely came from multiple teams with limited orchestration. The download-button removal, the agent/MCP work in VS Code, and the extension restrictions may have different motivations. The transcript also points out that Microsoft’s stricter terms published in January 2025 could have set the stage for later enforcement.

What does the transcript suggest forks should do next?

It predicts a shift toward importing what still works, encouraging more extension publishing on Open VSX (an open marketplace format), and building open alternatives for proprietary components—especially for C++ runtime pieces and .NET experiences where Microsoft-controlled extensions are now restricted.

Review Questions

  1. What specific April 2025 restriction message limits Microsoft language extensions to certain products, and why does that break forks?
  2. How do the February 2025 removal of the marketplace download button and the January 2025 terms update interact to reduce fork flexibility?
  3. Why does the transcript treat “licensing that looks MIT” as potentially misleading when runtime binaries are proprietary?

Key Points

  1. 1

    April 2025 introduced a restriction error that limits certain Microsoft language extensions to specific Microsoft products, breaking them in VS Code forks like Cursor and Windsurf.

  2. 2

    Microsoft language extensions are not uniformly open-source; runtime components inside VSIX packages can carry proprietary licensing that complicates redistribution or embedding.

  3. 3

    February 2025 removed the VS Code marketplace “download extension” button, reducing the ability to fetch extension packages outside the official Microsoft Store.

  4. 4

    The crackdown fits into a longer inheritance chain—Sublime Text and Atom’s extensibility models leading to VS Code, then to Cursor—so extension ecosystem access is a central dependency for forks.

  5. 5

    The transcript suggests Cursor’s marketplace may have relied on wrapping the official extension ecosystem, which may have conflicted with Microsoft terms later tightened in January 2025.

  6. 6

    The changes may reflect multiple independent decisions by different Microsoft teams rather than one coordinated “destroy forks” plan, but the user impact is still immediate and broad.

  7. 7

    A likely future for forks involves more Open VSX publishing and open alternatives for proprietary extension components, especially in C++ and .NET areas.

Highlights

A new April 2025 error restricts Microsoft language extensions to a defined list of Microsoft products, cutting off C++ and .NET tooling in Cursor and Windsurf.
Microsoft removed the marketplace “download extension” button in February 2025, undermining a key workaround path for fork users and platforms.
The transcript frames the conflict as an extension-platform dependency problem: forks inherit VS Code’s ecosystem, but Microsoft can tighten licensing and distribution at any layer.
The licensing story is messy: some extension pages may look MIT-licensed while bundled runtime binaries remain under proprietary terms.
The likely response is structural—more Open VSX publishing and more open alternatives—rather than expecting Microsoft-controlled extensions to remain universally usable.

Topics

  • VS Code Forks
  • Extension Licensing
  • Open VSX
  • Cursor Marketplace
  • C++ and .NET Extensions

Mentioned

  • VS Code
  • MCP
  • SSO
  • SAML
  • TS
  • VSSX
  • VSIX
  • Electron
  • IDE
  • ID