diff --git a/runtime/bin/dart_embedder_api_impl.cc b/runtime/bin/dart_embedder_api_impl.cc
index cf2116a..492aab8 100644
--- a/runtime/bin/dart_embedder_api_impl.cc
+++ b/runtime/bin/dart_embedder_api_impl.cc
@@ -45,9 +45,9 @@
                                         const uint8_t* buffer,
                                         intptr_t buffer_size,
                                         char** error) {
-  Dart_Isolate kernel_isolate = Dart_CreateIsolateGroupFromKernel(
+  Dart_Isolate kernel_isolate = Dart_CreateIsolateFromKernel(
       data.script_uri, data.main, buffer, buffer_size, data.flags,
-      data.isolate_group_data, data.isolate_data, error);
+      data.callback_data, error);
   if (kernel_isolate == nullptr) {
     return nullptr;
   }
@@ -78,9 +78,9 @@
   }
   data.flags->load_vmservice_library = true;
 
-  Dart_Isolate service_isolate = Dart_CreateIsolateGroupFromKernel(
+  Dart_Isolate service_isolate = Dart_CreateIsolateFromKernel(
       data.script_uri, data.main, kernel_buffer, kernel_buffer_size, data.flags,
-      data.isolate_group_data, data.isolate_data, error);
+      data.callback_data, error);
   if (service_isolate == nullptr) {
     return nullptr;
   }
diff --git a/runtime/bin/gen_snapshot.cc b/runtime/bin/gen_snapshot.cc
index f4203b6..fbd41ce 100644
--- a/runtime/bin/gen_snapshot.cc
+++ b/runtime/bin/gen_snapshot.cc
@@ -745,24 +745,23 @@
     isolate_flags.entry_points = no_entry_points;
   }
 
