How to Run PowerShell Script in Visual Studio Code: A Step-by-Step Guide

Running PowerShell scripts in Visual Studio Code streamlines the development process by leveraging the powerful integrated development environment (IDE) features it offers, such as syntax highlighting, version control, and debugging. As Visual Studio Code becomes increasingly popular among developers, understanding how to execute PowerShell scripts within this environment is crucial. With the integration of the PowerShell extension, available in Visual Studio Code’s marketplace, developers can run scripts, debug code, and manage PowerShell sessions more efficiently.

To execute a PowerShell script in Visual Studio Code, a developer must first ensure that the PowerShell extension is installed. This extension provides specialized support for PowerShell language, including executing scripts from within the editor itself. It enhances productivity by providing an integrated console, allowing developers to run commands and scripts without leaving the IDE. The extension essentially converts Visual Studio Code into a powerful script editor for PowerShell.

Launching a script is straightforward after the PowerShell extension is installed and enabled. One can easily invoke the script using Visual Studio Code’s built-in terminal. The IDE’s user interface also provides various ways to execute scripts, such as through the command palette or by configuring tasks. These features within Visual Studio Code offer a tailored development experience for PowerShell scripters, catering to both novice and expert users.


Before one can run a PowerShell script in Visual Studio Code, certain prerequisites must be met:

  1. Visual Studio Code: The user must have Visual Studio Code installed on their system. This is the Integrated Development Environment (IDE), where scripts will be written and executed.
  2. PowerShell Extension: Visual Studio Code has a marketplace where extensions are available. One must install the PowerShell extension for PowerShell scripting support.
  3. PowerShell: The system should have PowerShell installed. PowerShell Core is recommended for cross-platform compatibility.
  4. .NET Framework: For Windows users, .NET Framework is required, whereas PowerShell Core users should have .NET Core installed.
  5. Execution Policy: The user must ensure the PowerShell execution policy allows script execution. Typically, the policy should be set to RemoteSigned, which can be configured by running Set-ExecutionPolicy RemoteSigned in an elevated PowerShell prompt.
  6. Git (Optional): If version control is desired, Git should be installed on the user’s system.

The table below summarizes the prerequisites:

Visual Studio CodeIDE where PowerShell scripts are written and executed.
PowerShell ExtensionExtends VS Code for PowerShell scripting capabilities.
PowerShell/CoreScripting language and command-line shell.
.NET Framework/CoreSoftware framework required for PowerShell.
Execution PolicyPolicy setting that determines script execution permissions.
Git (Optional)Version control system useful for managing script versions.

It’s imperative for the user also to have a basic understanding of PowerShell scripting to leverage the features provided by Visual Studio Code effectively.

Installing Visual Studio Code

Before one can run PowerShell scripts in Visual Studio Code, they must first install the editor. Below is a step-by-step guide on how to do so:

  1. Navigate to the Official Website: Users should visit the Visual Studio Code website at
  2. Download the Installer: Select the appropriate version for the user’s operating system (Windows, macOS, or Linux). Operating System Download Link Windows Download for Windows macOS Download for macOS Linux See Linux options
  3. Run the Installer: After the download is complete, users need to locate and run the downloaded file.
    • Windows: A .exe file will be downloaded. Double-click on it to start the installation.
    • macOS: A .zip file will be downloaded. Unzip it, and move Visual Studio Code to the Applications folder.
    • Linux: The method varies with the distribution; options include .deb or .rpm packages.
  4. Follow Installation Prompts: The installer will guide users through the necessary steps. They should accept the license agreement, choose the installation location, select additional tasks such as creating a desktop icon, and begin the installation.
  5. Launch Visual Studio Code: Once installed, users can open Visual Studio Code directly from the installation window or find it in their list of applications.

Visual Studio Code is now installed and ready for configuring extensions, such as those needed to run PowerShell scripts effectively.

Configuring PowerShell Extension for Visual Studio Code

To efficiently manage and run PowerShell scripts in Visual Studio Code (VSCode), configuring the PowerShell extension is essential. It integrates the rich scripting capabilities of PowerShell with VSCode’s powerful editing features.

