Using Clang in Visual Studio Code

In this tutorial, you configure Visual Studio Code on macOS to use the Clang/LLVM compiler and debugger. The configuration applies to a single workspace (folder hierarchy), but you can easily copy the configuration files to other workspaces where the same settings are required. After configuring VS Code, you will compile and debug a simple program to get familiar with the VS Code user interface. After completing this tutorial, you will be ready to create and configure your own workspace, and to explore the VS Code documentation for further information about its many features. This tutorial does not teach you about Clang or the C++ language. For those subjects, there are many good resources available on the Web.

If you have any problems, feel free to file an issue for this tutorial in the VS Code documentation repository.


To successfully complete this tutorial, you must do the following steps:

  1. Install Visual Studio Code and follow the setup instructions in Visual Studio Code on macOS.

  2. Install the C++ extension for VS Code.

Add VS Code to your PATH

In order to start VS Code from the command line, we'll need to add it to the PATH environment variable. This only needs to be done once, on first use.

  1. Open VS Code

  2. Press ⇧⌘P (Windows, Linux Ctrl+Shift+P) to open the Command Palette.

  3. Start typing "Shell" and from the list of suggestions choose Shell Command: Install 'code' command in PATH.

    Shell command in Command Palette

  4. You should see a notification in the lower right of the VS Code window that tells you that VS Code was successfully added to the PATH.

  5. Close VS Code.

Start VS Code in a folder

In the macOS Terminal, create an empty folder called "projects" and then a subfolder called "helloworld". Navigate into it, and open VS Code (code) in that folder (.) by entering the following commands:

mkdir projects
cd projects
mkdir helloworld
cd helloworld
code .

The code . command opens VS Code in the current working directory, which becomes your workspace. Our task is to add three files to the workspace that will tell VS Code how to compile and debug our program. VS Code will place these files in a .vscode subdirectory that it will create for us:

  • c_cpp_properties.json to specify the compiler path
  • tasks.json to specify how to build the executable
  • launch.json to specify debugger settings

Configure the compiler path

  1. Press ⇧⌘P (Windows, Linux Ctrl+Shift+P) to open the Command Palette. Start typing "C/C++" and then choose Edit Configurations from the list of suggestions. VS Code creates a file called c_cpp_properties.json and populates it with some default settings.
  2. Find the compilerPath setting and paste in the path to the bin folder. For Clang, this is typically usr/bin/clang/.

The compilerPath setting is the most important setting in your configuration. The extension uses it to infer the path to system header files, which it needs for IntelliSense support. There is no need to specify it explicitly in the includePath setting unless you have additional or non-standard paths in your code base. In fact, we recommend that you delete the setting entirely if you don't need it.

  1. On macOS, you must set the macFrameworkPath to point to the system header files.
  2. The only other change is to set intelliSenseMode to clang-x64".

