diff --git a/dev/core/src/com/google/gwt/dev/javac/CompiledClass.java b/dev/core/src/com/google/gwt/dev/javac/CompiledClass.java
index a0e0585..6779fed 100644
--- a/dev/core/src/com/google/gwt/dev/javac/CompiledClass.java
+++ b/dev/core/src/com/google/gwt/dev/javac/CompiledClass.java
@@ -19,57 +19,51 @@
 import com.google.gwt.dev.util.Name.InternalName;
 import com.google.gwt.dev.util.StringInterner;
 
-import org.eclipse.jdt.core.compiler.CharOperation;
-import org.eclipse.jdt.internal.compiler.ClassFile;
 import org.eclipse.jdt.internal.compiler.classfmt.ClassFileReader;
 import org.eclipse.jdt.internal.compiler.classfmt.ClassFormatException;
 import org.eclipse.jdt.internal.compiler.env.NameEnvironmentAnswer;
-import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding;
-import org.eclipse.jdt.internal.compiler.lookup.NestedTypeBinding;
-import org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding;
+
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import java.io.Serializable;
 
 /**
  * Encapsulates the state of a single compiled class file.
  */
-public final class CompiledClass {
+public final class CompiledClass implements Serializable {
 
   private static final DiskCache diskCache = new DiskCache();
 
+  private final CompiledClass enclosingClass;
+  private final String internalName;
+  private final boolean isLocal;
+  private CompilationUnit unit;
+  
   /**
-   * Returns <code>true</code> if this is a local type, or if this type is
-   * nested inside of any local type.
+   * A token to retrieve this object's bytes from the disk cache. byte code is
+   * placed in the cache when the object is deserialized.
    */
-  private static boolean isLocalType(SourceTypeBinding binding) {
-    SourceTypeBinding b = binding;
-    while (!b.isStatic()) {
-      if (b instanceof LocalTypeBinding) {
-        return true;
-      }
-      b = ((NestedTypeBinding) b).enclosingType;
-    }
-    return false;
-  }
-
-  protected final CompiledClass enclosingClass;
-  protected final String internalName;
-  protected final boolean isLocal;
-  protected CompilationUnit unit;
-
-  /**
-   * A token to retrieve this object's bytes from the disk cache.
-   */
-  private final long cacheToken;
-
+  private transient long cacheToken;
   private transient NameEnvironmentAnswer nameEnvironmentAnswer;
 
-  CompiledClass(ClassFile classFile, CompiledClass enclosingClass) {
+  /**
+   * Create a compiled class from raw class bytes.
+   * 
+   * @param classBytes - byte code for this class
+   * @param enclosingClass - outer class
+   * @param isLocal Is this class a local class? (See the JLS rev 2 section
+   *          14.3)
+   * @param internalName the internal binary name for this class. e.g. {@code
+   *          java/util/Map$Entry}. See
+   *          {@link "http://java.sun.com/docs/books/jvms/second_edition/html/ClassFile.doc.html#14757"}
+   */
+  CompiledClass(byte[] classBytes, CompiledClass enclosingClass,
+      boolean isLocal, String internalName) {
     this.enclosingClass = enclosingClass;
-    SourceTypeBinding binding = classFile.referenceBinding;
-    this.internalName = StringInterner.get().intern(
-        CharOperation.charToString(binding.constantPoolName()));
-    byte[] bytes = classFile.getBytes();
-    this.cacheToken = diskCache.writeByteArray(bytes);
-    this.isLocal = isLocalType(binding);
+    this.internalName = StringInterner.get().intern(internalName);
+    this.cacheToken = diskCache.writeByteArray(classBytes);
+    this.isLocal = isLocal;
   }
 
   /**
@@ -84,7 +78,8 @@
   }
 
   /**
-   * Returns the binary class name, e.g. {@code java/util/Map$Entry}.
+   * Returns the class internal binary name for this type, e.g. {@code
+   * java/util/Map$Entry}.
    */
   public String getInternalName() {
     return internalName;
@@ -138,4 +133,16 @@
     assert this.unit == null;
     this.unit = unit;
   }
+
+  private void readObject(ObjectInputStream inputStream)
+      throws ClassNotFoundException, IOException {
+    inputStream.defaultReadObject();
+    this.cacheToken = diskCache.transferFromStream(inputStream);
+  }
+
+  private void writeObject(ObjectOutputStream outputStream) throws IOException {
+    outputStream.defaultWriteObject();
+    byte[] byteCode = diskCache.readByteArray(cacheToken);
+    diskCache.transferToStream(cacheToken, outputStream);
+  }
 }
diff --git a/dev/core/src/com/google/gwt/dev/javac/JdtCompiler.java b/dev/core/src/com/google/gwt/dev/javac/JdtCompiler.java
index fb752ef..464f8b0 100644
--- a/dev/core/src/com/google/gwt/dev/javac/JdtCompiler.java
+++ b/dev/core/src/com/google/gwt/dev/javac/JdtCompiler.java
@@ -52,8 +52,10 @@
 import org.eclipse.jdt.internal.compiler.lookup.BlockScope;
 import org.eclipse.jdt.internal.compiler.lookup.ClassScope;
 import org.eclipse.jdt.internal.compiler.lookup.CompilationUnitScope;
+import org.eclipse.jdt.internal.compiler.lookup.LocalTypeBinding;
 import org.eclipse.jdt.internal.compiler.lookup.LookupEnvironment;
 import org.eclipse.jdt.internal.compiler.lookup.MethodScope;
+import org.eclipse.jdt.internal.compiler.lookup.NestedTypeBinding;
 import org.eclipse.jdt.internal.compiler.lookup.ReferenceBinding;
 import org.eclipse.jdt.internal.compiler.lookup.SourceTypeBinding;
 import org.eclipse.jdt.internal.compiler.lookup.UnresolvedReferenceBinding;
@@ -129,14 +131,6 @@
     }
   }
   /**
-   * Interface for processing units on the fly during compilation.
-   */
-  public interface UnitProcessor {
-    void process(CompilationUnitBuilder builder,
-        CompilationUnitDeclaration cud, List<CompiledClass> compiledClasses);
-  }
-
-  /**
    * Static cache of all the JRE package names.
    */
   public static class JreIndex {
@@ -181,6 +175,14 @@
   }
 
   /**
+   * Interface for processing units on the fly during compilation.
+   */
+  public interface UnitProcessor {
+    void process(CompilationUnitBuilder builder,
+        CompilationUnitDeclaration cud, List<CompiledClass> compiledClasses);
+  }
+
+  /**
    * Adapts a {@link CompilationUnit} for a JDT compile.
    */
   private static class Adapter implements ICompilationUnit {
@@ -261,7 +263,9 @@
         enclosingClass = results.get(enclosingClassFile);
         assert enclosingClass != null;
       }