Extension Installation

  • To install the PowerShell extension, one can navigate to the Extensions view by clicking on the Extensions icon in the Activity Bar on the side of the window or pressing Ctrl+Shift+X.
  • Search for “PowerShell” and select the extension named “PowerShell” provided by Microsoft, then click “Install”.

Default Configuration

The extension comes with a default configuration, which works well for most users. Upon installation, the extension:

  • Automatically identifies installed versions of PowerShell on your system and sets one as the default interpreter.
  • Configures the integrated terminal to use PowerShell.
  • Provides default settings for code formatting and analysis, leveraging PSScriptAnalyzer.

Custom User Settings

Users may wish to tailor the experience to their preferences by adding custom settings. This involves:

  • Accessing the User Settings editor by pressing Ctrl+, or by selecting “Preferences: Open User Settings” from the command palette (Ctrl+Shift+P).
  • Adding or modifying settings related to the PowerShell extension, which could include:
    • "powershell.powerShellExePath" to specify a different path to the PowerShell executable.
    • "powershell.scriptAnalysis.enable" to toggle the script analysis feature.
    • "powershell.codeFormatting.*" to adjust formatting options to personal coding style.

For advanced customizations, refer to the official PowerShell extension documentation for comprehensive configuration options.

Creating a PowerShell Script

To begin creating a PowerShell script in Visual Studio Code, one needs to follow a structured approach:

  1. Install PowerShell Extension: Initially, one must ensure the PowerShell extension is installed in Visual Studio Code. This can be done by navigating to the Extensions view by clicking on the Extensions icon in the Activity Bar on the side of the window, and searching for ‘PowerShell’. Install the extension provided by Microsoft.
  2. Open a New File: After installation is complete, open a new file by selecting File > New File from the menu or by using the keyboard shortcut Ctrl+N (Windows) or Cmd+N (macOS).
  3. Select the Language Mode: To inform Visual Studio Code that the new file is a PowerShell script, they must change the language mode to PowerShell. To do this, click on the language mode indicator on the right side of the status bar and select ‘PowerShell’ from the list of languages.
  4. Write the Script: Now the user is ready to start writing their script. Begin by typing valid PowerShell commands. One can use IntelliSense, a code-completion aid that includes parameters and variable type suggestions.
  5. Save the Script: Remember to save the script with a .ps1 extension, which is the standard for PowerShell scripts. This can be done by pressing Ctrl+S (Windows) or Cmd+S (macOS) and entering a name that ends with .ps1.

By following these steps, a user can create a basic PowerShell script within Visual Studio Code, which can then be further developed and executed as required.

Running a PowerShell Script

In Visual Studio Code, users can execute PowerShell scripts efficiently either through the integrated terminal or by utilizing the Run Code feature.

Using the Integrated Terminal

To run a PowerShell script in Visual Studio Code, one can leverage the Integrated Terminal. First, open the terminal by pressing Ctrl+ (backtick). Navigate to the directory containing the script using the cd command.

To execute the script, type ./scriptname.ps1, replacing scriptname.ps1 with the actual name of the PowerShell script. If an execution policy error occurs, run Set-ExecutionPolicy RemoteSigned to adjust the policy for script execution.

Running Scripts with the Run Code Feature

Alternatively, users can execute a PowerShell script using the Run Code feature provided by the Code Runner extension. Ensure that the Code Runner extension is installed.

Open the PowerShell script file, then press Ctrl+Alt+N to run the script. The output will appear in the OUTPUT pane of Visual Studio Code.

To stop a running script, use the Ctrl+Alt+M shortcut. Configuration for the Run Code feature can be adjusted in the User or Workspace settings, where one can customize the execution behavior.

Understanding Execution Policies

PowerShell’s Execution Policies determine how scripts are run and managed. They play a crucial role in the security and administration of scripting environments.

Execution Policy Overview

