Very simple version of Isolates.

sdk/lib/_internal/pub/lib/src/dart.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /// A library for compiling Dart code and manipulating analyzer parse trees.
 library pub.dart;
 
 import 'dart:async';
 import 'dart:isolate';
 
@@ skipping 74 matching lines @@
 /// [code] should be the contents of a Dart entrypoint. It may contain imports;
 /// they will be resolved in the same context as the host isolate.
 ///
 /// Returns a Future that will resolve to a [SendPort] that will communicate to
 /// the spawned isolate once it's spawned. If the isolate fails to spawn, the
 /// Future will complete with an error.
 Future<SendPort> runInIsolate(String code) {
   return withTempDir((dir) {
     var dartPath = path.join(dir, 'runInIsolate.dart');
     writeTextFile(dartPath, code, dontLogContents: true);
-    var bufferPort = spawnFunction(_isolateBuffer);
-    return bufferPort.call(path.toUri(dartPath).toString()).then((response) {
-      if (response.first == 'error') {
-        return new Future.error(
-            new CrossIsolateException.deserialize(response.last));
-      }
+    var port = new ReceivePort();
+    var initialMessage =  [path.toUri(dartPath).toString(), port.sendPort];
+    var isolate = Isolate.spawn(_isolateBuffer, initialMessage);
+    return isolate.then((_) {
+      return port.first.then((response) {
+        if (response.first == 'error') {
+          return new Future.error(
+              new CrossIsolateException.deserialize(response.last));
+        }
 
-      return response.last;
+        return response.last;
+      });
     });
   });
 }
 
 // TODO(nweiz): remove this when issue 12617 is fixed.
 /// A function used as a buffer between the host isolate and [spawnUri].
 ///
 /// [spawnUri] synchronously loads the file and its imports, which can deadlock
 /// the host isolate if there's an HTTP import pointing at a server in the host.
 /// Adding an additional isolate in the middle works around this.
-void _isolateBuffer() {
-  port.receive((uri, replyTo) {
-    try {
-      replyTo.send(['success', spawnUri(uri)]);
-    } catch (e, stack) {
+void _isolateBuffer(initialMessage) {
+  var uri = initialMessage[0];
+  var replyTo = initialMessage[1];
+  try {
+    // TODO(floitsch): If we do it right we shouldn't need to have a try/catch
+    // and a catchError.
+    Isolate.spawnUri(Uri.parse(uri), [], replyTo).catchError((e, stack) {
       replyTo.send(['error', CrossIsolateException.serialize(e, stack)]);
-    }
-  });
+    });
+  } catch (e, stack) {
+    replyTo.send(['error', CrossIsolateException.serialize(e, stack)]);
+  }
 }
 
 /// An exception that was originally raised in another isolate.
 ///
 /// Exception objects can't cross isolate boundaries in general, so this class
 /// wraps as much information as can be consistently serialized.
 class CrossIsolateException implements Exception {
   /// The name of the type of exception thrown.
   ///
   /// This is the return value of [error.runtimeType.toString()]. Keep in mind
@@ skipping 29 matching lines @@
     if (stack == null) stack = getAttachedStackTrace(error);
     return {
       'type': error.runtimeType.toString(),
       'message': getErrorMessage(error),
       'stack': stack == null ? null : stack.toString()
     };
   }
 
   String toString() => "$message\n$stackTrace";
 }