diff --git a/extensions/vscode-api-tests/src/singlefolder-tests/terminal.test.ts b/extensions/vscode-api-tests/src/singlefolder-tests/terminal.test.ts
index 63e39fdd2e457aeabf0f78f81e4104a30d76add0..ee5f7505d6c201d0ef74a1dea468055f2bab6f42 100644
--- a/extensions/vscode-api-tests/src/singlefolder-tests/terminal.test.ts
+++ b/extensions/vscode-api-tests/src/singlefolder-tests/terminal.test.ts
@@ -3,7 +3,7 @@
  *  Licensed under the MIT License. See License.txt in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
-import { window, Terminal, TerminalVirtualProcess, EventEmitter, TerminalDimensions, workspace, ConfigurationTarget } from 'vscode';
+import { window, Terminal, Pseudoterminal, EventEmitter, TerminalDimensions, workspace, ConfigurationTarget } from 'vscode';
 import { doesNotThrow, equal, ok } from 'assert';
 
 suite('window namespace tests', () => {
@@ -264,12 +264,12 @@ suite('window namespace tests', () => {
 					});
 					term.dispose();
 				});
-				const virtualProcess: TerminalVirtualProcess = {
+				const pty: Pseudoterminal = {
 					onDidWrite: new EventEmitter<string>().event,
 					start: () => {},
 					shutdown: () => {}
 				};
-				window.createTerminal({ name: 'c', virtualProcess });
+				window.createTerminal({ name: 'c', pty });
 			});
 
 			test('should fire Terminal.onData on write', (done) => {
@@ -291,12 +291,12 @@ suite('window namespace tests', () => {
 				let startResolve: () => void;
 				const startPromise: Promise<void> = new Promise<void>(r => startResolve = r);
 				const writeEmitter = new EventEmitter<string>();
-				const virtualProcess: TerminalVirtualProcess = {
+				const pty: Pseudoterminal = {
 					onDidWrite: writeEmitter.event,
 					start: () => startResolve(),
 					shutdown: () => {}
 				};
-				const terminal = window.createTerminal({ name: 'foo', virtualProcess });
+				const terminal = window.createTerminal({ name: 'foo', pty });
 			});
 
 			test('should fire provide dimensions on start as the terminal has been shown', (done) => {
@@ -304,7 +304,7 @@ suite('window namespace tests', () => {
 					equal(terminal, term);
 					reg1.dispose();
 				});
-				const virtualProcess: TerminalVirtualProcess = {
+				const pty: Pseudoterminal = {
 					onDidWrite: new EventEmitter<string>().event,
 					start: (dimensions) => {
 						ok(dimensions!.columns > 0);
@@ -317,7 +317,7 @@ suite('window namespace tests', () => {
 					},
 					shutdown: () => {}
 				};
-				const terminal = window.createTerminal({ name: 'foo', virtualProcess });
+				const terminal = window.createTerminal({ name: 'foo', pty });
 			});
 
 			test('should respect dimension overrides', (done) => {
@@ -340,13 +340,13 @@ suite('window namespace tests', () => {
 				});
 				const writeEmitter = new EventEmitter<string>();
 				const overrideDimensionsEmitter = new EventEmitter<TerminalDimensions>();
-				const virtualProcess: TerminalVirtualProcess = {
+				const pty: Pseudoterminal = {
 					onDidWrite: writeEmitter.event,
 					onDidOverrideDimensions: overrideDimensionsEmitter.event,
 					start: () => {},
 					shutdown: () => {}
 				};
-				const terminal = window.createTerminal({ name: 'foo', virtualProcess });
+				const terminal = window.createTerminal({ name: 'foo', pty });
 			});
 		});
 	});
diff --git a/extensions/vscode-api-tests/src/singlefolder-tests/workspace.tasks.test.ts b/extensions/vscode-api-tests/src/singlefolder-tests/workspace.tasks.test.ts
index 43470d24e196c5e29ee978633bf1d60cfb0f8413..695ac4b0f59bd1762be781623531b1a933cfbb51 100644
--- a/extensions/vscode-api-tests/src/singlefolder-tests/workspace.tasks.test.ts
+++ b/extensions/vscode-api-tests/src/singlefolder-tests/workspace.tasks.test.ts
@@ -35,8 +35,8 @@ suite.only('workspace-namespace', () => {
 						customProp1: 'testing task one'
 					};
 					const writeEmitter = new vscode.EventEmitter<string>();
-					const execution = new vscode.CustomExecution2((): Thenable<vscode.TerminalVirtualProcess> => {
-						return Promise.resolve(<vscode.TerminalVirtualProcess>{
+					const execution = new vscode.CustomExecution2((): Thenable<vscode.Pseudoterminal> => {
+						return Promise.resolve(<vscode.Pseudoterminal>{
 							onDidWrite: writeEmitter.event,
 							start: () => {
 								writeEmitter.fire('testing\r\n');
diff --git a/src/vs/vscode.proposed.d.ts b/src/vs/vscode.proposed.d.ts
index 430967c999eab9f6f164d9c0d3b24bbc1c64b0f0..d1bb0e8eb672febe7fc78ae27f9d3ae956924ce1 100644
--- a/src/vs/vscode.proposed.d.ts
+++ b/src/vs/vscode.proposed.d.ts
@@ -816,7 +816,7 @@ declare module 'vscode' {
 	 * [Terminal.sendText](#Terminal.sendText) is triggered that will fire the
 	 * [TerminalRenderer.onDidAcceptInput](#TerminalRenderer.onDidAcceptInput) event.
 	 *
-	 * @deprecated Use [virtual processes](#TerminalVirtualProcess) instead.
+	 * @deprecated Use [ExtensionTerminalOptions](#ExtensionTerminalOptions) instead.
 	 *
 	 * **Example:** Create a terminal renderer, show it and write hello world in red
 	 * ```typescript
@@ -828,7 +828,7 @@ declare module 'vscode' {
 	export interface TerminalRenderer {
 		/**
 		 * The name of the terminal, this will appear in the terminal selector.
-		 * @deprecated Use [virtual processes](#TerminalVirtualProcess) instead.
+		 * @deprecated Use [ExtensionTerminalOptions](#ExtensionTerminalOptions) instead.
 		 */
 		name: string;
 
@@ -837,7 +837,7 @@ declare module 'vscode' {
 		 * a value smaller than the maximum value, if this is undefined the terminal will auto fit
 		 * to the maximum value [maximumDimensions](TerminalRenderer.maximumDimensions).
 		 *
-		 * @deprecated Use [virtual processes](#TerminalVirtualProcess) instead.
+		 * @deprecated Use [ExtensionTerminalOptions](#ExtensionTerminalOptions) instead.
 		 *
 		 * **Example:** Override the dimensions of a TerminalRenderer to 20 columns and 10 rows
 		 * ```typescript
@@ -855,14 +855,14 @@ declare module 'vscode' {
 		 * Listen to [onDidChangeMaximumDimensions](TerminalRenderer.onDidChangeMaximumDimensions)
 		 * to get notified when this value changes.
 		 *
-		 * @deprecated Use [virtual processes](#TerminalVirtualProcess) instead.
+		 * @deprecated Use [ExtensionTerminalOptions](#ExtensionTerminalOptions) instead.
 		 */
 		readonly maximumDimensions: TerminalDimensions | undefined;
 
 		/**
 		 * The corresponding [Terminal](#Terminal) for this TerminalRenderer.
 		 *
-		 * @deprecated Use [virtual processes](#TerminalVirtualProcess) instead.
+		 * @deprecated Use [ExtensionTerminalOptions](#ExtensionTerminalOptions) instead.
 		 */
 		readonly terminal: Terminal;
 
@@ -871,7 +871,7 @@ declare module 'vscode' {
 		 * text to the underlying _process_, this will write the text to the terminal itself.
 		 *
 		 * @param text The text to write.
-		 * @deprecated Use [virtual processes](#TerminalVirtualProcess) instead.
+		 * @deprecated Use [ExtensionTerminalOptions](#ExtensionTerminalOptions) instead.
 		 *
 		 * **Example:** Write red text to the terminal
 		 * ```typescript
@@ -890,7 +890,7 @@ declare module 'vscode' {
 		 * [Terminal.sendText](#Terminal.sendText). Keystrokes are converted into their
 		 * corresponding VT sequence representation.
 		 *
-		 * @deprecated Use [virtual processes](#TerminalVirtualProcess) instead.
+		 * @deprecated Use [ExtensionTerminalOptions](#ExtensionTerminalOptions) instead.
 		 *
 		 * **Example:** Simulate interaction with the terminal from an outside extension or a
 		 * workbench command such as `workbench.action.terminal.runSelectedText`
@@ -908,7 +908,7 @@ declare module 'vscode' {
 		 * An event which fires when the [maximum dimensions](#TerminalRenderer.maximumDimensions) of
 		 * the terminal renderer change.
 		 *
-		 * @deprecated Use [virtual processes](#TerminalVirtualProcess) instead.
+		 * @deprecated Use [ExtensionTerminalOptions](#ExtensionTerminalOptions) instead.
 		 */
 		readonly onDidChangeMaximumDimensions: Event<TerminalDimensions>;
 	}
@@ -918,60 +918,60 @@ declare module 'vscode' {
 		 * Create a [TerminalRenderer](#TerminalRenderer).
 		 *
 		 * @param name The name of the terminal renderer, this shows up in the terminal selector.
-		 * @deprecated Use [virtual processes](#TerminalVirtualProcess) instead.
+		 * @deprecated Use [ExtensionTerminalOptions](#ExtensionTerminalOptions) instead.
 		 */
 		export function createTerminalRenderer(name: string): TerminalRenderer;
 	}
 
 	//#endregion
 
-	//#region Terminal extension pty
+	//#region Extension terminals
 
 	export namespace window {
 		/**
-		 * Creates a [Terminal](#Terminal) where an extension acts as the process.
+		 * Creates a [Terminal](#Terminal) where an extension controls the teerminal.
 		 *
-		 * @param options A [TerminalVirtualProcessOptions](#TerminalVirtualProcessOptions) object describing the
-		 * characteristics of the new terminal.
+		 * @param options An [ExtensionTerminalOptions](#ExtensionTerminalOptions) object describing
+		 * the characteristics of the new terminal.
 		 * @return A new Terminal.
 		 */
-		export function createTerminal(options: TerminalVirtualProcessOptions): Terminal;
+		export function createTerminal(options: ExtensionTerminalOptions): Terminal;
 	}
 
 	/**
 	 * Value-object describing what options a virtual process terminal should use.
 	 */
-	export interface TerminalVirtualProcessOptions {
+	export interface ExtensionTerminalOptions {
 		/**
 		 * A human-readable string which will be used to represent the terminal in the UI.
 		 */
 		name: string;
 
 		/**
-		 * An implementation of [TerminalVirtualProcess](#TerminalVirtualProcess) that allows an
-		 * extension to act as a terminal's backing process.
+		 * An implementation of [Pseudoterminal](#Pseudoterminal) that allows an extension to
+		 * control a terminal.
 		 */
-		virtualProcess: TerminalVirtualProcess;
+		pty: Pseudoterminal;
 	}
 
 	/**
-	 * Defines the interface of a terminal virtual process, enabling extensions to act as a process
-	 * in the terminal.
+	 * Defines the interface of a terminal pty, enabling extensions to control a terminal.
 	 */
-	interface TerminalVirtualProcess {
+	interface Pseudoterminal {
 		/**
 		 * An event that when fired will write data to the terminal. Unlike
-		 * [Terminal.sendText](#Terminal.sendText) which sends text to the underlying _process_,
-		 * this will write the text to the terminal itself.
+		 * [Terminal.sendText](#Terminal.sendText) which sends text to the underlying _process_
+		 * (the pty "slave"), this will write the text to the terminal itself (the pty "master").
 		 *
 		 * **Example:** Write red text to the terminal
 		 * ```typescript
 		 * const writeEmitter = new vscode.EventEmitter<string>();
-		 * const virtualProcess: TerminalVirtualProcess = {
-		 *   onDidWrite: writeEmitter.event
+		 * const pty: vscode.Pseudoterminal = {
+		 *   onDidWrite: writeEmitter.event,
+		 *   start: () => writeEmitter.fire('\x1b[31mHello world\x1b[0m'),
+		 *   shutdown: () => {}
 		 * };
-		 * vscode.window.createTerminal({ name: 'My terminal', virtualProcess });
-		 * writeEmitter.fire('\x1b[31mHello world\x1b[0m');
+		 * vscode.window.createTerminal({ name: 'My terminal', pty });
 		 * ```
 		 *
 		 * **Example:** Move the cursor to the 10th row and 20th column and write an asterisk
@@ -985,44 +985,50 @@ declare module 'vscode' {
 		 * An event that when fired allows overriding the [dimensions](#Terminal.dimensions) of the
 		 * terminal. Note that when set the overridden dimensions will only take effect when they
 		 * are lower than the actual dimensions of the terminal (ie. there will never be a scroll
-		 * bar). Set to `undefined` for the terminal to go back to the regular dimensions.
+		 * bar). Set to `undefined` for the terminal to go back to the regular dimensions (fit to
+		 * the size of the panel).
 		 *
 		 * **Example:** Override the dimensions of a terminal to 20 columns and 10 rows
 		 * ```typescript
 		 * const dimensionsEmitter = new vscode.EventEmitter<string>();
-		 * const virtualProcess: TerminalVirtualProcess = {
+		 * const pty: vscode.Pseudoterminal = {
 		 *   onDidWrite: writeEmitter.event,
-		 *   onDidOverrideDimensions: dimensionsEmitter.event
+		 *   onDidOverrideDimensions: dimensionsEmitter.event,
+		 *   start: () => {
+		 *       dimensionsEmitter.fire({
+		 *       columns: 20,
+		 *       rows: 10
+		 *     });
+		 *   },
+		 *   shutdown: () => {}
 		 * };
-		 * vscode.window.createTerminal({ name: 'My terminal', virtualProcess });
-		 * dimensionsEmitter.fire({
-		 *   columns: 20,
-		 *   rows: 10
-		 * });
+		 * vscode.window.createTerminal({ name: 'My terminal', pty });
 		 * ```
 		 */
 		onDidOverrideDimensions?: Event<TerminalDimensions | undefined>;
 
 		/**
 		 * An event that when fired will exit the process with an exit code, this will behave the
-		 * same for a virtual process as when a regular process exits with an exit code. Note that
-		 * exit codes must be positive numbers, when negative the exit code will be forced to `1`.
+		 * same for an extension treminal as when a regular process exits with an exit code. Note
+		 * that exit codes must be positive numbers, when negative the exit code will be forced to
+		 * `1`.
 		 *
 		 * **Example:** Exit with an exit code of `0` if the y key is pressed, otherwise `1`.
 		 * ```typescript
 		 * const writeEmitter = new vscode.EventEmitter<string>();
 		 * const exitEmitter = new vscode.EventEmitter<number>();
-		 * const virtualProcess: TerminalVirtualProcess = {
+		 * const pty: vscode.Pseudoterminal = {
 		 *   onDidWrite: writeEmitter.event,
-		 *   input: data => exitEmitter.fire(data === 'y' ? 0 : 1)
+		 *   start: () => writeEmitter.fire('Press y to exit successfully'),
+		 *   shutdown: () => {}
+		 *   handleInput: data => exitEmitter.fire(data === 'y' ? 0 : 1)
 		 * };
-		 * vscode.window.createTerminal({ name: 'Exit example', virtualProcess });
-		 * writeEmitter.fire('Press y to exit successfully');
+		 * vscode.window.createTerminal({ name: 'Exit example', pty });
 		 */
 		onDidExit?: Event<number>;
 
 		/**
-		 * Implement to handle when the terminal is ready to start firing events.
+		 * Implement to handle when the pty is ready to start firing events.
 		 *
 		 * @param initialDimensions The dimensions of the terminal, this will be undefined if the
 		 * terminal panel has not been opened before this is called.
@@ -1035,21 +1041,23 @@ declare module 'vscode' {
 		shutdown(): void;
 
 		/**
-		 * Implement to handle keystrokes in the terminal or when an extension calls
-		 * [Terminal.sendText](#Terminal.sendText). Keystrokes are converted into their
-		 * corresponding VT sequence representation.
+		 * Implement to handle incoming keystrokes in the terminal or when an extension calls
+		 * [Terminal.sendText](#Terminal.sendText). `data` contains the keystrokes/text serialized into
+		 * their corresponding VT sequence representation.
 		 *
-		 * @param data The sent data.
+		 * @param data The incoming data.
 		 *
 		 * **Example:** Echo input in the terminal. The sequence for enter (`\r`) is translated to
 		 * CRLF to go to a new line and move the cursor to the start of the line.
 		 * ```typescript
 		 * const writeEmitter = new vscode.EventEmitter<string>();
-		 * const virtualProcess: TerminalVirtualProcess = {
+		 * const pty: vscode.Pseudoterminal = {
 		 *   onDidWrite: writeEmitter.event,
+		 *   start: () => {},
+		 *   shutdown: () => {},
 		 *   handleInput: data => writeEmitter.fire(data === '\r' ? '\r\n' : data)
 		 * };
-		 * vscode.window.createTerminal({ name: 'Local echo', virtualProcess });
+		 * vscode.window.createTerminal({ name: 'Local echo', pty });
 		 * ```
 		 */
 		handleInput?(data: string): void;
@@ -1145,6 +1153,7 @@ declare module 'vscode' {
 	}
 	//#endregion
 
+	//#region CustomExecution
 	/**
 	 * Class used to execute an extension callback as a task.
 	 */
@@ -1168,16 +1177,18 @@ declare module 'vscode' {
 	 */
 	export class CustomExecution2 {
 		/**
-		 * @param process The [TerminalVirtualProcess](#TerminalVirtualProcess) to be used by the task to display output.
+		 * @param process The [Pseudotrminal](#Pseudoterminal) to be used by the task to display output.
 		 * @param callback The callback that will be called when the task is started by a user.
 		 */
-		constructor(callback: (thisArg?: any) => Thenable<TerminalVirtualProcess>);
+		constructor(callback: (thisArg?: any) => Thenable<Pseudoterminal>);
 
 		/**
-		 * The callback used to execute the task. Cancellation should be handled using the shutdown method of [TerminalVirtualProcess](#TerminalVirtualProcess).
-		 * When the task is complete, onDidExit should be fired on the TerminalVirtualProcess with the exit code with '0' for success and a non-zero value for failure.
+		 * The callback used to execute the task. Cancellation should be handled using
+		 * [Pseudoterminal.shutdown](#Pseudoterminal.shutdown). When the task is complete,
+		 * [Pseudoterminal.onDidExit](#Pseudoterminal.onDidExit) should be fired with the exit code
+		 * with '0' for success and a non-zero value for failure.
 		 */
-		callback: (thisArg?: any) => Thenable<TerminalVirtualProcess>;
+		callback: (thisArg?: any) => Thenable<Pseudoterminal>;
 	}
 
 	/**
@@ -1203,6 +1214,7 @@ declare module 'vscode' {
 		 */
 		execution2?: ProcessExecution | ShellExecution | CustomExecution | CustomExecution2;
 	}
+	//#endregion
 
 	//#region Tasks
 	export interface TaskPresentationOptions {
diff --git a/src/vs/workbench/api/browser/mainThreadTerminalService.ts b/src/vs/workbench/api/browser/mainThreadTerminalService.ts
index 13f4fad4663557a16956f8d6a3b56b5f16f31bbb..2d3dd6d003522e279283f520206acc8e97260418 100644
--- a/src/vs/workbench/api/browser/mainThreadTerminalService.ts
+++ b/src/vs/workbench/api/browser/mainThreadTerminalService.ts
@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { IDisposable, DisposableStore } from 'vs/base/common/lifecycle';
-import { ITerminalService, ITerminalInstance, IShellLaunchConfig, ITerminalProcessExtHostProxy, ITerminalProcessExtHostRequest, ITerminalDimensions, EXT_HOST_CREATION_DELAY, IAvailableShellsRequest, IDefaultShellAndArgsRequest, ITerminalVirtualProcessRequest } from 'vs/workbench/contrib/terminal/common/terminal';
+import { ITerminalService, ITerminalInstance, IShellLaunchConfig, ITerminalProcessExtHostProxy, ITerminalProcessExtHostRequest, ITerminalDimensions, EXT_HOST_CREATION_DELAY, IAvailableShellsRequest, IDefaultShellAndArgsRequest, IExtensionTerminalRequest } from 'vs/workbench/contrib/terminal/common/terminal';
 import { ExtHostContext, ExtHostTerminalServiceShape, MainThreadTerminalServiceShape, MainContext, IExtHostContext, ShellLaunchConfigDto, TerminalLaunchConfig, ITerminalDimensionsDto } from 'vs/workbench/api/common/extHost.protocol';
 import { extHostNamedCustomer } from 'vs/workbench/api/common/extHostCustomers';
 import { URI } from 'vs/base/common/uri';
@@ -48,7 +48,7 @@ export class MainThreadTerminalService implements MainThreadTerminalServiceShape
 		this._toDispose.add(_terminalService.onInstanceDimensionsChanged(instance => this._onInstanceDimensionsChanged(instance)));
 		this._toDispose.add(_terminalService.onInstanceMaximumDimensionsChanged(instance => this._onInstanceMaximumDimensionsChanged(instance)));
 		this._toDispose.add(_terminalService.onInstanceRequestExtHostProcess(request => this._onTerminalRequestExtHostProcess(request)));
-		this._toDispose.add(_terminalService.onInstanceRequestVirtualProcess(e => this._onTerminalRequestVirtualProcess(e)));
+		this._toDispose.add(_terminalService.onInstanceRequestExtensionTerminal(e => this._onTerminalRequestExtensionTerminal(e)));
 		this._toDispose.add(_terminalService.onActiveInstanceChanged(instance => this._onActiveTerminalChanged(instance ? instance.id : null)));
 		this._toDispose.add(_terminalService.onInstanceTitleChanged(instance => this._onTitleChanged(instance.id, instance.title)));
 		this._toDispose.add(_terminalService.configHelper.onWorkspacePermissionsChanged(isAllowed => this._onWorkspacePermissionsChanged(isAllowed)));
@@ -90,7 +90,7 @@ export class MainThreadTerminalService implements MainThreadTerminalServiceShape
 			env: launchConfig.env,
 			strictEnv: launchConfig.strictEnv,
 			hideFromUser: launchConfig.hideFromUser,
-			isVirtualProcess: launchConfig.isVirtualProcess
+			isExtensionTerminal: launchConfig.isExtensionTerminal
 		};
 		const terminal = this._terminalService.createTerminal(shellLaunchConfig);
 		this._terminalProcesses.set(terminal.id, new Promise<ITerminalProcessExtHostProxy>(r => this._terminalProcessesReady.set(terminal.id, r)));
@@ -270,7 +270,7 @@ export class MainThreadTerminalService implements MainThreadTerminalServiceShape
 		proxy.onRequestLatency(() => this._onRequestLatency(proxy.terminalId));
 	}
 
-	private _onTerminalRequestVirtualProcess(request: ITerminalVirtualProcessRequest): void {
+	private _onTerminalRequestExtensionTerminal(request: IExtensionTerminalRequest): void {
 		const proxy = request.proxy;
 		const ready = this._terminalProcessesReady.get(proxy.terminalId);
 		if (!ready) {
@@ -286,7 +286,7 @@ export class MainThreadTerminalService implements MainThreadTerminalServiceShape
 			columns: request.cols,
 			rows: request.rows
 		} : undefined;
-		this._proxy.$startVirtualProcess(proxy.terminalId, initialDimensions);
+		this._proxy.$startExtensionTerminal(proxy.terminalId, initialDimensions);
 		proxy.onInput(data => this._proxy.$acceptProcessInput(proxy.terminalId, data));
 		proxy.onShutdown(immediate => this._proxy.$acceptProcessShutdown(proxy.terminalId, immediate));
 		proxy.onRequestCwd(() => this._proxy.$acceptProcessRequestCwd(proxy.terminalId));
diff --git a/src/vs/workbench/api/common/extHost.protocol.ts b/src/vs/workbench/api/common/extHost.protocol.ts
index f8d565df56c2d1d34ccb035247d9b1bc56f779c7..6a76d4e86b402edfc3768a89862040fb9c13a66e 100644
--- a/src/vs/workbench/api/common/extHost.protocol.ts
+++ b/src/vs/workbench/api/common/extHost.protocol.ts
@@ -390,7 +390,7 @@ export interface TerminalLaunchConfig {
 	waitOnExit?: boolean;
 	strictEnv?: boolean;
 	hideFromUser?: boolean;
-	isVirtualProcess?: boolean;
+	isExtensionTerminal?: boolean;
 }
 
 export interface MainThreadTerminalServiceShape extends IDisposable {
@@ -1162,7 +1162,7 @@ export interface ExtHostTerminalServiceShape {
 	$acceptTerminalDimensions(id: number, cols: number, rows: number): void;
 	$acceptTerminalMaximumDimensions(id: number, cols: number, rows: number): void;
 	$createProcess(id: number, shellLaunchConfig: ShellLaunchConfigDto, activeWorkspaceRootUri: UriComponents, cols: number, rows: number, isWorkspaceShellAllowed: boolean): void;
-	$startVirtualProcess(id: number, initialDimensions: ITerminalDimensionsDto | undefined): void;
+	$startExtensionTerminal(id: number, initialDimensions: ITerminalDimensionsDto | undefined): void;
 	$acceptProcessInput(id: number, data: string): void;
 	$acceptProcessResize(id: number, cols: number, rows: number): void;
 	$acceptProcessShutdown(id: number, immediate: boolean): void;
diff --git a/src/vs/workbench/api/common/extHostTypes.ts b/src/vs/workbench/api/common/extHostTypes.ts
index b8aebf92b45f46e5afd7cf2950005e62a6a286e1..20d60dddd304053b7b10d5969a250263c19a1f9f 100644
--- a/src/vs/workbench/api/common/extHostTypes.ts
+++ b/src/vs/workbench/api/common/extHostTypes.ts
@@ -1773,19 +1773,19 @@ export class CustomExecution implements vscode.CustomExecution {
 }
 
 export class CustomExecution2 implements vscode.CustomExecution2 {
-	private _callback: () => Thenable<vscode.TerminalVirtualProcess>;
-	constructor(callback: () => Thenable<vscode.TerminalVirtualProcess>) {
+	private _callback: () => Thenable<vscode.Pseudoterminal>;
+	constructor(callback: () => Thenable<vscode.Pseudoterminal>) {
 		this._callback = callback;
 	}
 	public computeId(): string {
 		return 'customExecution' + generateUuid();
 	}
 
-	public set callback(value: () => Thenable<vscode.TerminalVirtualProcess>) {
+	public set callback(value: () => Thenable<vscode.Pseudoterminal>) {
 		this._callback = value;
 	}
 
-	public get callback(): (() => Thenable<vscode.TerminalVirtualProcess>) {
+	public get callback(): (() => Thenable<vscode.Pseudoterminal>) {
 		return this._callback;
 	}
 }
diff --git a/src/vs/workbench/api/node/extHost.api.impl.ts b/src/vs/workbench/api/node/extHost.api.impl.ts
index 27fb09b2abd97156230e381034511ba33dbc2471..f4df88c11ba2d86c049fa8e1cbe916dcb54c48ce 100644
--- a/src/vs/workbench/api/node/extHost.api.impl.ts
+++ b/src/vs/workbench/api/node/extHost.api.impl.ts
@@ -528,10 +528,10 @@ export function createApiFactory(
 				checkProposedApiEnabled(extension);
 				return extHostEditorInsets.createWebviewEditorInset(editor, line, height, options, extension);
 			},
-			createTerminal(nameOrOptions?: vscode.TerminalOptions | vscode.TerminalVirtualProcessOptions | string, shellPath?: string, shellArgs?: string[] | string): vscode.Terminal {
+			createTerminal(nameOrOptions?: vscode.TerminalOptions | vscode.ExtensionTerminalOptions | string, shellPath?: string, shellArgs?: string[] | string): vscode.Terminal {
 				if (typeof nameOrOptions === 'object') {
-					if ('virtualProcess' in nameOrOptions) {
-						return extHostTerminalService.createVirtualProcessTerminal(nameOrOptions);
+					if ('pty' in nameOrOptions) {
+						return extHostTerminalService.createExtensionTerminal(nameOrOptions);
 					} else {
 						nameOrOptions.hideFromUser = nameOrOptions.hideFromUser || (nameOrOptions.runInBackground && extension.enableProposedApi);
 						return extHostTerminalService.createTerminalFromOptions(nameOrOptions);
diff --git a/src/vs/workbench/api/node/extHostTask.ts b/src/vs/workbench/api/node/extHostTask.ts
index 0e7f5f9dd7aadc8650edfbb72c37d9a78e7b687b..9191b53aa47503d058a96c1581ae313e14f8a204 100644
--- a/src/vs/workbench/api/node/extHostTask.ts
+++ b/src/vs/workbench/api/node/extHostTask.ts
@@ -588,7 +588,7 @@ export class ExtHostTask implements ExtHostTaskShape {
 
 			// Clone the custom execution to keep the original untouched. This is important for multiple runs of the same task.
 			this._activeCustomExecutions2.set(execution.id, execution2);
-			await this._terminalService.attachVirtualProcessToTerminal(terminalId, await execution2.callback());
+			await this._terminalService.attachPtyToTerminal(terminalId, await execution2.callback());
 		}
 
 		// Once a terminal is spun up for the custom execution task this event will be fired.
diff --git a/src/vs/workbench/api/node/extHostTerminalService.ts b/src/vs/workbench/api/node/extHostTerminalService.ts
index 4aa39f9112731b264ceff0cc8277753953a2e182..604008252d50eb5189f0a2a007ff9085594110a3 100644
--- a/src/vs/workbench/api/node/extHostTerminalService.ts
+++ b/src/vs/workbench/api/node/extHostTerminalService.ts
@@ -124,8 +124,8 @@ export class ExtHostTerminal extends BaseExtHostTerminal implements vscode.Termi
 		this._runQueuedRequests(terminal.id);
 	}
 
-	public async createVirtualProcess(): Promise<void> {
-		const terminal = await this._proxy.$createTerminal({ name: this._name, isVirtualProcess: true });
+	public async createExtensionTerminal(): Promise<void> {
+		const terminal = await this._proxy.$createTerminal({ name: this._name, isExtensionTerminal: true });
 		this._name = terminal.name;
 		this._runQueuedRequests(terminal.id);
 	}
@@ -329,20 +329,20 @@ export class ExtHostTerminalService implements ExtHostTerminalServiceShape {
 		return terminal;
 	}
 
-	public createVirtualProcessTerminal(options: vscode.TerminalVirtualProcessOptions): vscode.Terminal {
+	public createExtensionTerminal(options: vscode.ExtensionTerminalOptions): vscode.Terminal {
 		const terminal = new ExtHostTerminal(this._proxy, options.name);
-		const p = new ExtHostVirtualProcess(options.virtualProcess);
-		terminal.createVirtualProcess().then(() => this._setupExtHostProcessListeners(terminal._id, p));
+		const p = new ExtHostPseudoterminal(options.pty);
+		terminal.createExtensionTerminal().then(() => this._setupExtHostProcessListeners(terminal._id, p));
 		this._terminals.push(terminal);
 		return terminal;
 	}
 
-	public async attachVirtualProcessToTerminal(id: number, virtualProcess: vscode.TerminalVirtualProcess): Promise<void> {
+	public async attachPtyToTerminal(id: number, pty: vscode.Pseudoterminal): Promise<void> {
 		const terminal = this._getTerminalByIdEventually(id);
 		if (!terminal) {
 			throw new Error(`Cannot resolve terminal with id ${id} for virtual process`);
 		}
-		const p = new ExtHostVirtualProcess(virtualProcess);
+		const p = new ExtHostPseudoterminal(pty);
 		this._setupExtHostProcessListeners(id, p);
 	}
 
@@ -619,9 +619,9 @@ export class ExtHostTerminalService implements ExtHostTerminalServiceShape {
 		this._setupExtHostProcessListeners(id, new TerminalProcess(shellLaunchConfig, initialCwd, cols, rows, env, enableConpty, this._logService));
 	}
 
-	public async $startVirtualProcess(id: number, initialDimensions: ITerminalDimensionsDto | undefined): Promise<void> {
+	public async $startExtensionTerminal(id: number, initialDimensions: ITerminalDimensionsDto | undefined): Promise<void> {
 		// Make sure the ExtHostTerminal exists so onDidOpenTerminal has fired before we call
-		// TerminalVirtualProcess.start
+		// Pseudoterminal.start
 		await this._getTerminalByIdEventually(id);
 
 		// Processes should be initialized here for normal virtual process terminals, however for
@@ -630,7 +630,7 @@ export class ExtHostTerminalService implements ExtHostTerminalServiceShape {
 		let retries = 5;
 		while (retries-- > 0) {
 			if (this._terminalProcesses[id]) {
-				(this._terminalProcesses[id] as ExtHostVirtualProcess).startSendingEvents(initialDimensions);
+				(this._terminalProcesses[id] as ExtHostPseudoterminal).startSendingEvents(initialDimensions);
 				return;
 			}
 			await timeout(50);
@@ -773,7 +773,7 @@ class ApiRequest {
 	}
 }
 
-class ExtHostVirtualProcess implements ITerminalChildProcess {
+class ExtHostPseudoterminal implements ITerminalChildProcess {
 	private _queuedEvents: (IQueuedEvent<string> | IQueuedEvent<number> | IQueuedEvent<{ pid: number, cwd: string }> | IQueuedEvent<ITerminalDimensions | undefined>)[] = [];
 	private _queueDisposables: IDisposable[] | undefined;
 
@@ -789,33 +789,33 @@ class ExtHostVirtualProcess implements ITerminalChildProcess {
 	public get onProcessOverrideDimensions(): Event<ITerminalDimensions | undefined> { return this._onProcessOverrideDimensions.event; }
 
 	constructor(
-		private readonly _virtualProcess: vscode.TerminalVirtualProcess
+		private readonly _pty: vscode.Pseudoterminal
 	) {
 		this._queueDisposables = [];
-		this._queueDisposables.push(this._virtualProcess.onDidWrite(e => this._queuedEvents.push({ emitter: this._onProcessData, data: e })));
-		if (this._virtualProcess.onDidExit) {
-			this._queueDisposables.push(this._virtualProcess.onDidExit(e => this._queuedEvents.push({ emitter: this._onProcessExit, data: e })));
+		this._queueDisposables.push(this._pty.onDidWrite(e => this._queuedEvents.push({ emitter: this._onProcessData, data: e })));
+		if (this._pty.onDidExit) {
+			this._queueDisposables.push(this._pty.onDidExit(e => this._queuedEvents.push({ emitter: this._onProcessExit, data: e })));
 		}
-		if (this._virtualProcess.onDidOverrideDimensions) {
-			this._queueDisposables.push(this._virtualProcess.onDidOverrideDimensions(e => this._queuedEvents.push({ emitter: this._onProcessOverrideDimensions, data: e ? { cols: e.columns, rows: e.rows } : undefined })));
+		if (this._pty.onDidOverrideDimensions) {
+			this._queueDisposables.push(this._pty.onDidOverrideDimensions(e => this._queuedEvents.push({ emitter: this._onProcessOverrideDimensions, data: e ? { cols: e.columns, rows: e.rows } : undefined })));
 		}
 	}
 
 	shutdown(): void {
-		if (this._virtualProcess.shutdown) {
-			this._virtualProcess.shutdown();
+		if (this._pty.shutdown) {
+			this._pty.shutdown();
 		}
 	}
 
 	input(data: string): void {
-		if (this._virtualProcess.handleInput) {
-			this._virtualProcess.handleInput(data);
+		if (this._pty.handleInput) {
+			this._pty.handleInput(data);
 		}
 	}
 
 	resize(cols: number, rows: number): void {
-		if (this._virtualProcess.setDimensions) {
-			this._virtualProcess.setDimensions({ columns: cols, rows });
+		if (this._pty.setDimensions) {
+			this._pty.setDimensions({ columns: cols, rows });
 		}
 	}
 
@@ -838,19 +838,19 @@ class ExtHostVirtualProcess implements ITerminalChildProcess {
 		this._queueDisposables = undefined;
 
 		// Attach the real listeners
-		this._virtualProcess.onDidWrite(e => this._onProcessData.fire(e));
-		if (this._virtualProcess.onDidExit) {
-			this._virtualProcess.onDidExit(e => {
+		this._pty.onDidWrite(e => this._onProcessData.fire(e));
+		if (this._pty.onDidExit) {
+			this._pty.onDidExit(e => {
 				// Ensure only positive exit codes are returned
 				this._onProcessExit.fire(e >= 0 ? e : 1);
 			});
 		}
-		if (this._virtualProcess.onDidOverrideDimensions) {
-			this._virtualProcess.onDidOverrideDimensions(e => this._onProcessOverrideDimensions.fire(e ? { cols: e.columns, rows: e.rows } : e));
+		if (this._pty.onDidOverrideDimensions) {
+			this._pty.onDidOverrideDimensions(e => this._onProcessOverrideDimensions.fire(e ? { cols: e.columns, rows: e.rows } : e));
 		}
 
-		if (this._virtualProcess.start) {
-			this._virtualProcess.start(initialDimensions);
+		if (this._pty.start) {
+			this._pty.start(initialDimensions);
 		}
 	}
 }
diff --git a/src/vs/workbench/contrib/tasks/browser/terminalTaskSystem.ts b/src/vs/workbench/contrib/tasks/browser/terminalTaskSystem.ts
index 21491081db7145e449997f11616bf38aea35d18d..efef7a28135654206d3936e9da2f0768aec3be50 100644
--- a/src/vs/workbench/contrib/tasks/browser/terminalTaskSystem.ts
+++ b/src/vs/workbench/contrib/tasks/browser/terminalTaskSystem.ts
@@ -926,7 +926,7 @@ export class TerminalTaskSystem implements ITaskSystem {
 			};
 		} else if (task.command.runtime === RuntimeType.CustomExecution2) {
 			this.currentTask.shellLaunchConfig = launchConfigs = {
-				isVirtualProcess: true,
+				isExtensionTerminal: true,
 				waitOnExit,
 				name: this.createTerminalName(task, workspaceFolder),
 				initialText: task.command.presentation && task.command.presentation.echo ? `\x1b[1m> Executing task: ${task._label} <\x1b[0m\n` : undefined
diff --git a/src/vs/workbench/contrib/terminal/browser/terminalProcessManager.ts b/src/vs/workbench/contrib/terminal/browser/terminalProcessManager.ts
index a391164f1f21f38c2b52b40e2da53443dd03c6a1..348b93e33072726ad7167a6abd9d59f45b205fa1 100644
--- a/src/vs/workbench/contrib/terminal/browser/terminalProcessManager.ts
+++ b/src/vs/workbench/contrib/terminal/browser/terminalProcessManager.ts
@@ -31,7 +31,7 @@ const LATENCY_MEASURING_INTERVAL = 1000;
 
 enum ProcessType {
 	Process,
-	VirtualProcess
+	ExtensionTerminal
 }
 
 /**
@@ -113,8 +113,8 @@ export class TerminalProcessManager implements ITerminalProcessManager {
 		rows: number,
 		isScreenReaderModeEnabled: boolean
 	): Promise<void> {
-		if (shellLaunchConfig.isVirtualProcess) {
-			this._processType = ProcessType.VirtualProcess;
+		if (shellLaunchConfig.isExtensionTerminal) {
+			this._processType = ProcessType.ExtensionTerminal;
 			this._process = this._instantiationService.createInstance(TerminalProcessExtHostProxy, this._terminalId, shellLaunchConfig, undefined, cols, rows, this._configHelper);
 		} else {
 			const forceExtHostProcess = (this._configHelper.config as any).extHostProcess;
@@ -239,7 +239,7 @@ export class TerminalProcessManager implements ITerminalProcessManager {
 	}
 
 	public write(data: string): void {
-		if (this.shellProcessId || this._processType === ProcessType.VirtualProcess) {
+		if (this.shellProcessId || this._processType === ProcessType.ExtensionTerminal) {
 			if (this._process) {
 				// Send data if the pty is ready
 				this._process.input(data);
@@ -292,4 +292,4 @@ export class TerminalProcessManager implements ITerminalProcessManager {
 
 		this._onProcessExit.fire(exitCode);
 	}
-}
\ No newline at end of file
+}
diff --git a/src/vs/workbench/contrib/terminal/common/terminal.ts b/src/vs/workbench/contrib/terminal/common/terminal.ts
index f427fd3ef0e6c9c5f3c87ea5f298a751cf562896..2774d70a82c3184cba65f6f7fdcf26e30d74b328 100644
--- a/src/vs/workbench/contrib/terminal/common/terminal.ts
+++ b/src/vs/workbench/contrib/terminal/common/terminal.ts
@@ -188,14 +188,14 @@ export interface IShellLaunchConfig {
 	initialText?: string;
 
 	/**
-	 * @deprecated use `isVirtualProcess`
+	 * @deprecated use `isExtensionTerminal`
 	 */
 	isRendererOnly?: boolean;
 
 	/**
-	 * When true an extension is acting as the terminal's process.
+	 * Whether an extension is controlling the terminal via a `vscode.Pseudoterminal`.
 	 */
-	isVirtualProcess?: boolean;
+	isExtensionTerminal?: boolean;
 
 	/**
 	 * Whether the terminal process environment should be exactly as provided in
@@ -232,7 +232,7 @@ export interface ITerminalService {
 	onInstanceDimensionsChanged: Event<ITerminalInstance>;
 	onInstanceMaximumDimensionsChanged: Event<ITerminalInstance>;
 	onInstanceRequestExtHostProcess: Event<ITerminalProcessExtHostRequest>;
-	onInstanceRequestVirtualProcess: Event<ITerminalVirtualProcessRequest>;
+	onInstanceRequestExtensionTerminal: Event<IExtensionTerminalRequest>;
 	onInstancesChanged: Event<void>;
 	onInstanceTitleChanged: Event<ITerminalInstance>;
 	onActiveInstanceChanged: Event<ITerminalInstance | undefined>;
@@ -300,7 +300,7 @@ export interface ITerminalService {
 
 	extHostReady(remoteAuthority: string): void;
 	requestExtHostProcess(proxy: ITerminalProcessExtHostProxy, shellLaunchConfig: IShellLaunchConfig, activeWorkspaceRootUri: URI, cols: number, rows: number, isWorkspaceShellAllowed: boolean): void;
-	requestVirtualProcess(proxy: ITerminalProcessExtHostProxy, cols: number, rows: number): void;
+	requestExtensionTerminal(proxy: ITerminalProcessExtHostProxy, cols: number, rows: number): void;
 }
 
 /**
@@ -769,7 +769,7 @@ export interface ITerminalProcessExtHostRequest {
 	isWorkspaceShellAllowed: boolean;
 }
 
-export interface ITerminalVirtualProcessRequest {
+export interface IExtensionTerminalRequest {
 	proxy: ITerminalProcessExtHostProxy;
 	cols: number;
 	rows: number;
diff --git a/src/vs/workbench/contrib/terminal/common/terminalProcessExtHostProxy.ts b/src/vs/workbench/contrib/terminal/common/terminalProcessExtHostProxy.ts
index e611bce74a669d33611125fed57fc5a46937faca..7093d6aa7f6586c09a920e8673e285fd542131ed 100644
--- a/src/vs/workbench/contrib/terminal/common/terminalProcessExtHostProxy.ts
+++ b/src/vs/workbench/contrib/terminal/common/terminalProcessExtHostProxy.ts
@@ -58,8 +58,9 @@ export class TerminalProcessExtHostProxy extends Disposable implements ITerminal
 
 		// Request a process if needed, if this is a virtual process this step can be skipped as
 		// there is no real "process" and we know it's ready on the ext host already.
-		if (shellLaunchConfig.isVirtualProcess) {
-			this._terminalService.requestVirtualProcess(this, cols, rows);
+		if (shellLaunchConfig.isExtensionTerminal) {
+			// TODO: This name should be improved
+			this._terminalService.requestExtensionTerminal(this, cols, rows);
 		} else {
 			remoteAgentService.getEnvironment().then(env => {
 				if (!env) {
@@ -149,4 +150,4 @@ export class TerminalProcessExtHostProxy extends Disposable implements ITerminal
 			this._pendingLatencyRequests.push(resolve);
 		});
 	}
-}
\ No newline at end of file
+}
diff --git a/src/vs/workbench/contrib/terminal/common/terminalService.ts b/src/vs/workbench/contrib/terminal/common/terminalService.ts
index 558be1e44ea9da5cd172d5e9c7787f30f5633aee..36cbc613dba94db47e88beaab358c6e3b67c4516 100644
--- a/src/vs/workbench/contrib/terminal/common/terminalService.ts
+++ b/src/vs/workbench/contrib/terminal/common/terminalService.ts
@@ -8,7 +8,7 @@ import { Event, Emitter } from 'vs/base/common/event';
 import { IContextKeyService, IContextKey } from 'vs/platform/contextkey/common/contextkey';
 import { ILifecycleService } from 'vs/platform/lifecycle/common/lifecycle';
 import { IPanelService } from 'vs/workbench/services/panel/common/panelService';
-import { ITerminalService, ITerminalInstance, IShellLaunchConfig, ITerminalConfigHelper, KEYBINDING_CONTEXT_TERMINAL_FOCUS, KEYBINDING_CONTEXT_TERMINAL_FIND_WIDGET_VISIBLE, TERMINAL_PANEL_ID, ITerminalTab, ITerminalProcessExtHostProxy, ITerminalProcessExtHostRequest, KEYBINDING_CONTEXT_TERMINAL_IS_OPEN, ITerminalNativeService, IShellDefinition, IAvailableShellsRequest, ITerminalVirtualProcessRequest } from 'vs/workbench/contrib/terminal/common/terminal';
+import { ITerminalService, ITerminalInstance, IShellLaunchConfig, ITerminalConfigHelper, KEYBINDING_CONTEXT_TERMINAL_FOCUS, KEYBINDING_CONTEXT_TERMINAL_FIND_WIDGET_VISIBLE, TERMINAL_PANEL_ID, ITerminalTab, ITerminalProcessExtHostProxy, ITerminalProcessExtHostRequest, KEYBINDING_CONTEXT_TERMINAL_IS_OPEN, ITerminalNativeService, IShellDefinition, IAvailableShellsRequest, IExtensionTerminalRequest } from 'vs/workbench/contrib/terminal/common/terminal';
 import { IStorageService } from 'vs/platform/storage/common/storage';
 import { URI } from 'vs/base/common/uri';
 import { FindReplaceState } from 'vs/editor/contrib/find/findState';
@@ -55,8 +55,8 @@ export abstract class TerminalService implements ITerminalService {
 	public get onInstanceProcessIdReady(): Event<ITerminalInstance> { return this._onInstanceProcessIdReady.event; }
 	protected readonly _onInstanceRequestExtHostProcess = new Emitter<ITerminalProcessExtHostRequest>();
 	public get onInstanceRequestExtHostProcess(): Event<ITerminalProcessExtHostRequest> { return this._onInstanceRequestExtHostProcess.event; }
-	protected readonly _onInstanceRequestVirtualProcess = new Emitter<ITerminalVirtualProcessRequest>();
-	public get onInstanceRequestVirtualProcess(): Event<ITerminalVirtualProcessRequest> { return this._onInstanceRequestVirtualProcess.event; }
+	protected readonly _onInstanceRequestExtensionTerminal = new Emitter<IExtensionTerminalRequest>();
+	public get onInstanceRequestExtensionTerminal(): Event<IExtensionTerminalRequest> { return this._onInstanceRequestExtensionTerminal.event; }
 	protected readonly _onInstanceDimensionsChanged = new Emitter<ITerminalInstance>();
 	public get onInstanceDimensionsChanged(): Event<ITerminalInstance> { return this._onInstanceDimensionsChanged.event; }
 	protected readonly _onInstanceMaximumDimensionsChanged = new Emitter<ITerminalInstance>();
@@ -144,8 +144,8 @@ export abstract class TerminalService implements ITerminalService {
 		});
 	}
 
-	public requestVirtualProcess(proxy: ITerminalProcessExtHostProxy, cols: number, rows: number): void {
-		this._onInstanceRequestVirtualProcess.fire({ proxy, cols, rows });
+	public requestExtensionTerminal(proxy: ITerminalProcessExtHostProxy, cols: number, rows: number): void {
+		this._onInstanceRequestExtensionTerminal.fire({ proxy, cols, rows });
 	}
 
 	public extHostReady(remoteAuthority: string): void {