AVAP TM  Dev Studio has hundreds of settings, thousands of
      extensions, and innumerable ways to adjust the UI layout to customize the
      editor. AVAP TM  Dev Studio  Profiles  let you
      create sets of customizations and quickly switch between them or share
      them with others. This topic explains how to create, modify, export, and
      import profiles.

## Create a Profile

AVAP TM  Dev Studio treats your current configuration as the{' '}
       Default Profile . As you modify settings, install
      extensions, or change UI layout by moving views, these customizations are
      tracked in the Default Profile.

To create a new profile, you can use the  File  >{' '}
       Preferences  >  Profiles  >{' '}
       Create Profile  menu item.

You can create a new profile based on the current profile (
       Profiles: Create from Current Profiles ) or create an
      Empty Profile. An Empty Profile includes no user customizations
      (settings, extensions, snippets, etc.).

You can also access the Profile command menu via the{' '}
       Manage  gear button in the lower right of the Activity
      bar.

The  Profiles: Create Profile  command is also available in
      the Command Palette (Ctrl+Shift+P).

You can choose to create a new profile by copying from a Profile Template
      or from an existing profile or create an Empty Profile in the Profile
      creation dialog.

### Partial Profile

A partial profile allows you to customize only a subset of configurations
      (settings, keyboard shortcuts, snippets, tasks and extensions) and
      use the rest of the configurations from the Default Profile. For example,
      you can create a profile with all configurations except for keyboard
      shortcuts, and AVAP TM  Dev Studio will apply the keyboard
      shortcuts from the Default Profile when this profile is active.

### Check the current profile

The current profile name is displayed in several places in the AVAP
       TM  Dev Studio UI:

* Title bar
* File > Preferences >{' '} Profiles
* Manage gear button hover

If you are still using the Default Profile, no profile name is displayed.

The  Manage  gear button displays a badge with the first
      two letters of the active profile so you can quickly check which profile
      you are running.

### Configure a profile

You can configure a profile just as you would normally change any AVAP
       TM  Dev Studio configuration. You can install/uninstall/disable
      extensions, change settings, and adjust the editor's UI layout
      (for example, moving and hiding views) like normal. These changes
      are stored in your currently active profile.

### Workspace associations

When you create or select an existing profile, it is associated with the
      current workspace and whenever you open that folder, the workspace's
      profile is active. If you open another folder, the profile switches to
      that folder's associated profile if one has been set or remains on the
      last used profile.

## Managing profiles

### Switch profiles

You can quickly switch between profiles with the{' '}
       Profiles: Switch Profile  command in the Command Palette,
      which presents a dropdown listing your available profiles.

You can also switch profiles by selecting a profile from the list
      displayed in the Profiles menus, available via the  Manage {' '}
      gear button or  File  >  Preferences {' '}
      >  Profiles .

### Edit a profile

You can edit an existing profile via the  Edit  command in
      the Profiles menu.

### Delete a profile

You can delete a profile via the  Delete Profile  command.
      The  Delete Profile  drop down lets you select which
      profile(s) to delete.

## Profile contents

The  Profiles: Show Contents  command (available in the
      Command Palette or Profiles menus) brings up the Profiles view, where
      you can review the customizations for the profile.

A profile can include:

* Settings - In a profile-specific `settings.json` file.
* Extensions - The list of extensions included in the current profile.
* UI state - View layout (positions), visible views and actions.
* Keybindings - In a profile-specific `keybindings.json` file.
* Snippets - In a profile-specific `{language}.json` {' '} files.
* User Tasks - In a profile-specific `tasks.json` file.

When you create a new profile based on the Default Profile, the
      profile-specific configuration files are populated from your user
      configuration files. Workspace-specific settings are not automatically
      included in a new profile.

### Applying a setting to all profiles

A setting can be applied to all profiles using the{' '}
       Apply Setting to all Profiles  action available in the
      Settings editor.

This will apply the value of the setting to all profiles. Any updates to
      this setting from any profile will be applied to all profiles. You can
      always revert this by unchecking the{' '}
       Apply Setting to all Profiles  action.

