diff --git a/packages/@ember/-internals/glimmer/index.ts b/packages/@ember/-internals/glimmer/index.ts
index 8e7f9456216..ae138e2e6c4 100644
--- a/packages/@ember/-internals/glimmer/index.ts
+++ b/packages/@ember/-internals/glimmer/index.ts
@@ -395,3 +395,4 @@ export { setComponentManager, getComponentManager } from './lib/utils/custom-com
 export { setModifierManager, getModifierManager } from './lib/utils/custom-modifier-manager';
 export { capabilities as modifierCapabilties } from './lib/modifiers/custom';
 export { isSerializationFirstNode } from './lib/utils/serialization-first-node-helpers';
+export { setComponentTemplate, getComponentTemplate } from './lib/utils/component-template';
diff --git a/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts b/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts
index b7a2b5a3bd4..0378589e97c 100644
--- a/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts
+++ b/packages/@ember/-internals/glimmer/lib/component-managers/curly.ts
@@ -583,7 +583,7 @@ export class CurlyComponentDefinition implements ComponentDefinition {
     public name: string,
     public ComponentClass: any,
     public handle: Option<VMHandle>,
-    public template?: OwnedTemplate,
+    public template: Option<OwnedTemplate>,
     args?: CurriedArgs
   ) {
     const layout = template && template.asLayout();
diff --git a/packages/@ember/-internals/glimmer/lib/environment.ts b/packages/@ember/-internals/glimmer/lib/environment.ts
index fda6bcae98b..65b9e3213fb 100644
--- a/packages/@ember/-internals/glimmer/lib/environment.ts
+++ b/packages/@ember/-internals/glimmer/lib/environment.ts
@@ -1,5 +1,5 @@
 import { OWNER, Owner } from '@ember/-internals/owner';
-import { constructStyleDeprecationMessage, lookupComponent } from '@ember/-internals/views';
+import { constructStyleDeprecationMessage } from '@ember/-internals/views';
 import { warn } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 import { Option, Simple } from '@glimmer/interfaces';
@@ -57,10 +57,6 @@ export default class Environment extends GlimmerEnvironment {
     return s;
   }
 
-  lookupComponent(name: string, meta: any) {
-    return lookupComponent(meta.owner, name, meta);
-  }
-
   toConditionalReference(reference: UpdatableReference): VersionedReference<boolean> {
     return ConditionalReference.create(reference);
   }
diff --git a/packages/@ember/-internals/glimmer/lib/resolver.ts b/packages/@ember/-internals/glimmer/lib/resolver.ts
index 60e48effa23..e1ae8935595 100644
--- a/packages/@ember/-internals/glimmer/lib/resolver.ts
+++ b/packages/@ember/-internals/glimmer/lib/resolver.ts
@@ -1,10 +1,11 @@
 import { privatize as P } from '@ember/-internals/container';
 import { ENV } from '@ember/-internals/environment';
-import { FactoryClass, LookupOptions, Owner } from '@ember/-internals/owner';
-import { lookupComponent, lookupPartial, OwnedTemplateMeta } from '@ember/-internals/views';
+import { Factory, FactoryClass, LookupOptions, Owner } from '@ember/-internals/owner';
+import { lookupPartial, OwnedTemplateMeta } from '@ember/-internals/views';
 import {
   EMBER_GLIMMER_ANGLE_BRACKET_BUILT_INS,
   EMBER_GLIMMER_FN_HELPER,
+  EMBER_GLIMMER_SET_COMPONENT_TEMPLATE,
   EMBER_MODULE_UNIFICATION,
 } from '@ember/canary-features';
 import { assert } from '@ember/debug';
@@ -48,6 +49,8 @@ import OnModifierManager from './modifiers/on';
 import { populateMacros } from './syntax';
 import { mountHelper } from './syntax/mount';
 import { outletHelper } from './syntax/outlet';
+import { Factory as TemplateFactory, OwnedTemplate } from './template';
+import { getComponentTemplate } from './utils/component-template';
 import { getModifierManager } from './utils/custom-modifier-manager';
 import { getManager } from './utils/managers';
 import { ClassBasedHelperReference, SimpleHelperReference } from './utils/references';
@@ -63,6 +66,117 @@ function makeOptions(moduleName: string, namespace?: string): LookupOptions {
   };
 }
 
