diff --git a/packages/output/src/browser/output-contribution.ts b/packages/output/src/browser/output-contribution.ts
index 2303d9a0ba17c..26ece2d8f5a28 100644
--- a/packages/output/src/browser/output-contribution.ts
+++ b/packages/output/src/browser/output-contribution.ts
@@ -19,6 +19,7 @@ import { AbstractViewContribution } from '@theia/core/lib/browser/shell/view-con
 import { Widget, KeybindingRegistry, KeybindingContext, ApplicationShell } from '@theia/core/lib/browser';
 import { OUTPUT_WIDGET_KIND, OutputWidget } from './output-widget';
 import { Command, CommandRegistry } from '@theia/core/lib/common';
+import { OutputChannelManager } from '../common/output-channel';
 
 export namespace OutputCommands {
 
@@ -37,6 +38,12 @@ export namespace OutputCommands {
         label: 'Select All'
     };
 
+    export const SCROLL_LOCK: Command = {
+        id: 'output:scrollLock',
+        label: 'Toggle Auto Scroll in Selected Channel',
+        category: OUTPUT_CATEGORY
+    };
+
 }
 
 /**
@@ -64,6 +71,9 @@ export class OutputContribution extends AbstractViewContribution<OutputWidget> {
     @inject(OutputWidgetIsActiveContext)
     protected readonly outputIsActiveContext: OutputWidgetIsActiveContext;
 
+    @inject(OutputChannelManager)
+    protected readonly outputChannelManager: OutputChannelManager;
+
     constructor() {
         super({
             widgetId: OUTPUT_WIDGET_KIND,
@@ -88,6 +98,11 @@ export class OutputContribution extends AbstractViewContribution<OutputWidget> {
             isVisible: () => this.outputIsActiveContext.isEnabled(),
             execute: widget => this.withWidget(widget, outputWidget => outputWidget.selectAll())
         });
+        commands.registerCommand(OutputCommands.SCROLL_LOCK, {
+            isEnabled: () => this.outputIsActiveContext.isEnabled(),
+            isVisible: () => this.outputIsActiveContext.isEnabled(),
+            execute: () => this.outputChannelManager.toggleScrollLock()
+        });
     }
 
     registerKeybindings(registry: KeybindingRegistry): void {
diff --git a/packages/output/src/browser/output-frontend-module.ts b/packages/output/src/browser/output-frontend-module.ts
index fdf9fdfb36489..b45f3cc75e7f0 100644
--- a/packages/output/src/browser/output-frontend-module.ts
+++ b/packages/output/src/browser/output-frontend-module.ts
@@ -16,7 +16,7 @@
 
 import { ContainerModule } from 'inversify';
 import { OutputWidget, OUTPUT_WIDGET_KIND } from './output-widget';
-import { WidgetFactory, bindViewContribution, KeybindingContext } from '@theia/core/lib/browser';
+import { WidgetFactory, bindViewContribution, KeybindingContext, FrontendApplicationContribution } from '@theia/core/lib/browser';
 import { OutputContribution, OutputWidgetIsActiveContext } from './output-contribution';
 import { OutputToolbarContribution } from './output-toolbar-contribution';
 import { OutputChannelManager } from '../common/output-channel';
@@ -27,6 +27,7 @@ export default new ContainerModule((bind, unbind, isBound, rebind) => {
     bindOutputPreferences(bind);
     bind(OutputWidget).toSelf();
     bind(OutputChannelManager).toSelf().inSingletonScope();
+    bind(FrontendApplicationContribution).toService(OutputChannelManager);
 
     bind(WidgetFactory).toDynamicValue(context => ({
         id: OUTPUT_WIDGET_KIND,
diff --git a/packages/output/src/browser/output-toolbar-contribution.tsx b/packages/output/src/browser/output-toolbar-contribution.tsx
index 45a2cfd8b4197..7b0ec46a532cb 100644
--- a/packages/output/src/browser/output-toolbar-contribution.tsx
+++ b/packages/output/src/browser/output-toolbar-contribution.tsx
@@ -17,8 +17,9 @@
 import { inject, injectable } from 'inversify';
 import { OutputWidget } from './output-widget';
 import { OutputChannelManager } from '../common/output-channel';
+import { DisposableCollection } from '@theia/core/lib/common/disposable';
 import { TabBarToolbarContribution, TabBarToolbarRegistry } from '@theia/core/lib/browser/shell/tab-bar-toolbar';
-import { OutputCommands } from './output-contribution';
+import { OutputCommands, OutputContribution } from './output-contribution';
 import * as React from 'react';
 
 @injectable()
@@ -27,20 +28,30 @@ export class OutputToolbarContribution implements TabBarToolbarContribution {
     @inject(OutputChannelManager)
     protected readonly outputChannelManager: OutputChannelManager;
 
+    @inject(OutputContribution)
+    protected readonly outputContribution: OutputContribution;
+
     async registerToolbarItems(toolbarRegistry: TabBarToolbarRegistry): Promise<void> {
         toolbarRegistry.registerItem({
             id: 'channels',
             render: () => this.renderChannelSelector(),
-            isVisible: widget => (widget instanceof OutputWidget),
+            isVisible: widget => widget instanceof OutputWidget,
             onDidChange: this.outputChannelManager.onListOrSelectionChange
         });
-
         toolbarRegistry.registerItem({
             id: OutputCommands.CLEAR_OUTPUT_TOOLBAR.id,
             command: OutputCommands.CLEAR_OUTPUT_TOOLBAR.id,
             tooltip: 'Clear Output',
             priority: 1,
         });
+        toolbarRegistry.registerItem({
+            id: OutputCommands.SCROLL_LOCK.id,
+            render: () => <ScrollLockToolbarItem
+                key={OutputCommands.SCROLL_LOCK.id}
+                outputChannelManager={this.outputChannelManager} />,
+            isVisible: widget => widget instanceof OutputWidget,
+            priority: 2
+        });
     }
 
     protected readonly NONE = '<no channels>';
@@ -55,8 +66,8 @@ export class OutputToolbarContribution implements TabBarToolbarContribution {
         }
         return <select
             className='theia-select'
-            id={OutputWidget.IDs.CHANNEL_LIST}
-            key={OutputWidget.IDs.CHANNEL_LIST}
+            id='outputChannelList'
+            key='outputChannelList'
             value={this.outputChannelManager.selectedChannel ? this.outputChannelManager.selectedChannel.name : this.NONE}
             onChange={this.changeChannel}
         >
@@ -71,3 +82,74 @@ export class OutputToolbarContribution implements TabBarToolbarContribution {
         }
     };
 }
+
+export namespace ScrollLockToolbarItem {
+    export interface Props {
+        readonly outputChannelManager: OutputChannelManager;
+    }
+    export interface State {
+        readonly lockedChannels: Array<string>;
+    }
+}
+class ScrollLockToolbarItem extends React.Component<ScrollLockToolbarItem.Props, ScrollLockToolbarItem.State> {
+
+    protected readonly toDispose = new DisposableCollection();
+
+    constructor(props: Readonly<ScrollLockToolbarItem.Props>) {
+        super(props);
+        const lockedChannels = this.manager.getChannels().filter(({ isLocked }) => isLocked).map(({ name }) => name);
+        this.state = { lockedChannels };
+    }
+
+    componentDidMount(): void {
+        this.toDispose.pushAll([
+            // Update when the selected channel changes.
+            this.manager.onSelectedChannelChange(() => this.setState({ lockedChannels: this.state.lockedChannels })),
+            // Update when the selected channel's scroll-lock state changes.
+            this.manager.onLockChange(({ name, isLocked }) => {
+                const lockedChannels = this.state.lockedChannels.slice();
+                if (isLocked) {
+                    lockedChannels.push(name);
+                } else {
+                    const index = lockedChannels.indexOf(name);
+                    if (index === -1) {
+                        console.warn(`Could not unlock channel '${name}'. It was not locked.`);
+                    } else {
+                        lockedChannels.splice(index, 1);
+                    }
+                }
+                this.setState({ lockedChannels });
+            }),
+        ]);
+    }
+
+    componentWillUnmount(): void {
+        this.toDispose.dispose();
+    }
+
+    render(): React.ReactNode {
+        const { selectedChannel } = this.manager;
+        if (!selectedChannel) {
+            return undefined;
+        }
+        return <div
+            key='output:toggleScrollLock'
+            className={`fa fa-${selectedChannel.isLocked ? 'lock' : 'unlock-alt'} item enabled`}
+            title={`Turn Auto Scrolling ${selectedChannel.isLocked ? 'On' : 'Off'}`}
+            onClick={this.toggleScrollLock} />;
+    }
+
+    protected readonly toggleScrollLock = (e: React.MouseEvent<HTMLElement>) => this.doToggleScrollLock(e);
+    protected doToggleScrollLock(e: React.MouseEvent<HTMLElement>): void {
+        const { selectedChannel } = this.manager;
+        if (selectedChannel) {
+            selectedChannel.toggleLocked();
+            e.stopPropagation();
+        }
+    }
+
+    private get manager(): OutputChannelManager {
+        return this.props.outputChannelManager;
+    }
+
+}
diff --git a/packages/output/src/browser/output-widget.tsx b/packages/output/src/browser/output-widget.tsx
index 72fcf8000f4e0..c366a6e801475 100644
--- a/packages/output/src/browser/output-widget.tsx
+++ b/packages/output/src/browser/output-widget.tsx
@@ -14,142 +14,232 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { inject, injectable, postConstruct } from 'inversify';
-import { Message } from '@theia/core/lib/browser';
-import { OutputChannel, OutputChannelManager, OutputChannelSeverity } from '../common/output-channel';
-import { ReactWidget } from '@theia/core/lib/browser/widgets/react-widget';
-import * as React from 'react';
-
 import '../../src/browser/style/output.css';
-
-export const OUTPUT_WIDGET_KIND = 'outputView';
+import * as React from 'react';
+import { inject, injectable, postConstruct } from 'inversify';
+import { toArray } from '@phosphor/algorithm';
+import { IDragEvent } from '@phosphor/dragdrop';
+import { Message, BaseWidget, ReactWidget, Widget, MessageLoop, DockPanel } from '@theia/core/lib/browser';
+import { Disposable, DisposableCollection } from '@theia/core/lib/common/disposable';
+import { OutputChannelManager, OutputChannel } from '../common/output-channel';
 
 @injectable()
-export class OutputWidget extends ReactWidget {
+export class OutputWidget extends BaseWidget {
+
+    static readonly ID = 'outputView';
 
     @inject(OutputChannelManager)
     protected readonly outputChannelManager: OutputChannelManager;
 
+    protected readonly channelsContainer: DockPanel;
+
     constructor() {
         super();
-        this.id = OUTPUT_WIDGET_KIND;
+        this.id = OutputWidget.ID;
         this.title.label = 'Output';
         this.title.caption = 'Output';
-        this.title.iconClass = 'fa output-tab-icon';
+        this.title.iconClass = 'fa fa-flag';
         this.title.closable = true;
         this.addClass('theia-output');
         this.node.tabIndex = 0;
+        this.channelsContainer = new NoopDragOverDockPanel({ spacing: 0, mode: 'single-document' });
+        this.channelsContainer.addClass('channels-container');
+        this.channelsContainer.node.tabIndex = -1;
     }
 
     @postConstruct()
     protected init(): void {
-        this.outputChannelManager.getChannels().forEach(this.registerListener.bind(this));
-        this.toDispose.push(this.outputChannelManager.onChannelAdded(channel => {
-            this.registerListener(channel);
-            this.update();
-        }));
-        this.toDispose.push(this.outputChannelManager.onSelectedChannelChange(event => {
-            this.update();
-        }));
-        this.update();
+        for (const channel of this.outputChannelManager.getChannels()) {
+            this.addChannel(channel);
+        }
+        this.toDispose.pushAll([
+            this.outputChannelManager.onChannelAdded(this.addChannel.bind(this)),
+            this.outputChannelManager.onChannelDelete(this.removeChannel.bind(this)),
+            this.outputChannelManager.onSelectedChannelChange(() => {
+                if (this.selectedChannelWidget) {
+                    this.channelsContainer.selectWidget(this.selectedChannelWidget);
+                }
+            })
+        ]);
+    }
+
+    protected onAfterAttach(message: Message): void {
+        super.onAfterAttach(message);
+        Widget.attach(this.channelsContainer, this.node);
+        this.toDisposeOnDetach.push(Disposable.create(() => Widget.detach(this.channelsContainer)));
     }
 
-    protected onActivateRequest(msg: Message): void {
-        super.onActivateRequest(msg);
-        const channelSelector = document.getElementById(OutputWidget.IDs.CHANNEL_LIST);
-        if (channelSelector) {
-            channelSelector.focus();
+    protected onActivateRequest(message: Message): void {
+        super.onActivateRequest(message);
+        if (this.selectedChannelWidget) {
+            MessageLoop.sendMessage(this.selectedChannelWidget, Widget.Msg.ActivateRequest);
         } else {
             this.node.focus();
         }
     }
 
-    protected registerListener(outputChannel: OutputChannel): void {
-        this.toDispose.push(outputChannel.onContentChange(c => {
-            if (outputChannel === this.outputChannelManager.selectedChannel) {
-                this.update();
-            }
-        }));
+    protected onResize(message: Widget.ResizeMessage): void {
+        super.onResize(message);
+        MessageLoop.sendMessage(this.channelsContainer, Widget.ResizeMessage.UnknownSize);
+        for (const widget of toArray(this.channelsContainer.widgets())) {
+            MessageLoop.sendMessage(widget, Widget.ResizeMessage.UnknownSize);
+        }
     }
 
-    protected render(): React.ReactNode {
-        return <React.Fragment>
-            {this.renderChannelContents()}
-        </React.Fragment>;
+    protected addChannel(channel: OutputChannel): void {
+        this.channelsContainer.addWidget(new OutputChannelWidget({ channel }));
+        this.update();
+    }
+
+    protected removeChannel({ channelName: name }: { channelName: string }): void {
+        const widget = this.getChannelWidget(name);
+        if (!widget) {
+            console.warn(`Nothing to do. Could not find widget for output channel '${name}.'`);
+        } else {
+            widget.close();
+        }
+        this.update();
     }
 
     clear(): void {
-        if (this.outputChannelManager.selectedChannel) {
-            this.outputChannelManager.selectedChannel.clear();
+        if (this.selectedChannel) {
+            this.selectedChannel.clear();
         }
     }
 
     selectAll(): void {
-        if (this.outputChannelManager.selectedChannel) {
-            const element = document.getElementById(OutputWidget.IDs.CONTENTS);
+        if (this.selectedChannelWidget) {
+            const element = this.selectedChannelWidget.node;
             if (element) {
-                const selectElementContent = (htmlElement: HTMLElement) => {
-                    const selection = window.getSelection();
-                    const range = document.createRange();
-                    if (selection && range) {
-                        range.selectNodeContents(htmlElement);
-                        selection.removeAllRanges();
-                        selection.addRange(range);
-                    }
-                };
                 element.focus();
-                selectElementContent(element);
+                const selection = window.getSelection();
+                if (selection) {
+                    const range = document.createRange();
+                    range.selectNodeContents(element);
+                    selection.removeAllRanges();
+                    selection.addRange(range);
+                }
             }
         }
     }
 
-    protected renderChannelContents(): React.ReactNode {
-        return <div id={OutputWidget.IDs.CONTENTS}>{this.renderLines()}</div>;
+    private get selectedChannel(): OutputChannel | undefined {
+        return this.outputChannelManager.selectedChannel;
     }
 
-    protected renderLines(): React.ReactNode[] {
-        let id = 0;
-        const result = [];
+    private getChannelWidget(name: string): Widget | undefined {
+        return toArray(this.channelsContainer.widgets()).find(widget => widget instanceof OutputChannelWidget && widget.channel.name === name);
+    }
 
-        const style: React.CSSProperties = {
-            whiteSpace: 'pre',
-            fontFamily: 'monospace',
+    private get selectedChannelWidget(): Widget | undefined {
+        if (this.selectedChannel) {
+            const { name } = this.selectedChannel;
+            return this.getChannelWidget(name);
+        }
+        return undefined;
+    }
+
+}
+
+/**
+ * Customized `DockPanel` that does not allow dropping widgets into it.
+ * Intercepts `'p-dragover'` events, and sets the desired drop action to `'none'`.
+ */
+class NoopDragOverDockPanel extends DockPanel {
+
+    constructor(options?: DockPanel.IOptions) {
+        super(options);
+        NoopDragOverDockPanel.prototype['_evtDragOver'] = (event: IDragEvent) => {
+            event.preventDefault();
+            event.stopPropagation();
+            event.dropAction = 'none';
         };
+    }
+}
 
