Setup and Installation

Purpose and Scope

Setup for VS Code has two related meanings. The first is the user-facing path for opening a usable editor on desktop, in the browser, through a remote host, or inside a managed enterprise environment. The second is runtime readiness: the installed environment must actually support language-aware editing, command behavior, and optional AI rendering once a workspace is open. The source evidence for this page sits in those runtime readiness layers, so this guide treats installation as a checklist that ends only after important editor and Copilot surfaces work correctly. Sources: src/vs/editor/common/languages/supports/inplaceReplaceSupport.ts, src/vs/editor/common/languages/supports/languageBracketsConfiguration.ts

A useful setup check should therefore look at behavior, not just packaging. If VS Code launches but bracket matching is wrong, numeric navigation fails, or AI answers render as unstructured text, users still experience the setup as incomplete. The editor language-support files show how common features are made language-sensitive, while the Copilot panel language files show that AI responses are expected to contain code, documentation, and mathematical notation with syntax-aware presentation. This distinction helps readers isolate whether a problem is in the editor, account access, enterprise policy, or AI display path. Sources: src/vs/editor/common/languages/supports/inplaceReplaceSupport.ts, src/vs/editor/common/languages/supports/languageBracketsConfiguration.ts, extensions/copilot/src/extension/completions-core/vscode-node/extension/src/panelShared/languages/index.ts

Supported Setup Paths

For a desktop setup, install the intended Visual Studio Code channel and open a real workspace rather than stopping at the welcome screen. A representative workspace should include files with nested delimiters, numbers, booleans, access modifiers, Markdown, and any framework syntax the team uses. The bracket configuration implementation is a strong readiness signal because it constructs per-language opening and closing bracket information, exposes lookup methods, and builds a bracket regular expression for editor features. When these features behave correctly, the local editor layer is likely healthy enough for editing, reviewing, and extension-driven workflows. Sources: src/vs/editor/common/languages/supports/languageBracketsConfiguration.ts

For a web or browser-hosted setup, the packaging layer changes but the validation goals remain similar. The user should confirm that the workbench can open the workspace, that language semantics are loaded, and that interactive editor commands still behave as expected. The same source-backed checks apply because common editor support is shared below the hosting surface. This is especially important for teams that move between local machines, browser workspaces, and remote-backed sessions; a setup that merely loads the shell is not equivalent to one that can correctly understand brackets, selections, and rendered generated content. Sources: src/vs/editor/common/languages/supports/inplaceReplaceSupport.ts, src/vs/editor/common/languages/supports/languageBracketsConfiguration.ts

Portable-like development should be thought of as repeatable readiness rather than as a promise that one copied directory covers every dependency. Users may carry settings, extensions, accounts, and workspaces across machines, but the environment still needs to prove that editor commands, language configuration, authentication, and rendering assets align. The in-place replacement support is a compact cross-environment test because it works from selected text and known value sets. If incrementing a number or cycling a boolean fails, investigate editor command wiring before assuming that a Copilot, marketplace, or remote issue is responsible. Sources: src/vs/editor/common/languages/supports/inplaceReplaceSupport.ts

Copilot Access and AI Readiness

Copilot setup begins after the editor is open. The official setup flow is status-bar first: choose to use AI features from the Copilot icon, select a sign-in method, and let VS Code associate the active identity with Copilot Free, an existing subscription, or an enterprise entitlement. For GitHub Enterprise users, the flow includes choosing the enterprise sign-in option and providing the instance URL. Treat these as separate layers in the setup plan: the editor binary, the workspace, the GitHub identity, the subscription or organization entitlement, and any enterprise policy that controls AI availability.

After account access succeeds, AI readiness still depends on local presentation support. The Copilot panel shared language index re-exports language inputs for CUDA C++, JavaScript React, combined Markdown and LaTeX, Markdown math, reStructuredText, search results, and TypeScript React. That registry implies that Copilot responses are not plain transcripts; they often include snippets, explanations, search-like output, and documentation that need language-specific highlighting. A practical first prompt should ask for JSX, Markdown documentation, or a short formula so the reader can verify both entitlement and rendering in one pass. Sources: extensions/copilot/src/extension/completions-core/vscode-node/extension/src/panelShared/languages/index.ts

The Markdown math grammar makes the rendering boundary concrete. It declares a Shiki language input with a Markdown math name and a TextMate scope, then describes patterns for TeX comments, line separators, functions with braced arguments, constants, braces, round brackets, numeric values, and mathematical operators. None of that proves account access; it proves that once AI output appears, the panel has local assets for making math-heavy text legible. If Copilot answers but formulas look flat or confusing, investigate panel language assets separately from sign-in and subscription state. Sources: extensions/copilot/src/extension/completions-core/vscode-node/extension/src/panelShared/languages/md-math.tmLanguage.ts

System-to-Code Mapping

Setup concern	Repository evidence	Validation task
Core bracket behavior	LanguageBracketsConfiguration	Open nested code and confirm matching, lookup, and colorization feel language-aware.
Command-level editing	BasicInplaceReplace	Select a number, boolean, or access modifier and navigate to the next or previous value.
Copilot syntax registry	panelShared/languages/index.ts	Ask for generated code or documentation and confirm a language-specific rendering path is present.
React-oriented output	javaScriptReact.tmLanguage.ts	Ask for JSX or React component output and verify that the panel preserves code structure.
Markdown and math output	markdown-latex-combined.tmLanguage.ts and md-math.tmLanguage.ts	Ask for Markdown with a formula and verify TeX-like regions remain readable.