### Applying an extension to all profiles

An extension can be applied to all profiles by clicking on the{' '}
       Apply Extension to all Profiles  action in the Extensions
      view.

This will make this extension available in all profiles. You can always
      revert this by unchecking the{' '}
       Apply Extension to all Profiles  action.

## Share Profiles

### Export

You can export a profile in order to save it or share it with others. The{' '}
       Export Profile  command displays the Profiles view with
      the contents of the active profile and an  Export  button.
      You can unselect various elements of the profile such as extensions or
      configuration files before you export the profile.

When you select  Export , you are prompted for the profile
      name and whether you want to export to a GitHub gist or your local file
      system.

After you save a profile to GitHub (you'll be prompted to log into
      GitHub), a dialog gives you the option to  Copy Link {' '}
      so you can share your profile gist URL with others. The URL includes an
      autogenerated GUID and has the format (LINK). The GitHub gist is
      marked as  Secret , so only those with the link can see the
      gist.

If you launch the profile URL, it opens AVAP TM  Dev Studio for
      the Web (vscode.dev) with the Profiles view open and the imported
      profile contents displayed. You can unselect profile elements if you wish
      and you need to manually  Install Extensions  (via the
      download cloud button) if you want to continue using that profile in
      vscode.dev.

You also have the option to{' '}
       
        Import Profile in AVAP TM  Dev Studio
       
      , which opens AVAP TM  Dev Studio Desktop with the profile's
      contents displayed and an  Import Profile  button.

You can review your gists at (LINK). From your GitHub gist page
      you can rename, delete, or copy the GUID of a gist.

If you chose to save the profile as a local file, a{' '}
       Save Profile  dialog lets you place the file on your local
      machine. A profile is persisted in a file with the extension{' '}
       `.code-profile` .

### Import

To import an existing profile, run the  Import Profiles {' '}
      command. You are prompted for the URL of a GitHub gist or the file
      location of a profile via an  Import Profile  dialog. Once
      you have selected the profile, the Profiles view opens and displays the
      profile to import. You can unselect some profile elements if you don't
      want to import them. Select the  Import Profile  button and
      you will now be using the imported profile.

## Uses for Profiles

Profiles are a great way to customize AVAP TM  Dev Studio to
      better fit your needs. In this section, we look at some common use cases
      for profiles.

Since profiles are remembered per workspace, they are a great way to
      customize AVAP TM  Dev Studio for a specific programming
      language. For example, you can create a JavaScript frontend profile that
      includes the extensions, settings, and customizations you use for
      JavaScript development in one workspace, and have a Python backend profile
      that includes the extensions, settings, and customizations you use for
      Python development in another workspace. Using this approach, you can
      easily switch between workspaces and always have AVAP TM  Dev
      Studio configured the right way.

### Demos

When doing a demo, you can use a profile to set up a specific
      configuration for your demo. For example, you can create a profile with a
      specific set of extensions and settings like zoom level, font size, and
      color theme. By doing this, a demo will not mess up your normal AVAP
       TM  Dev Studio setup and you can customize AVAP TM  Dev
      Studio for better visibility during your presentation.

### Education

Profiles can be used to customize AVAP TM  Dev Studio for
      students to ease the use in a classroom setting. Profiles allow educators
      to quickly share a customized AVAP TM  Dev Studio setup with
      students. For example, educators can create a profile with a specific set
      of extensions and settings needed for a computer science class and then
      share that profile with students.

### Report AVAPTM Dev Studio issues

One use of an Empty Profile is to reset your editor when you want to
      report an issue with AVAP TM  Dev Studio. An Empty Profile
      disables all extensions and modified settings so you can quickly see if
      the issue is due to an extension, a setting, or is in AVAP TM {' '}
      Dev Studio core.

## Profile Templates

AVAP TM  Dev Studio comes with a predefined set of profile
      templates that you can use to customize AVAP TM  Dev Studio for
      your specific workflow. To create a new profile based on a template,
      select a Profile Template when going through the{' '}
       Create Profile  flow.

