# VS Code Open Terminal: How to Launch a Shell Command Prompt in Visual Studio Code

> Quickly open a VS Code terminal using keyboard shortcuts or the workbench action terminal new command. Launch shell commands effortlessly within Visual Studio Code.

- Repository: [Microsoft/vscode](https://github.com/microsoft/vscode)
- Tags: how-to-guide
- Published: 2026-02-16

---

**Press Ctrl+Shift+` (Windows/Linux) or Cmd+Shift+` (macOS) to instantly open the integrated terminal, or programmatically invoke the `workbench.action.terminal.new` command ID.**

The VS Code open terminal functionality is central to the editor's workflow, enabling developers to execute shell commands without leaving the IDE. This feature is implemented in the Microsoft VS Code repository through a sophisticated terminal contribution system that exposes both UI commands and extension APIs.

## Understanding the VS Code Open Terminal Architecture

The integrated terminal in VS Code is implemented as a workbench contribution located in `src/vs/workbench/contrib/terminal/`. When you trigger a VS Code open terminal action, the system resolves the command ID `workbench.action.terminal.new` registered in [`src/vs/workbench/contrib/terminal/browser/terminalActions.ts`](https://github.com/microsoft/vscode/blob/main/src/vs/workbench/contrib/terminal/browser/terminalActions.ts) (lines 1214-1224).

This command delegates to `ITerminalService.createTerminal`, which spawns the shell process based on the selected profile and renders it in the terminal view. The architecture separates concerns between UI actions ([`terminalActions.ts`](https://github.com/microsoft/vscode/blob/main/terminalActions.ts)), menu contributions ([`terminalMenus.ts`](https://github.com/microsoft/vscode/blob/main/terminalMenus.ts)), and the low-level terminal service ([`terminalService.ts`](https://github.com/microsoft/vscode/blob/main/terminalService.ts)).

## Method 1: Keyboard Shortcuts for VS Code Open Terminal

### Default Keybindings

The fastest way to perform a VS Code open terminal action is using the default keyboard shortcut:

- **Windows/Linux**: `Ctrl+Shift+``
- **macOS**: `Cmd+Shift+``

These shortcuts dispatch the `workbench.action.terminal.new` command, creating a new terminal instance with the default shell profile.

### Customizing Your Shortcut

You can override these bindings in [`keybindings.json`](https://github.com/microsoft/vscode/blob/main/keybindings.json):

```json
{
  "key": "ctrl+alt+t",
  "command": "workbench.action.terminal.new"
}

```

## Method 2: Programmatic VS Code Open Terminal via Extension API

Extension developers can trigger the VS Code open terminal functionality through two primary APIs.

### Creating a Terminal with createTerminal()

The `vscode.window.createTerminal()` method provides full control over terminal creation. This API is exposed in [`src/vs/workbench/api/common/extHostExtensionApi.ts`](https://github.com/microsoft/vscode/blob/main/src/vs/workbench/api/common/extHostExtensionApi.ts) and mirrors the internal `ITerminalService.createTerminal` implementation.

```typescript
import * as vscode from 'vscode';

export function activate(context: vscode.ExtensionContext) {
    const disposable = vscode.commands.registerCommand('myExtension.openShell', () => {
        // Create terminal with specific options
        const terminal = vscode.window.createTerminal({
            name: 'Build Terminal',
            cwd: vscode.workspace.workspaceFolders?.[0].uri.fsPath
        });
        
        // Reveal the terminal in the panel
        terminal.show();
        
        // Optional: execute initial command
        terminal.sendText('npm run build', true);
    });

    context.subscriptions.push(disposable);
}

```

### Executing the Built-in Command

For simpler use cases, execute the registered command directly:

```typescript
// Opens terminal using the same path as UI shortcuts
await vscode.commands.executeCommand('workbench.action.terminal.new');

```

This approach uses the command registration found in [`terminalActions.ts`](https://github.com/microsoft/vscode/blob/main/terminalActions.ts) at lines 1214-1224, ensuring identical behavior to the keyboard shortcut.

## Method 3: UI-Based VS Code Open Terminal Actions

### Command Palette

Access the VS Code open terminal action through the Command Palette (`Ctrl+Shift+P` or `Cmd+Shift+P`):

1. Type "Terminal: New Terminal"
2. Select the command mapped to `workbench.action.terminal.new`

### Menu and Context Menu Items

The Terminal menu (`Terminal → New Terminal`) and the **+** button in the Terminal panel both dispatch the `workbench.action.terminal.new` command. These UI elements are wired in [`src/vs/workbench/contrib/terminal/browser/terminalMenus.ts`](https://github.com/microsoft/vscode/blob/main/src/vs/workbench/contrib/terminal/browser/terminalMenus.ts), which contributes the action to the panel context menu and the main menu bar.

## Advanced VS Code Open Terminal Configurations

### Specifying Shell Profiles

Control which shell opens by setting the default profile or specifying it per-terminal:

```typescript
// Use a specific profile (e.g., PowerShell on Windows)
const terminal = vscode.window.createTerminal({
    name: 'PowerShell',
    shellPath: 'powershell.exe'
});

```

The default profile selection logic resides in the terminal configuration service, referenced by `ITerminalService` when creating new instances.

### Terminal Location (Panel vs Editor)

By default, VS Code open terminal actions place the terminal in the bottom panel. You can open terminals in the editor area:

```typescript
const terminal = vscode.window.createTerminal({
    name: 'Editor Terminal',
    location: { viewColumn: vscode.ViewColumn.Beside }
});
terminal.show();

```

This corresponds to the `TerminalLocation.Editor` enum value handled internally in [`terminalActions.ts`](https://github.com/microsoft/vscode/blob/main/terminalActions.ts) for the "Create Terminal in Editor Area" command.

### Sending Text to the Terminal

After opening, interact programmatically:

```typescript
const term = vscode.window.createTerminal();
term.show();
term.sendText('git status', true); // true = execute immediately

```

The `sendText` method forwards input to the underlying PTY, matching the behavior of the **Run Selected Text** action defined in [`terminalActions.ts`](https://github.com/microsoft/vscode/blob/main/terminalActions.ts).

## Key Source Files for VS Code Open Terminal Implementation

Understanding the implementation helps debug terminal behavior and develop extensions:

- **[`src/vs/workbench/contrib/terminal/browser/terminalActions.ts`](https://github.com/microsoft/vscode/blob/main/src/vs/workbench/contrib/terminal/browser/terminalActions.ts)** – Registers the `workbench.action.terminal.new` command (lines 1214-1224) and other terminal-related actions.
- **[`src/vs/workbench/contrib/terminal/common/terminal.ts`](https://github.com/microsoft/vscode/blob/main/src/vs/workbench/contrib/terminal/common/terminal.ts)** – Declares the `TerminalCommandId` enum and `ITerminalService` interface used across the terminal system.
- **[`src/vs/workbench/contrib/terminal/browser/terminalMenus.ts`](https://github.com/microsoft/vscode/blob/main/src/vs/workbench/contrib/terminal/browser/terminalMenus.ts)** – Contributes terminal commands to the UI menus and panel context menus.
- **[`src/vs/platform/terminal/common/terminalService.ts`](https://github.com/microsoft/vscode/blob/main/src/vs/platform/terminal/common/terminalService.ts)** – Low-level service responsible for spawning shell processes and managing PTY instances.
- **[`src/vs/workbench/api/common/extHostExtensionApi.ts`](https://github.com/microsoft/vscode/blob/main/src/vs/workbench/api/common/extHostExtensionApi.ts)** – Exposes the `vscode.window.createTerminal` API to extensions.

These files together implement the open terminal workflow: UI → command registration → `ITerminalService.createTerminal` → PTY launch → terminal view rendering.

## Summary

- **Use keyboard shortcuts** (`Ctrl+Shift+`` or `Cmd+Shift+``) for instant access to the integrated terminal via the `workbench.action.terminal.new` command.
- **Call `vscode.window.createTerminal()`** from extensions to programmatically open terminals with custom names, working directories, or shell paths.
- **Execute `workbench.action.terminal.new`** directly using `vscode.commands.executeCommand()` to trigger the same behavior as UI shortcuts.
- **Control terminal placement** using the `location` option to open shells in the panel (default) or editor area.
- **Reference [`terminalActions.ts`](https://github.com/microsoft/vscode/blob/main/terminalActions.ts)** (lines 1214-1224) for the core command registration and `ITerminalService` for the underlying implementation.

## Frequently Asked Questions

### What is the command ID for opening a terminal in VS Code?

The command ID is **`workbench.action.terminal.new`**. This ID is registered in [`src/vs/workbench/contrib/terminal/browser/terminalActions.ts`](https://github.com/microsoft/vscode/blob/main/src/vs/workbench/contrib/terminal/browser/terminalActions.ts) (lines 1214-1224) and is bound to the default keyboard shortcut `Ctrl+Shift+`` (Windows/Linux) or `Cmd+Shift+`` (macOS). You can invoke this ID programmatically using `vscode.commands.executeCommand('workbench.action.terminal.new')`.

### How do I open a terminal in VS Code using the Extension API?

Use the **`vscode.window.createTerminal()`** method, which is exposed in [`src/vs/workbench/api/common/extHostExtensionApi.ts`](https://github.com/microsoft/vscode/blob/main/src/vs/workbench/api/common/extHostExtensionApi.ts). This returns a `Terminal` object that you must call `.show()` on to reveal. You can pass options like `name`, `cwd`, and `shellPath` to customize the shell environment. This API mirrors the internal `ITerminalService.createTerminal` implementation used by the core command.

### Can I open a terminal in the editor area instead of the bottom panel?

Yes. When calling `vscode.window.createTerminal()`, pass the **`location`** option with `{ viewColumn: vscode.ViewColumn.Beside }` or `vscode.ViewColumn.One` to open the terminal in the editor area. This corresponds to the internal `TerminalLocation.Editor` enum value handled in [`terminalActions.ts`](https://github.com/microsoft/vscode/blob/main/terminalActions.ts). By default, terminals open in `TerminalLocation.Panel` (the bottom panel).

### Where is the terminal implementation located in the VS Code source code?

The primary implementation resides in **`src/vs/workbench/contrib/terminal/`**. Key files include [`terminalActions.ts`](https://github.com/microsoft/vscode/blob/main/terminalActions.ts) (registers the `workbench.action.terminal.new` command), [`terminalMenus.ts`](https://github.com/microsoft/vscode/blob/main/terminalMenus.ts) (wires commands to UI menus), and [`common/terminal.ts`](https://github.com/microsoft/vscode/blob/main/common/terminal.ts) (defines `ITerminalService` and `TerminalCommandId`). The low-level PTY spawning logic lives in [`src/vs/platform/terminal/common/terminalService.ts`](https://github.com/microsoft/vscode/blob/main/src/vs/platform/terminal/common/terminalService.ts), while the extension API surface is exposed in [`src/vs/workbench/api/common/extHostExtensionApi.ts`](https://github.com/microsoft/vscode/blob/main/src/vs/workbench/api/common/extHostExtensionApi.ts).