This mapping is intentionally task-oriented because installation failures are often reported with vague symptoms. A missing entitlement, a blocked enterprise policy, a broken bracket configuration, and a missing grammar all look like setup problems to an end user, but they belong to different systems. The editor files cover local language and command behavior that should work before AI is considered. The Copilot grammar files cover the display path that matters after authentication. Keeping those layers separate reduces guesswork and gives support teams a short path from observed symptom to likely component. Sources: src/vs/editor/common/languages/supports/inplaceReplaceSupport.ts, src/vs/editor/common/languages/supports/languageBracketsConfiguration.ts, extensions/copilot/src/extension/completions-core/vscode-node/extension/src/panelShared/languages/index.ts

Implementation Details

The in-place replacement implementation is a small but useful readiness probe. Its public navigation method accepts two candidate ranges with associated text plus a direction, checks the first candidate, then falls back to the second. Numeric replacement parses the value, preserves decimal precision by scaling with a computed precision factor, increments or decrements by the correct unit, and refuses to decrement zero into a negative value. Text replacement cycles through built-in sets for booleans, Visual Basic-style modifiers, and common access modifiers. This makes it a quick check for selection-sensitive editor commands. Sources: src/vs/editor/common/languages/supports/inplaceReplaceSupport.ts

The bracket configuration implementation is more structural. It receives a language identifier and a language configuration, filters valid bracket pairs, caches opening and closing bracket kinds, and links each opening bracket to the closing brackets it can match. It also treats colorized bracket pairs as brackets and marks them for colorization. When a language does not explicitly configure colorized bracket pairs, the implementation excludes angle brackets from the default colorized set because many languages also use them as comparison operators. That conservative default shows why setup validation must use real project languages rather than artificial examples only. Sources: src/vs/editor/common/languages/supports/languageBracketsConfiguration.ts

The Copilot panel language modules define a different readiness boundary: whether generated content can be displayed with appropriate syntax cues. The shared index centralizes exported grammars so panel code can import known language inputs rather than duplicating registrations. The JavaScript React, combined Markdown and LaTeX, and Markdown math files represent common first-run responses: component examples, prose documentation, and formula-heavy explanations. When a user verifies Copilot setup, these rendering checks should follow authentication because they confirm that the AI surface is usable for real work, not merely reachable. Sources: extensions/copilot/src/extension/completions-core/vscode-node/extension/src/panelShared/languages/index.ts, extensions/copilot/src/extension/completions-core/vscode-node/extension/src/panelShared/languages/javaScriptReact.tmLanguage.ts, extensions/copilot/src/extension/completions-core/vscode-node/extension/src/panelShared/languages/markdown-latex-combined.tmLanguage.ts, extensions/copilot/src/extension/completions-core/vscode-node/extension/src/panelShared/languages/md-math.tmLanguage.ts

First-Run Validation Flow

1. Install or open the intended VS Code environment, such as desktop, Insiders, browser-hosted, remote-backed, or enterprise-managed.
2. Open a representative workspace with the languages, markup, and frameworks the user actually edits.
3. Confirm bracket matching and bracket colorization in nested code before investigating optional AI features.
4. Select a numeric literal, boolean, or access modifier and run value navigation to verify command-level editing behavior.
5. If using Copilot, start from the Copilot status bar entry, choose the correct GitHub.com or GitHub Enterprise sign-in path, and complete authentication.
6. Ask Copilot for output containing JSX, Markdown, or mathematical notation and confirm that the panel renders the answer with useful syntax cues.
7. If features remain unavailable, separate local editor readiness from subscription, organization policy, telemetry settings, and enterprise access rules.

Treat this flow as a fast readiness test before deeper customization. A setup is not complete merely because VS Code launches, and it is not necessarily broken merely because Copilot is unavailable. Local editor services, language configuration, account entitlement, enterprise policy, and Copilot rendering are independent layers with different failure modes. After these checks pass, move on to command-line setup, extension management, source control, terminal tasks, or more detailed Copilot workflow pages depending on the next user journey.

Relevant Source Files

• src/vs/editor/common/languages/supports/inplaceReplaceSupport.ts — Implements BasicInplaceReplace, including numeric value navigation and cycling through default textual value sets.
• src/vs/editor/common/languages/supports/languageBracketsConfiguration.ts — Defines immutable per-language bracket configuration, opening and closing bracket lookup, colorized bracket handling, and bracket regular expression creation.
• extensions/copilot/src/extension/completions-core/vscode-node/extension/src/panelShared/languages/index.ts — Re-exports the Copilot panel language inputs used to syntax-highlight AI-rendered content.
• extensions/copilot/src/extension/completions-core/vscode-node/extension/src/panelShared/languages/javaScriptReact.tmLanguage.ts — Provides the JavaScript React language grammar input used by Copilot panel rendering.
• extensions/copilot/src/extension/completions-core/vscode-node/extension/src/panelShared/languages/markdown-latex-combined.tmLanguage.ts — Provides combined Markdown and LaTeX grammar support for Copilot-rendered documentation-style content.
• extensions/copilot/src/extension/completions-core/vscode-node/extension/src/panelShared/languages/md-math.tmLanguage.ts — Defines Markdown math highlighting rules for TeX-like syntax in Copilot panel content.

Related Pages and Next Steps

Read the overview page if you need the broader distinction between Code - OSS and the Visual Studio Code product. Use the command-line interface page when setup needs to cover launch commands, tunnels, server entry points, or automation. Continue to the Copilot and AI overview after sign-in succeeds and you want to understand inline suggestions, chat, agents, and enterprise boundaries. For teams standardizing development environments, pair this page with extension management, workbench UI, terminal, and source-control pages so first-run validation covers the full edit-build-debug loop.