diff --git a/src/jupyter_contrib_nbextensions/nbextensions/runtools/annotations.odg b/src/jupyter_contrib_nbextensions/nbextensions/runtools/annotations.odg
new file mode 100644
index 000000000..ffa9b9b58
Binary files /dev/null and b/src/jupyter_contrib_nbextensions/nbextensions/runtools/annotations.odg differ
diff --git a/src/jupyter_contrib_nbextensions/nbextensions/runtools/cellstate.js b/src/jupyter_contrib_nbextensions/nbextensions/runtools/cellstate.js
new file mode 100644
index 000000000..71a17c373
--- /dev/null
+++ b/src/jupyter_contrib_nbextensions/nbextensions/runtools/cellstate.js
@@ -0,0 +1,20 @@
+
+
+  CodeMirror.defineOption("cellstate", false, function(cm, val, old) {
+    if (old && old != CodeMirror.Init) {
+      cm.clearGutter(cm.state.cellState.options.gutter);
+      cm.state.cellState = null;
+      cm.off("gutterClick", onGutterClick);
+      cm.off("change", onChange);
+      cm.off("viewportChange", onViewportChange);
+      cm.off("swapDoc", onChange);
+    }
+    if (val) {
+      cm.state.cellState = new State(parseOptions(val));
+      updateInViewport(cm);
+      cm.on("gutterClick", onGutterClick);
+      cm.on("change", onChange);
+      cm.on("viewportChange", onViewportChange);
+      cm.on("swapDoc", onChange);
+    }
+  });
diff --git a/src/jupyter_contrib_nbextensions/nbextensions/runtools/demo.gif b/src/jupyter_contrib_nbextensions/nbextensions/runtools/demo.gif
new file mode 100644
index 000000000..d906670d9
Binary files /dev/null and b/src/jupyter_contrib_nbextensions/nbextensions/runtools/demo.gif differ
diff --git a/src/jupyter_contrib_nbextensions/nbextensions/runtools/gutter.css b/src/jupyter_contrib_nbextensions/nbextensions/runtools/gutter.css
index e0eee3265..cebc4a998 100644
--- a/src/jupyter_contrib_nbextensions/nbextensions/runtools/gutter.css
+++ b/src/jupyter_contrib_nbextensions/nbextensions/runtools/gutter.css
@@ -1,5 +1,3 @@
-.CodeMirror-foldgutter {
-  width: .9em;
+.CodeMirror-cellstate {
+  width: 0.5em;
 }
-
-
diff --git a/src/jupyter_contrib_nbextensions/nbextensions/runtools/icon.png b/src/jupyter_contrib_nbextensions/nbextensions/runtools/icon.png
index dfe59fea3..1c4434056 100644
Binary files a/src/jupyter_contrib_nbextensions/nbextensions/runtools/icon.png and b/src/jupyter_contrib_nbextensions/nbextensions/runtools/icon.png differ
diff --git a/src/jupyter_contrib_nbextensions/nbextensions/runtools/main.js b/src/jupyter_contrib_nbextensions/nbextensions/runtools/main.js
index 37b78bf60..c021ee546 100644
--- a/src/jupyter_contrib_nbextensions/nbextensions/runtools/main.js
+++ b/src/jupyter_contrib_nbextensions/nbextensions/runtools/main.js
@@ -1,15 +1,178 @@
-// Add toolbar buttons for extended code execution commands
-
+// Extended code execution commands and more
 
 define([
     'base/js/namespace',
     'jquery',
     'require',
     'base/js/events',
-    'codemirror/lib/codemirror'
-],   function(IPython, $, require, events, codemirror) {
+    'services/config',
+    'base/js/utils',
+    'notebook/js/codecell'
+], function(Jupyter, $, require, events, configmod, utils, codecell) {
     "use strict";
 
+    var base_url = utils.get_body_data("baseUrl");
+    var config = new configmod.ConfigSection('notebook', {
+        base_url: base_url
+    });
+    var run_list = []; /* list of cells to be run */
+
+    // define default config parameter values
+    var params = {
+        run_cells_above: 'Alt-a',
+        run_cells_below: 'Alt-b',
+        toggle_marker: 'Alt-t',
+        mark_all_codecells: 'Alt-m',
+        unmark_all_codecells: 'Alt-u',
+        run_marked_cells: 'Alt-r',
+        run_all_cells: 'Alt-x',
+        run_all_cells_ignore_errors: 'Alt-f',
+        stop_execution: 'Ctrl-c',
+        marked_color: '#20f224',
+        scheduled_color: '#00def0',
+        run_color: '#f30a2d'
+    };
+
+    // updates default params with any specified in the provided config data
+    var update_params = function(config_data) {
+        for (var key in params) {
+            if (config_data.hasOwnProperty(key)) {
+                params[key] = config_data[key];
+            }
+        }
+    };
+
+    /**
+     * Add event if user clicks on codemirror gutter
+     *
+     */
+    function add_gutter_events() {
+        var ncells = Jupyter.notebook.ncells();
+        var cells = Jupyter.notebook.get_cells();
+        for (var i = 0; i < ncells; i++) {
+            var cell = cells[i];
+            if ((cell.cell_type === "code")) {
+                cell.code_mirror.on("gutterClick", changeEvent);
+
+                if (cell.metadata.run_control !== undefined) {
+                    if (cell.metadata.run_control.marked === true) {
+                        var g = cell.code_mirror.getGutterElement();
+                        $(g).css({
+                            "background-color": params.marked_color
+                        });
+                    }
+                }
+            }
+        }
+    }
+
+    /*
+     * Initialize toolbar and gutter after config was loaded
+     */
+    function initialize() {
+        if (Jupyter.notebook.config.data.hasOwnProperty('runtools')) {
+            update_params(Jupyter.notebook.config.data.runtools)
+        }
+
+        add_gutter_events();
+
+        /* Add run control buttons to toolbar */
+        Jupyter.toolbar.add_buttons_group([
+            Jupyter.actions.register ({
+                help: 'Toggle Runtools Toolbar',
+                icon: 'fa-cogs',
+                handler: toggle_toolbar
+            }, 'toggle_runtools')
+        ]);
+        $("#toggle_runtools").css({
+            'outline': 'none'
+        });
+
+        /* Add keyboard shortcuts */
+        var add_command_shortcuts = {};
+        add_command_shortcuts[params["run_cells_above"]] = {
+            help: 'Run cells above',
+            help_index: 'xa',
+            handler: function() {
+                var mode = Jupyter.notebook.get_selected_cell().mode;
+                Jupyter.notebook.execute_cells_above();
+                Jupyter.notebook.select_next();
+                var type = Jupyter.notebook.get_selected_cell().cell_type;
+                if (mode === "edit" && type === "code") Jupyter.notebook.edit_mode();
+                return false;
+            }
+        };
+        add_command_shortcuts[params["run_cells_below"]] = {
+            help: 'Run cells below',
+            help_index: 'aa',
+            handler: function() {
+                var mode = Jupyter.notebook.get_selected_cell().mode;
+                Jupyter.notebook.execute_cells_below();
+                var type = Jupyter.notebook.get_selected_cell().cell_type;
+                if (mode === "edit" && type === "code") Jupyter.notebook.edit_mode();
+                return false;
+            }
+        };
+        add_command_shortcuts[params["toggle_marker"]] = {
+            help: 'Toggle marker',
+            help_index: 'mt',
+            handler: function() {
+                toggle_marker();
+                return false;
+            }
+        };
+        add_command_shortcuts[params["mark_all_codecells"]] = {
+            help: 'Mark all codecells',
+            help_index: 'ma',
+            handler: function() {
+                mark_all();
+                return false;
+            }
+        };
+        add_command_shortcuts[params["unmark_all_codecells"]] = {
+            help: 'Unmark all codecells',
+            help_index: 'mu',
+            handler: function() {
+                mark_none();
+                return false;
+            }
+        };
+        add_command_shortcuts[params["run_marked_cells"]] = {
+            help: 'Run marked cells',
+            help_index: 'rm',
+            handler: function() {
+                run_marked_cells();
+                return false;
+            }
+        };
+        add_command_shortcuts[params["run_all_cells"]] = {
+            help: 'Run all cells',
+            help_index: 'ra',
+            handler: function() {
+                var pos = Jupyter.notebook.element.scrollTop();
+                var ic = Jupyter.notebook.get_selected_index();
+                Jupyter.notebook.execute_all_cells();
+                Jupyter.notebook.select(ic);
+                Jupyter.notebook.element.animate({
+                    scrollTop: pos
+                }, 100);
+                return false;
+            }
+        };
+        add_command_shortcuts[params["run_all_cells_ignore_errors"]] = {
+            help: 'Run all cells - ignore errors',
+            help_index: 'rf',
+            handler: function() {
+                run_all_cells_ignore_errors();
+                return false;
+            }
+        };
+        Jupyter.keyboard_manager.command_shortcuts.add_shortcuts(add_command_shortcuts);
+        Jupyter.keyboard_manager.edit_shortcuts.add_shortcuts(add_command_shortcuts);
+
+        events.on('finished_execute.CodeCell', finished_execute_event);
+    }
+
     /**
      * Hide or show a cell
      *
@@ -17,9 +180,9 @@ define([
      * @param io 'i' for cell input, 'o' for cell output
      * @param showme {Boolean} show (true) or hide (false) cell
      */
-     function showCell(cell, io, showme) {
-        if ( io == 'i') {
-            if ( showme == true) {
+    function showCell(cell, io, showme) {
+        if (io === 'i') {
+            if (showme === true) {
                 cell.element.find("div.input").show();
                 cell.metadata.hide_input = false;
             } else {
@@ -27,7 +190,7 @@ define([
                 cell.metadata.hide_input = true;
             }
         } else {
-            if ( showme == true) {
+            if (showme === true) {
                 cell.element.find('div.output').show();
                 cell.metadata.hide_output = false;
             } else {
@@ -40,14 +203,14 @@ define([
     /**
      * Hide or show input of all marked code cells
      *
-     * @param {Boolean} show show (true) or hide (false)
+     * @param show {Boolean} show (true) or hide (false) code cells
      */
     function show_input(show) {
-        var ncells = IPython.notebook.ncells();
-        var cells = IPython.notebook.get_cells();
-        for (var i=0; i<ncells; i++) { 
-            var _cell=cells[i];
-            if (_cell.metadata.run_control !== undefined && _cell.metadata.run_control.marked === true )
+        var ncells = Jupyter.notebook.ncells();
+        var cells = Jupyter.notebook.get_cells();
+        for (var i = 0; i < ncells; i++) {
+            var _cell = cells[i];
+            if (_cell.metadata.run_control !== undefined && _cell.metadata.run_control.marked === true)
                 showCell(_cell, 'i', show);
         }
     }
@@ -58,90 +221,160 @@ define([
      * @param {Boolean} show show (true) or hide (false)
      */
     function show_output(show) {
-        var ncells = IPython.notebook.ncells();
-        var cells = IPython.notebook.get_cells();
-        for (var i=0; i<ncells; i++) { 
-            var _cell=cells[i];
-            if (_cell.metadata.run_control != undefined && _cell.metadata.run_control.marked == true )
+        var ncells = Jupyter.notebook.ncells();
+        var cells = Jupyter.notebook.get_cells();
+        for (var i = 0; i < ncells; i++) {
+            var _cell = cells[i];
+            if (_cell.metadata.run_control !== undefined && _cell.metadata.run_control.marked === true)
                 showCell(_cell, 'o', show);
-        } 
+        }
+    }
+
+
+    /**
+     * Execute next cell in run list, if it is still marked
+     *
+     */
+    function execute_next_marked_cell() {
+        while (run_list.length > 0) {
+            var runcell = run_list.shift();
+            var end = IPython.notebook.ncells();
+            for (var i = 0; i < end; i++) {
+                if (runcell === IPython.notebook.get_cell(i)) {
+                    if (runcell.metadata.run_control !== undefined && runcell.metadata.run_control.marked === true) {
+                        IPython.notebook.select(i);
+                        var g = runcell.code_mirror.getGutterElement();
+                        $(g).css({
+                            "background-color": params.run_color
+                        });
+                        IPython.notebook.execute_cell();
+                        return;
+                    }
+                }
+            }
+        }
     }
 
     /**
      * Run code cells marked in metadata
-     * 
+     *
      */
-    function run_marked() {
-        var current = IPython.notebook.get_selected_index();
+    function run_marked_cells() {
         var end = IPython.notebook.ncells();
-        for (var i=0; i<end; i++) { 
+        run_list = [];
+        /* Mark all selected cells as scheduled to be run with new gutter background color  */
+        for (var i = 0; i < end; i++) {
             IPython.notebook.select(i);
             var cell = IPython.notebook.get_selected_cell();
-            if ((cell instanceof IPython.CodeCell)) { 
-                if (cell.metadata.run_control != undefined) {
-                    if (cell.metadata.run_control.marked == true ) {
-                        IPython.notebook.execute_cell();
-                    } 
-                } 
+            if (cell instanceof IPython.CodeCell) {
+                var last_line = cell.code_mirror.lastLine();
+                var cell_empty = ( last_line === 0 && cell.code_mirror.getLine(last_line) === "");
+                if (cell.metadata.run_control !== undefined && cell_empty === false) {
+                    if (cell.metadata.run_control.marked === true) {
+                        var g = cell.code_mirror.getGutterElement();
+                        $(g).css({
+                            "background-color": params.scheduled_color
+                        });
+                        run_list.push(cell);
+                    }
+                }
             }
         }
-        IPython.notebook.select(current);
+        execute_next_marked_cell();
     }
 
-        /**
-         *
-         * @param cell
-         * @param value
-         */
-    function setCell(cell,value) {
-        if (cell.metadata.run_control == undefined) cell.metadata.run_control = {};
-        if (cell.metadata.run_control.marked == undefined) cell.metadata.run_control.marked = false;
-        if (value == undefined) value = !cell.metadata.run_control.marked;
-        var g=cell.code_mirror.getGutterElement();
-        if (value == false) {
+    /*
+     * Execute next cell in run_list when notified execution of last cell has been finished
+     * @param evt Event
+     * @param data Cell that has finished executing
+     */
+    var finished_execute_event = function(evt, data) {
+        var cell = data.cell;
+        /* Reset gutter color no non-queued state */
+        if ((cell instanceof IPython.CodeCell)) {
+            if (cell.metadata.run_control !== undefined) {
+                if (cell.metadata.run_control.marked === true) {
+                    var g = cell.code_mirror.getGutterElement();
+                    $(g).css({
+                        "background-color": params.marked_color
+                    });
+                }
+            }
+        }
+        execute_next_marked_cell();
+    };
+
+    /**
+     *
+     * @param cell
+     * @param value
+     */
+    function setCell(cell, value) {
+        if (cell.metadata.run_control === undefined) cell.metadata.run_control = {};
+        if (cell.metadata.run_control.marked === undefined) cell.metadata.run_control.marked = false;
+        if (value === undefined) value = !cell.metadata.run_control.marked;
+        var g = cell.code_mirror.getGutterElement();
+        if (value === false) {
             cell.metadata.run_control.marked = false;
-            $(g).css({"background-color": "#f5f5f5"});
+            $(g).css({
+                "background-color": ""
+            });
         } else {
             cell.metadata.run_control.marked = true;
-            $(g).css({"background-color": "#0f0"});
+            $(g).css({
+                "background-color": params.marked_color
+            });
         }
     }
 
-        /**
-         * Toggle code cell marker
-         */
+    /**
+     * Toggle code cell marker
+     */
     function toggle_marker() {
-        var cell = IPython.notebook.get_selected_cell();
+        var cell = Jupyter.notebook.get_selected_cell();
         setCell(cell, undefined);
         cell.focus_cell();
     }
 
-        /**
-         *
-         */
+    /**
+     *
+     */
     function mark_all() {
-        var cell = IPython.notebook.get_selected_cell();
-        var ncells = IPython.notebook.ncells();
-        var cells = IPython.notebook.get_cells();
-        for (var i=0; i<ncells; i++) { 
-            var _cell=cells[i];
+        var cell = Jupyter.notebook.get_selected_cell();
+        var ncells = Jupyter.notebook.ncells();
+        var cells = Jupyter.notebook.get_cells();
+        for (var i = 0; i < ncells; i++) {
+            var _cell = cells[i];
             setCell(_cell, true);
         }
-        cell.focus_cell();        
+        cell.focus_cell();
     }
 
-        /**
-         *
-         */
+    /**
+     *
+     */
     function mark_none() {
-        var cell = IPython.notebook.get_selected_cell();
-        var ncells = IPython.notebook.ncells();
-        var cells = IPython.notebook.get_cells();
-        for (var i=0; i<ncells; i++) { 
-            var _cell=cells[i];
+        var cell = Jupyter.notebook.get_selected_cell();
+        var ncells = Jupyter.notebook.ncells();
+        var cells = Jupyter.notebook.get_cells();
+        for (var i = 0; i < ncells; i++) {
+            var _cell = cells[i];
             setCell(_cell, false);
         }
-        cell.focus_cell();        
+        cell.focus_cell();
+    }
+
+    /**
+     *
+     * @param cell notebook cell instance
+     * @param state {string} state to be display [ '', 'locked', 'executed', 'modified' ]
+     */
+    function set_cell_state(cell, state) {
+        var icon = "";
+        if (state === 'locked') {
+            icon = '<div class="fa fa-lock" style="font-size:70%;" /div>'
+        }
+        cell.code_mirror.setGutterMarker(0, "CodeMirror-cellstate", celltypeMarker(icon))
     }
 
     /**
@@ -151,55 +384,36 @@ define([
      * @param line current line
      * @param gutter not used
      */
-    function changeEvent(cm,line, gutter) {
+    function changeEvent(cm, line, gutter) {
         var cmline = cm.doc.children[0].lines[line];
-        /* clicking on gutterMarkers should not change selection */
-        if (cmline.gutterMarkers != undefined) return;
-        
-        var cell = IPython.notebook.get_selected_cell();
-        if (cell.code_mirror != cm) {
-            var ncells = IPython.notebook.ncells();
-            var cells = IPython.notebook.get_cells();
-        for (var i=0; i<ncells; i++) {
+        var cell = Jupyter.notebook.get_selected_cell();
+        if (cmline === undefined) {
+            return;
+        }
+
+        if (cell.code_mirror !== cm) {
+            var ncells = Jupyter.notebook.ncells();
+            var cells = Jupyter.notebook.get_cells();
+            for (var i = 0; i < ncells; i++) {
                 cell = cells[i];
-                if (cell.code_mirror == cm ) { break; }
+                if (cell.code_mirror === cm) {
+                    break;
+                }
             }
         }
-        if (cell.metadata.run_control == undefined)
+        if (cell.metadata.run_control === undefined)
             cell.metadata.run_control = {};
         setCell(cell, !cell.metadata.run_control.marked);
     }
 
-    /**
-     * Register newly created cell
-     *
-     * @param {Object} event
-     * @param {Object} nbcell notebook cell
-     */
-    var create_cell = function (event,nbcell) {
-        var cell = nbcell.cell;
-        if ((cell.cell_type == "code")) {
-            cell.code_mirror.on("gutterClick", changeEvent);
-            if ((cell instanceof IPython.CodeCell)) {
-                var gutters = cell.code_mirror.getOption('gutters');
-                var found = jQuery.inArray("CodeMirror-foldgutter", gutters);
-                if (found == -1) {
-                    cell.code_mirror.setOption('gutters', [gutters, "CodeMirror-foldgutter"]);
-                    cell.code_mirror.refresh();
-                }
-            }
-
-        }
-    };
-
     /**
      *
      * @param cell cell to be tested
      * @returns {boolean} true if marked
      */
     var is_marked = function(cell) {
-        if (cell.metadata.run_control != undefined) {
-            if (cell.metadata.run_control.marked == true) {
+        if (cell.metadata.run_control !== undefined) {
+            if (cell.metadata.run_control.marked === true) {
                 return true;
             }
         }
@@ -207,81 +421,47 @@ define([
     };
 
     /**
-     *  Move marked cells one up, don't have one marked cell overtake another one
-     *
-     */
-    var move_marked_up = function() {
-        var ncells = IPython.notebook.ncells();
-        for (var i=1; i<ncells; i++) {
-            var cells = IPython.notebook.get_cells();
-            if ((cells[i].cell_type == "code")) {
-                if ( is_marked(cells[i]) && !is_marked(cells[i-1]) ) {
-                        IPython.notebook.move_cell_up(i);
-                }
-            }
-        }
-    };
-
-    /*
-     * Move marked code cells one up
+     * Return div element to set in cellstate gutter
      *
+     * @param val HTML string
+     * @returns {Element} div Element
      */
-    var move_marked_down = function() {
-        var ncells = IPython.notebook.ncells();
-        for (var i=ncells-2; i>=0; i--) {
-            var cells = IPython.notebook.get_cells();
-            if ((cells[i].cell_type == "code")) {
-                if (is_marked(cells[i]) && !is_marked(cells[i + 1])) {
-                    IPython.notebook.move_cell_down(i);
-                }
-            }
-        }
-    };
-
-    function makeLockMarker() {
+    function celltypeMarker(val) {
         var marker = document.createElement("div");
         marker.style.color = "#822";
-        marker.innerHTML = '<i class="fa fa-lock" /i>';
+        marker.innerHTML = val;
         return marker;
     }
 
-
-
-    var lock_cell = function() {
-        var ncells = IPython.notebook.ncells();
-        for (var i=ncells-2; i>=0; i--) {
-            var cells = IPython.notebook.get_cells();
+    /**
+     * Lock/Unlock current code cell
+     *             if (cell.metadata.run_control != undefined && cell.metadata.run_control.read_only) {
+     *                     cell.code_mirror.setOption('readOnly', cell.metadata.run_control.read_only);
+     */
+    var lock_cell = function(locked) {
+        var ncells = Jupyter.notebook.ncells();
+        for (var i = ncells - 2; i >= 0; i--) {
+            var cells = Jupyter.notebook.get_cells();
             if ((cells[i].cell_type === "code") && is_marked(cells[i])) {
-                cells[i].code_mirror.setOption('readOnly', true);
-                cells[i].metadata.deletable = false;
-                cells[i].metadata.locked = true;
-                cells[i].code_mirror.setGutterMarker(0,"CodeMirror-foldgutter", makeLockMarker())
+                if (locked === true) {
+                    cells[i].metadata.editable = false;
+                    set_cell_state(cells[i], 'locked')
+                } else {
+                    cells[i].metadata.editable = true;
+                    set_cell_state(cells[i], '')
+                }
             }
         }
     };
 
-    var unlock_cell = function() {
-        var ncells = IPython.notebook.ncells();
-        for (var i=ncells-2; i>=0; i--) {
-            var cells = IPython.notebook.get_cells();
-            if ((cells[i].cell_type === "code" && is_marked(cells[i]))) {
-                cells[i].code_mirror.setOption('readOnly', false);
-                cells[i].metadata.deletable = true;
-                cells[i].metadata.locked = false;
-                cells[i].code_mirror.setGutterMarker(0,"CodeMirror-foldgutter", null)
-                }
-            }
-        };
-
-
     /**
      * Execute all cells and don't stop on errors
      *
      */
-    var execute_all_cells_ignore_errors = function () {
-        for (var i=0; i < IPython.notebook.ncells(); i++) {
-            IPython.notebook.select(i);
-            var cell = IPython.notebook.get_selected_cell();
+    var run_all_cells_ignore_errors = function() {
+        for (var i = 0; i < Jupyter.notebook.ncells(); i++) {
+            Jupyter.notebook.select(i);
+            var cell = Jupyter.notebook.get_selected_cell();
             cell.execute(false);
         }
     };
@@ -290,16 +470,22 @@ define([
      * Create floating toolbar
      *
      */
-    var create_runtools_div = function () {
+    var create_runtools_div = function() {
         var btn = '<div class="btn-toolbar">\
             <div class="btn-group">\
                 <button type="button" id="run_c" class="btn btn-primary fa fa-step-forward" title="Run current cell"></button>\
-                <button type="button" id="run_ca" class="btn btn-primary fa icon-run-to" title="Run from first to current cell"></button>\
-                <button type="button" id="run_cb" class="btn btn-primary fa icon-run-from" title="Run from current to last cell"></button>\
-                <button type="button" id="run_a" class="btn btn-primary fa icon-run-all" title="Run all cells"></button>\
-                <button type="button" id="run_af" class="btn btn-primary fa icon-run-all-forced" title="Run all cells ignore errors"></button>\
-                <button type="button" id="run_m" class="btn btn-primary fa icon-run-marked" title="Run marked cells"></button>\
-                <button type="button" id="interrupt_b" class="btn btn-primary fa fa-stop" title="Interrupt execution"></button>\
+                <button type="button" id="run_ca" class="btn btn-primary fa icon-run-to" title="' +
+            'Run cells above (' + params["run_cells_above"] + ')"</button>\
+                <button type="button" id="run_cb" class="btn btn-primary fa icon-run-from" title="' +
+            'Run cells below (' + params["run_cells_below"] + ')"</button>\
+                <button type="button" id="run_a" class="btn btn-primary fa icon-run-all" title="' +
+            'Run all cells (' + params["run_all_cells"] + ')"</button>\
+                <button type="button" id="run_af" class="btn btn-primary fa icon-run-all-forced" title="' +
+            'Run all - ignore errors (' + params["run_all_cells_ignore_errors"] + ')"</button>\
+                <button type="button" id="run_m" class="btn btn-primary fa icon-run-marked" title="' +
+            'Run marked codecells (' + params["run_marked_cells"] + ')"</button>\
+                <button type="button" id="interrupt_b" class="btn btn-primary fa fa-stop" title="' +
+            'Stop execution (' + params["stop_execution"] + ')"</button>\
             </div>\
             <div class="btn-group">\
                 <button type="button" id="mark_toggle" class="btn btn-primary fa icon-mark-toggle" title="Mark single code cell"></button>\
@@ -311,63 +497,179 @@ define([
                 <button type="button" id="hide_input" class="btn btn-primary fa icon-hide-input" title="Hide input of code cell"></button>\
                 <button type="button" id="show_output" class="btn btn-primary fa icon-show-output" title="Show output of code cell"></button>\
                 <button type="button" id="hide_output" class="btn btn-primary fa icon-hide-output" title="Hide output of code cell"></button>\
-            </div>\
-            <div class="btn-group">\
-                <button type="button" id="up_marked" class="btn btn-primary fa fa-arrow-up" title="Move marked cells down"></button>\
-                <button type="button" id="down_marked" class="btn btn-primary fa fa-arrow-down" title="Move marked cells up"></button>\
                 <button type="button" id="lock_marked" class="btn btn-primary fa fa-lock" title="Lock marked cells"></button>\
                 <button type="button" id="unlock_marked" class="btn btn-primary fa fa-unlock" title="Unlock marked cells"></button>\
             </div>\
             </div>';
 
         var runtools_wrapper = $('<div id="runtools-wrapper">')
-           .text("Runtools")
-           .append(btn)
-           .draggable()
-           .append("</div>");
+            .text("Runtools")
+            .append(btn)
+            .draggable()
+            .append("</div>");
 
         $("#header").append(runtools_wrapper);
-        $("#runtools-wrapper").css({'position' : 'absolute'});
-    
-        $('#run_c').on('click', function(e) { IPython.notebook.execute_cell(); e.target.blur() })
-           .tooltip({ title : 'Run current cell' , delay: {show: 500, hide: 100}});
-        $('#run_ca').on('click', function(e) { IPython.notebook.execute_cells_above(); IPython.notebook.select_next(); e.target.blur() })
-            .tooltip({ title : 'Run cells above (Alt-A)' , delay: {show: 500, hide: 100}});
-        $('#run_cb').on('click', function(e) { IPython.notebook.execute_cells_below(); e.target.blur() })
-            .tooltip({ title : 'Run cells below (Alt-B)' , delay: {show: 500, hide: 100}});
-        $('#run_a').on('click', function(e) { IPython.notebook.execute_all_cells(); e.target.blur() })
-            .tooltip({ title : 'Run all cells (Alt-X)' , delay: {show: 500, hide: 100}});
-        $('#run_af').on('click', function(e) { execute_all_cells_ignore_errors(); e.target.blur() })
-            .tooltip({ title : 'Run all - ignore errors' , delay: {show: 500, hide: 100}});
-        $('#run_m').on('click', function(e) { run_marked(); e.target.blur() })
-            .tooltip({ title : 'Run marked codecells (Alt-R)' , delay: {show: 500, hide: 100}});
-        $('#interrupt_b').on('click', function(e) { IPython.notebook.kernel.interrupt(); e.target.blur() })
-            .tooltip({ title : 'Interrupt' , delay: {show: 500, hide: 100}});
-
-        $('#mark_toggle').on('click', function() { toggle_marker()  })
-        .tooltip({ title : 'Toggle codecell marker (Alt-T)' , delay: {show: 500, hide: 100}});
-        $('#mark_all').on('click', function() { mark_all()  })
-        .tooltip({ title : 'Mark all codecells (Alt-M)' , delay: {show: 500, hide: 100}});
-        $('#mark_none').on('click', function() { mark_none()  })
-            .tooltip({ title : 'Unmark all codecells (Alt-U)' , delay: {show: 500, hide: 100}});
-
-        $('#show_input').on('click', function() { show_input(true); this.blur() })
-            .tooltip({ title : 'Show input area of codecell' , delay: {show: 500, hide: 100}});
-        $('#hide_input').on('click', function() { show_input(false); this.blur()  })
-            .tooltip({ title : 'Hide input area of codecell' , delay: {show: 500, hide: 100}});
-        $('#show_output').on('click', function() { show_output(true); this.blur()  })
-            .tooltip({ title : 'Show output area of codecell' , delay: {show: 500, hide: 100}});
-        $('#hide_output').on('click', function() { show_output(false); this.blur()  })
-            .tooltip({ title : 'Hide output area of codecell' , delay: {show: 500, hide: 100}});
-
-        $('#up_marked').on('click', function() { move_marked_up(); this.blur()  })
-            .tooltip({ title : 'Move marked codecells up' , delay: {show: 500, hide: 100}});
-        $('#down_marked').on('click', function() { move_marked_down(); this.blur()  })
-            .tooltip({ title : 'Move marked codecells down' , delay: {show: 500, hide: 100}});
-        $('#lock_marked').on('click', function() { lock_cell(); this.blur()  })
-            .tooltip({ title : 'Lock codecells' , delay: {show: 500, hide: 100}});
-        $('#unlock_marked').on('click', function() { unlock_cell(); this.blur()  })
-            .tooltip({ title : 'Unlock codecells' , delay: {show: 500, hide: 100}});
+        $("#runtools-wrapper").css({
+            'position': 'absolute'
+        });
+        $('#run_c').on('click', function(e) {
+                Jupyter.notebook.execute_cell();
+                e.target.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#run_ca').on('click', function(e) {
+                Jupyter.notebook.execute_cells_above();
+                Jupyter.notebook.select_next();
+                e.target.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#run_cb').on('click', function(e) {
+                Jupyter.notebook.execute_cells_below();
+                e.target.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#run_a').on('click', function(e) {
+                Jupyter.notebook.execute_all_cells();
+                e.target.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#run_af').on('click', function(e) {
+                run_all_cells_ignore_errors();
+                e.target.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#run_m').on('click', function(e) {
+                run_marked_cells();
+                e.target.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#interrupt_b').on('click', function(e) {
+                interrupt_execution();
+                e.target.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#mark_toggle').on('click', function() {
+                toggle_marker()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#mark_all').on('click', function() {
+                mark_all()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#mark_none').on('click', function() {
+                mark_none()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#show_input').on('click', function() {
+                show_input(true);
+                this.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#hide_input').on('click', function() {
+                show_input(false);
+                this.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#show_output').on('click', function() {
+                show_output(true);
+                this.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#hide_output').on('click', function() {
+                show_output(false);
+                this.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#lock_marked').on('click', function() {
+                lock_cell(true);
+                this.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
+        $('#unlock_marked').on('click', function() {
+                lock_cell(false);
+                this.blur()
+            })
+            .tooltip({
+                delay: {
+                    show: 500,
+                    hide: 100
+                }
+            });
     };
 
     /**
@@ -389,189 +691,96 @@ define([
             create_runtools_div()
         }
     };
-    
-    /**
-     * Add run control buttons to toolbar
-     * 
-     */
-    IPython.toolbar.add_buttons_group([
-            {
-                id : 'toggle_runtools',
-                label : 'Toggle Runtools Toolbar',
-                icon : 'fa-cogs',
-                callback : function () {
-                    toggle_toolbar();
-                    }
-            }
-         ]);
-    $("#toggle_runtools").css({'outline' : 'none'});
+
 
     /**
      * Add CSS file
      *
      * @param name filename
      */
-    var load_css = function (name) {
+    var load_css = function(name) {
         var link = document.createElement("link");
         link.type = "text/css";
         link.rel = "stylesheet";
         link.href = require.toUrl(name);
         document.getElementsByTagName("head")[0].appendChild(link);
-      };
+    };
 
     /**
-     *  Add keyboard shortcuts
+     * Add gutter to a new cell
      *
-     */
-    var add_command_shortcuts = {
-            'alt-a' : {
-                help    : 'Execute cells above',
-                help_index : 'xa',
-                handler : function() {
-                    var mode = IPython.notebook.get_selected_cell().mode;
-                    IPython.notebook.execute_cells_above();
-                    IPython.notebook.select_next();
-                    var type = IPython.notebook.get_selected_cell().cell_type;
-                    if (mode == "edit" && type == "code") IPython.notebook.edit_mode();
-                    return false;
-                }
-            },
-            'alt-b' : {
-                help    : 'Execute cells below',
-                help_index : 'aa',
-                handler : function() {
-                    var mode = IPython.notebook.get_selected_cell().mode;               
-                    IPython.notebook.execute_cells_below();
-                    var type = IPython.notebook.get_selected_cell().cell_type;
-                    if (mode == "edit" && type == "code") IPython.notebook.edit_mode();                   
-                    return false;
-                }
-            }, 
-            'alt-t' : {
-                help    : 'Toggle marker',
-                help_index : 'mt',
-                handler : function() {
-                    toggle_marker();
-                    return false;
-                }
-            }, 
-            'alt-m' : {
-                help    : 'Mark all codecells',
-                help_index : 'ma',
-                handler : function() {
-                    mark_all();
-                    return false;
-                }
-            }, 
-            'alt-u' : {
-                help    : 'Unmark all codecells',
-                help_index : 'mu',
-                handler : function() {
-                    mark_none();
-                    return false;
-                }
-            }, 
-            'alt-r' : {
-                help    : 'Run marked cells',
-                help_index : 'rm',
-                handler : function() {
-                    run_marked();
-                    return false;
-                }
-            }, 
-            'alt-x' : {
-                help    : 'Run all cells',
-                help_index : 'ra',
-                handler : function() {
-                    var pos = IPython.notebook.element.scrollTop();
-                    var ic = IPython.notebook.get_selected_index();
-                    IPython.notebook.execute_all_cells();
-                    IPython.notebook.select(ic);
-                    IPython.notebook.element.animate({scrollTop:pos}, 100);
-                    return false;
-                }
-            }, 
-            'alt-f' : {
-                help    : 'Run all cells - ignore errors',
-                help_index : 'rf',
-                handler : function() {
-                    execute_all_cells_ignore_errors();
-                    return false;
-                }
-            }
-        };
-    IPython.keyboard_manager.command_shortcuts.add_shortcuts(add_command_shortcuts);
-    IPython.keyboard_manager.edit_shortcuts.add_shortcuts(add_command_shortcuts);
-
-    /**
-     * Add event if user clicks on codemirror gutter
+     * @param event
+     * @param nbcell
      *
      */
-    var ncells = IPython.notebook.ncells();
-    var cells = IPython.notebook.get_cells();
-    for (var i=0; i<ncells; i++) {
-        var cell=cells[i];
-        if ((cell.cell_type == "code")) {
-            cell.code_mirror.on("gutterClick", changeEvent);
-
-            if (cell.metadata.run_control != undefined) {
-                if (cell.metadata.run_control.marked == true) {
-                    var g=cell.code_mirror.getGutterElement();
-                    $(g).css({"background-color": "#0f0"});
-                }
+    var createCell = function(event, nbcell) {
+        var cell = nbcell.cell;
+        if (cell instanceof codecell.CodeCell) {
+            var gutters = cell.code_mirror.getOption('gutters').slice();
+            if ($.inArray("CodeMirror-cellstate", gutters) < 0) {
+                gutters.push('CodeMirror-cellstate');
+                cell.code_mirror.setOption('gutters', gutters);
+                cell.code_mirror.on("gutterClick", changeEvent);
+
             }
         }
-    }
+    };
+
 
+    /**
+     * Initialize all cells with new gutter
+     */
     var initGutter = function() {
-        var ncells = IPython.notebook.ncells();
-        var cells = IPython.notebook.get_cells();
-        for (var i=0; i<ncells; i++) {
+        var ncells = Jupyter.notebook.ncells();
+        var cells = Jupyter.notebook.get_cells();
+        for (var i = 0; i < ncells; i++) {
             var cell = cells[i];
-            if ((cell instanceof IPython.CodeCell)) {
-                var gutters = cell.code_mirror.getOption('gutters');
-                var found = jQuery.inArray("CodeMirror-foldgutter", gutters);
-                if (found == -1) {
-                    cell.code_mirror.setOption('gutters', [gutters, "CodeMirror-foldgutter"]);
-                    //cell.code_mirror.refresh();
+            if (cell instanceof codecell.CodeCell) {
+                var gutters = cell.code_mirror.getOption('gutters').slice();
+                if ($.inArray("CodeMirror-cellstate", gutters) < 0) {
+                    gutters.push('CodeMirror-cellstate');
+                    cell.code_mirror.setOption('gutters', gutters);
                 }
             }
         }
         /**
          * Restore hide/show status after reload
          */
-        for (i=0; i<ncells; i++) {
-            var _cell=cells[i];
-            if (_cell.metadata.hasOwnProperty('hide_input') && _cell.metadata.hide_input === true )
-                showCell(_cell, 'i',false);
-            if (_cell.metadata.hasOwnProperty('hide_output') && _cell.metadata.hide_output === true )
-                showCell(_cell, 'o',false);
-            if (_cell.metadata.hasOwnProperty('locked') && _cell.metadata.locked === true ) {
-                _cell.code_mirror.setOption('readOnly', true);
-                _cell.code_mirror.setGutterMarker(0, "CodeMirror-foldgutter", makeLockMarker());
-                //_cell.code_mirror.refresh();
+        for (i = 0; i < ncells; i++) {
+            var cell = cells[i];
+            if (cell.metadata.hasOwnProperty('hide_input') && cell.metadata.hide_input === true)
+                showCell(cell, 'i', false);
+            if (cell.metadata.hasOwnProperty('hide_output') && cell.metadata.hide_output === true)
+                showCell(cell, 'o', false);
+            if (cell.is_editable() === false) {
+                set_cell_state(cell, 'locked');
             }
-        _cell.code_mirror.refresh();
+            cell.code_mirror.refresh();
         }
+        events.on('create.Cell', createCell);
     };
 
     /**
-     * Called after extension was loaded
+     * Called from notebook after extension was loaded
      *
      */
     var load_extension = function() {
-        events.on('create.Cell',create_cell);
         load_css('./main.css');
-        load_css('codemirror/addon/fold/foldgutter.css');
-        load_css( './gutter.css'); /* change default gutter width */
-        if (Jupyter.notebook !== undefined && Jupyter.notebook._fully_loaded) {
-            require(['codemirror/addon/fold/foldgutter'], initGutter)
-        } else {
-            events.on("notebook_loaded.Notebook", function () {
-                require(['codemirror/addon/fold/foldgutter'], initGutter)
-            })
-        }
+        load_css('./gutter.css'); /* set gutter width */
+        require(['./cellstate'], function() {
+            if (Jupyter.notebook._fully_loaded) {
+                initGutter();
+            } else {
+                events.one('notebook_loaded.Notebook', initGutter);
+            }
+        });
+        config.load()
     };
 
-    return { load_ipython_extension : load_extension };
+    Jupyter.notebook.config.loaded.then(initialize);
+
+    return {
+        load_jupyter_extension: load_extension,
+        load_ipython_extension: load_extension
+    };
 });
diff --git a/src/jupyter_contrib_nbextensions/nbextensions/runtools/readme.md b/src/jupyter_contrib_nbextensions/nbextensions/runtools/readme.md
index 39a48632c..007d49c21 100644
--- a/src/jupyter_contrib_nbextensions/nbextensions/runtools/readme.md
+++ b/src/jupyter_contrib_nbextensions/nbextensions/runtools/readme.md
@@ -13,6 +13,11 @@ Code Cell Execution
 * Execute marked code cells (cells with green gutter area are marked)
 * Stop execution (duplicate to standard toolbar button)
 
+When executing marked cells, they are put in a execution list, and
+executed in order. The execution list can be modified by unmarking
+a cell not yet run. The execution list can be stopped by clicking on
+`stop execution`. Execution of the currently running cell can be stopped
+by pressing `stop execution` twice.
 
 Code Cell Marking
 -----------------
@@ -40,7 +45,7 @@ Codecells can be marked by clicking on the gutter of a codecell or by clicking o
 ![](runtools_marker.png)
 
 Marked codecells can be locked to read-only mode and moved upd and down:   
-![](runtools_move_lock.png)
+![](runtools_lock.png)
 
 The input and output areas of marked codecells can be hidden:   
 ![](runtools_show_hide.png)
@@ -49,6 +54,12 @@ A IPython notebook with marked cells looks like this:
 ![](runtools_nb.png)
 
 
+Demo
+----
+
+![](demo.gif)
+
+
 Internals
 ---------
 
diff --git a/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools.yaml b/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools.yaml
index d88391ef1..995b80334 100644
--- a/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools.yaml
+++ b/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools.yaml
@@ -4,4 +4,56 @@ Description: Runtools provide a number of additional functions for working with
 Link: readme.md
 Icon: icon.png
 Main: main.js
-Compatibility: 4.x, 5.x
+Compatibility: 5.x
+Parameters:
+- name: runtools.run_cells_above
+  description: run cells above
+  input_type: hotkey
+  default: Alt-a
+- name: runtools.run_cells_below
+  description: run cells below
+  input_type: hotkey
+  default: Alt-b
+- name: runtools.toggle_marker
+  description: Toggle marker
+  input_type: hotkey
+  default: Alt-t
+- name: runtools.mark_all_codecells
+  description: Mark all codecells
+  input_type: hotkey
+  default: Alt-m
+- name: runtools.unmark_all_codecells
+  description: Unmark all codecells
+  input_type: hotkey
+  default: Alt-u
+- name: runtools.run_marked_cells
+  description: run marked cells
+  input_type: hotkey
+  default: Alt-r
+- name: runtools.stop_execution
+  description: stop execution
+  input_type: hotkey
+  default: Ctrl-c
+- name: runtools.run_all_cells
+  description: run all cells
+  input_type: hotkey
+  default: Alt-x
+- name: runtools.run_alls_cells_ignore_errors
+  description: run all cells - ignore errors
+  input_type: hotkey
+  default: Alt-f
+- name: runtools.marked_color
+  description: |
+    Color for marking a codecell
+  default: '#20f224'
+  input_type: color
+- name: runtools.scheduled_color
+  description: |
+    Color when a codecell is scheduled to be rund
+  default: '#00def0'
+  input_type: color
+- name: runtools.run_color
+  description: |
+    Color while a codecell is being run
+  default: '#f30a2d'
+  input_type: color
diff --git a/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools_execute.png b/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools_execute.png
index 4529de1e5..ed8e96c1d 100644
Binary files a/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools_execute.png and b/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools_execute.png differ
diff --git a/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools_lock.png b/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools_lock.png
new file mode 100644
index 000000000..3b0a56161
Binary files /dev/null and b/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools_lock.png differ
diff --git a/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools_marker.png b/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools_marker.png
index 6baad887a..ad3914f39 100644
Binary files a/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools_marker.png and b/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools_marker.png differ
diff --git a/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools_move_lock.png b/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools_move_lock.png
deleted file mode 100644
index 7dd861cba..000000000
Binary files a/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools_move_lock.png and /dev/null differ
diff --git a/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools_show_hide.png b/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools_show_hide.png
index 58cf3ad05..8ff9477aa 100644
Binary files a/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools_show_hide.png and b/src/jupyter_contrib_nbextensions/nbextensions/runtools/runtools_show_hide.png differ