### Python Profile Template

The Python profile is a good starting point for Python development. It
      comes with Python specific snippets and has the following extensions:

* autoDocstring - Generate Python docstrings automatically.
* Black Formatter - Formatting support using the black formatter.
* Docker - Create, manage, and debug containerized applications.
* Even Better TOML - Fully-featured TOML support.
* Python - IntelliSense, linting, formatting, debugging, refactoring.
* Python Environment Manager - Manage Python environments and packages.
* Remote Development extension pack - Supports SSH, WSL, and Dev Containers.
* Ruff - Integrates the Ruff Python linter.

This profile also sets the following settings:

```javascript
` `"python.analysis.autoImportCompletions": true,
        ` `"python.analysis.fixAll": ["source.unusedImports"],
        ` `"editor.defaultFormatter": "ms-python.black-formatter"
```

### Data Science Profile Template

The Data Science profile is a good starting point for all data and
      notebook work. It comes with specific snippets and has the following
      extensions:

* Data Wrangler - Data cleaning and preparation for tabular datasets.
* Black Formatter - Formatting support using the black formatter.
* Jupyter - Use Jupyter notebooks within AVAP TM Dev Studio.
* Python - IntelliSense, linting, formatting, debugging, refactoring.
* Dev Containers - Create custom development environments inside a Docker container.
* GitHub Copilot - Your AI pair programmer.

This profile also sets the following settings:

```javascript
` `"[python]": {
        ` `"editor.defaultFormatter": "ms-python.black-formatter",
        ` `"editor.formatOnType": true,
        ` `"editor.formatOnSave": true
        ` `},
        ` `"editor.inlineSuggest.enabled": true,
        ` `"editor.lineHeight": 17,
        ` `"breadcrumbs.enabled": false,
        ` `"files.autoSave": "afterDelay",
        ` `"jupyter.themeMatplotlibPlots": true,
        ` `"jupyter.widgetScriptSources": [` `"unpkg.com",
        ` `"jsdelivr.com"
        ` `],
        ` `"notebook.experimental.outputScrolling": true,
        ` `// "notebook.outline.showCodeCells": true,
        ` `"files.exclude": {
        ` `"\*\*/.csv": true,
        ` `"\*\*/.parquet": true,
        ` `"\*\*/.pkl": true,
        ` `"\*\*/.xls": true
        ` `}
```

### Doc Writer Profile Template

The Doc Writer profile is a good lightweight setup for writing
      documentation. It comes with the following extensions:

* Code Spell Checker - Spelling checker for source code.
* Markdown Checkboxes - Adds checkbox support to the AVAP TM Dev Studio built-in Markdown Preview.
* Markdown Emoji - Adds emoji syntax support to Markdown Preview and notebook Markdown cells.
* Markdown Footnotes - Adds ^footnote syntax support to the Markdown Preview.
* Markdown Preview GitHub Styling - Use GitHub styling in the Markdown Preview.
* Markdown Preview Mermaid Support - Mermaid diagrams and flowcharts.
* Markdown yaml Preamble - Renders YAML front matter as a table.
* markdownlint - Markdown linting and style checking for AVAP TM {' '} Dev Studio.

This profile also sets the following settings:

```javascript
` `"workbench.colorTheme": "Default Light+ Experimental",
        ` `"editor.minimap.enabled": false,
        ` `"breadcrumbs.enabled": false,
        ` `"editor.glyphMargin": false,
        ` `"explorer.decorations.badges": false,
        ` `"explorer.decorations.colors": false,
        ` `"editor.fontLigatures": true,
        ` `"files.autoSave": "afterDelay",
        ` `"git.enableSmartCommit": true,
        ` `"window.commandCenter": true,
        ` `"editor.renderWhitespace": "none",
        ` `"workbench.editor.untitled.hint": "hidden",
        ` `"markdown.validate.enabled": true,
        ` `"markdown.updateLinksOnFileMove.enabled": "prompt",
        ` `"workbench.startupEditor": "none"
```