-  auto isolate_group_data = new IsolateGroupData(NULL, NULL, NULL, NULL);
+  IsolateData* isolate_data = new IsolateData(NULL, NULL, NULL, NULL);
   Dart_Isolate isolate;
   char* error = NULL;
   if (isolate_snapshot_data == NULL) {
     // We need to capture the vmservice library in the core snapshot, so load it
     // in the main isolate as well.
     isolate_flags.load_vmservice_library = true;
-    isolate = Dart_CreateIsolateGroupFromKernel(
-        NULL, NULL, kernel_buffer, kernel_buffer_size, &isolate_flags,
-        isolate_group_data, /*isolate_data=*/nullptr, &error);
+    isolate = Dart_CreateIsolateFromKernel(NULL, NULL, kernel_buffer,
+                                           kernel_buffer_size, &isolate_flags,
+                                           isolate_data, &error);
   } else {
-    isolate = Dart_CreateIsolateGroup(NULL, NULL, isolate_snapshot_data,
-                                      isolate_snapshot_instructions, NULL, NULL,
-                                      &isolate_flags, isolate_group_data,
-                                      /*isolate_data=*/nullptr, &error);
+    isolate = Dart_CreateIsolate(NULL, NULL, isolate_snapshot_data,
+                                 isolate_snapshot_instructions, NULL, NULL,
+                                 &isolate_flags, isolate_data, &error);
   }
   if (isolate == NULL) {
-    delete isolate_group_data;
+    delete isolate_data;
     Syslog::PrintErr("%s\n", error);
     free(error);
     return kErrorExitCode;
@@ -784,9 +783,9 @@
   // If the input dill file does not have a root library, then
   // Dart_LoadScript will error.
   //
-  // TODO(kernel): Dart_CreateIsolateGroupFromKernel should respect the root
-  // library in the kernel file, though this requires auditing the other
-  // loading paths in the embedders that had to work around this.
+  // TODO(kernel): Dart_CreateIsolateFromKernel should respect the root library
+  // in the kernel file, though this requires auditing the other loading paths
+  // in the embedders that had to work around this.
   result = Dart_SetRootLibrary(
       Dart_LoadLibraryFromKernel(kernel_buffer, kernel_buffer_size));
   CHECK_RESULT(result);
diff --git a/runtime/bin/isolate_data.cc b/runtime/bin/isolate_data.cc
index bb270a3..54b1050 100644
--- a/runtime/bin/isolate_data.cc
+++ b/runtime/bin/isolate_data.cc
@@ -9,10 +9,10 @@
 namespace dart {
 namespace bin {
 
-IsolateGroupData::IsolateGroupData(const char* url,
-                                   const char* package_root,
-                                   const char* packages_file,
-                                   AppSnapshot* app_snapshot)
+IsolateData::IsolateData(const char* url,
+                         const char* package_root,
+                         const char* packages_file,
+                         AppSnapshot* app_snapshot)
     : script_url((url != NULL) ? strdup(url) : NULL),
       package_root(NULL),
       packages_file(NULL),
@@ -30,7 +30,10 @@
   }
 }
 
-IsolateGroupData::~IsolateGroupData() {
+void IsolateData::OnIsolateShutdown() {
+}
+
+IsolateData::~IsolateData() {
   free(script_url);
   script_url = NULL;
   free(package_root);
diff --git a/runtime/bin/isolate_data.h b/runtime/bin/isolate_data.h
index 07445df..528f397 100644
--- a/runtime/bin/isolate_data.h
+++ b/runtime/bin/isolate_data.h
@@ -31,13 +31,13 @@
 // Data associated with every isolate in the standalone VM
 // embedding. This is used to free external resources for each isolate
 // when the isolate shuts down.
-class IsolateGroupData {
+class IsolateData {
  public:
-  IsolateGroupData(const char* url,
-                   const char* package_root,
-                   const char* packages_file,
-                   AppSnapshot* app_snapshot);
-  ~IsolateGroupData();
+  IsolateData(const char* url,
+              const char* package_root,
+              const char* packages_file,
+              AppSnapshot* app_snapshot);
+  ~IsolateData();
 
   char* script_url;
   char* package_root;
@@ -49,16 +49,16 @@
 
   intptr_t kernel_buffer_size() const { return kernel_buffer_size_; }
 
-  // Associate the given kernel buffer with this IsolateGroupData without
-  // giving it ownership of the 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;
   }
 
-  // Associate the given kernel buffer with this IsolateGroupData and give it
-  // ownership of the buffer. This IsolateGroupData is the first one to own the
+  // 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);
@@ -66,9 +66,9 @@
     kernel_buffer_size_ = size;
   }
 
-  // Associate the given kernel buffer with this IsolateGroupData and give it
+  // Associate the given kernel buffer with this IsolateData and give it
   // ownership of the buffer. The buffer is already owned by another
-  // IsolateGroupData.
+  // IsolateData.
   void SetKernelBufferAlreadyOwned(std::shared_ptr<uint8_t> buffer,
                                    intptr_t size) {
     ASSERT(kernel_buffer_.get() == NULL);
@@ -111,7 +111,7 @@
     dependencies_ = deps;
   }
 
-  bool RunFromAppSnapshot() const { return app_snapshot_ != nullptr; }
+  void OnIsolateShutdown();
 
  private:
   Loader* loader_;
@@ -123,7 +123,7 @@
 
   static void FreeUnownedKernelBuffer(uint8_t*) {}
 
-  DISALLOW_COPY_AND_ASSIGN(IsolateGroupData);
+  DISALLOW_COPY_AND_ASSIGN(IsolateData);
 };
 
 }  // namespace bin
diff --git a/runtime/bin/loader.cc b/runtime/bin/loader.cc
index 9467fa6..a56cdc2 100644
--- a/runtime/bin/loader.cc
+++ b/runtime/bin/loader.cc
@@ -29,9 +29,9 @@
 static const intptr_t _Dart_kImportExtension = 9;
 static const intptr_t _Dart_kResolveAsFilePath = 10;
 
-Loader::Loader(IsolateGroupData* isolate_group_data)
+Loader::Loader(IsolateData* isolate_data)
     : port_(ILLEGAL_PORT),
-      isolate_group_data_(isolate_group_data),
+      isolate_data_(isolate_data),
       error_(Dart_Null()),
       monitor_(),
       pending_operations_(0),
@@ -40,10 +40,10 @@
       results_capacity_(0),
       payload_(NULL),
       payload_length_(0) {
-  ASSERT(isolate_group_data_ != NULL);
+  ASSERT(isolate_data_ != NULL);
   port_ = Dart_NewNativePort("Loader", Loader::NativeMessageHandler, false);
-  isolate_group_data_->set_loader(this);
-  AddLoader(port_, isolate_group_data_);
+  isolate_data_->set_loader(this);
+  AddLoader(port_, isolate_data_);
 }
 
 Loader::~Loader() {
@@ -55,8 +55,8 @@
   monitor_.Exit();
   RemoveLoader(port_);
   port_ = ILLEGAL_PORT;
-  isolate_group_data_->set_loader(NULL);
-  isolate_group_data_ = NULL;
+  isolate_data_->set_loader(NULL);
+  isolate_data_ = NULL;
   for (intptr_t i = 0; i < results_length_; i++) {
     results_[i].Cleanup();
   }
@@ -263,7 +263,7 @@
 
 void Loader::AddDependencyLocked(Loader* loader, const char* resolved_uri) {
   MallocGrowableArray<char*>* dependencies =
-      loader->isolate_group_data_->dependencies();
+      loader->isolate_data_->dependencies();
   if (dependencies == NULL) {
     return;
   }
@@ -271,10 +271,10 @@
 }
 
 void Loader::ResolveDependenciesAsFilePaths() {
-  IsolateGroupData* isolate_group_data =
-      reinterpret_cast<IsolateGroupData*>(Dart_CurrentIsolateGroupData());
-  ASSERT(isolate_group_data != NULL);
-  MallocGrowableArray<char*>* dependencies = isolate_group_data->dependencies();
+  IsolateData* isolate_data =
+      reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
+  ASSERT(isolate_data != NULL);
+  MallocGrowableArray<char*>* dependencies = isolate_data->dependencies();
   if (dependencies == NULL) {
     return;
   }
@@ -455,15 +455,14 @@
 }
 
 void Loader::InitForSnapshot(const char* snapshot_uri) {
-  IsolateGroupData* isolate_group_data =
-      reinterpret_cast<IsolateGroupData*>(Dart_CurrentIsolateGroupData());
-  ASSERT(isolate_group_data != NULL);
-  ASSERT(!isolate_group_data->HasLoader());
+  IsolateData* isolate_data =
+      reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
+  ASSERT(isolate_data != NULL);
+  ASSERT(!isolate_data->HasLoader());
   // Setup a loader. The constructor does a bunch of leg work.
-  Loader* loader = new Loader(isolate_group_data);
+  Loader* loader = new Loader(isolate_data);
   // Send the init message.
-  loader->Init(isolate_group_data->package_root,
-               isolate_group_data->packages_file,
+  loader->Init(isolate_data->package_root, isolate_data->packages_file,
                DartUtils::original_working_directory, snapshot_uri);
   // Destroy the loader. The destructor does a bunch of leg work.
   delete loader;
@@ -517,19 +516,18 @@
                                         Dart_Handle url,
                                         uint8_t** payload,
                                         intptr_t* payload_length) {
-  IsolateGroupData* isolate_group_data =
-      reinterpret_cast<IsolateGroupData*>(Dart_CurrentIsolateGroupData());
-  ASSERT(isolate_group_data != NULL);
-  ASSERT(!isolate_group_data->HasLoader());
+  IsolateData* isolate_data =
+      reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
+  ASSERT(isolate_data != NULL);
+  ASSERT(!isolate_data->HasLoader());
   Loader* loader = NULL;
 
   // Setup the loader. The constructor does a bunch of leg work.
-  loader = new Loader(isolate_group_data);
-  loader->Init(isolate_group_data->package_root,
-               isolate_group_data->packages_file,
+  loader = new Loader(isolate_data);
+  loader->Init(isolate_data->package_root, isolate_data->packages_file,
                DartUtils::original_working_directory, NULL);
   ASSERT(loader != NULL);
-  ASSERT(isolate_group_data->HasLoader());
+  ASSERT(isolate_data->HasLoader());
 
   // Now send a load request to the service isolate.
   loader->SendRequest(tag, url, Dart_Null());
@@ -681,9 +679,9 @@
     }
   }
 
-  IsolateGroupData* isolate_group_data =
-      reinterpret_cast<IsolateGroupData*>(Dart_CurrentIsolateGroupData());
-  ASSERT(isolate_group_data != NULL);
+  IsolateData* isolate_data =
+      reinterpret_cast<IsolateData*>(Dart_CurrentIsolateData());
+  ASSERT(isolate_data != NULL);
   if ((tag == Dart_kScriptTag) && Dart_IsString(library)) {
     // Update packages file for isolate.
     const char* packages_file = NULL;
@@ -691,26 +689,25 @@
     if (Dart_IsError(result)) {
       return result;
     }
-    isolate_group_data->UpdatePackagesFile(packages_file);
+    isolate_data->UpdatePackagesFile(packages_file);
   }
   // Grab this isolate's loader.
   Loader* loader = NULL;
 
   // The outer invocation of the tag handler for this isolate. We make the outer
   // invocation block and allow any nested invocations to operate in parallel.
-  const bool blocking_call = !isolate_group_data->HasLoader();
+  const bool blocking_call = !isolate_data->HasLoader();
 
   // If we are the outer invocation of the tag handler and the tag is an import
   // this means that we are starting a deferred library load.
   const bool is_deferred_import = blocking_call && (tag == Dart_kImportTag);
-  if (!isolate_group_data->HasLoader()) {
+  if (!isolate_data->HasLoader()) {
     // The isolate doesn't have a loader -- this is the outer invocation which
     // will block.
 
     // Setup the loader. The constructor does a bunch of leg work.
-    loader = new Loader(isolate_group_data);
-    loader->Init(isolate_group_data->package_root,
-                 isolate_group_data->packages_file,
+    loader = new Loader(isolate_data);
+    loader->Init(isolate_data->package_root, isolate_data->packages_file,
                  DartUtils::original_working_directory,
                  (tag == Dart_kScriptTag) ? url_string : NULL);
   } else {
@@ -718,10 +715,10 @@
     // The isolate has a loader -- this is an inner invocation that will queue
     // work with the service isolate.
     // Use the existing loader.
-    loader = isolate_group_data->loader();
+    loader = isolate_data->loader();
   }
   ASSERT(loader != NULL);
-  ASSERT(isolate_group_data->HasLoader());
+  ASSERT(isolate_data->HasLoader());
 
   if (DartUtils::IsDartExtensionSchemeURL(url_string)) {
     loader->SendImportExtensionRequest(url, Dart_LibraryUrl(library));
@@ -818,11 +815,11 @@
 intptr_t Loader::loader_infos_length_ = 0;
 intptr_t Loader::loader_infos_capacity_ = 0;
 
-// Add a mapping from |port| to |isolate_group_data| (really the loader). When a
+// Add a mapping from |port| to |isolate_data| (really the loader). When a
 // native message arrives, we use this map to report the I/O result to the
 // correct loader.
 // This happens whenever an isolate begins loading.
-void Loader::AddLoader(Dart_Port port, IsolateGroupData* isolate_group_data) {
+void Loader::AddLoader(Dart_Port port, IsolateData* isolate_data) {
   MutexLocker ml(loader_infos_lock_);
   ASSERT(LoaderForLocked(port) == NULL);
   if (loader_infos_length_ == loader_infos_capacity_) {
@@ -835,12 +832,12 @@
     // Initialize new entries.
     for (intptr_t i = loader_infos_length_; i < loader_infos_capacity_; i++) {
       loader_infos_[i].port = ILLEGAL_PORT;
-      loader_infos_[i].isolate_group_data = NULL;
+      loader_infos_[i].isolate_data = NULL;
     }
   }
   ASSERT(loader_infos_length_ < loader_infos_capacity_);
   loader_infos_[loader_infos_length_].port = port;
-  loader_infos_[loader_infos_length_].isolate_group_data = isolate_group_data;
+  loader_infos_[loader_infos_length_].isolate_data = isolate_data;
   loader_infos_length_++;
   ASSERT(LoaderForLocked(port) != NULL);
 }
@@ -874,7 +871,7 @@
   if (index < 0) {
     return NULL;
   }
-  return loader_infos_[index].isolate_group_data->loader();
+  return loader_infos_[index].isolate_data->loader();
 }
 
 Loader* Loader::LoaderFor(Dart_Port port) {
diff --git a/runtime/bin/loader.h b/runtime/bin/loader.h
index d2f950a..4142c89 100644
--- a/runtime/bin/loader.h
+++ b/runtime/bin/loader.h
@@ -17,7 +17,7 @@
 
 class Loader {
  public:
-  explicit Loader(IsolateGroupData* isolate_group_data);
+  explicit Loader(IsolateData* isolate_data);
   ~Loader();
 
   static void InitForSnapshot(const char* snapshot_uri);
@@ -43,8 +43,8 @@
  private:
   // The port assigned to our native message handler.
   Dart_Port port_;
-  // Each Loader is associated with an Isolate via its IsolateGroupData.
-  IsolateGroupData* isolate_group_data_;
+  // Each Loader is associated with an Isolate via its IsolateData.
+  IsolateData* isolate_data_;
   // Remember the first error that occurs during loading.
   Dart_Handle error_;
   // This monitor is used to protect the pending operations count and the
@@ -128,12 +128,12 @@
 
   // We use one native message handler callback for N loaders. The native
   // message handler callback provides us with the Dart_Port which we use as a
-  // key into our map of active loaders from |port| to |isolate_group_data|.
+  // key into our map of active loaders from |port| to |isolate_data|.
 
   // Static information to map Dart_Port back to the isolate in question.
   struct LoaderInfo {
     Dart_Port port;
-    IsolateGroupData* isolate_group_data;
+    IsolateData* isolate_data;
   };
 
   // The map of active loaders.
@@ -142,7 +142,7 @@
   static intptr_t loader_infos_length_;
   static intptr_t loader_infos_capacity_;
 
-  static void AddLoader(Dart_Port port, IsolateGroupData* data);
+  static void AddLoader(Dart_Port port, IsolateData* data);
   static void RemoveLoader(Dart_Port port);
   static intptr_t LoaderIndexFor(Dart_Port port);
   static Loader* LoaderFor(Dart_Port port);
diff --git a/runtime/bin/main.cc b/runtime/bin/main.cc
index 222c092..c9edf66 100644
--- a/runtime/bin/main.cc
+++ b/runtime/bin/main.cc
@@ -133,10 +133,10 @@
     return;
   }
   Loader::ResolveDependenciesAsFilePaths();
-  auto isolate_group_data =
-      reinterpret_cast<IsolateGroupData*>(Dart_IsolateGroupData(isolate));
-  ASSERT(isolate_group_data != NULL);
-  MallocGrowableArray<char*>* dependencies = isolate_group_data->dependencies();
+  IsolateData* isolate_data =
+      reinterpret_cast<IsolateData*>(Dart_IsolateData(isolate));
+  ASSERT(isolate_data != NULL);
+  MallocGrowableArray<char*>* dependencies = isolate_data->dependencies();
   ASSERT(dependencies != NULL);
   File* file =
       File::Open(NULL, Options::depfile(), File::kWriteTruncate);
@@ -191,145 +191,57 @@
   }
 }
 
-static Dart_Handle SetupCoreLibraries(Dart_Isolate isolate,
-                                      IsolateGroupData* isolate_group_data,
-                                      bool is_isolate_group_start,
-                                      const char** resolved_packages_config) {
-  const auto packages_file = isolate_group_data->packages_file;
-  const auto script_uri = isolate_group_data->script_url;
-
-  Dart_Handle result;
-
-  // Set up the library tag handler for this isolate.
-  result = Dart_SetLibraryTagHandler(Loader::LibraryTagHandler);
-  if (Dart_IsError(result)) return result;
-
-  // Prepare builtin and other core libraries for use to resolve URIs.
-  // Set up various closures, e.g: printing, timers etc.
-  // Set up 'package root' for URI resolution.
-  result = DartUtils::PrepareForScriptLoading(false, Options::trace_loading());
-  if (Dart_IsError(result)) return result;
-
-  if (Dart_IsVMFlagSet("support_service") || !Dart_IsPrecompiledRuntime()) {
-    // Set up the load port provided by the service isolate so that we can
-    // load scripts.
-    result = DartUtils::SetupServiceLoadPort();
-    if (Dart_IsError(result)) return result;
-  }
-
-  // Setup package root if specified.
-  result = DartUtils::SetupPackageRoot(nullptr, packages_file);
-  if (Dart_IsError(result)) return result;
-  if (!Dart_IsNull(result) && resolved_packages_config != nullptr) {
-    result = Dart_StringToCString(result, resolved_packages_config);
-    if (Dart_IsError(result)) return result;
-    ASSERT(*resolved_packages_config != nullptr);
-
-#if !defined(DART_PRECOMPILED_RUNTIME)
-    if (is_isolate_group_start) {
-      isolate_group_data->set_resolved_packages_config(
-          *resolved_packages_config);
-    } else {
-      ASSERT(strcmp(isolate_group_data->resolved_packages_config(),
-                    *resolved_packages_config) == 0);
-    }
-#endif
-  }
-
-  result = Dart_SetEnvironmentCallback(DartUtils::EnvironmentCallback);
-  if (Dart_IsError(result)) return result;
-
-  // Setup the native resolver as the snapshot does not carry it.
-  Builtin::SetNativeResolver(Builtin::kBuiltinLibrary);
-  Builtin::SetNativeResolver(Builtin::kIOLibrary);
-  Builtin::SetNativeResolver(Builtin::kCLILibrary);
-  VmService::SetNativeResolver();
-
-  const char* namespc =
-      Dart_IsKernelIsolate(isolate) ? NULL : Options::namespc();
-  result =
-      DartUtils::SetupIOLibrary(namespc, script_uri, Options::exit_disabled());
-  if (Dart_IsError(result)) return result;
-
-  return Dart_Null();
-}
-
-static bool OnIsolateInitialize(void** child_callback_data, char** error) {
-  Dart_Isolate isolate = Dart_CurrentIsolate();
-  ASSERT(isolate != nullptr);
-
-  auto isolate_group_data =
-      reinterpret_cast<IsolateGroupData*>(Dart_CurrentIsolateGroupData());
-
-  Dart_EnterScope();
-  const auto script_uri = isolate_group_data->script_url;
-  const bool isolate_run_app_snapshot =
-      isolate_group_data->RunFromAppSnapshot();
-  Dart_Handle result = SetupCoreLibraries(isolate, isolate_group_data,
-                                          /*group_start=*/false,
-                                          /*resolved_packages_config=*/nullptr);
-  if (Dart_IsError(result)) goto failed;
-
-  if (isolate_run_app_snapshot) {
-    if (Dart_IsVMFlagSet("support_service") || !Dart_IsPrecompiledRuntime()) {
-      Loader::InitForSnapshot(script_uri);
-    }
-  } else {
-    result = DartUtils::ResolveScript(Dart_NewStringFromCString(script_uri));
-    if (Dart_IsError(result)) return result;
-
-    if (isolate_group_data->kernel_buffer().get() != nullptr) {
-      // Various core-library parts will send requests to the Loader to resolve
-      // relative URIs and perform other related tasks. We need Loader to be
-      // initialized for this to work because loading from Kernel binary
-      // bypasses normal source code loading paths that initialize it.
-      const char* resolved_script_uri = NULL;
-      result = Dart_StringToCString(result, &resolved_script_uri);
-      if (Dart_IsError(result)) return result;
-      Loader::InitForSnapshot(resolved_script_uri);
-    }
-  }
-
-  if (isolate_run_app_snapshot) {
-    result = Loader::ReloadNativeExtensions();
-    if (Dart_IsError(result)) goto failed;
-  }
-
-  // Make the isolate runnable so that it is ready to handle messages.
-  Dart_ExitScope();
-  Dart_ExitIsolate();
-  *error = Dart_IsolateMakeRunnable(isolate);
-  Dart_EnterIsolate(isolate);
-  return *error == nullptr;
-
-failed:
-  *error = strdup(Dart_GetError(result));
-  Dart_ExitScope();
-  return false;
-}
-
 static Dart_Isolate IsolateSetupHelper(Dart_Isolate isolate,
                                        bool is_main_isolate,
                                        const char* script_uri,
+                                       const char* package_root,
                                        const char* packages_config,
                                        bool isolate_run_app_snapshot,
                                        Dart_IsolateFlags* flags,
                                        char** error,
                                        int* exit_code) {
   Dart_EnterScope();
+#if !defined(DART_PRECOMPILED_RUNTIME)
+  IsolateData* isolate_data =
+      reinterpret_cast<IsolateData*>(Dart_IsolateData(isolate));
+  const uint8_t* kernel_buffer = isolate_data->kernel_buffer().get();
+  intptr_t kernel_buffer_size = isolate_data->kernel_buffer_size();
+#endif
 
-  auto isolate_group_data =
-      reinterpret_cast<IsolateGroupData*>(Dart_IsolateGroupData(isolate));
+  // Set up the library tag handler for this isolate.
+  Dart_Handle result = Dart_SetLibraryTagHandler(Loader::LibraryTagHandler);
+  CHECK_RESULT(result);
 
-  const char* resolved_packages_config = nullptr;
-  Dart_Handle result = SetupCoreLibraries(isolate, isolate_group_data,
-                                          /*is_isolate_group_start=*/true,
-                                          &resolved_packages_config);
+  // Prepare builtin and other core libraries for use to resolve URIs.
+  // Set up various closures, e.g: printing, timers etc.
+  // Set up 'package root' for URI resolution.
+  result = DartUtils::PrepareForScriptLoading(false, Options::trace_loading());
+  CHECK_RESULT(result);
+
+  if (Dart_IsVMFlagSet("support_service") || !Dart_IsPrecompiledRuntime()) {
+    // Set up the load port provided by the service isolate so that we can
+    // load scripts.
+    result = DartUtils::SetupServiceLoadPort();
+    CHECK_RESULT(result);
+  }
+
+  // Setup package root if specified.
+  result = DartUtils::SetupPackageRoot(NULL, packages_config);
+  CHECK_RESULT(result);
+  const char* resolved_packages_config = NULL;
+  if (!Dart_IsNull(result)) {
+    result = Dart_StringToCString(result, &resolved_packages_config);
+    CHECK_RESULT(result);
+    ASSERT(resolved_packages_config != NULL);
+#if !defined(DART_PRECOMPILED_RUNTIME)
+    isolate_data->set_resolved_packages_config(resolved_packages_config);
+#endif
+  }
+
+  result = Dart_SetEnvironmentCallback(DartUtils::EnvironmentCallback);
   CHECK_RESULT(result);
 
 #if !defined(DART_PRECOMPILED_RUNTIME)
-  const uint8_t* kernel_buffer = isolate_group_data->kernel_buffer().get();
-  intptr_t kernel_buffer_size = isolate_group_data->kernel_buffer_size();
   if (!isolate_run_app_snapshot && kernel_buffer == NULL &&
       !Dart_IsKernelIsolate(isolate)) {
     if (!dfe.CanUseDartFrontend()) {
@@ -353,8 +265,8 @@
       Dart_ShutdownIsolate();
       return NULL;
     }
-    isolate_group_data->SetKernelBufferNewlyOwned(
-        application_kernel_buffer, application_kernel_buffer_size);
+    isolate_data->SetKernelBufferNewlyOwned(application_kernel_buffer,
+                                            application_kernel_buffer_size);
     kernel_buffer = application_kernel_buffer;
     kernel_buffer_size = application_kernel_buffer_size;
   }
@@ -368,12 +280,23 @@
   }
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 
+  // Setup the native resolver as the snapshot does not carry it.
+  Builtin::SetNativeResolver(Builtin::kBuiltinLibrary);
+  Builtin::SetNativeResolver(Builtin::kIOLibrary);
+  Builtin::SetNativeResolver(Builtin::kCLILibrary);
+  VmService::SetNativeResolver();
+
   if (isolate_run_app_snapshot) {
     Dart_Handle result = Loader::ReloadNativeExtensions();
     CHECK_RESULT(result);
   }
 
+  const char* namespc =
+      Dart_IsKernelIsolate(isolate) ? NULL : Options::namespc();
   if (isolate_run_app_snapshot) {
+    result = DartUtils::SetupIOLibrary(namespc, script_uri,
+                                       Options::exit_disabled());
+    CHECK_RESULT(result);
     if (Dart_IsVMFlagSet("support_service") || !Dart_IsPrecompiledRuntime()) {
       Loader::InitForSnapshot(script_uri);
     }
@@ -413,6 +336,10 @@
     Dart_TimelineEvent("LoadScript", Dart_TimelineGetMicros(),
                        Dart_GetMainPortId(), Dart_Timeline_Event_Async_End, 0,
                        NULL, NULL);
+
+    result = DartUtils::SetupIOLibrary(namespc, script_uri,
+                                       Options::exit_disabled());
+    CHECK_RESULT(result);
 #else
     UNREACHABLE();
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
@@ -470,7 +397,7 @@
   }
 
   Dart_Isolate isolate = NULL;
-  IsolateGroupData* isolate_group_data = NULL;
+  IsolateData* isolate_data = NULL;
   bool isolate_run_app_snapshot = false;
   AppSnapshot* app_snapshot = NULL;
   // Kernel isolate uses an app snapshot or uses the dill file.
@@ -485,43 +412,42 @@
     app_snapshot->SetBuffers(
         &ignore_vm_snapshot_data, &ignore_vm_snapshot_instructions,
         &isolate_snapshot_data, &isolate_snapshot_instructions);
-    isolate_group_data =
-        new IsolateGroupData(uri, package_root, packages_config, app_snapshot);
-    isolate = Dart_CreateIsolateGroup(
+    isolate_data =
+        new IsolateData(uri, package_root, packages_config, app_snapshot);
+    isolate = Dart_CreateIsolate(
         DART_KERNEL_ISOLATE_NAME, DART_KERNEL_ISOLATE_NAME,
         isolate_snapshot_data, isolate_snapshot_instructions,
         app_isolate_shared_data, app_isolate_shared_instructions, flags,
-        isolate_group_data, /*isolate_data=*/nullptr, error);
+        isolate_data, error);
   }
   if (isolate == NULL) {
     // Clear error from app snapshot and re-trying from kernel file.
     free(*error);
     *error = NULL;
-    delete isolate_group_data;
+    delete isolate_data;
 
     const uint8_t* kernel_service_buffer = NULL;
     intptr_t kernel_service_buffer_size = 0;
     dfe.LoadKernelService(&kernel_service_buffer, &kernel_service_buffer_size);
     ASSERT(kernel_service_buffer != NULL);
-    isolate_group_data =
-        new IsolateGroupData(uri, package_root, packages_config, NULL);
-    isolate_group_data->SetKernelBufferUnowned(
+    isolate_data = new IsolateData(uri, package_root, packages_config, NULL);
+    isolate_data->SetKernelBufferUnowned(
         const_cast<uint8_t*>(kernel_service_buffer),
         kernel_service_buffer_size);
-    isolate = Dart_CreateIsolateGroupFromKernel(
+    isolate = Dart_CreateIsolateFromKernel(
         DART_KERNEL_ISOLATE_NAME, DART_KERNEL_ISOLATE_NAME,
-        kernel_service_buffer, kernel_service_buffer_size, flags,
-        isolate_group_data, nullptr, error);
+        kernel_service_buffer, kernel_service_buffer_size, flags, isolate_data,
+        error);
   }
 
   if (isolate == NULL) {
     Syslog::PrintErr("%s\n", *error);
-    delete isolate_group_data;
+    delete isolate_data;
     return NULL;
   }
   kernel_isolate_is_running = true;
 
-  return IsolateSetupHelper(isolate, false, uri, packages_config,
+  return IsolateSetupHelper(isolate, false, uri, package_root, packages_config,
                             isolate_run_app_snapshot, flags, error, exit_code);
 }
 #endif  // !defined(EXCLUDE_CFE_AND_KERNEL_PLATFORM)
@@ -537,19 +463,18 @@
                                                  int* exit_code) {
   ASSERT(script_uri != NULL);
   Dart_Isolate isolate = NULL;
-  IsolateGroupData* isolate_group_data =
-      new IsolateGroupData(script_uri, package_root, packages_config, NULL);
+  IsolateData* isolate_data =
+      new IsolateData(script_uri, package_root, packages_config, NULL);
 
 #if defined(DART_PRECOMPILED_RUNTIME)
   // AOT: All isolates start from the app snapshot.
   const uint8_t* isolate_snapshot_data = app_isolate_snapshot_data;
   const uint8_t* isolate_snapshot_instructions =
       app_isolate_snapshot_instructions;
-  isolate = Dart_CreateIsolateGroup(
+  isolate = Dart_CreateIsolate(
       script_uri, DART_VM_SERVICE_ISOLATE_NAME, isolate_snapshot_data,
       isolate_snapshot_instructions, app_isolate_shared_data,
-      app_isolate_shared_instructions, flags, isolate_group_data,
-      /*isolate_data=*/nullptr, error);
+      app_isolate_shared_instructions, flags, isolate_data, error);
 #else
   // JIT: Service isolate uses the core libraries snapshot.
 
@@ -559,14 +484,13 @@
   const uint8_t* isolate_snapshot_data = core_isolate_snapshot_data;
   const uint8_t* isolate_snapshot_instructions =
       core_isolate_snapshot_instructions;
-  isolate = Dart_CreateIsolateGroup(
+  isolate = Dart_CreateIsolate(
       script_uri, DART_VM_SERVICE_ISOLATE_NAME, isolate_snapshot_data,
       isolate_snapshot_instructions, app_isolate_shared_data,
-      app_isolate_shared_instructions, flags, isolate_group_data,
-      /*isolate_data=*/nullptr, error);
+      app_isolate_shared_instructions, flags, isolate_data, error);
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
   if (isolate == NULL) {
-    delete isolate_group_data;
+    delete isolate_data;
     return NULL;
   }
 
@@ -595,16 +519,15 @@
 }
 
 // Returns newly created Isolate on success, NULL on failure.
-static Dart_Isolate CreateIsolateGroupAndSetupHelper(
-    bool is_main_isolate,
-    const char* script_uri,
-    const char* name,
-    const char* package_root,
-    const char* packages_config,
-    Dart_IsolateFlags* flags,
-    void* callback_data,
-    char** error,
-    int* exit_code) {
+static Dart_Isolate CreateIsolateAndSetupHelper(bool is_main_isolate,
+                                                const char* script_uri,
+                                                const char* name,
+                                                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;
@@ -644,8 +567,8 @@
   }
 
   if (flags->copy_parent_code && callback_data) {
-    IsolateGroupData* parent_isolate_data =
-        reinterpret_cast<IsolateGroupData*>(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();
@@ -656,19 +579,19 @@
   }
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 
-  IsolateGroupData* isolate_group_data = new IsolateGroupData(
-      script_uri, package_root, packages_config, app_snapshot);
+  IsolateData* isolate_data =
+      new IsolateData(script_uri, package_root, packages_config, app_snapshot);
   if (kernel_buffer != NULL) {
     if (parent_kernel_buffer) {
-      isolate_group_data->SetKernelBufferAlreadyOwned(
-          std::move(parent_kernel_buffer), kernel_buffer_size);
+      isolate_data->SetKernelBufferAlreadyOwned(std::move(parent_kernel_buffer),
+                                                kernel_buffer_size);
     } else {
-      isolate_group_data->SetKernelBufferNewlyOwned(kernel_buffer,
-                                                    kernel_buffer_size);
+      isolate_data->SetKernelBufferNewlyOwned(kernel_buffer,
+                                              kernel_buffer_size);
     }
   }
   if (is_main_isolate && (Options::depfile() != NULL)) {
-    isolate_group_data->set_dependencies(new MallocGrowableArray<char*>());
+    isolate_data->set_dependencies(new MallocGrowableArray<char*>());
   }
 
   Dart_Isolate isolate = NULL;
@@ -695,45 +618,45 @@
     // TODO(sivachandra): When the platform program is unavailable, check if
     // application kernel binary is self contained or an incremental binary.
     // Isolate should be created only if it is a self contained kernel binary.
-    isolate = Dart_CreateIsolateGroupFromKernel(
+    isolate = Dart_CreateIsolateFromKernel(
         script_uri, name, platform_kernel_buffer, platform_kernel_buffer_size,
-        flags, isolate_group_data, /*isolate_data=*/nullptr, error);
+        flags, isolate_data, error);
   } else {
-    isolate = Dart_CreateIsolateGroup(
+    isolate = Dart_CreateIsolate(
         script_uri, name, isolate_snapshot_data, isolate_snapshot_instructions,
         app_isolate_shared_data, app_isolate_shared_instructions, flags,
-        isolate_group_data, /*isolate_data=*/nullptr, error);
+        isolate_data, error);
   }
 #else
-  isolate = Dart_CreateIsolateGroup(
+  isolate = Dart_CreateIsolate(
       script_uri, name, isolate_snapshot_data, isolate_snapshot_instructions,
       app_isolate_shared_data, app_isolate_shared_instructions, flags,
-      isolate_group_data, /*isolate_data=*/nullptr, error);
+      isolate_data, error);
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)
 
   Dart_Isolate created_isolate = NULL;
   if (isolate == NULL) {
-    delete isolate_group_data;
+    delete isolate_data;
   } else {
     created_isolate = IsolateSetupHelper(
-        isolate, is_main_isolate, script_uri, packages_config,
+        isolate, is_main_isolate, script_uri, package_root, packages_config,
         isolate_run_app_snapshot, flags, error, exit_code);
   }
   int64_t end = Dart_TimelineGetMicros();
-  Dart_TimelineEvent("CreateIsolateGroupAndSetupHelper", start, end,
+  Dart_TimelineEvent("CreateIsolateAndSetupHelper", start, end,
                      Dart_Timeline_Event_Duration, 0, NULL, NULL);
   return created_isolate;
 }
 
 #undef CHECK_RESULT
 
-static Dart_Isolate CreateIsolateGroupAndSetup(const char* script_uri,
-                                               const char* main,
-                                               const char* package_root,
-                                               const char* package_config,
-                                               Dart_IsolateFlags* flags,
-                                               void* callback_data,
-                                               char** error) {
+static Dart_Isolate CreateIsolateAndSetup(const char* script_uri,
+                                          const char* main,
+                                          const char* package_root,
+                                          const char* package_config,
+                                          Dart_IsolateFlags* flags,
+                                          void* callback_data,
+                                          char** error) {
   // The VM should never call the isolate helper with a NULL flags.
   ASSERT(flags != NULL);
   ASSERT(flags->version == DART_FLAGS_CURRENT_VERSION);
@@ -756,23 +679,28 @@
         script_uri, package_root, package_config, flags, error, &exit_code);
   }
   bool is_main_isolate = false;
-  return CreateIsolateGroupAndSetupHelper(is_main_isolate, script_uri, main,
-                                          package_root, package_config, flags,
-                                          callback_data, error, &exit_code);
+  return CreateIsolateAndSetupHelper(is_main_isolate, script_uri, main,
+                                     package_root, package_config, flags,
+                                     callback_data, error, &exit_code);
 }
 
-static void OnIsolateShutdown(void* isolate_group_data, void* isolate_data) {
+static void OnIsolateShutdown(void* callback_data) {
   Dart_EnterScope();
+
   Dart_Handle sticky_error = Dart_GetStickyError();
   if (!Dart_IsNull(sticky_error) && !Dart_IsFatalError(sticky_error)) {
     Syslog::PrintErr("%s\n", Dart_GetError(sticky_error));
   }
+
+  IsolateData* isolate_data = reinterpret_cast<IsolateData*>(callback_data);
+  isolate_data->OnIsolateShutdown();
+
   Dart_ExitScope();
 }
 
-static void DeleteIsolateGroupData(void* callback_data) {
-  auto isolate_group_data = reinterpret_cast<IsolateGroupData*>(callback_data);
-  delete isolate_group_data;
+static void DeleteIsolateData(void* callback_data) {
+  IsolateData* isolate_data = reinterpret_cast<IsolateData*>(callback_data);
+  delete isolate_data;
 }
 
 static const char* kStdoutStreamId = "Stdout";
@@ -861,7 +789,7 @@
 }
 
 bool RunMainIsolate(const char* script_name, CommandLineOptions* dart_options) {
-  // Call CreateIsolateGroupAndSetup which creates an isolate and loads up
+  // Call CreateIsolateAndSetup which creates an isolate and loads up
   // the specified application script.
   char* error = NULL;
   bool is_main_isolate = true;
@@ -869,7 +797,7 @@
   Dart_IsolateFlags flags;
   Dart_IsolateFlagsInitialize(&flags);
 
-  Dart_Isolate isolate = CreateIsolateGroupAndSetupHelper(
+  Dart_Isolate isolate = CreateIsolateAndSetupHelper(
       is_main_isolate, script_name, "main", Options::package_root(),
       Options::packages_file(), &flags, NULL /* callback_data */, &error,
       &exit_code);
@@ -897,8 +825,8 @@
 
   Dart_EnterScope();
 
-  auto isolate_group_data =
-      reinterpret_cast<IsolateGroupData*>(Dart_IsolateGroupData(isolate));
+  IsolateData* isolate_data =
+      reinterpret_cast<IsolateData*>(Dart_IsolateData(isolate));
   if (Options::gen_snapshot_kind() == kKernel) {
     if (vm_run_app_snapshot) {
       Syslog::PrintErr(
@@ -908,7 +836,7 @@
       Platform::Exit(kErrorExitCode);
     }
     Snapshot::GenerateKernel(Options::snapshot_filename(), script_name,
-                             isolate_group_data->resolved_packages_config());
+                             isolate_data->resolved_packages_config());
   } else {
     // Lookup the library of the root script.
     Dart_Handle root_lib = Dart_RootLibrary();
@@ -1181,11 +1109,9 @@
   init_params.version = DART_INITIALIZE_PARAMS_CURRENT_VERSION;
   init_params.vm_snapshot_data = vm_snapshot_data;
   init_params.vm_snapshot_instructions = vm_snapshot_instructions;
-  init_params.create_group = CreateIsolateGroupAndSetup;
-  init_params.initialize_isolate = OnIsolateInitialize;
-  init_params.shutdown_isolate = OnIsolateShutdown;
-  init_params.cleanup_isolate = nullptr;
-  init_params.cleanup_group = DeleteIsolateGroupData;
+  init_params.create = CreateIsolateAndSetup;
+  init_params.shutdown = OnIsolateShutdown;
+  init_params.cleanup = DeleteIsolateData;
   init_params.file_open = DartUtils::OpenFile;
   init_params.file_read = DartUtils::ReadFile;
   init_params.file_write = DartUtils::WriteFile;
diff --git a/runtime/bin/run_vm_tests.cc b/runtime/bin/run_vm_tests.cc
index 6f5a877..019522b 100644
--- a/runtime/bin/run_vm_tests.cc
+++ b/runtime/bin/run_vm_tests.cc
@@ -127,7 +127,7 @@
     return NULL;
   }
   Dart_Isolate isolate = NULL;
-  bin::IsolateGroupData* isolate_group_data = NULL;
+  bin::IsolateData* isolate_data = NULL;
   const uint8_t* kernel_service_buffer = NULL;
   intptr_t kernel_service_buffer_size = 0;
 
@@ -146,12 +146,12 @@
     app_snapshot->SetBuffers(
         &ignore_vm_snapshot_data, &ignore_vm_snapshot_instructions,
         &isolate_snapshot_data, &isolate_snapshot_instructions);
-    isolate_group_data = new bin::IsolateGroupData(
-        script_uri, package_root, packages_config, app_snapshot);
-    isolate = Dart_CreateIsolateGroup(
-        DART_KERNEL_ISOLATE_NAME, DART_KERNEL_ISOLATE_NAME,
-        isolate_snapshot_data, isolate_snapshot_instructions, NULL, NULL, flags,
-        isolate_group_data, /*isolate_data=*/nullptr, error);
+    isolate_data = new bin::IsolateData(script_uri, package_root,
+                                        packages_config, app_snapshot);
+    isolate =
+        Dart_CreateIsolate(DART_KERNEL_ISOLATE_NAME, DART_KERNEL_ISOLATE_NAME,
+                           isolate_snapshot_data, isolate_snapshot_instructions,
+                           NULL, NULL, flags, isolate_data, error);
     if (*error != NULL) {
       free(*error);
       *error = NULL;
@@ -161,29 +161,29 @@
     // This can cause the isolate to be killed early which will return `nullptr`
     // here.
     if (isolate == nullptr) {
-      delete isolate_group_data;
+      delete isolate_data;
       return NULL;
     }
   }
   if (isolate == NULL) {
-    delete isolate_group_data;
-    isolate_group_data = NULL;
+    delete isolate_data;
+    isolate_data = NULL;
 
     bin::dfe.Init();
     bin::dfe.LoadKernelService(&kernel_service_buffer,
                                &kernel_service_buffer_size);
     ASSERT(kernel_service_buffer != NULL);
-    isolate_group_data = new bin::IsolateGroupData(script_uri, package_root,
-                                                   packages_config, NULL);
-    isolate_group_data->SetKernelBufferUnowned(
+    isolate_data =
+        new bin::IsolateData(script_uri, package_root, packages_config, NULL);
+    isolate_data->SetKernelBufferUnowned(
         const_cast<uint8_t*>(kernel_service_buffer),
         kernel_service_buffer_size);
-    isolate = Dart_CreateIsolateGroupFromKernel(
+    isolate = Dart_CreateIsolateFromKernel(
         script_uri, main, kernel_service_buffer, kernel_service_buffer_size,
-        flags, isolate_group_data, /*isolate_data=*/nullptr, error);
+        flags, isolate_data, error);
   }
   if (isolate == NULL) {
-    delete isolate_group_data;
+    delete isolate_data;
     return NULL;
   }
 
@@ -213,9 +213,9 @@
   return isolate;
 }
 
-static void CleanupIsolateGroup(void* callback_data) {
-  bin::IsolateGroupData* isolate_data =
-      reinterpret_cast<bin::IsolateGroupData*>(callback_data);
+static void CleanupIsolate(void* callback_data) {
+  bin::IsolateData* isolate_data =
+      reinterpret_cast<bin::IsolateData*>(callback_data);
   delete isolate_data;
 }
 
@@ -311,22 +311,18 @@
 
   TesterState::vm_snapshot_data = dart::bin::vm_snapshot_data;
   TesterState::create_callback = CreateIsolateAndSetup;
-  TesterState::group_cleanup_callback = CleanupIsolateGroup;
+  TesterState::cleanup_callback = CleanupIsolate;
   TesterState::argv = dart_argv;
   TesterState::argc = dart_argc;
 
   error = Dart::Init(
       dart::bin::vm_snapshot_data, dart::bin::vm_snapshot_instructions,
-      /*create_group=*/CreateIsolateAndSetup,
-      /*initialize_isolate=*/nullptr,
-      /*shutdown_isolate=*/nullptr,
-      /*cleanup_isolate=*/nullptr,
-      /*cleanup_group=*/CleanupIsolateGroup,
-      /*thread_exit=*/nullptr, dart::bin::DartUtils::OpenFile,
-      dart::bin::DartUtils::ReadFile, dart::bin::DartUtils::WriteFile,
-      dart::bin::DartUtils::CloseFile, nullptr /* entropy_source */,
-      nullptr /* get_service_assets */, start_kernel_isolate,
-      /*code_observer=*/nullptr);
+      CreateIsolateAndSetup /* create */, nullptr /* shutdown */,
+      CleanupIsolate /* cleanup */, nullptr /* thread_exit */,
+      dart::bin::DartUtils::OpenFile, dart::bin::DartUtils::ReadFile,
+      dart::bin::DartUtils::WriteFile, dart::bin::DartUtils::CloseFile,
+      nullptr /* entropy_source */, nullptr /* get_service_assets */,
+      start_kernel_isolate, nullptr /* observer */);
   if (error != nullptr) {
     Syslog::PrintErr("Failed to initialize VM: %s\n", error);
     free(error);
diff --git a/runtime/include/dart_api.h b/runtime/include/dart_api.h
index e52f10f..16a5b80 100644
--- a/runtime/include/dart_api.h
+++ b/runtime/include/dart_api.h
@@ -88,7 +88,7 @@
  * current isolate may be NULL, in which case no isolate is ready to
  * execute. Most of the Dart apis require there to be a current
  * isolate in order to function without error. The current isolate is
- * set by any call to Dart_CreateIsolateGroup or Dart_EnterIsolate.
+ * set by any call to Dart_CreateIsolate or Dart_EnterIsolate.
  */
 typedef struct _Dart_Isolate* Dart_Isolate;
 
@@ -553,7 +553,7 @@
  *
  * This callback, provided by the embedder, is called when the VM
  * needs to create an isolate. The callback should create an isolate
- * by calling Dart_CreateIsolateGroup and load any scripts required for
+ * by calling Dart_CreateIsolate and load any scripts required for
  * execution.
  *
  * This callback may be called on a different thread than the one
@@ -562,7 +562,7 @@
  * When the function returns NULL, it is the responsibility of this
  * function to ensure that Dart_ShutdownIsolate has been called if
  * required (for example, if the isolate was created successfully by
- * Dart_CreateIsolateGroup() but the root library fails to load
+ * Dart_CreateIsolate() but the root library fails to load
  * successfully, then the function should call Dart_ShutdownIsolate
  * before returning).
  *
@@ -572,7 +572,7 @@
  * freed.
  *
  * \param script_uri The uri of the main source file or snapshot to load.
- *   Either the URI of the parent isolate set in Dart_CreateIsolateGroup for
+ *   Either the URI of the parent isolate set in Dart_CreateIsolate for
  *   Isolate.spawn, or the argument to Isolate.spawnUri canonicalized by the
  *   library tag handler of the parent isolate.
  *   The callback is responsible for loading the program by a call to
@@ -594,54 +594,20 @@
  *   from the spawning isolate or passed as parameters when spawning the
  *   isolate from Dart code.
  * \param callback_data The callback data which was passed to the
- *   parent isolate when it was created by calling Dart_CreateIsolateGroup().
+ *   parent isolate when it was created by calling Dart_CreateIsolate().
  * \param error A structure into which the embedder can place a
  *   C string containing an error message in the case of failures.
  *
  * \return The embedder returns NULL if the creation and
  *   initialization was not successful and the isolate if successful.
  */
-typedef Dart_Isolate (*Dart_IsolateGroupCreateCallback)(
-    const char* script_uri,
-    const char* main,
-    const char* package_root,
-    const char* package_config,
-    Dart_IsolateFlags* flags,
-    void* callback_data,
-    char** error);
-
-/**
- * An isolate initialization callback function.
- *
- * This callback, provided by the embedder, is called when the VM has created an
- * isolate within an existing isolate group (i.e. from the same source as an
- * existing isolate).
- *
- * The callback should setup native resolvers and might want to set a custom
- * message handler via [Dart_SetMessageNotifyCallback] and mark the isolate as
- * runnable.
- *
- * This callback may be called on a different thread than the one
- * running the parent isolate.
- *
- * When the function returns `false`, it is the responsibility of this
- * function to ensure that `Dart_ShutdownIsolate` has been called.
- *
- * When the function returns `false`, the function should set *error to
- * a malloc-allocated buffer containing a useful error message.  The
- * caller of this function (the VM) will make sure that the buffer is
- * freed.
- *
- * \param child_isolate_data The callback data to associate with the new
- *        child isolate.
- * \param error A structure into which the embedder can place a
- *   C string containing an error message in the case of failures.
- *
- * \return The embedder returns NULL if the creation and
- *   initialization was not successful and the isolate if successful.
- */
-typedef bool (*Dart_InitializeIsolateCallback)(void** child_isolate_data,
-                                               char** error);
+typedef Dart_Isolate (*Dart_IsolateCreateCallback)(const char* script_uri,
+                                                   const char* main,
+                                                   const char* package_root,
+                                                   const char* package_config,
+                                                   Dart_IsolateFlags* flags,
+                                                   void* callback_data,
+                                                   char** error);
 
 /**
  * An isolate unhandled exception callback function.
@@ -660,13 +626,11 @@
  * This function should be used to dispose of native resources that
  * are allocated to an isolate in order to avoid leaks.
  *
- * \param isolate_group_data The same callback data which was passed to the
- *   isolate group when it was created.
- * \param isolate_data The same callback data which was passed to the isolate
- *   when it was created.
+ * \param callback_data The same callback data which was passed to the
+ *   isolate when it was created.
+ *
  */
-typedef void (*Dart_IsolateShutdownCallback)(void* isolate_group_data,
-                                             void* isolate_data);
+typedef void (*Dart_IsolateShutdownCallback)(void* callback_data);
 
 /**
  * An isolate cleanup callback function.
@@ -678,28 +642,11 @@
  * This function should be used to dispose of native resources that
  * are allocated to an isolate in order to avoid leaks.
  *
- * \param isolate_group_data The same callback data which was passed to the
- *   isolate group when it was created.
- * \param isolate_data The same callback data which was passed to the isolate
- *   when it was created.
- */
-typedef void (*Dart_IsolateCleanupCallback)(void* isolate_group_data,
-                                            void* isolate_data);
-
-/**
- * An isolate group cleanup callback function.
- *
- * This callback, provided by the embedder, is called after the vm
- * shuts down an isolate group.
- *
- * This function should be used to dispose of native resources that
- * are allocated to an isolate in order to avoid leaks.
- *
- * \param isolate_group_data The same callback data which was passed to the
- *   isolate group when it was created.
+ * \param callback_data The same callback data which was passed to the
+ *   isolate when it was created.
  *
  */
-typedef void (*Dart_IsolateGroupCleanupCallback)(void* isolate_group_data);
+typedef void (*Dart_IsolateCleanupCallback)(void* callback_data);
 
 /**
  * A thread death callback function.
@@ -804,17 +751,12 @@
  * \param instructions_snapshot A buffer containing a snapshot of precompiled
  *   instructions, or NULL if no snapshot is provided. If provided, the buffer
  *   must remain valid until Dart_Cleanup returns.
- * \param initialize_isolate A function to be called during isolate
- *   initialization inside an existing isolate group.
- *   See Dart_InitializeIsolateCallback.
- * \param create_group A function to be called during isolate group creation.
- *   See Dart_IsolateGroupCreateCallback.
- * \param shutdown A function to be called right before an isolate is shutdown.
+ * \param create A function to be called during isolate creation.
+ *   See Dart_IsolateCreateCallback.
+ * \param shutdown A function to be called when an isolate is shutdown.
  *   See Dart_IsolateShutdownCallback.
- * \param cleanup A function to be called after an isolate was shutdown.
+ * \param cleanup A function to be called after an isolate is shutdown.
  *   See Dart_IsolateCleanupCallback.
- * \param cleanup_group A function to be called after an isolate group is shutdown.
- *   See Dart_IsolateGroupCleanupCallback.
  * \param get_service_assets A function to be called by the service isolate when
  *    it requires the vmservice assets archive.
  *    See Dart_GetVMServiceAssetsArchive.
@@ -825,11 +767,9 @@
   int32_t version;
   const uint8_t* vm_snapshot_data;
   const uint8_t* vm_snapshot_instructions;
-  Dart_IsolateGroupCreateCallback create_group;
-  Dart_InitializeIsolateCallback initialize_isolate;
-  Dart_IsolateShutdownCallback shutdown_isolate;
-  Dart_IsolateCleanupCallback cleanup_isolate;
-  Dart_IsolateGroupCleanupCallback cleanup_group;
+  Dart_IsolateCreateCallback create;
+  Dart_IsolateShutdownCallback shutdown;
+  Dart_IsolateCleanupCallback cleanup;
   Dart_ThreadExitCallback thread_exit;
   Dart_FileOpenCallback file_open;
   Dart_FileReadCallback file_read;
@@ -896,7 +836,7 @@
  * Requires there to be no current isolate.
  *
  * \param script_uri The main source file or snapshot this isolate will load.
- *   The VM will provide this URI to the Dart_IsolateGroupCreateCallback when a child
+ *   The VM will provide this URI to the Dart_IsolateCreateCallback when a child
  *   isolate is created by Isolate.spawn. The embedder should use a URI that
  *   allows it to load the same program into such a child isolate.
  * \param name A short name for the isolate to improve debugging messages.
@@ -907,7 +847,7 @@
  *   remain valid until the isolate shuts down.
  * \param flags Pointer to VM specific flags or NULL for default flags.
  * \param callback_data Embedder data.  This data will be passed to
- *   the Dart_IsolateGroupCreateCallback when new isolates are spawned from
+ *   the Dart_IsolateCreateCallback when new isolates are spawned from
  *   this parent isolate.
  * \param error Returns NULL if creation is successful, an error message
  *   otherwise. The caller is responsible for calling free() on the error
@@ -916,16 +856,15 @@
  * \return The new isolate on success, or NULL if isolate creation failed.
  */
 DART_EXPORT Dart_Isolate
-Dart_CreateIsolateGroup(const char* script_uri,
-                        const char* name,
-                        const uint8_t* isolate_snapshot_data,
-                        const uint8_t* isolate_snapshot_instructions,
-                        const uint8_t* shared_data,
-                        const uint8_t* shared_instructions,
-                        Dart_IsolateFlags* flags,
-                        void* isolate_group_data,
-                        void* isolate_data,
-                        char** error);
+Dart_CreateIsolate(const char* script_uri,
+                   const char* name,
+                   const uint8_t* isolate_snapshot_data,
+                   const uint8_t* isolate_snapshot_instructions,
+                   const uint8_t* shared_data,
+                   const uint8_t* shared_instructions,
+                   Dart_IsolateFlags* flags,
+                   void* callback_data,
+                   char** error);
 /* TODO(turnidge): Document behavior when there is already a current
  * isolate. */
 
@@ -936,7 +875,7 @@
  * Requires there to be no current isolate.
  *
  * \param script_uri The main source file or snapshot this isolate will load.
- *   The VM will provide this URI to the Dart_IsolateGroupCreateCallback when a child
+ *   The VM will provide this URI to the Dart_IsolateCreateCallback when a child
  *   isolate is created by Isolate.spawn. The embedder should use a URI that
  *   allows it to load the same program into such a child isolate.
  * \param name A short name for the isolate to improve debugging messages.
@@ -946,7 +885,7 @@
  *   remain valid until isolate shutdown.
  * \param flags Pointer to VM specific flags or NULL for default flags.
  * \param callback_data Embedder data.  This data will be passed to
- *   the Dart_IsolateGroupCreateCallback when new isolates are spawned from
+ *   the Dart_IsolateCreateCallback when new isolates are spawned from
  *   this parent isolate.
  * \param error Returns NULL if creation is successful, an error message
  *   otherwise. The caller is responsible for calling free() on the error
@@ -955,14 +894,13 @@
  * \return The new isolate on success, or NULL if isolate creation failed.
  */
 DART_EXPORT Dart_Isolate
-Dart_CreateIsolateGroupFromKernel(const char* script_uri,
-                                  const char* name,
-                                  const uint8_t* kernel_buffer,
-                                  intptr_t kernel_buffer_size,
-                                  Dart_IsolateFlags* flags,
-                                  void* isolate_group_data,
-                                  void* isolate_data,
-                                  char** error);
+Dart_CreateIsolateFromKernel(const char* script_uri,
+                             const char* name,
+                             const uint8_t* kernel_buffer,
+                             intptr_t kernel_buffer_size,
+                             Dart_IsolateFlags* flags,
+                             void* callback_data,
+                             char** error);
 /**
  * Shuts down the current isolate. After this call, the current isolate is NULL.
  * Any current scopes created by Dart_EnterScope will be exited. Invokes the
@@ -980,32 +918,20 @@
 DART_EXPORT Dart_Isolate Dart_CurrentIsolate();
 
 /**
- * Returns the callback data associated with the current isolate. This
- * data was set when the isolate got created or initialized.
+ * Returns the callback data associated with the current Isolate. This data was
+ * passed to the isolate when it was created.
  */
 DART_EXPORT void* Dart_CurrentIsolateData();
 
 /**
- * Returns the callback data associated with the given isolate. This
- * data was set when the isolate got created or initialized.
+ * Returns the callback data associated with the specified Isolate. This data
+ * was passed to the isolate when it was created.
+ * The embedder is responsible for ensuring the consistency of this data
+ * with respect to the lifecycle of an Isolate.
  */
 DART_EXPORT void* Dart_IsolateData(Dart_Isolate isolate);
 
 /**
- * Returns the callback data associated with the current isolate group. This
- * data was passed to the isolate group when it was created.
- */
-DART_EXPORT void* Dart_CurrentIsolateGroupData();
-
-/**
- * Returns the callback data associated with the specified isolate group. This
- * data was passed to the isolate when it was created.
- * The embedder is responsible for ensuring the consistency of this data
- * with respect to the lifecycle of an isolate group.
- */
-DART_EXPORT void* Dart_IsolateGroupData(Dart_Isolate isolate);
-
-/**
  * Returns the debugging name for the current isolate.
  *
  * This name is unique to each isolate and should only be used to make
@@ -2600,9 +2526,9 @@
 typedef struct _Dart_NativeArguments* Dart_NativeArguments;
 
 /**
- * Extracts current isolate group data from the native arguments structure.
+ * Extracts current isolate data from the native arguments structure.
  */
-DART_EXPORT void* Dart_GetNativeIsolateGroupData(Dart_NativeArguments args);
+DART_EXPORT void* Dart_GetNativeIsolateData(Dart_NativeArguments args);
 
 typedef enum {
   Dart_NativeArgument_kBool = 0,
@@ -3004,7 +2930,7 @@
  * Requires there to be no current root library.
  *
  * \param buffer A buffer which contains a kernel binary (see
- *     pkg/kernel/binary.md). Must remain valid until isolate group shutdown.
+ *     pkg/kernel/binary.md). Must remain valid until isolate shutdown.
  * \param buffer_size Length of the passed in buffer.
  *
  * \return A handle to the root library, or an error.
@@ -3374,7 +3300,7 @@
  *  Running this snapshot requires a VM compiled with DART_PRECOMPILED_SNAPSHOT.
  *  The kDartVmSnapshotData and kDartVmSnapshotInstructions should be passed to
  *  Dart_Initialize. The kDartIsolateSnapshotData and
- *  kDartIsolateSnapshotInstructions should be passed to Dart_CreateIsolateGroup.
+ *  kDartIsolateSnapshotInstructions should be passed to Dart_CreateIsolate.
  *
  *  The callback will be invoked one or more times to provide the assembly code.
  *
@@ -3450,7 +3376,7 @@
  *  startup and quicker warmup in a subsequent process.
  *
  *  Outputs a snapshot in two pieces. The pieces should be passed to
- *  Dart_CreateIsolateGroup in a VM using the same VM snapshot pieces used in the
+ *  Dart_CreateIsolate in a VM using the same VM snapshot pieces used in the
  *  current VM. The instructions piece must be loaded with read and execute
  *  permissions; the data piece may be loaded as read-only.
  *
diff --git a/runtime/include/dart_embedder_api.h b/runtime/include/dart_embedder_api.h
index 61b54fd..9a91a83 100644
--- a/runtime/include/dart_embedder_api.h
+++ b/runtime/include/dart_embedder_api.h
@@ -5,8 +5,8 @@
 #ifndef RUNTIME_INCLUDE_DART_EMBEDDER_API_H_
 #define RUNTIME_INCLUDE_DART_EMBEDDER_API_H_
 
-#include "include/dart_api.h"
-#include "include/dart_tools_api.h"
+#include "dart_api.h"
+#include "dart_tools_api.h"
 
 namespace dart {
 namespace embedder {
@@ -29,11 +29,8 @@
   // Isolate creation flags. Might be absent.
   Dart_IsolateFlags* flags;
 
-  // Isolate group callback data.
-  void* isolate_group_data;
-
   // Isolate callback data.
-  void* isolate_data;
+  void* callback_data;
 };
 
 // Create and initialize kernel-service isolate. This method should be used
diff --git a/runtime/lib/isolate.cc b/runtime/lib/isolate.cc
index 6331295..436e895 100644
--- a/runtime/lib/isolate.cc
+++ b/runtime/lib/isolate.cc
@@ -129,66 +129,28 @@
   }
 
   void Run() override {
-    IsolateGroupSource* source = state_->source();
-
-    // The create isolate group call back is mandatory.  If not provided we
-    // cannot spawn isolates.
-    Dart_IsolateGroupCreateCallback create_group_callback =
-        Isolate::CreateGroupCallback();
-    if (create_group_callback == nullptr) {
-      FailedSpawn("Isolate spawn is not supported by this Dart embedder\n");
+    // Create a new isolate.
+    char* error = NULL;
+    Dart_IsolateCreateCallback callback = Isolate::CreateCallback();
+    if (callback == NULL) {
+      ReportError(
+          "Isolate spawn is not supported by this Dart implementation\n");
       return;
     }
 
-    // The initialize callback is optional atm, we fall back to creating isolate
-    // groups if it was not provided.
-    Dart_InitializeIsolateCallback initialize_callback =
-        Isolate::InitializeCallback();
-
+    // Make a copy of the state's isolate flags and hand it to the callback.
+    Dart_IsolateFlags api_flags = *(state_->isolate_flags());
     const char* name = (state_->debug_name() == NULL) ? state_->function_name()
                                                       : state_->debug_name();
     ASSERT(name != NULL);
 
-    // Create a new isolate.
-    char* error = nullptr;
-    Isolate* isolate = nullptr;
-    if (source == nullptr || initialize_callback == nullptr) {
-      // Make a copy of the state's isolate flags and hand it to the callback.
-      Dart_IsolateFlags api_flags = *(state_->isolate_flags());
-      isolate = reinterpret_cast<Isolate*>((create_group_callback)(
-          state_->script_url(), name, nullptr, state_->package_config(),
-          &api_flags, parent_isolate_->init_callback_data(), &error));
-      parent_isolate_->DecrementSpawnCount();
-      parent_isolate_ = nullptr;
-    } else {
-      if (initialize_callback == nullptr) {
-        FailedSpawn("Isolate spawn is not supported by this embedder.");
-        return;
-      }
-
-      isolate = CreateIsolateFromExistingSource(source, name, &error);
-      parent_isolate_->DecrementSpawnCount();
-      parent_isolate_ = nullptr;
-      if (isolate == nullptr) {
-        FailedSpawn(error);
-        free(error);
-        return;
-      }
-
-      void* child_isolate_data = nullptr;
-      bool success = initialize_callback(&child_isolate_data, &error);
-      isolate->set_init_callback_data(child_isolate_data);
-      if (!success) {
-        Dart_ShutdownIsolate();
-        FailedSpawn(error);
-        free(error);
-        return;
-      }
-      Dart_ExitIsolate();
-    }
-
-    if (isolate == nullptr) {
-      FailedSpawn(error);
+    Isolate* isolate = reinterpret_cast<Isolate*>((callback)(
+        state_->script_url(), name, nullptr, state_->package_config(),
+        &api_flags, parent_isolate_->init_callback_data(), &error));
+    parent_isolate_->DecrementSpawnCount();
+    parent_isolate_ = nullptr;
+    if (isolate == NULL) {
+      ReportError(error);
       free(error);
       return;
     }
@@ -207,13 +169,6 @@
   }
 
  private:
-  void FailedSpawn(const char* error) {
-    ReportError(error != nullptr
-                    ? error
-                    : "Unknown error occured during Isolate spawning.");
-    state_ = nullptr;
-  }
-
   void ReportError(const char* error) {
     Dart_CObject error_cobj;
     error_cobj.type = Dart_CObject_kString;
@@ -285,7 +240,7 @@
       std::unique_ptr<IsolateSpawnState> state(new IsolateSpawnState(
           port.Id(), isolate->origin_id(), String2UTF8(script_uri), func,
           &message_buffer, utf8_package_config, paused.value(), fatal_errors,
-          on_exit_port, on_error_port, utf8_debug_name, isolate->source()));
+          on_exit_port, on_error_port, utf8_debug_name));
 
       // Since this is a call to Isolate.spawn, copy the parent isolate's code.
       state->isolate_flags()->copy_parent_code = true;
@@ -396,12 +351,10 @@
   const char* utf8_debug_name =
       debugName.IsNull() ? NULL : String2UTF8(debugName);
 
-  IsolateGroupSource* null_source = nullptr;
-
   std::unique_ptr<IsolateSpawnState> state(new IsolateSpawnState(
       port.Id(), canonical_uri, utf8_package_config, &arguments_buffer,
       &message_buffer, paused.value(), fatal_errors, on_exit_port,
-      on_error_port, utf8_debug_name, null_source));
+      on_error_port, utf8_debug_name));
 
   // If we were passed a value then override the default flags state for
   // checked mode.
diff --git a/runtime/observatory/tests/service/get_source_report_test.dart b/runtime/observatory/tests/service/get_source_report_test.dart
index 7627ef3..f859e6d 100644
--- a/runtime/observatory/tests/service/get_source_report_test.dart
+++ b/runtime/observatory/tests/service/get_source_report_test.dart
@@ -91,7 +91,7 @@
     final numRanges = coverage['ranges'].length;
     expect(coverage['type'], equals('SourceReport'));
 
-    expect(numRanges, equals(12));
+    expect((numRanges == 12), isTrue);
     expect(coverage['ranges'][0], equals(expectedRange));
     expect(coverage['scripts'].length, 1);
     expect(
diff --git a/runtime/observatory/tests/service/get_vm_timeline_rpc_test.dart b/runtime/observatory/tests/service/get_vm_timeline_rpc_test.dart
index 53fd8cd..cdd9344 100644
--- a/runtime/observatory/tests/service/get_vm_timeline_rpc_test.dart
+++ b/runtime/observatory/tests/service/get_vm_timeline_rpc_test.dart
@@ -89,7 +89,7 @@
     }
     if (event['cat'] == 'Embedder' &&
         (event['name'] == 'DFE::ReadScript' ||
-            event['name'] == 'CreateIsolateGroupAndSetupHelper')) {
+            event['name'] == 'CreateIsolateAndSetupHelper')) {
       continue;
     }
     Map arguments = event['args'];
diff --git a/runtime/vm/dart.cc b/runtime/vm/dart.cc
index 8753466..e43381d 100644
--- a/runtime/vm/dart.cc
+++ b/runtime/vm/dart.cc
@@ -130,11 +130,9 @@
 
 char* Dart::Init(const uint8_t* vm_isolate_snapshot,
                  const uint8_t* instructions_snapshot,
-                 Dart_IsolateGroupCreateCallback create_group,
-                 Dart_InitializeIsolateCallback initialize_isolate,
+                 Dart_IsolateCreateCallback create,
                  Dart_IsolateShutdownCallback shutdown,
-                 Dart_IsolateShutdownCallback cleanup,
-                 Dart_IsolateGroupCleanupCallback cleanup_group,
+                 Dart_IsolateCleanupCallback cleanup,
                  Dart_ThreadExitCallback thread_exit,
                  Dart_FileOpenCallback file_open,
                  Dart_FileReadCallback file_read,
@@ -357,11 +355,9 @@
   Api::InitHandles();
 
   Thread::ExitIsolate();  // Unregister the VM isolate from this thread.
-  Isolate::SetCreateGroupCallback(create_group);
-  Isolate::SetInitializeCallback_(initialize_isolate);
+  Isolate::SetCreateCallback(create);
   Isolate::SetShutdownCallback(shutdown);
   Isolate::SetCleanupCallback(cleanup);
-  Isolate::SetGroupCleanupCallback(cleanup_group);
 
   if (FLAG_support_service) {
     Service::SetGetServiceAssetsCallback(get_service_assets);
@@ -624,7 +620,7 @@
                                   const uint8_t* shared_instructions,
                                   const uint8_t* kernel_buffer,
                                   intptr_t kernel_buffer_size,
-                                  void* isolate_data) {
+                                  void* data) {
   // Initialize the new isolate.
   Thread* T = Thread::Current();
   Isolate* I = T->isolate();
@@ -728,7 +724,7 @@
   }
 
   I->heap()->InitGrowthControl();
-  I->set_init_callback_data(isolate_data);
+  I->set_init_callback_data(data);
   Api::SetupAcquiredError(I);
   if (FLAG_print_class_table) {
     I->class_table()->Print();
@@ -854,12 +850,11 @@
   Thread* thread = Thread::Current();
   ASSERT(thread->execution_state() == Thread::kThreadInVM);
   Isolate* isolate = thread->isolate();
-  void* isolate_group_data = isolate->source()->callback_data;
-  void* isolate_data = isolate->init_callback_data();
+  void* callback_data = isolate->init_callback_data();
   Dart_IsolateShutdownCallback callback = Isolate::ShutdownCallback();
   if (callback != NULL) {
     TransitionVMToNative transition(thread);
-    (callback)(isolate_group_data, isolate_data);
+    (callback)(callback_data);
   }
 }
 
diff --git a/runtime/vm/dart.h b/runtime/vm/dart.h
index 6e4cf64..64d10f9 100644
--- a/runtime/vm/dart.h
+++ b/runtime/vm/dart.h
@@ -28,11 +28,9 @@
   // (caller owns error message and has to free it).
   static char* Init(const uint8_t* vm_snapshot_data,
                     const uint8_t* vm_snapshot_instructions,
-                    Dart_IsolateGroupCreateCallback create_group,
-                    Dart_InitializeIsolateCallback initialize_isolate,
+                    Dart_IsolateCreateCallback create,
                     Dart_IsolateShutdownCallback shutdown,
                     Dart_IsolateCleanupCallback cleanup,
-                    Dart_IsolateGroupCleanupCallback cleanup_group,
                     Dart_ThreadExitCallback thread_exit,
                     Dart_FileOpenCallback file_open,
                     Dart_FileReadCallback file_read,
diff --git a/runtime/vm/dart_api_impl.cc b/runtime/vm/dart_api_impl.cc
index f3a9994..caa2de9 100644
--- a/runtime/vm/dart_api_impl.cc
+++ b/runtime/vm/dart_api_impl.cc
@@ -1005,13 +1005,11 @@
   }
 
   return Dart::Init(params->vm_snapshot_data, params->vm_snapshot_instructions,
-                    params->create_group, params->initialize_isolate,
-                    params->shutdown_isolate, params->cleanup_isolate,
-                    params->cleanup_group, params->thread_exit,
-                    params->file_open, params->file_read, params->file_write,
-                    params->file_close, params->entropy_source,
-                    params->get_service_assets, params->start_kernel_isolate,
-                    params->code_observer);
+                    params->create, params->shutdown, params->cleanup,
+                    params->thread_exit, params->file_open, params->file_read,
+                    params->file_write, params->file_close,
+                    params->entropy_source, params->get_service_assets,
+                    params->start_kernel_isolate, params->code_observer);
 }
 
 DART_EXPORT char* Dart_Cleanup() {
@@ -1060,13 +1058,26 @@
 
 // --- Isolates ---
 
-static Dart_Isolate CreateIsolate(IsolateGroupSource* source,
+static Dart_Isolate CreateIsolate(const char* script_uri,
                                   const char* name,
-                                  void* isolate_data,
+                                  const uint8_t* snapshot_data,
+                                  const uint8_t* snapshot_instructions,
+                                  const uint8_t* shared_data,
+                                  const uint8_t* shared_instructions,
+                                  const uint8_t* kernel_buffer,
+                                  intptr_t kernel_buffer_size,
+                                  Dart_IsolateFlags* flags,
+                                  void* callback_data,
                                   char** error) {
   CHECK_NO_ISOLATE(Isolate::Current());
 
-  Isolate* I = Dart::CreateIsolate(name, source->flags);
+  // Setup default flags in case none were passed.
+  Dart_IsolateFlags api_flags;
+  if (flags == NULL) {
+    Isolate::FlagsInitialize(&api_flags);
+    flags = &api_flags;
+  }
+  Isolate* I = Dart::CreateIsolate((name == NULL) ? "isolate" : name, *flags);
   if (I == NULL) {
     if (error != NULL) {
       *error = strdup("Isolate creation failed");
@@ -1083,15 +1094,14 @@
     // bootstrap library files which call out to a tag handler that may create
     // Api Handles when an error is encountered.
     T->EnterApiScope();
-    const Error& error_obj =
-        Error::Handle(Z, Dart::InitializeIsolate(
-                             source->snapshot_data,
-                             source->snapshot_instructions, source->shared_data,
-                             source->shared_instructions, source->kernel_buffer,
-                             source->kernel_buffer_size, isolate_data));
+    const Error& error_obj = Error::Handle(
+        Z,
+        Dart::InitializeIsolate(snapshot_data, snapshot_instructions,
+                                shared_data, shared_instructions, kernel_buffer,
+                                kernel_buffer_size, callback_data));
     if (error_obj.IsNull()) {
 #if defined(DART_NO_SNAPSHOT) && !defined(PRODUCT)
-      if (FLAG_check_function_fingerprints && source->kernel_buffer == NULL) {
+      if (FLAG_check_function_fingerprints && kernel_buffer == NULL) {
         Library::CheckFunctionFingerprints();
       }
 #endif  // defined(DART_NO_SNAPSHOT) && !defined(PRODUCT).
@@ -1103,8 +1113,6 @@
     T->ExitApiScope();
   }
 
-  I->set_source(source);
-
   if (success) {
     // A Thread structure has been associated to the thread, we do the
     // safepoint transition explicitly here instead of using the
@@ -1122,125 +1130,37 @@
   return reinterpret_cast<Dart_Isolate>(NULL);
 }
 
-Isolate* CreateIsolateFromExistingSource(IsolateGroupSource* source,
-                                         const char* name,
-                                         char** error) {
-  API_TIMELINE_DURATION(Thread::Current());
-  CHECK_NO_ISOLATE(Isolate::Current());
-
-  Isolate* isolate = reinterpret_cast<Isolate*>(
-      CreateIsolate(source, name, /*isolate_data=*/nullptr, error));
-  RELEASE_ASSERT(isolate->source() == source);
-
-  if (source->script_kernel_buffer != nullptr) {
-#if defined(DART_PRECOMPILED_RUNTIME)
-    UNREACHABLE();
-#else
-    Dart_EnterScope();
-    {
-      Thread* T = Thread::Current();
-      TransitionNativeToVM transition(T);
-      HANDLESCOPE(T);
-      StackZone zone(T);
-
-      // The kernel loader is about to allocate a bunch of new libraries,
-      // classes and functions into old space. Force growth, and use of the
-      // bump allocator instead of freelists.
-      BumpAllocateScope bump_allocate_scope(T);
-
-      // NOTE: We do not attach a finalizer for this object, because the
-      // embedder will free it once the isolate group has shutdown.
-      const auto& td = ExternalTypedData::Handle(ExternalTypedData::New(
-          kExternalTypedDataUint8ArrayCid,
-          const_cast<uint8_t*>(source->script_kernel_buffer),
-          source->script_kernel_size, Heap::kOld));
-
-      std::unique_ptr<kernel::Program> program =
-          kernel::Program::ReadFromTypedData(td,
-                                             const_cast<const char**>(error));
-      if (program == nullptr) {
-        UNIMPLEMENTED();
-      }
-      const Object& tmp =
-          kernel::KernelLoader::LoadEntireProgram(program.get());
-
-      // If the existing isolate could spawn with a root library we should be
-      // able to do the same
-      RELEASE_ASSERT(!tmp.IsNull() && tmp.IsLibrary());
-      isolate->object_store()->set_root_library(Library::Cast(tmp));
-    }
-    Dart_ExitScope();
-#endif  // defined(DART_PRECOMPILED_RUNTIME)
-  }
-
-  return isolate;
-}
-
 DART_EXPORT void Dart_IsolateFlagsInitialize(Dart_IsolateFlags* flags) {
   Isolate::FlagsInitialize(flags);
 }
 
 DART_EXPORT Dart_Isolate
-Dart_CreateIsolateGroup(const char* script_uri,
-                        const char* name,
-                        const uint8_t* snapshot_data,
-                        const uint8_t* snapshot_instructions,
-                        const uint8_t* shared_data,
-                        const uint8_t* shared_instructions,
-                        Dart_IsolateFlags* flags,
-                        void* isolate_group_data,
-                        void* isolate_data,
-                        char** error) {
+Dart_CreateIsolate(const char* script_uri,
+                   const char* name,
+                   const uint8_t* snapshot_data,
+                   const uint8_t* snapshot_instructions,
+                   const uint8_t* shared_data,
+                   const uint8_t* shared_instructions,
+                   Dart_IsolateFlags* flags,
+                   void* callback_data,
+                   char** error) {
   API_TIMELINE_DURATION(Thread::Current());
-
-  Dart_IsolateFlags api_flags;
-  if (flags == nullptr) {
-    Isolate::FlagsInitialize(&api_flags);
-    flags = &api_flags;
-  }
-
-  const char* non_null_name = name == nullptr ? "isolate" : name;
-  auto source = new IsolateGroupSource(script_uri, non_null_name, snapshot_data,
-                                       snapshot_instructions, shared_data,
-                                       shared_instructions, nullptr, -1, *flags,
-                                       isolate_group_data);
-  source->IncrementIsolateUsageCount();
-  Dart_Isolate isolate =
-      CreateIsolate(source, non_null_name, isolate_data, error);
-  if (source->DecrementIsolateUsageCount()) {
-    delete source;
-  }
-  return isolate;
+  return CreateIsolate(script_uri, name, snapshot_data, snapshot_instructions,
+                       shared_data, shared_instructions, NULL, 0, flags,
+                       callback_data, error);
 }
 
 DART_EXPORT Dart_Isolate
-Dart_CreateIsolateGroupFromKernel(const char* script_uri,
-                                  const char* name,
-                                  const uint8_t* kernel_buffer,
-                                  intptr_t kernel_buffer_size,
-                                  Dart_IsolateFlags* flags,
-                                  void* isolate_group_data,
-                                  void* isolate_data,
-                                  char** error) {
+Dart_CreateIsolateFromKernel(const char* script_uri,
+                             const char* name,
+                             const uint8_t* kernel_buffer,
+                             intptr_t kernel_buffer_size,
+                             Dart_IsolateFlags* flags,
+                             void* callback_data,
+                             char** error) {
   API_TIMELINE_DURATION(Thread::Current());
-
-  Dart_IsolateFlags api_flags;
-  if (flags == nullptr) {
-    Isolate::FlagsInitialize(&api_flags);
-    flags = &api_flags;
-  }
-
-  const char* non_null_name = name == nullptr ? "isolate" : name;
-  auto source = new IsolateGroupSource(
-      script_uri, non_null_name, nullptr, nullptr, nullptr, nullptr,
-      kernel_buffer, kernel_buffer_size, *flags, isolate_group_data);
-  source->IncrementIsolateUsageCount();
-  Dart_Isolate isolate =
-      CreateIsolate(source, non_null_name, isolate_data, error);
-  if (source->DecrementIsolateUsageCount()) {
-    delete source;
-  }
-  return isolate;
+  return CreateIsolate(script_uri, name, NULL, NULL, NULL, NULL, kernel_buffer,
+                       kernel_buffer_size, flags, callback_data, error);
 }
 
 DART_EXPORT void Dart_ShutdownIsolate() {
@@ -1251,7 +1171,7 @@
   // The Thread structure is disassociated from the isolate, we do the
   // safepoint transition explicitly here instead of using the TransitionXXX
   // scope objects as the original transition happened outside this scope in
-  // Dart_EnterIsolate/Dart_CreateIsolateGroup.
+  // Dart_EnterIsolate/Dart_CreateIsolate.
   ASSERT(T->execution_state() == Thread::kThreadInNative);
   T->ExitSafepoint();
   T->set_execution_state(Thread::kThreadInVM);
@@ -1290,23 +1210,9 @@
   if (isolate == NULL) {
     FATAL1("%s expects argument 'isolate' to be non-null.", CURRENT_FUNC);
   }
-  // TODO(http://dartbug.com/16615): Validate isolate parameter.
-  return reinterpret_cast<Isolate*>(isolate)->init_callback_data();
-}
-
-DART_EXPORT void* Dart_CurrentIsolateGroupData() {
-  Isolate* isolate = Isolate::Current();
-  CHECK_ISOLATE(isolate);
-  NoSafepointScope no_safepoint_scope;
-  return isolate->source()->callback_data;
-}
-
-DART_EXPORT void* Dart_IsolateGroupData(Dart_Isolate isolate) {
-  if (isolate == NULL) {
-    FATAL1("%s expects argument 'isolate' to be non-null.", CURRENT_FUNC);
-  }
-  // TODO(http://dartbug.com/16615): Validate isolate parameter.
-  return reinterpret_cast<Isolate*>(isolate)->source()->callback_data;
+  // TODO(16615): Validate isolate parameter.
+  Isolate* iso = reinterpret_cast<Isolate*>(isolate);
+  return iso->init_callback_data();
 }
 
 DART_EXPORT Dart_Handle Dart_DebugName() {
@@ -1321,7 +1227,6 @@
   if (isolate == NULL) {
     FATAL1("%s expects argument 'isolate' to be non-null.", CURRENT_FUNC);
   }
-  // TODO(http://dartbug.com/16615): Validate isolate parameter.
   Isolate* I = reinterpret_cast<Isolate*>(isolate);
   int64_t main_port = static_cast<int64_t>(I->main_port());
   return OS::SCreate(NULL, "isolates/%" Pd64, main_port);
@@ -1329,7 +1234,7 @@
 
 DART_EXPORT void Dart_EnterIsolate(Dart_Isolate isolate) {
   CHECK_NO_ISOLATE(Isolate::Current());
-  // TODO(http://dartbug.com/16615): Validate isolate parameter.
+  // TODO(16615): Validate isolate parameter.
   Isolate* iso = reinterpret_cast<Isolate*>(isolate);
   if (!Thread::EnterIsolate(iso)) {
     FATAL(
@@ -1589,7 +1494,7 @@
   // The Thread structure is disassociated from the isolate, we do the
   // safepoint transition explicitly here instead of using the TransitionXXX
   // scope objects as the original transition happened outside this scope in
-  // Dart_EnterIsolate/Dart_CreateIsolateGroup.
+  // Dart_EnterIsolate/Dart_CreateIsolate.
   ASSERT(T->execution_state() == Thread::kThreadInNative);
   T->ExitSafepoint();
   T->set_execution_state(Thread::kThreadInVM);
@@ -4654,7 +4559,7 @@
   return Api::Success();
 }
 
-DART_EXPORT void* Dart_GetNativeIsolateGroupData(Dart_NativeArguments args) {
+DART_EXPORT void* Dart_GetNativeIsolateData(Dart_NativeArguments args) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   Isolate* isolate = arguments->thread()->isolate();
   ASSERT(isolate == Isolate::Current());
@@ -5136,15 +5041,9 @@
   // instead of freelists.
   BumpAllocateScope bump_allocate_scope(T);
 
-  // NOTE: We do not attach a finalizer for this object, because the embedder
-  // will free it once the isolate group has shutdown.
-  const auto& td = ExternalTypedData::Handle(ExternalTypedData::New(
-      kExternalTypedDataUint8ArrayCid, const_cast<uint8_t*>(buffer),
-      buffer_size, Heap::kOld));
-
   const char* error = nullptr;
   std::unique_ptr<kernel::Program> program =
-      kernel::Program::ReadFromTypedData(td, &error);
+      kernel::Program::ReadFromBuffer(buffer, buffer_size, &error);
   if (program == nullptr) {
     return Api::NewError("Can't load Kernel binary: %s.", error);
   }
@@ -5154,10 +5053,6 @@
   if (tmp.IsError()) {
     return Api::NewHandle(T, tmp.raw());
   }
-
-  I->source()->script_kernel_size = buffer_size;
-  I->source()->script_kernel_buffer = buffer;
-
   // TODO(32618): Setting root library based on whether it has 'main' or not
   // is not correct because main can be in the exported namespace of a library
   // or it could be a getter.
@@ -5392,16 +5287,9 @@
   // instead of freelists.
   BumpAllocateScope bump_allocate_scope(T);
 
-  // NOTE: We do not attach a finalizer for this object, because the embedder
-  // will/should free it once the isolate group has shutdown.
-  // See also http://dartbug.com/37030.
-  const auto& td = ExternalTypedData::Handle(ExternalTypedData::New(
-      kExternalTypedDataUint8ArrayCid, const_cast<uint8_t*>(buffer),
-      buffer_size, Heap::kOld));
-
   const char* error = nullptr;
   std::unique_ptr<kernel::Program> program =
-      kernel::Program::ReadFromTypedData(td, &error);
+      kernel::Program::ReadFromBuffer(buffer, buffer_size, &error);
   if (program == nullptr) {
     return Api::NewError("Can't load Kernel binary: %s.", error);
   }
diff --git a/runtime/vm/dart_api_impl.h b/runtime/vm/dart_api_impl.h
index d7634e3..2d8ad35 100644
--- a/runtime/vm/dart_api_impl.h
+++ b/runtime/vm/dart_api_impl.h
@@ -5,8 +5,6 @@
 #ifndef RUNTIME_VM_DART_API_IMPL_H_
 #define RUNTIME_VM_DART_API_IMPL_H_
 
-#include <memory>
-
 #include "vm/allocation.h"
 #include "vm/heap/safepoint.h"
 #include "vm/native_arguments.h"
@@ -34,7 +32,7 @@
     if ((isolate) == NULL) {                                                   \
       FATAL1(                                                                  \
           "%s expects there to be a current isolate. Did you "                 \
-          "forget to call Dart_CreateIsolateGroup or Dart_EnterIsolate?",      \
+          "forget to call Dart_CreateIsolate or Dart_EnterIsolate?",           \
           CURRENT_FUNC);                                                       \
     }                                                                          \
   } while (0)
@@ -362,14 +360,6 @@
 #define ASSERT_CALLBACK_STATE(thread)                                          \
   ASSERT(thread->no_callback_scope_depth() == 0)
 
-class IsolateGroupSource;
-
-// Creates a new isolate from [source] (which should come from an existing
-// isolate).
-Isolate* CreateIsolateFromExistingSource(IsolateGroupSource* source,
-                                         const char* name,
-                                         char** error);
-
 }  // namespace dart.
 
 #endif  // RUNTIME_VM_DART_API_IMPL_H_
diff --git a/runtime/vm/dart_api_impl_test.cc b/runtime/vm/dart_api_impl_test.cc
index 6fc6940..2035e4a 100644
--- a/runtime/vm/dart_api_impl_test.cc
+++ b/runtime/vm/dart_api_impl_test.cc
@@ -33,9 +33,9 @@
   memset(&params, 0, sizeof(Dart_InitializeParams));
   params.version = DART_INITIALIZE_PARAMS_CURRENT_VERSION;
   params.vm_snapshot_data = TesterState::vm_snapshot_data;
-  params.create_group = TesterState::create_callback;
-  params.shutdown_isolate = TesterState::shutdown_callback;
-  params.cleanup_group = TesterState::group_cleanup_callback;
+  params.create = TesterState::create_callback;
+  params.shutdown = TesterState::shutdown_callback;
+  params.cleanup = TesterState::cleanup_callback;
   params.start_kernel_isolate = true;
 
   // Reinitialize and ensure we can execute Dart code.
@@ -63,9 +63,9 @@
   memset(&params, 0, sizeof(Dart_InitializeParams));
   params.version = DART_INITIALIZE_PARAMS_CURRENT_VERSION;
   params.vm_snapshot_data = TesterState::vm_snapshot_data;
-  params.create_group = TesterState::create_callback;
-  params.shutdown_isolate = TesterState::shutdown_callback;
-  params.cleanup_group = TesterState::group_cleanup_callback;
+  params.create = TesterState::create_callback;
+  params.shutdown = TesterState::shutdown_callback;
+  params.cleanup = TesterState::cleanup_callback;
   params.start_kernel_isolate = true;
 
   bool was_called = false;
@@ -3670,21 +3670,20 @@
 
 VM_UNIT_TEST_CASE(DartAPI_CurrentIsolateData) {
   Dart_IsolateShutdownCallback saved_shutdown = Isolate::ShutdownCallback();
-  Dart_IsolateGroupCleanupCallback saved_cleanup =
-      Isolate::GroupCleanupCallback();
+  Dart_IsolateCleanupCallback saved_cleanup = Isolate::CleanupCallback();
   Isolate::SetShutdownCallback(NULL);
-  Isolate::SetGroupCleanupCallback(NULL);
+  Isolate::SetCleanupCallback(NULL);
 
   intptr_t mydata = 12345;
   Dart_Isolate isolate =
       TestCase::CreateTestIsolate(NULL, reinterpret_cast<void*>(mydata));
   EXPECT(isolate != NULL);
-  EXPECT_EQ(mydata, reinterpret_cast<intptr_t>(Dart_CurrentIsolateGroupData()));
-  EXPECT_EQ(mydata, reinterpret_cast<intptr_t>(Dart_IsolateGroupData(isolate)));
+  EXPECT_EQ(mydata, reinterpret_cast<intptr_t>(Dart_CurrentIsolateData()));
+  EXPECT_EQ(mydata, reinterpret_cast<intptr_t>(Dart_IsolateData(isolate)));
   Dart_ShutdownIsolate();
 
   Isolate::SetShutdownCallback(saved_shutdown);
-  Isolate::SetGroupCleanupCallback(saved_cleanup);
+  Isolate::SetCleanupCallback(saved_cleanup);
 }
 
 static Dart_Handle LoadScript(const char* url_str, const char* source) {
@@ -6619,8 +6618,8 @@
 
 // Common code for RunLoop_Success/RunLoop_Failure.
 static void RunLoopTest(bool throw_exception) {
-  Dart_IsolateGroupCreateCallback saved = Isolate::CreateGroupCallback();
-  Isolate::SetCreateGroupCallback(RunLoopTestCallback);
+  Dart_IsolateCreateCallback saved = Isolate::CreateCallback();
+  Isolate::SetCreateCallback(RunLoopTestCallback);
   Dart_Isolate isolate =
       RunLoopTestCallback(NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 
@@ -6644,7 +6643,7 @@
   Dart_ExitScope();
   Dart_ShutdownIsolate();
 
-  Isolate::SetCreateGroupCallback(saved);
+  Isolate::SetCreateCallback(saved);
 }
 
 VM_UNIT_TEST_CASE(DartAPI_RunLoop_Success) {
@@ -6655,93 +6654,45 @@
   RunLoopTest(true);
 }
 
-static void* shutdown_isolate_group_data;
-static void* shutdown_isolate_data;
-static void* cleanup_isolate_group_data;
-static void* cleanup_isolate_data;
-
-// Called on isolate shutdown time (which is still allowed to run Dart code)
-static void IsolateShutdownTestCallback(void* group_data, void* isolate_data) {
-  // Shutdown runs before cleanup.
-  EXPECT(cleanup_isolate_group_data == nullptr);
-  EXPECT(cleanup_isolate_data == nullptr);
-
-  // Shutdown must have a current isolate (since it is allowed to execute Dart
-  // code)
-  EXPECT(Dart_CurrentIsolate() != nullptr);
-  EXPECT(Dart_CurrentIsolateGroupData() == group_data);
-  EXPECT(Dart_CurrentIsolateData() == isolate_data);
-
-  shutdown_isolate_group_data = group_data;
-  shutdown_isolate_data = isolate_data;
+static void* shutdown_callback_data;
+static void IsolateShutdownTestCallback(void* callback_data) {
+  shutdown_callback_data = callback_data;
 }
-
-// Called on isolate cleanup time (which is after the isolate has been
-// destroyed)
-static void IsolateCleanupTestCallback(void* group_data, void* isolate_data) {
-  // Cleanup runs after shutdown.
-  EXPECT(shutdown_isolate_group_data != nullptr);
-  EXPECT(shutdown_isolate_data != nullptr);
-
-  // The isolate was destroyed and there should not be a current isolate.
-  EXPECT(Dart_CurrentIsolate() == nullptr);
-
-  cleanup_isolate_group_data = group_data;
-  cleanup_isolate_data = isolate_data;
-}
-
-// Called on isolate group cleanup time (once all isolates have been destroyed)
-static void* cleanup_group_callback_data;
-static void IsolateGroupCleanupTestCallback(void* callback_data) {
-  cleanup_group_callback_data = callback_data;
+static void* cleanup_callback_data;
+static void IsolateCleanupTestCallback(void* callback_data) {
+  cleanup_callback_data = callback_data;
 }
 
 VM_UNIT_TEST_CASE(DartAPI_IsolateShutdownAndCleanup) {
   Dart_IsolateShutdownCallback saved_shutdown = Isolate::ShutdownCallback();
-  Dart_IsolateGroupCleanupCallback saved_cleanup =
-      Isolate::GroupCleanupCallback();
+  Dart_IsolateCleanupCallback saved_cleanup = Isolate::CleanupCallback();
   Isolate::SetShutdownCallback(IsolateShutdownTestCallback);
   Isolate::SetCleanupCallback(IsolateCleanupTestCallback);
-  Isolate::SetGroupCleanupCallback(IsolateGroupCleanupTestCallback);
 
-  shutdown_isolate_group_data = nullptr;
-  shutdown_isolate_data = nullptr;
-  cleanup_group_callback_data = nullptr;
-  void* my_group_data = reinterpret_cast<void*>(123);
-  void* my_data = reinterpret_cast<void*>(456);
-
+  shutdown_callback_data = NULL;
+  cleanup_callback_data = NULL;
+  void* my_data = reinterpret_cast<void*>(12345);
   // Create an isolate.
-  Dart_Isolate isolate =
-      TestCase::CreateTestIsolate(nullptr, my_group_data, my_data);
+  Dart_Isolate isolate = TestCase::CreateTestIsolate(NULL, my_data);
   EXPECT(isolate != NULL);
 
   // The shutdown callback has not been called.
-  EXPECT(nullptr == shutdown_isolate_data);
-  EXPECT(nullptr == shutdown_isolate_group_data);
-  EXPECT(nullptr == cleanup_group_callback_data);
-
-  // The isolate is the active isolate which allows us to access the isolate
-  // specific and isolate-group specific data.
-  EXPECT(Dart_CurrentIsolateData() == my_data);
-  EXPECT(Dart_CurrentIsolateGroupData() == my_group_data);
+  EXPECT_EQ(0, reinterpret_cast<intptr_t>(shutdown_callback_data));
+  EXPECT_EQ(0, reinterpret_cast<intptr_t>(cleanup_callback_data));
 
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
 
-  // The shutdown & cleanup callbacks have been called.
-  EXPECT(my_data == shutdown_isolate_data);
-  EXPECT(my_group_data == shutdown_isolate_group_data);
-  EXPECT(my_data == cleanup_isolate_data);
-  EXPECT(my_group_data == cleanup_isolate_group_data);
-  EXPECT(my_group_data == cleanup_group_callback_data);
+  // The shutdown callback has been called.
+  EXPECT_EQ(12345, reinterpret_cast<intptr_t>(shutdown_callback_data));
+  EXPECT_EQ(12345, reinterpret_cast<intptr_t>(cleanup_callback_data));
 
   Isolate::SetShutdownCallback(saved_shutdown);
-  Isolate::SetGroupCleanupCallback(saved_cleanup);
+  Isolate::SetCleanupCallback(saved_cleanup);
 }
 
 static int64_t add_result = 0;
-static void IsolateShutdownRunDartCodeTestCallback(void* isolate_group_data,
-                                                   void* isolate_data) {
+static void IsolateShutdownRunDartCodeTestCallback(void* callback_data) {
   Dart_Isolate isolate = Dart_CurrentIsolate();
   if (Dart_IsKernelIsolate(isolate) || Dart_IsServiceIsolate(isolate)) {
     return;
diff --git a/runtime/vm/isolate.cc b/runtime/vm/isolate.cc
index b6d1352..11e65e9 100644
--- a/runtime/vm/isolate.cc
+++ b/runtime/vm/isolate.cc
@@ -1001,11 +1001,7 @@
 }
 
 void Isolate::InitVM() {
-  create_group_callback_ = nullptr;
-  initialize_callback_ = nullptr;
-  shutdown_callback_ = nullptr;
-  cleanup_callback_ = nullptr;
-  cleanup_group_callback_ = nullptr;
+  create_callback_ = nullptr;
   if (isolates_list_monitor_ == nullptr) {
     isolates_list_monitor_ = new Monitor();
   }
@@ -1904,34 +1900,15 @@
   // as we are shutting down the isolate.
   Thread::ExitIsolate();
 
-  // The source is null iff the isolate is the "vm-isolate".
-  ASSERT((source_ == nullptr) == (Dart::vm_isolate() == this));
-
-  if (source_ != nullptr) {
-    // Run isolate specific cleanup function.
-    Dart_IsolateCleanupCallback cleanup = Isolate::CleanupCallback();
-    if (cleanup != nullptr) {
-      cleanup(source_->callback_data, init_callback_data());
-    }
-
-    // Run isolate group specific cleanup function if the last isolate in an
-    // isolate group died.
-    if (source_->DecrementIsolateUsageCount()) {
-      auto group_cleanup_callback = Isolate::GroupCleanupCallback();
-      if (group_cleanup_callback != nullptr) {
-        group_cleanup_callback(source_->callback_data);
-      }
-      delete source_;
-      source_ = nullptr;
-    }
+  Dart_IsolateCleanupCallback cleanup = Isolate::CleanupCallback();
+  if (cleanup != nullptr) {
+    cleanup(init_callback_data());
   }
 }
 
-Dart_InitializeIsolateCallback Isolate::initialize_callback_ = nullptr;
-Dart_IsolateGroupCreateCallback Isolate::create_group_callback_ = nullptr;
+Dart_IsolateCreateCallback Isolate::create_callback_ = nullptr;
 Dart_IsolateShutdownCallback Isolate::shutdown_callback_ = nullptr;
 Dart_IsolateCleanupCallback Isolate::cleanup_callback_ = nullptr;
-Dart_IsolateGroupCleanupCallback Isolate::cleanup_group_callback_ = nullptr;
 
 Monitor* Isolate::isolates_list_monitor_ = nullptr;
 Isolate* Isolate::isolates_list_head_ = nullptr;
@@ -2943,8 +2920,7 @@
                                      bool errors_are_fatal,
                                      Dart_Port on_exit_port,
                                      Dart_Port on_error_port,
-                                     const char* debug_name,
-                                     IsolateGroupSource* source)
+                                     const char* debug_name)
     : isolate_(nullptr),
       parent_port_(parent_port),
       origin_id_(origin_id),
@@ -2956,7 +2932,6 @@
       class_name_(nullptr),
       function_name_(nullptr),
       debug_name_(debug_name),
-      source_(source),
       serialized_args_(nullptr),
       serialized_message_(message_buffer->StealMessage()),
       paused_(paused),
@@ -2988,8 +2963,7 @@
                                      bool errors_are_fatal,
                                      Dart_Port on_exit_port,
                                      Dart_Port on_error_port,
-                                     const char* debug_name,
-                                     IsolateGroupSource* source)
+                                     const char* debug_name)
     : isolate_(nullptr),
       parent_port_(parent_port),
       origin_id_(ILLEGAL_PORT),
@@ -3001,7 +2975,6 @@
       class_name_(nullptr),
       function_name_(nullptr),
       debug_name_(debug_name),
-      source_(source),
       serialized_args_(args_buffer->StealMessage()),
       serialized_message_(message_buffer->StealMessage()),
       isolate_flags_(),
diff --git a/runtime/vm/isolate.h b/runtime/vm/isolate.h
index a4a4bb7..6c6ee8e 100644
--- a/runtime/vm/isolate.h
+++ b/runtime/vm/isolate.h
@@ -155,78 +155,6 @@
     unsafe_trust_strong_mode_types,                                            \
     FLAG_experimental_unsafe_mode_use_at_your_own_risk)
 
-// Represents the information used for spawning the first isolate within an
-// isolate group.
-//
-// Any subsequent isolates created via `Isolate.spawn()` will be created using
-// the same [IsolateGroupSource] (the object itself is shared among all isolates
-// within the same group).
-//
-// Issue(http://dartbug.com/36097): It is still possible to run into issues if
-// an isolate has spawned another one and then loads more code into the first
-// one, which the latter will not get. Though it makes the status quo better
-// than what we had before (where the embedder needed to maintain the
-// same-source guarantee).
-//
-// => This is only the first step towards having multiple isolates share the
-//    same heap (and therefore the same program structure).
-//
-class IsolateGroupSource {
- public:
-  IsolateGroupSource(const char* script_uri,
-                     const char* name,
-                     const uint8_t* snapshot_data,
-                     const uint8_t* snapshot_instructions,
-                     const uint8_t* shared_data,
-                     const uint8_t* shared_instructions,
-                     const uint8_t* kernel_buffer,
-                     intptr_t kernel_buffer_size,
-                     Dart_IsolateFlags flags,
-                     void* callback_data)
-      : script_uri(script_uri),
-        name(strdup(name)),
-        snapshot_data(snapshot_data),
-        snapshot_instructions(snapshot_instructions),
-        shared_data(shared_data),
-        shared_instructions(shared_instructions),
-        kernel_buffer(kernel_buffer),
-        kernel_buffer_size(kernel_buffer_size),
-        flags(flags),
-        callback_data(callback_data),
-        script_kernel_buffer(nullptr),
-        script_kernel_size(-1) {}
-  ~IsolateGroupSource() { free(name); }
-
-  // The arguments used for spawning in
-  // `Dart_CreateIsolateGroupFromKernel` / `Dart_CreateIsolate`.
-  const char* script_uri;
-  char* name;
-  const uint8_t* snapshot_data;
-  const uint8_t* snapshot_instructions;
-  const uint8_t* shared_data;
-  const uint8_t* shared_instructions;
-  const uint8_t* kernel_buffer;
-  const intptr_t kernel_buffer_size;
-  Dart_IsolateFlags flags;
-  void* callback_data;
-
-  // The kernel buffer used in `Dart_LoadScriptFromKernel`.
-  const uint8_t* script_kernel_buffer;
-  intptr_t script_kernel_size;
-
-  void IncrementIsolateUsageCount() {
-    AtomicOperations::IncrementBy(&isolate_count_, 1);
-  }
-
-  // Returns true if this was the last reference.
-  bool DecrementIsolateUsageCount() {
-    return AtomicOperations::FetchAndDecrement(&isolate_count_) == 1;
-  }
-
- private:
-  intptr_t isolate_count_ = 0;
-};
-
 class Isolate : public BaseIsolate {
  public:
   // Keep both these enums in sync with isolate_patch.dart.
@@ -311,13 +239,6 @@
     message_notify_callback_ = value;
   }
 
-  IsolateGroupSource* source() const { return source_; }
-
-  void set_source(IsolateGroupSource* source) {
-    source->IncrementIsolateUsageCount();
-    source_ = source;
-  }
-
   bool HasPendingMessages();
 
   Thread* mutator_thread() const;
@@ -516,18 +437,11 @@
   void DecrementSpawnCount();
   void WaitForOutstandingSpawns();
 
-  static void SetCreateGroupCallback(Dart_IsolateGroupCreateCallback cb) {
-    create_group_callback_ = cb;
+  static void SetCreateCallback(Dart_IsolateCreateCallback cb) {
+    create_callback_ = cb;
   }
-  static Dart_IsolateGroupCreateCallback CreateGroupCallback() {
-    return create_group_callback_;
-  }
-
-  static void SetInitializeCallback_(Dart_InitializeIsolateCallback cb) {
-    initialize_callback_ = cb;
-  }
-  static Dart_InitializeIsolateCallback InitializeCallback() {
-    return initialize_callback_;
+  static Dart_IsolateCreateCallback CreateCallback() {
+    return create_callback_;
   }
 
   static void SetShutdownCallback(Dart_IsolateShutdownCallback cb) {
@@ -544,13 +458,6 @@
     return cleanup_callback_;
   }
 
-  static void SetGroupCleanupCallback(Dart_IsolateGroupCleanupCallback cb) {
-    cleanup_group_callback_ = cb;
-  }
-  static Dart_IsolateGroupCleanupCallback GroupCleanupCallback() {
-    return cleanup_group_callback_;
-  }
-
 #if !defined(PRODUCT)
   void set_object_id_ring(ObjectIdRing* ring) { object_id_ring_ = ring; }
   ObjectIdRing* object_id_ring() { return object_id_ring_; }
@@ -1149,11 +1056,9 @@
 
   ReversePcLookupCache* reverse_pc_lookup_cache_ = nullptr;
 
-  static Dart_IsolateGroupCreateCallback create_group_callback_;
-  static Dart_InitializeIsolateCallback initialize_callback_;
+  static Dart_IsolateCreateCallback create_callback_;
   static Dart_IsolateShutdownCallback shutdown_callback_;
   static Dart_IsolateCleanupCallback cleanup_callback_;
-  static Dart_IsolateGroupCleanupCallback cleanup_group_callback_;
 
 #if !defined(PRODUCT)
   static void WakePauseEventHandler(Dart_Isolate isolate);
@@ -1167,7 +1072,6 @@
   static Monitor* isolates_list_monitor_;
   static Isolate* isolates_list_head_;
   static bool creation_enabled_;
-  IsolateGroupSource* source_ = nullptr;
 
 #define REUSABLE_FRIEND_DECLARATION(name)                                      \
   friend class Reusable##name##HandleScope;
@@ -1241,8 +1145,7 @@
                     bool errorsAreFatal,
                     Dart_Port onExit,
                     Dart_Port onError,
-                    const char* debug_name,
-                    IsolateGroupSource* source);
+                    const char* debug_name);
   IsolateSpawnState(Dart_Port parent_port,
                     const char* script_url,
                     const char* package_config,
@@ -1252,8 +1155,7 @@
                     bool errorsAreFatal,
                     Dart_Port onExit,
                     Dart_Port onError,
-                    const char* debug_name,
-                    IsolateGroupSource* source);
+                    const char* debug_name);
   ~IsolateSpawnState();
 
   Isolate* isolate() const { return isolate_; }
@@ -1278,8 +1180,6 @@
   RawInstance* BuildArgs(Thread* thread);
   RawInstance* BuildMessage(Thread* thread);
 
-  IsolateGroupSource* source() const { return source_; }
-
  private:
   Isolate* isolate_;
   Dart_Port parent_port_;
@@ -1292,7 +1192,6 @@
   const char* class_name_;
   const char* function_name_;
   const char* debug_name_;
-  IsolateGroupSource* source_;
   std::unique_ptr<Message> serialized_args_;
   std::unique_ptr<Message> serialized_message_;
 
diff --git a/runtime/vm/kernel_isolate.cc b/runtime/vm/kernel_isolate.cc
index 4002a84..e1b8c7c 100644
--- a/runtime/vm/kernel_isolate.cc
+++ b/runtime/vm/kernel_isolate.cc
@@ -60,7 +60,7 @@
 const int KernelIsolate::kNotifyIsolateShutdown = 6;
 
 const char* KernelIsolate::kName = DART_KERNEL_ISOLATE_NAME;
-Dart_IsolateGroupCreateCallback KernelIsolate::create_group_callback_ = NULL;
+Dart_IsolateCreateCallback KernelIsolate::create_callback_ = NULL;
 Monitor* KernelIsolate::monitor_ = new Monitor();
 KernelIsolate::State KernelIsolate::state_ = KernelIsolate::kStopped;
 Isolate* KernelIsolate::isolate_ = NULL;
@@ -76,9 +76,9 @@
     char* error = NULL;
     Isolate* isolate = NULL;
 
-    Dart_IsolateGroupCreateCallback create_group_callback =
-        KernelIsolate::create_group_callback();
-    ASSERT(create_group_callback != NULL);
+    Dart_IsolateCreateCallback create_callback =
+        KernelIsolate::create_callback();
+    ASSERT(create_callback != NULL);
 
     // Note: these flags must match those passed to the VM during
     // the app-jit training run (see //utils/kernel-service/BUILD.gn).
@@ -94,8 +94,8 @@
 #endif
 
     isolate = reinterpret_cast<Isolate*>(
-        create_group_callback(KernelIsolate::kName, KernelIsolate::kName, NULL,
-                              NULL, &api_flags, NULL, &error));
+        create_callback(KernelIsolate::kName, KernelIsolate::kName, NULL, NULL,
+                        &api_flags, NULL, &error));
     if (isolate == NULL) {
       if (FLAG_trace_kernel) {
         OS::PrintErr(DART_KERNEL_ISOLATE_NAME ": Isolate creation error: %s\n",
@@ -227,8 +227,8 @@
   }
   // Grab the isolate create callback here to avoid race conditions with tests
   // that change this after Dart_Initialize returns.
-  create_group_callback_ = Isolate::CreateGroupCallback();
-  if (create_group_callback_ == NULL) {
+  create_callback_ = Isolate::CreateCallback();
+  if (create_callback_ == NULL) {
     KernelIsolate::InitializingFailed();
     return;
   }
diff --git a/runtime/vm/kernel_isolate.h b/runtime/vm/kernel_isolate.h
index fe457dd..cdfe9da 100644
--- a/runtime/vm/kernel_isolate.h
+++ b/runtime/vm/kernel_isolate.h
@@ -76,11 +76,11 @@
   static void FinishedExiting();
   static void FinishedInitializing();
   static void InitializingFailed();
-  static Dart_IsolateGroupCreateCallback create_group_callback() {
-    return create_group_callback_;
+  static Dart_IsolateCreateCallback create_callback() {
+    return create_callback_;
   }
 
-  static Dart_IsolateGroupCreateCallback create_group_callback_;
+  static Dart_IsolateCreateCallback create_callback_;
   static Monitor* monitor_;
   enum State {
     kStopped,
diff --git a/runtime/vm/service_isolate.cc b/runtime/vm/service_isolate.cc
index 1ab50b1..d76e551 100644
--- a/runtime/vm/service_isolate.cc
+++ b/runtime/vm/service_isolate.cc
@@ -73,7 +73,7 @@
 }
 
 const char* ServiceIsolate::kName = DART_VM_SERVICE_ISOLATE_NAME;
-Dart_IsolateGroupCreateCallback ServiceIsolate::create_group_callback_ = NULL;
+Dart_IsolateCreateCallback ServiceIsolate::create_callback_ = NULL;
 Monitor* ServiceIsolate::monitor_ = new Monitor();
 ServiceIsolate::State ServiceIsolate::state_ = ServiceIsolate::kStopped;
 Isolate* ServiceIsolate::isolate_ = NULL;
@@ -330,15 +330,16 @@
     char* error = NULL;
     Isolate* isolate = NULL;
 
-    const auto create_group_callback = ServiceIsolate::create_group_callback();
-    ASSERT(create_group_callback != NULL);
+    Dart_IsolateCreateCallback create_callback =
+        ServiceIsolate::create_callback();
+    ASSERT(create_callback != NULL);
 
     Dart_IsolateFlags api_flags;
     Isolate::FlagsInitialize(&api_flags);
 
     isolate = reinterpret_cast<Isolate*>(
-        create_group_callback(ServiceIsolate::kName, ServiceIsolate::kName,
-                              NULL, NULL, &api_flags, NULL, &error));
+        create_callback(ServiceIsolate::kName, ServiceIsolate::kName, NULL,
+                        NULL, &api_flags, NULL, &error));
     if (isolate == NULL) {
       if (FLAG_trace_service) {
         OS::PrintErr(DART_VM_SERVICE_ISOLATE_NAME
@@ -477,8 +478,8 @@
   }
   // Grab the isolate create callback here to avoid race conditions with tests
   // that change this after Dart_Initialize returns.
-  create_group_callback_ = Isolate::CreateGroupCallback();
-  if (create_group_callback_ == NULL) {
+  create_callback_ = Isolate::CreateCallback();
+  if (create_callback_ == NULL) {
     ServiceIsolate::InitializingFailed();
     return;
   }
diff --git a/runtime/vm/service_isolate.h b/runtime/vm/service_isolate.h
index 6d82bdc..ab08649 100644
--- a/runtime/vm/service_isolate.h
+++ b/runtime/vm/service_isolate.h
@@ -65,11 +65,11 @@
   static void FinishedInitializing();
   static void InitializingFailed();
   static void MaybeMakeServiceIsolate(Isolate* isolate);
-  static Dart_IsolateGroupCreateCallback create_group_callback() {
-    return create_group_callback_;
+  static Dart_IsolateCreateCallback create_callback() {
+    return create_callback_;
   }
 
-  static Dart_IsolateGroupCreateCallback create_group_callback_;
+  static Dart_IsolateCreateCallback create_callback_;
   static Monitor* monitor_;
   enum State {
     kStopped,
diff --git a/runtime/vm/unit_test.cc b/runtime/vm/unit_test.cc
index 49b6339..b75e93b 100644
--- a/runtime/vm/unit_test.cc
+++ b/runtime/vm/unit_test.cc
@@ -37,9 +37,9 @@
 const intptr_t platform_strong_dill_size = kPlatformStrongDillSize;
 
 const uint8_t* TesterState::vm_snapshot_data = NULL;
-Dart_IsolateGroupCreateCallback TesterState::create_callback = NULL;
+Dart_IsolateCreateCallback TesterState::create_callback = NULL;
 Dart_IsolateShutdownCallback TesterState::shutdown_callback = NULL;
-Dart_IsolateGroupCleanupCallback TesterState::group_cleanup_callback = nullptr;
+Dart_IsolateCleanupCallback TesterState::cleanup_callback = NULL;
 const char** TesterState::argv = NULL;
 int TesterState::argc = 0;
 
@@ -107,20 +107,17 @@
                                      intptr_t len,
                                      const uint8_t* instr_buffer,
                                      const char* name,
-                                     void* group_data,
-                                     void* isolate_data) {
+                                     void* data) {
   char* err;
   Dart_IsolateFlags api_flags;
   Isolate::FlagsInitialize(&api_flags);
   Dart_Isolate isolate = NULL;
   if (len == 0) {
-    isolate = Dart_CreateIsolateGroup(name, NULL, data_buffer, instr_buffer,
-                                      NULL, NULL, &api_flags, group_data,
-                                      isolate_data, &err);
+    isolate = Dart_CreateIsolate(name, NULL, data_buffer, instr_buffer, NULL,
+                                 NULL, &api_flags, data, &err);
   } else {
-    isolate = Dart_CreateIsolateGroupFromKernel(name, NULL, data_buffer, len,
-                                                &api_flags, group_data,
-                                                isolate_data, &err);
+    isolate = Dart_CreateIsolateFromKernel(name, NULL, data_buffer, len,
+                                           &api_flags, data, &err);
   }
   if (isolate == NULL) {
     OS::PrintErr("Creation of isolate failed '%s'\n", err);
@@ -130,13 +127,10 @@
   return isolate;
 }
 
-Dart_Isolate TestCase::CreateTestIsolate(const char* name,
-                                         void* group_data,
-                                         void* isolate_data) {
+Dart_Isolate TestCase::CreateTestIsolate(const char* name, void* data) {
   return CreateIsolate(bin::core_isolate_snapshot_data,
                        0 /* Snapshots have length encoded within them. */,
-                       bin::core_isolate_snapshot_instructions, name,
-                       group_data, isolate_data);
+                       bin::core_isolate_snapshot_instructions, name, data);
 }
 
 static const char* kPackageScheme = "package:";
diff --git a/runtime/vm/unit_test.h b/runtime/vm/unit_test.h
index cdf133a..742e3a7 100644
--- a/runtime/vm/unit_test.h
+++ b/runtime/vm/unit_test.h
@@ -232,9 +232,9 @@
 class TesterState : public AllStatic {
  public:
   static const uint8_t* vm_snapshot_data;
-  static Dart_IsolateGroupCreateCallback create_callback;
+  static Dart_IsolateCreateCallback create_callback;
   static Dart_IsolateShutdownCallback shutdown_callback;
-  static Dart_IsolateGroupCleanupCallback group_cleanup_callback;
+  static Dart_IsolateCleanupCallback cleanup_callback;
   static const char** argv;
   static int argc;
 };
@@ -358,9 +358,8 @@
                                                     const char* name = NULL) {
     return CreateIsolate(buffer, 0, NULL, name);
   }
-  static Dart_Isolate CreateTestIsolate(const char* name = nullptr,
-                                        void* isolate_group_data = nullptr,
-                                        void* isolate_data = nullptr);
+  static Dart_Isolate CreateTestIsolate(const char* name = NULL,
+                                        void* data = NULL);
   static Dart_Handle library_handler(Dart_LibraryTag tag,
                                      Dart_Handle library,
                                      Dart_Handle url);
@@ -394,8 +393,7 @@
                                     intptr_t len,
                                     const uint8_t* instr_buffer,
                                     const char* name,
-                                    void* group_data = nullptr,
-                                    void* isolate_data = nullptr);
+                                    void* data = NULL);
 
   static char* ValidateCompilationResult(Zone* zone,
                                          Dart_KernelCompilationResult result,
diff --git a/tools/patches/flutter-engine/7340a569caac6431d8698dc3788579b57ffcf0c6.patch b/tools/patches/flutter-engine/7340a569caac6431d8698dc3788579b57ffcf0c6.patch
deleted file mode 100644
index 5e57559..0000000
--- a/tools/patches/flutter-engine/7340a569caac6431d8698dc3788579b57ffcf0c6.patch
+++ /dev/null
@@ -1,147 +0,0 @@
-diff --git a/runtime/dart_isolate.cc b/runtime/dart_isolate.cc
-index e181dd55b..318649190 100644
---- a/runtime/dart_isolate.cc
-+++ b/runtime/dart_isolate.cc
-@@ -163,7 +163,7 @@ bool DartIsolate::Initialize(Dart_Isolate dart_isolate, bool is_root_isolate) {
-   }
- 
-   auto* isolate_data = static_cast<std::shared_ptr<DartIsolate>*>(
--      Dart_IsolateData(dart_isolate));
-+      Dart_IsolateGroupData(dart_isolate));
-   if (isolate_data->get() != this) {
-     return false;
-   }
-@@ -174,7 +174,7 @@ bool DartIsolate::Initialize(Dart_Isolate dart_isolate, bool is_root_isolate) {
-   // We are entering a new scope (for the first time since initialization) and
-   // we want to restore the current scope to null when we exit out of this
-   // method. This balances the implicit Dart_EnterIsolate call made by
--  // Dart_CreateIsolate (which calls the Initialize).
-+  // Dart_CreateIsolateGroup (which calls the Initialize).
-   Dart_ExitIsolate();
- 
-   tonic::DartIsolateScope scope(isolate());
-@@ -720,14 +720,16 @@ DartIsolate::CreateDartVMAndEmbedderObjectPair(
-   }
- 
-   // Create the Dart VM isolate and give it the embedder object as the baton.
--  Dart_Isolate isolate = Dart_CreateIsolate(
-+  Dart_Isolate isolate = Dart_CreateIsolateGroup(
-       advisory_script_uri,         //
-       advisory_script_entrypoint,  //
-       (*embedder_isolate)->GetIsolateSnapshot()->GetDataMapping(),
-       (*embedder_isolate)->GetIsolateSnapshot()->GetInstructionsMapping(),
-       (*embedder_isolate)->GetSharedSnapshot()->GetDataMapping(),
-       (*embedder_isolate)->GetSharedSnapshot()->GetInstructionsMapping(), flags,
--      embedder_isolate.get(), error);
-+      /*isolate_group_data=*/embedder_isolate.get(),
-+      /*isolate_data=*/embedder_isolate.get(),
-+      error);
- 
-   if (isolate == nullptr) {
-     FML_DLOG(ERROR) << *error;
-@@ -770,14 +772,15 @@ DartIsolate::CreateDartVMAndEmbedderObjectPair(
- 
- // |Dart_IsolateShutdownCallback|
- void DartIsolate::DartIsolateShutdownCallback(
--    std::shared_ptr<DartIsolate>* embedder_isolate) {
--  embedder_isolate->get()->OnShutdownCallback();
-+      std::shared_ptr<DartIsolate>* isolate_group_data,
-+      std::shared_ptr<DartIsolate>* isolate_data) {
-+  isolate_group_data->get()->OnShutdownCallback();
- }
- 
--// |Dart_IsolateCleanupCallback|
--void DartIsolate::DartIsolateCleanupCallback(
--    std::shared_ptr<DartIsolate>* embedder_isolate) {
--  delete embedder_isolate;
-+// |Dart_IsolateGroupCleanupCallback|
-+void DartIsolate::DartIsolateGroupCleanupCallback(
-+    std::shared_ptr<DartIsolate>* isolate_group_data) {
-+  delete isolate_group_data;
- }
- 
- fml::RefPtr<const DartSnapshot> DartIsolate::GetIsolateSnapshot() const {
-diff --git a/runtime/dart_isolate.h b/runtime/dart_isolate.h
-index 407852dc2..1f6689e87 100644
---- a/runtime/dart_isolate.h
-+++ b/runtime/dart_isolate.h
-@@ -186,11 +186,12 @@ class DartIsolate : public UIDartState {
- 
-   // |Dart_IsolateShutdownCallback|
-   static void DartIsolateShutdownCallback(
--      std::shared_ptr<DartIsolate>* embedder_isolate);
-+      std::shared_ptr<DartIsolate>* isolate_group_data,
-+      std::shared_ptr<DartIsolate>* isolate_data);
- 
--  // |Dart_IsolateCleanupCallback|
--  static void DartIsolateCleanupCallback(
--      std::shared_ptr<DartIsolate>* embedder_isolate);
-+  // |Dart_IsolateGroupCleanupCallback|
-+  static void DartIsolateGroupCleanupCallback(
-+      std::shared_ptr<DartIsolate>* isolate_group_data);
- 
-   FML_DISALLOW_COPY_AND_ASSIGN(DartIsolate);
- };
-diff --git a/runtime/dart_vm.cc b/runtime/dart_vm.cc
-index 903e74b15..9f6d51b7a 100644
---- a/runtime/dart_vm.cc
-+++ b/runtime/dart_vm.cc
-@@ -366,12 +366,16 @@ DartVM::DartVM(std::shared_ptr<const DartVMData> vm_data,
-     params.vm_snapshot_data = vm_data_->GetVMSnapshot().GetDataMapping();
-     params.vm_snapshot_instructions =
-         vm_data_->GetVMSnapshot().GetInstructionsMapping();
--    params.create = reinterpret_cast<decltype(params.create)>(
-+    params.create_group = reinterpret_cast<decltype(params.create_group)>(
-         DartIsolate::DartIsolateCreateCallback);
--    params.shutdown = reinterpret_cast<decltype(params.shutdown)>(
-+    // NOTE: The Flutter embedder does not explicitly opt into having multiple
-+    // isolates inside one isolate group *yet*.  This means every isolate will
-+    // go into it's own isolate group atm.
-+    params.initialize_isolate = nullptr;
-+    params.shutdown_isolate = reinterpret_cast<decltype(params.shutdown_isolate)>(
-         DartIsolate::DartIsolateShutdownCallback);
--    params.cleanup = reinterpret_cast<decltype(params.cleanup)>(
--        DartIsolate::DartIsolateCleanupCallback);
-+    params.cleanup_group = reinterpret_cast<decltype(params.cleanup_group)>(
-+        DartIsolate::DartIsolateGroupCleanupCallback);
-     params.thread_exit = ThreadExitCallback;
-     params.get_service_assets = GetVMServiceAssetsArchiveCallback;
-     params.entropy_source = dart::bin::GetEntropy;
-diff --git a/shell/platform/fuchsia/dart/dart_component_controller.cc b/shell/platform/fuchsia/dart/dart_component_controller.cc
-index 1c4f71050..ce607ae92 100644
---- a/shell/platform/fuchsia/dart/dart_component_controller.cc
-+++ b/shell/platform/fuchsia/dart/dart_component_controller.cc
-@@ -324,10 +324,11 @@ bool DartComponentController::CreateIsolate(
-   auto state = new std::shared_ptr<tonic::DartState>(new tonic::DartState(
-       namespace_fd, [this](Dart_Handle result) { MessageEpilogue(result); }));
- 
--  isolate_ = Dart_CreateIsolate(
-+  isolate_ = Dart_CreateIsolateGroup(
-       url_.c_str(), label_.c_str(), isolate_snapshot_data,
-       isolate_snapshot_instructions, shared_snapshot_data,
--      shared_snapshot_instructions, nullptr /* flags */, state, &error);
-+      shared_snapshot_instructions, nullptr /* flags */,
-+      /*isolate_group_data=*/state, /*isolate_data=*/state, &error);
-   if (!isolate_) {
-     FX_LOGF(ERROR, LOG_TAG, "Dart_CreateIsolate failed: %s", error);
-     return false;
-diff --git a/shell/platform/fuchsia/dart/service_isolate.cc b/shell/platform/fuchsia/dart/service_isolate.cc
-index 2e6eda265..b45b40a2f 100644
---- a/shell/platform/fuchsia/dart/service_isolate.cc
-+++ b/shell/platform/fuchsia/dart/service_isolate.cc
-@@ -123,12 +123,12 @@ Dart_Isolate CreateServiceIsolate(const char* uri,
- #endif
- 
-   auto state = new std::shared_ptr<tonic::DartState>(new tonic::DartState());
--  Dart_Isolate isolate = Dart_CreateIsolate(
-+  Dart_Isolate isolate = Dart_CreateIsolateGroup(
-       uri, DART_VM_SERVICE_ISOLATE_NAME, mapped_isolate_snapshot_data.address(),
-       mapped_isolate_snapshot_instructions.address(),
-       mapped_shared_snapshot_data.address(),
--      mapped_shared_snapshot_instructions.address(), nullptr /* flags */, state,
--      error);
-+      mapped_shared_snapshot_instructions.address(), nullptr /* flags */,
-+      /*isolate_group_data=*/state, /*isolate_data=*/state, error);
-   if (!isolate) {
-     FX_LOGF(ERROR, LOG_TAG, "Dart_CreateIsolate failed: %s", *error);
-     return nullptr;