diff --git a/blocks_vertical/default_toolbox.js b/blocks_vertical/default_toolbox.js
index 8c5624fad4..e0a31e4e1d 100644
--- a/blocks_vertical/default_toolbox.js
+++ b/blocks_vertical/default_toolbox.js
@@ -28,6 +28,11 @@ goog.require('Blockly.Blocks');
  * @fileoverview Provide a default toolbox XML.
  */
 
+/**
+ * NOTE: This is only used in the scratch-blocks development playground!
+ * The XML here is overridden by scratch-gui.
+ */
+
 Blockly.Blocks.defaultToolbox = '<xml id="toolbox-categories" style="display: none">' +
   '<category name="%{BKY_CATEGORY_MOTION}" id="motion" colour="#4C97FF" secondaryColour="#3373CC">' +
     '<block type="motion_movesteps" id="motion_movesteps">' +
diff --git a/blocks_vertical/procedures.js b/blocks_vertical/procedures.js
index fc7df29075..2792dc563a 100644
--- a/blocks_vertical/procedures.js
+++ b/blocks_vertical/procedures.js
@@ -32,6 +32,20 @@ goog.require('Blockly.ScratchBlocks.VerticalExtensions');
 
 // Serialization and deserialization.
 
+Blockly.ScratchBlocks.ProcedureUtils.parseReturnMutation = function(xmlElement) {
+  if (xmlElement.hasAttribute('return')) {
+    var type = +xmlElement.getAttribute('return');
+    if (
+      type === Blockly.PROCEDURES_CALL_TYPE_STATEMENT ||
+      type === Blockly.PROCEDURES_CALL_TYPE_REPORTER ||
+      type === Blockly.PROCEDURES_CALL_TYPE_BOOLEAN
+    ) {
+      return type;
+    }
+  }
+  return Blockly.PROCEDURES_CALL_TYPE_STATEMENT;
+};
+
 /**
  * Create XML to represent the (non-editable) name and arguments of a procedure
  * call block.
@@ -43,6 +57,9 @@ Blockly.ScratchBlocks.ProcedureUtils.callerMutationToDom = function() {
   container.setAttribute('proccode', this.procCode_);
   container.setAttribute('argumentids', JSON.stringify(this.argumentIds_));
   container.setAttribute('warp', JSON.stringify(this.warp_));
+  if (this.return_ !== Blockly.PROCEDURES_CALL_TYPE_STATEMENT) {
+    container.setAttribute('return', this.return_);
+  }
   return container;
 };
 
@@ -58,6 +75,10 @@ Blockly.ScratchBlocks.ProcedureUtils.callerDomToMutation = function(xmlElement)
       JSON.parse(xmlElement.getAttribute('generateshadows'));
   this.argumentIds_ = JSON.parse(xmlElement.getAttribute('argumentids'));
   this.warp_ = JSON.parse(xmlElement.getAttribute('warp'));
+  this.return_ = Blockly.ScratchBlocks.ProcedureUtils.parseReturnMutation(xmlElement);
+  if (this.return_ !== Blockly.PROCEDURES_CALL_TYPE_STATEMENT) {
+    this.workspace.enableProcedureReturns();
+  }
   this.updateDisplay_();
 };
 
@@ -138,6 +159,22 @@ Blockly.ScratchBlocks.ProcedureUtils.updateDisplay_ = function() {
   this.createAllInputs_(connectionMap);
   this.deleteShadows_(connectionMap);
 
+  if (!wasRendered && this.getReturn) {
+    this.setInputsInline(true);
+    if (this.getReturn() === Blockly.PROCEDURES_CALL_TYPE_STATEMENT) {
+      this.setPreviousStatement(true, null);
+      this.setNextStatement(true, null);
+    } else {
+      if (this.getReturn() === Blockly.PROCEDURES_CALL_TYPE_BOOLEAN) {
+        this.setOutput(true, null);
+        this.setOutputShape(Blockly.OUTPUT_SHAPE_HEXAGONAL);
+      } else {
+        this.setOutput(true, Blockly.Procedures.ENFORCE_TYPES ? 'Number' : null);
+        this.setOutputShape(Blockly.OUTPUT_SHAPE_ROUND);
+      }
+    }
+  }
+
   this.rendered = wasRendered;
   if (wasRendered && !this.isInsertionMarker()) {
     this.initSvg();
@@ -210,6 +247,7 @@ Blockly.ScratchBlocks.ProcedureUtils.createAllInputs_ = function(connectionMap)
   });
   // Create arguments and labels as appropriate.
   var argumentCount = 0;
+  var hasAnyField = false;
   for (var i = 0, component; component = procComponents[i]; i++) {
     var labelText;
     if (component.substring(0, 1) == '%') {
@@ -228,11 +266,21 @@ Blockly.ScratchBlocks.ProcedureUtils.createAllInputs_ = function(connectionMap)
       }
       this.populateArgument_(argumentType, argumentCount, connectionMap, id,
           input);
+      hasAnyField = true;
       argumentCount++;
     } else {
       labelText = component.trim();
     }
-    this.addProcedureLabel_(labelText.replace(/\\%/, '%'));
+    labelText = labelText.replace(/\\%/, '%');
+    // don't add empty labels which will just waste space
+    if (labelText) {
+      this.addProcedureLabel_(labelText);
+      hasAnyField = true;
+    }
+  }
+  // Custom reporters will crash editor if they have no fields.
+  if (!hasAnyField) {
+    this.addProcedureLabel_(' ');
   }
 };
 
@@ -666,6 +714,14 @@ Blockly.ScratchBlocks.ProcedureUtils.setWarp = function(warp) {
   this.warp_ = warp;
 };
 
+/**
+ * @this {BlockSvg}
+ * @returns {number} Value of the return_ property. See enum in constants.js
+ */
+Blockly.ScratchBlocks.ProcedureUtils.getReturn = function() {
+  return this.return_;
+};
+
 /**
  * Callback to remove a field, only for the declaration block.
  * @param {Blockly.Field} field The field being removed.
@@ -794,11 +850,12 @@ Blockly.Blocks['procedures_call'] = {
    */
   init: function() {
     this.jsonInit({
-      "extensions": ["colours_more", "shape_statement", "procedure_call_contextmenu"]
+      "extensions": ["colours_more", "procedure_call_contextmenu"]
     });
     this.procCode_ = '';
     this.argumentIds_ = [];
     this.warp_ = false;
+    this.return_ = Blockly.PROCEDURES_CALL_TYPE_STATEMENT;
   },
   // Shared.
   getProcCode: Blockly.ScratchBlocks.ProcedureUtils.getProcCode,
