Language Extensions and Combined Profiles

Can languages be installed as a combination?

Yes. Put the extensions needed by a project into one combined Profile, such as Web + Python. This does not merge two active Profiles. Use another Profile or window for a different project.

What gets installed?

Opening a Python file or committing recommendations does not automatically install every recommendation. Installing a Pack does install its members. Extension management

Installed, enabled, and activated are different states. Extensions may start for languages, commands, debugging, or startup events. Neither “everything always runs” nor “only the current language runs” is reliable. Inspect Developer: Show Running Extensions. Activation events

Starting sets by language

These are choices for the workflows below, not mandatory downloads for everyone who opens a text file. Follow the ID links to check publishers and current contents.

The Java Pack currently includes language support, debugging, testing, Maven, Gradle, and project management. For a smaller set, install individual IDs such as redhat.java, vscjava.vscode-java-debug, and vscjava.vscode-java-test. Spring is a separate choice. Java Pack contents

Python installs Pylance, Python Debugger, and Python Environments by default as optional dependencies. Installing the two IDs in the table can therefore produce more than two installed extensions. Ruff remains a separate choice. Python companion extensions

Extensions do not prepare every runtime or project dependency. Even when an extension downloads helper tools, reproduce the CLI/CI environment separately. Built-in TypeScript language support is distinct from the project compiler. TypeScript documentation

Share repository recommendations

For a Web + Python repository, merge these IDs into .vscode/extensions.json, then inspect @recommended in Extensions and choose what to install.

{
    "recommendations": [
        "EditorConfig.EditorConfig",
        "oxc.oxc-vscode",
        "ms-python.python",
        "charliermarsh.ruff"
    ]
}

Choosing to install the entire recommendation list can include languages outside your own work. For a broad monorepo, narrow your personal selection with a Profile. This file does not lock versions or enforce installation.

Install into a Profile

Use VS Code Desktop with code on PATH. On macOS, run Shell Command: Install 'code' command in PATH from the Command Palette. First create an Empty Profile named Web + Python in Profiles. Alternatively, open code . --profile "Web + Python" and confirm Profile creation has finished before running the installation commands below. CLI options

Opening a window and installing extensions handle Profiles differently. --install-extension --profile ... looks up an existing Profile and can fail if the name is missing. Do not rely on installation to create it. VS Code CLI implementation

code --profile "Web + Python" --install-extension EditorConfig.EditorConfig
code --profile "Web + Python" --install-extension oxc.oxc-vscode
code --profile "Web + Python" --install-extension ms-python.python
code --profile "Web + Python" --install-extension charliermarsh.ruff
code --profile "Web + Python" --list-extensions --show-versions
code . --profile "Web + Python"

These commands add extensions; they do not remove unwanted existing ones. Review the result and associate the Profile with the project. Profiles are not containers with fully isolated extension files and versions. Check extensions marked Apply Extension to all Profiles. Profiles

Select a combination with a script

Save the following as install-vscode-extensions.sh in a learning project. It runs in Bash on macOS, Linux, or WSL and installs only the selected case. Before running it, create the selected empty Profile (Web + Python, Web + Java, or Go + Infra). Running all three choices adds each set to its respective Profile.

#!/usr/bin/env bash
set -euo pipefail

choice="${1:-web-python}"
case "$choice" in
  web-python)
    profile="Web + Python"
    extensions=(oxc.oxc-vscode ms-python.python charliermarsh.ruff)
    ;;
  web-java)
    profile="Web + Java"
    extensions=(oxc.oxc-vscode vscjava.vscode-java-pack)
    ;;
  go-infra)
    profile="Go + Infra"
    extensions=(golang.Go redhat.vscode-yaml foxundermoon.shell-format timonwong.shellcheck)
    ;;
  *)
    printf 'Usage: %s {web-python|web-java|go-infra}\n' "$0" >&2
    exit 2
    ;;
esac

command -v code >/dev/null
for extension_id in EditorConfig.EditorConfig "${extensions[@]}"; do
  code --profile "$profile" --install-extension "$extension_id"
done
code --profile "$profile" --list-extensions --show-versions

bash install-vscode-extensions.sh web-python
code . --profile "Web + Python"

Use web-java for Java and Web, or go-infra for Go and operational files. Add Spring, Jupyter, or Vue only when required. For an ESLint/Prettier project, replace the Oxc ID with that project's extensions and follow format ownership.

The same Web + Python set in Windows PowerShell:

$profileName = "Web + Python"
$extensionIds = @(
  "EditorConfig.EditorConfig",
  "oxc.oxc-vscode",
  "ms-python.python",
  "charliermarsh.ruff"
)
foreach ($extensionId in $extensionIds) {
  code --profile $profileName --install-extension $extensionId
  if ($LASTEXITCODE -ne 0) { throw "Extension install failed: $extensionId" }
}
code --profile $profileName --list-extensions --show-versions

