diff --git a/src/vs/base/common/worker/simpleWorker.ts b/src/vs/base/common/worker/simpleWorker.ts
index 2cc1b188cac..6c9815d3aaa 100644
--- a/src/vs/base/common/worker/simpleWorker.ts
+++ b/src/vs/base/common/worker/simpleWorker.ts
@@ -16,7 +16,7 @@ export interface IWorker extends IDisposable {
 }
 
 export interface IWorkerCallback {
-	(message: string): void;
+	(message: any): void;
 }
 
 export interface IWorkerFactory {
diff --git a/src/vs/base/worker/workerMain.ts b/src/vs/base/worker/workerMain.ts
index 0ec8b7834dc..8d51252951a 100644
--- a/src/vs/base/worker/workerMain.ts
+++ b/src/vs/base/worker/workerMain.ts
@@ -20,8 +20,8 @@
 	let loadCode = function (moduleId: string) {
 		require([moduleId], function (ws) {
 			setTimeout(function () {
-				let messageHandler = ws.create((msg: any) => {
-					(<any>self).postMessage(msg);
+				let messageHandler = ws.create((msg: any, transfer?: Transferable[]) => {
+					(<any>self).postMessage(msg, transfer);
 				}, null);
 
 				self.onmessage = (e) => messageHandler.onmessage(e.data);
diff --git a/src/vs/code/electron-browser/workbench/workbench.html b/src/vs/code/electron-browser/workbench/workbench.html
index dfac360344a..483d01493f5 100644
--- a/src/vs/code/electron-browser/workbench/workbench.html
+++ b/src/vs/code/electron-browser/workbench/workbench.html
@@ -10,4 +10,4 @@
 
 	<!-- Startup via workbench.js -->
 	<script src="workbench.js"></script>
-</html>
\ No newline at end of file
+</html>
diff --git a/src/vs/workbench/api/common/extHost.api.impl.ts b/src/vs/workbench/api/common/extHost.api.impl.ts
index e8fec875029..0c4b489095d 100644
--- a/src/vs/workbench/api/common/extHost.api.impl.ts
+++ b/src/vs/workbench/api/common/extHost.api.impl.ts
@@ -15,7 +15,7 @@ import { OverviewRulerLane } from 'vs/editor/common/model';
 import * as languageConfiguration from 'vs/editor/common/modes/languageConfiguration';
 import { score } from 'vs/editor/common/modes/languageSelector';
 import * as files from 'vs/platform/files/common/files';
-import { ExtHostContext, MainContext } from 'vs/workbench/api/common/extHost.protocol';
+import { ExtHostContext, MainContext, ExtHostLogServiceShape } from 'vs/workbench/api/common/extHost.protocol';
 import { ExtHostApiCommands } from 'vs/workbench/api/common/extHostApiCommands';
 import { ExtHostClipboard } from 'vs/workbench/api/common/extHostClipboard';
 import { IExtHostCommands } from 'vs/workbench/api/common/extHostCommands';
@@ -33,7 +33,6 @@ import { ExtHostFileSystem } from 'vs/workbench/api/common/extHostFileSystem';
 import { ExtHostFileSystemEventService } from 'vs/workbench/api/common/extHostFileSystemEventService';
 import { ExtHostLanguageFeatures } from 'vs/workbench/api/common/extHostLanguageFeatures';
 import { ExtHostLanguages } from 'vs/workbench/api/common/extHostLanguages';
-import { ExtHostLogService } from 'vs/workbench/api/common/extHostLogService';
 import { ExtHostMessageService } from 'vs/workbench/api/common/extHostMessageService';
 import { IExtHostOutputService } from 'vs/workbench/api/common/extHostOutput';
 import { ExtHostProgress } from 'vs/workbench/api/common/extHostProgress';
@@ -95,10 +94,10 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 	const uriTransformer = accessor.get(IURITransformerService);
 	const rpcProtocol = accessor.get(IExtHostRpcService);
 	const extHostStorage = accessor.get(IExtHostStorage);
-	const extHostLogService = <ExtHostLogService>accessor.get(ILogService);
+	const extHostLogService = accessor.get(ILogService);
 
 	// register addressable instances
-	rpcProtocol.set(ExtHostContext.ExtHostLogService, extHostLogService);
+	rpcProtocol.set(ExtHostContext.ExtHostLogService, <ExtHostLogServiceShape><any>extHostLogService);
 	rpcProtocol.set(ExtHostContext.ExtHostWorkspace, extHostWorkspace);
 	rpcProtocol.set(ExtHostContext.ExtHostConfiguration, extHostConfiguration);
 	rpcProtocol.set(ExtHostContext.ExtHostExtensionService, extensionService);
@@ -145,10 +144,6 @@ export function createApiFactoryAndRegisterActors(accessor: ServicesAccessor): I
 	const extHostStatusBar = new ExtHostStatusBar(rpcProtocol);
 	const extHostLanguages = new ExtHostLanguages(rpcProtocol, extHostDocuments);
 
-	// Register an output channel for exthost log
-	const outputChannelName = initData.remote.isRemote ? nls.localize('remote extension host Log', "Remote Extension Host") : nls.localize('extension host Log', "Extension Host");
-	extHostOutputService.createOutputChannelFromLogFile(outputChannelName, extHostLogService.logFile);
-
 	// Register API-ish commands
 	ExtHostApiCommands.register(extHostCommands);
 
diff --git a/src/vs/workbench/api/common/extHostExtensionService.ts b/src/vs/workbench/api/common/extHostExtensionService.ts
index 58098d94099..99553033cd2 100644
--- a/src/vs/workbench/api/common/extHostExtensionService.ts
+++ b/src/vs/workbench/api/common/extHostExtensionService.ts
@@ -14,7 +14,6 @@ import { ILogService } from 'vs/platform/log/common/log';
 import { ExtHostExtensionServiceShape, IInitData, MainContext, MainThreadExtensionServiceShape, MainThreadTelemetryShape, MainThreadWorkspaceShape, IResolveAuthorityResult } from 'vs/workbench/api/common/extHost.protocol';
 import { ExtHostConfiguration, IExtHostConfiguration } from 'vs/workbench/api/common/extHostConfiguration';
 import { ActivatedExtension, EmptyExtension, ExtensionActivatedByAPI, ExtensionActivatedByEvent, ExtensionActivationReason, ExtensionActivationTimes, ExtensionActivationTimesBuilder, ExtensionsActivator, IExtensionAPI, IExtensionContext, IExtensionModule, HostExtension, ExtensionActivationTimesFragment } from 'vs/workbench/api/common/extHostExtensionActivator';
-import { ExtHostLogService } from 'vs/workbench/api/common/extHostLogService';
 import { ExtHostStorage, IExtHostStorage } from 'vs/workbench/api/common/extHostStorage';
 import { ExtHostWorkspace, IExtHostWorkspace } from 'vs/workbench/api/common/extHostWorkspace';
 import { ExtensionActivationError } from 'vs/workbench/services/extensions/common/extensions';
@@ -75,7 +74,7 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 	protected readonly _instaService: IInstantiationService;
 	protected readonly _extHostWorkspace: ExtHostWorkspace;
 	protected readonly _extHostConfiguration: ExtHostConfiguration;
-	protected readonly _extHostLogService: ExtHostLogService;
+	protected readonly _logService: ILogService;
 
 	protected readonly _mainThreadWorkspaceProxy: MainThreadWorkspaceShape;
 	protected readonly _mainThreadTelemetryProxy: MainThreadTelemetryShape;
@@ -102,7 +101,7 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 		@IExtHostRpcService extHostContext: IExtHostRpcService,
 		@IExtHostWorkspace extHostWorkspace: IExtHostWorkspace,
 		@IExtHostConfiguration extHostConfiguration: IExtHostConfiguration,
-		@ILogService extHostLogService: ExtHostLogService,
+		@ILogService logService: ILogService,
 		@IExtHostInitDataService initData: IExtHostInitDataService,
 		@IExtensionStoragePaths storagePath: IExtensionStoragePaths
 	) {
@@ -112,7 +111,7 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 
 		this._extHostWorkspace = extHostWorkspace;
 		this._extHostConfiguration = extHostConfiguration;
-		this._extHostLogService = extHostLogService;
+		this._logService = logService;
 		this._disposables = new DisposableStore();
 
 		this._mainThreadWorkspaceProxy = this._extHostContext.getProxy(MainContext.MainThreadWorkspace);
@@ -329,14 +328,14 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 			return Promise.resolve(new EmptyExtension(ExtensionActivationTimes.NONE));
 		}
 
-		this._extHostLogService.info(`ExtensionService#_doActivateExtension ${extensionDescription.identifier.value} ${JSON.stringify(reason)}`);
+		this._logService.info(`ExtensionService#_doActivateExtension ${extensionDescription.identifier.value} ${JSON.stringify(reason)}`);
 
 		const activationTimesBuilder = new ExtensionActivationTimesBuilder(reason.startup);
 		return Promise.all<any>([
 			this._loadCommonJSModule(extensionDescription.main, activationTimesBuilder),
 			this._loadExtensionContext(extensionDescription)
 		]).then(values => {
-			return AbstractExtHostExtensionService._callActivate(this._extHostLogService, extensionDescription.identifier, <IExtensionModule>values[0], <IExtensionContext>values[1], activationTimesBuilder);
+			return AbstractExtHostExtensionService._callActivate(this._logService, extensionDescription.identifier, <IExtensionModule>values[0], <IExtensionContext>values[1], activationTimesBuilder);
 		});
 	}
 
@@ -347,7 +346,7 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 		const globalState = new ExtensionMemento(extensionDescription.identifier.value, true, this._storage);
 		const workspaceState = new ExtensionMemento(extensionDescription.identifier.value, false, this._storage);
 
-		this._extHostLogService.trace(`ExtensionService#loadExtensionContext ${extensionDescription.identifier.value}`);
+		this._logService.trace(`ExtensionService#loadExtensionContext ${extensionDescription.identifier.value}`);
 		return Promise.all([
 			globalState.whenReady,
 			workspaceState.whenReady,
@@ -359,10 +358,10 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 				workspaceState,
 				subscriptions: [],
 				get extensionPath() { return extensionDescription.extensionLocation.fsPath; },
-				storagePath: this._storagePath.workspaceValue(extensionDescription),
-				globalStoragePath: this._storagePath.globalValue(extensionDescription),
+				get storagePath() { return that._storagePath.workspaceValue(extensionDescription); },
+				get globalStoragePath() { return that._storagePath.globalValue(extensionDescription); },
 				asAbsolutePath: (relativePath: string) => { return path.join(extensionDescription.extensionLocation.fsPath, relativePath); },
-				logPath: that._extHostLogService.getLogDirectory(extensionDescription.identifier),
+				get logPath() { return path.join(that._initData.logsLocation.fsPath, extensionDescription.identifier.value); },
 				executionContext: this._initData.remote.isRemote ? ExtensionExecutionContext.Remote : ExtensionExecutionContext.Local,
 			});
 		});
@@ -385,7 +384,8 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 			try {
 				activationTimesBuilder.activateCallStart();
 				logService.trace(`ExtensionService#_callActivateOptional ${extensionId.value}`);
-				const activateResult: Promise<IExtensionAPI> = extensionModule.activate.apply(global, [context]);
+				const scope = typeof global === 'object' ? global : self; // `global` is nodejs while `self` is for workers
+				const activateResult: Promise<IExtensionAPI> = extensionModule.activate.apply(scope, [context]);
 				activationTimesBuilder.activateCallStop();
 
 				activationTimesBuilder.activateResolveStart();
@@ -478,7 +478,7 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 	}
 
 	private async _activateIfGlobPatterns(folders: ReadonlyArray<vscode.WorkspaceFolder>, extensionId: ExtensionIdentifier, globPatterns: string[]): Promise<void> {
-		this._extHostLogService.trace(`extensionHostMain#activateIfGlobPatterns: fileSearch, extension: ${extensionId.value}, entryPoint: workspaceContains`);
+		this._logService.trace(`extensionHostMain#activateIfGlobPatterns: fileSearch, extension: ${extensionId.value}, entryPoint: workspaceContains`);
 
 		if (globPatterns.length === 0) {
 			return Promise.resolve(undefined);
@@ -525,7 +525,7 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 	}
 
 	private async _doHandleExtensionTests(): Promise<void> {
-		const { extensionDevelopmentLocationURI: extensionDevelopmentLocationURI, extensionTestsLocationURI } = this._initData.environment;
+		const { extensionDevelopmentLocationURI, extensionTestsLocationURI } = this._initData.environment;
 		if (!(extensionDevelopmentLocationURI && extensionTestsLocationURI && extensionTestsLocationURI.scheme === Schemas.file)) {
 			return Promise.resolve(undefined);
 		}
@@ -605,7 +605,7 @@ export abstract class AbstractExtHostExtensionService implements ExtHostExtensio
 			.then(() => this._handleEagerExtensions())
 			.then(() => this._handleExtensionTests())
 			.then(() => {
-				this._extHostLogService.info(`eager extensions activated`);
+				this._logService.info(`eager extensions activated`);
 			});
 	}
 
diff --git a/src/vs/workbench/api/common/extHostLogService.ts b/src/vs/workbench/api/common/extHostLogService.ts
deleted file mode 100644
index d67a19801d3..00000000000
--- a/src/vs/workbench/api/common/extHostLogService.ts
+++ /dev/null
@@ -1,34 +0,0 @@
-/*---------------------------------------------------------------------------------------------
- *  Copyright (c) Microsoft Corporation. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *--------------------------------------------------------------------------------------------*/
-
-import { join } from 'vs/base/common/path';
-import { ILogService, DelegatedLogService, LogLevel } from 'vs/platform/log/common/log';
-import { ExtHostLogServiceShape } from 'vs/workbench/api/common/extHost.protocol';
-import { ExtensionHostLogFileName } from 'vs/workbench/services/extensions/common/extensions';
-import { URI } from 'vs/base/common/uri';
-import { ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
-
-export class ExtHostLogService extends DelegatedLogService implements ILogService, ExtHostLogServiceShape {
-
-	private _logsPath: string;
-	readonly logFile: URI;
-
-	constructor(
-		delegate: ILogService,
-		logsPath: string,
-	) {
-		super(delegate);
-		this._logsPath = logsPath;
-		this.logFile = URI.file(join(logsPath, `${ExtensionHostLogFileName}.log`));
-	}
-
-	$setLevel(level: LogLevel): void {
-		this.setLevel(level);
-	}
-
-	getLogDirectory(extensionID: ExtensionIdentifier): string {
-		return join(this._logsPath, extensionID.value);
-	}
-}
diff --git a/src/vs/workbench/api/node/extHost.services.ts b/src/vs/workbench/api/node/extHost.services.ts
index 153413e086e..a227d8a67b3 100644
--- a/src/vs/workbench/api/node/extHost.services.ts
+++ b/src/vs/workbench/api/node/extHost.services.ts
@@ -24,8 +24,11 @@ import { IExtensionStoragePaths } from 'vs/workbench/api/common/extHostStoragePa
 import { IExtHostExtensionService } from 'vs/workbench/api/common/extHostExtensionService';
 import { ExtHostExtensionService } from 'vs/workbench/api/node/extHostExtensionService';
 import { IExtHostStorage, ExtHostStorage } from 'vs/workbench/api/common/extHostStorage';
+import { ILogService } from 'vs/platform/log/common/log';
+import { ExtHostLogService } from 'vs/workbench/api/node/extHostLogService';
 
 // register singleton services
+registerSingleton(ILogService, ExtHostLogService);
 registerSingleton(IExtHostOutputService, ExtHostOutputService2);
 registerSingleton(IExtHostWorkspace, ExtHostWorkspace);
 registerSingleton(IExtHostDecorations, ExtHostDecorations);
diff --git a/src/vs/workbench/api/node/extHostExtensionService.ts b/src/vs/workbench/api/node/extHostExtensionService.ts
index efbf84cf641..8f1f5d6ee75 100644
--- a/src/vs/workbench/api/node/extHostExtensionService.ts
+++ b/src/vs/workbench/api/node/extHostExtensionService.ts
@@ -41,14 +41,24 @@ export class ExtHostExtensionService extends AbstractExtHostExtensionService {
 		}
 
 		// Do this when extension service exists, but extensions are not being activated yet.
-		await connectProxyResolver(this._extHostWorkspace, configProvider, this, this._extHostLogService, this._mainThreadTelemetryProxy);
+		await connectProxyResolver(this._extHostWorkspace, configProvider, this, this._logService, this._mainThreadTelemetryProxy);
 
+		// Use IPC messages to forward console-calls, note that the console is
+		// already patched to use`process.send()`
+		const nativeProcessSend = process.send!;
+		const mainThreadConsole = this._extHostContext.getProxy(MainContext.MainThreadConsole);
+		process.send = (...args: any[]) => {
+			if (args.length === 0 || !args[0] || args[0].type !== '__$console') {
+				return nativeProcessSend.apply(process, args);
+			}
+			mainThreadConsole.$logExtensionHostMessage(args[0]);
+		};
 	}
 
 	protected _loadCommonJSModule<T>(modulePath: string, activationTimesBuilder: ExtensionActivationTimesBuilder): Promise<T> {
 		let r: T | null = null;
 		activationTimesBuilder.codeLoadingStart();
-		this._extHostLogService.info(`ExtensionService#loadCommonJSModule ${modulePath}`);
+		this._logService.info(`ExtensionService#loadCommonJSModule ${modulePath}`);
 		try {
 			r = require.__$__nodeRequire<T>(modulePath);
 		} catch (e) {
diff --git a/src/vs/workbench/api/node/extHostLogService.ts b/src/vs/workbench/api/node/extHostLogService.ts
new file mode 100644
index 00000000000..f29d417620d
--- /dev/null
+++ b/src/vs/workbench/api/node/extHostLogService.ts
@@ -0,0 +1,36 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { localize } from 'vs/nls';
+import { join } from 'vs/base/common/path';
+import { ILogService, DelegatedLogService, LogLevel } from 'vs/platform/log/common/log';
+import { ExtHostLogServiceShape } from 'vs/workbench/api/common/extHost.protocol';
+import { ExtensionHostLogFileName } from 'vs/workbench/services/extensions/common/extensions';
+import { URI } from 'vs/base/common/uri';
+import { IExtHostInitDataService } from 'vs/workbench/api/common/extHostInitDataService';
+import { Schemas } from 'vs/base/common/network';
+import { SpdLogService } from 'vs/platform/log/node/spdlogService';
+import { IExtHostOutputService } from 'vs/workbench/api/common/extHostOutput';
+
+export class ExtHostLogService extends DelegatedLogService implements ILogService, ExtHostLogServiceShape {
+
+	constructor(
+		@IExtHostInitDataService initData: IExtHostInitDataService,
+		@IExtHostOutputService extHostOutputService: IExtHostOutputService
+	) {
+		if (initData.logsLocation.scheme !== Schemas.file) { throw new Error('Only file-logging supported'); }
+		super(new SpdLogService(ExtensionHostLogFileName, initData.logsLocation.fsPath, initData.logLevel));
+
+		// Register an output channel for exthost log
+		extHostOutputService.createOutputChannelFromLogFile(
+			initData.remote.isRemote ? localize('remote extension host Log', "Remote Extension Host") : localize('extension host Log', "Extension Host"),
+			URI.file(join(initData.logsLocation.fsPath, `${ExtensionHostLogFileName}.log`))
+		);
+	}
+
+	$setLevel(level: LogLevel): void {
+		this.setLevel(level);
+	}
+}
diff --git a/src/vs/workbench/api/worker/extHostExtensionService.ts b/src/vs/workbench/api/worker/extHostExtensionService.ts
new file mode 100644
index 00000000000..6f7f2b67feb
--- /dev/null
+++ b/src/vs/workbench/api/worker/extHostExtensionService.ts
@@ -0,0 +1,98 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { createApiFactoryAndRegisterActors, IExtensionApiFactory } from 'vs/workbench/api/common/extHost.api.impl';
+import { ExtensionActivationTimesBuilder } from 'vs/workbench/api/common/extHostExtensionActivator';
+import { AbstractExtHostExtensionService } from 'vs/workbench/api/common/extHostExtensionService';
+import { endsWith } from 'vs/base/common/strings';
+import { IExtensionDescription, ExtensionIdentifier } from 'vs/platform/extensions/common/extensions';
+import { ExtHostConfigProvider } from 'vs/workbench/api/common/extHostConfiguration';
+import * as vscode from 'vscode';
+import { TernarySearchTree } from 'vs/base/common/map';
+import { nullExtensionDescription } from 'vs/workbench/services/extensions/common/extensions';
+import { ExtensionDescriptionRegistry } from 'vs/workbench/services/extensions/common/extensionDescriptionRegistry';
+
+class ApiInstances {
+
+	private readonly _apiInstances = new Map<string, typeof vscode>();
+
+	constructor(
+		private readonly _apiFactory: IExtensionApiFactory,
+		private readonly _extensionPaths: TernarySearchTree<IExtensionDescription>,
+		private readonly _extensionRegistry: ExtensionDescriptionRegistry,
+		private readonly _configProvider: ExtHostConfigProvider,
+	) {
+		//
+	}
+
+	get(modulePath: string): typeof vscode {
+		const extension = this._extensionPaths.findSubstr(modulePath) || nullExtensionDescription;
+		const id = ExtensionIdentifier.toKey(extension.identifier);
+
+		let apiInstance = this._apiInstances.get(id);
+		if (!apiInstance) {
+			apiInstance = this._apiFactory(extension, this._extensionRegistry, this._configProvider);
+			this._apiInstances.set(id, apiInstance);
+		}
+		return apiInstance;
+	}
+}
+
+export class ExtHostExtensionService extends AbstractExtHostExtensionService {
+
+	private _apiInstances?: ApiInstances;
+
+	protected async _beforeAlmostReadyToRunExtensions(): Promise<void> {
+		// initialize API and register actors
+		const apiFactory = this._instaService.invokeFunction(createApiFactoryAndRegisterActors);
+		const configProvider = await this._extHostConfiguration.getConfigProvider();
+		const extensionPath = await this.getExtensionPathIndex();
+		this._apiInstances = new ApiInstances(apiFactory, extensionPath, this._registry, configProvider);
+	}
+
+	protected _loadCommonJSModule<T>(modulePath: string, activationTimesBuilder: ExtensionActivationTimesBuilder): Promise<T> {
+
+		// make sure modulePath ends with `.js`
+		const suffix = '.js';
+		modulePath = endsWith(modulePath, suffix) ? modulePath : modulePath + suffix;
+
+		interface FakeCommonJSSelf {
+			module?: object;
+			exports?: object;
+			require?: (module: string) => any;
+			window?: object;
+			__dirname: never;
+			__filename: never;
+		}
+
+		// FAKE commonjs world that only collects exports
+		const patchSelf: FakeCommonJSSelf = <any>self;
+		const module = { exports: {} };
+		patchSelf.module = module;
+		patchSelf.exports = module.exports;
+		patchSelf.window = self; // <- that's improper but might help extensions that aren't authored correctly
+
+		// FAKE require function that only works for the vscode-module
+		patchSelf.require = (module: string) => {
+			if (module !== 'vscode') {
+				throw new Error(`Cannot load module '${module}'`);
+			}
+			return this._apiInstances!.get(modulePath);
+		};
+
+		try {
+			activationTimesBuilder.codeLoadingStart();
+			importScripts(modulePath);
+		} finally {
+			activationTimesBuilder.codeLoadingStop();
+		}
+
+		return Promise.resolve(module.exports as T);
+	}
+
+	async $setRemoteEnvironment(env: { [key: string]: string | null }): Promise<void> {
+		throw new Error('Not supported');
+	}
+}
diff --git a/src/vs/workbench/api/worker/extHostLogService.ts b/src/vs/workbench/api/worker/extHostLogService.ts
new file mode 100644
index 00000000000..79211c61945
--- /dev/null
+++ b/src/vs/workbench/api/worker/extHostLogService.ts
@@ -0,0 +1,84 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { ILogService, LogLevel, AbstractLogService } from 'vs/platform/log/common/log';
+import { ExtHostLogServiceShape } from 'vs/workbench/api/common/extHost.protocol';
+import { IExtHostInitDataService } from 'vs/workbench/api/common/extHostInitDataService';
+import { IExtHostOutputService } from 'vs/workbench/api/common/extHostOutput';
+import * as vscode from 'vscode';
+
+export class ExtHostLogService extends AbstractLogService implements ILogService, ExtHostLogServiceShape {
+
+	_serviceBrand: any;
+
+	private readonly _logChannel: vscode.OutputChannel;
+
+	constructor(
+		@IExtHostInitDataService initData: IExtHostInitDataService,
+		@IExtHostOutputService extHostOutputService: IExtHostOutputService
+	) {
+		super();
+		this.setLevel(initData.logLevel);
+		this._logChannel = extHostOutputService.createOutputChannel('Log (Worker Extension Host)');
+	}
+
+	$setLevel(level: LogLevel): void {
+		this.setLevel(level);
+	}
+
+	trace(_message: string, ..._args: any[]): void {
+		if (this.getLevel() <= LogLevel.Trace) {
+			this._logChannel.appendLine(this._format(arguments));
+		}
+	}
+
+	debug(_message: string, ..._args: any[]): void {
+		if (this.getLevel() <= LogLevel.Debug) {
+			this._logChannel.appendLine(this._format(arguments));
+		}
+	}
+
+	info(_message: string, ..._args: any[]): void {
+		if (this.getLevel() <= LogLevel.Info) {
+			this._logChannel.appendLine(this._format(arguments));
+		}
+	}
+
+	warn(_message: string, ..._args: any[]): void {
+		if (this.getLevel() <= LogLevel.Warning) {
+			this._logChannel.appendLine(this._format(arguments));
+		}
+	}
+
+	error(_message: string | Error, ..._args: any[]): void {
+		if (this.getLevel() <= LogLevel.Error) {
+			this._logChannel.appendLine(this._format(arguments));
+		}
+	}
+
+	critical(_message: string | Error, ..._args: any[]): void {
+		if (this.getLevel() <= LogLevel.Critical) {
+			this._logChannel.appendLine(String(arguments));
+		}
+	}
+
+	private _format(args: any): string {
+		let result = '';
+
+		for (let i = 0; i < args.length; i++) {
+			let a = args[i];
+
+			if (typeof a === 'object') {
+				try {
+					a = JSON.stringify(a);
+				} catch (e) { }
+			}
+
+			result += (i > 0 ? ' ' : '') + a;
+		}
+
+		return result;
+	}
+}
diff --git a/src/vs/workbench/services/extensions/browser/extensionService.ts b/src/vs/workbench/services/extensions/browser/extensionService.ts
index 077598d16d6..a32024e35ac 100644
--- a/src/vs/workbench/services/extensions/browser/extensionService.ts
+++ b/src/vs/workbench/services/extensions/browser/extensionService.ts
@@ -18,6 +18,8 @@ import { ExtensionHostProcessManager } from 'vs/workbench/services/extensions/co
 import { RemoteExtensionHostClient, IInitDataProvider } from 'vs/workbench/services/extensions/common/remoteExtensionHostClient';
 import { IRemoteAgentEnvironment } from 'vs/platform/remote/common/remoteAgentEnvironment';
 import { INotificationService, Severity } from 'vs/platform/notification/common/notification';
+import { WebWorkerExtensionHostStarter } from 'vs/workbench/services/extensions/browser/webWorkerExtensionHostStarter';
+import { URI } from 'vs/base/common/uri';
 
 export class ExtensionService extends AbstractExtensionService implements IExtensionService {
 
@@ -62,6 +64,11 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 		const result: ExtensionHostProcessManager[] = [];
 
 		const remoteAgentConnection = this._remoteAgentService.getConnection()!;
+
+		const webHostProcessWorker = this._instantiationService.createInstance(WebWorkerExtensionHostStarter, true, Promise.resolve([]), URI.parse('empty:value')); //todo@joh
+		const webHostProcessManager = this._instantiationService.createInstance(ExtensionHostProcessManager, false, webHostProcessWorker, remoteAgentConnection.remoteAuthority, initialActivationEvents);
+		result.push(webHostProcessManager);
+
 		const remoteExtHostProcessWorker = this._instantiationService.createInstance(RemoteExtensionHostClient, this.getExtensions(), this._createProvider(remoteAgentConnection.remoteAuthority), this._remoteAgentService.socketFactory);
 		const remoteExtHostProcessManager = this._instantiationService.createInstance(ExtensionHostProcessManager, false, remoteExtHostProcessWorker, remoteAgentConnection.remoteAuthority, initialActivationEvents);
 		result.push(remoteExtHostProcessManager);
diff --git a/src/vs/workbench/services/extensions/browser/webWorkerExtensionHostStarter.ts b/src/vs/workbench/services/extensions/browser/webWorkerExtensionHostStarter.ts
new file mode 100644
index 00000000000..1f04364fa5d
--- /dev/null
+++ b/src/vs/workbench/services/extensions/browser/webWorkerExtensionHostStarter.ts
@@ -0,0 +1,149 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { DefaultWorkerFactory } from 'vs/base/worker/defaultWorkerFactory';
+import { Emitter, Event } from 'vs/base/common/event';
+import { DisposableStore } from 'vs/base/common/lifecycle';
+import { IMessagePassingProtocol } from 'vs/base/parts/ipc/common/ipc';
+import { VSBuffer } from 'vs/base/common/buffer';
+import { createMessageOfType, MessageType, isMessageOfType } from 'vs/workbench/services/extensions/common/extensionHostProtocol';
+import { IInitData } from 'vs/workbench/api/common/extHost.protocol';
+import { ITelemetryService } from 'vs/platform/telemetry/common/telemetry';
+import { IWorkspaceContextService, WorkbenchState } from 'vs/platform/workspace/common/workspace';
+import { ILabelService } from 'vs/platform/label/common/label';
+import { ILogService } from 'vs/platform/log/common/log';
+import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
+import * as platform from 'vs/base/common/platform';
+import { URI } from 'vs/base/common/uri';
+import { IExtensionHostStarter } from 'vs/workbench/services/extensions/common/extensions';
+import { IProductService } from 'vs/platform/product/common/product';
+import { IWorkbenchEnvironmentService } from 'vs/workbench/services/environment/common/environmentService';
+
+export class WebWorkerExtensionHostStarter implements IExtensionHostStarter {
+
+	private _toDispose = new DisposableStore();
+	private _isTerminating: boolean = false;
+	private _protocol?: IMessagePassingProtocol;
+
+	private readonly _onDidExit = new Emitter<[number, string | null]>();
+	readonly onExit: Event<[number, string | null]> = this._onDidExit.event;
+
+	constructor(
+		private readonly _autoStart: boolean,
+		private readonly _extensions: Promise<IExtensionDescription[]>,
+		private readonly _extensionHostLogsLocation: URI,
+		@ITelemetryService private readonly _telemetryService: ITelemetryService,
+		@IWorkspaceContextService private readonly _contextService: IWorkspaceContextService,
+		@ILabelService private readonly _labelService: ILabelService,
+		@ILogService private readonly _logService: ILogService,
+		@IWorkbenchEnvironmentService private readonly _environmentService: IWorkbenchEnvironmentService,
+		@IProductService private readonly _productService: IProductService,
+	) {
+
+	}
+
+	async start(): Promise<IMessagePassingProtocol> {
+
+		if (!this._protocol) {
+
+			const emitter = new Emitter<VSBuffer>();
+			const worker = new DefaultWorkerFactory('WorkerExtensionHost').create(
+				'vs/workbench/services/extensions/worker/extensionHostWorker', data => {
+					if (data instanceof ArrayBuffer) {
+						emitter.fire(VSBuffer.wrap(new Uint8Array(data, 0, data.byteLength)));
+					} else {
+						console.warn('UNKNOWN data received', data);
+						this._onDidExit.fire([77, 'UNKNOWN data received']);
+					}
+				}, err => {
+					this._onDidExit.fire([81, err]);
+					console.error(err);
+				}
+			);
+
+			// keep for cleanup
+			this._toDispose.add(emitter);
+			this._toDispose.add(worker);
+
+			const protocol: IMessagePassingProtocol = {
+				onMessage: emitter.event,
+				send: vsbuf => {
+					const data = vsbuf.buffer.buffer.slice(vsbuf.buffer.byteOffset, vsbuf.buffer.byteOffset + vsbuf.buffer.byteLength);
+					worker.postMessage(data, [data]);
+				}
+			};
+
+			// extension host handshake happens below
+			// (1) <== wait for: Ready
+			// (2) ==> send: init data
+			// (3) <== wait for: Initialized
+
+			await Event.toPromise(Event.filter(protocol.onMessage, msg => isMessageOfType(msg, MessageType.Ready)));
+			protocol.send(VSBuffer.fromString(JSON.stringify(await this._createExtHostInitData())));
+			await Event.toPromise(Event.filter(protocol.onMessage, msg => isMessageOfType(msg, MessageType.Initialized)));
+
+			this._protocol = protocol;
+		}
+		return this._protocol;
+
+	}
+
+	dispose(): void {
+		if (!this._protocol) {
+			this._toDispose.dispose();
+			return;
+		}
+		if (this._isTerminating) {
+			return;
+		}
+		this._isTerminating = true;
+		this._protocol.send(createMessageOfType(MessageType.Terminate));
+		setTimeout(() => this._toDispose.dispose(), 10 * 1000);
+	}
+
+	getInspectPort(): number | undefined {
+		return undefined;
+	}
+
+	private async _createExtHostInitData(): Promise<IInitData> {
+		const [telemetryInfo, extensionDescriptions] = await Promise.all([this._telemetryService.getTelemetryInfo(), this._extensions]);
+		const workspace = this._contextService.getWorkspace();
+		return {
+			commit: this._productService.commit,
+			version: this._productService.version,
+			parentPid: -1,
+			environment: {
+				isExtensionDevelopmentDebug: false,
+				appRoot: this._environmentService.appRoot ? URI.file(this._environmentService.appRoot) : undefined,
+				appSettingsHome: this._environmentService.appSettingsHome ? this._environmentService.appSettingsHome : undefined,
+				appName: this._productService.nameLong,
+				appUriScheme: this._productService.urlProtocol,
+				appLanguage: platform.language,
+				extensionDevelopmentLocationURI: this._environmentService.extensionDevelopmentLocationURI,
+				extensionTestsLocationURI: this._environmentService.extensionTestsLocationURI,
+				globalStorageHome: URI.parse('fake:globalStorageHome'), //todo@joh URI.file(this._environmentService.globalStorageHome),
+				userHome: URI.parse('fake:userHome'), //todo@joh URI.file(this._environmentService.userHome),
+				webviewResourceRoot: this._environmentService.webviewResourceRoot,
+				webviewCspSource: this._environmentService.webviewCspSource,
+			},
+			workspace: this._contextService.getWorkbenchState() === WorkbenchState.EMPTY ? undefined : {
+				configuration: workspace.configuration || undefined,
+				id: workspace.id,
+				name: this._labelService.getWorkspaceLabel(workspace)
+			},
+			resolvedExtensions: [],
+			hostExtensions: [],
+			extensions: extensionDescriptions,
+			telemetryInfo,
+			logLevel: this._logService.getLevel(),
+			logsLocation: this._extensionHostLogsLocation,
+			autoStart: this._autoStart,
+			remote: {
+				authority: this._environmentService.configuration.remoteAuthority,
+				isRemote: false
+			},
+		};
+	}
+}
diff --git a/src/vs/workbench/services/extensions/common/extensionHostMain.ts b/src/vs/workbench/services/extensions/common/extensionHostMain.ts
index d1c8e25185b..16356a4a96c 100644
--- a/src/vs/workbench/services/extensions/common/extensionHostMain.ts
+++ b/src/vs/workbench/services/extensions/common/extensionHostMain.ts
@@ -10,7 +10,6 @@ import { URI, setUriThrowOnMissingScheme } from 'vs/base/common/uri';
 import { IURITransformer } from 'vs/base/common/uriIpc';
 import { IMessagePassingProtocol } from 'vs/base/parts/ipc/common/ipc';
 import { IInitData, MainContext, MainThreadConsoleShape } from 'vs/workbench/api/common/extHost.protocol';
-import { ExtHostLogService } from 'vs/workbench/api/common/extHostLogService';
 import { RPCProtocol } from 'vs/workbench/services/extensions/common/rpcProtocol';
 import { IExtensionDescription } from 'vs/platform/extensions/common/extensions';
 import { ILogService } from 'vs/platform/log/common/log';
@@ -35,10 +34,6 @@ export interface IConsolePatchFn {
 	(mainThreadConsole: MainThreadConsoleShape): any;
 }
 
-export interface ILogServiceFn {
-	(initData: IInitData): ILogService;
-}
-
 export class ExtensionHostMain {
 
 	private _isTerminating: boolean;
@@ -50,8 +45,6 @@ export class ExtensionHostMain {
 		protocol: IMessagePassingProtocol,
 		initData: IInitData,
 		hostUtils: IHostUtils,
-		consolePatchFn: IConsolePatchFn,
-		logServiceFn: ILogServiceFn,
 		uriTransformer: IURITransformer | null
 	) {
 		this._isTerminating = false;
@@ -61,27 +54,27 @@ export class ExtensionHostMain {
 		// ensure URIs are transformed and revived
 		initData = ExtensionHostMain._transform(initData, rpcProtocol);
 
-		// allow to patch console
-		consolePatchFn(rpcProtocol.getProxy(MainContext.MainThreadConsole));
-
-		// services
-		const extHostLogService = new ExtHostLogService(logServiceFn(initData), initData.logsLocation.fsPath);
-		this._disposables.add(extHostLogService);
-
 		// bootstrap services
 		const services = new ServiceCollection(...getSingletonServiceDescriptors());
 		services.set(IExtHostInitDataService, { _serviceBrand: undefined, ...initData });
 		services.set(IExtHostRpcService, new ExtHostRpcService(rpcProtocol));
-		services.set(ILogService, extHostLogService);
 		services.set(IURITransformerService, new URITransformerService(uriTransformer));
 		services.set(IHostUtils, hostUtils);
 
 		const instaService: IInstantiationService = new InstantiationService(services, true);
 
-		extHostLogService.info('extension host started');
-		extHostLogService.trace('initData', initData);
+		// todo@joh
+		// ugly self - inject
+		const logService = instaService.invokeFunction(accessor => accessor.get(ILogService));
+		this._disposables.add(logService);
 
-		// todo@joh -> not soo nice...
+		logService.info('extension host started');
+		logService.trace('initData', initData);
+
+		// todo@joh
+		// ugly self - inject
+		// must call initialize *after* creating the extension service
+		// because `initialize` itself creates instances that depend on it
 		this._extensionService = instaService.invokeFunction(accessor => accessor.get(IExtHostExtensionService));
 		this._extensionService.initialize();
 
diff --git a/src/vs/workbench/services/extensions/electron-browser/extensionService.ts b/src/vs/workbench/services/extensions/electron-browser/extensionService.ts
index 6fb7d2d1be1..272f399268f 100644
--- a/src/vs/workbench/services/extensions/electron-browser/extensionService.ts
+++ b/src/vs/workbench/services/extensions/electron-browser/extensionService.ts
@@ -349,6 +349,7 @@ export class ExtensionService extends AbstractExtensionService implements IExten
 		}
 
 		const result: ExtensionHostProcessManager[] = [];
+
 		const extHostProcessWorker = this._instantiationService.createInstance(ExtensionHostProcessWorker, autoStart, extensions, this._extensionHostLogsLocation);
 		const extHostProcessManager = this._instantiationService.createInstance(ExtensionHostProcessManager, true, extHostProcessWorker, null, initialActivationEvents);
 		result.push(extHostProcessManager);
diff --git a/src/vs/workbench/services/extensions/node/extensionHostProcessSetup.ts b/src/vs/workbench/services/extensions/node/extensionHostProcessSetup.ts
index f708e29da7c..1e887093123 100644
--- a/src/vs/workbench/services/extensions/node/extensionHostProcessSetup.ts
+++ b/src/vs/workbench/services/extensions/node/extensionHostProcessSetup.ts
@@ -12,16 +12,14 @@ import { IMessagePassingProtocol } from 'vs/base/parts/ipc/common/ipc';
 import { PersistentProtocol, ProtocolConstants, createBufferedEvent } from 'vs/base/parts/ipc/common/ipc.net';
 import { NodeSocket, WebSocketNodeSocket } from 'vs/base/parts/ipc/node/ipc.net';
 import product from 'vs/platform/product/node/product';
-import { IInitData, MainThreadConsoleShape } from 'vs/workbench/api/common/extHost.protocol';
+import { IInitData } from 'vs/workbench/api/common/extHost.protocol';
 import { MessageType, createMessageOfType, isMessageOfType, IExtHostSocketMessage, IExtHostReadyMessage } from 'vs/workbench/services/extensions/common/extensionHostProtocol';
-import { ExtensionHostMain, IExitFn, ILogServiceFn } from 'vs/workbench/services/extensions/common/extensionHostMain';
+import { ExtensionHostMain, IExitFn } from 'vs/workbench/services/extensions/common/extensionHostMain';
 import { VSBuffer } from 'vs/base/common/buffer';
-import { ExtensionHostLogFileName } from 'vs/workbench/services/extensions/common/extensions';
 import { IURITransformer, URITransformer, IRawURITransformer } from 'vs/base/common/uriIpc';
 import { exists } from 'vs/base/node/pfs';
 import { realpath } from 'vs/base/node/extpath';
 import { IHostUtils } from 'vs/workbench/api/common/extHostExtensionService';
-import { SpdLogService } from 'vs/platform/log/node/spdlogService';
 import 'vs/workbench/api/node/extHost.services';
 
 interface ParsedExtHostArgs {
@@ -70,21 +68,6 @@ function patchProcess(allowExit: boolean) {
 	};
 }
 
-// use IPC messages to forward console-calls
-function patchPatchedConsole(mainThreadConsole: MainThreadConsoleShape): void {
-	// The console is already patched to use `process.send()`
-	const nativeProcessSend = process.send!;
-	process.send = (...args: any[]) => {
-		if (args.length === 0 || !args[0] || args[0].type !== '__$console') {
-			return nativeProcessSend.apply(process, args);
-		}
-
-		mainThreadConsole.$logExtensionHostMessage(args[0]);
-	};
-}
-
-const createLogService: ILogServiceFn = initData => new SpdLogService(ExtensionHostLogFileName, initData.logsLocation.fsPath, initData.logLevel);
-
 interface IRendererConnection {
 	protocol: IMessagePassingProtocol;
 	initData: IInitData;
@@ -206,7 +189,7 @@ async function createExtHostProtocol(): Promise<IMessagePassingProtocol> {
 }
 
 function connectToRenderer(protocol: IMessagePassingProtocol): Promise<IRendererConnection> {
-	return new Promise<IRendererConnection>((c, e) => {
+	return new Promise<IRendererConnection>((c) => {
 
 		// Listen init data message
 		const first = protocol.onMessage(raw => {
@@ -335,8 +318,6 @@ export async function startExtensionHostProcess(): Promise<void> {
 		renderer.protocol,
 		initData,
 		hostUtils,
-		patchPatchedConsole,
-		createLogService,
 		uriTransformer
 	);
 
diff --git a/src/vs/workbench/services/extensions/node/proxyResolver.ts b/src/vs/workbench/services/extensions/node/proxyResolver.ts
index 6aa6ba1e617..64c2e0a526e 100644
--- a/src/vs/workbench/services/extensions/node/proxyResolver.ts
+++ b/src/vs/workbench/services/extensions/node/proxyResolver.ts
@@ -17,11 +17,11 @@ import { IExtHostWorkspaceProvider } from 'vs/workbench/api/common/extHostWorksp
 import { ExtHostConfigProvider } from 'vs/workbench/api/common/extHostConfiguration';
 import { ProxyAgent } from 'vscode-proxy-agent';
 import { MainThreadTelemetryShape } from 'vs/workbench/api/common/extHost.protocol';
-import { ExtHostLogService } from 'vs/workbench/api/common/extHostLogService';
 import { toErrorMessage } from 'vs/base/common/errorMessage';
 import { ExtHostExtensionService } from 'vs/workbench/api/node/extHostExtensionService';
 import { URI } from 'vs/base/common/uri';
 import { promisify } from 'util';
+import { ILogService } from 'vs/platform/log/common/log';
 
 interface ConnectionResult {
 	proxy: string;
@@ -34,7 +34,7 @@ export function connectProxyResolver(
 	extHostWorkspace: IExtHostWorkspaceProvider,
 	configProvider: ExtHostConfigProvider,
 	extensionService: ExtHostExtensionService,
-	extHostLogService: ExtHostLogService,
+	extHostLogService: ILogService,
 	mainThreadTelemetry: MainThreadTelemetryShape
 ) {
 	const resolveProxy = setupProxyResolution(extHostWorkspace, configProvider, extHostLogService, mainThreadTelemetry);
@@ -47,7 +47,7 @@ const maxCacheEntries = 5000; // Cache can grow twice that much due to 'oldCache
 function setupProxyResolution(
 	extHostWorkspace: IExtHostWorkspaceProvider,
 	configProvider: ExtHostConfigProvider,
-	extHostLogService: ExtHostLogService,
+	extHostLogService: ILogService,
 	mainThreadTelemetry: MainThreadTelemetryShape
 ) {
 	const env = process.env;
@@ -421,7 +421,7 @@ function configureModuleLoading(extensionService: ExtHostExtensionService, looku
 		});
 }
 
-function useSystemCertificates(extHostLogService: ExtHostLogService, useSystemCertificates: boolean, opts: http.RequestOptions, callback: () => void) {
+function useSystemCertificates(extHostLogService: ILogService, useSystemCertificates: boolean, opts: http.RequestOptions, callback: () => void) {
 	if (useSystemCertificates) {
 		getCaCertificates(extHostLogService)
 			.then(caCertificates => {
@@ -443,7 +443,7 @@ function useSystemCertificates(extHostLogService: ExtHostLogService, useSystemCe
 }
 
 let _caCertificates: ReturnType<typeof readCaCertificates> | Promise<undefined>;
-async function getCaCertificates(extHostLogService: ExtHostLogService) {
+async function getCaCertificates(extHostLogService: ILogService) {
 	if (!_caCertificates) {
 		_caCertificates = readCaCertificates()
 			.then(res => res && res.certs.length ? res : undefined)
diff --git a/src/vs/workbench/services/extensions/worker/extHost.services.ts b/src/vs/workbench/services/extensions/worker/extHost.services.ts
new file mode 100644
index 00000000000..bf4a7791554
--- /dev/null
+++ b/src/vs/workbench/services/extensions/worker/extHost.services.ts
@@ -0,0 +1,57 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
+import { IExtHostOutputService, ExtHostOutputService } from 'vs/workbench/api/common/extHostOutput';
+import { IExtHostWorkspace, ExtHostWorkspace } from 'vs/workbench/api/common/extHostWorkspace';
+import { IExtHostDecorations, ExtHostDecorations } from 'vs/workbench/api/common/extHostDecorations';
+import { IExtHostConfiguration, ExtHostConfiguration } from 'vs/workbench/api/common/extHostConfiguration';
+import { IExtHostCommands, ExtHostCommands } from 'vs/workbench/api/common/extHostCommands';
+import { IExtHostDocumentsAndEditors, ExtHostDocumentsAndEditors } from 'vs/workbench/api/common/extHostDocumentsAndEditors';
+import { IExtHostTerminalService } from 'vs/workbench/api/common/extHostTerminalService';
+import { IExtHostTask } from 'vs/workbench/api/common/extHostTask';
+import { IExtHostDebugService } from 'vs/workbench/api/common/extHostDebugService';
+import { IExtHostSearch } from 'vs/workbench/api/common/extHostSearch';
+import { IExtensionStoragePaths } from 'vs/workbench/api/common/extHostStoragePaths';
+import { IExtHostExtensionService } from 'vs/workbench/api/common/extHostExtensionService';
+import { IExtHostStorage, ExtHostStorage } from 'vs/workbench/api/common/extHostStorage';
+import { ExtHostExtensionService } from 'vs/workbench/api/worker/extHostExtensionService';
+import { ServiceIdentifier } from 'vs/platform/instantiation/common/instantiation';
+import { ILogService } from 'vs/platform/log/common/log';
+import { ExtHostLogService } from 'vs/workbench/api/worker/extHostLogService';
+
+// register singleton services
+registerSingleton(ILogService, ExtHostLogService);
+registerSingleton(IExtHostOutputService, ExtHostOutputService);
+registerSingleton(IExtHostWorkspace, ExtHostWorkspace);
+registerSingleton(IExtHostDecorations, ExtHostDecorations);
+registerSingleton(IExtHostConfiguration, ExtHostConfiguration);
+registerSingleton(IExtHostCommands, ExtHostCommands);
+registerSingleton(IExtHostDocumentsAndEditors, ExtHostDocumentsAndEditors);
+registerSingleton(IExtHostStorage, ExtHostStorage);
+registerSingleton(IExtHostExtensionService, ExtHostExtensionService);
+
+// register services that only throw errors
+function NotImplementedProxy<T>(name: ServiceIdentifier<T>): { new(): T } {
+	return <any>class {
+		constructor() {
+			return new Proxy({}, {
+				get(target: any, prop: string | number) {
+					if (target[prop]) {
+						return target[prop];
+					}
+					throw new Error(`Not Implemented: ${name}->${String(prop)}`);
+				}
+			});
+		}
+	};
+}
+registerSingleton(IExtHostTerminalService, class extends NotImplementedProxy(IExtHostTerminalService) { });
+registerSingleton(IExtHostTask, class extends NotImplementedProxy(IExtHostTask) { });
+registerSingleton(IExtHostDebugService, class extends NotImplementedProxy(IExtHostDebugService) { });
+registerSingleton(IExtHostSearch, class extends NotImplementedProxy(IExtHostSearch) { });
+registerSingleton(IExtensionStoragePaths, class extends NotImplementedProxy(IExtensionStoragePaths) {
+	whenReady = Promise.resolve();
+});
diff --git a/src/vs/workbench/services/extensions/worker/extensionHostWorker.ts b/src/vs/workbench/services/extensions/worker/extensionHostWorker.ts
new file mode 100644
index 00000000000..3ed289be397
--- /dev/null
+++ b/src/vs/workbench/services/extensions/worker/extensionHostWorker.ts
@@ -0,0 +1,117 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { IRequestHandler } from 'vs/base/common/worker/simpleWorker';
+import { IMessagePassingProtocol } from 'vs/base/parts/ipc/common/ipc';
+import { VSBuffer } from 'vs/base/common/buffer';
+import { Emitter } from 'vs/base/common/event';
+import { isMessageOfType, MessageType, createMessageOfType } from 'vs/workbench/services/extensions/common/extensionHostProtocol';
+import { IInitData } from 'vs/workbench/api/common/extHost.protocol';
+import { ExtensionHostMain } from 'vs/workbench/services/extensions/common/extensionHostMain';
+import { IHostUtils } from 'vs/workbench/api/common/extHostExtensionService';
+import 'vs/workbench/services/extensions/worker/extHost.services';
+
+// worker-self
+declare namespace self {
+	function close(): void;
+}
+
+// do not allow extensions to call terminate
+const nativeClose = self.close.bind(self);
+self.close = () => console.trace('An extension called terminate and this was prevented');
+let onTerminate = nativeClose;
+
+const hostUtil = new class implements IHostUtils {
+	_serviceBrand: any;
+	exit(_code?: number | undefined): void {
+		nativeClose();
+	}
+	async exists(_path: string): Promise<boolean> {
+		return true;
+	}
+	async realpath(path: string): Promise<string> {
+		return path;
+	}
+};
+
+//todo@joh do not allow extensions to call postMessage and other globals...
+
+class ExtensionWorker implements IRequestHandler {
+
+	// worker-contract
+	readonly _requestHandlerBrand: any;
+	readonly onmessage: (data: any) => any;
+
+	// protocol
+	readonly protocol: IMessagePassingProtocol;
+
+	constructor(postMessage: (message: any, transfer?: Transferable[]) => any) {
+
+		let emitter = new Emitter<VSBuffer>();
+		let terminating = false;
+
+		this.onmessage = data => {
+			if (!(data instanceof ArrayBuffer)) {
+				console.warn('UNKNOWN data received', data);
+				return;
+			}
+
+			const msg = VSBuffer.wrap(new Uint8Array(data, 0, data.byteLength));
+			if (isMessageOfType(msg, MessageType.Terminate)) {
+				// handle terminate-message right here
+				terminating = true;
+				onTerminate();
+				return;
+			}
+
+			// emit non-terminate messages to the outside
+			emitter.fire(msg);
+		};
+
+		this.protocol = {
+			onMessage: emitter.event,
+			send: vsbuf => {
+				if (!terminating) {
+					const data = vsbuf.buffer.buffer.slice(vsbuf.buffer.byteOffset, vsbuf.buffer.byteOffset + vsbuf.buffer.byteLength);
+					postMessage(data, [data]);
+				}
+			}
+		};
+	}
+}
+
+interface IRendererConnection {
+	protocol: IMessagePassingProtocol;
+	initData: IInitData;
+}
+function connectToRenderer(protocol: IMessagePassingProtocol): Promise<IRendererConnection> {
+	return new Promise<IRendererConnection>(resolve => {
+		const once = protocol.onMessage(raw => {
+			once.dispose();
+			const initData = <IInitData>JSON.parse(raw.toString());
+			protocol.send(createMessageOfType(MessageType.Initialized));
+			resolve({ protocol, initData });
+		});
+		protocol.send(createMessageOfType(MessageType.Ready));
+	});
+}
+
+export function create(postMessage: (message: any, transfer?: Transferable[]) => any): IRequestHandler {
+	const res = new ExtensionWorker(postMessage);
+
+	connectToRenderer(res.protocol).then(data => {
+
+		const extHostMain = new ExtensionHostMain(
+			data.protocol,
+			data.initData,
+			hostUtil,
+			null,
+		);
+
+		onTerminate = () => extHostMain.terminate();
+	});
+
+	return res;
+}
diff --git a/tslint.json b/tslint.json
index e10b559308d..548b9a51191 100644
--- a/tslint.json
+++ b/tslint.json
@@ -391,6 +391,14 @@
 					"**/vs/workbench/contrib/*/common/**"
 				]
 			},
+			{
+				"target": "**/vs/workbench/api/worker/**",
+				"restrictions": [
+					"vscode",
+					"vs/nls",
+					"**/vs/**/{common,worker}/**"
+				]
+			},
 			{
 				"target": "**/vs/workbench/electron-browser/**",
 				"restrictions": [
@@ -434,16 +442,30 @@
 					"vscode-textmate"
 				]
 			},
+			{
+				"target": "**/vs/workbench/services/**/worker/**",
+				"restrictions": [
+					"vs/nls",
+					"**/vs/base/**/common/**",
+					"**/vs/platform/**/common/**",
+					"**/vs/editor/common/**",
+					"**/vs/workbench/**/common/**",
+					"**/vs/workbench/**/worker/**",
+					"**/vs/workbench/services/**/common/**",
+					"vscode"
+				]
+			},
 			{
 				"target": "**/vs/workbench/services/**/browser/**",
 				"restrictions": [
 					"vs/nls",
 					"vs/css!./**/*",
-					"**/vs/base/**/{common,browser}/**",
+					"**/vs/base/**/{common,browser,worker}/**",
 					"**/vs/platform/**/{common,browser}/**",
 					"**/vs/editor/{common,browser}/**",
 					"**/vs/workbench/workbench.web.api",
 					"**/vs/workbench/{common,browser}/**",
+					"**/vs/workbench/api/{common,browser}/**",
 					"**/vs/workbench/services/**/{common,browser}/**",
 					"vscode-textmate",
 					"onigasm-umd",
@@ -468,7 +490,7 @@
 				"restrictions": [
 					"vs/nls",
 					"vs/css!./**/*",
-					"**/vs/base/**/{common,browser,node,electron-browser}/**",
+					"**/vs/base/**/{common,browser,worker,node,electron-browser}/**",
 					"**/vs/platform/**/{common,browser,node,electron-browser}/**",
 					"**/vs/editor/**",
 					"**/vs/workbench/{common,browser,node,electron-browser,api}/**",