diff --git a/FEATURES.md b/FEATURES.md
index fb0d67c5fc9..ca598244f45 100644
--- a/FEATURES.md
+++ b/FEATURES.md
@@ -310,3 +310,8 @@ for a detailed explanation.
   for each person.. E.g. a list of all `firstNames`, or `lastNames`, or `ages`.
 
   Addd in [#11196](https://github.com/emberjs/ember.js/pull/11196)
+
+* `ember-htmlbars-helper`
+
+  Implements RFC https://github.com/emberjs/rfcs/pull/53, a public helper
+  api.
diff --git a/features.json b/features.json
index 4bb640ea38b..2f437d78411 100644
--- a/features.json
+++ b/features.json
@@ -20,7 +20,8 @@
     "ember-routing-route-configured-query-params": null,
     "ember-libraries-isregistered": null,
     "ember-routing-htmlbars-improved-actions": true,
-    "ember-htmlbars-get-helper": null
+    "ember-htmlbars-get-helper": null,
+    "ember-htmlbars-helper": true
   },
   "debugStatements": [
     "Ember.warn",
diff --git a/package.json b/package.json
index 98376097922..68a2e144df1 100644
--- a/package.json
+++ b/package.json
@@ -23,7 +23,7 @@
     "express": "^4.5.0",
     "github": "^0.2.3",
     "glob": "~4.3.2",
-    "htmlbars": "0.13.25",
+    "htmlbars": "0.13.28",
     "qunit-extras": "^1.3.0",
     "qunitjs": "^1.16.0",
     "route-recognizer": "0.1.5",
diff --git a/packages/ember-application/lib/system/application.js b/packages/ember-application/lib/system/application.js
index 2dd9c9ca1ac..2b7248351c5 100644
--- a/packages/ember-application/lib/system/application.js
+++ b/packages/ember-application/lib/system/application.js
@@ -1016,7 +1016,6 @@ Application.reopenClass({
     registry.optionsForType('component', { singleton: false });
     registry.optionsForType('view', { singleton: false });
     registry.optionsForType('template', { instantiate: false });
-    registry.optionsForType('helper', { instantiate: false });
 
     registry.register('application:main', namespace, { instantiate: false });
 
diff --git a/packages/ember-application/tests/system/dependency_injection/default_resolver_test.js b/packages/ember-application/tests/system/dependency_injection/default_resolver_test.js
index 0bde4b6f075..713ebef475c 100644
--- a/packages/ember-application/tests/system/dependency_injection/default_resolver_test.js
+++ b/packages/ember-application/tests/system/dependency_injection/default_resolver_test.js
@@ -9,6 +9,10 @@ import Service from "ember-runtime/system/service";
 import EmberObject from "ember-runtime/system/object";
 import Namespace from "ember-runtime/system/namespace";
 import Application from "ember-application/system/application";
+import Helper, { helper as makeHelper } from "ember-htmlbars/helper";
+import makeHandlebarsBoundHelper from "ember-htmlbars/compat/make-bound-helper";
+import makeViewHelper from "ember-htmlbars/system/make-view-helper";
+import makeHTMLBarsBoundHelper from "ember-htmlbars/system/make_bound_helper";
 import {
   registerHelper
 } from "ember-htmlbars/helpers";
@@ -102,12 +106,48 @@ QUnit.test("the default resolver resolves helpers", function() {
 });
 
 QUnit.test("the default resolver resolves container-registered helpers", function() {
-  function gooresolvertestHelper() { return 'GOO'; }
-  function gooGazResolverTestHelper() { return 'GAZ'; }
-  application.register('helper:gooresolvertest', gooresolvertestHelper);
-  application.register('helper:goo-baz-resolver-test', gooGazResolverTestHelper);
-  equal(gooresolvertestHelper, locator.lookup('helper:gooresolvertest'), "looks up gooresolvertest helper");
-  equal(gooGazResolverTestHelper, locator.lookup('helper:goo-baz-resolver-test'), "looks up gooGazResolverTestHelper helper");
+  let shorthandHelper = makeHelper(function() {});
+  let helper = Helper.extend();
+
+  application.register('helper:shorthand', shorthandHelper);
+  application.register('helper:complete', helper);
+
+  let lookedUpShorthandHelper = locator.lookupFactory('helper:shorthand');
+  ok(lookedUpShorthandHelper.isHelperInstance, 'shorthand helper isHelper');
+
+  let lookedUpHelper = locator.lookupFactory('helper:complete');
+  ok(lookedUpHelper.isHelperFactory, 'complete helper is factory');
+  ok(helper.detect(lookedUpHelper), "looked up complete helper");
+});
+
+QUnit.test("the default resolver resolves helpers on the namespace", function() {
+  let ShorthandHelper = makeHelper(function() {});
+  let CompleteHelper = Helper.extend();
+  let LegacyBareFunctionHelper = function() {};
+  let LegacyHandlebarsBoundHelper = makeHandlebarsBoundHelper(function() {});
+  let LegacyHTMLBarsBoundHelper = makeHTMLBarsBoundHelper(function() {});
+  let ViewHelper = makeViewHelper(function() {});
+
+  application.ShorthandHelper = ShorthandHelper;
+  application.CompleteHelper = CompleteHelper;
+  application.LegacyBareFunctionHelper = LegacyBareFunctionHelper;
+  application.LegacyHandlebarsBoundHelper = LegacyHandlebarsBoundHelper;
+  application.LegacyHtmlBarsBoundHelper = LegacyHTMLBarsBoundHelper; // Must use lowered "tml" in "HTMLBars" for resolver to find this
+  application.ViewHelper = ViewHelper;
+
+  let resolvedShorthand = registry.resolve('helper:shorthand');
+  let resolvedComplete = registry.resolve('helper:complete');
+  let resolvedLegacy = registry.resolve('helper:legacy-bare-function');
+  let resolvedLegacyHandlebars = registry.resolve('helper:legacy-handlebars-bound');
+  let resolvedLegacyHTMLBars = registry.resolve('helper:legacy-html-bars-bound');
+  let resolvedView = registry.resolve('helper:view');
+
+  equal(resolvedShorthand, ShorthandHelper, 'resolve fetches the shorthand helper factory');
+  equal(resolvedComplete, CompleteHelper, 'resolve fetches the complete helper factory');
+  ok(typeof resolvedLegacy === 'function', 'legacy function helper is resolved');
+  equal(resolvedView, ViewHelper, 'resolves view helper');
+  equal(resolvedLegacyHTMLBars, LegacyHTMLBarsBoundHelper, 'resolves legacy HTMLBars bound helper');
+  equal(resolvedLegacyHandlebars, LegacyHandlebarsBoundHelper, 'resolves legacy Handlebars bound helper');
 });
 
 QUnit.test("the default resolver throws an error if the fullName to resolve is invalid", function() {
diff --git a/packages/ember-htmlbars/lib/helper.js b/packages/ember-htmlbars/lib/helper.js
new file mode 100644
index 00000000000..3aab9f523d7
--- /dev/null
+++ b/packages/ember-htmlbars/lib/helper.js
@@ -0,0 +1,23 @@
+import Object from "ember-runtime/system/object";
+
+// Ember.Helper.extend({ compute(params, hash) {} });
+var Helper = Object.extend({
+  isHelper: true,
+  recompute() {
+    this._stream.notify();
+  }
+});
+
+Helper.reopenClass({
+  isHelperFactory: true
+});
+
+// Ember.Helper.helper(function(params, hash) {});
+export function helper(helperFn) {
+  return {
+    isHelperInstance: true,
+    compute: helperFn
+  };
+}
+
+export default Helper;
diff --git a/packages/ember-htmlbars/lib/hooks/element.js b/packages/ember-htmlbars/lib/hooks/element.js
index ddc63fd765e..d02fd31e61d 100644
--- a/packages/ember-htmlbars/lib/hooks/element.js
+++ b/packages/ember-htmlbars/lib/hooks/element.js
@@ -5,6 +5,7 @@
 
 import { findHelper } from "ember-htmlbars/system/lookup-helper";
 import { handleRedirect } from "htmlbars-runtime/hooks";
+import { buildHelperStream } from "ember-htmlbars/system/invoke-helper";
 
 var fakeElement;
 
@@ -32,7 +33,8 @@ export default function emberElement(morph, env, scope, path, params, hash, visi
   var result;
   var helper = findHelper(path, scope.self, env);
   if (helper) {
-    result = env.hooks.invokeHelper(null, env, scope, null, params, hash, helper, { element: morph.element }).value;
+    var helperStream = buildHelperStream(helper, params, hash, { element: morph.element }, env, scope);
+    result = helperStream.value();
   } else {
     result = env.hooks.get(env, scope, path);
   }
diff --git a/packages/ember-htmlbars/lib/hooks/has-helper.js b/packages/ember-htmlbars/lib/hooks/has-helper.js
index 169f2b4f881..35d8e69ab10 100644
--- a/packages/ember-htmlbars/lib/hooks/has-helper.js
+++ b/packages/ember-htmlbars/lib/hooks/has-helper.js
@@ -1,5 +1,17 @@
-import { findHelper } from "ember-htmlbars/system/lookup-helper";
+import { validateLazyHelperName } from "ember-htmlbars/system/lookup-helper";
 
 export default function hasHelperHook(env, scope, helperName) {
-  return !!findHelper(helperName, scope.self, env);
+  if (env.helpers[helperName]) {
+    return true;
+  }
+
+  var container = env.container;
+  if (validateLazyHelperName(helperName, container, env.hooks.keywords)) {
+    var containerName = 'helper:' + helperName;
+    if (container._registry.has(containerName)) {
+      return true;
+    }
+  }
+
+  return false;
 }
diff --git a/packages/ember-htmlbars/lib/hooks/invoke-helper.js b/packages/ember-htmlbars/lib/hooks/invoke-helper.js
index 9f72f98b8e2..92cd928c07d 100644
--- a/packages/ember-htmlbars/lib/hooks/invoke-helper.js
+++ b/packages/ember-htmlbars/lib/hooks/invoke-helper.js
@@ -1,43 +1,24 @@
 import Ember from 'ember-metal/core'; // Ember.assert
-import getValue from "ember-htmlbars/hooks/get-value";
+import { buildHelperStream } from "ember-htmlbars/system/invoke-helper";
 
+export default function invokeHelper(morph, env, scope, visitor, params, hash, helper, templates, context) {
 
-
-export default function invokeHelper(morph, env, scope, visitor, _params, _hash, helper, templates, context) {
-  var params, hash;
-
-  if (typeof helper === 'function') {
-    params = getArrayValues(_params);
-    hash = getHashValues(_hash);
-    return { value: helper.call(context, params, hash, templates) };
-  } else if (helper.isLegacyViewHelper) {
+  if (helper.isLegacyViewHelper) {
     Ember.assert("You can only pass attributes (such as name=value) not bare " +
-                 "values to a helper for a View found in '" + helper.viewClass + "'", _params.length === 0);
+                 "values to a helper for a View found in '" + helper.viewClass + "'", params.length === 0);
 
-    env.hooks.keyword('view', morph, env, scope, [helper.viewClass], _hash, templates.template.raw, null, visitor);
+    env.hooks.keyword('view', morph, env, scope, [helper.viewClass], hash, templates.template.raw, null, visitor);
+    // Opts into a special mode for view helpers
     return { handled: true };
-  } else if (helper && helper.helperFunction) {
-    var helperFunc = helper.helperFunction;
-    return { value: helperFunc.call({}, _params, _hash, templates, env, scope) };
-  }
-}
-
-// We don't want to leak mutable cells into helpers, which
-// are pure functions that can only work with values.
-function getArrayValues(params) {
-  let out = [];
-  for (let i=0, l=params.length; i<l; i++) {
-    out.push(getValue(params[i]));
   }
 
-  return out;
-}
+  var helperStream = buildHelperStream(helper, params, hash, templates, env, scope, context);
 
-function getHashValues(hash) {
-  let out = {};
-  for (let prop in hash) {
-    out[prop] = getValue(hash[prop]);
+  // Ember.Helper helpers are pure values, thus linkable
+  if (helperStream.linkable) {
+    return { link: true, value: helperStream };
   }
 
-  return out;
+  // Legacy helpers are not linkable, they must run every rerender
+  return { value: helperStream.value() };
 }
diff --git a/packages/ember-htmlbars/lib/hooks/subexpr.js b/packages/ember-htmlbars/lib/hooks/subexpr.js
index 762183d3400..493ac113189 100644
--- a/packages/ember-htmlbars/lib/hooks/subexpr.js
+++ b/packages/ember-htmlbars/lib/hooks/subexpr.js
@@ -4,12 +4,8 @@
 */
 
 import lookupHelper from "ember-htmlbars/system/lookup-helper";
-import merge from "ember-metal/merge";
-import Stream from "ember-metal/streams/stream";
-import create from "ember-metal/platform/create";
+import { buildHelperStream } from "ember-htmlbars/system/invoke-helper";
 import {
-  readArray,
-  readHash,
   labelsFor,
   labelFor
 } from "ember-metal/streams/utils";
@@ -22,15 +18,20 @@ export default function subexpr(env, scope, helperName, params, hash) {
     return keyword(null, env, scope, params, hash, null, null);
   }
 
+  var label = labelForSubexpr(params, hash, helperName);
   var helper = lookupHelper(helperName, scope.self, env);
-  var invoker = function(params, hash) {
-    return env.hooks.invokeHelper(null, env, scope, null, params, hash, helper, { template: {}, inverse: {} }, undefined).value;
-  };
 
-  //Ember.assert("A helper named '"+helperName+"' could not be found", typeof helper === 'function');
+  var helperStream = buildHelperStream(helper, params, hash, { template: {}, inverse: {} }, env, scope, label);
 
-  var label = labelForSubexpr(params, hash, helperName);
-  return new SubexprStream(params, hash, invoker, label);
+  for (var i = 0, l = params.length; i < l; i++) {
+    helperStream.addDependency(params[i]);
+  }
+
+  for (var key in hash) {
+    helperStream.addDependency(hash[key]);
+  }
+
+  return helperStream;
 }
 
 function labelForSubexpr(params, hash, helperName) {
@@ -57,26 +58,3 @@ function labelsForHash(hash) {
 
   return out.join(" ");
 }
-
-function SubexprStream(params, hash, helper, label) {
-  this.init(label);
-  this.params = params;
-  this.hash = hash;
-  this.helper = helper;
-
-  for (var i = 0, l = params.length; i < l; i++) {
-    this.addDependency(params[i]);
-  }
-
-  for (var key in hash) {
-    this.addDependency(hash[key]);
-  }
-}
-
-SubexprStream.prototype = create(Stream.prototype);
-
-merge(SubexprStream.prototype, {
-  compute() {
-    return this.helper(readArray(this.params), readHash(this.hash));
-  }
-});
diff --git a/packages/ember-htmlbars/lib/main.js b/packages/ember-htmlbars/lib/main.js
index 68274f73698..0237ec353db 100644
--- a/packages/ember-htmlbars/lib/main.js
+++ b/packages/ember-htmlbars/lib/main.js
@@ -31,6 +31,7 @@ import legacyEachWithKeywordHelper from "ember-htmlbars/helpers/-legacy-each-wit
 import getHelper from "ember-htmlbars/helpers/-get";
 import htmlSafeHelper from "ember-htmlbars/helpers/-html-safe";
 import DOMHelper from "ember-htmlbars/system/dom-helper";
+import Helper, { helper as makeHelper } from "ember-htmlbars/helper";
 
 // importing adds template bootstrapping
 // initializer to enable embedded templates
@@ -70,3 +71,8 @@ Ember.HTMLBars = {
   registerPlugin: registerPlugin,
   DOMHelper
 };
+
+if (Ember.FEATURES.isEnabled('ember-htmlbars-helpers')) {
+  Helper.helper = makeHelper;
+  Ember.Helper = Helper;
+}
diff --git a/packages/ember-htmlbars/lib/streams/built-in-helper.js b/packages/ember-htmlbars/lib/streams/built-in-helper.js
new file mode 100644
index 00000000000..6f48eef32d5
--- /dev/null
+++ b/packages/ember-htmlbars/lib/streams/built-in-helper.js
@@ -0,0 +1,27 @@
+import Stream from "ember-metal/streams/stream";
+import create from "ember-metal/platform/create";
+import merge from "ember-metal/merge";
+import {
+  getArrayValues,
+  getHashValues
+} from "ember-htmlbars/streams/utils";
+
+export default function BuiltInHelperStream(helper, params, hash, templates, env, scope, context, label) {
+  this.init(label);
+  this.helper = helper;
+  this.params = params;
+  this.templates = templates;
+  this.env = env;
+  this.scope = scope;
+  this.hash = hash;
+  this.context = context;
+}
+
+BuiltInHelperStream.prototype = create(Stream.prototype);
+
+merge(BuiltInHelperStream.prototype, {
+  compute() {
+    // Using call and undefined is probably not needed, these are only internal
+    return this.helper.call(this.context, getArrayValues(this.params), getHashValues(this.hash), this.templates, this.env, this.scope);
+  }
+});
diff --git a/packages/ember-htmlbars/lib/streams/compat-helper.js b/packages/ember-htmlbars/lib/streams/compat-helper.js
new file mode 100644
index 00000000000..25cea3fe848
--- /dev/null
+++ b/packages/ember-htmlbars/lib/streams/compat-helper.js
@@ -0,0 +1,22 @@
+import Stream from "ember-metal/streams/stream";
+import create from "ember-metal/platform/create";
+import merge from "ember-metal/merge";
+
+export default function CompatHelperStream(helper, params, hash, templates, env, scope, label) {
+  this.init(label);
+  this.helper = helper.helperFunction;
+  this.params = params;
+  this.templates = templates;
+  this.env = env;
+  this.scope = scope;
+  this.hash = hash;
+}
+
+CompatHelperStream.prototype = create(Stream.prototype);
+
+merge(CompatHelperStream.prototype, {
+  compute() {
+    // Using call and undefined is probably not needed, these are only internal
+    return this.helper.call(undefined, this.params, this.hash, this.templates, this.env, this.scope);
+  }
+});
diff --git a/packages/ember-htmlbars/lib/streams/helper-factory.js b/packages/ember-htmlbars/lib/streams/helper-factory.js
new file mode 100644
index 00000000000..d871e667553
--- /dev/null
+++ b/packages/ember-htmlbars/lib/streams/helper-factory.js
@@ -0,0 +1,35 @@
+import Stream from "ember-metal/streams/stream";
+import create from "ember-metal/platform/create";
+import merge from "ember-metal/merge";
+import {
+  getArrayValues,
+  getHashValues
+} from "ember-htmlbars/streams/utils";
+
+export default function HelperFactoryStream(helperFactory, params, hash, label) {
+  this.init(label);
+  this.helperFactory = helperFactory;
+  this.params = params;
+  this.hash = hash;
+  this.linkable = true;
+  this.helper = null;
+}
+
+HelperFactoryStream.prototype = create(Stream.prototype);
+
+merge(HelperFactoryStream.prototype, {
+  compute() {
+    if (!this.helper) {
+      this.helper = this.helperFactory.create({ _stream: this });
+    }
+    return this.helper.compute(getArrayValues(this.params), getHashValues(this.hash));
+  },
+  deactivate() {
+    this.super$deactivate();
+    if (this.helper) {
+      this.helper.destroy();
+      this.helper = null;
+    }
+  },
+  super$deactivate: HelperFactoryStream.prototype.deactivate
+});
diff --git a/packages/ember-htmlbars/lib/streams/helper-instance.js b/packages/ember-htmlbars/lib/streams/helper-instance.js
new file mode 100644
index 00000000000..4bd52e161f1
--- /dev/null
+++ b/packages/ember-htmlbars/lib/streams/helper-instance.js
@@ -0,0 +1,23 @@
+import Stream from "ember-metal/streams/stream";
+import create from "ember-metal/platform/create";
+import merge from "ember-metal/merge";
+import {
+  getArrayValues,
+  getHashValues
+} from "ember-htmlbars/streams/utils";
+
+export default function HelperInstanceStream(helper, params, hash, label) {
+  this.init(label);
+  this.helper = helper;
+  this.params = params;
+  this.hash = hash;
+  this.linkable = true;
+}
+
+HelperInstanceStream.prototype = create(Stream.prototype);
+
+merge(HelperInstanceStream.prototype, {
+  compute() {
+    return this.helper.compute(getArrayValues(this.params), getHashValues(this.hash));
+  }
+});
diff --git a/packages/ember-htmlbars/lib/streams/utils.js b/packages/ember-htmlbars/lib/streams/utils.js
new file mode 100644
index 00000000000..6e1615f1193
--- /dev/null
+++ b/packages/ember-htmlbars/lib/streams/utils.js
@@ -0,0 +1,21 @@
+import getValue from "ember-htmlbars/hooks/get-value";
+
+// We don't want to leak mutable cells into helpers, which
+// are pure functions that can only work with values.
+export function getArrayValues(params) {
+  let out = [];
+  for (let i=0, l=params.length; i<l; i++) {
+    out.push(getValue(params[i]));
+  }
+
+  return out;
+}
+
+export function getHashValues(hash) {
+  let out = {};
+  for (let prop in hash) {
+    out[prop] = getValue(hash[prop]);
+  }
+
+  return out;
+}
diff --git a/packages/ember-htmlbars/lib/system/invoke-helper.js b/packages/ember-htmlbars/lib/system/invoke-helper.js
new file mode 100644
index 00000000000..a07cab0b830
--- /dev/null
+++ b/packages/ember-htmlbars/lib/system/invoke-helper.js
@@ -0,0 +1,17 @@
+import HelperInstanceStream from "ember-htmlbars/streams/helper-instance";
+import HelperFactoryStream from "ember-htmlbars/streams/helper-factory";
+import BuiltInHelperStream from "ember-htmlbars/streams/built-in-helper";
+import CompatHelperStream from "ember-htmlbars/streams/compat-helper";
+
+export function buildHelperStream(helper, params, hash, templates, env, scope, context, label) {
+  Ember.assert("Helpers may not be used in the block form, for example {{#my-helper}}{{/my-helper}}. Please use a component, or alternatively use the helper in combination with a built-in Ember helper, for example {{#if (my-helper)}}{{/if}}.", !helper.isHelperInstance || !helper.isHelperFactory && !templates.template.meta);
+  if (helper.isHelperFactory) {
+    return new HelperFactoryStream(helper, params, hash, label);
+  } else if (helper.isHelperInstance) {
+    return new HelperInstanceStream(helper, params, hash, label);
+  } else if (helper.helperFunction) {
+    return new CompatHelperStream(helper, params, hash, templates, env, scope, label);
+  } else {
+    return new BuiltInHelperStream(helper, params, hash, templates, env, scope, context, label);
+  }
+}
diff --git a/packages/ember-htmlbars/lib/system/lookup-helper.js b/packages/ember-htmlbars/lib/system/lookup-helper.js
index a86f3248ce3..0f738c376a4 100644
--- a/packages/ember-htmlbars/lib/system/lookup-helper.js
+++ b/packages/ember-htmlbars/lib/system/lookup-helper.js
@@ -5,13 +5,20 @@
 
 import Ember from "ember-metal/core";
 import Cache from "ember-metal/cache";
-import makeViewHelper from "ember-htmlbars/system/make-view-helper";
 import HandlebarsCompatibleHelper from "ember-htmlbars/compat/helper";
 
-export var ISNT_HELPER_CACHE = new Cache(1000, function(key) {
-  return key.indexOf('-') === -1;
+export var CONTAINS_DASH_CACHE = new Cache(1000, function(key) {
+  return key.indexOf('-') !== -1;
 });
 
+export function validateLazyHelperName(helperName, container, keywords) {
+  return container && CONTAINS_DASH_CACHE.get(helperName) && !(helperName in keywords);
+}
+
+function isLegacyBareHelper(helper) {
+  return helper && (!helper.isHelperFactory && !helper.isHelperInstance && !helper.isHTMLBars);
+}
+
 /**
   Used to lookup/resolve handlebars helpers. The lookup order is:
 
@@ -28,40 +35,21 @@ export var ISNT_HELPER_CACHE = new Cache(1000, function(key) {
 */
 export function findHelper(name, view, env) {
   var helper = env.helpers[name];
-  if (helper) {
-    return helper;
-  }
-
-  var container = env.container;
 
-  if (!container || ISNT_HELPER_CACHE.get(name)) {
-    return;
-  }
-
-  if (name in env.hooks.keywords) {
-    return;
-  }
-
-  var helperName = 'helper:' + name;
-  helper = container.lookup(helperName);
   if (!helper) {
-    var componentLookup = container.lookup('component-lookup:main');
-    Ember.assert("Could not find 'component-lookup:main' on the provided container," +
-                 " which is necessary for performing component lookups", componentLookup);
-
-    var Component = componentLookup.lookupFactory(name, container);
-    if (Component) {
-      helper = makeViewHelper(Component);
-      container._registry.register(helperName, helper);
+    var container = env.container;
+    if (validateLazyHelperName(name, container, env.hooks.keywords)) {
+      var helperName = 'helper:' + name;
+      if (container._registry.has(helperName)) {
+        helper = container.lookupFactory(helperName);
+        if (isLegacyBareHelper(helper)) {
+          Ember.deprecate(`The helper "${name}" is a deprecated bare function helper. Please use Ember.Helper.build to wrap helper functions.`);
+          helper = new HandlebarsCompatibleHelper(helper);
+        }
+      }
     }
   }
 
-  if (helper && !helper.isHTMLBars) {
-    helper = new HandlebarsCompatibleHelper(helper);
-    container._registry.unregister(helperName);
-    container._registry.register(helperName, helper);
-  }
-
   return helper;
 }
 
diff --git a/packages/ember-htmlbars/lib/system/make_bound_helper.js b/packages/ember-htmlbars/lib/system/make_bound_helper.js
index aa2f6ed982b..e686263de8b 100644
--- a/packages/ember-htmlbars/lib/system/make_bound_helper.js
+++ b/packages/ember-htmlbars/lib/system/make_bound_helper.js
@@ -3,8 +3,7 @@
 @submodule ember-htmlbars
 */
 
-import Helper from "ember-htmlbars/system/helper";
-import { readHash, readArray } from "ember-metal/streams/utils";
+import { helper } from "ember-htmlbars/helper";
 
 /**
   Create a bound helper. Accepts a function that receives the ordered and hash parameters
@@ -50,8 +49,5 @@ import { readHash, readArray } from "ember-metal/streams/utils";
   @since 1.10.0
 */
 export default function makeBoundHelper(fn) {
-  return new Helper(function(params, hash, templates) {
-    Ember.assert("makeBoundHelper generated helpers do not support use with blocks", !templates.template.meta);
-    return fn(readArray(params), readHash(hash));
-  });
+  return helper(fn);
 }
diff --git a/packages/ember-htmlbars/lib/utils/is-component.js b/packages/ember-htmlbars/lib/utils/is-component.js
index 5aaf8deb442..deec618271a 100644
--- a/packages/ember-htmlbars/lib/utils/is-component.js
+++ b/packages/ember-htmlbars/lib/utils/is-component.js
@@ -3,7 +3,7 @@
 @submodule ember-htmlbars
 */
 
-import { ISNT_HELPER_CACHE } from "ember-htmlbars/system/lookup-helper";
+import { CONTAINS_DASH_CACHE } from "ember-htmlbars/system/lookup-helper";
 
 /*
  Given a path name, returns whether or not a component with that
@@ -12,7 +12,7 @@ import { ISNT_HELPER_CACHE } from "ember-htmlbars/system/lookup-helper";
 export default function isComponent(env, scope, path) {
   var container = env.container;
   if (!container) { return false; }
-  if (ISNT_HELPER_CACHE.get(path)) { return false; }
+  if (!CONTAINS_DASH_CACHE.get(path)) { return false; }
   return container._registry.has('component:' + path) ||
          container._registry.has('template:components/' + path);
 }
diff --git a/packages/ember-htmlbars/tests/compat/handlebars_get_test.js b/packages/ember-htmlbars/tests/compat/handlebars_get_test.js
index c592db6e459..201f280ed87 100644
--- a/packages/ember-htmlbars/tests/compat/handlebars_get_test.js
+++ b/packages/ember-htmlbars/tests/compat/handlebars_get_test.js
@@ -3,6 +3,7 @@ import EmberView from "ember-views/views/view";
 import handlebarsGet from "ember-htmlbars/compat/handlebars-get";
 import { Registry } from "ember-runtime/system/container";
 import { runAppend, runDestroy } from "ember-runtime/tests/utils";
+import HandlebarsCompatibleHelper from "ember-htmlbars/compat/helper";
 
 import EmberHandlebars from "ember-htmlbars/compat";
 
@@ -17,7 +18,6 @@ QUnit.module("ember-htmlbars: compat - Ember.Handlebars.get", {
     registry = new Registry();
     container = registry.container();
     registry.optionsForType('template', { instantiate: false });
-    registry.optionsForType('helper', { instantiate: false });
     registry.register('view:toplevel', EmberView.extend());
   },
 
@@ -34,13 +34,13 @@ QUnit.module("ember-htmlbars: compat - Ember.Handlebars.get", {
 QUnit.test('it can lookup a path from the current context', function() {
   expect(1);
 
-  registry.register('helper:handlebars-get', function(path, options) {
+  registry.register('helper:handlebars-get', new HandlebarsCompatibleHelper(function(path, options) {
     var context = options.contexts && options.contexts[0] || this;
 
     ignoreDeprecation(function() {
       equal(handlebarsGet(context, path, options), 'bar');
     });
-  });
+  }));
 
   view = EmberView.create({
     container: container,
@@ -56,13 +56,13 @@ QUnit.test('it can lookup a path from the current context', function() {
 QUnit.test('it can lookup a path from the current keywords', function() {
   expect(1);
 
-  registry.register('helper:handlebars-get', function(path, options) {
+  registry.register('helper:handlebars-get', new HandlebarsCompatibleHelper(function(path, options) {
     var context = options.contexts && options.contexts[0] || this;
 
     ignoreDeprecation(function() {
       equal(handlebarsGet(context, path, options), 'bar');
     });
-  });
+  }));
 
   view = EmberView.create({
     container: container,
@@ -80,13 +80,13 @@ QUnit.test('it can lookup a path from globals', function() {
 
   lookup.Blammo = { foo: 'blah' };
 
-  registry.register('helper:handlebars-get', function(path, options) {
+  registry.register('helper:handlebars-get', new HandlebarsCompatibleHelper(function(path, options) {
     var context = options.contexts && options.contexts[0] || this;
 
     ignoreDeprecation(function() {
       equal(handlebarsGet(context, path, options), lookup.Blammo.foo);
     });
-  });
+  }));
 
   view = EmberView.create({
     container: container,
@@ -100,13 +100,13 @@ QUnit.test('it can lookup a path from globals', function() {
 QUnit.test('it raises a deprecation warning on use', function() {
   expect(1);
 
-  registry.register('helper:handlebars-get', function(path, options) {
+  registry.register('helper:handlebars-get', new HandlebarsCompatibleHelper(function(path, options) {
     var context = options.contexts && options.contexts[0] || this;
 
     expectDeprecation(function() {
       handlebarsGet(context, path, options);
     }, 'Usage of Ember.Handlebars.get is deprecated, use a Component or Ember.Handlebars.makeBoundHelper instead.');
-  });
+  }));
 
   view = EmberView.create({
     container: container,
diff --git a/packages/ember-htmlbars/tests/compat/helper_test.js b/packages/ember-htmlbars/tests/compat/helper_test.js
index 347fdc81522..87818f99726 100644
--- a/packages/ember-htmlbars/tests/compat/helper_test.js
+++ b/packages/ember-htmlbars/tests/compat/helper_test.js
@@ -11,6 +11,7 @@ import compile from "ember-template-compiler/system/compile";
 import { runAppend, runDestroy } from "ember-runtime/tests/utils";
 import Registry from "container/registry";
 import ComponentLookup from 'ember-views/component_lookup';
+import HandlebarsCompatibleHelper from "ember-htmlbars/compat/helper";
 
 var view, registry, container;
 
@@ -21,7 +22,6 @@ QUnit.module('ember-htmlbars: compat - Handlebars compatible helpers', {
     registry.optionsForType('component', { singleton: false });
     registry.optionsForType('view', { singleton: false });
     registry.optionsForType('template', { instantiate: false });
-    registry.optionsForType('helper', { instantiate: false });
     registry.register('component-lookup:main', ComponentLookup);
   },
   teardown() {
@@ -102,9 +102,9 @@ QUnit.test('has the correct options.data.view within a components layout', funct
   }));
 
   registry.register('template:components/foo-bar', compile('{{my-thing}}'));
-  registry.register('helper:my-thing', function(options) {
+  registry.register('helper:my-thing', new HandlebarsCompatibleHelper(function(options) {
     equal(options.data.view, component, 'passed in view should match the current component');
-  });
+  }));
 
   view = EmberView.create({
     container,
diff --git a/packages/ember-htmlbars/tests/compat/make-view-helper_test.js b/packages/ember-htmlbars/tests/compat/make-view-helper_test.js
index 90b5160cacd..5ee5aa4fedb 100644
--- a/packages/ember-htmlbars/tests/compat/make-view-helper_test.js
+++ b/packages/ember-htmlbars/tests/compat/make-view-helper_test.js
@@ -11,7 +11,6 @@ QUnit.module('ember-htmlbars: compat - makeViewHelper compat', {
   setup() {
     registry = new Registry();
     container = registry.container();
-    registry.optionsForType('helper', { instantiate: false });
   },
 
   teardown() {
diff --git a/packages/ember-htmlbars/tests/helpers/custom_helper_test.js b/packages/ember-htmlbars/tests/helpers/custom_helper_test.js
new file mode 100644
index 00000000000..b05e508ab04
--- /dev/null
+++ b/packages/ember-htmlbars/tests/helpers/custom_helper_test.js
@@ -0,0 +1,360 @@
+import Component from "ember-views/views/component";
+import Helper, { helper as makeHelper } from "ember-htmlbars/helper";
+import compile from "ember-template-compiler/system/compile";
+import { runAppend, runDestroy } from "ember-runtime/tests/utils";
+import Registry from "container/registry";
+import run from "ember-metal/run_loop";
+import ComponentLookup from "ember-views/component_lookup";
+
+let registry, container, component;
+
+QUnit.module('ember-htmlbars: custom app helpers', {
+  setup() {
+    registry = new Registry();
+    registry.optionsForType('template', { instantiate: false });
+    registry.optionsForType('helper', { singleton: false });
+    container = registry.container();
+  },
+
+  teardown() {
+    runDestroy(component);
+    runDestroy(container);
+    registry = container = component = null;
+  }
+});
+
+QUnit.test('dashed shorthand helper is resolved from container', function() {
+  var HelloWorld = makeHelper(function() {
+    return 'hello world';
+  });
+  registry.register('helper:hello-world', HelloWorld);
+  component = Component.extend({
+    container,
+    layout: compile('{{hello-world}}')
+  }).create();
+
+  runAppend(component);
+  equal(component.$().text(), 'hello world');
+});
+
+QUnit.test('dashed helper is resolved from container', function() {
+  var HelloWorld = Helper.extend({
+    compute() {
+      return 'hello world';
+    }
+  });
+  registry.register('helper:hello-world', HelloWorld);
+  component = Component.extend({
+    container,
+    layout: compile('{{hello-world}}')
+  }).create();
+
+  runAppend(component);
+  equal(component.$().text(), 'hello world');
+});
+
+QUnit.test('dashed helper can recompute a new value', function() {
+  var destroyCount = 0;
+  var count = 0;
+  var helper;
+  var HelloWorld = Helper.extend({
+    init() {
+      this._super(...arguments);
+      helper = this;
+    },
+    compute() {
+      return ++count;
+    },
+    destroy() {
+      destroyCount++;
+      this._super();
+    }
+  });
+  registry.register('helper:hello-world', HelloWorld);
+  component = Component.extend({
+    container,
+    layout: compile('{{hello-world}}')
+  }).create();
+
+  runAppend(component);
+  equal(component.$().text(), '1');
+  run(function() {
+    helper.recompute();
+  });
+  equal(component.$().text(), '2');
+  equal(destroyCount, 0, 'destroy is not called on recomputation');
+});
+
+QUnit.test('dashed shorthand helper is called for param changes', function() {
+  var count = 0;
+  var HelloWorld = makeHelper(function() {
+    return ++count;
+  });
+  registry.register('helper:hello-world', HelloWorld);
+  component = Component.extend({
+    container,
+    name: 'bob',
+    layout: compile('{{hello-world name}}')
+  }).create();
+
+  runAppend(component);
+  equal(component.$().text(), '1');
+  run(function() {
+    component.set('name', 'sal');
+  });
+  equal(component.$().text(), '2');
+});
+
+QUnit.test('dashed helper compute is called for param changes', function() {
+  var count = 0;
+  var createCount = 0;
+  var HelloWorld = Helper.extend({
+    init() {
+      this._super(...arguments);
+      // FIXME: Ideally, the helper instance does not need to be recreated
+      // for change of params.
+      createCount++;
+    },
+    compute() {
+      return ++count;
+    }
+  });
+  registry.register('helper:hello-world', HelloWorld);
+  component = Component.extend({
+    container,
+    name: 'bob',
+    layout: compile('{{hello-world name}}')
+  }).create();
+
+  runAppend(component);
+  equal(component.$().text(), '1');
+  run(function() {
+    component.set('name', 'sal');
+  });
+  equal(component.$().text(), '2');
+  equal(createCount, 1, 'helper is only created once');
+});
+
+QUnit.test('dashed shorthand helper receives params, hash', function() {
+  var params, hash;
+  var HelloWorld = makeHelper(function(_params, _hash) {
+    params = _params;
+    hash = _hash;
+  });
+  registry.register('helper:hello-world', HelloWorld);
+  component = Component.extend({
+    container,
+    name: 'bob',
+    layout: compile('{{hello-world name "rich" last="sam"}}')
+  }).create();
+
+  runAppend(component);
+
+  equal(params[0], 'bob', 'first argument is bob');
+  equal(params[1], 'rich', 'second argument is rich');
+  equal(hash.last, 'sam', 'hash.last argument is sam');
+});
+
+QUnit.test('dashed helper receives params, hash', function() {
+  var params, hash;
+  var HelloWorld = Helper.extend({
+    compute(_params, _hash) {
+      params = _params;
+      hash = _hash;
+    }
+  });
+  registry.register('helper:hello-world', HelloWorld);
+  component = Component.extend({
+    container,
+    name: 'bob',
+    layout: compile('{{hello-world name "rich" last="sam"}}')
+  }).create();
+
+  runAppend(component);
+
+  equal(params[0], 'bob', 'first argument is bob');
+  equal(params[1], 'rich', 'second argument is rich');
+  equal(hash.last, 'sam', 'hash.last argument is sam');
+});
+
+QUnit.test('dashed helper usable in subexpressions', function() {
+  var JoinWords = Helper.extend({
+    compute(params) {
+      return params.join(' ');
+    }
+  });
+  registry.register('helper:join-words', JoinWords);
+  component = Component.extend({
+    container,
+    layout: compile(
+      `{{join-words "Who"
+                   (join-words "overcomes" "by")
+                   "force"
+                   (join-words (join-words "hath overcome but" "half"))
+                   (join-words "his" (join-words "foe"))}}`)
+  }).create();
+
+  runAppend(component);
+
+  equal(component.$().text(),
+    'Who overcomes by force hath overcome but half his foe');
+});
+
+QUnit.test('dashed helper not usable with a block', function() {
+  var SomeHelper = makeHelper(function() {});
+  registry.register('helper:some-helper', SomeHelper);
+  component = Component.extend({
+    container,
+    layout: compile(`{{#some-helper}}{{/some-helper}}`)
+  }).create();
+
+  expectAssertion(function() {
+    runAppend(component);
+  }, /Helpers may not be used in the block form/);
+});
+
+QUnit.test('dashed helper is torn down', function() {
+  var destroyCalled = 0;
+  var SomeHelper = Helper.extend({
+    destroy() {
+      destroyCalled++;
+      this._super.apply(this, arguments);
+    },
+    compute() {
+      return 'must define a compute';
+    }
+  });
+  registry.register('helper:some-helper', SomeHelper);
+  component = Component.extend({
+    container,
+    layout: compile(`{{some-helper}}`)
+  }).create();
+
+  runAppend(component);
+  runDestroy(component);
+
+  equal(destroyCalled, 1, 'destroy called once');
+});
+
+QUnit.test('dashed helper used in subexpression can recompute', function() {
+  var helper;
+  var phrase = 'overcomes by';
+  var DynamicSegment = Helper.extend({
+    init() {
+      this._super(...arguments);
+      helper = this;
+    },
+    compute() {
+      return phrase;
+    }
+  });
+  var JoinWords = Helper.extend({
+    compute(params) {
+      return params.join(' ');
+    }
+  });
+  registry.register('helper:dynamic-segment', DynamicSegment);
+  registry.register('helper:join-words', JoinWords);
+  component = Component.extend({
+    container,
+    layout: compile(
+      `{{join-words "Who"
+                   (dynamic-segment)
+                   "force"
+                   (join-words (join-words "hath overcome but" "half"))
+                   (join-words "his" (join-words "foe"))}}`)
+  }).create();
+
+  runAppend(component);
+
+  equal(component.$().text(),
+    'Who overcomes by force hath overcome but half his foe');
+
+  phrase = 'believes his';
+  Ember.run(function() {
+    helper.recompute();
+  });
+
+  equal(component.$().text(),
+    'Who believes his force hath overcome but half his foe');
+});
+
+QUnit.test('dashed helper used in subexpression can recompute component', function() {
+  var helper;
+  var phrase = 'overcomes by';
+  var DynamicSegment = Helper.extend({
+    init() {
+      this._super(...arguments);
+      helper = this;
+    },
+    compute() {
+      return phrase;
+    }
+  });
+  var JoinWords = Helper.extend({
+    compute(params) {
+      return params.join(' ');
+    }
+  });
+  registry.register('component-lookup:main', ComponentLookup);
+  registry.register('component:some-component', Ember.Component.extend({
+    layout: compile('{{first}} {{second}} {{third}} {{fourth}} {{fifth}}')
+  }));
+  registry.register('helper:dynamic-segment', DynamicSegment);
+  registry.register('helper:join-words', JoinWords);
+  component = Component.extend({
+    container,
+    layout: compile(
+      `{{some-component first="Who"
+                   second=(dynamic-segment)
+                   third="force"
+                   fourth=(join-words (join-words "hath overcome but" "half"))
+                   fifth=(join-words "his" (join-words "foe"))}}`)
+  }).create();
+
+  runAppend(component);
+
+  equal(component.$().text(),
+    'Who overcomes by force hath overcome but half his foe');
+
+  phrase = 'believes his';
+  Ember.run(function() {
+    helper.recompute();
+  });
+
+  equal(component.$().text(),
+    'Who believes his force hath overcome but half his foe');
+});
+
+QUnit.test('dashed helper used in subexpression is destroyed', function() {
+  var destroyCount = 0;
+  var DynamicSegment = Helper.extend({
+    phrase: 'overcomes by',
+    compute() {
+      return this.phrase;
+    },
+    destroy() {
+      destroyCount++;
+      this._super(...arguments);
+    }
+  });
+  var JoinWords = makeHelper(function(params) {
+    return params.join(' ');
+  });
+  registry.register('helper:dynamic-segment', DynamicSegment);
+  registry.register('helper:join-words', JoinWords);
+  component = Component.extend({
+    container,
+    layout: compile(
+      `{{join-words "Who"
+                   (dynamic-segment)
+                   "force"
+                   (join-words (join-words "hath overcome but" "half"))
+                   (join-words "his" (join-words "foe"))}}`)
+  }).create();
+
+  runAppend(component);
+  runDestroy(component);
+
+  equal(destroyCount, 1, 'destroy is called after a view is destroyed');
+});
diff --git a/packages/ember-htmlbars/tests/helpers/unbound_test.js b/packages/ember-htmlbars/tests/helpers/unbound_test.js
index bea164776fc..58abf5e500e 100644
--- a/packages/ember-htmlbars/tests/helpers/unbound_test.js
+++ b/packages/ember-htmlbars/tests/helpers/unbound_test.js
@@ -482,7 +482,6 @@ QUnit.module("ember-htmlbars: {{#unbound}} helper -- Container Lookup", {
     Ember.lookup = lookup = { Ember: Ember };
     registry = new Registry();
     container = registry.container();
-    registry.optionsForType('helper', { instantiate: false });
   },
 
   teardown() {
diff --git a/packages/ember-htmlbars/tests/helpers/view_test.js b/packages/ember-htmlbars/tests/helpers/view_test.js
index 8f43f7541bd..77523bcc2b5 100644
--- a/packages/ember-htmlbars/tests/helpers/view_test.js
+++ b/packages/ember-htmlbars/tests/helpers/view_test.js
@@ -49,7 +49,6 @@ QUnit.module("ember-htmlbars: {{#view}} helper", {
     registry = new Registry();
     container = registry.container();
     registry.optionsForType('template', { instantiate: false });
-    registry.optionsForType('helper', { instantiate: false });
     registry.register('view:toplevel', EmberView.extend());
     registry.register('component-lookup:main', ComponentLookup);
   },
diff --git a/packages/ember-htmlbars/tests/integration/block_params_test.js b/packages/ember-htmlbars/tests/integration/block_params_test.js
index ae808b0acea..b25bcb1fa92 100644
--- a/packages/ember-htmlbars/tests/integration/block_params_test.js
+++ b/packages/ember-htmlbars/tests/integration/block_params_test.js
@@ -22,7 +22,6 @@ QUnit.module("ember-htmlbars: block params", {
     registry.optionsForType('component', { singleton: false });
     registry.optionsForType('view', { singleton: false });
     registry.optionsForType('template', { instantiate: false });
-    registry.optionsForType('helper', { instantiate: false });
     registry.register('component-lookup:main', ComponentLookup);
   },
 
diff --git a/packages/ember-htmlbars/tests/integration/component_element_id_test.js b/packages/ember-htmlbars/tests/integration/component_element_id_test.js
index 23989ecc73a..10a4f92cbce 100644
--- a/packages/ember-htmlbars/tests/integration/component_element_id_test.js
+++ b/packages/ember-htmlbars/tests/integration/component_element_id_test.js
@@ -14,7 +14,6 @@ QUnit.module('ember-htmlbars: component elementId', {
     registry.optionsForType('component', { singleton: false });
     registry.optionsForType('view', { singleton: false });
     registry.optionsForType('template', { instantiate: false });
-    registry.optionsForType('helper', { instantiate: false });
     registry.register('component-lookup:main', ComponentLookup);
   },
 
diff --git a/packages/ember-htmlbars/tests/integration/component_invocation_test.js b/packages/ember-htmlbars/tests/integration/component_invocation_test.js
index ff1763b5ffe..a48534016f3 100644
--- a/packages/ember-htmlbars/tests/integration/component_invocation_test.js
+++ b/packages/ember-htmlbars/tests/integration/component_invocation_test.js
@@ -17,7 +17,6 @@ function commonSetup() {
   registry.optionsForType('component', { singleton: false });
   registry.optionsForType('view', { singleton: false });
   registry.optionsForType('template', { instantiate: false });
-  registry.optionsForType('helper', { instantiate: false });
   registry.register('component-lookup:main', ComponentLookup);
 }
 
diff --git a/packages/ember-htmlbars/tests/integration/component_lifecycle_test.js b/packages/ember-htmlbars/tests/integration/component_lifecycle_test.js
index 9712a982174..91095e034d8 100644
--- a/packages/ember-htmlbars/tests/integration/component_lifecycle_test.js
+++ b/packages/ember-htmlbars/tests/integration/component_lifecycle_test.js
@@ -17,7 +17,6 @@ QUnit.module('component - lifecycle hooks', {
     registry.optionsForType('component', { singleton: false });
     registry.optionsForType('view', { singleton: false });
     registry.optionsForType('template', { instantiate: false });
-    registry.optionsForType('helper', { instantiate: false });
     registry.register('component-lookup:main', ComponentLookup);
 
     hooks = [];
diff --git a/packages/ember-htmlbars/tests/integration/mutable_binding_test.js b/packages/ember-htmlbars/tests/integration/mutable_binding_test.js
index c3eba82d37d..6995b93ad10 100644
--- a/packages/ember-htmlbars/tests/integration/mutable_binding_test.js
+++ b/packages/ember-htmlbars/tests/integration/mutable_binding_test.js
@@ -17,7 +17,6 @@ QUnit.module('component - mutable bindings', {
     registry.optionsForType('component', { singleton: false });
     registry.optionsForType('view', { singleton: false });
     registry.optionsForType('template', { instantiate: false });
-    registry.optionsForType('helper', { instantiate: false });
     registry.register('component-lookup:main', ComponentLookup);
   },
 
diff --git a/packages/ember-htmlbars/tests/integration/void-element-component-test.js b/packages/ember-htmlbars/tests/integration/void-element-component-test.js
index da442a2d1f2..a3adbb8c71d 100644
--- a/packages/ember-htmlbars/tests/integration/void-element-component-test.js
+++ b/packages/ember-htmlbars/tests/integration/void-element-component-test.js
@@ -14,7 +14,6 @@ QUnit.module('ember-htmlbars: components for void elements', {
     registry.optionsForType('component', { singleton: false });
     registry.optionsForType('view', { singleton: false });
     registry.optionsForType('template', { instantiate: false });
-    registry.optionsForType('helper', { instantiate: false });
     registry.register('component-lookup:main', ComponentLookup);
   },
 
diff --git a/packages/ember-htmlbars/tests/system/lookup-helper_test.js b/packages/ember-htmlbars/tests/system/lookup-helper_test.js
index c4d07c09ad7..928b2172c0e 100644
--- a/packages/ember-htmlbars/tests/system/lookup-helper_test.js
+++ b/packages/ember-htmlbars/tests/system/lookup-helper_test.js
@@ -1,7 +1,8 @@
 import lookupHelper, { findHelper } from "ember-htmlbars/system/lookup-helper";
 import ComponentLookup from "ember-views/component_lookup";
 import Registry from "container/registry";
-import Component from "ember-views/views/component";
+import Helper, { helper as makeHelper } from "ember-htmlbars/helper";
+import HandlebarsCompatibleHelper from "ember-htmlbars/compat/helper";
 
 function generateEnv(helpers, container) {
   return {
@@ -15,7 +16,6 @@ function generateContainer() {
   var registry = new Registry();
   var container = registry.container();
 
-  registry.optionsForType('helper', { instantiate: false });
   registry.register('component-lookup:main', ComponentLookup);
 
   return container;
@@ -64,16 +64,15 @@ QUnit.test('does a lookup in the container if the name contains a dash (and help
     container: container
   };
 
-  function someName() {}
-  someName.isHTMLBars = true;
+  var someName = Helper.extend();
   view.container._registry.register('helper:some-name', someName);
 
   var actual = lookupHelper('some-name', view, env);
 
-  equal(actual, someName, 'does not wrap provided function if `isHTMLBars` is truthy');
+  ok(someName.detect(actual), 'helper is an instance of the helper class');
 });
 
-QUnit.test('wraps helper from container in a Handlebars compat helper', function() {
+QUnit.test('looks up a shorthand helper in the container', function() {
   expect(2);
   var container = generateContainer();
   var env = generateEnv(null, container);
@@ -85,50 +84,31 @@ QUnit.test('wraps helper from container in a Handlebars compat helper', function
   function someName() {
     called = true;
   }
-  view.container._registry.register('helper:some-name', someName);
+  view.container._registry.register('helper:some-name', makeHelper(someName));
 
   var actual = lookupHelper('some-name', view, env);
 
-  ok(actual.isHTMLBars, 'wraps provided helper in an HTMLBars compatible helper');
+  ok(actual.isHelperInstance, 'is a helper');
 
-  var fakeParams = [];
-  var fakeHash = {};
-  var fakeOptions = {
-    morph: { update() { } },
-    template: {},
-    inverse: {}
-  };
-  var fakeEnv = { };
-  var fakeScope = { };
-  actual.helperFunction(fakeParams, fakeHash, fakeOptions, fakeEnv, fakeScope);
+  actual.compute([], {});
 
   ok(called, 'HTMLBars compatible wrapper is wraping the provided function');
 });
 
-QUnit.test('asserts if component-lookup:main cannot be found', function() {
-  var container = generateContainer();
-  var env = generateEnv(null, container);
-  var view = {
-    container: container
-  };
-
-  view.container._registry.unregister('component-lookup:main');
-
-  expectAssertion(function() {
-    lookupHelper('some-name', view, env);
-  }, 'Could not find \'component-lookup:main\' on the provided container, which is necessary for performing component lookups');
-});
-
-QUnit.test('registers a helper in the container if component is found', function() {
+QUnit.test('fails with a useful error when resolving a function', function() {
+  expect(2);
   var container = generateContainer();
   var env = generateEnv(null, container);
   var view = {
     container: container
   };
 
-  view.container._registry.register('component:some-name', Component);
-
-  lookupHelper('some-name', view, env);
+  function someName() {}
+  view.container._registry.register('helper:some-name', someName);
 
-  ok(view.container.lookup('helper:some-name'), 'new helper was registered');
+  var actual;
+  expectDeprecation(function() {
+    actual = lookupHelper('some-name', view, env);
+  }, /helper "some-name" is a deprecated bare function helper/);
+  ok(actual instanceof HandlebarsCompatibleHelper, 'function looks up as compat helper');
 });
diff --git a/packages/ember-htmlbars/tests/system/make_bound_helper_test.js b/packages/ember-htmlbars/tests/system/make_bound_helper_test.js
index 773a7fc1840..bdaee374480 100644
--- a/packages/ember-htmlbars/tests/system/make_bound_helper_test.js
+++ b/packages/ember-htmlbars/tests/system/make_bound_helper_test.js
@@ -21,7 +21,6 @@ QUnit.module("ember-htmlbars: makeBoundHelper", {
   setup() {
     registry = new Registry();
     container = registry.container();
-    registry.optionsForType('helper', { instantiate: false });
   },
 
   teardown() {
@@ -192,7 +191,7 @@ QUnit.test("bound helpers should not be invoked with blocks", function() {
 
   expectAssertion(function() {
     runAppend(view);
-  }, /makeBoundHelper generated helpers do not support use with blocks/i);
+  }, /Helpers may not be used in the block form/);
 });
 
 QUnit.test("shouldn't treat raw numbers as bound paths", function() {
diff --git a/packages/ember-htmlbars/tests/system/make_view_helper_test.js b/packages/ember-htmlbars/tests/system/make_view_helper_test.js
index 02c4ffbd8bf..08e4ff6b5ec 100644
--- a/packages/ember-htmlbars/tests/system/make_view_helper_test.js
+++ b/packages/ember-htmlbars/tests/system/make_view_helper_test.js
@@ -10,7 +10,6 @@ QUnit.module("ember-htmlbars: makeViewHelper", {
   setup() {
     registry = new Registry();
     container = registry.container();
-    registry.optionsForType('helper', { instantiate: false });
   },
   teardown() {
     runDestroy(view);
diff --git a/packages/ember-metal/lib/streams/key-stream.js b/packages/ember-metal/lib/streams/key-stream.js
index d7c217018c2..2dc1927a873 100644
--- a/packages/ember-metal/lib/streams/key-stream.js
+++ b/packages/ember-metal/lib/streams/key-stream.js
@@ -59,7 +59,7 @@ merge(KeyStream.prototype, {
 
     var object = this.sourceDep.getValue();
     if (object !== this.observedObject) {
-      this.deactivate();
+      this._clearObservedObject();
 
       if (object && typeof object === 'object') {
         addObserver(object, this.key, this, this.notify);
@@ -70,13 +70,16 @@ merge(KeyStream.prototype, {
 
   _super$deactivate: Stream.prototype.deactivate,
 
-  deactivate() {
-    this._super$deactivate();
-
+  _clearObservedObject() {
     if (this.observedObject) {
       removeObserver(this.observedObject, this.key, this, this.notify);
       this.observedObject = null;
     }
+  },
+
+  deactivate() {
+    this._super$deactivate();
+    this._clearObservedObject();
   }
 });
 
diff --git a/packages/ember-metal/lib/streams/stream.js b/packages/ember-metal/lib/streams/stream.js
index 9c317791a73..43a91a1c58f 100644
--- a/packages/ember-metal/lib/streams/stream.js
+++ b/packages/ember-metal/lib/streams/stream.js
@@ -180,7 +180,7 @@ Stream.prototype = {
 
   revalidate(value) {
     if (value !== this.observedProxy) {
-      this.deactivate();
+      this._clearObservedProxy();
 
       ProxyMixin = ProxyMixin || Ember.__loader.require('ember-runtime/mixins/-proxy').default;
 
@@ -191,13 +191,17 @@ Stream.prototype = {
     }
   },
 
-  deactivate() {
+  _clearObservedProxy() {
     if (this.observedProxy) {
       removeObserver(this.observedProxy, 'content', this, this.notify);
       this.observedProxy = null;
     }
   },
 
+  deactivate() {
+    this._clearObservedProxy();
+  },
+
   compute() {
     throw new Error("Stream error: compute not implemented");
   },
diff --git a/packages/ember-views/lib/component_lookup.js b/packages/ember-views/lib/component_lookup.js
index 6c4a3adcc13..ca643e3f081 100644
--- a/packages/ember-views/lib/component_lookup.js
+++ b/packages/ember-views/lib/component_lookup.js
@@ -1,13 +1,12 @@
 import Ember from 'ember-metal/core';
 import EmberObject from "ember-runtime/system/object";
-import { ISNT_HELPER_CACHE } from "ember-htmlbars/system/lookup-helper";
+import { CONTAINS_DASH_CACHE } from "ember-htmlbars/system/lookup-helper";
 
 export default EmberObject.extend({
   invalidName(name) {
-    var invalidName = ISNT_HELPER_CACHE.get(name);
-
-    if (invalidName) {
+    if (!CONTAINS_DASH_CACHE.get(name)) {
       Ember.assert(`You cannot use '${name}' as a component name. Component names must contain a hyphen.`);
+      return true;
     }
   },
 
diff --git a/packages/ember/tests/helpers/helper_registration_test.js b/packages/ember/tests/helpers/helper_registration_test.js
index 2d2cdb8ae7d..8bc4c22c4d8 100644
--- a/packages/ember/tests/helpers/helper_registration_test.js
+++ b/packages/ember/tests/helpers/helper_registration_test.js
@@ -1,6 +1,8 @@
 import "ember";
 
 import EmberHandlebars from "ember-htmlbars/compat";
+import HandlebarsCompatibleHelper from "ember-htmlbars/compat/helper";
+import Helper from "ember-htmlbars/helper";
 
 var compile, helpers, makeBoundHelper;
 compile = EmberHandlebars.compile;
@@ -56,13 +58,13 @@ var boot = function(callback) {
 };
 
 QUnit.test("Unbound dashed helpers registered on the container can be late-invoked", function() {
+  Ember.TEMPLATES.application = compile("<div id='wrapper'>{{x-borf}} {{x-borf 'YES'}}</div>");
+  let helper = new HandlebarsCompatibleHelper(function(val) {
+    return arguments.length > 1 ? val : "BORF";
+  });
 
-  Ember.TEMPLATES.application = compile("<div id='wrapper'>{{x-borf}} {{x-borf YES}}</div>");
-
-  boot(function() {
-    registry.register('helper:x-borf', function(val) {
-      return arguments.length > 1 ? val : "BORF";
-    });
+  boot(() => {
+    registry.register('helper:x-borf', helper);
   });
 
   equal(Ember.$('#wrapper').text(), "BORF YES", "The helper was invoked from the container");
@@ -121,3 +123,24 @@ QUnit.test("Undashed helpers registered on the container can not (presently) be
     });
   }, /A helper named 'omg' could not be found/);
 });
+
+QUnit.test("Helpers can receive injections", function() {
+  Ember.TEMPLATES.application = compile("<div id='wrapper'>{{full-name}}</div>");
+
+  var serviceCalled = false;
+  boot(function() {
+    registry.register('service:name-builder', Ember.Service.extend({
+      build() {
+        serviceCalled = true;
+      }
+    }));
+    registry.register('helper:full-name', Helper.extend({
+      nameBuilder: Ember.inject.service('name-builder'),
+      compute() {
+        this.get('nameBuilder').build();
+      }
+    }));
+  });
+
+  ok(serviceCalled, 'service was injected, method called');
+});