### Node.js Profile Template*

The Node.js profile is a good starting point for all Node.js work. It
      comes with the following extensions:

* ESLint - Integrates ESLint JavaScript into AVAP TM Dev Studio.
* Dev Containers - Create custom development environments inside a Docker container.
* Docker - Create, manage, and debug containerized applications.
* DotENV - Support for dotenv file syntax.
* EditorConfig for AVAP TM Dev Studio - EditorConfig Support for AVAP TM Dev Studio.
* JavaScript (ES6) code snippets - Code snippets for JavaScript in ES6 syntax.
* Jest - Use Facebook's jest testing framework.
* Microsoft Edge Tools for AVAP TM Dev Studio - Use the Microsoft Edge Tools from within AVAP TM Dev Studio.
* npm Intellisense - Autocomplete npm modules in import statements.
* Prettier - Code formatter - Code formatter using Prettier.
* Rest Client - REST Client for AVAP TM Dev Studio.
* YAML - YAML language support with built-in Kubernetes syntax.

This profile comes with the following settings:

```javascript
` `"editor.formatOnPaste": true,
        ` `"git.autofetch": true,
        ` `"[markdown]": {
        ` `"editor.wordWrap": "on"
        ` `},
        ` `"[json]": {
        ` `"editor.defaultFormatter": "esbenp.prettier-vscode"
        ` `},
        ` `"[jsonc]": {
        ` `"editor.defaultFormatter": "vscode.json-language-features"
        ` `},
        ` `"[html]": {
        ` `"editor.defaultFormatter": "esbenp.prettier-vscode"
        ` `},
        ` `"[javascript]": {
        ` `"editor.defaultFormatter": "esbenp.prettier-vscode"
        ` `},
        ` `"[typescript]": {
        ` `"editor.defaultFormatter": "esbenp.prettier-vscode"
        ` `}
```

### Angular Profile Template

The Angular profile is a good starting point for all Angular work. It
      comes with the following extensions:

* Angular Language Service - Editor services for Angular templates.
* Angular Schematics - Integrate Angular schematics (CLI commands).
* angular2-switcher - Easily navigate to `typescript|template|style` in angular2 project.
* Dev Containers - Create custom development environments inside a Docker container.
* EditorConfig for AVAP TM Dev Studio - EditorConfig Support for AVAP TM Dev Studio.
* ESLint - Integrates ESLint JavaScript into AVAP TM Dev Studio.
* JavaScript (ES6) code snippets - Code snippets for JavaScript in ES6 syntax.
* Jest - Use Facebook's jest testing framework.
* Material Icon Theme - Material Design Icons for AVAP TM Dev Studio.
* Microsoft Edge Tools for AVAP TM Dev Studio - Use the Microsoft Edge Tools from within AVAP TM Dev Studio.
* Playwright Test for VSCode - Run Playwright tests in AVAP TM {' '} Dev Studio.
* Prettier - Code formatter - Code formatter using Prettier.
* Rest Client - REST Client for AVAP TM Dev Studio.
* YAML - YAML language support with built-in Kubernetes syntax.

This profile sets the following settings:

```javascript
` `"editor.formatOnPaste": true,
        ` `"git.autofetch": true,
        ` `"[markdown]": {
        ` `"editor.wordWrap": "on"
        ` `},
        ` `"[json]": {
        ` `"editor.defaultFormatter": "esbenp.prettier-vscode"
        ` `},
        ` `"[jsonc]": {
        ` `"editor.defaultFormatter": "vscode.json-language-features"
        ` `},
        ` `"[html]": {
        ` `"editor.defaultFormatter": "esbenp.prettier-vscode"
        ` `},
        ` `"[javascript]": {
        ` `"editor.defaultFormatter": "esbenp.prettier-vscode"
        ` `},
        ` `"[typescript]": {
        ` `"editor.defaultFormatter": "esbenp.prettier-vscode"
        ` `},
        ` `"workbench.iconTheme": "material-icon-theme"
```