Your complete c_cpp_properties.json file should look like this:

    "configurations": [
            "name": "macOS",
            "includePath": [
            "defines": [],
            "macFrameworkPath": [
            "compilerPath": "/usr/bin/clang",
            "cStandard": "c11",
            "cppStandard": "c++17",
            "intelliSenseMode": "clang-x64"
    "version": 4

Create a build task

Next, we need to create a tasks.json file to tell VS Code how to build (compile) the program. This task will invoke the g++ compiler on WSL to create an executable file based on the source code.

  1. From the main menu, choose View > Command Palette and then type "task" and choose Tasks: Add a default build task then choose Others. VS Code creates a minimal tasks.json file and opens it in the editor.
  2. Go ahead and replace the entire file contents with the following code snippet:
    "version": "2.0.0",
    "tasks": [
            "label": "Build with Clang",
            "type": "shell",
            "command": "clang++",
            "args": [
            "group": {
                "kind": "build",
                "isDefault": true

The label value is used to identify the task in the VS Code Command Palette; you can name this whatever you like. The args array specifies the command-line arguments that will be passed to the compiler that was specified in the previous step. These arguments must be specified in the order expected by the compiler.

The "isDefault": true value in the group object specifies that this task will be run when you press ⇧⌘B (Windows, Linux Ctrl+Shift+B). The --debug argument causes debug symbols to be produced, which is required for stepping through code when you debug.

Configure debug settings

Next, we'll configure VS Code to launch gdb when we press F5 to debug the program. Note that the program name helloworld.out matches what we specified in tasks.json.

By default, the C++ extension adds a breakpoint to the first line of main. The stopAtEntry value is set to true to cause the debugger to stop on that breakpoint. You can set this to false if you prefer to ignore it.

Your complete launch.json file should look like this:

    "version": "0.2.0",
    "configurations": [
            "name": "(lldb) Launch",
            "type": "cppdbg",
            "request": "launch",
            "program": "${workspaceFolder}/helloworld.out",
            "args": [],
            "stopAtEntry": true,
            "cwd": "${workspaceFolder}",
            "environment": [],
            "externalConsole": true,
            "MIMode": "lldb",
            "logging": {
                "trace": true,
                "traceResponse": true,
                "engineLogging": true

Add a source code file

  1. In the main VS Code menu, click on File > New File and name it helloworld.cpp.

  2. Paste in this source code:

    #include <iostream>
    #include <vector>
    #include <string>
    using namespace std;
    int main()
        vector<string> msg {"Hello", "C++", "World", "from", "VS Code!"};
        for (const string& word : msg)
            cout << word << " ";
        cout << endl;
  3. Now press ⌘S (Windows, Linux Ctrl+S) to save the file. Notice how all the files we have just edited appear in the File Explorer view in the left panel of VS Code:

File Explorer

This same panel is also used for source control, debugging, searching and replacing text, and managing extensions. The buttons on the left control those views. We'll look at the Debug View later in this tutorial. You can find out more about the other views in the VS Code documentation.

Explore IntelliSense

In your new helloworld.cpp file, hover over vector or string to see type information. After the declaration of the msg variable, start typing msg. as you would when calling a member function. You should immediately see a completion list that shows all the member functions, and a window that shows the type information for the msg object:

Statement completion IntelliSense

Build the program

  1. To run the build task that you defined in tasks.json, press ⇧⌘B (Windows, Linux Ctrl+Shift+B) or from the main menu choose View > Command Palette and start typing "Tasks: Run Build Task". The option will appear before you finish typing.
  2. When the task starts, you should see an integrated terminal window appear below the code editor. After the task completes, the terminal shows output from the compiler that indicates whether the build succeeded or failed. For a successful Clang build, the output looks something like this:

Clang build output in terminal

  1. As the message instructs, press any key to close the integrated terminal.

Start a debugging session

  1. You are now ready to run the program. Press F5 or from the main menu choose Debug > Start Debugging. Before we start stepping through the code, let's take a moment to notice several changes in the user interface:
  • The Debug Console appears and displays output from the debugger.

  • The code editor highlights the first statement in the main method. This is a breakpoint that the C++ extension automatically sets for you:

Initial breakpoint

  • The workspace pane on the left now shows debugging information. These windows will dynamically update as you step through the code.

Debugging windows

  • At the top of the code editor, a debugging control panel appears. You can move this around the screen by grabbing the dots on the left side.

Debugging controls

Step through the code

Now we're ready to start stepping through the code.

  1. Click or press the Step over icon in the debugging control panel.

    Step over button

    This will advance program execution to the first line of the for loop, and skip over all the internal function calls within the vector and string classes that are invoked when the msg variable is created and initialized. Notice the change in the Variables window on the left. In this case, the errors are expected because, although the variable names for the loop are now visible to the debugger, the statement has not executed yet, so there is nothing to read at this point. The contents of msg are visible, however, because that statement has completed.

  2. Press Step over again to advance to the next statement in this program (skipping over all the internal code that is executed to initialize the loop). Now, the Variables window shows information about the loop variables.

  3. Press Step over again to execute the cout statement. Your application is now running in a macOS Terminal window. Press Cmd+Tab to find it. You should see Hello output there on the command line.

  4. If you like, you can keep pressing Step over until all the words in the vector have been printed to the console. But if you are curious, try pressing the Step Into button to step through source code in the C++ standard library!

    Breakpoint in gcc standard library header

    To return to your own code, one way is to keep pressing Step over. Another way is to set a breakpoint in your code by switching to the helloworld.cpp tab in the code editor, putting the insertion point somewhere on the cout statement inside the loop, and pressing F9. A red dot appears in the gutter on the left to indicate that a breakpoint has been set on this line.

    Breakpoint in main

    Then press F5 to start execution from the current line in the standard library header. Execution will break on cout. If you like, you can press F9 again to toggle off the breakpoint.

Set a watch

Sometimes you might want to keep track of the value of a variable as your program executes. You can do this by setting a watch on the variable.

  1. Place the insertion point inside the loop. In the Watch window, click the plus sign and in the text box, type word, which is the name of the loop variable. Now view the Watch window as you step through the loop.

    Watch window

  2. Add another watch by adding this statement before the loop: int i = 0;. Then, inside the loop, add this statement: ++i;. Now add a watch for i as you did in the previous step.

  3. To quickly view the value of any variable while execution is paused on a breakpoint, you can simply hover over it with the mouse pointer.

    Mouse hover

Next steps