@@ -807,6 +864,7 @@ Blockly.Blocks['procedures_call'] = {
   deleteShadows_: Blockly.ScratchBlocks.ProcedureUtils.deleteShadows_,
   createAllInputs_: Blockly.ScratchBlocks.ProcedureUtils.createAllInputs_,
   updateDisplay_: Blockly.ScratchBlocks.ProcedureUtils.updateDisplay_,
+  getReturn: Blockly.ScratchBlocks.ProcedureUtils.getReturn,
 
   // Exist on all three blocks, but have different implementations.
   mutationToDom: Blockly.ScratchBlocks.ProcedureUtils.callerMutationToDom,
@@ -969,3 +1027,23 @@ Blockly.Blocks['argument_editor_string_number'] = {
   // Exist on declaration and arguments editors, with different implementations.
   removeFieldCallback: Blockly.ScratchBlocks.ProcedureUtils.removeArgumentCallback_
 };
+
+Blockly.Blocks['procedures_return'] = {
+  /**
+   * Point towards drop-down menu.
+   * @this Blockly.Block
+  */
+  init: function() {
+    this.jsonInit({
+      "message0": Blockly.Msg.PROCEDURES_RETURN,
+      "args0": [
+        {
+          "type": "input_value",
+          "name": "VALUE"
+        }
+      ],
+      "extensions": ["colours_more", "shape_end"]
+    });
+    this.workspace.enableProcedureReturns();
+  }
+};
diff --git a/blocks_vertical/vertical_extensions.js b/blocks_vertical/vertical_extensions.js
index 76fe3aa59d..905e1b77e1 100644
--- a/blocks_vertical/vertical_extensions.js
+++ b/blocks_vertical/vertical_extensions.js
@@ -208,6 +208,13 @@ Blockly.ScratchBlocks.VerticalExtensions.PROCEDURE_CALL_CONTEXTMENU = {
    */
   customContextMenu: function(menuOptions) {
     menuOptions.push(Blockly.Procedures.makeEditOption(this));
+    if (
+      !this.isInFlyout &&
+      Blockly.Procedures.USER_CAN_CHANGE_CALL_TYPE &&
+      this.workspace.procedureReturnsEnabled
+    ) {
+      menuOptions.push(Blockly.Procedures.makeChangeTypeOption(this));
+    }
   }
 };
 
diff --git a/core/connection.js b/core/connection.js
index cfc0f779c3..b707371c40 100644
--- a/core/connection.js
+++ b/core/connection.js
@@ -145,6 +145,11 @@ Blockly.Connection.prototype.connect_ = function(childConnection) {
   if (parentConnection == parentBlock.getFirstStatementConnection()) {
     isSurroundingC = true;
   }
+
+  if (Blockly.Events.isEnabled() && !childBlock.isInsertionMarker()) {
+    childBlock.workspace.procedureReturnsWillChange();
+  }
+
   // Disconnect any existing parent on the child connection.
   if (childConnection.isConnected()) {
     // Scratch-specific behaviour:
@@ -584,10 +589,15 @@ Blockly.Connection.prototype.disconnect = function() {
  */
 Blockly.Connection.prototype.disconnectInternal_ = function(parentBlock,
     childBlock) {
+  if (Blockly.Events.isEnabled() && !childBlock.isInsertionMarker()) {
+    childBlock.workspace.procedureReturnsWillChange();
+  }
+
   var event;
   if (Blockly.Events.isEnabled()) {
     event = new Blockly.Events.BlockMove(childBlock);
   }
+
   var otherConnection = this.targetConnection;
   otherConnection.targetConnection = null;
   this.targetConnection = null;
diff --git a/core/constants.js b/core/constants.js
index 2b6d653586..0eb7bee9cf 100644
--- a/core/constants.js
+++ b/core/constants.js
@@ -377,6 +377,27 @@ Blockly.PROCEDURES_PROTOTYPE_BLOCK_TYPE = 'procedures_prototype';
  */
 Blockly.PROCEDURES_CALL_BLOCK_TYPE = 'procedures_call';
 
+/**
+ * Enum for procedure call statements.
+ */
+Blockly.PROCEDURES_CALL_TYPE_STATEMENT = 0;
+
+/**
+ * Enum for procedure call round reporters.
+ */
+Blockly.PROCEDURES_CALL_TYPE_REPORTER = 1;
+
+/**
+ * Enum for procedure call booleans.
+ */
+Blockly.PROCEDURES_CALL_TYPE_BOOLEAN = 2;
+
+/**
+ * The type of all procedure return blocks.
+ * @const {string}
+ */
+Blockly.PROCEDURES_RETURN_BLOCK_TYPE = 'procedures_return';
+
 /**
  * ENUM for flyout status button states.
  * @const
diff --git a/core/procedures.js b/core/procedures.js
index 5c4f81ef2e..ed3b4134ee 100644
--- a/core/procedures.js
+++ b/core/procedures.js
@@ -227,7 +227,12 @@ Blockly.Procedures.flyoutCategory = function(workspace) {
   var mutations = Blockly.Procedures.allProcedureMutations(workspace);
   mutations = Blockly.Procedures.sortProcedureMutations_(mutations);
   for (var i = 0; i < mutations.length; i++) {
-    var mutation = mutations[i];
+    var mutation = mutations[i].cloneNode(false);
+    var procCode = mutation.getAttribute('proccode');
+    var returnType = Blockly.Procedures.getProcedureReturnType(procCode, workspace);
+    if (returnType !== Blockly.PROCEDURES_CALL_TYPE_STATEMENT) {
+      mutation.setAttribute('return', returnType);
+    }
     // <block type="procedures_call">
     //   <mutation ...></mutation>
     // </block>
@@ -237,6 +242,33 @@ Blockly.Procedures.flyoutCategory = function(workspace) {
     block.appendChild(mutation);
     xmlList.push(block);
   }
+
+  var showReturn = (
+    Blockly.Procedures.DEFAULT_ENABLE_RETURNS ?
+    mutations.length > 0 :
+    workspace.procedureReturnsEnabled
+  );
+  if (showReturn) {
+    var returnDocsButton = goog.dom.createDom('button');
+    returnDocsButton.setAttribute('callbackkey', 'OPEN_RETURN_DOCS');
+    returnDocsButton.setAttribute('text', Blockly.Msg.PROCEDURES_DOCS);
+    xmlList.push(returnDocsButton);
+
+    var returnBlock = goog.dom.createDom('block');
+    returnBlock.setAttribute('type', Blockly.PROCEDURES_RETURN_BLOCK_TYPE);
+    returnBlock.setAttribute('gap', 16);
+    var returnBlockValue = goog.dom.createDom('value');
+    returnBlockValue.setAttribute('name', 'VALUE');
+    var returnBlockShadow = goog.dom.createDom('shadow');
+    returnBlockShadow.setAttribute('type', 'text');
+    var returnBlockField = goog.dom.createDom('field');
+    returnBlockField.setAttribute('name', 'TEXT');
+    returnBlockShadow.appendChild(returnBlockField);
+    returnBlockValue.appendChild(returnBlockShadow);
+    returnBlock.appendChild(returnBlockValue);
+    xmlList.push(returnBlock);
+  }
+
   return xmlList;
 };
 
@@ -316,7 +348,12 @@ Blockly.Procedures.mutateCallersAndPrototype = function(name, ws, mutation) {
     for (var i = 0, caller; caller = callers[i]; i++) {
       var oldMutationDom = caller.mutationToDom();
       var oldMutation = oldMutationDom && Blockly.Xml.domToText(oldMutationDom);
-      caller.domToMutation(mutation);
+
+      // Preserve the block's existing shape
+      var mutationToReplaceWith = mutation.cloneNode(false);
+      mutationToReplaceWith.setAttribute('return', oldMutationDom.getAttribute('return'));
+      caller.domToMutation(mutationToReplaceWith);
+
       var newMutationDom = caller.mutationToDom();
       var newMutation = newMutationDom && Blockly.Xml.domToText(newMutationDom);
       if (oldMutation != newMutation) {
@@ -516,6 +553,53 @@ Blockly.Procedures.makeEditOption = function(block) {
   return editOption;
 };
 
+Blockly.Procedures.makeChangeTypeOption = function(block) {
+  var isStatement = block.getReturn() === Blockly.PROCEDURES_CALL_TYPE_STATEMENT;
+  var option = {
+    enabled: true,
+    text: isStatement ? Blockly.Msg.PROCEDURES_TO_REPORTER : Blockly.Msg.PROCEDURES_TO_STATEMENT,
+    callback: function() {
+      var newType;
+      if (isStatement) {
+        var procCode = block.getProcCode();
+        var workspace = block.workspace;
+        var actualReturnType = Blockly.Procedures.getProcedureReturnType(procCode, workspace);
+        // If the definition is boolean-shaped, then the reporter should be boolean-shaped,
+        // otherwise normal reporter shaped.
+        newType = (
+          actualReturnType === Blockly.PROCEDURES_CALL_TYPE_BOOLEAN ?
+          actualReturnType :
+          Blockly.PROCEDURES_CALL_TYPE_REPORTER
+        );
+      } else {
+        newType = Blockly.PROCEDURES_CALL_TYPE_STATEMENT;
+      }
+
+      Blockly.Events.setGroup(true);
+      try {
+        Blockly.Procedures.changeReturnType(block, newType);
+      } finally {
+        Blockly.Events.setGroup(false);
+      }
+    }
+  };
+  return option;
+};
+
+Blockly.Procedures.changeReturnType = function(block, returnType) {
+  block.unplug(true);
+  var workspace = block.workspace;
+  var xml = Blockly.Xml.blockToDom(block);
+  var xy = block.getRelativeToSurfaceXY();
+  block.dispose();
+
+  var mutation = xml.querySelector('mutation');
+  mutation.setAttribute('return', returnType);
+
+  var newBlock = Blockly.Xml.domToBlock(xml, workspace);
+  newBlock.moveBy(xy.x, xy.y);
+};
+
 /**
  * Callback to show the procedure definition corresponding to a custom command
  * block.
@@ -575,3 +659,81 @@ Blockly.Procedures.deleteProcedureDefCallback = function(procCode,
 
   return true;
 };
+
+/**
+ * If true, the user will be able to manually override the shape of procedure call blocks.
+ */
+Blockly.Procedures.USER_CAN_CHANGE_CALL_TYPE = true;
+
+/**
+ * If false, a round procedure call reporter can be dropped into any input, including boolean ones.
+ */
+Blockly.Procedures.ENFORCE_TYPES = false;
+
+/**
+ * If true, the return block will always be available. If false, either create a block that requires
+ * returns or call workspace.enableProcedureReturns() to enable return blocks.
+ */
+Blockly.Procedures.DEFAULT_ENABLE_RETURNS = false;
+
+/**
+ * @param {string} procCode The procedure code
+ * @param {Blockly.Workspace} workspace The workspace
+ * @returns {number} The type of the return block
+ */
+Blockly.Procedures.getProcedureReturnType = function(procCode, workspace) {
+  var defineBlock = Blockly.Procedures.getDefineBlock(procCode, workspace);
+  if (!defineBlock) {
+    return Blockly.PROCEDURES_CALL_TYPE_STATEMENT;
+  }
+  return Blockly.Procedures.getBlockReturnType(defineBlock);
+};
+
+/**
+ * @param {Blockly.Workspace} workspace The workspace
+ * @returns {Record<string, number>} The return type of each procedure in the workspace.
+ */
+Blockly.Procedures.getAllProcedureReturnTypes = function(workspace) {
+  var result = Object.create(null);
+  var blocks = workspace.getTopBlocks(false);
+  for (var i = 0; i < blocks.length; i++) {
+    var block = blocks[i];
+    if (block.type == Blockly.PROCEDURES_DEFINITION_BLOCK_TYPE && !block.isInsertionMarker()) {
+      var procCode = block.getInput('custom_block').connection.targetBlock().getProcCode();
+      // To match behavior of getDefineBlock, if multiple instances of this procedure are
+      // defined, only use the first one.
+      if (!Object.prototype.hasOwnProperty.call(result, procCode)) {
+        result[procCode] = Blockly.Procedures.getBlockReturnType(block);
+      }
+    }
+  }
+  return result;
+};
+
+/**
+ * @param {Blockly.Block} block The block
+ * @returns {number} The type of the return block
+ */
+Blockly.Procedures.getBlockReturnType = function(block) {
+  var hasSeenBooleanReturn = false;
+  /** @type {Blockly.Block[]} */
+  var descendants = block.getDescendants();
+  for (var i = 0; i < descendants.length; i++) {
+    if (descendants[i].type === Blockly.PROCEDURES_RETURN_BLOCK_TYPE) {
+      // The block at i + 1 should be the block inside of the return block.
+      // Even if the return block is missing its input, this will still be fine, because the
+      // next block should a stacked block which won't be hexagon-shaped.
+      if (i + 1 < descendants.length && descendants[i + 1].outputShape_ === Blockly.OUTPUT_SHAPE_HEXAGONAL) {
+        // keep searching, because there may be other, non-boolean returns in this function definition.
+        hasSeenBooleanReturn = true;
+      } else {
+        return Blockly.PROCEDURES_CALL_TYPE_REPORTER;
+      }
+    }
+  }
+  if (hasSeenBooleanReturn) {
+    return Blockly.PROCEDURES_CALL_TYPE_BOOLEAN;
+  } else {
+    return Blockly.PROCEDURES_CALL_TYPE_STATEMENT;
+  }
+};
diff --git a/core/workspace_svg.js b/core/workspace_svg.js
index a98bb0c6c4..5f5682b4ee 100644
--- a/core/workspace_svg.js
+++ b/core/workspace_svg.js
@@ -116,6 +116,11 @@ Blockly.WorkspaceSvg = function(options, opt_blockDragSurface, opt_wsDragSurface
       Blockly.DataCategory);
   this.registerToolboxCategoryCallback(Blockly.PROCEDURE_CATEGORY_NAME,
       Blockly.Procedures.flyoutCategory);
+
+  this.procedureReturnsEnabled = Blockly.Procedures.DEFAULT_ENABLE_RETURNS;
+  this.initialProcedureReturnTypes_ = null;
+  this.procedureReturnChangeTimeout_ = null;
+  this.checkProcedureReturnAfterGesture_ = false;
 };
 goog.inherits(Blockly.WorkspaceSvg, Blockly.Workspace);
 
@@ -558,6 +563,9 @@ Blockly.WorkspaceSvg.prototype.dispose = function() {
     Blockly.unbindEvent_(this.resizeHandlerWrapper_);
     this.resizeHandlerWrapper_ = null;
   }
+  if (this.procedureReturnChangeTimeout_) {
+    clearTimeout(this.procedureReturnChangeTimeout_);
+  }
 };
 
 /**
@@ -690,6 +698,92 @@ Blockly.WorkspaceSvg.prototype.queueIntersectionCheck = function() {
   }
 };
 
+/**
+ * Call *before* modifying scripts.
+ */
+Blockly.WorkspaceSvg.prototype.procedureReturnsWillChange = function() {
+  if (this.initialProcedureReturnTypes_) {
+    // Already queued.
+    return;
+  }
+
+  this.initialProcedureReturnTypes_ = Blockly.Procedures.getAllProcedureReturnTypes(this);
+
+  if (this.currentGesture_) {
+    this.checkProcedureReturnAfterGesture_ = true;
+  } else {
+    this.procedureReturnChangeTimeout_ = setTimeout(this.processProcedureReturnsChanged_.bind(this));
+  }
+};
+
+/**
+ * @private
+ */
+Blockly.WorkspaceSvg.prototype.processProcedureReturnsChanged_ = function() {
+  var initialTypes = this.initialProcedureReturnTypes_;
+  var finalTypes = Blockly.Procedures.getAllProcedureReturnTypes(this);
+
+  this.initialProcedureReturnTypes_ = null;
+  this.checkProcedureReturnAfterGesture_ = false;
+  this.procedureReturnChangeTimeout_ = null;
+
+  Blockly.Events.setGroup(true);
+  var topBlocks = this.getTopBlocks(false);
+  for (var i = 0; i < topBlocks.length; i++) {
+    var block = topBlocks[i];
+    if (block.type !== Blockly.PROCEDURES_CALL_BLOCK_TYPE) continue;
+
+    // After a gesture, we are called early enough that there could still be insertion markers.
+    if (block.isInsertionMarker()) continue;
+
+    // Because this block is a top block, it by definition won't have a parent, but if another
+    // block is connected below, we should leave it unchanged instead of unplugging.
+    if (block.getNextBlock()) continue;
+
+    var procCode = block.getProcCode();
+    // If the procedure doesn't exist or is new, ignore it.
+    if (
+      !Object.prototype.hasOwnProperty.call(initialTypes, procCode) ||
+      !Object.prototype.hasOwnProperty.call(finalTypes, procCode)
+    ) continue;
+
+    var actualReturnType = finalTypes[procCode];
+    if (
+      block.getReturn() !== actualReturnType &&
+      // If user is allowed to override call block shape, only update the shape if the definition's
+      // shape has actually changed.
+      (!Blockly.Procedures.USER_CAN_CHANGE_CALL_TYPE || initialTypes[procCode] !== actualReturnType)
+    ) {
+      Blockly.Procedures.changeReturnType(block, actualReturnType);
+    }
+  }
+  Blockly.Events.setGroup(false);
+
+  // Toolbox refresh can be slow, so only do when needed.
+  var toolboxOutdated = false;
+  for (var procCode in finalTypes) {
+    // If a current procedure existed but its type has changed, the toolbox must be updated.
+    // If a new procedure was created, the toolbox is already updated elsewhere.
+    if (
+      Object.prototype.hasOwnProperty.call(initialTypes, procCode) &&
+      initialTypes[procCode] !== finalTypes[procCode]
+    ) {
+      toolboxOutdated = true;
+      break;
+    }
+  }
+  if (toolboxOutdated) {
+    this.refreshToolboxSelection_();
+  }
+};
+
+/**
+ * Does not refresh toolbox.
+ */
+Blockly.WorkspaceSvg.prototype.enableProcedureReturns = function() {
+  this.procedureReturnsEnabled = true;
+};
+
 /**
  * Resize and reposition all of the workspace chrome (toolbox,
  * trash, scrollbars etc.)
@@ -2231,6 +2325,10 @@ Blockly.WorkspaceSvg.prototype.getGesture = function(e) {
  */
 Blockly.WorkspaceSvg.prototype.clearGesture = function() {
   this.currentGesture_ = null;
+
+  if (this.checkProcedureReturnAfterGesture_) {
+    this.processProcedureReturnsChanged_();
+  }
 };
 
 /**
diff --git a/msg/messages.js b/msg/messages.js
index c7c1e613fe..ad7e83d5f5 100644
--- a/msg/messages.js
+++ b/msg/messages.js
@@ -220,6 +220,12 @@ Blockly.Msg.OPERATORS_MATHOP_10EXP = '10 ^';
 // Procedures blocks
 Blockly.Msg.PROCEDURES_DEFINITION = 'define %1';
 
+// TW Procedures blocks
+Blockly.Msg.PROCEDURES_RETURN = 'return %1';
+Blockly.Msg.PROCEDURES_TO_REPORTER = 'Change To Reporter';
+Blockly.Msg.PROCEDURES_TO_STATEMENT = 'Change To Stacked Block';
+Blockly.Msg.PROCEDURES_DOCS = 'How to use return';
+
 // Sensing blocks
 Blockly.Msg.SENSING_TOUCHINGOBJECT = 'touching %1?';
 Blockly.Msg.SENSING_TOUCHINGOBJECT_POINTER = 'mouse-pointer';
diff --git a/tests/vertical_playground.html b/tests/vertical_playground.html
index 5ff492a0d3..bac380c356 100644
--- a/tests/vertical_playground.html
+++ b/tests/vertical_playground.html
@@ -135,6 +135,7 @@
         var input = document.getElementById('importExport');
         var xml = Blockly.Xml.textToDom(input.value);
         Blockly.Xml.domToWorkspace(xml, workspace);
+        workspace.refreshToolboxSelection_();
         taChange();
       }