diff --git a/pkg/vm/bin/kernel_service.dart b/pkg/vm/bin/kernel_service.dart
index ccffa5a..6ccb6ca 100644
--- a/pkg/vm/bin/kernel_service.dart
+++ b/pkg/vm/bin/kernel_service.dart
@@ -27,7 +27,9 @@
 import 'dart:typed_data' show Uint8List;
 
 import 'package:build_integration/file_system/multi_root.dart';
+import 'package:front_end/src/api_prototype/memory_file_system.dart';
 import 'package:front_end/src/api_unstable/vm.dart';
+import 'package:kernel/binary/ast_to_binary.dart';
 import 'package:kernel/kernel.dart' show Component, Procedure;
 import 'package:kernel/target/targets.dart' show TargetFlags;
 import 'package:vm/bytecode/gen_bytecode.dart' show generateBytecode;
@@ -63,14 +65,19 @@
 
 abstract class Compiler {
   final FileSystem fileSystem;
+  final Uri platformKernelPath;
+  bool suppressWarnings;
+  bool bytecode;
+  String packageConfig;
+
   final List<String> errors = new List<String>();
 
   CompilerOptions options;
 
-  Compiler(this.fileSystem, Uri platformKernelPath,
-      {bool suppressWarnings: false,
-      bool bytecode: false,
-      String packageConfig: null}) {
+  Compiler(this.fileSystem, this.platformKernelPath,
+      {this.suppressWarnings: false,
+      this.bytecode: false,
+      this.packageConfig: null}) {
     Uri packagesUri = null;
     if (packageConfig != null) {
       packagesUri = Uri.parse(packageConfig);
@@ -134,6 +141,23 @@
   Future<Component> compileInternal(Uri script);
 }
 
+class FileSink implements Sink<List<int>> {
+  MemoryFileSystemEntity entityForUri;
+  List<int> bytes = <int>[];
+
+  FileSink(this.entityForUri);
+
+  @override
+  void add(List<int> data) {
+    bytes.addAll(data);
+  }
+
+  @override
+  void close() {
+    this.entityForUri.writeAsBytesSync(bytes);
+  }
+}
+
 class IncrementalCompilerWrapper extends Compiler {
   IncrementalCompiler generator;
 
@@ -157,6 +181,30 @@
 
   void accept() => generator.accept();
   void invalidate(Uri uri) => generator.invalidate(uri);
+
+  Future<IncrementalCompilerWrapper> clone(int isolateId) async {
+    IncrementalCompilerWrapper clone = IncrementalCompilerWrapper(
+        fileSystem, platformKernelPath,
+        suppressWarnings: suppressWarnings,
+        bytecode: bytecode,
+        packageConfig: packageConfig);
+
+    generator.resetDeltaState();
+    Component fullComponent = await generator.compile();
+
+    // Assume fileSystem is HybridFileSystem because that is the setup where
+    // clone should be used for.
+    MemoryFileSystem memoryFileSystem = (fileSystem as HybridFileSystem).memory;
+
+    String filename = 'full-component-$isolateId.dill';
+    Sink sink = FileSink(memoryFileSystem.entityForUri(Uri.file(filename)));
+    new BinaryPrinter(sink).writeComponentFile(fullComponent);
+    await sink.close();
+
+    clone.generator = new IncrementalCompiler(options, generator.entryPoint,
+        initializeFromDillUri: Uri.file(filename));
+    return clone;
+  }
 }
 
 class SingleShotCompilerWrapper extends Compiler {
@@ -201,17 +249,28 @@
     updateSources(compiler, sourceFiles);
     invalidateSources(compiler, sourceFiles);
   } else {
-    FileSystem fileSystem = _buildFileSystem(
-        sourceFiles, platformKernel, multirootFilepaths, multirootScheme);
+    // This is how identify scenario where child isolate hot reload requests
+    // requires setting up actual compiler first: non-empty sourceFiles list has
+    // no actual content specified for the source file.
+    if (sourceFiles != null &&
+        sourceFiles.length > 0 &&
+        sourceFiles[1] == null) {
+      // Just use first compiler that should represent main isolate as a source for cloning.
+      var source = isolateCompilers.entries.first;
+      compiler = await source.value.clone(isolateId);
+    } else {
+      FileSystem fileSystem = _buildFileSystem(
+          sourceFiles, platformKernel, multirootFilepaths, multirootScheme);
 
-    // TODO(aam): IncrementalCompilerWrapper instance created below have to be
-    // destroyed when corresponding isolate is shut down. To achieve that kernel
-    // isolate needs to receive a message indicating that particular
-    // isolate was shut down. Message should be handled here in this script.
-    compiler = new IncrementalCompilerWrapper(fileSystem, platformKernelPath,
-        suppressWarnings: suppressWarnings,
-        bytecode: bytecode,
-        packageConfig: packageConfig);
+      // TODO(aam): IncrementalCompilerWrapper instance created below have to be
+      // destroyed when corresponding isolate is shut down. To achieve that kernel
+      // isolate needs to receive a message indicating that particular
+      // isolate was shut down. Message should be handled here in this script.
+      compiler = new IncrementalCompilerWrapper(fileSystem, platformKernelPath,
+          suppressWarnings: suppressWarnings,
+          bytecode: bytecode,
+          packageConfig: packageConfig);
+    }
     isolateCompilers[isolateId] = compiler;
   }
   return compiler;
diff --git a/pkg/vm/lib/incremental_compiler.dart b/pkg/vm/lib/incremental_compiler.dart
index 92136c2..e1715745 100644
--- a/pkg/vm/lib/incremental_compiler.dart
+++ b/pkg/vm/lib/incremental_compiler.dart
@@ -32,6 +32,8 @@
   Uri initializeFromDillUri;
   Uri _entryPoint;
 
+  Uri get entryPoint => _entryPoint;
+
   IncrementalCompiler(this._compilerOptions, this._entryPoint,
       {this.initializeFromDillUri}) {
     _generator = new IncrementalKernelGenerator(
@@ -44,6 +46,7 @@
   /// If [entryPoint] is specified, that points to new entry point for the
   /// compilation. Otherwise, previously set entryPoint is used.
   Future<Component> compile({Uri entryPoint}) async {
+    _entryPoint = entryPoint ?? _entryPoint;
     Component component = await _generator.computeDelta(
         entryPoint: entryPoint, fullComponent: fullComponent);
     initialized = true;
diff --git a/runtime/bin/isolate_data.cc b/runtime/bin/isolate_data.cc
index 4be4208..54b1050 100644
--- a/runtime/bin/isolate_data.cc
+++ b/runtime/bin/isolate_data.cc
@@ -21,8 +21,7 @@
       dependencies_(NULL),
       resolved_packages_config_(NULL),
       kernel_buffer_(NULL),
-      kernel_buffer_size_(0),
-      owns_kernel_buffer_(false) {
+      kernel_buffer_size_(0) {
   if (package_root != NULL) {
     ASSERT(packages_file == NULL);
     this->package_root = strdup(package_root);
@@ -43,10 +42,6 @@
   packages_file = NULL;
   free(resolved_packages_config_);
   resolved_packages_config_ = NULL;
-  if (owns_kernel_buffer_) {
-    ASSERT(kernel_buffer_ != NULL);
-    free(kernel_buffer_);
-  }
   kernel_buffer_ = NULL;
   kernel_buffer_size_ = 0;
   delete app_snapshot_;
diff --git a/runtime/bin/isolate_data.h b/runtime/bin/isolate_data.h
index ceab601..528f397 100644
--- a/runtime/bin/isolate_data.h
+++ b/runtime/bin/isolate_data.h
@@ -5,6 +5,9 @@
 #ifndef RUNTIME_BIN_ISOLATE_DATA_H_
 #define RUNTIME_BIN_ISOLATE_DATA_H_
 
+#include <memory>
+#include <utility>
+
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/globals.h"
@@ -40,13 +43,37 @@
   char* package_root;
   char* packages_file;
 
-  const uint8_t* kernel_buffer() const { return kernel_buffer_; }
+  const std::shared_ptr<uint8_t>& kernel_buffer() const {
+    return kernel_buffer_;
+  }
+
   intptr_t kernel_buffer_size() const { return kernel_buffer_size_; }
-  void set_kernel_buffer(uint8_t* buffer, intptr_t size, bool take_ownership) {
-    ASSERT(kernel_buffer_ == NULL);
-    kernel_buffer_ = buffer;
+
+  // Associate the given kernel buffer with this IsolateData without giving it
+  // ownership of the buffer.
+  void SetKernelBufferUnowned(uint8_t* buffer, intptr_t size) {
+    ASSERT(kernel_buffer_.get() == NULL);
+    kernel_buffer_ = std::shared_ptr<uint8_t>(buffer, FreeUnownedKernelBuffer);
     kernel_buffer_size_ = size;
-    owns_kernel_buffer_ = take_ownership;
+  }
+
+  // Associate the given kernel buffer with this IsolateData and give it
+  // ownership of the buffer. This IsolateData is the first one to own the
+  // buffer.
+  void SetKernelBufferNewlyOwned(uint8_t* buffer, intptr_t size) {
+    ASSERT(kernel_buffer_.get() == NULL);
+    kernel_buffer_ = std::shared_ptr<uint8_t>(buffer, free);
+    kernel_buffer_size_ = size;
+  }
+
+  // Associate the given kernel buffer with this IsolateData and give it
+  // ownership of the buffer. The buffer is already owned by another
+  // IsolateData.
+  void SetKernelBufferAlreadyOwned(std::shared_ptr<uint8_t> buffer,
+                                   intptr_t size) {
+    ASSERT(kernel_buffer_.get() == NULL);
+    kernel_buffer_ = std::move(buffer);
+    kernel_buffer_size_ = size;
   }
 
   void UpdatePackagesFile(const char* packages_file_) {
@@ -91,9 +118,10 @@
   AppSnapshot* app_snapshot_;
   MallocGrowableArray<char*>* dependencies_;
   char* resolved_packages_config_;
-  uint8_t* kernel_buffer_;
+  std::shared_ptr<uint8_t> kernel_buffer_;
   intptr_t kernel_buffer_size_;
-  bool owns_kernel_buffer_;
+
+  static void FreeUnownedKernelBuffer(uint8_t*) {}
 
   DISALLOW_COPY_AND_ASSIGN(IsolateData);
 };
diff --git a/runtime/bin/main.cc b/runtime/bin/main.cc
index 339a63ed..bd32e22 100644
--- a/runtime/bin/main.cc
+++ b/runtime/bin/main.cc
@@ -5,6 +5,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <memory>
 
 #include "include/bin/dart_io_api.h"
 #include "include/dart_api.h"
@@ -213,7 +214,7 @@
 #if !defined(DART_PRECOMPILED_RUNTIME)
   IsolateData* isolate_data =
       reinterpret_cast<IsolateData*>(Dart_IsolateData(isolate));
-  const uint8_t* kernel_buffer = isolate_data->kernel_buffer();
+  const uint8_t* kernel_buffer = isolate_data->kernel_buffer().get();
   intptr_t kernel_buffer_size = isolate_data->kernel_buffer_size();
 #endif
 
@@ -274,9 +275,8 @@
       Dart_ShutdownIsolate();
       return NULL;
     }
-    isolate_data->set_kernel_buffer(application_kernel_buffer,
-                                    application_kernel_buffer_size,
-                                    true /*take ownership*/);
+    isolate_data->SetKernelBufferNewlyOwned(application_kernel_buffer,
+                                            application_kernel_buffer_size);
     kernel_buffer = application_kernel_buffer;
     kernel_buffer_size = application_kernel_buffer_size;
   }
@@ -433,9 +433,9 @@
     dfe.LoadKernelService(&kernel_service_buffer, &kernel_service_buffer_size);
     ASSERT(kernel_service_buffer != NULL);
     isolate_data = new IsolateData(uri, package_root, packages_config, NULL);
-    isolate_data->set_kernel_buffer(const_cast<uint8_t*>(kernel_service_buffer),
-                                    kernel_service_buffer_size,
-                                    false /* take_ownership */);
+    isolate_data->SetKernelBufferUnowned(
+        const_cast<uint8_t*>(kernel_service_buffer),
+        kernel_service_buffer_size);
     isolate = Dart_CreateIsolateFromKernel(
         DART_KERNEL_ISOLATE_NAME, main, kernel_service_buffer,
         kernel_service_buffer_size, flags, isolate_data, error);
@@ -527,11 +527,13 @@
                                                 const char* package_root,
                                                 const char* packages_config,
                                                 Dart_IsolateFlags* flags,
+                                                void* callback_data,
                                                 char** error,
                                                 int* exit_code) {
   int64_t start = Dart_TimelineGetMicros();
   ASSERT(script_uri != NULL);
   uint8_t* kernel_buffer = NULL;
+  std::shared_ptr<uint8_t> parent_kernel_buffer;
   intptr_t kernel_buffer_size = 0;
   AppSnapshot* app_snapshot = NULL;
 
@@ -565,7 +567,16 @@
           &isolate_snapshot_data, &isolate_snapshot_instructions);
     }
   }
-  if (!isolate_run_app_snapshot) {
+
+  if (flags->copy_parent_code && callback_data) {
+    IsolateData* parent_isolate_data =
+        reinterpret_cast<IsolateData*>(callback_data);
+    parent_kernel_buffer = parent_isolate_data->kernel_buffer();
+    kernel_buffer = parent_kernel_buffer.get();
+    kernel_buffer_size = parent_isolate_data->kernel_buffer_size();
+  }
+
+  if (kernel_buffer == NULL && !isolate_run_app_snapshot) {
     dfe.ReadScript(script_uri, &kernel_buffer, &kernel_buffer_size);
   }
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
@@ -573,8 +584,13 @@
   IsolateData* isolate_data =
       new IsolateData(script_uri, package_root, packages_config, app_snapshot);
   if (kernel_buffer != NULL) {
-    isolate_data->set_kernel_buffer(kernel_buffer, kernel_buffer_size,
-                                    true /*take ownership*/);
+    if (parent_kernel_buffer) {
+      isolate_data->SetKernelBufferAlreadyOwned(std::move(parent_kernel_buffer),
+                                                kernel_buffer_size);
+    } else {
+      isolate_data->SetKernelBufferNewlyOwned(kernel_buffer,
+                                              kernel_buffer_size);
+    }
   }
   if (is_main_isolate && (Options::depfile() != NULL)) {
     isolate_data->set_dependencies(new MallocGrowableArray<char*>());
@@ -640,7 +656,7 @@
                                           const char* package_root,
                                           const char* package_config,
                                           Dart_IsolateFlags* flags,
-                                          void* data,
+                                          void* callback_data,
                                           char** error) {
   // The VM should never call the isolate helper with a NULL flags.
   ASSERT(flags != NULL);
@@ -667,8 +683,8 @@
   }
   bool is_main_isolate = false;
   return CreateIsolateAndSetupHelper(is_main_isolate, script_uri, main,
-                                     package_root, package_config, flags, error,
-                                     &exit_code);
+                                     package_root, package_config, flags,
+                                     callback_data, error, &exit_code);
 }
 
 char* BuildIsolateName(const char* script_name, const char* func_name) {
@@ -802,7 +818,8 @@
 
   Dart_Isolate isolate = CreateIsolateAndSetupHelper(
       is_main_isolate, script_name, "main", Options::package_root(),
-      Options::packages_file(), &flags, &error, &exit_code);
+      Options::packages_file(), &flags, NULL /* callback_data */, &error,
+      &exit_code);
 
   if (isolate == NULL) {
     delete[] isolate_name;
diff --git a/runtime/bin/run_vm_tests.cc b/runtime/bin/run_vm_tests.cc
index 703f57f..f024c4d 100644
--- a/runtime/bin/run_vm_tests.cc
+++ b/runtime/bin/run_vm_tests.cc
@@ -166,9 +166,9 @@
     ASSERT(kernel_service_buffer != NULL);
     isolate_data =
         new bin::IsolateData(script_uri, package_root, packages_config, NULL);
-    isolate_data->set_kernel_buffer(const_cast<uint8_t*>(kernel_service_buffer),
-                                    kernel_service_buffer_size,
-                                    false /* take_ownership */);
+    isolate_data->SetKernelBufferUnowned(
+        const_cast<uint8_t*>(kernel_service_buffer),
+        kernel_service_buffer_size);
     isolate = Dart_CreateIsolateFromKernel(
         script_uri, main, kernel_service_buffer, kernel_service_buffer_size,
         flags, isolate_data, error);
diff --git a/runtime/include/dart_api.h b/runtime/include/dart_api.h
index 6f259c1..661a146 100644
--- a/runtime/include/dart_api.h
+++ b/runtime/include/dart_api.h
@@ -553,7 +553,7 @@
  * for each part.
  */
 
-#define DART_FLAGS_CURRENT_VERSION (0x0000000a)
+#define DART_FLAGS_CURRENT_VERSION (0x0000000b)
 
 typedef struct {
   int32_t version;
@@ -565,6 +565,7 @@
   bool use_bare_instructions;
   bool load_vmservice_library;
   bool unsafe_trust_strong_mode_types;
+  bool copy_parent_code;
 } Dart_IsolateFlags;
 
 /**
diff --git a/runtime/lib/isolate.cc b/runtime/lib/isolate.cc
index 608ced8..b925147 100644
--- a/runtime/lib/isolate.cc
+++ b/runtime/lib/isolate.cc
@@ -230,6 +230,10 @@
           isolate->spawn_count_monitor(), isolate->spawn_count(),
           utf8_package_root, utf8_package_config, paused.value(), fatal_errors,
           on_exit_port, on_error_port);
+
+      // Since this is a call to Isolate.spawn, copy the parent isolate's code.
+      state->isolate_flags()->copy_parent_code = true;
+
       ThreadPool::Task* spawn_task = new SpawnIsolateTask(state);
 
       isolate->IncrementSpawnCount();
@@ -357,6 +361,9 @@
     flags->enable_asserts = checked.value();
   }
 
+  // Since this is a call to Isolate.spawnUri, don't copy the parent's code.
+  state->isolate_flags()->copy_parent_code = false;
+
   ThreadPool::Task* spawn_task = new SpawnIsolateTask(state);
 
   isolate->IncrementSpawnCount();
diff --git a/runtime/vm/compiler/frontend/kernel_fingerprints.cc b/runtime/vm/compiler/frontend/kernel_fingerprints.cc
index ca2969c..03a4e59 100644
--- a/runtime/vm/compiler/frontend/kernel_fingerprints.cc
+++ b/runtime/vm/compiler/frontend/kernel_fingerprints.cc
@@ -261,7 +261,14 @@
 }
 
 void KernelFingerprintHelper::CalculateInterfaceTypeFingerprint(bool simple) {
-  BuildHash(ReadUInt());  // read klass_name.
+  NameIndex kernel_class = ReadCanonicalNameReference();
+  ASSERT(H.IsClass(kernel_class));
+  const String& class_name = H.DartClassName(kernel_class);
+  NameIndex kernel_library = H.CanonicalNameParent(kernel_class);
+  const String& library_name =
+      H.DartSymbolPlain(H.CanonicalNameString(kernel_library));
+  BuildHash(class_name.Hash());
+  BuildHash(library_name.Hash());
   if (!simple) {
     CalculateListOfDartTypesFingerprint();  // read list of types.
   }
diff --git a/runtime/vm/isolate.cc b/runtime/vm/isolate.cc
index 5b69675..df87172 100644
--- a/runtime/vm/isolate.cc
+++ b/runtime/vm/isolate.cc
@@ -780,6 +780,7 @@
 #undef INIT_FROM_FLAG
   api_flags->entry_points = NULL;
   api_flags->load_vmservice_library = false;
+  api_flags->copy_parent_code = false;
 }
 
 void Isolate::FlagsCopyTo(Dart_IsolateFlags* api_flags) const {
@@ -790,6 +791,7 @@
 #undef INIT_FROM_FIELD
   api_flags->entry_points = NULL;
   api_flags->load_vmservice_library = should_load_vmservice();
+  api_flags->copy_parent_code = false;
 }
 
 void Isolate::FlagsCopyFrom(const Dart_IsolateFlags& api_flags) {
diff --git a/runtime/vm/isolate.h b/runtime/vm/isolate.h
index 0cb4ecb..278857f 100644
--- a/runtime/vm/isolate.h
+++ b/runtime/vm/isolate.h
@@ -134,7 +134,7 @@
 // List of Isolate flags with corresponding members of Dart_IsolateFlags and
 // corresponding global command line flags.
 //
-//       V(when, name, Dart_IsolateFlags-member-name, command-line-flag-name)
+//       V(when, name, bit-name, Dart_IsolateFlags-name, command-line-flag-name)
 //
 #define ISOLATE_FLAG_LIST(V)                                                   \
   V(NONPRODUCT, asserts, EnableAsserts, enable_asserts, FLAG_enable_asserts)   \
diff --git a/tests/lib_2/isolate/issue_6610_test.dart b/tests/lib_2/isolate/issue_6610_test.dart
new file mode 100644
index 0000000..96cc5e8f
--- /dev/null
+++ b/tests/lib_2/isolate/issue_6610_test.dart
@@ -0,0 +1,74 @@
+// 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.
+
+// Testing that Isolate.spawn copies the source code of the parent isolate,
+// rather than rereading the parent's source URI.
+// https://github.com/dart-lang/sdk/issues/6610
+
+// Isolate structure:
+//     Root 1 -> Branch 1 -> Leaf 1
+//     /
+//  main
+//     \
+//     Root 2 -> Branch 2 -> Leaf 2
+
+library spawn_tests;
+
+import "dart:io";
+import 'dart:isolate';
+import 'package:expect/expect.dart';
+
+void main() {
+  HttpServer.bind("127.0.0.1", 0).then((server) {
+    var count = 0;
+    server.listen((HttpRequest request) {
+      ++count;
+      request.response.write("""
+        import 'dart:isolate';
+
+        void main(_, SendPort port) {
+          root(port);
+        }
+
+        void root(SendPort port) {
+          port.send("Root ${count}");
+          Isolate.spawn(branch, port);
+        }
+
+        void branch(SendPort port) {
+          port.send("Branch ${count}");
+          Isolate.spawn(leaf, port);
+        }
+
+        void leaf(SendPort port) {
+          port.send("Leaf ${count}");
+        }
+      """);
+      request.response.close();
+    });
+
+    ReceivePort port = new ReceivePort();
+    var messageSet = Set();
+    port.listen((message) {
+      messageSet.add(message);
+      if (messageSet.length >= 6) {
+        server.close();
+        port.close();
+        Expect.setEquals([
+          "Root 1",
+          "Root 2",
+          "Branch 1",
+          "Branch 2",
+          "Leaf 1",
+          "Leaf 2",
+        ], messageSet);
+      }
+    });
+
+    Isolate.spawnUri(
+        Uri.parse("http://127.0.0.1:${server.port}"), [], port.sendPort);
+    Isolate.spawnUri(
+        Uri.parse("http://127.0.0.1:${server.port}"), [], port.sendPort);
+  });
+}
diff --git a/tests/lib_2/lib_2.status b/tests/lib_2/lib_2.status
index aa5ed20..f6628fa 100644
--- a/tests/lib_2/lib_2.status
+++ b/tests/lib_2/lib_2.status
@@ -211,6 +211,7 @@
 isolate/issue_21398_parent_isolate1_test: Skip # Isolate.spawnUri
 isolate/issue_21398_parent_isolate_test: Skip # Isolate.spawnUri
 isolate/issue_24243_parent_isolate_test: Skip # Isolate.spawnUri
+isolate/issue_6610_test: Skip # Isolate.spawnUri
 isolate/mandel_isolate_test: Skip # Isolate.spawnUri
 isolate/message2_test: Skip # Isolate.spawnUri
 isolate/message_test: Skip # Isolate.spawnUri
diff --git a/tests/lib_2/lib_2_kernel.status b/tests/lib_2/lib_2_kernel.status
index 629efbf..ca19533 100644
--- a/tests/lib_2/lib_2_kernel.status
+++ b/tests/lib_2/lib_2_kernel.status
@@ -251,6 +251,9 @@
 typed_data/int32x4_static_test/01: MissingCompileTimeError
 typed_data/int32x4_static_test/02: MissingCompileTimeError
 
+[ $hot_reload && ($compiler == dartk || $compiler == dartkb) ]
+isolate/issue_6610_test: RuntimeError, Crash # Sources are looked up on every reload request.
+
 [ $hot_reload_rollback && ($compiler == dartk || $compiler == dartkb) ]
 isolate/illegal_msg_function_test: Skip # Timeout
 isolate/pause_test: Skip # Timeout
@@ -260,6 +263,7 @@
 # batch mode.
 [ $strong && ($arch == simarm || $arch == simarm64 || $arch == simdbc64) && ($compiler == dartk || $compiler == dartkb) ]
 isolate/mandel_isolate_test: Pass, Timeout
+isolate/nested_spawn2_test: Pass, RuntimeError # RuntimeError caused by timeout
 mirrors/library_uri_io_test: RuntimeError # Please triage.
 
 [ $strong && ($compiler == dartk || $compiler == dartkb) ]