diff --git a/dev/core/src/com/google/gwt/core/ext/linker/impl/StandardCompilationResult.java b/dev/core/src/com/google/gwt/core/ext/linker/impl/StandardCompilationResult.java
index 2b4f0f8..716995e 100644
--- a/dev/core/src/com/google/gwt/core/ext/linker/impl/StandardCompilationResult.java
+++ b/dev/core/src/com/google/gwt/core/ext/linker/impl/StandardCompilationResult.java
@@ -17,6 +17,7 @@
 
 import com.google.gwt.core.ext.linker.CompilationResult;
 import com.google.gwt.core.ext.linker.SelectionProperty;
+import com.google.gwt.dev.PermutationResult;
 import com.google.gwt.dev.util.Util;
 
 import java.io.File;
@@ -68,19 +69,18 @@
    */
   public static final Comparator<SortedMap<SelectionProperty, String>> MAP_COMPARATOR = new MapComparator();
 
-  private final File cacheFile;
+  private final File resultFile;
   private transient SoftReference<String[]> js;
 
   private final SortedSet<SortedMap<SelectionProperty, String>> propertyValues = new TreeSet<SortedMap<SelectionProperty, String>>(
       MAP_COMPARATOR);
   private final String strongName;
 
-  public StandardCompilationResult(String[] js, String strongName,
-      File cacheFile) {
+  public StandardCompilationResult(String[] js, String strongName, File resultFile) {
     super(StandardLinkerContext.class);
     this.js = new SoftReference<String[]>(js);
     this.strongName = strongName;
-    this.cacheFile = cacheFile;
+    this.resultFile = resultFile;
   }
 
   /**
@@ -102,12 +102,20 @@
     }
 
     if (toReturn == null) {
-      byte[][] bytes = Util.readFileAndSplit(cacheFile);
-      if (bytes == null) {
-        throw new RuntimeException("Unexpectedly unable to read JS file '"
-            + cacheFile.getAbsolutePath() + "'");
+      PermutationResult result;
+      try {
+        result = Util.readFileAsObject(resultFile, PermutationResult.class);
+      } catch (ClassNotFoundException e) {
+        throw new RuntimeException(
+            "Unexpectedly unable to read PermutationResult '"
+                + resultFile.getAbsolutePath() + "'", e);
       }
-      toReturn = Util.toStrings(bytes);
+      if (result == null) {
+        throw new RuntimeException(
+            "Unexpectedly unable to read PermutationResult '"
+                + resultFile.getAbsolutePath() + "'");
+      }
+      toReturn = result.getJs();
       js = new SoftReference<String[]>(toReturn);
     }
     return toReturn;
diff --git a/dev/core/src/com/google/gwt/core/ext/linker/impl/StandardLinkerContext.java b/dev/core/src/com/google/gwt/core/ext/linker/impl/StandardLinkerContext.java
index 26353b1..cb9619a 100644
--- a/dev/core/src/com/google/gwt/core/ext/linker/impl/StandardLinkerContext.java
+++ b/dev/core/src/com/google/gwt/core/ext/linker/impl/StandardLinkerContext.java
@@ -26,6 +26,7 @@
 import com.google.gwt.core.ext.linker.PublicResource;
 import com.google.gwt.core.ext.linker.SelectionProperty;
 import com.google.gwt.core.ext.linker.LinkerOrder.Order;
+import com.google.gwt.dev.PermutationResult;
 import com.google.gwt.dev.cfg.BindingProperty;
 import com.google.gwt.dev.cfg.ModuleDef;
 import com.google.gwt.dev.cfg.Property;
@@ -261,21 +262,27 @@
   /**
    * Gets or creates a CompilationResult for the given JavaScript program.
    */
-  public StandardCompilationResult getCompilation(TreeLogger logger, File jsFile)
-      throws UnableToCompleteException {
-    byte[][] results = Util.readFileAndSplit(jsFile);
-
-    if (results == null) {
-      logger.log(TreeLogger.ERROR, "Unable to read file '"
-          + jsFile.getAbsolutePath() + "'");
+  public StandardCompilationResult getCompilation(TreeLogger logger,
+      File resultFile) throws UnableToCompleteException {
+    PermutationResult permutationResult;
+    try {
+      permutationResult = Util.readFileAsObject(resultFile,
+          PermutationResult.class);
+    } catch (ClassNotFoundException e) {
+      logger.log(TreeLogger.ERROR, "Unable to instantiate PermutationResult", e);
       throw new UnableToCompleteException();
     }
 
-    String strongName = Util.computeStrongName(results);
+    if (permutationResult == null) {
+      logger.log(TreeLogger.ERROR, "Unable to read PermutationResult");
+      throw new UnableToCompleteException();
+    }
+
+    String strongName = Util.computeStrongName(Util.getBytes(permutationResult.getJs()));
     StandardCompilationResult result = resultsByStrongName.get(strongName);
     if (result == null) {
-      result = new StandardCompilationResult(Util.toStrings(results), strongName,
-          jsFile);
+      result = new StandardCompilationResult(permutationResult.getJs(),
+          strongName, resultFile);
       resultsByStrongName.put(result.getStrongName(), result);
       artifacts.add(result);
     }
diff --git a/dev/core/src/com/google/gwt/dev/CompilePerms.java b/dev/core/src/com/google/gwt/dev/CompilePerms.java
index 55c5999..ec0e924 100644
--- a/dev/core/src/com/google/gwt/dev/CompilePerms.java
+++ b/dev/core/src/com/google/gwt/dev/CompilePerms.java
@@ -18,10 +18,10 @@
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
 import com.google.gwt.dev.CompileTaskRunner.CompileTask;
-import com.google.gwt.dev.PermutationCompiler.ResultsHandler;
-import com.google.gwt.dev.jjs.UnifiedAst;
 import com.google.gwt.dev.jjs.JavaToJavaScriptCompiler;
+import com.google.gwt.dev.jjs.UnifiedAst;
 import com.google.gwt.dev.util.Util;
+import com.google.gwt.dev.util.arg.ArgHandlerLocalWorkers;
 import com.google.gwt.util.tools.ArgHandlerString;
 
 import java.io.File;
@@ -29,15 +29,16 @@
 import java.util.TreeSet;
 
 /**
- * Performs the second phase of compilation, converting the Precompile's AST into
- * JavaScript outputs.
+ * Performs the second phase of compilation, converting the Precompile's AST
+ * into JavaScript outputs.
  */
 public class CompilePerms {
 
   /**
    * Options for CompilePerms.
    */
-  public interface CompilePermsOptions extends CompileTaskOptions, OptionPerms {
+  public interface CompilePermsOptions extends CompileTaskOptions,
+      OptionLocalWorkers, OptionPerms {
   }
 
   /**
@@ -121,6 +122,7 @@
     public ArgProcessor(CompilePermsOptions options) {
       super(options);
       registerHandler(new ArgHandlerPerms(options));
+      registerHandler(new ArgHandlerLocalWorkers(options));
     }
 
     @Override
@@ -135,6 +137,7 @@
   static class CompilePermsOptionsImpl extends CompileTaskOptionsImpl implements
       CompilePermsOptions {
 
+    private int localWorkers;
     private int[] permsToCompile = new int[0];
 
     public CompilePermsOptionsImpl() {
@@ -146,24 +149,40 @@
 
     public void copyFrom(CompilePermsOptions other) {
       super.copyFrom(other);
-
       setPermsToCompile(other.getPermsToCompile());
+      setLocalWorkers(other.getLocalWorkers());
+    }
+
+    public int getLocalWorkers() {
+      return localWorkers;
     }
 
     public int[] getPermsToCompile() {
       return permsToCompile.clone();
     }
 
+    public void setLocalWorkers(int localWorkers) {
+      this.localWorkers = localWorkers;
+    }
+
     public void setPermsToCompile(int[] permsToCompile) {
       this.permsToCompile = permsToCompile.clone();
     }
   }
 
-  public static String[] compile(TreeLogger logger, Permutation permutation,
-      UnifiedAst unifiedAst) {
+  /**
+   * Compile a single permutation.
+   */
+  public static PermutationResult compile(TreeLogger logger,
+      Permutation permutation, UnifiedAst unifiedAst) {
     try {
-      return JavaToJavaScriptCompiler.compilePermutation(logger, unifiedAst,
-          permutation.getRebindAnswers());
+      final String js[] = JavaToJavaScriptCompiler.compilePermutation(logger,
+          unifiedAst, permutation.getRebindAnswers());
+      return new PermutationResult() {
+        public String[] getJs() {
+          return js;
+        }
+      };
     } catch (UnableToCompleteException e) {
       // We intentionally don't pass in the exception here since the real
       // cause has been logged.
@@ -171,6 +190,20 @@
     }
   }
 
+  /**
+   * Compile multiple permutations.
+   */
+  public static boolean compile(TreeLogger logger,
+      Precompilation precompilation, Permutation[] perms, int localWorkers,
+      File[] resultFiles) throws UnableToCompleteException {
+    final TreeLogger branch = logger.branch(TreeLogger.INFO, "Compiling "
+        + perms.length + " permutations");
+    PermutationWorkerFactory.compilePermutations(logger, precompilation, perms,
+        localWorkers, resultFiles);
+    branch.log(TreeLogger.INFO, "Permutation compile succeeded");
+    return true;
+  }
+
   public static void main(String[] args) {
     /*
      * NOTE: main always exits with a call to System.exit to terminate any
@@ -194,6 +227,14 @@
     System.exit(1);
   }
 
+  public static File[] makeResultFiles(File compilerWorkDir, Permutation[] perms) {
+    File[] resultFiles = new File[perms.length];
+    for (int i = 0; i < perms.length; ++i) {
+      resultFiles[i] = makePermFilename(compilerWorkDir, perms[i].getId());
+    }
+    return resultFiles;
+  }
+
   /**
    * Return the filename corresponding to the given permutation number,
    * one-based.
@@ -229,17 +270,15 @@
           + precompilationFile.getAbsolutePath() + "'", e);
       return false;
     }
-    Permutation[] perms = precompilation.getPermutations();
-    UnifiedAst unifiedAst = precompilation.getUnifiedAst();
-    int[] permsToRun = options.getPermsToCompile();
 
+    Permutation[] perms = precompilation.getPermutations();
+    Permutation[] subPerms;
+    int[] permsToRun = options.getPermsToCompile();
     if (permsToRun.length == 0) {
-      // Compile them all.
-      permsToRun = new int[perms.length];
-      for (int i = 0; i < permsToRun.length; ++i) {
-        permsToRun[i] = i;
-      }
+      subPerms = perms;
     } else {
+      int i = 0;
+      subPerms = new Permutation[permsToRun.length];
       // Range check the supplied perms.
       for (int permToRun : permsToRun) {
         if (permToRun >= perms.length) {
@@ -248,21 +287,12 @@
               + (perms.length - 1) + "'");
           return false;
         }
+        subPerms[i++] = perms[permToRun];
       }
     }
 
-    final TreeLogger branch = logger.branch(TreeLogger.INFO, "Compiling "
-        + permsToRun.length + " permutations");
-    PermutationCompiler multiThread = new PermutationCompiler(branch,
-        unifiedAst, perms, permsToRun);
-    multiThread.go(new ResultsHandler() {
-      public void addResult(Permutation permutation, int permNum, String[] js)
-          throws UnableToCompleteException {
-        Util.writeStringsAsFile(branch, makePermFilename(
-            options.getCompilerWorkDir(), permNum), js);
-      }
-    });
-    branch.log(TreeLogger.INFO, "Permutation compile succeeded");
-    return true;
+    File[] resultFiles = makeResultFiles(options.getCompilerWorkDir(), perms);
+    return compile(logger, precompilation, subPerms, options.getLocalWorkers(),
+        resultFiles);
   }
 }
diff --git a/dev/core/src/com/google/gwt/dev/CompilePermsServer.java b/dev/core/src/com/google/gwt/dev/CompilePermsServer.java
new file mode 100644
index 0000000..ace3385
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/CompilePermsServer.java
@@ -0,0 +1,309 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.dev;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.TreeLogger.Type;
+import com.google.gwt.dev.jjs.UnifiedAst;
+import com.google.gwt.dev.util.arg.ArgHandlerLogLevel;
+import com.google.gwt.dev.util.arg.OptionLogLevel;
+import com.google.gwt.dev.util.log.PrintWriterTreeLogger;
+import com.google.gwt.util.tools.ArgHandlerString;
+import com.google.gwt.util.tools.ToolBase;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.net.Socket;
+import java.net.UnknownHostException;
+
+/**
+ * An out-of-process implementation of CompilePerms that will connect back to an
+ * existing compiler host. This class is intended to be launched by
+ * {@link ExternalPermutationWorkerFactory} and not by users directly.
+ */
+public class CompilePermsServer {
+  /**
+   * Adds host and port information.
+   */
+  public interface CompileServerOptions extends OptionLogLevel {
+    String getCompileHost();
+
+    int getCompilePort();
+
+    String getCookie();
+
+    void setCompileHost(String host);
+
+    void setCompilePort(int port);
+
+    void setCookie(String cookie);
+  }
+
+  static final class ArgHandlerCompileHost extends ArgHandlerString {
+    private final CompileServerOptions options;
+
+    public ArgHandlerCompileHost(CompileServerOptions options) {
+      this.options = options;
+    }
+
+    @Override
+    public String getPurpose() {
+      return "The host to which the permutation server should connect";
+    }
+
+    @Override
+    public String getTag() {
+      return "-host";
+    }
+
+    @Override
+    public String[] getTagArgs() {
+      return new String[] {"hostname"};
+    }
+
+    @Override
+    public boolean isRequired() {
+      return true;
+    }
+
+    @Override
+    public boolean setString(String str) {
+      options.setCompileHost(str);
+      return true;
+    }
+  }
+
+  static final class ArgHandlerCompilePort extends ArgHandlerString {
+    private final CompileServerOptions options;
+
+    public ArgHandlerCompilePort(CompileServerOptions options) {
+      this.options = options;
+    }
+
+    @Override
+    public String getPurpose() {
+      return "The port to which the permutation server should connect";
+    }
+
+    @Override
+    public String getTag() {
+      return "-port";
+    }
+
+    @Override
+    public String[] getTagArgs() {
+      return new String[] {"1234"};
+    }
+
+    @Override
+    public boolean isRequired() {
+      return true;
+    }
+
+    @Override
+    public boolean setString(String str) {
+      Integer port = Integer.parseInt(str);
+      if (port <= 0) {
+        return false;
+      }
+      options.setCompilePort(port);
+      return true;
+    }
+  }
+
+  static final class ArgHandlerCookie extends ArgHandlerString {
+
+    private final CompileServerOptions options;
+
+    public ArgHandlerCookie(CompileServerOptions option) {
+      this.options = option;
+    }
+
+    @Override
+    public String getPurpose() {
+      return "Specifies the security cookie the server expects";
+    }
+
+    @Override
+    public String getTag() {
+      return "-cookie";
+    }
+
+    @Override
+    public String[] getTagArgs() {
+      return new String[] {"cookie"};
+    }
+
+    @Override
+    public boolean isRequired() {
+      return true;
+    }
+
+    @Override
+    public boolean setString(String str) {
+      options.setCookie(str);
+      return true;
+    }
+  }
+
+  static class ArgProcessor extends ToolBase {
+    public ArgProcessor(CompileServerOptions options) {
+      registerHandler(new ArgHandlerLogLevel(options));
+      registerHandler(new ArgHandlerCompileHost(options));
+      registerHandler(new ArgHandlerCompilePort(options));
+      registerHandler(new ArgHandlerCookie(options));
+    }
+
+    /*
+     * Overridden to make public.
+     */
+    @Override
+    public final boolean processArgs(String[] args) {
+      return super.processArgs(args);
+    }
+
+    @Override
+    protected String getName() {
+      return CompilePermsServer.class.getName();
+    }
+  }
+
+  static class CompileServerOptionsImpl implements CompileServerOptions {
+
+    private String compileHost;
+    private int compilePort;
+    private String cookie;
+    private Type logLevel;
+
+    public void copyFrom(CompileServerOptions other) {
+      setCompileHost(other.getCompileHost());
+      setCompilePort(other.getCompilePort());
+      setCookie(other.getCookie());
+      setLogLevel(other.getLogLevel());
+    }
+
+    public String getCompileHost() {
+      return compileHost;
+    }
+
+    public int getCompilePort() {
+      return compilePort;
+    }
+
+    public String getCookie() {
+      return cookie;
+    }
+
+    public Type getLogLevel() {
+      return logLevel;
+    }
+
+    public void setCompileHost(String host) {
+      assert host != null;
+      compileHost = host;
+    }
+
+    public void setCompilePort(int port) {
+      assert port > 0;
+      compilePort = port;
+    }
+
+    public void setCookie(String cookie) {
+      this.cookie = cookie;
+    }
+
+    public void setLogLevel(Type logLevel) {
+      this.logLevel = logLevel;
+    }
+  }
+
+  public static void main(String[] args) {
+    final CompileServerOptions options = new CompileServerOptionsImpl();
+    if (new ArgProcessor(options).processArgs(args)) {
+      PrintWriterTreeLogger logger = new PrintWriterTreeLogger();
+      logger.setMaxDetail(options.getLogLevel());
+      if (run(options, logger)) {
+        System.exit(0);
+      }
+    }
+    System.exit(-1);
+  }
+
+  public static boolean run(CompileServerOptions options, TreeLogger logger) {
+    try {
+      Socket s = new Socket(options.getCompileHost(), options.getCompilePort());
+      logger.log(TreeLogger.DEBUG, "Socket opened");
+
+      ObjectOutputStream out = new ObjectOutputStream(s.getOutputStream());
+      ObjectInputStream in = new ObjectInputStream(s.getInputStream());
+
+      // Write my cookie
+      out.writeUTF(options.getCookie());
+      out.flush();
+
+      // Read the File that contains the serialized UnifiedAst
+      File astFile = (File) in.readObject();
+      ObjectInputStream astIn = new ObjectInputStream(new FileInputStream(
+          astFile));
+      UnifiedAst ast = (UnifiedAst) astIn.readObject();
+      ast.prepare();
+      logger.log(TreeLogger.SPAM, "Created new UnifiedAst instance");
+
+      // Report on the amount of memory we think we're using
+      long estimatedMemory = Runtime.getRuntime().totalMemory()
+          - Runtime.getRuntime().freeMemory();
+      out.writeLong(estimatedMemory);
+      out.flush();
+
+      boolean keepGoing = in.readBoolean();
+      while (keepGoing) {
+        compilePermutation(logger, ast, in, out);
+
+        keepGoing = in.readBoolean();
+        logger.log(TreeLogger.SPAM, "keepGoing = " + keepGoing);
+      }
+
+      logger.log(TreeLogger.DEBUG, "Successfully terminating");
+      return true;
+
+    } catch (UnknownHostException e) {
+      logger.log(TreeLogger.ERROR, "Invalid hostname", e);
+    } catch (IOException e) {
+      logger.log(TreeLogger.ERROR, "Communication error", e);
+    } catch (ClassNotFoundException e) {
+      logger.log(TreeLogger.ERROR, "Probable client/server mismatch or "
+          + "classpath misconfiguration", e);
+    }
+    return false;
+  }
+
+  static void compilePermutation(TreeLogger logger, UnifiedAst ast,
+      ObjectInputStream in, ObjectOutputStream out)
+      throws ClassNotFoundException, IOException {
+    Permutation p = (Permutation) in.readObject();
+    logger.log(TreeLogger.SPAM, "Permutation read");
+
+    PermutationResult result = CompilePerms.compile(logger.branch(
+        TreeLogger.DEBUG, "Compiling"), p, ast);
+    logger.log(TreeLogger.DEBUG, "Successfully compiled permutation");
+    out.writeObject(result);
+    out.flush();
+    logger.log(TreeLogger.SPAM, "Sent result");
+  }
+}
diff --git a/dev/core/src/com/google/gwt/dev/CompileTaskOptionsImpl.java b/dev/core/src/com/google/gwt/dev/CompileTaskOptionsImpl.java
index e0b7ead..e92d1c8 100644
--- a/dev/core/src/com/google/gwt/dev/CompileTaskOptionsImpl.java
+++ b/dev/core/src/com/google/gwt/dev/CompileTaskOptionsImpl.java
@@ -24,8 +24,6 @@
  */
 class CompileTaskOptionsImpl implements CompileTaskOptions {
 
-  public static final String GWT_TMP_DIR = "gwt-tmp";
-
   private Type logLevel;
   private String moduleName;
   private boolean useGuiLogger;
diff --git a/dev/core/src/com/google/gwt/dev/CompilerOptions.java b/dev/core/src/com/google/gwt/dev/CompilerOptions.java
index 0b568e4..382eee8 100644
--- a/dev/core/src/com/google/gwt/dev/CompilerOptions.java
+++ b/dev/core/src/com/google/gwt/dev/CompilerOptions.java
@@ -21,5 +21,6 @@
 /**
  * The complete set of options for the GWT compiler.
  */
-public interface CompilerOptions extends PrecompileOptions, LinkOptions {
+public interface CompilerOptions extends PrecompileOptions, LinkOptions,
+    OptionLocalWorkers {
 }
diff --git a/dev/core/src/com/google/gwt/dev/ExternalPermutationWorkerFactory.java b/dev/core/src/com/google/gwt/dev/ExternalPermutationWorkerFactory.java
new file mode 100644
index 0000000..392afea
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/ExternalPermutationWorkerFactory.java
@@ -0,0 +1,376 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.dev;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.dev.jjs.UnifiedAst;
+import com.google.gwt.dev.util.Util;
+
+import java.io.BufferedReader;
+import java.io.EOFException;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.lang.management.ManagementFactory;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.net.SocketTimeoutException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+
+/**
+ * A PermutationWorkerFactory designed to launch instances of
+ * {@link CompilePermsServer}. The system property
+ * {@value #JAVA_COMMAND_PROPERTY} can be used to change the command used to
+ * launch the JVM. The system property {@link #JVM_ARGS_PROPERTY} can be used to
+ * override the JVM args passed to the subprocess.
+ */
+public class ExternalPermutationWorkerFactory extends PermutationWorkerFactory {
+
+  /**
+   * Allows accept() to be called a finite number of times on a ServerSocket
+   * before closing the socket.
+   */
+  private static class CountedServerSocket {
+    private int accepts;
+    private ServerSocket sock;
+
+    public CountedServerSocket(ServerSocket sock, int maxAccepts) {
+      assert sock != null;
+      assert maxAccepts >= 1;
+
+      this.accepts = maxAccepts;
+      this.sock = sock;
+    }
+
+    public synchronized Socket accept() throws IOException {
+      assert accepts >= 0;
+
+      if (accepts == 0) {
+        throw new IllegalStateException("Too many calls to accept()");
+      }
+
+      try {
+        return sock.accept();
+      } finally {
+        if (--accepts == 0) {
+          sock.close();
+          sock = null;
+        }
+      }
+    }
+  }
+
+  private static class ExternalPermutationWorker implements PermutationWorker {
+    private final File astFile;
+    private final Set<String> cookies;
+    private ObjectInputStream in;
+    private ObjectOutputStream out;
+    private final CountedServerSocket serverSocket;
+    private Socket workerSocket;
+
+    public ExternalPermutationWorker(CountedServerSocket sock, File astFile,
+        Set<String> cookies) {
+      this.astFile = astFile;
+      this.cookies = cookies;
+      this.serverSocket = sock;
+    }
+
+    public PermutationResult compile(TreeLogger logger, Permutation permutation)
+        throws TransientWorkerException, UnableToCompleteException {
+
+      // If we've just started, we need to get a connection from a subprocess
+      if (workerSocket == null) {
+        try {
+          /*
+           * We've set SO_TIMEOUT, so this may fail if the remote process never
+           * connects back.
+           */
+          workerSocket = serverSocket.accept();
+
+          in = new ObjectInputStream(workerSocket.getInputStream());
+          out = new ObjectOutputStream(workerSocket.getOutputStream());
+
+          // Verify we're talking to the right worker
+          String c = in.readUTF();
+          if (!cookies.contains(c)) {
+            throw new TransientWorkerException("Received unknown cookie " + c,
+                null);
+          }
+
+          out.writeObject(astFile);
+
+          // Get the remote worker's estimate of memory use
+          long memoryUse = in.readLong();
+          logger.log(TreeLogger.SPAM, "Remote process indicates " + memoryUse
+              + " bytes of memory used");
+
+        } catch (SocketTimeoutException e) {
+          throw new TransientWorkerException(
+              "Remote process did not connect within timeout period", e);
+        } catch (IOException e) {
+          throw new TransientWorkerException(
+              "Unable to communicate with worker", e);
+        }
+      }
+
+      try {
+        out.writeBoolean(true);
+        out.writeObject(permutation);
+        out.flush();
+        return (PermutationResult) in.readObject();
+      } catch (IOException e) {
+        logger.log(TreeLogger.WARN, "Lost communication with remote process", e);
+        throw new TransientWorkerException(
+            "Lost communication with remote process", e);
+      } catch (ClassNotFoundException e) {
+        logger.log(TreeLogger.ERROR, "Unable to receive response", e);
+        throw new UnableToCompleteException();
+      }
+    }
+
+    public String getName() {
+      return "External worker "
+          + (workerSocket != null ? workerSocket.getRemoteSocketAddress()
+              : "unconnected");
+    }
+
+    public void shutdown() {
+      if (out != null) {
+        try {
+          out.writeBoolean(false);
+          out.flush();
+          out.close();
+        } catch (IOException e) {
+          // Not much to do here
+        }
+      }
+
+      if (in != null) {
+        try {
+          in.close();
+        } catch (IOException e) {
+          // Not much to do here
+        }
+      }
+
+      if (workerSocket != null) {
+        try {
+          workerSocket.close();
+        } catch (IOException e) {
+          // Nothing to do
+        }
+      }
+    }
+  }
+
+  /**
+   * A system property that can be used to override the command used to invoke a
+   * JVM instance.
+   */
+  public static final String JAVA_COMMAND_PROPERTY = "gwt.jjs.javaCommand";
+
+  /**
+   * A system property that can be used to override the JVM args passed to the
+   * subprocess.
+   */
+  public static final String JVM_ARGS_PROPERTY = "gwt.jjs.javaArgs";
+
+  /**
+   * Launches an external worker and returns the cookie that worker should
+   * return via the network connection.
+   */
+  private static String launchExternalWorker(TreeLogger logger, int port)
+      throws UnableToCompleteException {
+
+    String javaCommand = System.getProperty(JAVA_COMMAND_PROPERTY,
+        System.getProperty("java.home") + File.separator + "bin"
+            + File.separator + "java");
+    logger.log(TreeLogger.TRACE, "javaCommand = " + javaCommand);
+
+    // Construct the arguments
+    List<String> args = new ArrayList<String>();
+    args.add(javaCommand);
+
+    // This will include -Xmx, -D, etc...
+    String userJvmArgs = System.getProperty(JVM_ARGS_PROPERTY);
+    if (userJvmArgs == null) {
+      args.addAll(ManagementFactory.getRuntimeMXBean().getInputArguments());
+    } else {
+      args.addAll(Arrays.asList(userJvmArgs.split(" ")));
+    }
+
+    // Determine the logLevel for the external program
+    TreeLogger.Type logLevel = TreeLogger.ERROR;
+    for (TreeLogger.Type t : TreeLogger.Type.values()) {
+      if (logger.isLoggable(t)) {
+        logLevel = t;
+      } else {
+        break;
+      }
+    }
+
+    byte[] cookieBytes = new byte[16];
+    (new Random()).nextBytes(cookieBytes);
+    String cookie = Util.toHexString(cookieBytes);
+
+    // Cook up the classpath, main class, and extra args
+    args.addAll(Arrays.asList("-classpath",
+        ManagementFactory.getRuntimeMXBean().getClassPath(),
+        CompilePermsServer.class.getName(), "-host", "localhost", "-port",
+        String.valueOf(port), "-logLevel", logLevel.toString(), "-cookie",
+        cookie));
+
+    // Filter undesirable arguments
+    for (Iterator<String> iter = args.iterator(); iter.hasNext();) {
+      String arg = iter.next();
+      if (arg.startsWith("-agentlib")) {
+        iter.remove();
+      }
+    }
+
+    ProcessBuilder builder = new ProcessBuilder();
+    builder.command(args);
+
+    try {
+      final Process proc = builder.start();
+      final BufferedReader bin = new BufferedReader(new InputStreamReader(
+          proc.getInputStream()));
+      final BufferedReader berr = new BufferedReader(new InputStreamReader(
+          proc.getErrorStream()));
+      final TreeLogger procLogger = logger.branch(TreeLogger.DEBUG,
+          "Process output");
+
+      // Threads to copy stdout, stderr to the logger
+      new Thread(new Runnable() {
+        public void run() {
+          while (true) {
+            try {
+              String line = bin.readLine();
+              if (line == null) {
+                break;
+              }
+              procLogger.log(TreeLogger.INFO, line);
+            } catch (EOFException e) {
+              // Ignore
+            } catch (IOException e) {
+              procLogger.log(TreeLogger.ERROR,
+                  "Unable to read from subprocess", e);
+            }
+          }
+        }
+      }).start();
+
+      new Thread(new Runnable() {
+        public void run() {
+          while (true) {
+            try {
+              String line = berr.readLine();
+              if (line == null) {
+                break;
+              }
+              procLogger.log(TreeLogger.ERROR, line);
+            } catch (EOFException e) {
+              // Ignore
+            } catch (IOException e) {
+              procLogger.log(TreeLogger.ERROR,
+                  "Unable to read from subprocess", e);
+            }
+          }
+        }
+      }).start();
+
+      // The child process should not outlive this JVM
+      Runtime.getRuntime().addShutdownHook(new Thread(new Runnable() {
+        public void run() {
+          try {
+            proc.exitValue();
+          } catch (IllegalThreadStateException e) {
+            proc.destroy();
+          }
+        }
+      }));
+
+      return cookie;
+    } catch (IOException e) {
+      logger.log(TreeLogger.ERROR, "Unable to start external process", e);
+      throw new UnableToCompleteException();
+    }
+  }
+
+  private ServerSocket sock;
+
+  @Override
+  public Collection<PermutationWorker> getWorkers(TreeLogger logger,
+      UnifiedAst unifiedAst, int numWorkers) throws UnableToCompleteException {
+    File astFile;
+    try {
+      astFile = File.createTempFile("externalPermutationWorkerFactory", ".ser");
+      astFile.deleteOnExit();
+      Util.writeObjectAsFile(logger, astFile, unifiedAst);
+    } catch (IOException e) {
+      logger.log(TreeLogger.ERROR, "Unable to create temporary file", e);
+      throw new UnableToCompleteException();
+    }
+
+    Set<String> cookies = Collections.synchronizedSet(new HashSet<String>(
+        numWorkers));
+    CountedServerSocket countedSock = new CountedServerSocket(sock, numWorkers);
+    List<PermutationWorker> toReturn = new ArrayList<PermutationWorker>(
+        numWorkers);
+
+    for (int i = 0; i < numWorkers; i++) {
+      String cookie = launchExternalWorker(logger, sock.getLocalPort());
+      cookies.add(cookie);
+      toReturn.add(new ExternalPermutationWorker(countedSock, astFile, cookies));
+    }
+
+    return toReturn;
+  }
+
+  @Override
+  public void init(TreeLogger logger) throws UnableToCompleteException {
+    try {
+      sock = new ServerSocket();
+      /*
+       * Have accept() wait no more than one minute for a connection. This
+       * prevents dead-head behavior.
+       */
+      sock.setSoTimeout(60000);
+      sock.bind(null);
+      logger.log(TreeLogger.SPAM, "Listening for external workers on port "
+          + sock.getLocalPort());
+    } catch (IOException e) {
+      logger.log(TreeLogger.ERROR, "Unable to create socket", e);
+      throw new UnableToCompleteException();
+    }
+  }
+
+  @Override
+  public boolean isLocal() {
+    return true;
+  }
+}
diff --git a/dev/core/src/com/google/gwt/dev/GWTCompiler.java b/dev/core/src/com/google/gwt/dev/GWTCompiler.java
index 3d7b06d..546e5ab 100644
--- a/dev/core/src/com/google/gwt/dev/GWTCompiler.java
+++ b/dev/core/src/com/google/gwt/dev/GWTCompiler.java
@@ -17,13 +17,15 @@
 
 import com.google.gwt.core.ext.TreeLogger;
 import com.google.gwt.core.ext.UnableToCompleteException;
-import com.google.gwt.dev.CompilePerms.CompilePermsOptionsImpl;
 import com.google.gwt.dev.CompileTaskRunner.CompileTask;
 import com.google.gwt.dev.Link.LinkOptionsImpl;
 import com.google.gwt.dev.Precompile.PrecompileOptionsImpl;
+import com.google.gwt.dev.cfg.ModuleDef;
+import com.google.gwt.dev.cfg.ModuleDefLoader;
 import com.google.gwt.dev.util.PerfLogger;
 import com.google.gwt.dev.util.Util;
 import com.google.gwt.dev.util.arg.ArgHandlerExtraDir;
+import com.google.gwt.dev.util.arg.ArgHandlerLocalWorkers;
 import com.google.gwt.dev.util.arg.ArgHandlerOutDir;
 import com.google.gwt.dev.util.arg.ArgHandlerWorkDirOptional;
 import com.google.gwt.util.tools.Utility;
@@ -44,6 +46,7 @@
       registerHandler(new ArgHandlerWorkDirOptional(options));
 
       registerHandler(new ArgHandlerExtraDir(options));
+      registerHandler(new ArgHandlerLocalWorkers(options));
       registerHandler(new ArgHandlerOutDir(options));
     }
 
@@ -57,6 +60,7 @@
       CompilerOptions {
 
     private LinkOptionsImpl linkOptions = new LinkOptionsImpl();
+    private int localWorkers;
 
     public GWTCompilerOptionsImpl() {
     }
@@ -68,12 +72,17 @@
     public void copyFrom(CompilerOptions other) {
       super.copyFrom(other);
       linkOptions.copyFrom(other);
+      localWorkers = other.getLocalWorkers();
     }
 
     public File getExtraDir() {
       return linkOptions.getExtraDir();
     }
 
+    public int getLocalWorkers() {
+      return localWorkers;
+    }
+
     public File getOutDir() {
       return linkOptions.getOutDir();
     }
@@ -82,6 +91,10 @@
       linkOptions.setExtraDir(extraDir);
     }
 
+    public void setLocalWorkers(int localWorkers) {
+      this.localWorkers = localWorkers;
+    }
+
     public void setOutDir(File outDir) {
       linkOptions.setOutDir(outDir);
     }
@@ -117,10 +130,15 @@
   }
 
   public boolean run(TreeLogger logger) throws UnableToCompleteException {
+    ModuleDef module = ModuleDefLoader.loadFromClassPath(logger,
+        options.getModuleName());
+
     if (options.isValidateOnly()) {
-      return new Precompile(options).run(logger);
+      return Precompile.validate(logger, options, module, options.getGenDir(),
+          options.getCompilerWorkDir());
     } else {
       PerfLogger.start("compile");
+      long compileStart = System.currentTimeMillis();
       logger = logger.branch(TreeLogger.INFO, "Compiling module "
           + options.getModuleName());
 
@@ -131,22 +149,24 @@
           tempWorkDir = true;
         }
 
-        if (new Precompile(options).run(logger)) {
-          /*
-           * TODO: use the in-memory result of Precompile to run CompilePerms
-           * instead of serializing through the file system.
-           */
-          CompilePermsOptionsImpl permsOptions = new CompilePermsOptionsImpl();
-          permsOptions.copyFrom(options);
-          if (new CompilePerms(permsOptions).run(logger)) {
-            if (new Link(options).run(logger)) {
-              logger.log(TreeLogger.INFO, "Compilation succeeded");
-              return true;
-            }
-          }
-        }
+        Precompilation precompilation = Precompile.precompile(logger, options,
+            module, options.getGenDir(), options.getCompilerWorkDir());
 
-        logger.log(TreeLogger.ERROR, "Compilation failed");
+        Permutation[] allPerms = precompilation.getPermutations();
+        File[] resultFiles = CompilePerms.makeResultFiles(
+            options.getCompilerWorkDir(), allPerms);
+        CompilePerms.compile(logger, precompilation, allPerms,
+            options.getLocalWorkers(), resultFiles);
+
+        Link.link(logger.branch(TreeLogger.INFO, "Linking into "
+            + options.getOutDir().getPath()), module, precompilation,
+            resultFiles, options.getOutDir(), options.getExtraDir());
+
+        long compileDone = System.currentTimeMillis();
+        long delta = compileDone - compileStart;
+        logger.log(TreeLogger.INFO, "Compilation succeeded -- "
+            + String.format("%.3f", delta / 1000d) + "s");
+        return true;
       } catch (IOException e) {
         logger.log(TreeLogger.ERROR,
             "Unable to create compiler work directory", e);
diff --git a/dev/core/src/com/google/gwt/dev/Link.java b/dev/core/src/com/google/gwt/dev/Link.java
index d476bbc..f10d910 100644
--- a/dev/core/src/com/google/gwt/dev/Link.java
+++ b/dev/core/src/com/google/gwt/dev/Link.java
@@ -100,20 +100,20 @@
   }
 
   public static ArtifactSet link(TreeLogger logger, ModuleDef module,
-      Precompilation precompilation, File[] jsFiles)
+      Precompilation precompilation, File[] resultFiles)
       throws UnableToCompleteException {
     StandardLinkerContext linkerContext = new StandardLinkerContext(logger,
         module, precompilation.getUnifiedAst().getOptions());
-    return doLink(logger, linkerContext, precompilation, jsFiles);
+    return doLink(logger, linkerContext, precompilation, resultFiles);
   }
 
   public static void link(TreeLogger logger, ModuleDef module,
-      Precompilation precompilation, File[] jsFiles, File outDir, File extrasDir)
-      throws UnableToCompleteException {
+      Precompilation precompilation, File[] resultFiles, File outDir,
+      File extrasDir) throws UnableToCompleteException {
     StandardLinkerContext linkerContext = new StandardLinkerContext(logger,
         module, precompilation.getUnifiedAst().getOptions());
     ArtifactSet artifacts = doLink(logger, linkerContext, precompilation,
-        jsFiles);
+        resultFiles);
     doProduceOutput(logger, artifacts, linkerContext, module, outDir, extrasDir);
   }
 
@@ -142,15 +142,15 @@
 
   private static ArtifactSet doLink(TreeLogger logger,
       StandardLinkerContext linkerContext, Precompilation precompilation,
-      File[] jsFiles) throws UnableToCompleteException {
+      File[] resultFiles) throws UnableToCompleteException {
     Permutation[] perms = precompilation.getPermutations();
-    if (perms.length != jsFiles.length) {
+    if (perms.length != resultFiles.length) {
       throw new IllegalArgumentException(
-          "Mismatched jsFiles.length and permutation count");
+          "Mismatched resultFiles.length and permutation count");
     }
 
     for (int i = 0; i < perms.length; ++i) {
-      finishPermuation(logger, perms[i], jsFiles[i], linkerContext);
+      finishPermuation(logger, perms[i], resultFiles[i], linkerContext);
     }
 
     linkerContext.addOrReplaceArtifacts(precompilation.getGeneratedArtifacts());
@@ -254,11 +254,11 @@
       return false;
     }
     Permutation[] perms = precompilation.getPermutations();
-    File[] jsFiles = new File[perms.length];
+    File[] resultFiles = new File[perms.length];
     for (int i = 0; i < perms.length; ++i) {
-      jsFiles[i] = CompilePerms.makePermFilename(options.getCompilerWorkDir(),
-          i);
-      if (!jsFiles[i].exists()) {
+      resultFiles[i] = CompilePerms.makePermFilename(
+          options.getCompilerWorkDir(), i);
+      if (!resultFiles[i].exists()) {
         logger.log(TreeLogger.ERROR, "File not found '"
             + precompilationFile.getAbsolutePath()
             + "'; please compile all permutations");
@@ -271,7 +271,7 @@
     StandardLinkerContext linkerContext = new StandardLinkerContext(branch,
         module, precompilation.getUnifiedAst().getOptions());
     ArtifactSet artifacts = doLink(branch, linkerContext, precompilation,
-        jsFiles);
+        resultFiles);
 
     doProduceOutput(branch, artifacts, linkerContext, module,
         options.getOutDir(), options.getExtraDir());
diff --git a/dev/core/src/com/google/gwt/dev/OptionLocalWorkers.java b/dev/core/src/com/google/gwt/dev/OptionLocalWorkers.java
new file mode 100644
index 0000000..e853888
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/OptionLocalWorkers.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.dev;
+
+/**
+ * Controls the number of local PermutationWorkers to be used.
+ */
+public interface OptionLocalWorkers {
+  /**
+   * Returns the number of workers to run on this machine.
+   */
+  int getLocalWorkers();
+
+  /**
+   * Sets the number of workers to run on this machine.
+   */
+  void setLocalWorkers(int localWorkers);
+}
diff --git a/dev/core/src/com/google/gwt/dev/Permutation.java b/dev/core/src/com/google/gwt/dev/Permutation.java
index 13ca881..3eba3f2 100644
--- a/dev/core/src/com/google/gwt/dev/Permutation.java
+++ b/dev/core/src/com/google/gwt/dev/Permutation.java
@@ -28,13 +28,19 @@
  * Represents the state of a single permutation for compile.
  */
 public final class Permutation implements Serializable {
+  private final int id;
   private final List<StaticPropertyOracle> propertyOracles = new ArrayList<StaticPropertyOracle>();
   private final SortedMap<String, String> rebindAnswers = new TreeMap<String, String>();
 
-  public Permutation(StaticPropertyOracle propertyOracle) {
+  public Permutation(int id, StaticPropertyOracle propertyOracle) {
+    this.id = id;
     this.propertyOracles.add(propertyOracle);
   }
 
+  public int getId() {
+    return id;
+  }
+
   public StaticPropertyOracle[] getPropertyOracles() {
     return propertyOracles.toArray(new StaticPropertyOracle[propertyOracles.size()]);
   }
diff --git a/dev/core/src/com/google/gwt/dev/PermutationResult.java b/dev/core/src/com/google/gwt/dev/PermutationResult.java
new file mode 100644
index 0000000..0b6f1bf
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/PermutationResult.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.dev;
+
+import java.io.Serializable;
+
+/**
+ * An extensible return type for the results of compiling a single permutation.
+ */
+public interface PermutationResult extends Serializable {
+  /**
+   * The compiled JavaScript code.
+   */
+  String[] getJs();
+}
diff --git a/dev/core/src/com/google/gwt/dev/PermutationWorker.java b/dev/core/src/com/google/gwt/dev/PermutationWorker.java
new file mode 100644
index 0000000..f24d35f
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/PermutationWorker.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.dev;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+
+/**
+ * Represents a facility that can compile an individual {@link Permutation}.
+ * Instances of PermutationWorker are expected to be created via
+ * {@link PermutationWorkerFactory#getWorkers(int)}.
+ */
+interface PermutationWorker {
+
+  /**
+   * Compile a single permutation. The {@link com.google.gwt.dev.jjs.UnifiedAst}
+   * will have been provided to {@link PermutationWorkerFactory#getWorkers}
+   * method.
+   * 
+   * @throws TransientWorkerException if the Permutation should be tried again
+   *           on another worker
+   * @throws UnableToCompleteException due to a fatal error
+   */
+  PermutationResult compile(TreeLogger logger, Permutation permutation)
+      throws TransientWorkerException, UnableToCompleteException;
+
+  /**
+   * Returns a human-readable description of the worker instance. This may be
+   * used for error reporting.
+   */
+  String getName();
+
+  /**
+   * Release any resources associated with the worker.
+   */
+  void shutdown();
+}
diff --git a/dev/core/src/com/google/gwt/dev/PermutationWorkerFactory.java b/dev/core/src/com/google/gwt/dev/PermutationWorkerFactory.java
new file mode 100644
index 0000000..4448c3d
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/PermutationWorkerFactory.java
@@ -0,0 +1,396 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.dev;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.dev.jjs.InternalCompilerException;
+import com.google.gwt.dev.jjs.UnifiedAst;
+import com.google.gwt.dev.util.Util;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+import java.util.concurrent.ArrayBlockingQueue;
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+/**
+ * Represents a factory for implementations of an endpoint that will invoke
+ * CompilePerms. Implementations of PermutationWorkerFactory should be
+ * default-instantiable and will have {@link #init} called immediately after
+ * construction.
+ */
+public abstract class PermutationWorkerFactory {
+
+  /**
+   * This callable is responsible for compiling one permutation. It waits for an
+   * available worker, uses it, and returns it to the pool when finished.
+   */
+  private static class CompileOnePermutation implements Callable<ResultStatus> {
+    private final BlockingQueue<PermutationWorker> availableWorkers;
+    private final TreeLogger logger;
+    private final Permutation permutation;
+    private final File resultFile;
+
+    public CompileOnePermutation(TreeLogger logger, Permutation permutation,
+        File resultFile, BlockingQueue<PermutationWorker> availableWorkers) {
+      this.logger = logger;
+      this.permutation = permutation;
+      this.resultFile = resultFile;
+      this.availableWorkers = availableWorkers;
+    }
+
+    public ResultStatus call() {
+      // Find a free worker
+      PermutationWorker worker;
+      try {
+        worker = availableWorkers.take();
+      } catch (InterruptedException e) {
+        logger.log(TreeLogger.DEBUG, "Worker interrupted", e);
+        return ResultStatus.HARD_FAILURE;
+      }
+
+      if (worker == noMoreWorkersWorker) {
+        // Shutting down
+        return ResultStatus.HARD_FAILURE;
+      }
+
+      // Invoke the worker
+      try {
+        PermutationResult result = worker.compile(logger, permutation);
+        Util.writeObjectAsFile(logger, resultFile, result);
+        logger.log(TreeLogger.DEBUG, "Successfully compiled permutation");
+        availableWorkers.add(worker);
+        return ResultStatus.SUCCESS;
+      } catch (TransientWorkerException e) {
+        logger.log(TreeLogger.DEBUG, "Worker died, will retry Permutation", e);
+        return ResultStatus.TRANSIENT_FAILURE;
+      } catch (UnableToCompleteException e) {
+        logger.log(TreeLogger.ERROR, "Unrecoverable exception, shutting down",
+            e);
+        return ResultStatus.HARD_FAILURE;
+      }
+    }
+  }
+
+  private static enum ResultStatus {
+    /**
+     * A failure bad enough to merit shutting down the compilation.
+     */
+    HARD_FAILURE,
+
+    /**
+     * A successful compile.
+     */
+    SUCCESS,
+
+    /**
+     * A worker died while processing this permutation, but it is worth trying
+     * to compile it with another worker.
+     */
+    TRANSIENT_FAILURE
+  };
+
+  /**
+   * The name of the system property used to define the workers.
+   */
+  public static final String FACTORY_IMPL_PROPERTY = "gwt.jjs.permutationWorkerFactory";
+
+  /**
+   * This value can be passed into {@link #setLocalWorkers(int)} to indicate
+   * that a heuristic should be used to determine the total number of local
+   * workers.
+   */
+  public static final int WORKERS_AUTO = 0;
+
+  private static List<PermutationWorkerFactory> lazyFactories;
+
+  private static final PermutationWorker noMoreWorkersWorker = new PermutationWorker() {
+
+    public PermutationResult compile(TreeLogger logger, Permutation permutation)
+        throws TransientWorkerException, UnableToCompleteException {
+      throw new UnableToCompleteException();
+    }
+
+    public String getName() {
+      return "Marker worker indicating no more workers";
+    }
+
+    public void shutdown() {
+    }
+  };
+
+  /**
+   * Compiles all Permutations in a Precompilation and returns an array of Files
+   * that can be consumed by Link using the system-default
+   * PermutationWorkersFactories.
+   */
+  public static void compilePermutations(TreeLogger logger,
+      Precompilation precompilation, int localWorkers, File[] resultFiles)
+      throws UnableToCompleteException {
+    compilePermutations(logger, precompilation,
+        precompilation.getPermutations(), localWorkers, resultFiles);
+  }
+
+  /**
+   * Compiles a subset of the Permutations in a Precompilation and returns an
+   * array of Files that can be consumed by Link using the system-default
+   * PermutationWorkersFactories.
+   * 
+   * @param localWorkers Set the maximum number of workers that should be
+   *          executed on the local system by the PermutationWorkerFactory. The
+   *          value {@link #WORKERS_AUTO} will allow the
+   *          PermutationWorkerFactory to apply a heuristic to determine the
+   *          correct number of local workers.
+   * @param resultFiles the output files to write into; must be the same length
+   *          as permutations
+   */
+  public static void compilePermutations(TreeLogger logger,
+      Precompilation precompilation, Permutation[] permutations,
+      int localWorkers, File[] resultFiles) throws UnableToCompleteException {
+    assert permutations.length == resultFiles.length;
+    assert Arrays.asList(precompilation.getPermutations()).containsAll(
+        Arrays.asList(permutations));
+
+    // We may have a mixed collection of workers from different factories
+    List<PermutationWorker> workers = new ArrayList<PermutationWorker>();
+
+    /*
+     * We can have errors below this point, there's a finally block to handle
+     * cleanup of workers.
+     */
+    try {
+      createWorkers(logger, precompilation.getUnifiedAst(),
+          permutations.length, localWorkers, workers);
+      ExecutorService executor = Executors.newFixedThreadPool(workers.size());
+
+      // List of available workers.
+      // The extra space is for inserting nulls at shutdown time
+      BlockingQueue<PermutationWorker> availableWorkers = new ArrayBlockingQueue<PermutationWorker>(
+          2 * workers.size());
+      availableWorkers.addAll(workers);
+
+      try {
+
+        // Submit all tasks to the executor
+
+        // The permutation compiles not yet finished
+        Queue<CompileOnePermutation> tasksOutstanding = new LinkedList<CompileOnePermutation>();
+
+        // The futures for the results of those compiles
+        Queue<Future<ResultStatus>> resultFutures = new LinkedList<Future<ResultStatus>>();
+
+        for (int i = 0; i < permutations.length; ++i) {
+          TreeLogger permLogger = logger.branch(TreeLogger.DEBUG,
+              "Worker permutation " + permutations[i].getId() + " of "
+                  + permutations.length);
+          CompileOnePermutation task = new CompileOnePermutation(permLogger,
+              permutations[i], resultFiles[i], availableWorkers);
+          tasksOutstanding.add(task);
+          resultFutures.add(executor.submit(task));
+        }
+
+        // Count the number of dead workers
+        int numDeadWorkers = 0;
+        int successCount = 0;
+
+        while (!resultFutures.isEmpty() && numDeadWorkers < workers.size()) {
+          assert resultFutures.size() == tasksOutstanding.size();
+
+          CompileOnePermutation task = tasksOutstanding.remove();
+          Future<ResultStatus> future = resultFutures.remove();
+          ResultStatus result;
+          try {
+            result = future.get();
+          } catch (InterruptedException e) {
+            logger.log(TreeLogger.ERROR,
+                "Exiting without results due to interruption", e);
+            throw new UnableToCompleteException();
+          } catch (ExecutionException e) {
+            logger.log(TreeLogger.ERROR, "A compilation failed", e);
+            throw new UnableToCompleteException();
+          }
+
+          if (result == ResultStatus.SUCCESS) {
+            ++successCount;
+          } else if (result == ResultStatus.TRANSIENT_FAILURE) {
+            // A worker died. Resubmit for the remaining workers.
+            ++numDeadWorkers;
+            tasksOutstanding.add(task);
+            resultFutures.add(executor.submit(task));
+          } else if (result == ResultStatus.HARD_FAILURE) {
+            // Shut down.
+            break;
+          } else {
+            throw new InternalCompilerException("Unknown result type");
+          }
+        }
+
+        // Too many permutations is a coding error
+        assert successCount <= permutations.length;
+
+        if (successCount < permutations.length) {
+          // Likely as not, all of the workers died
+          logger.log(TreeLogger.ERROR, "Not all permutation were compiled "
+              + successCount + " of " + permutations.length);
+          throw new UnableToCompleteException();
+        }
+      } finally {
+        // Shut down the executor
+        executor.shutdown();
+
+        // Inform any residual CompileOnePermutation's that there aren't any
+        // more workers
+        for (int i = 0; i < workers.size(); i++) {
+          availableWorkers.add(noMoreWorkersWorker);
+        }
+      }
+    } finally {
+      // Shut down all workers
+      for (PermutationWorker worker : workers) {
+        worker.shutdown();
+      }
+    }
+  }
+
+  /**
+   * Creates one or more implementations of worker factories. This will treat
+   * the value of the {@value #FACTORY_IMPL_PROPERTY} system property as a
+   * comma-separated list of type names.
+   */
+  private static synchronized List<PermutationWorkerFactory> createAll(
+      TreeLogger logger) throws UnableToCompleteException {
+    // NB: This is the much-derided FactoryFactory pattern
+
+    logger = logger.branch(TreeLogger.TRACE,
+        "Creating PermutationWorkerFactory instances");
+
+    if (lazyFactories != null) {
+      logger.log(TreeLogger.SPAM, "Using lazy instances");
+      return lazyFactories;
+    }
+
+    List<PermutationWorkerFactory> mutableFactories = new ArrayList<PermutationWorkerFactory>();
+    String classes = System.getProperty(FACTORY_IMPL_PROPERTY,
+        ThreadedPermutationWorkerFactory.class.getName() + ","
+            + ExternalPermutationWorkerFactory.class.getName());
+    logger.log(TreeLogger.SPAM, "Factory impl property is " + classes);
+
+    String[] classParts = classes.split(",");
+    for (String className : classParts) {
+      try {
+        Class<? extends PermutationWorkerFactory> clazz = Class.forName(
+            className).asSubclass(PermutationWorkerFactory.class);
+        PermutationWorkerFactory factory = clazz.newInstance();
+        factory.init(logger);
+        mutableFactories.add(factory);
+        logger.log(TreeLogger.SPAM, "Added PermutationWorkerFactory "
+            + clazz.getName());
+      } catch (ClassCastException e) {
+        logger.log(TreeLogger.ERROR, className + " is not a "
+            + PermutationWorkerFactory.class.getName());
+      } catch (ClassNotFoundException e) {
+        logger.log(TreeLogger.ERROR,
+            "Unable to find PermutationWorkerFactory named " + className);
+      } catch (InstantiationException e) {
+        logger.log(TreeLogger.ERROR,
+            "Unable to instantiate PermutationWorkerFactory " + className, e);
+      } catch (IllegalAccessException e) {
+        logger.log(TreeLogger.ERROR,
+            "Unable to instantiate PermutationWorkerFactory " + className, e);
+      }
+    }
+
+    if (mutableFactories.size() == 0) {
+      logger.log(TreeLogger.ERROR,
+          "No usable PermutationWorkerFactories available");
+      throw new UnableToCompleteException();
+    }
+
+    return lazyFactories = Collections.unmodifiableList(mutableFactories);
+  }
+
+  /**
+   * Create as many workers as possible to service the Permutations.
+   */
+  private static void createWorkers(TreeLogger logger, UnifiedAst unifiedAst,
+      int workersNeeded, int localWorkers, List<PermutationWorker> workers)
+      throws UnableToCompleteException {
+    if (localWorkers <= WORKERS_AUTO) {
+      // TODO: something smarter?
+      localWorkers = 1;
+    }
+
+    for (PermutationWorkerFactory factory : PermutationWorkerFactory.createAll(logger)) {
+      if (workersNeeded <= 0) {
+        break;
+      }
+
+      int wanted = factory.isLocal() ? Math.min(workersNeeded, localWorkers)
+          : workersNeeded;
+      if (wanted <= 0) {
+        continue;
+      }
+
+      Collection<PermutationWorker> newWorkers = factory.getWorkers(logger,
+          unifiedAst, wanted);
+
+      workers.addAll(newWorkers);
+      workersNeeded -= newWorkers.size();
+      if (factory.isLocal()) {
+        localWorkers -= newWorkers.size();
+      }
+    }
+
+    if (workers.size() == 0) {
+      logger.log(TreeLogger.ERROR, "No PermutationWorkers created");
+      throw new UnableToCompleteException();
+    }
+  }
+
+  /**
+   * Return some number of PermutationWorkers.
+   * 
+   * @param unifiedAst a UnifiedAst
+   * @param numWorkers the desired number of workers
+   * @return a collection of PermutationWorkers, the size of which may be less
+   *         than <code>numWorkers</code>
+   */
+  public abstract Collection<PermutationWorker> getWorkers(TreeLogger logger,
+      UnifiedAst unifiedAst, int numWorkers) throws UnableToCompleteException;
+
+  /**
+   * Initialize the PermutationWorkerFactory.
+   */
+  public abstract void init(TreeLogger logger) throws UnableToCompleteException;
+
+  /**
+   * Indicates if the PermutationWorkers created by the factory consume
+   * computational or memory resources on the local system, as opposed to the
+   * per-permutation work being performed on a remote system.
+   */
+  public abstract boolean isLocal();
+}
diff --git a/dev/core/src/com/google/gwt/dev/Precompile.java b/dev/core/src/com/google/gwt/dev/Precompile.java
index a7e8bf0..c5a4d82 100644
--- a/dev/core/src/com/google/gwt/dev/Precompile.java
+++ b/dev/core/src/com/google/gwt/dev/Precompile.java
@@ -171,7 +171,7 @@
         rebindOracles[i] = new StandardRebindOracle(compilationState,
             propertyOracles[i], module, rules, genDir, generatorResourcesDir,
             generatorArtifacts);
-        permutations[i] = new Permutation(propertyOracles[i]);
+        permutations[i] = new Permutation(i, propertyOracles[i]);
       }
     }
 
diff --git a/dev/core/src/com/google/gwt/dev/ThreadedPermutationWorkerFactory.java b/dev/core/src/com/google/gwt/dev/ThreadedPermutationWorkerFactory.java
new file mode 100644
index 0000000..89eebf0
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/ThreadedPermutationWorkerFactory.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.dev;
+
+import com.google.gwt.core.ext.TreeLogger;
+import com.google.gwt.core.ext.UnableToCompleteException;
+import com.google.gwt.dev.jjs.UnifiedAst;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Create a single in-process PermutationWorker. This WorkerFactory is intended
+ * to be used as a fall-back in case the other PermutationWorkers are unable to
+ * complete.
+ */
+public class ThreadedPermutationWorkerFactory extends PermutationWorkerFactory {
+
+  private static class ThreadedPermutationWorker implements PermutationWorker {
+    private final UnifiedAst ast;
+    private final int id;
+
+    public ThreadedPermutationWorker(UnifiedAst ast, int id) {
+      this.ast = ast;
+      this.id = id;
+    }
+
+    public PermutationResult compile(final TreeLogger logger,
+        final Permutation permutation) throws TransientWorkerException,
+        UnableToCompleteException {
+      try {
+        return CompilePerms.compile(logger, permutation, ast);
+      } catch (OutOfMemoryError e) {
+        logger.log(TreeLogger.ERROR,
+            "OutOfMemoryError: Increase heap size or lower "
+                + MAX_THREADS_PROPERTY);
+        throw new UnableToCompleteException();
+      }
+    }
+
+    public String getName() {
+      return "In-process PermutationWorker " + id;
+    }
+
+    public void shutdown() {
+      // No-op
+    }
+  }
+
+  /**
+   * A Java system property that can be used to change the number of in-process
+   * threads used.
+   */
+  public static final String MAX_THREADS_PROPERTY = "gwt.jjs.maxThreads";
+
+  @Override
+  public Collection<PermutationWorker> getWorkers(TreeLogger logger,
+      UnifiedAst unifiedAst, int numWorkers) throws UnableToCompleteException {
+    logger = logger.branch(TreeLogger.SPAM,
+        "Creating ThreadedPermutationWorkers");
+
+    numWorkers = Math.min(numWorkers, Integer.getInteger(MAX_THREADS_PROPERTY,
+        1));
+
+    if (numWorkers == 0) {
+      return Collections.emptyList();
+    }
+
+    // The worker will deserialize a new copy
+    List<PermutationWorker> toReturn = new ArrayList<PermutationWorker>(
+        numWorkers);
+    for (int i = 0; i < numWorkers; i++) {
+      toReturn.add(new ThreadedPermutationWorker(unifiedAst, i));
+    }
+    return toReturn;
+  }
+
+  @Override
+  public void init(TreeLogger logger) throws UnableToCompleteException {
+    logger = logger.branch(TreeLogger.SPAM,
+        "Initializing ThreadedPermutationWorkerFactory");
+  }
+
+  @Override
+  public boolean isLocal() {
+    return true;
+  }
+}
diff --git a/dev/core/src/com/google/gwt/dev/TransientWorkerException.java b/dev/core/src/com/google/gwt/dev/TransientWorkerException.java
new file mode 100644
index 0000000..5f4e2bc
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/TransientWorkerException.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.dev;
+
+/**
+ * Indicates that a PermutationWorker failed to complete its assignment, but
+ * that the permutation should be retried on another worker. This would be used
+ * to report errors such as OutOfMemory when compiling in-process or unexpected
+ * death of an out-of-process worker (network break, etc).
+ */
+public class TransientWorkerException extends Exception {
+  public TransientWorkerException(String msg, Throwable cause) {
+    super(msg, cause);
+  }
+}
diff --git a/dev/core/src/com/google/gwt/dev/jjs/UnifiedAst.java b/dev/core/src/com/google/gwt/dev/jjs/UnifiedAst.java
index 6dfc5fe..d0d2e6d 100644
--- a/dev/core/src/com/google/gwt/dev/jjs/UnifiedAst.java
+++ b/dev/core/src/com/google/gwt/dev/jjs/UnifiedAst.java
@@ -143,6 +143,18 @@
     return rebindRequests;
   }
 
+  /**
+   * Internally prepares a new AST for compilation if one is not already
+   * prepared.
+   */
+  public void prepare() {
+    synchronized (myLockObject) {
+      if (initialAst == null) {
+        initialAst = deserializeAst(serializedAst);
+      }
+    }
+  }
+
   AST getFreshAst() {
     synchronized (myLockObject) {
       if (initialAst != null) {
diff --git a/dev/core/src/com/google/gwt/dev/util/Util.java b/dev/core/src/com/google/gwt/dev/util/Util.java
index 31f6972..53e5f0c 100644
--- a/dev/core/src/com/google/gwt/dev/util/Util.java
+++ b/dev/core/src/com/google/gwt/dev/util/Util.java
@@ -311,8 +311,7 @@
   }
 
   /**
-   * Returns a String as a byte-array using the default encoding for the
-   * compiler.
+   * Returns a byte-array representing the default encoding for a String.
    */
   public static byte[] getBytes(String s) {
     try {
@@ -323,6 +322,10 @@
     }
   }
 
+  /**
+   * Returns an array of byte-arrays representing the default encoding for an
+   * array of Strings.
+   */
   public static byte[][] getBytes(String[] s) {
     byte[][] bytes = new byte[s.length][];
     for (int i = 0; i < s.length; i++) {
@@ -578,24 +581,24 @@
     logger.log(TreeLogger.INFO, "Unable to dump source to disk", caught);
   }
 
-  public static byte[][] readFileAndSplit(File file) {
-    RandomAccessFile f = null;
-    try {
-      f = new RandomAccessFile(file, "r");
-      int length = f.readInt();
-      byte[][] results = new byte[length][];
-      for (int i = 0; i < length; i++) {
-        int nextLength = f.readInt();
-        results[i] = new byte[nextLength];
-        f.read(results[i]);
-      }
-      return results;
-    } catch (IOException e) {
-      return null;
-    } finally {
-      Utility.close(f);
-    }
-  }
+  // public static byte[][] readFileAndSplit(File file) {
+  // RandomAccessFile f = null;
+  // try {
+  // f = new RandomAccessFile(file, "r");
+  // int length = f.readInt();
+  // byte[][] results = new byte[length][];
+  // for (int i = 0; i < length; i++) {
+  // int nextLength = f.readInt();
+  // results[i] = new byte[nextLength];
+  // f.read(results[i]);
+  // }
+  // return results;
+  // } catch (IOException e) {
+  // return null;
+  // } finally {
+  // Utility.close(f);
+  // }
+  // }
 
   public static byte[] readFileAsBytes(File file) {
     FileInputStream fileInputStream = null;
@@ -1155,30 +1158,31 @@
     }
   }
 
-  /**
-   * Write all of the supplied bytes to the file, in a way that they can be read
-   * back by {@link #readFileAndSplit(File).
-   */
-  public static boolean writeStringsAsFile(TreeLogger branch,
-      File makePermFilename, String[] js) {
-    RandomAccessFile f = null;
-    try {
-      makePermFilename.delete();
-      makePermFilename.getParentFile().mkdirs();
-      f = new RandomAccessFile(makePermFilename, "rwd");
-      f.writeInt(js.length);
-      for (String s : js) {
-        byte[] b = getBytes(s);
-        f.writeInt(b.length);
-        f.write(b);
-      }
-      return true;
-    } catch (IOException e) {
-      return false;
-    } finally {
-      Utility.close(f);
-    }
-  }
+  // /**
+  // * Write all of the supplied bytes to the file, in a way that they can be
+  // read
+  // * back by {@link #readFileAndSplit(File).
+  // */
+  // public static boolean writeStringsAsFile(TreeLogger branch,
+  // File makePermFilename, String[] js) {
+  // RandomAccessFile f = null;
+  // try {
+  // makePermFilename.delete();
+  // makePermFilename.getParentFile().mkdirs();
+  // f = new RandomAccessFile(makePermFilename, "rwd");
+  // f.writeInt(js.length);
+  // for (String s : js) {
+  // byte[] b = getBytes(s);
+  // f.writeInt(b.length);
+  // f.write(b);
+  // }
+  // return true;
+  // } catch (IOException e) {
+  // return false;
+  // } finally {
+  // Utility.close(f);
+  // }
+  // }
 
   /**
    * Reads the specified number of bytes from the {@link InputStream}.
diff --git a/dev/core/src/com/google/gwt/dev/util/arg/ArgHandlerLocalWorkers.java b/dev/core/src/com/google/gwt/dev/util/arg/ArgHandlerLocalWorkers.java
new file mode 100644
index 0000000..6800c83
--- /dev/null
+++ b/dev/core/src/com/google/gwt/dev/util/arg/ArgHandlerLocalWorkers.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.dev.util.arg;
+
+import com.google.gwt.dev.OptionLocalWorkers;
+import com.google.gwt.util.tools.ArgHandlerInt;
+
+/**
+ * An arg handler to specify the number of local workers that should be used by
+ * the compiler.
+ */
+public class ArgHandlerLocalWorkers extends ArgHandlerInt {
+
+  private final OptionLocalWorkers options;
+
+  public ArgHandlerLocalWorkers(OptionLocalWorkers options) {
+    this.options = options;
+  }
+
+  @Override
+  public String[] getDefaultArgs() {
+    // Default to 1 for now; we might do an "auto" later.
+    return new String[] {getTag(), "1"};
+  }
+
+  @Override
+  public String getPurpose() {
+    return "Specifies the number of local workers to use whe compiling permutations";
+  }
+
+  @Override
+  public String getTag() {
+    return "-localWorkers";
+  }
+
+  @Override
+  public String[] getTagArgs() {
+    return new String[] {"count"};
+  }
+
+  @Override
+  public void setInt(int value) {
+    options.setLocalWorkers(value);
+  }
+}
diff --git a/reference/dispatch/Dispatch.gwt.xml b/reference/dispatch/Dispatch.gwt.xml
new file mode 100644
index 0000000..fa1c708
--- /dev/null
+++ b/reference/dispatch/Dispatch.gwt.xml
@@ -0,0 +1,6 @@
+<!DOCTYPE document SYSTEM
+    "http://google-web-toolkit.googlecode.com/svn/releases/1.5/distro-source/core/src/gwt-module.dtd">
+<module>
+  <inherits name='com.google.gwt.user.User' />
+  <entry-point class='kellegous.client.Dispatch' />
+</module>
diff --git a/reference/dispatch/client/Dispatch.java b/reference/dispatch/client/Dispatch.java
new file mode 100644
index 0000000..cac6f18
--- /dev/null
+++ b/reference/dispatch/client/Dispatch.java
@@ -0,0 +1,143 @@
+package kellegous.client;
+
+import com.google.gwt.core.client.Duration;
+import com.google.gwt.core.client.EntryPoint;
+import com.google.gwt.core.client.GWT;
+import com.google.gwt.dom.client.DivElement;
+import com.google.gwt.dom.client.Document;
+import com.google.gwt.user.client.Command;
+import com.google.gwt.user.client.Event;
+import com.google.gwt.user.client.EventListener;
+
+public class Dispatch implements EntryPoint {
+  private static native Event createMockEvent() /*-{
+    return { type: "click" };
+  }-*/;
+
+  private static double[] runTrial(int numberOfObservers,
+      int numberOfIterations, int numberOfSamples) {
+    final double[] results = new double[numberOfSamples];
+    final EventListener subject = Subject.create(numberOfObservers);
+    final Event event = createMockEvent();
+    for (int j = 0; j < numberOfSamples; ++j) {
+      final Duration d = new Duration();
+      for (int i = 0; i < numberOfIterations; ++i) {
+        subject.onBrowserEvent(event);
+      }
+      results[j] = d.elapsedMillis();
+    }
+    return results;
+  }
+
+  private static native void schedule(Command command) /*-{
+    $wnd.setTimeout(function() {
+      command.@com.google.gwt.user.client.Command::execute()();
+    }, 0);
+  }-*/;
+
+  // t-distribution for p = 0.05 (used to compute 95% confidence intervals).
+  // This table is based at df = 2.
+  private final static double[] TDIST = new double[] {
+      4.3027, 3.1824, 2.7765, 2.5706, 2.4469, 2.3646, 2.3060, 2.2622, 2.2281,
+      2.2010, 2.1788, 2.1604, 2.1448, 2.1315, 2.1199, 2.1098, 2.1009, 2.0930,
+      2.0860, 2.0796, 2.0739, 2.0687, 2.0639, 2.0595, 2.0555, 2.0518, 2.0484,
+      2.0452, 2.0423, 2.0395, 2.0369, 2.0345, 2.0322, 2.0301, 2.0281, 2.0262,
+      2.0244, 2.0227, 2.0211, 2.0195, 2.0181, 2.0167, 2.0154, 2.0141, 2.0129,
+      2.0117, 2.0106, 2.0096, 2.0086, 2.0076, 2.0066, 2.0057, 2.0049, 2.0040,
+      2.0032, 2.0025, 2.0017, 2.0010, 2.0003, 1.9996, 1.9990, 1.9983, 1.9977,
+      1.9971, 1.9966, 1.9960, 1.9955, 1.9949, 1.9944, 1.9939, 1.9935, 1.9930,
+      1.9925, 1.9921, 1.9917, 1.9913, 1.9908, 1.9905, 1.9901, 1.9897, 1.9893,
+      1.9890, 1.9886, 1.9883, 1.9879, 1.9876, 1.9873, 1.9870, 1.9867, 1.9864,
+      1.9861, 1.9858, 1.9855, 1.9852, 1.9850, 1.9847, 1.9845, 1.9842, 1.9840};
+
+  private static double computeT(int df) {
+    return TDIST[df - 2];
+  }
+
+  private static double computeMean(double[] s) {
+    double sum = 0.0;
+    final int n = s.length;
+    for (int i = 0; i < n; ++i) {
+      sum += s[i];
+    }
+    return sum / n;
+  }
+
+  private static double computeStandardError(double[] data, double mean) {
+    final int n = data.length;
+    double sum = 0.0;
+    for (int i = 0; i < n; ++i) {
+      final double d = data[i] - mean;
+      sum += d * d;
+    }
+
+    return Math.sqrt(sum / n) / Math.sqrt(n);
+  }
+
+  private static class Stats {
+    private final double mean, upper, lower;
+
+    Stats(double[] data) {
+      mean = computeMean(data);
+      final double error = computeStandardError(data, mean);
+      final double t = computeT(data.length - 1);
+      upper = mean + t * error;
+      lower = mean - t * error;
+    }
+
+    @Override
+    public String toString() {
+      return mean + ", " + lower + ", " + upper;
+    }
+  }
+
+  public static class Runner {
+    private int n;
+    private final int max, numIterations, numSamples;
+    private Stats[] results;
+
+    Runner(int min, int max, int numIterations, int numSamples) {
+      n = min;
+      this.max = max;
+      this.numIterations = numIterations;
+      this.numSamples = numSamples;
+      results = new Stats[max - min + 1];
+    }
+
+    void finish() {
+      final Document document = Document.get();
+      final DivElement root = document.createDivElement();
+      document.getBody().appendChild(root);
+      for (int i = 0, n = results.length; i < n; ++i) {
+        final DivElement div = document.createDivElement();
+        root.appendChild(div);
+        div.setInnerText("" + results[i].toString());
+      }
+    }
+
+    void next() {
+      schedule(new Command() {
+        public void execute() {
+          final double[] results = runTrial(n, numIterations, numSamples);
+          Runner.this.results[n] = new Stats(results);
+          if (++n <= max) {
+            next();
+          } else {
+            finish();
+          }
+        }
+      });
+    }
+
+    void run() {
+      next();
+    }
+  }
+
+  public void onModuleLoad() {
+    // Don't run this in hosted mode.
+    if (GWT.isScript()) {
+      new Runner(0, 10, 10000, 20).run();
+    }
+  }
+}
diff --git a/reference/dispatch/client/Subject.java b/reference/dispatch/client/Subject.java
new file mode 100644
index 0000000..fc21bee
--- /dev/null
+++ b/reference/dispatch/client/Subject.java
@@ -0,0 +1,22 @@
+package kellegous.client;
+
+import com.google.gwt.user.client.EventListener;
+import com.google.gwt.user.client.ui.Button;
+import com.google.gwt.user.client.ui.ClickListener;
+import com.google.gwt.user.client.ui.Widget;
+
+public class Subject {
+  public static EventListener create(int numberOfObserver) {
+    final Button subject = new Button("a button");
+    for (int i = 0; i < numberOfObserver; ++i) {
+      subject.addClickListener(new ClickListener() {
+        private int count = 0;
+
+        public void onClick(Widget sender) {
+          count++;
+        }
+      });
+    }
+    return subject;
+  }
+}
diff --git a/reference/dispatch/public/Dispatch.html b/reference/dispatch/public/Dispatch.html
new file mode 100644
index 0000000..e87c244
--- /dev/null
+++ b/reference/dispatch/public/Dispatch.html
@@ -0,0 +1,10 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
+<html>
+  <head>
+    <meta http-equiv="content-type" content="text/html; charset=UTF-8">
+    <title>Dispatch5</title>
+    <script type="text/javascript" language="javascript" src="kellegous.Dispatch.nocache.js"></script>
+  </head>
+  <body>
+  </body>
+</html>
diff --git a/samples/showcase/src/com/google/gwt/sample/showcase/client/ContentWidget.java b/samples/showcase/src/com/google/gwt/sample/showcase/client/ContentWidget.java
index 9d656ad..a4378e3 100644
--- a/samples/showcase/src/com/google/gwt/sample/showcase/client/ContentWidget.java
+++ b/samples/showcase/src/com/google/gwt/sample/showcase/client/ContentWidget.java
@@ -28,9 +28,9 @@
 import com.google.gwt.user.client.DOM;
 import com.google.gwt.user.client.Window;
 import com.google.gwt.user.client.rpc.AsyncCallback;
-import com.google.gwt.user.client.ui.Composite;
 import com.google.gwt.user.client.ui.DeckPanel;
 import com.google.gwt.user.client.ui.HTML;
+import com.google.gwt.user.client.ui.LazyPanel;
 import com.google.gwt.user.client.ui.TabBar;
 import com.google.gwt.user.client.ui.VerticalPanel;
 import com.google.gwt.user.client.ui.Widget;
@@ -59,7 +59,7 @@
  * <li>.sc-ContentWidget-description { Applied to the description }</li>
  * </ul>
  */
-public abstract class ContentWidget extends Composite implements
+public abstract class ContentWidget extends LazyPanel implements
     SelectionHandler<Integer> {
   /**
    * The constants used in this Content Widget.
@@ -90,7 +90,7 @@
   /**
    * An instance of the constants.
    */
-  private CwConstants constants;
+  private final CwConstants constants;
 
   /**
    * The deck panel with the contents.
@@ -98,11 +98,6 @@
   private DeckPanel deckPanel = null;
 
   /**
-   * A boolean indicating whether or not this widget has been initialized.
-   */
-  private boolean initialized = false;
-
-  /**
    * A boolean indicating whether or not the RPC request for the source code has
    * been sent.
    */
@@ -131,13 +126,11 @@
   public ContentWidget(CwConstants constants) {
     this.constants = constants;
     tabBar = new TabBar();
-    deckPanel = new DeckPanel();
-    initWidget(deckPanel);
-    setStyleName(DEFAULT_STYLE_NAME);
   }
 
   /**
-   * Add an item to this content widget.
+   * Add an item to this content widget. Should not be called before
+   * {@link #onInitializeComplete} has been called.
    * 
    * @param w the widget to add
    * @param tabText the text to display in the tab
@@ -187,66 +180,8 @@
   }
 
   /**
-   * Initialize this widget by creating the elements that should be added to the
-   * page.
-   */
-  public final void initialize() {
-    if (initialized == false) {
-      initialized = true;
-
-      // Add a tab handler
-      tabBar.addSelectionHandler(this);
-
-      // Create a container for the main example
-      final VerticalPanel vPanel = new VerticalPanel();
-      add(vPanel, constants.contentWidgetExample());
-
-      // Add the name
-      HTML nameWidget = new HTML(getName());
-      nameWidget.setStyleName(DEFAULT_STYLE_NAME + "-name");
-      vPanel.add(nameWidget);
-
-      // Add the description
-      HTML descWidget = new HTML(getDescription());
-      descWidget.setStyleName(DEFAULT_STYLE_NAME + "-description");
-      vPanel.add(descWidget);
-
-      // Add source code tab
-      if (hasSource()) {
-        sourceWidget = new HTML();
-        add(sourceWidget, constants.contentWidgetSource());
-      } else {
-        sourceLoaded = true;
-      }
-
-      // Add style tab
-      if (hasStyle()) {
-        styleDefs = new HashMap<String, String>();
-        styleWidget = new HTML();
-        add(styleWidget, constants.contentWidgetStyle());
-      }
-
-      asyncOnInitialize(new AsyncCallback<Widget>() {
-
-        public void onFailure(Throwable caught) {
-          Window.alert("exception: " + caught);
-        }
-
-        public void onSuccess(Widget result) {
-          // Initialize the widget and add it to the page
-          Widget widget = result;
-          if (widget != null) {
-            vPanel.add(widget);
-          }
-          onInitializeComplete();
-        }
-      });
-    }
-  }
-
-  /**
-   * When the widget is first initialize, this method is called. If it returns a
-   * Widget, the widget will be added as the first tab. Return null to disable
+   * When the widget is first initialized, this method is called. If it returns
+   * a Widget, the widget will be added as the first tab. Return null to disable
    * the first tab.
    * 
    * @return the widget to add to the first tab
@@ -315,10 +250,69 @@
 
   protected abstract void asyncOnInitialize(final AsyncCallback<Widget> callback);
 
+  /**
+   * Initialize this widget by creating the elements that should be added to the
+   * page.
+   */
+  protected final Widget createWidget() {
+    deckPanel = new DeckPanel();
+
+    setStyleName(DEFAULT_STYLE_NAME);
+
+    // Add a tab handler
+    tabBar.addSelectionHandler(this);
+
+    // Create a container for the main example
+    final VerticalPanel vPanel = new VerticalPanel();
+    add(vPanel, constants.contentWidgetExample());
+
+    // Add the name
+    HTML nameWidget = new HTML(getName());
+    nameWidget.setStyleName(DEFAULT_STYLE_NAME + "-name");
+    vPanel.add(nameWidget);
+
+    // Add the description
+    HTML descWidget = new HTML(getDescription());
+    descWidget.setStyleName(DEFAULT_STYLE_NAME + "-description");
+    vPanel.add(descWidget);
+
+    // Add source code tab
+    if (hasSource()) {
+      sourceWidget = new HTML();
+      add(sourceWidget, constants.contentWidgetSource());
+    } else {
+      sourceLoaded = true;
+    }
+
+    // Add style tab
+    if (hasStyle()) {
+      styleDefs = new HashMap<String, String>();
+      styleWidget = new HTML();
+      add(styleWidget, constants.contentWidgetStyle());
+    }
+
+    asyncOnInitialize(new AsyncCallback<Widget>() {
+
+      public void onFailure(Throwable caught) {
+        Window.alert("exception: " + caught);
+      }
+
+      public void onSuccess(Widget result) {
+        // Initialize the showcase widget (if any) and add it to the page
+        Widget widget = result;
+        if (widget != null) {
+          vPanel.add(widget);
+        }
+        onInitializeComplete();
+      }
+    });
+
+    return deckPanel;
+  }
+
   @Override
   protected void onLoad() {
-    // Initialize this widget if we haven't already
-    initialize();
+    ensureWidget();
 
     // Select the first tab
     if (getTabBar().getTabCount() > 0) {
diff --git a/user/javadoc/com/google/gwt/examples/LazyPanelExample.java b/user/javadoc/com/google/gwt/examples/LazyPanelExample.java
new file mode 100644
index 0000000..6dead55
--- /dev/null
+++ b/user/javadoc/com/google/gwt/examples/LazyPanelExample.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.examples;
+
+import com.google.gwt.core.client.EntryPoint;
+import com.google.gwt.event.dom.client.ClickEvent;
+import com.google.gwt.event.dom.client.ClickHandler;
+import com.google.gwt.user.client.ui.Label;
+import com.google.gwt.user.client.ui.LazyPanel;
+import com.google.gwt.user.client.ui.PushButton;
+import com.google.gwt.user.client.ui.RootPanel;
+import com.google.gwt.user.client.ui.Widget;
+
+public class LazyPanelExample implements EntryPoint {
+
+  /**
+   * A friendly little LazyPanel.
+   */
+  static class HelloLazy extends LazyPanel {
+    @Override
+    protected Widget createWidget() {
+      return new Label("Well hello there!");
+    }
+  }
+
+  public void onModuleLoad() {
+    final Widget lazy = new HelloLazy(); 
+    lazy.setVisible(false);
+
+    PushButton b = new PushButton("Click me");    
+    b.addClickHandler(new ClickHandler() {
+      public void onClick(ClickEvent event) {
+        lazy.setVisible(true);
+      }
+    });
+    
+    RootPanel root = RootPanel.get();
+    root.add(b);
+    root.add(lazy);
+  }
+}
diff --git a/user/src/com/google/gwt/user/client/ui/DisclosurePanel.java b/user/src/com/google/gwt/user/client/ui/DisclosurePanel.java
index 12ee898..32e6be8 100644
--- a/user/src/com/google/gwt/user/client/ui/DisclosurePanel.java
+++ b/user/src/com/google/gwt/user/client/ui/DisclosurePanel.java
@@ -89,6 +89,10 @@
         run(ANIMATION_DURATION);
       } else {
         panel.contentWrapper.setVisible(panel.isOpen);
+        if (panel.isOpen) {
+          // Special treatment on the visible case to ensure LazyPanel works 
+          panel.getContent().setVisible(true);
+        }
       }
     }
 
@@ -107,7 +111,9 @@
       super.onStart();
       if (opening) {
         curPanel.contentWrapper.setVisible(true);
-      }
+        // Special treatment on the visible case to ensure LazyPanel works 
+        curPanel.getContent().setVisible(true);
+     }
     }
 
     @Override
diff --git a/user/src/com/google/gwt/user/client/ui/LazyPanel.java b/user/src/com/google/gwt/user/client/ui/LazyPanel.java
new file mode 100644
index 0000000..5aca1a2
--- /dev/null
+++ b/user/src/com/google/gwt/user/client/ui/LazyPanel.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package com.google.gwt.user.client.ui;
+
+/**
+ * Convenience class to help lazy loading. The bulk of a LazyPanel is not
+ * instantiated until {@link #setVisible}(true) or {@link #ensureWidget} is
+ * called.
+ * <p>
+ * <h3>Example</h3>
+ * {@example com.google.gwt.examples.LazyPanelExample}
+ */
+public abstract class LazyPanel extends SimplePanel {
+  
+  public LazyPanel() {
+  }
+
+  /**
+   * Create the widget contained within the {@link LazyPanel}.
+   * 
+   * @return the lazy widget
+   */
+  protected abstract Widget createWidget();
+
+  /**
+   * Ensures that the widget has been created by calling {@link #createWidget}
+   * if {@link #getWidget} returns <code>null</code>. Typically it is not
+   * necessary to call this directly, as it is called as a side effect of a
+   * <code>setVisible(true)</code> call.
+   */
+  public void ensureWidget() {
+    Widget widget = getWidget();
+    if (widget == null) {
+      widget = createWidget();
+      setWidget(widget);
+    }
+  }
+
+  @Override
+  /**
+   * Sets whether this object is visible. If <code>visible</code> is 
+   * <code>true</code>, creates the sole child widget if necessary by calling
+   * {@link #ensureWidget}.
+   * 
+   * @param visible <code>true</code> to show the object, <code>false</code>
+   * to hide it
+   */
+  public void setVisible(boolean visible) {
+    if (visible) {
+      ensureWidget();
+    }
+    super.setVisible(visible);
+  }
+}
diff --git a/user/src/com/google/gwt/user/client/ui/TabPanel.java b/user/src/com/google/gwt/user/client/ui/TabPanel.java
index e15f772..2203703 100644
--- a/user/src/com/google/gwt/user/client/ui/TabPanel.java
+++ b/user/src/com/google/gwt/user/client/ui/TabPanel.java
@@ -42,9 +42,12 @@
  * {@link com.google.gwt.user.client.ui.HasWidgets}.
  * </p>
  * 
- * <h3>CSS Style Rules</h3> <ul class='css'> <li>.gwt-TabPanel { the tab panel
- * itself }</li> <li>.gwt-TabPanelBottom { the bottom section of the tab panel
- * (the deck containing the widget) }</li> </ul>
+ * <h3>CSS Style Rules</h3> 
+ * <ul class='css'> 
+ * <li>.gwt-TabPanel { the tab panel itself }</li> 
+ * <li>.gwt-TabPanelBottom { the bottom section of the tab panel
+ * (the deck containing the widget) }</li> 
+ * </ul>
  * 
  * <p>
  * <h3>Example</h3>
diff --git a/user/test/com/google/gwt/user/UISuite.java b/user/test/com/google/gwt/user/UISuite.java
index 1452667..1f06f51 100644
--- a/user/test/com/google/gwt/user/UISuite.java
+++ b/user/test/com/google/gwt/user/UISuite.java
@@ -47,6 +47,7 @@
 import com.google.gwt.user.client.ui.HorizontalPanelTest;
 import com.google.gwt.user.client.ui.HyperlinkTest;
 import com.google.gwt.user.client.ui.ImageTest;
+import com.google.gwt.user.client.ui.LazyPanelTest;
 import com.google.gwt.user.client.ui.LinearPanelTest;
 import com.google.gwt.user.client.ui.ListBoxTest;
 import com.google.gwt.user.client.ui.MenuBarTest;
@@ -78,7 +79,7 @@
 import junit.framework.Test;
 
 /**
- * TODO: document me.
+ * Tests of the ui package.
  */
 public class UISuite {
   public static Test suite() {
@@ -120,6 +121,7 @@
     suite.addTestSuite(HyperlinkTest.class);
     suite.addTestSuite(ImageBundleGeneratorTest.class);
     suite.addTestSuite(ImageTest.class);
+    suite.addTestSuite(LazyPanelTest.class);
     suite.addTestSuite(LinearPanelTest.class);
     suite.addTestSuite(ListBoxTest.class);
     suite.addTestSuite(MenuBarTest.class);
diff --git a/user/test/com/google/gwt/user/client/ui/CompositeTest.java b/user/test/com/google/gwt/user/client/ui/CompositeTest.java
index b037981..37abcf8 100644
--- a/user/test/com/google/gwt/user/client/ui/CompositeTest.java
+++ b/user/test/com/google/gwt/user/client/ui/CompositeTest.java
@@ -44,6 +44,7 @@
     boolean domFocusFired;
     boolean domBlurFired;
 
+    @SuppressWarnings("deprecation")
     public EventTestComposite() {
       initWidget(tb);
       sinkEvents(Event.FOCUSEVENTS);
diff --git a/user/test/com/google/gwt/user/client/ui/LazyPanelTest.java b/user/test/com/google/gwt/user/client/ui/LazyPanelTest.java
new file mode 100644
index 0000000..dfd0e3c
--- /dev/null
+++ b/user/test/com/google/gwt/user/client/ui/LazyPanelTest.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright 2008 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+package com.google.gwt.user.client.ui;
+
+import com.google.gwt.junit.client.GWTTestCase;
+
+/**
+ * Tests {@link LazyPanel}.
+ */
+public class LazyPanelTest extends GWTTestCase {
+  private final static class MyLazyPanel extends LazyPanel {
+    final Widget widgetToCreate;
+    boolean createWasCalled;
+
+    public MyLazyPanel(Widget widgetToCreate) {
+      this.widgetToCreate = widgetToCreate;
+    }
+
+    @Override
+    protected Widget createWidget() {
+      createWasCalled = true;
+      return widgetToCreate;
+    }
+  }
+
+  @Override
+  public String getModuleName() {
+    return "com.google.gwt.user.User";
+  }
+
+  public void testSetVisible() {
+    Widget w = new Label();
+    MyLazyPanel p = new MyLazyPanel(w);
+    assertNull(p.getWidget());
+    assertNull(w.getParent());
+
+    RootPanel.get().add(p);
+    assertNull(w.getParent());
+
+    p.setVisible(true);
+    assertWidgetIsChildOf(w, p);
+    
+    p.createWasCalled = false;
+    p.setVisible(false);
+    assertFalse(p.createWasCalled);
+    
+    p.setVisible(true);
+    assertFalse("Should not call createWidget again", p.createWasCalled);
+  }
+
+  public void testEnsureWidget() {
+    Widget w = new Label();
+    MyLazyPanel p = new MyLazyPanel(w);
+    
+    p.ensureWidget();
+    assertWidgetIsChildOf(w, p);
+    assertEquals(w, p.getWidget());
+  }
+
+  private void assertWidgetIsChildOf(Widget w, Widget p) {
+    Widget parentCursor = w;
+    while (parentCursor != null && parentCursor != RootPanel.get()) {
+      parentCursor = parentCursor.getParent();
+      if (p.equals(parentCursor)) {
+        break;
+      }
+    }
+    assertEquals("Expect w to be child of p", p, parentCursor);
+  }
+  
+  public void testInDeckPanel() {
+    // There are separate paths for the first widget displayed 
+    // and for succeeding, so test both (see DeckPanel#showWidget)
+    
+    DeckPanel deck = new DeckPanel();
+
+    Widget w0 = new Label();
+    deck.insert(new MyLazyPanel(w0), 0);
+    assertNull(w0.getParent());
+
+    Widget w1 = new Label();
+    deck.insert(new MyLazyPanel(w1), 1);
+    assertNull(w0.getParent());
+    assertNull(w1.getParent());
+    
+    deck.showWidget(0);
+    assertWidgetIsChildOf(w0, deck);
+    assertNull(w1.getParent());
+
+    deck.showWidget(1);
+    assertWidgetIsChildOf(w1, deck);
+  }
+  
+  public void testInStackPanel() {
+    StackPanel stack = new StackPanel();
+    stack.add(new Label(), "Able");
+
+    Widget w = new Label();
+    stack.add(new MyLazyPanel(w), "Baker");
+    assertNull(w.getParent());
+    
+    stack.showStack(1);
+    assertWidgetIsChildOf(w, stack);
+  }
+  
+  public void testInDisclosurePanel() {
+    Widget w = new Label();
+    DisclosurePanel dp = new DisclosurePanel();
+
+    dp.add(new MyLazyPanel(w));
+    assertNull(w.getParent());
+    
+    dp.setOpen(true);
+    assertWidgetIsChildOf(w, dp);
+  }
+  
+  public void testInAnimatedDisclosurePanel() {
+    Widget w = new Label();
+    DisclosurePanel dp = new DisclosurePanel();
+    dp.setAnimationEnabled(true);
+
+    dp.add(new MyLazyPanel(w));
+    assertNull(w.getParent());
+    
+    dp.setOpen(true);
+    assertWidgetIsChildOf(w, dp);
+  }
+}