diff --git a/.travis.yml b/.travis.yml
index 477740d..2b14c55 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -17,6 +17,7 @@
 # snapshot if it's available.
 before_script:
   - dart --no-checked --snapshot=bin/pub.dart.snapshot --snapshot-kind=app-jit bin/pub.dart --help
+  - dart --preview-dart-2 --snapshot=bin/pub.dart.snapshot.dart2 bin/pub.dart
 
 # Only building these branches means that we don't run two builds for each pull
 # request.
diff --git a/lib/src/command.dart b/lib/src/command.dart
index 4b5772b..cfc7545 100644
--- a/lib/src/command.dart
+++ b/lib/src/command.dart
@@ -39,7 +39,7 @@
   Entrypoint get entrypoint {
     // Lazy load it.
     if (_entrypoint == null) {
-      _entrypoint = new Entrypoint('.', cache);
+      _entrypoint = new Entrypoint.current(cache);
     }
     return _entrypoint;
   }
diff --git a/lib/src/command/run.dart b/lib/src/command/run.dart
index e480337..93afa3c 100644
--- a/lib/src/command/run.dart
+++ b/lib/src/command/run.dart
@@ -57,8 +57,23 @@
       log.warning("The --mode flag is deprecated and has no effect.");
     }
 
+    // The user may pass in an executable without an extension, but the file
+    // to actually execute will always have one.
+    if (p.extension(executable) != ".dart") executable += ".dart";
+
+    var snapshotPath =
+        p.join(entrypoint.cachePath, "bin", package, "$executable.snapshot");
+
+    // Don't ever compile snapshots for mutable packages, since their code may
+    // change later on.
+    var useSnapshot = fileExists(snapshotPath) ||
+        (package != entrypoint.root.name &&
+            !entrypoint.packageGraph.isPackageMutable(package));
+
     var exitCode = await runExecutable(entrypoint, package, executable, args,
-        checked: argResults['checked']);
+        checked: argResults['checked'],
+        snapshotPath: useSnapshot ? snapshotPath : null,
+        recompile: entrypoint.precompileExecutables);
     await flushThenExit(exitCode);
   }
 }
diff --git a/lib/src/command/uploader.dart b/lib/src/command/uploader.dart
index 6d16e46..43fd9e5 100644
--- a/lib/src/command/uploader.dart
+++ b/lib/src/command/uploader.dart
@@ -4,10 +4,7 @@
 
 import 'dart:async';
 
-import 'package:path/path.dart' as path;
-
 import '../command.dart';
-import '../entrypoint.dart';
 import '../exit_codes.dart' as exit_codes;
 import '../http.dart';
 import '../io.dart';