-        if (this.outputChannelManager.selectedChannel) {
-            for (const outputChannelLine of this.outputChannelManager.selectedChannel.getLines()) {
-                const lines = outputChannelLine.text.split(/[\n\r]+/);
-                let className;
-                if (outputChannelLine.severity === OutputChannelSeverity.Error) {
-                    className = 'theia-output-error';
-                } else if (outputChannelLine.severity === OutputChannelSeverity.Warning) {
-                    className = 'theia-output-warning';
-                }
-                for (const line of lines) {
-                    result.push(<div style={style} className={className} key={id++}>{line}</div>);
+class OutputChannelWidget extends ReactWidget {
+
+    /**
+     * For the `focus`; do not touch it. Use React instead.
+     */
+    protected anchor?: HTMLElement;
+
+    constructor(protected readonly options: Widget.IOptions & { channel: OutputChannel }) {
+        super(options);
+        this.id = `output-channel-widget--${this.channel.name}`;
+        this.node.tabIndex = 0;
+        this.addClass('output-channel-widget');
+        this.toDispose.push(new DisposableCollection(
+            this.channel.onContentChange(() => this.update())
+        ));
+    }
+
+    protected onAfterAttach(message: Message): void {
+        super.onAfterAttach(message);
+        this.update();
+    }
+
+    protected onResize(message: Widget.ResizeMessage): void {
+        super.onResize(message);
+        this.update();
+    }
+
+    protected onUpdateRequest(message: Message): void {
+        super.onUpdateRequest(message);
+        if (!this.channel.isLocked) {
+            setTimeout(() => {
+                if (this.anchor) {
+                    this.anchor.scrollIntoView(false);
                 }
-            }
+            }, 1);
         }
-        if (result.length === 0) {
-            result.push(<div style={style} key={id++}>{'<no output yet>'}</div>);
+    }
+
+    protected onActivateRequest(message: Message): void {
+        super.onActivateRequest(message);
+        if (!this.channel.isLocked && this.anchor) {
+            this.anchor.focus();
+        } else {
+            this.node.focus();
         }
-        return result;
     }
 
-    protected onUpdateRequest(msg: Message): void {
-        super.onUpdateRequest(msg);
-        setTimeout(() => {
-            const div = document.getElementById(OutputWidget.IDs.CONTENTS) as HTMLDivElement;
-            if (div && div.children.length > 0) {
-                div.children[div.children.length - 1].scrollIntoView(false);
+    protected render(): React.ReactNode {
+        const lines = [];
+        let id = 0;
+        const style: React.CSSProperties = {
+            whiteSpace: 'pre',
+            fontFamily: 'monospace',
+        };
+        const name = this.channel.name;
+        for (const text of this.channel.getLines()) {
+            for (const content of text.split(/[\n\r]+/) || []) {
+                lines.push(<div style={style} key={`${name}-${id++}`}>{content}</div>);
             }
-        });
+        }
+        if (lines.length === 0) {
+            lines.push(<div style={style} key={`${name}-${id++}`}>{'<no output yet>'}</div>);
+        }
+        const anchor = <div ref={this.setAnchor} tabIndex={0} />;
+        return <div>
+            {lines}
+            {anchor}
+        </div>;
     }
-}
 
-export namespace OutputWidget {
-    export namespace IDs {
-        export const CONTENTS = 'outputContents';
-        export const CHANNEL_LIST = 'outputChannelList';
+    get channel(): OutputChannel {
+        return this.options.channel;
     }
+
+    private setAnchor = (element: HTMLElement | null) => {
+        if (element) {
+            this.anchor = element;
+        }
+    };
+
 }
+
+/**
+ * @deprecated Use `OutputWidget.ID` instead.
+ */
+export const OUTPUT_WIDGET_KIND = OutputWidget.ID;
diff --git a/packages/output/src/browser/style/output.css b/packages/output/src/browser/style/output.css
index 0561490972001..0f2c0a71faa92 100644
--- a/packages/output/src/browser/style/output.css
+++ b/packages/output/src/browser/style/output.css
@@ -14,54 +14,17 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
- #outputView {
-	font-size: var(--theia-ui-font-size1);
-}
-
-#outputView #outputContents {
-    overflow: auto;
-    height: inherit;
-    padding: 6px;
-    box-sizing: border-box;
-}
-
-.theia-side-panel #outputView #outputContents {
-    margin-left: 14px;
-}
-
-#outputView #outputChannelList {
-    line-height: var(--theia-content-line-height);
+#outputView {
     font-size: var(--theia-ui-font-size1);
-    
-    -webkit-appearance: none;
-    -moz-appearance: none;
-    background-position: calc(100% - 6px) 8px, calc(100% - 2px) 8px, 100% 0;
-    background-size: 4px 5px;
-    background-repeat: no-repeat;
-    padding-left: 3px;
-    padding-right: 15px;
-}
-
-#outputView #outputClear {
-    background-image: var(--theia-icon-clear);
-    background-position: center;
-    background-repeat: no-repeat;
-    display: inline-block;
-    width: 21px;
-    opacity: var(--theia-mod-disabled-opacity);;
 }
 
-#outputView #outputClear.enabled {
-    opacity: 0.7;
-    cursor: pointer;
+#outputView .channels-container {
+    height: 100%;
+    width: 100%;
 }
 
