diff --git a/package.json b/package.json
index 58ddd8f7a..6412f1502 100644
--- a/package.json
+++ b/package.json
@@ -44,8 +44,8 @@
   },
   "homepage": "https://github.com/mgechev/codelyzer#readme",
   "devDependencies": {
-    "@angular/compiler": "^4.0.0-rc.5",
-    "@angular/core": "^4.0.0-rc.5",
+    "@angular/compiler": "^4.0.0",
+    "@angular/core": "^4.0.0",
     "@types/chai": "^3.4.33",
     "@types/less": "0.0.31",
     "@types/mocha": "^2.2.32",
@@ -63,7 +63,7 @@
     "ts-node": "1.2.2",
     "tslint": "^4.0.0",
     "typescript": "^2.1.4",
-    "zone.js": "^0.7.2"
+    "zone.js": "^0.8.4"
   },
   "peerDependencies": {
     "tslint": "^4.0.0",
diff --git a/src/angular/templates/basicTemplateAstVisitor.ts b/src/angular/templates/basicTemplateAstVisitor.ts
index d5e475d7f..63636e908 100644
--- a/src/angular/templates/basicTemplateAstVisitor.ts
+++ b/src/angular/templates/basicTemplateAstVisitor.ts
@@ -116,8 +116,7 @@ export class BasicTemplateAstVisitor extends SourceMappingVisitor implements ast
     element.directives.forEach(d => this.visit(d, context));
   }
 