If installation fails halfway, already installed extensions remain. Resolve the failure, rerun, and inspect the list. This is neither a version lock nor an atomic deployment.

When to create an Extension Pack

Consider a maintained Pack when several repositories need the same distributable bundle. Start with explicit ID lists for a few combinations. A Pack's package.json could contain the following; replace the publisher ID with the actual distribution account.

{
    "name": "team-web-python",
    "displayName": "Team Web + Python",
    "publisher": "your-publisher-id",
    "version": "0.0.1",
    "engines": { "vscode": "^1.85.0" },
    "categories": ["Extension Packs"],
    "extensionPack": [
        "EditorConfig.EditorConfig",
        "oxc.oxc-vscode",
        "ms-python.python",
        "charliermarsh.ruff"
    ]
}

extensionPack lists bundled installations; extensionDependencies declares runtime dependencies of an extension. A recommendations file is not a Pack. Saving this manifest in a repository does not install anything: package/install a VSIX or publish through Marketplace. A Pack does not install JDKs, Python, or npm dependencies. Extension manifest

Choose a method for the project

Start with repository recommendations and a personal Profile matching the languages you work on. Use the Java Pack when onboarding needs its broader feature set. Decide by an actual task, rather than by the number of installed extensions.

Install recommendations in the UI

1. Open the repository root and create or inspect .vscode/extensions.json using the example above.
2. Open Extensions with Ctrl+Shift+X on Windows/Linux or Cmd+Shift+X on macOS.
3. Search @recommended and identify Workspace Recommendations, separately from other recommendation groups.
4. Check publisher IDs before installing individual items. Installing that whole group can include languages outside your own work.
5. Open a .ts or .py file and check that Format Document can select the intended provider.

Deleting a recommendation does not remove an installed extension. Inspect @installed afterward. Recommendations and management

Install the Java Pack through the UI or CLI

1. Search Extensions for @id:vscjava.vscode-java-pack.
2. Inspect its Extension Pack section. For example, the included Gradle extension can be installed even when your project only uses Maven.
3. Install, then check the language support, debugger, and test runner in @installed.
4. Prepare the JDK and build wrapper using the Java guide.

For CLI installation, first create the Web + Java Profile. Run the second command only for a Spring project.

code --profile "Web + Java" --install-extension vscjava.vscode-java-pack

code --profile "Web + Java" --install-extension vmware.vscode-boot-dev-pack

code --profile "Web + Java" --list-extensions --show-versions

This adds Java extensions. Use the earlier web-java combination to add Web tools too. Check diagnostics, a JUnit run, and a breakpoint instead of merely counting installed items. Java Pack, Spring Pack

Associate a Profile with a project

1. Open Profiles from Manage and choose New Profile.
2. Name it Web + Python, select Empty Profile as the source, and create it.
3. Open the project folder and select it with Profiles: Switch Profile.
4. Confirm the active name, then use the earlier CLI commands or web-python script.
5. Reopen the project after visiting another folder and check the selected Profile.

Use a combined Profile for two languages in one monorepo window. Use separate windows for separate work. Profile creation and folder associations

Move a Profile to another computer

Export the selected Profile with the desired contents to a local .code-profile file. On the target computer, use Import Profile and select the imported Profile. This workflow needs no public upload or account synchronization.

Compare code --profile "Web + Python" --list-extensions --show-versions on both computers. Adjust local paths and install runtimes and project dependencies separately. Matching themes are not proof of a working development environment. Profile sharing

Remove an oversized setup

Try Disable (Workspace) from the extension's Manage menu and check that diagnostics, tests, and formatting still work. Restore it with Enable (Workspace) when needed.

When removal is appropriate, specify the Profile and inspect the resulting list. This example removes a Java Pack accidentally installed in Web + Python:

code --profile "Web + Python" --uninstall-extension vscjava.vscode-java-pack
code --profile "Web + Python" --list-extensions --show-versions

Inspect the removal UI and remaining extensions; do not equate removing a Pack with removing every member. Other workflows may use those members. Also check extensions applied to all Profiles. Disabling and uninstalling

Troubleshooting checkpoints

Verify the result

Record the Profile's extension list, then test definition navigation, Rename, test debugging, and formatting. Use the shortcut reference and the SDK checks in Java, TypeScript, Go, and Python.

In SSH, WSL, or Dev Containers, check the execution location too. A local installation list is not automatically an identical remote installation. Inspect the Local/remote sections and Install in ... actions. Remote SSH extensions

Sources checked on 2026-09-06. The Bash script's branches, arguments, and failure handling were checked with a mock CLI. The PowerShell example was not executed; verify actual Marketplace installation and GUI activation in your environment using the procedure above.