Cloud Parts

Visual Studio Code

Microsoft’s free, extensible editor and the most used one by far, built on the MIT-licensed Code - OSS project that Cursor, Windsurf and Void forked.

What it is
Editors and terminals (code editors)
Type
Open source
Made by
Microsoft
License
MIT (Code - OSS source); Microsoft product licence for the VS Code build
Facts checked
9 October 2026
Website Source code

What it is

Visual Studio Code is a desktop editor built from web technology. It runs in Electron, GitHub’s shell that combines web UI with Node.js, which made it cross-platform from the first preview. The core stays small: extensions run in a separate extension host process, language support comes from language servers over the Language Server Protocol, which VS Code introduced, and debugging from debug adapters over the Debug Adapter Protocol. Even its JavaScript and TypeScript support ships as bundled extensions written against the same public API. In the Stack Overflow 2026 survey, 70.9% of 13,193 respondents used it regularly, far ahead of any other editor.

Microsoft develops the source in the open as Code - OSS under the MIT licence, then builds the Visual Studio Code product from it, adding branding, telemetry settings, the Visual Studio Marketplace connection and a few proprietary pieces under a Microsoft licence. Remote Development installs a VS Code Server inside a container, WSL or an SSH host, so extensions and language servers run next to the code while the UI stays local.

AI is now part of the core. Microsoft open-sourced the GitHub Copilot Chat extension, agent mode included, under MIT in June 2025, with a plan to move its pieces into VS Code itself. Recent releases run agent sessions in a separate agent host process, can show several sessions side by side, and can sandbox an agent’s file and network access.

Why teams pick it

  • The default: most extensions, tutorials and team setups assume it, and the Marketplace covers almost any language or tool
  • Language servers and debug adapters for nearly every language, through the protocols VS Code created
  • Remote Development works in containers, WSL and over SSH with no source code on your laptop
  • MIT-licensed source that anyone can fork and build, which is why Cursor, Windsurf and Void exist

Watch out for

  • The Microsoft build isn’t the open-source build: it adds proprietary code and a product licence, and collects usage telemetry unless you turn it off
  • Some Microsoft extensions, including the Remote Development pack and the C# debugger, are licensed only for Microsoft’s products, so forks can’t use them
  • Extensions that use proposed (unstable) APIs can’t be published to the Marketplace for stable builds, apart from a short allow-list of mostly Microsoft extensions

The Visual Studio Code family

3 technologies built from or on Visual Studio Code

Alternatives

What all code editors have in common →
ZedOpen sourceA code editor written from scratch in Rust by the team behind Atom, drawn on the GPU, with its own agent and the Agent Client Protocol for outside ones.

How it fits with other technologies

What uses Visual Studio Code

Install an extension, then open a file at a line and a folder on a remote machine · bash

# the Python extension also installs Pylance and the debugpy debugger
code --install-extension ms-python.python
code --list-extensions --show-versions
# ms-python.debugpy@2026.6.0
# ms-python.python@2026.8.0
# ms-python.vscode-pylance@2026.4.1

code --goto src/app.py:42                          # open at line 42
code --remote ssh-remote+gpu-vm /home/me/project  # Remote - SSH: tools run on gpu-vm

See it in a real stack

No architecture uses Visual Studio Code yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2015–2025

VS Code grew out of Microsoft’s “Monaco” team, which set out to answer one question: can a browser-based code editor feel native, with suggestion lists, error squiggles and Go to Definition? Their editor ended up in OneDrive, Azure and the F12 tools of Internet Explorer. To build it they needed a development tool of their own, and that tool became Visual Studio Code: the Monaco editor in GitHub’s Electron shell, focused on editing, navigation, debugging and Git. Microsoft previewed it at Build 2015.

The first preview lacked two things: extensibility and open development. Six months later, at Connect(); 2015, Microsoft added a full extension model and the Visual Studio Marketplace, and open-sourced the repository. By version 1.0 in April 2016 there were 2 million installs, more than 500,000 monthly active users and over 1,000 extensions. Two months later Microsoft, Red Hat and Codenvy announced the Language Server Protocol that VS Code used internally as a shared standard.

In 2019 Remote Development split VS Code into a local UI and a server running beside the code, in containers, over SSH or in WSL. The MIT-licensed base also made VS Code the starting point for a generation of AI editors, Cursor, Windsurf and Void among them. In 2025 Microsoft answered by making VS Code itself an “open source AI editor”, publishing the Copilot Chat code under MIT.

Why it’s built this way

Web technology inside Electron
The team had already built a browser-based editor that felt native. A native shell around it gave a cross-platform desktop app quickly, on macOS, Windows and Linux from the first preview.
Build VS Code on its own extension API
To deliver a rich, stable API, the team wrote features such as JavaScript and TypeScript support against the same API extension authors get. By 1.0 it was confident enough to declare that API stable.
Language support in separate servers
Language tools are heavy on CPU and memory and are written in many languages. Running them as separate processes behind a protocol kept the editor responsive and let one server serve many editors.
Open source, with the proprietary parts kept separate
Microsoft wanted everything possible to be open, but kept its brand, Marketplace access and some licensed components out of the repository, so anyone can fork Code - OSS and still get a working editor.

Timeline

  1. 2015

    First preview at Microsoft Build

  2. 2015

    Beta at Connect(): extensions, the Marketplace and an open-source repository

  3. 2016

    Version 1.0 in April: 2 million installs and over 1,000 extensions

  4. 2016

    Language Server Protocol announced with Red Hat and Codenvy

  5. 2019

    Remote Development preview for containers, SSH and WSL

  6. 2025

    GitHub Copilot Chat, with agent mode, open-sourced under MIT

Sources12 · facts checked 9 October 2026

Improve this page on GitHub