-      CompiledClass result = new CompiledClass(classFile, enclosingClass);
+      String internalName = CharOperation.charToString(classFile.fileName());
+      CompiledClass result = new CompiledClass(classFile.getBytes(), 
+          enclosingClass, isLocalType(classFile), internalName);
       results.put(classFile, result);
     }
   }
@@ -357,7 +361,7 @@
       }
     }
   }
-
+  
   /**
    * Compiles the given set of units. The units will be internally modified to
    * reflect the results of compilation.
@@ -439,6 +443,21 @@
     return null;
   }
 
+  /**
+   * Returns <code>true</code> if this is a local type, or if this type is
+   * nested inside of any local type.
+   */
+  private static boolean isLocalType(ClassFile classFile) {
+    SourceTypeBinding b = classFile.referenceBinding;
+    while (!b.isStatic()) {
+      if (b instanceof LocalTypeBinding) {
+        return true;
+      }
+      b = ((NestedTypeBinding) b).enclosingType;
+    }
+    return false;
+  }
+
   private AdditionalTypeProviderDelegate additionalTypeProviderDelegate;
 
   /**
diff --git a/dev/core/test/com/google/gwt/dev/javac/CompiledClassTest.java b/dev/core/test/com/google/gwt/dev/javac/CompiledClassTest.java
new file mode 100644
index 0000000..8d78d85
--- /dev/null
+++ b/dev/core/test/com/google/gwt/dev/javac/CompiledClassTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2011 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.javac;
+
+import com.google.gwt.dev.util.Util;
+
+import junit.framework.TestCase;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+
+public class CompiledClassTest extends TestCase {
+  static byte[] dummyByteCode = {
+    (byte) 0xDE, (byte) 0xAD, (byte)0xBE, (byte)0xEF  
+  };
+  static final String DUMMY_NAME = "com.example.DeadBeef";
+  
+  public void testCompiledClassSerialization() throws Exception {
+    CompiledClass writeObject = new CompiledClass(dummyByteCode, null, false, DUMMY_NAME);
+    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+    Util.writeObjectToStream(outputStream, writeObject);
+    ByteArrayInputStream inputStream = new ByteArrayInputStream(outputStream.toByteArray());
+    CompiledClass readObject = Util.readStreamAsObject(inputStream, CompiledClass.class);
+    assertEquals(4, readObject.getBytes().length);
+    byte[] readBytes = readObject.getBytes();
+    for (int i = 0; i < 4 ; ++i) {
+      assertEquals(dummyByteCode[i], readBytes[i]);
+    }
+  }
+}