-  visitReference(ast: ast.ReferenceAst, context: any): any {
-  }
+  visitReference(ast: ast.ReferenceAst, context: any): any {}
 
   visitVariable(ast: ast.VariableAst, context: any): any {
     this._variables.push(ast.name);
diff --git a/src/angular/templates/templateParser.ts b/src/angular/templates/templateParser.ts
index a0083d890..4ee1dbc25 100644
--- a/src/angular/templates/templateParser.ts
+++ b/src/angular/templates/templateParser.ts
@@ -1,9 +1,9 @@
+import { NO_ERRORS_SCHEMA, ViewEncapsulation } from '@angular/core';
 import * as compiler from '@angular/compiler';
 
 import { Config, DirectiveDeclaration } from '../config';
 import { SemVerDSL } from '../../util/ngVersion';
-import { NO_ERRORS_SCHEMA } from '@angular/core';
-import { ɵConsole } from '@angular/core';
+
 let refId = 0;
 
 const dummyMetadataFactory = (declaration: DirectiveDeclaration) => {
@@ -40,6 +40,12 @@ const dummyMetadataFactory = (declaration: DirectiveDeclaration) => {
   };
 };
 
+class Console {
+  log(message: string) {}
+  warn(message: string) {}
+}
+
+
 let defaultDirectives = [];
 
 export const parseTemplate = (template: string, directives: DirectiveDeclaration[] = []) => {
@@ -48,7 +54,7 @@ export const parseTemplate = (template: string, directives: DirectiveDeclaration
   const TemplateParser = <any>compiler.TemplateParser;
   const expressionParser = new compiler.Parser(new compiler.Lexer());
   const elementSchemaRegistry = new compiler.DomElementSchemaRegistry();
-  const ngConsole = new ɵConsole();
+  const ngConsole = new Console();
   const htmlParser =
       new compiler.I18NHtmlParser(new compiler.HtmlParser());
 
@@ -69,12 +75,12 @@ export const parseTemplate = (template: string, directives: DirectiveDeclaration
 
   // Make sure it works with 2.2.x & 2.3.x
   const summaryKind = ((compiler as any).CompileSummaryKind || {}).Template;
-  const templateMetadata: compiler.CompileTemplateMetadata = {
+  let templateMetadata: any = {
     encapsulation: 0,
     template: template,
-    isInline: false,
     templateUrl: '',
     styles: [],
+    isInline: true,
     styleUrls: [],
     ngContentSelectors: [],
     animations: [],
diff --git a/src/index.ts b/src/index.ts
index b4db7e62e..1e18c454b 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -18,4 +18,5 @@ export { Rule as UseInputPropertyDecoratorRule } from './useInputPropertyDecorat
 export { Rule as UseLifeCycleInterfaceRule } from './useLifeCycleInterfaceRule';
 export { Rule as UseOutputPropertyDecoratorRule } from './useOutputPropertyDecoratorRule';
 export { Rule as UsePipeTransformInterfaceRule } from './usePipeTransformInterfaceRule';
+export { Rule as TemplateToNgTemplateRule } from './templateToNgTemplateRule';
 export * from './angular/config';
diff --git a/src/templateToNgTemplateRule.ts b/src/templateToNgTemplateRule.ts
new file mode 100644
index 000000000..97e57af19
--- /dev/null
+++ b/src/templateToNgTemplateRule.ts
@@ -0,0 +1,83 @@
+import * as Lint from 'tslint';
+import * as ts from 'typescript';
+import {stringDistance} from './util/utils';
+import {getDeclaredProperties, getDeclaredMethods} from './util/classDeclarationUtils';
+import {Ng2Walker} from './angular/ng2Walker';
+import {RecursiveAngularExpressionVisitor} from './angular/templates/recursiveAngularExpressionVisitor';
+import * as e from '@angular/compiler/src/expression_parser/ast';
+import { EmbeddedTemplateAst, ElementAst } from '@angular/compiler';
+import { BasicTemplateAstVisitor } from './angular/templates/basicTemplateAstVisitor';
+import { Fix } from 'tslint';
+import SyntaxKind = require('./util/syntaxKind');
+
+const ErrorMessage = 'You should use <ng-template/> instead of <template/>';
+const TemplateStart = '<template';
+const TemplateEnd = '</template>';
+const TemplateEndRe = /<\/template>/i;
+
+const set = new Set<EmbeddedTemplateAst>();
+
+class TemplateToNgTemplateVisitor extends BasicTemplateAstVisitor {
+  private _prevClosing: number = 0;
+  private _fix: Fix;
+  private _visitedElements = new Set<EmbeddedTemplateAst>();
+
+  visitEmbeddedTemplate(element: EmbeddedTemplateAst, ctx: any) {
+    if (this._visitedElements.has(element)) {
+      return;
+    } else {
+      this._visitedElements.add(element);
+    }
+
+    const sp = element.sourceSpan;
+    const content = sp.start.file.content;
+    const subtemplate = content.substring(sp.start.offset, sp.end.offset);
+
+    if (subtemplate.startsWith(TemplateStart)) {
+      const replacement = this.createReplacement(sp.start.offset, TemplateStart.length, '<ng-template');
+      if (!this._fix) {
+        this._fix = this.createFix(replacement);
+      } else {
+        this._fix.replacements.push(replacement);
+      }
+      this.addFailure(this.createFailure(sp.start.offset, sp.end.offset - sp.start.offset, ErrorMessage, this._fix));
+    }
+
+    super.visitEmbeddedTemplate(element, ctx);
+
+    const subcontent = content.substring(this._prevClosing, content.length);
+    const matches = TemplateEndRe.exec(subcontent);
+    if (this._fix && matches && typeof matches.index === 'number') {
+      this._fix.replacements.push(this.createReplacement(matches.index + this._prevClosing, TemplateEnd.length, '</ng-template>'));
+      this._prevClosing = matches.index + this._prevClosing + TemplateEnd.length;
+      const rest = content.substring(this._prevClosing, content.length);
+      if (!TemplateEndRe.test(rest)) {
+        this._fix = null;
+        this._prevClosing = 0;
+        this._visitedElements = new Set();
+      }
+    }
+  }
+}
+
+export class Rule extends Lint.Rules.AbstractRule {
+  public static metadata: Lint.IRuleMetadata = {
+    ruleName: 'templates-use-public-rule',
+    type: 'functionality',
+    description: `Ensure that properties and methods accessed from the template are public.`,
+    rationale: `When Angular compiles the templates, it has to access these propertes from outside the class.`,
+    options: null,
+    optionsDescription: `Not configurable.`,
+    typescriptOnly: true,
+  };
+
+  static FAILURE: string = 'The %s "%s" that you\'re trying to access does not exist in the class declaration.';
+
+  public apply(sourceFile:ts.SourceFile): Lint.RuleFailure[] {
+    return this.applyWithWalker(
+        new Ng2Walker(sourceFile,
+            this.getOptions(), {
+              templateVisitorCtrl: TemplateToNgTemplateVisitor
+            }));
+  }
+}
diff --git a/test/templateToNgTemplate.spec.ts b/test/templateToNgTemplate.spec.ts
new file mode 100644
index 000000000..7adb88c27
--- /dev/null
+++ b/test/templateToNgTemplate.spec.ts
@@ -0,0 +1,282 @@
+import { assertSuccess, assertAnnotated, assertFailure } from './testHelper';
+import chai = require('chai');
+
+describe('templates-use-public', () => {
+  it('should skip elements with *-prefixed attr', () => {
+    let source = `
+      @Component({
+        selector: 'foobar',
+        template: '<section><div *ngIf="42"></div></section>'
+      })
+      class Test {}`;
+      assertSuccess('template-to-ng-template', source);
+  });
+
+  it('should detect templete elements', () => {
+    let source = `
+      @Component({
+        selector: 'foobar',
+        template: '<section><template [ngForOf]></template></div>'
+                            ~~~~~~~~~~~~~~~~~~~~
+      })
+      class Test {}`;
+      assertAnnotated({
+        ruleName: 'template-to-ng-template',
+        message: 'You should use <ng-template/> instead of <template/>',
+        source
+      });
+  });
+
+  it('should detect templete elements', () => {
+    let source = `
+      @Component({
+        selector: 'foobar',
+        template: '<section><template [ngForOf]><br></template></div>'
+                            ~~~~~~~~~~~~~~~~~~~~
+      })
+      class Test {}`;
+      assertAnnotated({
+        ruleName: 'template-to-ng-template',
+        message: 'You should use <ng-template/> instead of <template/>',
+        source
+      });
+  });
+
+  it('should detect templete elements', () => {
+    let source = `
+      @Component({
+        selector: 'foobar',
+        template: \`<section>
+          <template [ngForOf]><div/>
+          ~~~~~~~~~~~~~~~~~~~~
+          </template></div>\`
+      })
+      class Test {}`;
+      assertAnnotated({
+        ruleName: 'template-to-ng-template',
+        message: 'You should use <ng-template/> instead of <template/>',
+        source
+      });
+  });
+
+  describe('autofixes', () => {
+
+    it('should not autofix template suggar', () => {
+      let source = `
+      @Component({
+        selector: 'foobar',
+        template: '<section><div *ngIf="42"></div></section>'
+      })
+      class Test {}`;
+      assertSuccess('template-to-ng-template', source);
+    });
+
+    it('should fix template with no suggar', () => {
+      let source = `
+      @Component({
+        selector: 'foobar',
+        template: '<div></div><template></template><template></template>'
+      })
+      class Test {}`;
+      const failures = assertFailure('template-to-ng-template', source, {
+        message: 'You should use <ng-template/> instead of <template/>',
+          startPosition: {
+            line: 3,
+            character: 30
+          },
+          endPosition: {
+            line: 3,
+            character: 40
+          }
+        });
+      chai.expect(failures[0].hasFix()).to.eq(true);
+      const fixes = failures[0].getFix();
+      chai.expect(fixes.replacements.length).to.eq(4);
+      const reps = fixes.replacements;
+      chai.expect(reps[0].text).to.eq('<ng-template');
+      chai.expect(reps[1].text).to.eq('</ng-template>');
+      chai.expect(reps[2].text).to.eq('<ng-template');
+      chai.expect(reps[3].text).to.eq('</ng-template>');
+      chai.expect(reps[0].start).to.eq(78);
+      chai.expect(reps[0].end).to.eq(87);
+      chai.expect(reps[1].start).to.eq(88);
+      chai.expect(reps[1].end).to.eq(99);
+      chai.expect(reps[2].start).to.eq(99);
+      chai.expect(reps[2].end).to.eq(108);
+      chai.expect(reps[3].start).to.eq(109);
+      chai.expect(reps[3].end).to.eq(120);
+      const res = fixes.apply(source);
+      const expected = `
+      @Component({
+        selector: 'foobar',
+        template: '<div></div><ng-template></ng-template><ng-template></ng-template>'
+      })
+      class Test {}`;
+      chai.expect(res).to.eq(expected);
+    });
+
+    it('should fix template with no suggar & nested templates', () => {
+      let source = `
+      @Component({
+        selector: 'foobar',
+        template: '<div></div><template><template></template></template>'
+      })
+      class Test {}`;
+      const failures = assertFailure('template-to-ng-template', source, {
+        message: 'You should use <ng-template/> instead of <template/>',
+          startPosition: {
+            line: 3,
+            character: 30
+          },
+          endPosition: {
+            line: 3,
+            character: 40
+          }
+        });
+      chai.expect(failures[0].hasFix()).to.eq(true);
+      const fixes = failures[0].getFix();
+      chai.expect(fixes.replacements.length).to.eq(4);
+      const reps = fixes.replacements;
+      const res = fixes.apply(source);
+      const expected = `
+      @Component({
+        selector: 'foobar',
+        template: '<div></div><ng-template><ng-template></ng-template></ng-template>'
+      })
+      class Test {}`;
+      chai.expect(res).to.eq(expected);
+    });
+
+    it('should fix template with templates & suggar', () => {
+      let source = `
+      @Component({
+        selector: 'foobar',
+        template: \`
+          <div *ngIf="bar"></div>
+          <template>
+          </template>\`
+      })
+      class Test {}`;
+      const failures = assertFailure('template-to-ng-template', source, {
+        message: 'You should use <ng-template/> instead of <template/>',
+          startPosition: {
+            line: 5,
+            character: 10
+          },
+          endPosition: {
+            line: 5,
+            character: 20
+          }
+        });
+      chai.expect(failures[0].hasFix()).to.eq(true);
+      const fixes = failures[0].getFix();
+      chai.expect(fixes.replacements.length).to.eq(2);
+      const reps = fixes.replacements;
+      const res = fixes.apply(source);
+      const expected = `
+      @Component({
+        selector: 'foobar',
+        template: \`
+          <div *ngIf="bar"></div>
+          <ng-template>
+          </ng-template>\`
+      })
+      class Test {}`;
+      chai.expect(res).to.eq(expected);
+    });
+
+    it('should fix template with no suggar & nested templates & nested elements', () => {
+      let source = `
+      @Component({
+        selector: 'foobar',
+        template: \`
+          <template>
+            <template>
+              <div *ngIf="foo"></div>
+            </template>
+            <template>
+              <div><span>
+              </span></div>
+            </template>
+          </template>
+        \`
+      })
+      class Test {}`;
+      const failures = assertFailure('template-to-ng-template', source, {
+        message: 'You should use <ng-template/> instead of <template/>',
+          startPosition: {
+            line: 4,
+            character: 10
+          },
+          endPosition: {
+            line: 4,
+            character: 20
+          }
+        });
+      chai.expect(failures[0].hasFix()).to.eq(true);
+      const fixes = failures[0].getFix();
+      chai.expect(fixes.replacements.length).to.eq(6);
+      const reps = fixes.replacements;
+      const res = fixes.apply(source);
+      const expected = `
+      @Component({
+        selector: 'foobar',
+        template: \`
+          <ng-template>
+            <ng-template>
+              <div *ngIf="foo"></div>
+            </ng-template>
+            <ng-template>
+              <div><span>
+              </span></div>
+            </ng-template>
+          </ng-template>
+        \`
+      })
+      class Test {}`;
+      chai.expect(res).to.eq(expected);
+    });
+
+    it('should fix template with no suggar & nested templates & nested elements', () => {
+      let source = `
+      @Component({
+        selector: 'foobar',
+        template: \`
+          <div *ngIf="foo">
+            <template></template>
+          </div>
+        \`
+      })
+      class Test {}`;
+      const failures = assertFailure('template-to-ng-template', source, {
+        message: 'You should use <ng-template/> instead of <template/>',
+          startPosition: {
+            line: 5,
+            character: 12
+          },
+          endPosition: {
+            line: 5,
+            character: 22
+          }
+        });
+      chai.expect(failures[0].hasFix()).to.eq(true);
+      const fixes = failures[0].getFix();
+      chai.expect(fixes.replacements.length).to.eq(2);
+      const reps = fixes.replacements;
+      const res = fixes.apply(source);
+      const expected = `
+      @Component({
+        selector: 'foobar',
+        template: \`
+          <div *ngIf="foo">
+            <ng-template></ng-template>
+          </div>
+        \`
+      })
+      class Test {}`;
+      chai.expect(res).to.eq(expected);
+    });
+
+  });
+
+});
diff --git a/yarn.lock b/yarn.lock
index 0c96ac3ef..25263ead7 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -2,13 +2,13 @@
 # yarn lockfile v1
 
 
-"@angular/compiler@^4.0.0-rc.2":
-  version "4.0.0-rc.2"
-  resolved "https://registry.yarnpkg.com/@angular/compiler/-/compiler-4.0.0-rc.2.tgz#643e199e6792413f42cf149a9cf1672284787c11"
+"@angular/compiler@^4.0.0":
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/@angular/compiler/-/compiler-4.0.1.tgz#15721edb148167a2d83b6f9324817e658eac8280"
 
-"@angular/core@^4.0.0-rc.2":
-  version "4.0.0-rc.2"
-  resolved "https://registry.yarnpkg.com/@angular/core/-/core-4.0.0-rc.2.tgz#59535050e5d0e6141417186eee571296f8e9c3d0"
+"@angular/core@^4.0.0":
+  version "4.0.1"
+  resolved "https://registry.yarnpkg.com/@angular/core/-/core-4.0.1.tgz#0b110a001012076ea696460ccd922707bcdf51ba"
 
 "@types/chai@^3.4.33":
   version "3.4.34"
@@ -1725,6 +1725,6 @@ yargs@^4.7.1:
     y18n "^3.2.1"
     yargs-parser "^2.4.1"
 
-zone.js@^0.7.2:
-  version "0.7.2"
-  resolved "https://registry.yarnpkg.com/zone.js/-/zone.js-0.7.2.tgz#1a62b6be4b24d1b935e4566b0b4386b66966d1a7"
+zone.js@^0.8.4:
+  version "0.8.5"
+  resolved "https://registry.yarnpkg.com/zone.js/-/zone.js-0.8.5.tgz#7906e017482cbff4c3f079c5c34305ce941f5ba2"