@@ -58,7 +55,7 @@
     return new Future.sync(() {
       var package = argResults['package'];
       if (package != null) return package;
-      return new Entrypoint(path.current, cache).root.name;
+      return entrypoint.root.name;
     })
         .then((package) {
           var uploader = rest[0];
diff --git a/lib/src/dart.dart b/lib/src/dart.dart
index d445b20..6ce6700 100644
--- a/lib/src/dart.dart
+++ b/lib/src/dart.dart
@@ -11,6 +11,7 @@
 import 'exceptions.dart';
 import 'io.dart';
 import 'log.dart' as log;
+import 'utils.dart';
 
 /// Returns whether [dart] looks like an entrypoint file.
 bool isEntrypoint(CompilationUnit dart) {
@@ -51,18 +52,41 @@
 ///
 /// If [name] is passed, it is used to describe the executable in logs and error
 /// messages.
+///
+/// When running in Dart 2 mode, this automatically creates a Dart 2-compatible
+/// snapshot as well at `$snapshotPath.dart2`.
 Future snapshot(Uri executableUrl, String snapshotPath,
     {Uri packagesFile, String name}) async {
   name = log.bold(name ?? executableUrl.toString());
 
-  var args = ['--snapshot=$snapshotPath', executableUrl.toString()];
-  if (packagesFile != null) args.insert(0, "--packages=$packagesFile");
-  var result = await runProcess(Platform.executable, args);
+  var dart1Args = ['--snapshot=$snapshotPath', executableUrl.toString()];
 
-  if (result.success) {
+  var dart2Path = '$snapshotPath.dart2';
+  var dart2Args = isDart2
+      ? ['--preview-dart-2', '--snapshot=$dart2Path', executableUrl.toString()]
+      : null;
+
+  if (packagesFile != null) {
+    dart1Args.insert(0, "--packages=$packagesFile");
+
+    // Resolve [packagesFile] in case it's relative to work around sdk#33177.
+    dart2Args?.insert(0, "--packages=${Uri.base.resolveUri(packagesFile)}");
+  }
+
+  var processes = [runProcess(Platform.executable, dart1Args)];
+  if (isDart2) processes.add(runProcess(Platform.executable, dart2Args));
+  var results = await Future.wait(processes);
+
+  var failure =
+      results.firstWhere((result) => !result.success, orElse: () => null);
+  if (failure == null) {
     log.message("Precompiled $name.");
   } else {
-    throw new ApplicationException(
-        log.yellow("Failed to precompile $name:\n") + result.stderr.join('\n'));
+    // Don't leave partial results.
+    deleteEntry(snapshotPath);
+    deleteEntry(dart2Path);
+
+    throw new ApplicationException(log.yellow("Failed to precompile $name:\n") +
+        failure.stderr.join('\n'));
   }
 }
diff --git a/lib/src/entrypoint.dart b/lib/src/entrypoint.dart
index b44cc06..c266723 100644
--- a/lib/src/entrypoint.dart
+++ b/lib/src/entrypoint.dart
@@ -74,6 +74,9 @@
   /// real directory on disk.
   final bool _inMemory;
 
+  /// Whether this entrypoint exists within the package cache.
+  bool get isCached => root.dir != null && p.isWithin(cache.rootDir, root.dir);
+
   /// Whether this is an entrypoint for a globally-activated package.
   final bool isGlobal;
 
@@ -138,26 +141,40 @@
     return newPath;
   }
 
+  /// Returns the contents of the `.packages` file for this entrypoint.
+  ///
+  /// This is based on the package's lockfile, so it works whether or not a
+  /// `.packages` file has been written.
+  String get packagesFileContents => lockFile.packagesFile(cache, root.name);
+
   /// The path to the directory containing dependency executable snapshots.
   String get _snapshotPath => p.join(cachePath, 'bin');
 
+  /// Loads the entrypoint for the package at the current directory.
+  Entrypoint.current(SystemCache cache)
+      : root = new Package.load(null, '.', cache.sources, isRootPackage: true),
+        cache = cache,
+        _inMemory = false,
+        isGlobal = false;
+
   /// Loads the entrypoint from a package at [rootDir].
-  Entrypoint(String rootDir, SystemCache cache, {this.isGlobal: false})
+  Entrypoint(String rootDir, SystemCache cache)
       : root =
             new Package.load(null, rootDir, cache.sources, isRootPackage: true),
         cache = cache,
-        _inMemory = false;
+        _inMemory = false,
+        isGlobal = true;
 
   /// Creates an entrypoint given package and lockfile objects.
-  Entrypoint.inMemory(this.root, this._lockFile, this.cache,
-      {this.isGlobal: false})
-      : _inMemory = true;
+  Entrypoint.inMemory(this.root, this._lockFile, this.cache)
+      : _inMemory = true,
+        isGlobal = true;
 
   /// Creates an entrypoint given a package and a [solveResult], from which the
   /// package graph and lockfile will be computed.
-  Entrypoint.fromSolveResult(this.root, this.cache, SolveResult solveResult,
-      {this.isGlobal: false})
-      : _inMemory = true {
+  Entrypoint.fromSolveResult(this.root, this.cache, SolveResult solveResult)
+      : _inMemory = true,
+        isGlobal = true {
     _packageGraph = new PackageGraph.fromSolveResult(this, solveResult);
     _lockFile = _packageGraph.lockFile;
   }
@@ -238,7 +255,7 @@
     /// have to reload and reparse all the pubspecs.
     _packageGraph = new PackageGraph.fromSolveResult(this, result);
 
-    writeTextFile(packagesFile, lockFile.packagesFile(cache, root.name));
+    writeTextFile(packagesFile, packagesFileContents);
 
     try {
       if (precompile) {
@@ -350,8 +367,12 @@
     // executable will save us a few IO operations over checking each one. If
     // some executables do exist and some do not, the directory is corrupted and
     // it's good to start from scratch anyway.
-    var executablesExist = executables.every((executable) => fileExists(p.join(
-        _snapshotPath, packageName, "${p.basename(executable)}.snapshot")));
+    var executablesExist = executables.every((executable) {
+      var snapshotPath = p.join(
+          _snapshotPath, packageName, "${p.basename(executable)}.snapshot");
+      if (!fileExists(snapshotPath)) return false;
+      if (isDart2 && !fileExists("$snapshotPath.dart2")) return false;
+    });
     if (!executablesExist) return executables;
 
     // Otherwise, we don't need to recompile.
diff --git a/lib/src/executable.dart b/lib/src/executable.dart
index 796b326..6ef158f 100644
--- a/lib/src/executable.dart
+++ b/lib/src/executable.dart
@@ -14,25 +14,34 @@
 import 'isolate.dart' as isolate;
 import 'log.dart' as log;
 import 'utils.dart';
-import 'system_cache.dart';
 
 /// Runs [executable] from [package] reachable from [entrypoint].
 ///
-/// The executable string is a relative Dart file path using native path
-/// separators with or without a trailing ".dart" extension. It is contained
-/// within [package], which should either be the entrypoint package or an
-/// immediate dependency of it.
+/// The [executable] is a relative path to a Dart file within [package], which
+/// should either be the entrypoint package or an immediate dependency of it.
 ///
 /// Arguments from [args] will be passed to the spawned Dart application.
 ///
-/// If [checked] is true, the program is run in checked mode. If [mode] is
-/// passed, it's used as the barback mode; it defaults to [BarbackMode.RELEASE].
+/// If [checked] is true, the program is run in checked mode.
+///
+/// If [packagesFile] is passed, it's used as the package config file path for
+/// the executable. Otherwise, `entrypoint.packagesFile` is used.
+///
+/// If [snapshotPath] is passed, this will run the executable from that snapshot
+/// if it exists. If [recompile] is passed, it's called if the snapshot is
+/// out-of-date or nonexistent. It's expected to regenerate a snapshot at
+/// [snapshotPath], after which the snapshot will be re-run. It's ignored if
+/// [snapshotPath] isn't passed.
 ///
 /// Returns the exit code of the spawned app.
 Future<int> runExecutable(Entrypoint entrypoint, String package,
     String executable, Iterable<String> args,
-    {bool isGlobal: false, bool checked: false, SystemCache cache}) async {
-  assert(!isGlobal || cache != null);
+    {bool checked: false,
+    String packagesFile,
+    String snapshotPath,
+    Future<void> recompile()}) async {
+  packagesFile ??= entrypoint.packagesFile;
+
   // Make sure the package is an immediate dependency of the entrypoint or the
   // entrypoint itself.
   if (entrypoint.root.name != package &&
@@ -49,25 +58,24 @@
   entrypoint.migrateCache();
 
   // Unless the user overrides the verbosity, we want to filter out the
-  // normal pub output shown while loading the environment.
+  // normal pub output that may be shown when recompiling snapshots.
   if (log.verbosity == log.Verbosity.NORMAL) {
     log.verbosity = log.Verbosity.WARNING;
   }
 
-  // Ensure that there's a trailing extension.
-  if (p.extension(executable) != ".dart") executable += ".dart";
-
-  var localSnapshotPath =
-      p.join(entrypoint.cachePath, "bin", package, "$executable.snapshot");
   // Snapshots are compiled in Dart 1 mode, so in Dart 2 mode we always run
   // executables from source.
-  if (!isDart2 && !isGlobal && fileExists(localSnapshotPath)) {
+  if (snapshotPath != null) {
+    // Look for the Dart 2-specific snapshot when running in Dart 2 mode.
+    if (isDart2) snapshotPath += '.dart2';
+
     // Since we don't access the package graph, this doesn't happen
     // automatically.
     entrypoint.assertUpToDate();
 
-    return _runCachedExecutable(entrypoint, localSnapshotPath, args,
-        checked: checked);
+    var result = await _runOrCompileSnapshot(snapshotPath, args,
+        packagesFile: packagesFile, checked: checked, recompile: recompile);
+    if (result != null) return result;
   }
 
   // If the command has a path separator, then it's a path relative to the
@@ -75,12 +83,11 @@
   // "bin".
   if (p.split(executable).length == 1) executable = p.join("bin", executable);
 
-  var executablePath = await _executablePath(entrypoint, package, executable,
-      isGlobal: isGlobal, cache: cache);
+  var executablePath = await _executablePath(entrypoint, package, executable);
 
   if (executablePath == null) {
     var message = "Could not find ${log.bold(executable)}";
-    if (isGlobal || package != entrypoint.root.name) {
+    if (entrypoint.isGlobal || package != entrypoint.root.name) {
       message += " in package ${log.bold(package)}";
     }
     log.error("$message.");
@@ -91,7 +98,7 @@
   // helpful for the subprocess to be able to spawn Dart with
   // Platform.executableArguments and have that work regardless of the working
   // directory.
-  var packageConfig = p.toUri(p.absolute(entrypoint.packagesFile));
+  var packageConfig = p.toUri(p.absolute(packagesFile));
 
   await isolate.runUri(p.toUri(executablePath), args.toList(), null,
       checked: checked,
@@ -106,28 +113,37 @@
 /// returns `null`. If the executable is global and doesn't already have a
 /// `.packages` file one will be created.
 Future<String> _executablePath(
-    Entrypoint entrypoint, String package, String path,
-    {bool isGlobal: false, SystemCache cache}) async {
+    Entrypoint entrypoint, String package, String path) async {
   assert(p.isRelative(path));
 
-  if (!fileExists(entrypoint.packagesFile)) {
-    if (!isGlobal) return null;
-    // A .packages file may not already exist if the global executable has a
-    // 1.6-style lock file instead.
-    await writeTextFile(
-        entrypoint.packagesFile, entrypoint.lockFile.packagesFile(cache));
-  }
   var fullPath = entrypoint.packageGraph.packages[package].path(path);
   if (!fileExists(fullPath)) return null;
   return p.absolute(fullPath);
 }
 
+/// Like [runSnapshot], but runs [recompile] if [path] doesn't exist yet.
+///
+/// Returns `null` if [path] doesn't exist and isn't generated by [recompile].
+Future<int> _runOrCompileSnapshot(String path, Iterable<String> args,
+    {Future<void> recompile(),
+    String packagesFile,
+    bool checked: false}) async {
+  if (!fileExists(path)) {
+    if (recompile == null) return null;
+    await recompile();
+    if (!fileExists(path)) return null;
+  }
+
+  return await runSnapshot(path, args,
+      recompile: recompile, packagesFile: packagesFile, checked: checked);
+}
+
 /// Runs the snapshot at [path] with [args] and hooks its stdout, stderr, and
 /// sdtin to this process's.
 ///
 /// If [recompile] is passed, it's called if the snapshot is out-of-date. It's
 /// expected to regenerate a snapshot at [path], after which the snapshot will
-/// be re-run. It may return a Future.
+/// be re-run.
 ///
 /// If [checked] is set, runs the snapshot in checked mode.
 ///
@@ -135,7 +151,9 @@
 ///
 /// This doesn't do any validation of the snapshot's SDK version.
 Future<int> runSnapshot(String path, Iterable<String> args,
-    {recompile(), String packagesFile, bool checked: false}) async {
+    {Future<void> recompile(),
+    String packagesFile,
+    bool checked: false}) async {
   Uri packageConfig;
   if (packagesFile != null) {
     // We use an absolute path here not because the VM insists but because it's
@@ -155,6 +173,8 @@
   } on IsolateSpawnException catch (error) {
     if (recompile == null) rethrow;
     if (!error.message.contains("Wrong script snapshot version")) rethrow;
+
+    log.fine("Precompiled executable is out of date.");
     await recompile();
     await isolate.runUri(url, argList, null,
         checked: checked, packageConfig: packageConfig);
@@ -162,14 +182,3 @@
 
   return exitCode;
 }
-
-/// Runs the executable snapshot at [snapshotPath].
-Future<int> _runCachedExecutable(
-    Entrypoint entrypoint, String snapshotPath, List<String> args,
-    {bool checked: false}) {
-  return runSnapshot(snapshotPath, args,
-      packagesFile: entrypoint.packagesFile, checked: checked, recompile: () {
-    log.fine("Precompiled executable is out of date.");
-    return entrypoint.precompileExecutables();
-  });
-}
diff --git a/lib/src/global_packages.dart b/lib/src/global_packages.dart
index c99f9f3..a69d5c4 100644
--- a/lib/src/global_packages.dart
+++ b/lib/src/global_packages.dart
@@ -137,7 +137,7 @@
   /// Otherwise, the previous ones will be preserved.
   Future activatePath(String path, List<String> executables,
       {bool overwriteBinStubs}) async {
-    var entrypoint = new Entrypoint(path, cache, isGlobal: true);
+    var entrypoint = new Entrypoint(path, cache);
 
     // Get the package's dependencies.
     await entrypoint.acquireDependencies(SolveType.GET);
@@ -204,8 +204,7 @@
 
     // Load the package graph from [result] so we don't need to re-parse all
     // the pubspecs.
-    var entrypoint =
-        new Entrypoint.fromSolveResult(root, cache, result, isGlobal: true);
+    var entrypoint = new Entrypoint.fromSolveResult(root, cache, result);
     var snapshots = await _precompileExecutables(entrypoint, dep.name);
 
     _updateBinStubs(entrypoint.packageGraph.packages[dep.name], executables,
@@ -226,6 +225,13 @@
       var binDir = p.join(_directory, packageName, 'bin');
       cleanDir(binDir);
 
+      var packagesFilePath = p.join(_directory, packageName, '.packages');
+      if (!fileExists(packagesFilePath)) {
+        // A .packages file may not already exist if the global executable has a
+        // 1.6-style lock file instead.
+        await writeTextFile(packagesFilePath, entrypoint.packagesFileContents);
+      }
+
       // Try to avoid starting up an asset server to precompile packages if
       // possible. This is faster and produces better error messages.
       var package = entrypoint.packageGraph.packages[packageName];
@@ -335,14 +341,12 @@
     if (source is CachedSource) {
       // For cached sources, the package itself is in the cache and the
       // lockfile is the one we just loaded.
-      entrypoint = new Entrypoint.inMemory(cache.load(id), lockFile, cache,
-          isGlobal: true);
+      entrypoint = new Entrypoint.inMemory(cache.load(id), lockFile, cache);
     } else {
       // For uncached sources (i.e. path), the ID just points to the real
       // directory for the package.
       entrypoint = new Entrypoint(
-          (id.source as PathSource).pathFromDescription(id.description), cache,
-          isGlobal: true);
+          (id.source as PathSource).pathFromDescription(id.description), cache);
     }
 
     entrypoint.root.pubspec.sdkConstraints.forEach((sdkName, constraint) {
@@ -375,28 +379,17 @@
   Future<int> runExecutable(
       String package, String executable, Iterable<String> args,
       {bool checked: false}) {
-    var binDir = p.join(_directory, package, 'bin');
-    // Snapshots are compiled in Dart 1 mode, so in Dart 2 mode we always run
-    // executables from source.
-    if (isDart2 || !fileExists(p.join(binDir, '$executable.dart.snapshot'))) {
-      return exe.runExecutable(find(package), package, executable, args,
-          isGlobal: true, checked: checked, cache: cache);
-    }
-
-    // Unless the user overrides the verbosity, we want to filter out the
-    // normal pub output shown while loading the environment.
-    if (log.verbosity == log.Verbosity.NORMAL) {
-      log.verbosity = log.Verbosity.WARNING;
-    }
-
-    var snapshotPath = p.join(binDir, '$executable.dart.snapshot');
-    return exe.runSnapshot(snapshotPath, args, checked: checked,
-        recompile: () async {
-      log.fine("$package:$executable is out of date and needs to be "
-          "recompiled.");
-      await _precompileExecutables(
-          find(package).packageGraph.entrypoint, package);
-    });
+    var entrypoint = find(package);
+    return exe.runExecutable(
+        entrypoint, package, p.join('bin', '$executable.dart'), args,
+        checked: checked,
+        packagesFile:
+            entrypoint.isCached ? _getPackagesFilePath(package) : null,
+        // Don't use snapshots for executables activated from paths.
+        snapshotPath: entrypoint.isCached
+            ? p.join(_directory, package, 'bin', '$executable.dart.snapshot')
+            : null,
+        recompile: () => _precompileExecutables(entrypoint, package));
   }
 
   /// Gets the path to the lock file for an activated cached package with
diff --git a/test/global/dart2_test.dart b/test/global/dart2_test.dart
new file mode 100644
index 0000000..e619453
--- /dev/null
+++ b/test/global/dart2_test.dart
@@ -0,0 +1,89 @@
+// 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:path/path.dart' as p;
+import 'package:test/test.dart';
+
+import '../descriptor.dart' as d;
+import '../test_pub.dart';
+
+main() {
+  test("doesn't create a Dart 2 snapshot in Dart 1", () async {
+    await servePackages((builder) {
+      builder.serve("foo", "1.0.0", contents: [
+        d.dir('bin', [d.file("hello.dart", "void main() => print('hello!');")])
+      ]);
+    });
+
+    await runPub(
+        args: ["global", "activate", "foo"],
+        output: allOf([contains('Precompiled foo:hello.')]));
+
+    await d.dir(p.join(cachePath, 'global_packages', 'foo', 'bin'),
+        [d.nothing('hello.dart.snapshot.dart2')]).validate();
+  });
+
+  test("creates both a Dart 1 and Dart 2 snapshot in Dart 2", () async {
+    await servePackages((builder) {
+      builder.serve("foo", "1.0.0", contents: [
+        d.dir('bin', [d.file("hello.dart", "void main() => print('hello!');")])
+      ]);
+    });
+
+    await runPub(
+        args: ["global", "activate", "foo"],
+        output: allOf([contains('Precompiled foo:hello.')]),
+        dart2: true);
+
+    await d.dir(p.join(cachePath, 'global_packages', 'foo', 'bin'), [
+      d.file('hello.dart.snapshot', contains('hello!')),
+      d.file('hello.dart.snapshot.dart2', contains('hello!'))
+    ]).validate();
+  });
+
+  test("creates a Dart 2 snapshot when reactivated with Dart 2", () async {
+    await servePackages((builder) {
+      builder.serve("foo", "1.0.0", contents: [
+        d.dir('bin', [d.file("hello.dart", "void main() => print('hello!');")])
+      ]);
+    });
+
+    await runPub(
+        args: ["global", "activate", "foo"],
+        output: allOf([contains('Precompiled foo:hello.')]));
+    await runPub(
+        args: ["global", "activate", "foo"],
+        output: allOf([contains('Precompiled foo:hello.')]),
+        dart2: true);
+
+    await d.dir(p.join(cachePath, 'global_packages', 'foo', 'bin'), [
+      d.file('hello.dart.snapshot', contains('hello!')),
+      d.file('hello.dart.snapshot.dart2', contains('hello!'))
+    ]).validate();
+  });
+
+  test("creates a Dart 2 snapshot when run with Dart 2", () async {
+    await servePackages((builder) {
+      builder.serve("foo", "1.0.0", contents: [
+        d.dir('bin', [d.file("hello.dart", "void main() => print('hello!');")])
+      ]);
+    });
+
+    await runPub(
+        args: ["global", "activate", "foo"],
+        output: allOf([contains('Precompiled foo:hello.')]));
+
+    var pub = await pubRun(global: true, args: ["foo:hello"], dart2: true);
+    // In the real world this would just print "hello!", but since we
+    // collect all output we see the precompilation messages as well.
+    expect(pub.stdout, emits("Precompiling executables..."));
+    expect(pub.stdout, emitsThrough("hello!"));
+    await pub.shouldExit();
+
+    await d.dir(p.join(cachePath, 'global_packages', 'foo', 'bin'), [
+      d.file('hello.dart.snapshot', contains('hello!')),
+      d.file('hello.dart.snapshot.dart2', contains('hello!'))
+    ]).validate();
+  });
+}
diff --git a/test/global/run/uses_old_lockfile_test.dart b/test/global/run/uses_old_lockfile_test.dart
index 38e850b..983a61a 100644
--- a/test/global/run/uses_old_lockfile_test.dart
+++ b/test/global/run/uses_old_lockfile_test.dart
@@ -42,7 +42,7 @@
     ]).create();
 
     var pub = await pubRun(global: true, args: ["foo:script"]);
-    expect(pub.stdout, emits("bar 1.0.0"));
+    expect(pub.stdout, emitsThrough("bar 1.0.0"));
     await pub.shouldExit();
 
     await d.dir(cachePath, [
diff --git a/test/snapshot_test.dart b/test/snapshot_test.dart
index 9f9837a..64609c3 100644
--- a/test/snapshot_test.dart
+++ b/test/snapshot_test.dart
@@ -91,6 +91,49 @@
       await process.shouldExit();
     });
 
+    test("only for Dart 1 in Dart 1 mode", () async {
+      await servePackages((builder) {
+        builder.serve("foo", "1.2.3", contents: [
+          d.dir(
+              "bin", [d.file("hello.dart", "void main() => print('hello!');")])
+        ]);
+      });
+
+      await d.appDir({"foo": "1.2.3"}).create();
+
+      await pubGet(output: allOf([contains("Precompiled foo:hello.")]));
+
+      await d.dir(p.join(appPath, '.dart_tool', 'pub', 'bin', 'foo'),
+          [d.nothing('hello.dart.snapshot.dart2')]).validate();
+    });
+
+    test("for Dart 1 and 2 in Dart 2 mode", () async {
+      await servePackages((builder) {
+        builder.serve("foo", "1.2.3", contents: [
+          d.dir(
+              "bin", [d.file("hello.dart", "void main() => print('hello!');")])
+        ]);
+      });
+
+      await d.appDir({"foo": "1.2.3"}).create();
+
+      await pubGet(
+          output: allOf([contains("Precompiled foo:hello.")]), dart2: true);
+
+      await d.dir(p.join(appPath, '.dart_tool', 'pub', 'bin', 'foo'), [
+        d.file('hello.dart.snapshot', contains('hello!')),
+        d.file('hello.dart.snapshot.dart2', contains('hello!'))
+      ]).validate();
+
+      var process = await pubRun(args: ['foo:hello']);
+      expect(process.stdout, emits("hello!"));
+      await process.shouldExit();
+
+      process = await pubRun(args: ['foo:hello'], dart2: true);
+      expect(process.stdout, emits("hello!"));
+      await process.shouldExit();
+    });
+
     group("again if", () {
       test("its package is updated", () async {
         await servePackages((builder) {
@@ -227,6 +270,83 @@
           d.dir('foo', [d.file('hello.dart.snapshot', contains('hello!'))])
         ]).validate();
       });
+
+      test("the SDK is out of date", () async {
+        await servePackages((builder) {
+          builder.serve("foo", "5.6.7", contents: [
+            d.dir("bin",
+                [d.file("hello.dart", "void main() => print('hello!');")])
+          ]);
+        });
+
+        await d.appDir({"foo": "5.6.7"}).create();
+
+        await pubGet(output: contains("Precompiled foo:hello."));
+
+        await d.dir(p.join(appPath, '.dart_tool', 'pub', 'bin'), [
+          d.dir('foo', [d.outOfDateSnapshot('hello.dart.snapshot')])
+        ]).create();
+
+        var process = await pubRun(args: ['foo:hello']);
+
+        // In the real world this would just print "hello!", but since we
+        // collect all output we see the precompilation messages as well.
+        expect(process.stdout, emits("Precompiling executables..."));
+        expect(process.stdout, emitsThrough("hello!"));
+        await process.shouldExit();
+
+        await d.dir(p.join(appPath, '.dart_tool', 'pub', 'bin'), [
+          d.file('sdk-version', '0.1.2+3\n'),
+          d.dir('foo', [d.file('hello.dart.snapshot', contains('hello!'))])
+        ]).validate();
+      });
+
+      group("Dart 2 is newly in use for", () {
+        test("pub get", () async {
+          await servePackages((builder) {
+            builder.serve("foo", "5.6.7", contents: [
+              d.dir("bin",
+                  [d.file("hello.dart", "void main() => print('hello!');")])
+            ]);
+          });
+
+          await d.appDir({"foo": "5.6.7"}).create();
+
+          await pubGet(output: contains("Precompiled foo:hello."));
+          await pubGet(output: contains("Precompiled foo:hello."), dart2: true);
+
+          await d.dir(p.join(appPath, '.dart_tool', 'pub', 'bin', 'foo'), [
+            d.file('hello.dart.snapshot', contains('hello!')),
+            d.file('hello.dart.snapshot.dart2', contains('hello!'))
+          ]).validate();
+        });
+
+        test("pub run", () async {
+          await servePackages((builder) {
+            builder.serve("foo", "5.6.7", contents: [
+              d.dir("bin",
+                  [d.file("hello.dart", "void main() => print('hello!');")])
+            ]);
+          });
+
+          await d.appDir({"foo": "5.6.7"}).create();
+
+          await pubGet(output: contains("Precompiled foo:hello."));
+
+          var process = await pubRun(args: ['foo:hello'], dart2: true);
+
+          // In the real world this would just print "hello!", but since we
+          // collect all output we see the precompilation messages as well.
+          expect(process.stdout, emits("Precompiling executables..."));
+          expect(process.stdout, emitsThrough("hello!"));
+          await process.shouldExit();
+
+          await d.dir(p.join(appPath, '.dart_tool', 'pub', 'bin', 'foo'), [
+            d.file('hello.dart.snapshot', contains('hello!')),
+            d.file('hello.dart.snapshot.dart2', contains('hello!'))
+          ]).validate();
+        });
+      });
     });
   });
 }
diff --git a/test/test_pub.dart b/test/test_pub.dart
index bd4afdf..42574a1 100644
--- a/test/test_pub.dart
+++ b/test/test_pub.dart
@@ -123,7 +123,8 @@
     silent,
     warning,
     int exitCode,
-    Map<String, String> environment}) async {
+    Map<String, String> environment,
+    bool dart2: false}) async {
   if (error != null && warning != null) {
     throw new ArgumentError("Cannot pass both 'error' and 'warning'.");
   }
@@ -145,7 +146,8 @@
       error: error,
       silent: silent,
       exitCode: exitCode,
-      environment: environment);
+      environment: environment,
+      dart2: dart2);
 }
 
 Future pubGet(
@@ -154,14 +156,16 @@
         error,
         warning,
         int exitCode,
-        Map<String, String> environment}) =>
+        Map<String, String> environment,
+        bool dart2: false}) =>
     pubCommand(RunCommand.get,
         args: args,
         output: output,
         error: error,
         warning: warning,
         exitCode: exitCode,
-        environment: environment);
+        environment: environment,
+        dart2: dart2);
 
 Future pubUpgrade(
         {Iterable<String> args,
@@ -169,14 +173,16 @@
         error,
         warning,
         int exitCode,
-        Map<String, String> environment}) =>
+        Map<String, String> environment,
+        bool dart2: false}) =>
     pubCommand(RunCommand.upgrade,
         args: args,
         output: output,
         error: error,
         warning: warning,
         exitCode: exitCode,
-        environment: environment);
+        environment: environment,
+        dart2: dart2);
 
 Future pubDowngrade(
         {Iterable<String> args,
@@ -184,14 +190,16 @@
         error,
         warning,
         int exitCode,
-        Map<String, String> environment}) =>
+        Map<String, String> environment,
+        bool dart2: false}) =>
     pubCommand(RunCommand.downgrade,
         args: args,
         output: output,
         error: error,
         warning: warning,
         exitCode: exitCode,
-        environment: environment);
+        environment: environment,
+        dart2: dart2);
 
 /// Schedules starting the "pub [global] run" process and validates the
 /// expected startup output.
