Very simple version of Isolates.

tests/isolate/mandel_isolate_test.dart

 // Copyright (c) 2012, 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.
 
 library MandelIsolateTest;
 import 'dart:async';
 import 'dart:isolate';
 import 'dart:math';
 import '../../pkg/unittest/lib/unittest.dart';
 
@@ skipping 19 matching lines @@
   MandelbrotState() {
     _result = new List<List<int>>(N);
     _lineProcessedBy = new List<LineProcessorClient>(N);
     _sent = 0;
     _missing = N;
     _validated = new Completer<bool>();
   }
 
   void startClient(int id) {
     assert(_sent < N);
-    final client = new LineProcessorClient(this, id);
-    client.processLine(_sent++);
+    int line = _sent++;
+    LineProcessorClient.create(this, id).then((final client) {
+      client.processLine(line);
+    });
   }
 
   void notifyProcessedLine(LineProcessorClient client, int y, List<int> line) {
     assert(_result[y] == null);
     _result[y] = line;
     _lineProcessedBy[y] = client;
 
     if (_sent != N) {
       client.processLine(_sent++);
     } else {
@@ skipping 27 matching lines @@
 
   List<List<int>> _result;
   List<LineProcessorClient> _lineProcessedBy;
   int _sent;
   int _missing;
   Completer<bool> _validated;
 }
 
 
 class LineProcessorClient {
+  MandelbrotState _state;
+  int _id;
+  SendPort _port;
 
-  LineProcessorClient(MandelbrotState this._state, int this._id) {
-    _port = spawnFunction(processLines);
+  LineProcessorClient(this._state, this._id, this._port);
+
+  static Future<LineProcessorClient> create(MandelbrotState state, int id) {
+    ReceivePort reply = new ReceivePort();
+    return Isolate.spawn(processLines, reply.sendPort).then((_) {
+      return reply.first.then((port) {
+        return new LineProcessorClient(state, id, port);
+      });
+    });
   }
 
   void processLine(int y) {
-    _port.call(y).then((List<int> message) {
+    ReceivePort reply = new ReceivePort();
+    _port.send([y, reply.sendPort]);
+    reply.first.then((List<int> message) {
       _state.notifyProcessedLine(this, y, message);
     });
   }
 
   void shutdown() {
-    _port.send(TERMINATION_MESSAGE, null);
+    _port.send(TERMINATION_MESSAGE);
   }
-
-  MandelbrotState _state;
-  int _id;
-  SendPort _port;
 }
 
 List<int> processLine(int y) {
   double inverseN = 2.0 / N;
   double Civ = y * inverseN - 1.0;
   List<int> result = new List<int>(N);
   for (int x = 0; x < N; x++) {
     double Crv = x * inverseN - 1.5;
 
     double Zrv = Crv;
     double Ziv = Civ;
 
     double Trv = Crv * Crv;
     double Tiv = Civ * Civ;
 
     int i = 49;
     do {
       Ziv = (Zrv * Ziv) + (Zrv * Ziv) + Civ;
       Zrv = Trv - Tiv + Crv;
 
       Trv = Zrv * Zrv;
       Tiv = Ziv * Ziv;
     } while (((Trv + Tiv) <= 4.0) && (--i > 0));
 
     result[x] = i;
   }
   return result;
 }
 
-void processLines() {
-  port.receive((message, SendPort replyTo) {
-    if (message == TERMINATION_MESSAGE) {
-      assert(replyTo == null);
+void processLines(SendPort replyPort) {
+  ReceivePort port = new ReceivePort();
+  port.listen((message) {
+    if (message != TERMINATION_MESSAGE) {
+      int line = message[0];
+      SendPort replyTo = message[1];
+      replyTo.send(processLine(line));
+    } else {
       port.close();
-    } else {
-      replyTo.send(processLine(message), null);
     }
   });
+  replyPort.send(port.sendPort);
 }