diff --git a/.packages b/.packages
index b459b60..fe03169 100644
--- a/.packages
+++ b/.packages
@@ -10,6 +10,7 @@
 analysis_server_client:pkg/analysis_server_client/lib
 analyzer:pkg/analyzer/lib
 analyzer_cli:pkg/analyzer_cli/lib
+analyzer_fe_comparison:pkg/analyzer_fe_comparison/lib
 analyzer_plugin:pkg/analyzer_plugin/lib
 args:third_party/pkg/args/lib
 async:third_party/pkg/async/lib
diff --git a/pkg/analyzer_fe_comparison/lib/comparison.dart b/pkg/analyzer_fe_comparison/lib/comparison.dart
new file mode 100644
index 0000000..03138b7
--- /dev/null
+++ b/pkg/analyzer_fe_comparison/lib/comparison.dart
@@ -0,0 +1,23 @@
+// Copyright (c) 2018, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:analyzer_fe_comparison/src/analyzer.dart';
+import 'package:analyzer_fe_comparison/src/comparison_node.dart';
+import 'package:analyzer_fe_comparison/src/kernel.dart';
+
+/// Compares the analyzer and kernel representations of a project, and prints
+/// the resulting diff.
+void compare(
+    String platformPath, String projectLibPath, String packagesFilePath) async {
+  ComparisonNode analyzerNode = await driveAnalyzer(projectLibPath);
+  var packagesFileUri = Uri.file(packagesFilePath);
+  var inputs = <Uri>[];
+  for (var library in analyzerNode.children) {
+    inputs.add(Uri.parse(library.text));
+  }
+  var platformUri = Uri.file(platformPath);
+  ComparisonNode kernelNode =
+      await driveKernel(inputs, packagesFileUri, platformUri);
+  print(ComparisonNode.diff(kernelNode, analyzerNode));
+}
diff --git a/pkg/analyzer_fe_comparison/lib/src/analyzer.dart b/pkg/analyzer_fe_comparison/lib/src/analyzer.dart
new file mode 100644
index 0000000..0fa04da
--- /dev/null
+++ b/pkg/analyzer_fe_comparison/lib/src/analyzer.dart
@@ -0,0 +1,88 @@
+// Copyright (c) 2018, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:async';
+
+import 'package:analyzer/dart/analysis/analysis_context_collection.dart';
+import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/visitor.dart';
+import 'package:analyzer/src/generated/source.dart' show SourceKind;
+import 'package:analyzer_fe_comparison/src/comparison_node.dart';
+
+/// Analyzes the project located at [libPath] using the analyzer, and returns a
+/// [ComparisonNode] representing it.
+Future<ComparisonNode> driveAnalyzer(String libPath) async {
+  var visitor = _AnalyzerVisitor();
+  var contextCollection = AnalysisContextCollection(includedPaths: [libPath]);
+  var contexts = contextCollection.contexts;
+  if (contexts.length != 1) {
+    throw new StateError('Expected exactly one context');
+  }
+  var context = contexts[0];
+  var session = context.currentSession;
+  var uriConverter = session.uriConverter;
+  var contextRoot = context.contextRoot;
+  var libraryNodes = <ComparisonNode>[];
+  for (var filePath in contextRoot.analyzedFiles()) {
+    var kind = await session.getSourceKind(filePath);
+    if (kind == SourceKind.LIBRARY) {
+      var importUri = uriConverter.pathToUri(filePath);
+      var libraryElement = await session.getLibraryByUri(importUri.toString());
+      var childNodes = <ComparisonNode>[];
+      if (libraryElement.name.isNotEmpty) {
+        childNodes.add(ComparisonNode('name=${libraryElement.name}'));
+      }
+      for (var compilationUnit in libraryElement.units) {
+        var unitResult =
+            await session.getResolvedAst(compilationUnit.source.fullName);
+        for (var astNode in unitResult.unit.declarations) {
+          var childNode = astNode.accept(visitor);
+          if (childNode != null) {
+            childNodes.add(childNode);
+          }
+        }
+      }
+      libraryNodes.add(ComparisonNode.sorted(importUri.toString(), childNodes));
+    }
+  }
+  return ComparisonNode.sorted('Component', libraryNodes);
+}
+
+/// Visitor for serializing the contents of an analyzer AST into
+/// ComparisonNodes.
+class _AnalyzerVisitor extends UnifyingAstVisitor<ComparisonNode> {
+  @override
+  ComparisonNode visitClassDeclaration(ClassDeclaration node) {
+    return ComparisonNode('Class ${node.name.name}');
+  }
+
+  @override
+  ComparisonNode visitEnumDeclaration(EnumDeclaration node) {
+    return ComparisonNode('Enum ${node.name.name}');
+  }
+
+  @override
+  ComparisonNode visitFunctionDeclaration(FunctionDeclaration node) {
+    // TODO(paulberry)
+    return null;
+  }
+
+  @override
+  ComparisonNode visitFunctionTypeAlias(FunctionTypeAlias node) {
+    // TODO(paulberry)
+    return null;
+  }
+
+  @override
+  ComparisonNode visitNode(AstNode node) {
+    throw new UnimplementedError('AnalyzerVisitor: ${node.runtimeType}');
+  }
+
+  @override
+  ComparisonNode visitTopLevelVariableDeclaration(
+      TopLevelVariableDeclaration node) {
+    // TODO(paulberry)
+    return null;
+  }
+}
diff --git a/pkg/analyzer_fe_comparison/lib/src/comparison_node.dart b/pkg/analyzer_fe_comparison/lib/src/comparison_node.dart
new file mode 100644
index 0000000..50e1441c
--- /dev/null
+++ b/pkg/analyzer_fe_comparison/lib/src/comparison_node.dart
@@ -0,0 +1,133 @@
+// Copyright (c) 2018, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:math';
+
+/// [ComparisonNode] defines a simple tree structure that can be used to compare
+/// two representations of Dart code.
+///
+/// Each node contains a textual string and a list of child nodes.
+class ComparisonNode {
+  final String text;
+  final List<ComparisonNode> children;
+
+  ComparisonNode(this.text, [List<ComparisonNode> children])
+      : children = children ?? <ComparisonNode>[];
+
+  factory ComparisonNode.sorted(
+          String text, Iterable<ComparisonNode> children) =>
+      ComparisonNode(text, sortList(children));
+
+  @override
+  bool operator ==(Object other) {
+    if (other is ComparisonNode) {
+      if (text != other.text) return false;
+      if (children.length != other.children.length) return false;
+      for (int i = 0; i < children.length; i++) {
+        if (children[i] != other.children[i]) return false;
+      }
+      return true;
+    }
+    return false;
+  }
+
+  String toString({String newline: '\n'}) {
+    var lines = ['$text'];
+    var indentedNewline = '$newline  ';
+    for (var child in children) {
+      lines.add(child.toString(newline: indentedNewline));
+    }
+    return lines.join(indentedNewline);
+  }
+
+  static ComparisonNode diff(ComparisonNode a, ComparisonNode b) {
+    String diffText;
+    if (a.text == b.text) {
+      diffText = '= ${a.text}';
+    } else {
+      diffText = 'x ${a.text} -> ${b.text}';
+    }
+    return ComparisonNode(diffText, diffLists(a.children, b.children));
+  }
+
+  static List<ComparisonNode> diffLists(
+      List<ComparisonNode> a, List<ComparisonNode> b) {
+    // Note: this is an O(n) "poor man's" diff algorithm; it produces optimal
+    // results if the incoming results are sorted by text or if there is just
+    // one contiguous hunk of differences.  Otherwise it may not find the
+    // shortest diff.  This should be sufficient for our purposes, since we are
+    // not expecting many diffs.
+
+    // We'll exclude common nodes at the beginning of both lists
+    var shorterLength = min(a.length, b.length);
+    var commonInitialNodes = 0;
+    while (commonInitialNodes < shorterLength &&
+        a[commonInitialNodes] == b[commonInitialNodes]) {
+      commonInitialNodes++;
+    }
+
+    // Fast exit if a == b
+    if (commonInitialNodes == a.length && a.length == b.length) {
+      return [];
+    }
+
+    // We'll exclude common nodes at the end of both lists (note: we don't want
+    // to overcount by re-testing the common nodes identified above)
+    var commonFinalNodes = 0;
+    while (commonInitialNodes + commonFinalNodes < shorterLength &&
+        a[a.length - commonFinalNodes - 1] ==
+            b[b.length - commonFinalNodes - 1]) {
+      commonFinalNodes++;
+    }
+
+    // Walk the remaining nodes starting at the first node that's different,
+    // matching up nodes by their text.
+    var aIndex = commonInitialNodes;
+    var bIndex = commonInitialNodes;
+    var aEnd = a.length - commonFinalNodes;
+    var bEnd = b.length - commonFinalNodes;
+    var result = <ComparisonNode>[];
+    while (aIndex < aEnd && bIndex < bEnd) {
+      var comparisonResult = a[aIndex].text.compareTo(b[bIndex].text);
+      if (comparisonResult < 0) {
+        // a[aIndex].text sorts before b[bIndex].text.  Assume that this means
+        // a[aIndex] was removed.
+        result.add(diff(a[aIndex++], ComparisonNode('(removed)')));
+      } else if (comparisonResult > 0) {
+        // b[bIndex].text sorts before a[aIndex].text.  Assume that this means
+        // b[bIndex] was added.
+        result.add(diff(ComparisonNode('(added)'), b[bIndex++]));
+      } else {
+        // a[aIndex].text matches b[bIndex].text, so diff the nodes.
+        var difference = diff(a[aIndex++], b[bIndex++]);
+        if (difference.text.startsWith('=') && difference.children.isEmpty) {
+          // Nodes are identical, so don't add anything
+        } else {
+          result.add(difference);
+        }
+      }
+    }
+
+    // Deal with any nodes left over.
+    while (aIndex < aEnd) {
+      result.add(diff(a[aIndex++], ComparisonNode('(removed)')));
+    }
+    while (bIndex < bEnd) {
+      result.add(diff(ComparisonNode('(added)'), b[bIndex++]));
+    }
+
+    // If we get here and we haven't added any nodes, something has gone wrong.
+    if (result.isEmpty) {
+      throw StateError('Diff produced empty diff for non-matching lists');
+    }
+
+    return result;
+  }
+
+  static List<ComparisonNode> sortList(Iterable<ComparisonNode> nodes) {
+    var result = nodes.toList();
+    result.sort((a, b) => a.text.compareTo(b.text));
+    return result;
+  }
+}
diff --git a/pkg/analyzer_fe_comparison/lib/src/kernel.dart b/pkg/analyzer_fe_comparison/lib/src/kernel.dart
new file mode 100644
index 0000000..9be002b
--- /dev/null
+++ b/pkg/analyzer_fe_comparison/lib/src/kernel.dart
@@ -0,0 +1,79 @@
+// Copyright (c) 2018, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:async';
+
+import 'package:analyzer_fe_comparison/src/comparison_node.dart';
+import 'package:front_end/src/api_prototype/compiler_options.dart';
+import 'package:front_end/src/api_prototype/kernel_generator.dart';
+import 'package:front_end/src/api_prototype/standard_file_system.dart';
+import 'package:kernel/ast.dart';
+import 'package:kernel/target/targets.dart';
+
+/// Compiles the given [inputs] to kernel using the front_end, and returns a
+/// [ComparisonNode] representing them.
+Future<ComparisonNode> driveKernel(
+    List<Uri> inputs, Uri packagesFileUri, Uri platformUri) async {
+  var targetFlags = TargetFlags(strongMode: true, syncAsync: true);
+  var target = NoneTarget(targetFlags);
+  var fileSystem = StandardFileSystem.instance;
+
+  var compilerOptions = CompilerOptions()
+    ..fileSystem = fileSystem
+    ..packagesFileUri = packagesFileUri
+    ..sdkSummary = platformUri
+    ..strongMode = true
+    ..target = target
+    ..throwOnErrorsForDebugging = true
+    ..embedSourceText = false;
+
+  var component = await kernelForComponent(inputs, compilerOptions);
+  return component.accept(new _KernelVisitor(inputs.toSet()));
+}
+
+/// Visitor for serializing a kernel representation of a program into
+/// ComparisonNodes.
+class _KernelVisitor extends TreeVisitor<ComparisonNode> {
+  final Set<Uri> _inputs;
+
+  _KernelVisitor(this._inputs);
+
+  @override
+  ComparisonNode defaultTreeNode(TreeNode node) {
+    throw new UnimplementedError('KernelVisitor: ${node.runtimeType}');
+  }
+
+  @override
+  ComparisonNode visitClass(Class class_) {
+    if (class_.isAnonymousMixin) return null;
+    var kind = class_.isEnum ? 'Enum' : 'Class';
+    // TODO(paulberry): handle fields from Class
+    return ComparisonNode('$kind ${class_.name}');
+  }
+
+  @override
+  ComparisonNode visitComponent(Component component) {
+    return ComparisonNode.sorted(
+        'Component',
+        component.libraries
+            .where((library) => _inputs.contains(library.importUri))
+            .map<ComparisonNode>((library) => library.accept(this)));
+  }
+
+  @override
+  ComparisonNode visitLibrary(Library library) {
+    var children = <ComparisonNode>[];
+    if (library.name != null) {
+      children.add(ComparisonNode('name=${library.name}'));
+    }
+    for (var class_ in library.classes) {
+      var childNode = class_.accept(this);
+      if (childNode != null) {
+        children.add(childNode);
+      }
+    }
+    // TODO(paulberry): handle more fields from Library
+    return ComparisonNode.sorted(library.importUri.toString(), children);
+  }
+}
diff --git a/pkg/analyzer_fe_comparison/pubspec.yaml b/pkg/analyzer_fe_comparison/pubspec.yaml
new file mode 100644
index 0000000..94e9893
--- /dev/null
+++ b/pkg/analyzer_fe_comparison/pubspec.yaml
@@ -0,0 +1,9 @@
+name: analyzer_fe_comparison
+version: 1.0.0
+author: Dart Team <misc@dartlang.org>
+description: Tool for comparing the behavior of the analyzer and the front end.
+homepage: https://github.com/dart-lang/sdk/tree/master/pkg/analyzer_fe_comparison
+environment:
+  sdk: '>=2.0.0-dev-48.0 <3.0.0'
+dependencies:
+  kernel: ^0.3.4
diff --git a/pkg/analyzer_fe_comparison/tool/compare_packages.dart b/pkg/analyzer_fe_comparison/tool/compare_packages.dart
new file mode 100644
index 0000000..efb0efe
--- /dev/null
+++ b/pkg/analyzer_fe_comparison/tool/compare_packages.dart
@@ -0,0 +1,33 @@
+// Copyright (c) 2018, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:io';
+
+import 'package:analyzer_fe_comparison/comparison.dart';
+import 'package:path/path.dart' as path;
+
+/// Compares the analyzer and front_end behavior when compiling a package.
+///
+/// Currently hardcoded to use the package "analyzer".
+main() async {
+  var scriptPath = Platform.script.toFilePath();
+  var sdkRepoPath =
+      path.normalize(path.join(path.dirname(scriptPath), '..', '..', '..'));
+  var buildPath = await _findBuildDir(sdkRepoPath, 'ReleaseX64');
+  var dillPath = path.join(buildPath, 'vm_platform_strong.dill');
+  var analyzerLibPath = path.join(sdkRepoPath, 'pkg', 'analyzer', 'lib');
+  var packagesFilePath = path.join(sdkRepoPath, '.packages');
+  compare(dillPath, analyzerLibPath, packagesFilePath);
+}
+
+Future<String> _findBuildDir(String sdkRepoPath, String targetName) async {
+  for (var subdirName in ['out', 'xcodebuild']) {
+    var candidatePath = path.join(sdkRepoPath, subdirName, targetName);
+    if (await new Directory(candidatePath).exists()) {
+      return candidatePath;
+    }
+  }
+  throw new StateError('Cannot find build directory');
+}