+function componentFor(
+  name: string,
+  owner: Owner,
+  options?: LookupOptions
+): Option<Factory<{}, {}>> {
+  let fullName = `component:${name}`;
+  return owner.factoryFor(fullName, options) || null;
+}
+
+function layoutFor(name: string, owner: Owner, options?: LookupOptions): Option<OwnedTemplate> {
+  let templateFullName = `template:components/${name}`;
+
+  return owner.lookup(templateFullName, options) || null;
+}
+
+function lookupModuleUnificationComponentPair(
+  owner: Owner,
+  name: string,
+  options?: LookupOptions
+): Option<LookupResult> {
+  let localComponent = componentFor(name, owner, options);
+  let localLayout = layoutFor(name, owner, options);
+
+  let globalComponent = componentFor(name, owner);
+  let globalLayout = layoutFor(name, owner);
+
+  // TODO: we shouldn't have to recheck fallback, we should have a lookup that doesn't fallback
+  if (
+    localComponent !== null &&
+    globalComponent !== null &&
+    globalComponent.class === localComponent.class
+  ) {
+    localComponent = null;
+  }
+  if (
+    localLayout !== null &&
+    globalLayout !== null &&
+    localLayout.referrer.moduleName === globalLayout.referrer.moduleName
+  ) {
+    localLayout = null;
+  }
+
+  if (localComponent !== null || localLayout !== null) {
+    return { component: localComponent, layout: localLayout } as LookupResult;
+  } else if (globalComponent !== null || globalLayout !== null) {
+    return { component: globalComponent, layout: globalLayout } as LookupResult;
+  } else {
+    return null;
+  }
+}
+
+type LookupResult =
+  | {
+      component: Factory<{}, {}>;
+      layout: TemplateFactory;
+    }
+  | {
+      component: Factory<{}, {}>;
+      layout: null;
+    }
+  | {
+      component: null;
+      layout: TemplateFactory;
+    };
+
+function lookupComponentPair(
+  owner: Owner,
+  name: string,
+  options?: LookupOptions
+): Option<LookupResult> {
+  let component = componentFor(name, owner, options);
+
+  if (EMBER_GLIMMER_SET_COMPONENT_TEMPLATE) {
+    if (component !== null && component.class !== undefined) {
+      let layout = getComponentTemplate(component.class);
+
+      if (layout !== null) {
+        return { component, layout };
+      }
+    }
+  }
+
+  let layout = layoutFor(name, owner, options);
+
+  if (component === null && layout === null) {
+    return null;
+  } else {
+    return { component, layout } as LookupResult;
+  }
+}
+
+function lookupComponent(owner: Owner, name: string, options: LookupOptions): Option<LookupResult> {
+  if (options.source || options.namespace) {
+    if (EMBER_MODULE_UNIFICATION) {
+      return lookupModuleUnificationComponentPair(owner, name, options);
+    }
+
+    let pair = lookupComponentPair(owner, name, options);
+
+    if (pair !== null) {
+      return pair;
+    }
+  }
+
+  if (EMBER_MODULE_UNIFICATION) {
+    return lookupModuleUnificationComponentPair(owner, name);
+  }
+
+  return lookupComponentPair(owner, name);
+}
+
 interface IBuiltInHelpers {
   [name: string]: Helper | undefined;
 }
@@ -113,7 +227,6 @@ export default class RuntimeResolver implements IRuntimeResolver<OwnedTemplateMe
   private builtInModifiers: IBuiltInModifiers;
 
   private componentDefinitionCache: Map<object, ComponentDefinition | null> = new Map();
-  private customManagerCache: Map<string, ManagerDelegate<Opaque>> = new Map();
 
   public componentDefinitionCount = 0;
   public helperDefinitionCount = 0;
@@ -309,12 +422,18 @@ export default class RuntimeResolver implements IRuntimeResolver<OwnedTemplateMe
       name = parsed.name;
       namespace = parsed.namespace;
     }