-#outputView #outputClear.enabled:hover {
-    opacity: 1;
-}
-
-.output-tab-icon::before {
-    content: "\f024"
+#outputView .channels-container .output-channel-widget {
+    padding: 6px;
 }
 
 .theia-output-error {
diff --git a/packages/output/src/common/output-channel.ts b/packages/output/src/common/output-channel.ts
index 9d27021aef143..7131e6cdae6ba 100644
--- a/packages/output/src/common/output-channel.ts
+++ b/packages/output/src/common/output-channel.ts
@@ -14,13 +14,14 @@
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  ********************************************************************************/
 
-import { Emitter, Event } from '@theia/core';
 import { injectable, inject, postConstruct } from 'inversify';
+import { Emitter, Event, Disposable, DisposableCollection } from '@theia/core';
+import { StorageService, FrontendApplicationContribution } from '@theia/core/lib/browser';
+import { Deferred } from '@theia/core/lib/common/promise-util';
 import { OutputPreferences } from './output-preferences';
-import { Disposable, DisposableCollection } from 'vscode-ws-jsonrpc';
 
 @injectable()
-export class OutputChannelManager implements Disposable {
+export class OutputChannelManager implements FrontendApplicationContribution, Disposable {
     protected readonly channels = new Map<string, OutputChannel>();
     protected selectedChannelValue: OutputChannel | undefined;
 
@@ -28,18 +29,51 @@ export class OutputChannelManager implements Disposable {
     protected readonly channelAddedEmitter = new Emitter<OutputChannel>();
     protected readonly selectedChannelEmitter: Emitter<void> = new Emitter<void>();
     protected readonly listOrSelectionEmitter: Emitter<void> = new Emitter<void>();
+    protected readonly channelLockedEmitter = new Emitter<OutputChannel>();
     readonly onChannelDelete = this.channelDeleteEmitter.event;
     readonly onChannelAdded = this.channelAddedEmitter.event;
     readonly onSelectedChannelChange = this.selectedChannelEmitter.event;
     readonly onListOrSelectionChange = this.listOrSelectionEmitter.event;
+    readonly onLockChange = this.channelLockedEmitter.event;
 
     protected toDispose = new DisposableCollection();
+    protected toDisposeOnChannelDeletion = new Map<string, DisposableCollection>();
+    protected lockedChannels = new Set<string>();
+    protected restoredState = new Deferred<void>();
 
     @inject(OutputPreferences)
     protected readonly preferences: OutputPreferences;
 
+    @inject(StorageService)
+    protected readonly storageService: StorageService;
+
+    onStart(): void {
+        this.storageService.getData<Array<string>>('theia:output-channel-manager:lockedChannels')
+            .then(lockedChannels => {
+                if (Array.isArray(lockedChannels)) {
+                    for (const channelName of lockedChannels) {
+                        this.lockedChannels.add(channelName);
+                    }
+                }
+                this.restoredState.resolve();
+            });
+    }
+
+    onStop(): void {
+        const lockedChannels = Array.from(this.channels.values()).filter(({ isLocked }) => isLocked).map(({ name }) => name);
+        this.storageService.setData('theia:output-channel-manager:lockedChannels', lockedChannels);
+    }
+
     @postConstruct()
-    protected init(): void {
+    protected async init(): Promise<void> {
+        await this.restoredState.promise;
+        this.toDispose.pushAll([
+            this.channelDeleteEmitter,
+            this.channelAddedEmitter,
+            this.selectedChannelEmitter,
+            this.listOrSelectionEmitter,
+            this.channelLockedEmitter
+        ]);
         this.getChannels().forEach(this.registerListener.bind(this));
         this.toDispose.push(this.onChannelAdded(channel => {
             this.listOrSelectionEmitter.fire(undefined);
@@ -54,16 +88,29 @@ export class OutputChannelManager implements Disposable {
     }
 
     protected registerListener(outputChannel: OutputChannel): void {
+        const { name } = outputChannel;
         if (!this.selectedChannel) {
             this.selectedChannel = outputChannel;
         }
-        this.toDispose.push(outputChannel.onVisibilityChange(event => {
+        let toDispose = this.toDisposeOnChannelDeletion.get(name);
+        if (!toDispose) {
+            toDispose = new DisposableCollection();
+            this.toDisposeOnChannelDeletion.set(name, toDispose);
+        }
+        toDispose.push(outputChannel);
+        toDispose.push(outputChannel.onVisibilityChange(event => {
             if (event.visible) {
                 this.selectedChannel = outputChannel;
             } else if (outputChannel === this.selectedChannel) {
                 this.selectedChannel = this.getVisibleChannels()[0];
             }
         }));
+        toDispose.push(outputChannel.onLockChange(() => this.channelLockedEmitter.fire(outputChannel)));
+        if (this.lockedChannels.has(name)) {
+            if (!outputChannel.isLocked) {
+                outputChannel.toggleLocked();
+            }
+        }
     }
 
     getChannel(name: string): OutputChannel {
@@ -78,7 +125,16 @@ export class OutputChannelManager implements Disposable {
     }
 
     deleteChannel(name: string): void {
+        const existing = this.channels.get(name);
+        if (!existing) {
+            console.warn(`Could not delete channel '${name}'. The channel does not exist.`);
+            return;
+        }
         this.channels.delete(name);
+        const toDispose = this.toDisposeOnChannelDeletion.get(name);
+        if (toDispose) {
+            toDispose.dispose();
+        }
         this.channelDeleteEmitter.fire({ channelName: name });
     }
 
@@ -90,7 +146,7 @@ export class OutputChannelManager implements Disposable {
         return this.getChannels().filter(channel => channel.isVisible);
     }
 
-    public dispose(): void {
+    dispose(): void {
         this.toDispose.dispose();
     }
 
@@ -103,30 +159,35 @@ export class OutputChannelManager implements Disposable {
         this.selectedChannelEmitter.fire(undefined);
         this.listOrSelectionEmitter.fire(undefined);
     }
-}
 
-export enum OutputChannelSeverity {
-    Error = 1,
-    Warning = 2,
-    Info = 3
-}
-export interface OutputChannelLine {
-    text: string;
-    severity?: OutputChannelSeverity;
+    toggleScrollLock(channel: OutputChannel | undefined = this.selectedChannel): void {
+        if (channel) {
+            channel.toggleLocked();
+        }
+    }
 }
 
-export class OutputChannel {
+export class OutputChannel implements Disposable {
 
     private readonly visibilityChangeEmitter = new Emitter<{ visible: boolean }>();
+    private readonly lockChangeEmitter = new Emitter<{ locked: boolean }>();
     private readonly contentChangeEmitter = new Emitter<OutputChannel>();
-    private lines: OutputChannelLine[] = [];
-    private currentLine: OutputChannelLine | undefined;
+    private readonly toDispose = new DisposableCollection(
+        this.visibilityChangeEmitter,
+        this.lockChangeEmitter,
+        this.contentChangeEmitter
+    );
+
+    private lines: string[] = [];
+    private currentLine: string | undefined;
     private visible: boolean = true;
+    private locked: boolean = false;
 
     readonly onVisibilityChange: Event<{ visible: boolean }> = this.visibilityChangeEmitter.event;
+    readonly onLockChange: Event<{ locked: boolean }> = this.lockChangeEmitter.event;
     readonly onContentChange: Event<OutputChannel> = this.contentChangeEmitter.event;
 
-    constructor(readonly name: string, readonly preferences: OutputPreferences) { }
+    constructor(readonly name: string, protected readonly preferences: OutputPreferences) { }
 
     append(value: string): void {
         if (this.currentLine === undefined) {
@@ -174,4 +235,18 @@ export class OutputChannel {
     get isVisible(): boolean {
         return this.visible;
     }
+
+    toggleLocked(): void {
+        this.locked = !this.locked;
+        this.lockChangeEmitter.fire({ locked: this.isLocked });
+    }
+
+    get isLocked(): boolean {
+        return this.locked;
+    }
+
+    dispose(): void {
+        this.toDispose.dispose();
+    }
+
 }