### Java General Profile Template

The Java General profile is a good starting point for all Java work. It
      customizes the layout to improve the Java experience and comes with the
      following extensions from the Extension Pack for Java:

* Debugger for Java - A lightweight Java debugger.
* IntelliCode - AI-assisted development.
* IntelliCode API Usage Examples - Provides code examples for over 100K different APIs.
* Language Support for Java(TM) by Red Hat - Fundamental Java language support, Linting, Intellisense, formatting, refactoring.
* Maven for Java - Manage Maven projects and builds.
* Project Manager for Java - Manage Java projects within AVAP TM {' '} Dev Studio.
* Test Runner for Java - Run and debug JUnit or TestNG test cases.

### Java Spring Profile Template

The Java Spring profile is a good starting point for all Java and Spring
      developers. It builds on the Java General profile and add the following
      extensions from the Spring Boot Extension Pack:

* Spring Boot Dashboard - Provides Spring Boot live data visualization and observation in your running Spring applications.
* Spring Boot Tools - Rich language support for Spring Boot files.
* Spring Initializr Java Support - Scaffold and generate Spring Boot Java projects.

This profile sets the following settings:

```javascript
` `"[java]": {
        ` `"editor.defaultFormatter": "redhat.java"
        ` `},
        ` `"boot-java.rewrite.reconcile": true
```

## Command line

You can launch AVAP TM  Dev Studio with a specific profile via
      the  `--profile`  command-line interface option. You pass the
      name of the profile after the  `--profile`  argument and open a
      folder or a workspace using that profile. The command line below opens the{' '}
       `web-sample`  folder with the "Web Development"
      profile:

`
        code ~/projects/web-sample --profile "Web Development"
      `

If the profile specified does not exist, a new empty profile with the
      given name is created.

## Common Questions

### Where are profiles kept?

Profiles are stored under your User configurations similar to your user
      settings and keybindings.

* Windows `%APPDATA%\Code\User\profiles`
* macOS {' '} `$HOME/Library/Application\ Support/Code/User/profiles`
* Linux `$HOME/.config/Code/User/profiles`

If you are using the Insiders version, the intermediate folder name is{' '}
       `Code - Insiders` .

### Where is the UI State globalState.json file?

If you expand the  UI State  node in the Profiles view,
      there is a  `globalState.json`  entry. This is an in-memory JSON
      representation of your profile's UI State, describing the visibility
      and layout of various AVAP TM  Dev Studio UI elements. The file
      does not actually exist on disk and is just a JSON view of the underlying
      global state storage.

### What is a Temporary Profile?

A Temporary Profile is a profile that is not saved across AVAP
       TM  Dev Studio sessions. You create a Temporary Profile via the{' '}
       Profiles: Create a Temporary Profile  command in the
      Command Palette. The Temporary Profile starts as an Empty Profile and has
      an automatically generated name (such as  Temp 1 ).
      You can modify the profile settings and extensions, use the profile for
      the lifetime of your AVAP TM  Dev Studio session, but it will be
      deleted once you close AVAP TM  Dev Studio.

Temporary Profiles are useful if you want to try a new configuration or
      test an extension without modifying your default or existing profile.
      Restarting AVAP TM  Dev Studio reenables the current profile for
      your workspace.

### How can I remove the profile from my project?

You can set your project back to the Default Profile. If you'd like to
      remove all profile workspace associations, you can use the{' '}
       Developer: Reset Workspace Profiles Associations , which
      will set all local folders currently assigned a profile back to the
      Default Profile.  Reset Workspace Profiles Associations {' '}
      does not delete any existing profiles.

### Do profiles sync across machines (via Settings Sync)?

Yes, you can use Settings Sync to move your profiles across various
      machines. With Setting Sync enabled and  Profiles  checked
      in the  Settings Sync: Configure  drop down, all your
      created profiles are available.

### Why are some settings not exported when exporting a profile?

When exporting profiles, machine-specific settings are not included
      because these setting would not be applicable on another machine. For
      example, settings that point to local paths are not included.
