If you only need the $PATH to be set in the integrated terminal, you can use VS Code's terminal.integrated.env.<platform> setting (added in version 1.15). Find the setting for your platform in the settings, click "Edit in settings.json", and add a "PATH" field like so:

"terminal.integrated.env.osx": {
  "PATH": "${env:PATH}:/my/path"
}

(Replace .osx with .linux or .windows as needed.)

The expression ${env:PATH} causes the existing contents of the $PATH environment variable to be inserted. This way you can extend it without hard-coding it.

As for having the $PATH available everwhere in VS Code, so that it will be used by extensions that call binaries, the only workaround I've found so far is this:

1. Configure your shell to have the $PATH you want. For example, I'm using Bash, and my ~/.bash_profile has the following line:

    PATH="$PATH:$HOME/bin"
   

2. In VS Code, press ⇧⌘P and type install 'code' command if you haven't done so before.

3. Quit VS Code.

4. Launch VS Code not by clicking its icon in the dock, but by opening Terminal.app and typing code. Your newly set path will be active in VS Code until you quit it.

5. If VS Code restarts, for example due to an upgrade, the $PATH will reset to the system default. In that case, quit VS Code and re-launch it by typing code.

Update: VS Code on Mac and Linux now apparently tries to automatically resolve the shell environment when it is started by clicking the icon (rather than via code). It does this by temporarily starting a shell and reading the environment variables. I haven't tested this though.

Short answer

Edit the user preference "terminal.integrated.cwd": "" to the path that you want the integrated terminal to open to.

Long answer

The same answer, but the long step-by-step version,

In Visual Studio Code go to:

Menu File → Preferences → Settings

Now that you are in the "User Settings", using the "Search Settings" bar across the top of the window paste or type this:

terminal.integrated.cwd

It will list the following as a result:

// An explicit start path where the terminal will be launched, this is used
as the current working directory (cwd) for the shell process. This may be
particularly useful in workspace settings if the root directory is not a
convenient cwd.
"terminal.integrated.cwd": "",

You will notice that it will not let you type here to change this setting. That is because you can't change the default setting. You instead need to change your personal settings. Here's how...

Click the pencil icon to the left of the this option and then the "Copy to Settings" option that pops-up.

You should have a split screen in which the right side of the screen has the heading Place your settings here to overwrite the Default Settings. This is the correct place for you to make changes. You might already have a few personalized settings listed here.

When you clicked "Copy to Settings" it automatically added this line for you:

"terminal.integrated.cwd": ""

Notice that whichever item is last in this list will not have a trailing comma but any items before it in the list will require one.

FYI: you could have simply typed or copy/pasted this into the personalized settings yourself, but following these steps is the process to learn for changing other preferences as needed.

Now you are able to type to set the path you want to use. Make sure to use \\ in place of \ and you do not need the trailing \. For example including this line would always start your terminal in the baz directory:

{
    "terminal.integrated.cwd": "C:\\Users\\foo\\bar\\baz"
}

To apply the change, simply Save and restart Visual Studio Code.

According to Microsoft Docs: Settings file locations:

By default VS Code shows the Settings editor, but you can still edit the underlying settings.json file by using the Open Settings (JSON) command or by changing your default settings editor with the workbench.settings.editor setting.

Depending on your platform, the user settings file is located here:

• Windows %APPDATA%\Code\User\settings.json
• macOS $HOME/Library/Application Support/Code/User/settings.json
• Linux $HOME/.config/Code/User/settings.json

The workspace setting file is located under the .vscode folder in your root folder.

Note: In case of a Multi-root Workspace, workspace settings are located inside the workspace configuration file.

According to Microsoft Docs: Persisted Zoom Level the entry you are looking for is: window.zoomLevel

Thanks for reaching out. Here’s a breakdown for their roles:

1.      Settings.json

·         Used by the C/C++ extension in VS code.

·         The setting “C_Cpp.default.compilerPath” (or “C_Cpp.default.intelliSenseMode”) tells the IntelliSense engine which compiler to reference.

·         This helps VS Code provide code completion, error squiggles, and IntelliSense consistent with the compiler you’re using.

·         It does not actually compile or run the code it’s mainly for editing experience.

2.      Tasks.json

·         Defines how your code is built when you run Ctrl+Shift+B(build task).

·         Specifies which compiler executable (e.g., gcc, clang, cl.exe) to call, along with arguments.

3.      Launch.json

·         Defines how your program is debugged.

·         Referring to the compiled binary(output from tasks.json) and configures debugger settings.

·         It does not directly specify the compiler path but indirectly depend on the build task that used the compiler.

How the compiler path is determined automatically

·         When you install the C / C++ extension, VS code tries to detect available compilers (gcc, clang, cl.exe) from your system PATH.

·         The first detected compiler may be auto-filled in tasks.json and launch.json.

·         If multiple compilers are found, you can configure “C_Cpp.default.compilerPath” in settings.json to guide the IntelliSense and then manually generate/update tasks via “C/C++: edit configurations(UI)”.

Prompting for compiler each time

·         Remove

“C_Cpp.default.compilerPtah” from settings.json, so VS Code asks when IntelliSense needs it.

·         Or define multiple tasks in

Tasks.json(e.g., one for GCC, one for Clag), then choose which task to run using “Run Build Task”.

·         Use CMake tools extension if you want automatic multi-compiler management.

So in short:

Settings.json -> IntelliSense compiler reference

Tasks.json -> Actual compilation task

Launch.json -> Debugging setup, tied to the build task

You can also refer to these sites:

·         C++ extension settings reference

·         Configure C/C++ IntelliSense

·         Using C++ on Linux in VS Code

·         Configure VS Code for Microsoft C++

Let me know if you need any further help with this. We'll be happy to assist.

If you find this helpful, please mark this as answered.