@@ -200,10 +208,11 @@
 /// "pub run".
 ///
 /// Returns the `pub run` process.
-Future<PubProcess> pubRun({bool global: false, Iterable<String> args}) async {
+Future<PubProcess> pubRun(
+    {bool global: false, Iterable<String> args, bool dart2: false}) async {
   var pubArgs = global ? ["global", "run"] : ["run"];
   pubArgs.addAll(args);
-  var pub = await startPub(args: pubArgs);
+  var pub = await startPub(args: pubArgs, dart2: dart2);
 
   // Loading sources and transformers isn't normally printed, but the pub test
   // infrastructure runs pub in verbose mode, which enables this.
@@ -244,12 +253,16 @@
     silent,
     int exitCode: exit_codes.SUCCESS,
     String workingDirectory,
-    Map<String, String> environment}) async {
+    Map<String, String> environment,
+    bool dart2: false}) async {
   // Cannot pass both output and outputJson.
   assert(output == null || outputJson == null);
 
   var pub = await startPub(
-      args: args, workingDirectory: workingDirectory, environment: environment);
+      args: args,
+      workingDirectory: workingDirectory,
+      environment: environment,
+      dart2: dart2);
   await pub.shouldExit(exitCode);
 
   expect(() async {
@@ -338,7 +351,8 @@
     {Iterable<String> args,
     String tokenEndpoint,
     String workingDirectory,
-    Map<String, String> environment}) async {
+    Map<String, String> environment,
+    bool dart2: false}) async {
   args ??= [];
 
   ensureDir(_pathInSandbox(appPath));
@@ -359,13 +373,13 @@
   // TODO(nweiz): When the test runner supports plugins, create one to
   // auto-generate the snapshot before each run.
   var pubPath = p.absolute(p.join(pubRoot, 'bin/pub.dart'));
-  if (fileExists('$pubPath.snapshot')) pubPath += '.snapshot';
+  var snapshotPath = '$pubPath.snapshot';
+  if (dart2) snapshotPath += '.dart2';
+  if (fileExists(snapshotPath)) pubPath = snapshotPath;
 
-  var dartArgs = [
-    await PackageResolver.current.processArgument,
-    pubPath,
-    '--verbose'
-  ]..addAll(args);
+  var dartArgs = [await PackageResolver.current.processArgument];
+  if (dart2) dartArgs.add('--preview-dart-2');
+  dartArgs..addAll([pubPath, '--verbose'])..addAll(args);
 
   return await PubProcess.start(dartBin, dartArgs,
       environment: getPubTestEnvironment(tokenEndpoint)