-    let { layout, component } = lookupComponent(owner, name, makeOptions(moduleName, namespace));
+    let pair = lookupComponent(owner, name, makeOptions(moduleName, namespace));
+    if (pair === null) {
+      return null;
+    }
 
-    let key = component === undefined ? layout : component;
+    let layout: Option<OwnedTemplate> = null;
+    let key: object;
 
-    if (key === undefined) {
-      return null;
+    if (pair.component === null) {
+      key = layout = pair.layout!(owner);
+    } else {
+      key = pair.component;
     }
 
     let cachedComponentDefinition = this.componentDefinitionCache.get(key);
@@ -322,38 +441,43 @@ export default class RuntimeResolver implements IRuntimeResolver<OwnedTemplateMe
       return cachedComponentDefinition;
     }
 
+    if (layout === null && pair.layout !== null) {
+      layout = pair.layout(owner);
+    }
+
     let finalizer = _instrumentStart('render.getComponentDefinition', instrumentationPayload, name);
 
     let definition: Option<ComponentDefinition> = null;
 
-    if (layout !== undefined && component === undefined && ENV._TEMPLATE_ONLY_GLIMMER_COMPONENTS) {
-      definition = new TemplateOnlyComponentDefinition(layout(owner));
+    if (pair.component === null && ENV._TEMPLATE_ONLY_GLIMMER_COMPONENTS) {
+      definition = new TemplateOnlyComponentDefinition(layout!);
     }
 
-    if (component !== undefined && component.class !== undefined) {
-      let wrapper = getManager(component.class);
+    if (pair.component !== null) {
+      assert(`missing component class ${name}`, pair.component.class !== undefined);
+
+      let ComponentClass = pair.component.class!;
+      let wrapper = getManager(ComponentClass);
 
       if (wrapper !== null && wrapper.type === 'component') {
         let { factory } = wrapper;
 
         if (wrapper.internal) {
-          assert(`missing layout for internal component ${name}`, layout !== undefined);
+          assert(`missing layout for internal component ${name}`, pair.layout !== null);
 
           definition = new InternalComponentDefinition(
             factory(owner) as InternalComponentManager<Opaque>,
-            component.class,
-            layout!(owner)
+            ComponentClass as Factory<any, any>,
+            layout!
           );
         } else {
-          if (layout === undefined) {
-            layout = owner.lookup(P`template:components/-default`);
-          }
-
           definition = new CustomManagerDefinition(
             name,
-            component,
+            pair.component,
             factory(owner) as ManagerDelegate<Opaque>,
-            layout!(owner)
+            layout !== null
+              ? layout
+              : owner.lookup<TemplateFactory>(P`template:components/-default`)!(owner)
           );
         }
       }
@@ -362,9 +486,9 @@ export default class RuntimeResolver implements IRuntimeResolver<OwnedTemplateMe
     if (definition === null) {
       definition = new CurlyComponentDefinition(
         name,
-        component || owner.factoryFor(P`component:-default`),
+        pair.component || owner.factoryFor(P`component:-default`),
         null,
-        layout !== undefined ? layout(owner) : undefined
+        layout
       );
     }
 
@@ -372,15 +496,4 @@ export default class RuntimeResolver implements IRuntimeResolver<OwnedTemplateMe
     this.componentDefinitionCache.set(key, definition);
     return definition;
   }
-
-  _lookupComponentManager(owner: Owner, managerId: string): ManagerDelegate<Opaque> {
-    if (this.customManagerCache.has(managerId)) {
-      return this.customManagerCache.get(managerId)!;
-    }
-    let delegate = owner.lookup<ManagerDelegate<Opaque>>(`component-manager:${managerId}`);
-
-    this.customManagerCache.set(managerId, delegate);
-
-    return delegate;
-  }
 }
diff --git a/packages/@ember/-internals/glimmer/lib/template.ts b/packages/@ember/-internals/glimmer/lib/template.ts
index c585741562d..62bbd5091c9 100644
--- a/packages/@ember/-internals/glimmer/lib/template.ts
+++ b/packages/@ember/-internals/glimmer/lib/template.ts
@@ -32,7 +32,7 @@ export default function template(json: StaticTemplate): Factory {
 
     if (result === undefined) {
       counters.cacheMiss++;
-      let compiler: LazyCompiler<StaticTemplateMeta> = owner.lookup(TEMPLATE_COMPILER_MAIN);
+      let compiler = owner.lookup<LazyCompiler<StaticTemplateMeta>>(TEMPLATE_COMPILER_MAIN)!;
       result = glimmerFactory.create(compiler, { owner });
       cache.set(owner, result);
     } else {
diff --git a/packages/@ember/-internals/glimmer/lib/utils/component-template.ts b/packages/@ember/-internals/glimmer/lib/utils/component-template.ts
new file mode 100644
index 00000000000..8ff9754ff57
--- /dev/null
+++ b/packages/@ember/-internals/glimmer/lib/utils/component-template.ts
@@ -0,0 +1,39 @@
+import { toString } from '@ember/-internals/utils';
+import { assert } from '@ember/debug';
+import { Option } from '@glimmer/interfaces';
+import { Factory as TemplateFactory } from '../template';
+
+const TEMPLATES: WeakMap<object, TemplateFactory> = new WeakMap();
+
+const getPrototypeOf = Object.getPrototypeOf;
+
+export function setComponentTemplate(factory: TemplateFactory, obj: object) {
+  assert(
+    `Cannot call \`setComponentTemplate\` on \`${toString(obj)}\``,
+    obj !== null && (typeof obj === 'object' || typeof obj === 'function')
+  );
+
+  assert(
+    `Cannot call \`setComponentTemplate\` multiple times on the same class (\`${obj}\`)`,
+    !TEMPLATES.has(obj)
+  );
+
+  TEMPLATES.set(obj, factory);
+
+  return obj;
+}
+
+export function getComponentTemplate(obj: object): Option<TemplateFactory> {
+  let pointer = obj;
+  while (pointer !== undefined && pointer !== null) {
+    let template = TEMPLATES.get(pointer);
+
+    if (template !== undefined) {
+      return template;
+    }
+
+    pointer = getPrototypeOf(pointer);
+  }
+
+  return null;
+}
diff --git a/packages/@ember/-internals/glimmer/lib/utils/managers.ts b/packages/@ember/-internals/glimmer/lib/utils/managers.ts
index 267725385ae..9abdd6d78f2 100644
--- a/packages/@ember/-internals/glimmer/lib/utils/managers.ts
+++ b/packages/@ember/-internals/glimmer/lib/utils/managers.ts
@@ -1,7 +1,7 @@
 import { Owner } from '@ember/-internals/owner';
-import { Opaque, Option } from '@glimmer/interfaces';
+import { Option } from '@glimmer/interfaces';
 
-const MANAGERS: WeakMap<any, ManagerWrapper<Opaque>> = new WeakMap();
+const MANAGERS: WeakMap<object, ManagerWrapper<unknown>> = new WeakMap();
 
 const getPrototypeOf = Object.getPrototypeOf;
 
@@ -13,16 +13,18 @@ export interface ManagerWrapper<ManagerDelegate> {
   type: 'component' | 'modifier';
 }
 
-export function setManager<ManagerDelegate>(wrapper: ManagerWrapper<ManagerDelegate>, obj: any) {
+export function setManager<ManagerDelegate>(wrapper: ManagerWrapper<ManagerDelegate>, obj: object) {
   MANAGERS.set(obj, wrapper);
   return obj;
 }
 
-export function getManager<ManagerDelegate>(obj: any): Option<ManagerWrapper<ManagerDelegate>> {
+export function getManager<ManagerDelegate>(obj: object): Option<ManagerWrapper<ManagerDelegate>> {
   let pointer = obj;
   while (pointer !== undefined && pointer !== null) {
-    if (MANAGERS.has(pointer)) {
-      return MANAGERS.get(pointer) as ManagerWrapper<ManagerDelegate>;
+    let manager = MANAGERS.get(pointer);
+
+    if (manager !== undefined) {
+      return manager as ManagerWrapper<ManagerDelegate>;
     }
 
     pointer = getPrototypeOf(pointer);
diff --git a/packages/@ember/-internals/glimmer/tests/integration/application/engine-test.js b/packages/@ember/-internals/glimmer/tests/integration/application/engine-test.js
index 322e0f27109..953060821c8 100644
--- a/packages/@ember/-internals/glimmer/tests/integration/application/engine-test.js
+++ b/packages/@ember/-internals/glimmer/tests/integration/application/engine-test.js
@@ -313,8 +313,8 @@ moduleFor(
       this.assert.expect(1);
 
       let sharedLayout = compile(strip`
-      {{ambiguous-curlies}}
-    `);
+        {{ambiguous-curlies}}
+      `);
 
       let sharedComponent = Component.extend({
         layout: sharedLayout,
@@ -323,10 +323,10 @@ moduleFor(
       this.addTemplate(
         'application',
         strip`
-      <h1>Application</h1>
-      {{my-component ambiguous-curlies="Local Data!"}}
-      {{outlet}}
-    `
+          <h1>Application</h1>
+          {{my-component ambiguous-curlies="Local Data!"}}
+          {{outlet}}
+        `
       );
 
       this.add('component:my-component', sharedComponent);
@@ -344,17 +344,17 @@ moduleFor(
             this.register(
               'template:application',
               compile(strip`
-          <h1>Engine</h1>
-          {{my-component}}
-          {{outlet}}
-        `)
+                <h1>Engine</h1>
+                {{my-component}}
+                {{outlet}}
+              `)
             );
             this.register('component:my-component', sharedComponent);
             this.register(
               'template:components/ambiguous-curlies',
               compile(strip`
-          <p>Component!</p>
-        `)
+                <p>Component!</p>
+              `)
             );
           },
         })
diff --git a/packages/@ember/-internals/glimmer/tests/integration/components/component-template-test.js b/packages/@ember/-internals/glimmer/tests/integration/components/component-template-test.js
new file mode 100644
index 00000000000..ead2666701c
--- /dev/null
+++ b/packages/@ember/-internals/glimmer/tests/integration/components/component-template-test.js
@@ -0,0 +1,147 @@
+import { moduleFor, RenderingTestCase, runTask } from 'internal-test-helpers';
+
+import {
+  EMBER_GLIMMER_SET_COMPONENT_TEMPLATE,
+  EMBER_MODULE_UNIFICATION,
+} from '@ember/canary-features';
+
+import { Component, compile } from '../../utils/helpers';
+import { setComponentTemplate, getComponentTemplate } from '../../..';
+
+if (EMBER_GLIMMER_SET_COMPONENT_TEMPLATE) {
+  if (EMBER_MODULE_UNIFICATION) {
+    moduleFor(
+      'Components test: setComponentTemplate',
+      class extends RenderingTestCase {
+        '@skip setComponentTemplate does not work with module unification!'() {}
+      }
+    );
+  } else {
+    moduleFor(
+      'Components test: setComponentTemplate',
+      class extends RenderingTestCase {
+        '@test it basically works'() {
+          this.registerComponent('foo-bar', {
+            ComponentClass: setComponentTemplate(compile('hello'), Component.extend()),
+          });
+
+          this.render('<FooBar />');
+
+          this.assertComponentElement(this.firstChild, { content: 'hello' });
+
+          runTask(() => this.rerender());
+
+          this.assertComponentElement(this.firstChild, { content: 'hello' });
+        }
+
+        '@test it takes precedence over resolver'() {
+          this.registerComponent('foo-bar', {
+            ComponentClass: setComponentTemplate(compile('hello'), Component.extend()),
+            template: 'noooooo!',
+          });
+
+          this.render('<FooBar />');
+
+          this.assertComponentElement(this.firstChild, { content: 'hello' });
+
+          runTask(() => this.rerender());
+
+          this.assertComponentElement(this.firstChild, { content: 'hello' });
+        }
+
+        '@test calling it with primitives asserts'() {
+          expectAssertion(() => {
+            setComponentTemplate(compile('foo'), null);
+          }, /Cannot call `setComponentTemplate` on `null`/);
+
+          expectAssertion(() => {
+            setComponentTemplate(compile('foo'), undefined);
+          }, /Cannot call `setComponentTemplate` on `undefined`/);
+
+          expectAssertion(() => {
+            setComponentTemplate(compile('foo'), true);
+          }, /Cannot call `setComponentTemplate` on `true`/);
+
+          expectAssertion(() => {
+            setComponentTemplate(compile('foo'), false);
+          }, /Cannot call `setComponentTemplate` on `false`/);
+
+          expectAssertion(() => {
+            setComponentTemplate(compile('foo'), 123);
+          }, /Cannot call `setComponentTemplate` on `123`/);
+
+          expectAssertion(() => {
+            setComponentTemplate(compile('foo'), 'foo');
+          }, /Cannot call `setComponentTemplate` on `foo`/);
+
+          expectAssertion(() => {
+            setComponentTemplate(compile('foo'), Symbol('foo'));
+          }, /Cannot call `setComponentTemplate` on `Symbol\(foo\)`/);
+        }
+
+        '@test calling it twice on the same object asserts'() {
+          let Thing = setComponentTemplate(
+            compile('hello'),
+            Component.extend().reopenClass({
+              toString() {
+                return 'Thing';
+              },
+            })
+          );
+
+          expectAssertion(() => {
+            setComponentTemplate(compile('foo'), Thing);
+          }, /Cannot call `setComponentTemplate` multiple times on the same class \(`Thing`\)/);
+        }
+
+        '@test templates set with setComponentTemplate are inherited (EmberObject.extend())'() {
+          let Parent = setComponentTemplate(compile('hello'), Component.extend());
+
+          this.registerComponent('foo-bar', {
+            ComponentClass: Parent.extend(),
+          });
+
+          this.render('<FooBar />');
+
+          this.assertComponentElement(this.firstChild, { content: 'hello' });
+
+          runTask(() => this.rerender());
+
+          this.assertComponentElement(this.firstChild, { content: 'hello' });
+        }
+
+        '@test templates set with setComponentTemplate are inherited (native ES class extends)'() {
+          let Parent = setComponentTemplate(compile('hello'), Component.extend());
+
+          this.registerComponent('foo-bar', {
+            ComponentClass: class extends Parent {},
+          });
+
+          this.render('<FooBar />');
+
+          this.assertComponentElement(this.firstChild, { content: 'hello' });
+
+          runTask(() => this.rerender());
+
+          this.assertComponentElement(this.firstChild, { content: 'hello' });
+        }
+
+        '@test it can re-assign templates from another class'() {
+          let Foo = setComponentTemplate(compile('shared'), Component.extend());
+          let Bar = setComponentTemplate(getComponentTemplate(Foo), Component.extend());
+
+          this.registerComponent('foo', { ComponentClass: Foo });
+          this.registerComponent('bar', { ComponentClass: Bar });
+
+          this.render('<Foo />|<Bar />');
+
+          this.assertText('shared|shared');
+
+          runTask(() => this.rerender());
+
+          this.assertText('shared|shared');
+        }
+      }
+    );
+  }
+}
diff --git a/packages/@ember/-internals/owner/index.ts b/packages/@ember/-internals/owner/index.ts
index f2585f47c34..0c1f78d3168 100644
--- a/packages/@ember/-internals/owner/index.ts
+++ b/packages/@ember/-internals/owner/index.ts
@@ -26,8 +26,7 @@ export interface EngineInstanceOptions {
 }
 
 export interface Owner {
-  lookup<T>(fullName: string, options?: LookupOptions): T;
-  lookup(fullName: string, options?: LookupOptions): any;
+  lookup<T>(fullName: string, options?: LookupOptions): T | undefined;
   factoryFor<T, C>(fullName: string, options?: LookupOptions): Factory<T, C> | undefined;
   factoryFor(fullName: string, options?: LookupOptions): Factory<any, any> | undefined;
   buildChildEngineInstance<T>(name: string, options?: EngineInstanceOptions): T;
diff --git a/packages/@ember/-internals/views/index.d.ts b/packages/@ember/-internals/views/index.d.ts
index 6630631fb99..079c0f6e758 100644
--- a/packages/@ember/-internals/views/index.d.ts
+++ b/packages/@ember/-internals/views/index.d.ts
@@ -37,15 +37,6 @@ export function constructStyleDeprecationMessage(affectedStyle: any): string;
 
 export function hasPartial(name: string, owner: any): boolean;
 
-export function lookupComponent(
-  owner: Owner,
-  name: string,
-  options?: { source?: string }
-): {
-  layout: TemplateFactory | undefined;
-  component: Factory<any, any> | undefined;
-};
-
 export function lookupPartial(templateName: string, owner: Owner): TemplateFactory;
 
 export function getViewId(view: any): string;
diff --git a/packages/@ember/-internals/views/index.js b/packages/@ember/-internals/views/index.js
index 23a99099c34..7a2890e4eb2 100644
--- a/packages/@ember/-internals/views/index.js
+++ b/packages/@ember/-internals/views/index.js
@@ -27,5 +27,4 @@ export { default as ViewMixin } from './lib/mixins/view_support';
 export { default as ActionSupport } from './lib/mixins/action_support';
 export { MUTABLE_CELL } from './lib/compat/attrs';
 export { default as lookupPartial, hasPartial } from './lib/system/lookup_partial';
-export { default as lookupComponent } from './lib/utils/lookup-component';
 export { default as ActionManager } from './lib/system/action_manager';
diff --git a/packages/@ember/-internals/views/lib/utils/lookup-component.js b/packages/@ember/-internals/views/lib/utils/lookup-component.js
deleted file mode 100644
index 73949211918..00000000000
--- a/packages/@ember/-internals/views/lib/utils/lookup-component.js
+++ /dev/null
@@ -1,58 +0,0 @@
-import { EMBER_MODULE_UNIFICATION } from '@ember/canary-features';
-
-function lookupModuleUnificationComponentPair(componentLookup, owner, name, options) {
-  let localComponent = componentLookup.componentFor(name, owner, options);
-  let localLayout = componentLookup.layoutFor(name, owner, options);
-
-  let globalComponent = componentLookup.componentFor(name, owner);
-  let globalLayout = componentLookup.layoutFor(name, owner);
-
-  // TODO: we shouldn't have to recheck fallback, we should have a lookup that doesn't fallback
-  if (
-    localComponent !== undefined &&
-    globalComponent !== undefined &&
-    globalComponent.class === localComponent.class
-  ) {
-    localComponent = undefined;
-  }
-  if (
-    localLayout !== undefined &&
-    globalLayout !== undefined &&
-    localLayout.referrer.moduleName === globalLayout.referrer.moduleName
-  ) {
-    localLayout = undefined;
-  }
-
-  if (localLayout !== undefined || localComponent !== undefined) {
-    return { layout: localLayout, component: localComponent };
-  }
-
-  return { layout: globalLayout, component: globalComponent };
-}
-
-function lookupComponentPair(componentLookup, owner, name, options) {
-  if (EMBER_MODULE_UNIFICATION) {
-    return lookupModuleUnificationComponentPair(componentLookup, owner, name, options);
-  }
-
-  let component = componentLookup.componentFor(name, owner, options);
-  let layout = componentLookup.layoutFor(name, owner, options);
-
-  let result = { layout, component };
-
-  return result;
-}
-
-export default function lookupComponent(owner, name, options) {
-  let componentLookup = owner.lookup('component-lookup:main');
-
-  if (options && (options.source || options.namespace)) {
-    let localResult = lookupComponentPair(componentLookup, owner, name, options);
-
-    if (localResult.component || localResult.layout) {
-      return localResult;
-    }
-  }
-
-  return lookupComponentPair(componentLookup, owner, name);
-}
diff --git a/packages/@ember/canary-features/index.ts b/packages/@ember/canary-features/index.ts
index 6b1e3594d8d..ff6570bd84e 100644
--- a/packages/@ember/canary-features/index.ts
+++ b/packages/@ember/canary-features/index.ts
@@ -23,6 +23,7 @@ export const DEFAULT_FEATURES = {
   EMBER_GLIMMER_FN_HELPER: true,
   EMBER_CUSTOM_COMPONENT_ARG_PROXY: null,
   EMBER_FRAMEWORK_OBJECT_OWNER_ARGUMENT: true,
+  EMBER_GLIMMER_SET_COMPONENT_TEMPLATE: null,
 };
 
 /**
@@ -89,3 +90,6 @@ export const EMBER_CUSTOM_COMPONENT_ARG_PROXY = featureValue(
 export const EMBER_FRAMEWORK_OBJECT_OWNER_ARGUMENT = featureValue(
   FEATURES.EMBER_FRAMEWORK_OBJECT_OWNER_ARGUMENT
 );
+export const EMBER_GLIMMER_SET_COMPONENT_TEMPLATE = featureValue(
+  FEATURES.EMBER_GLIMMER_SET_COMPONENT_TEMPLATE
+);
diff --git a/packages/ember/index.js b/packages/ember/index.js
index d5e4c913632..c42f51f7c2e 100644
--- a/packages/ember/index.js
+++ b/packages/ember/index.js
@@ -7,7 +7,12 @@ import { Registry, Container } from '@ember/-internals/container';
 import * as instrumentation from '@ember/instrumentation';
 import { deleteMeta, meta } from '@ember/-internals/meta';
 import * as metal from '@ember/-internals/metal';
-import { FEATURES, isEnabled, EMBER_FRAMEWORK_OBJECT_OWNER_ARGUMENT } from '@ember/canary-features';
+import {
+  FEATURES,
+  isEnabled,
+  EMBER_FRAMEWORK_OBJECT_OWNER_ARGUMENT,
+  EMBER_GLIMMER_SET_COMPONENT_TEMPLATE,
+} from '@ember/canary-features';
 import * as EmberDebug from '@ember/debug';
 import { assert, deprecate } from '@ember/debug';
 import Backburner from 'backburner';
@@ -113,6 +118,8 @@ import {
   isSerializationFirstNode,
   setModifierManager,
   modifierCapabilties,
+  setComponentTemplate,
+  getComponentTemplate,
 } from '@ember/-internals/glimmer';
 // eslint-disable-next-line import/no-unresolved
 import VERSION from './version';
@@ -530,6 +537,10 @@ Ember._setComponentManager = setComponentManager;
 Ember._componentManagerCapabilities = capabilities;
 Ember._setModifierManager = setModifierManager;
 Ember._modifierManagerCapabilties = modifierCapabilties;
+if (EMBER_GLIMMER_SET_COMPONENT_TEMPLATE) {
+  Ember._getComponentTemplate = getComponentTemplate;
+  Ember._setComponentTemplate = setComponentTemplate;
+}
 Ember.Handlebars = {
   template,
   Utils: {
diff --git a/packages/ember/tests/reexports_test.js b/packages/ember/tests/reexports_test.js
index 16f8b41daff..54b5dac153e 100644
--- a/packages/ember/tests/reexports_test.js
+++ b/packages/ember/tests/reexports_test.js
@@ -3,6 +3,7 @@ import {
   FEATURES,
   EMBER_NATIVE_DECORATOR_SUPPORT,
   EMBER_METAL_TRACKED_PROPERTIES,
+  EMBER_GLIMMER_SET_COMPONENT_TEMPLATE,
 } from '@ember/canary-features';
 import { confirmExport } from 'internal-test-helpers';
 import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
@@ -225,6 +226,12 @@ let allExports = [
   ['String.htmlSafe', '@ember/-internals/glimmer', 'htmlSafe'],
   ['_setComponentManager', '@ember/-internals/glimmer', 'setComponentManager'],
   ['_componentManagerCapabilities', '@ember/-internals/glimmer', 'capabilities'],
+  EMBER_GLIMMER_SET_COMPONENT_TEMPLATE
+    ? ['_setComponentTemplate', '@ember/-internals/glimmer', 'setComponentTemplate']
+    : null,
+  EMBER_GLIMMER_SET_COMPONENT_TEMPLATE
+    ? ['_getComponentTemplate', '@ember/-internals/glimmer', 'getComponentTemplate']
+    : null,
 
   // @ember/-internals/runtime
   ['A', '@ember/-internals/runtime'],