PowerShell has several execution policies that can be defined at different scopes, from “Restricted” to “Unrestricted”. Restricted is the default policy, which prevents any scripts from running. In contrast, Unrestricted allows all scripts to run with a warning prompt for scripts from the internet. Here is a brief overview of the different policies:

  • Restricted: No scripts can run.
  • AllSigned: Only scripts signed by a trusted publisher can be run.
  • RemoteSigned: Locally-created scripts can run. A trusted publisher must sign scripts from the Internet.
  • Unrestricted: All scripts can run with a warning for those from the Internet.
  • Bypass: Nothing is blocked and there are no warnings or prompts.
  • Undefined: No defined policy, the system defaults to the closest scoped policy.

These policies help prevent untrusted scripts from causing harm to the system or user data.

Modifying Execution Policies

To change execution policies, one can use the Set-ExecutionPolicy cmdlet in PowerShell with administrative privileges. The policy can be set for the local machine, the current user, or for a particular session. Here’s how to change the execution policy:

  1. Open PowerShell as Administrator: This is necessary to modify execution policies.
  2. Use the Set-ExecutionPolicy Cmdlet: Specify the policy and scope with the following syntax: Set-ExecutionPolicy -ExecutionPolicy <PolicyName> -Scope <Scope>
  3. Confirm the Change: PowerShell prompts for confirmation to ensure the user understands the implications.

For example, to set the policy to RemoteSigned for the current user, one would use:

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

It is important to choose a policy that balances security needs with the practical aspects of script execution requirements.

Debugging PowerShell Scripts

When debugging PowerShell scripts in Visual Studio Code (VS Code), users leverage the PowerShell Integrated Console and breakpoints for an interactive debugging experience. It starts with installing the PowerShell extension for VS Code, which is essential for debugging capabilities.

Setting Up Breakpoints

A breakpoint can be set by clicking to the left of the line number or by pressing F9. Breakpoints are crucial as they allow the debugger to pause the script execution to examine the current state. There are different types of breakpoints:

  • Line Breakpoints: Pause execution at a specific line.
  • Conditional Breakpoints: Pause only when a condition is true.
  • Variable Breakpoints: Pause when a variable changes.

To view and manage breakpoints, one can use the Breakpoints pane.

Starting Debugging

To start debugging, press F5 or click the Play button in the debugging panel. The script will run and pause at any set breakpoints. While paused, investigators can:

  • Inspect variables in the Variables pane.
  • Track call stack in the Call Stack pane.
  • Execute commands in the Debug Console.

Step Operations

During a debugging session, users have multiple “step” operations at their disposal:

  • Step Over (F10): Execute the current line and go to the next.
  • Step Into (F11): Dive into function calls to debug further.
  • Step Out (Shift+F11): Exit the current function and return to the calling function.

Breakpoint and step controls allow users to navigate through the script thoroughly and methodically.

Finishing Debug Session

To end a session, click on the Stop button (red square) or press Shift + F5. Subsequently, the PowerShell Integrated Console resets and is ready for the next task. Remember, debugging is an iterative process; take advantage of breakpoints and stepping controls to effectively troubleshoot and refine scripts.

Common PowerShell Scripting Tasks in Visual Studio Code

Visual Studio Code (VS Code) is a versatile editor that supports PowerShell scripting effectively. Users frequently perform several common tasks within this environment to manage and develop their PowerShell scripts.

Creating Scripts: One can easily create new PowerShell scripts in VS Code. Simply open the command palette with Ctrl+Shift+P, type “PowerShell”, and select “Create New File”.

Editing Scripts: VS Code provides syntax highlighting, code snippets, and bracket matching which improves the scripting experience. Users can navigate the script with hotkeys like Ctrl+P to search for files or symbols.

Running Scripts: To execute a script, use the integrated terminal by pressing Ctrl+` to toggle it open, and type powershell to ensure PowerShell is the active shell, then execute the script using ./scriptname.ps1.

TaskShortcut or Command
Create New FileCtrl+Shift+P, “PowerShell”
Open Integrated TerminalCtrl+`
Run Script./scriptname.ps1

Debugging: Debugging is streamlined in VS Code. Set breakpoints by clicking left of the line number, start the debugger with F5, and step through the code with F10 (Step Over) and F11 (Step Into).

Version Control: Native Git integration allows users to control their script versions directly via the source control panel, enabling commit, push, and branching operations without leaving the editor.

This brief overview addresses the fundamental tasks developers encounter when working with PowerShell scripts in Visual Studio Code. The editor’s integration and supporting features simplify the development process for PowerShell enthusiasts and professionals.

Advanced Features of PowerShell in Visual Studio Code

Integrated Terminal: Visual Studio Code allows users to run PowerShell directly inside an integrated terminal, making it convenient to execute scripts without leaving the editor.

Debugging Tools: The editor offers powerful debugging tools for PowerShell scripts. Users can set breakpoints, step through code, watch variables, and inspect the call stack to troubleshoot and optimize scripts effectively.

Code Formatting: Visual Studio Code supports auto-formatting for PowerShell code, which helps in maintaining consistency and adhering to best practices. It can be applied manually or automatically on save, depending on user preferences.

Code Snippets: To enhance productivity, users can make use of pre-defined code snippets for common tasks, or create their own custom snippets, saving time and reducing repetitive coding.

LintingOffers real-time feedback on code quality.
Code NavigationAllows quick jumping to definitions.
Integrated Version ControlSimplifies work with Git repositories.

Extensible Platform: Users can extend the PowerShell experience in Visual Studio Code with a plethora of extensions available through the Visual Studio Code Marketplace.

Task Automation: Visual Studio Code can automate repetitive tasks using PowerShell tasks.json configurations, increasing efficiency and streamlining workflows.

Workspaces: Support for workspaces allows users to manage and switch between multiple project contexts easily, enabling them to handle different environments or versions of scripts with ease.

Best Practices for PowerShell Scripting

Consistent Naming Conventions

Use PascalCase for function names and camelCase for variable names. It clarifies their usage and purpose.

Commenting and Documentation

Comment code generously to explain complex sections. Descriptive comments and documentation built with Get-Help support readability and maintenance.

Version Control

Integrate scripts with version control systems like Git. This practice allows tracking changes and collaboration.

Error Handling

Employ try-catch-finally blocks to handle errors gracefully. Avoid using Write-Host for errors; instead, use Write-Output or Write-Error.

Scripts Modularity

Write functions for reusable code blocks to enhance modularity. One should break down large scripts into smaller, manageable functions.

Use PowerShell ISE or VS Code

Utilize PowerShell ISE or Visual Studio Code with the PowerShell extension for an integrated scripting environment.

Secure Scripting

Never store passwords or sensitive information in scripts. Utilize secure credential storage.

Test-Driven Development

Incorporate Pester or similar frameworks for test-driven development (TDD). It ensures that scripts meet requirements before deployment.

How to Run PowerShell Script in Visual Studio Code

Troubleshooting Common Issues

When a user runs into issues executing PowerShell scripts in Visual Studio Code, several common problems can be identified and resolved.

Execution Policy Restrictions

PowerShell’s execution policy might prohibit script running. To check the policy, use the following command in PowerShell:


If the policy is set to Restricted, one can change it with:

Set-ExecutionPolicy RemoteSigned

Missing PowerShell Extension

Visual Studio Code requires the PowerShell extension for proper scripting support. Ensure it’s installed by checking the Extensions pane or install it through:

Ctrl+P -> ext install ms-vscode.PowerShell

Incorrect File Path

The script may fail if the file path is incorrect. Ensure the script’s path is properly referenced relative to the current working directory or provide an absolute path.

Profile Load Failures

Errors may arise if the user’s PowerShell profile has issues. One might temporarily bypass the profile when starting PowerShell by using:

pwsh -NoProfile

Integrated Console Start Failures

Sometimes, the integrated console in VS Code could fail to start. In such scenarios, restarting Visual Studio Code may resolve the issue. If persistent, disabling other extensions may identify conflicts.

Error SymptomPotential Solution
Script fails to runCheck execution policy, file path
Console does not startRestart VS Code, check for extension conflicts

For persistent issues, consultation with the official Visual Studio Code documentation or the PowerShell extension GitHub issues page could provide additional insights.

You may also like: