diff --git a/pom.xml b/pom.xml
index 63de7a6..f876c36 100644
--- a/pom.xml
+++ b/pom.xml
@@ -330,6 +330,13 @@
       <version>5.1.10</version>
       <scope>test</scope>
     </dependency>
+
+    <dependency>
+      <groupId>com.google.protobuf</groupId>
+      <artifactId>protobuf-java</artifactId>
+      <version>2.2.0</version>
+      <scope>provided</scope>
+    </dependency>
   </dependencies>
 
   <repositories>
diff --git a/src/main/java/com/google/gwtorm/jdbc/gen/GeneratedClassLoader.java b/src/main/java/com/google/gwtorm/jdbc/gen/GeneratedClassLoader.java
index 53643d3..d56d9e0 100644
--- a/src/main/java/com/google/gwtorm/jdbc/gen/GeneratedClassLoader.java
+++ b/src/main/java/com/google/gwtorm/jdbc/gen/GeneratedClassLoader.java
@@ -57,7 +57,8 @@
     super(parent);
   }
 
-  void defineClass(final String name, final byte[] code) throws OrmException {
+  public void defineClass(final String name, final byte[] code)
+      throws OrmException {
     if (debugCodeGen) {
       final File outClassFile =
           new File("generated_classes/" + name.replace('.', '/') + ".class");
diff --git a/src/main/java/com/google/gwtorm/protobuf/CodecFactory.java b/src/main/java/com/google/gwtorm/protobuf/CodecFactory.java
new file mode 100644
index 0000000..7db0f96
--- /dev/null
+++ b/src/main/java/com/google/gwtorm/protobuf/CodecFactory.java
@@ -0,0 +1,82 @@
+// Copyright 2009 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.gwtorm.protobuf;
+
+import com.google.gwtorm.client.Column;
+import com.google.gwtorm.client.OrmException;
+import com.google.gwtorm.jdbc.gen.GeneratedClassLoader;
+
+import java.util.Collections;
+import java.util.Map;
+import java.util.WeakHashMap;
+
+/** Creates {@link ProtobufCodec} implementations on demand. */
+public final class CodecFactory {
+  private static final Map<Class<?>, String> encoders =
+      Collections.synchronizedMap(new WeakHashMap<Class<?>, String>());
+
+  /**
+   * Create an implementation to encode/decode an arbitrary object.
+   * <p>
+   * The object must use the {@link Column} annotations to denote the fields
+   * that should be encoded or decoded.
+   *
+   * @param <T> type of the object to be supported.
+   * @param type the object type.
+   * @return an encoder for this object type.
+   * @throws IllegalArgumentException the object's fields aren't declared
+   *         properly. This is a programming error that cannot be recovered.
+   */
+  public static <T> ProtobufCodec<T> encoder(Class<T> type)
+      throws IllegalStateException {
+    final GeneratedClassLoader loader = newLoader(type);
+    ProtobufCodec<T> encoder = null;
+    String cacheName = encoders.get(type);
+    if (cacheName != null) {
+      encoder = get(loader, cacheName);
+    }
+    if (encoder == null) {
+      final CodecGen<T> gen = new CodecGen<T>(loader, type);
+      try {
+        encoder = gen.create();
+      } catch (OrmException e) {
+        throw new IllegalArgumentException("Class " + type.getName()
+            + " cannot be supported on protobuf", e);
+      }
+      encoders.put(type, encoder.getClass().getName());
+    }
+    return encoder;
+  }
+
+  private static <T> GeneratedClassLoader newLoader(final Class<T> type) {
+    return new GeneratedClassLoader(type.getClassLoader());
+  }
+
+  @SuppressWarnings("unchecked")
+  private static <T> ProtobufCodec<T> get(ClassLoader cl, String name) {
+    try {
+      return (ProtobufCodec<T>) Class.forName(name, true, cl).newInstance();
+    } catch (InstantiationException e) {
+      return null;
+    } catch (IllegalAccessException e) {
+      return null;
+    } catch (ClassNotFoundException e) {
+      return null;
+    }
+  }
+
+  private CodecFactory() {
+  }
+}
diff --git a/src/main/java/com/google/gwtorm/protobuf/CodecGen.java b/src/main/java/com/google/gwtorm/protobuf/CodecGen.java
new file mode 100644
index 0000000..6c79119
--- /dev/null
+++ b/src/main/java/com/google/gwtorm/protobuf/CodecGen.java
@@ -0,0 +1,744 @@
+// Copyright 2009 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.gwtorm.protobuf;
+
+import com.google.gwtorm.client.Column;
+import com.google.gwtorm.client.OrmException;
+import com.google.gwtorm.jdbc.gen.CodeGenSupport;
+import com.google.gwtorm.jdbc.gen.GeneratedClassLoader;
+import com.google.gwtorm.schema.ColumnModel;
+import com.google.gwtorm.schema.Util;
+import com.google.gwtorm.schema.java.JavaColumnModel;
+import com.google.protobuf.ByteString;
+import com.google.protobuf.CodedInputStream;
+import com.google.protobuf.CodedOutputStream;
+import com.google.protobuf.WireFormat;
+
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Label;
+import org.objectweb.asm.MethodVisitor;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+
+import java.io.OutputStream;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
+
+/** Generates {@link ProtobufCodec} implementations. */
+class CodecGen<T> implements Opcodes {
+  private static final Type string = Type.getType(String.class);
+  private static final Type byteStringOutput =
+      Type.getType(ByteString.Output.class);
+  private static final Type byteString = Type.getType(ByteString.class);
+  private static final Type object = Type.getType(Object.class);
+  private static final Type codedOutputStream =
+      Type.getType(CodedOutputStream.class);
+  private static final Type codedInputStream =
+      Type.getType(CodedInputStream.class);
+  private final GeneratedClassLoader classLoader;
+  private final Class<T> pojo;
+  private final Type pojoType;
+
+  private ClassWriter cw;
+  private JavaColumnModel[] myFields;
+  private String superTypeName;
+  private String implClassName;
+  private String implTypeName;
+
+  public CodecGen(final GeneratedClassLoader loader, final Class<T> t) {
+    classLoader = loader;
+    pojo = t;
+    pojoType = Type.getType(pojo);
+  }
+
+  public ProtobufCodec<T> create() throws OrmException {
+    myFields = scanFields(pojo);
+
+    init();
+    implementConstructor();
+    implementSizeof();
+    implementEncode();
+    implementDecode();
+    cw.visitEnd();
+    classLoader.defineClass(implClassName, cw.toByteArray());
+
+    try {
+      final Class<?> c = Class.forName(implClassName, true, classLoader);
+      return cast(c.newInstance());
+    } catch (InstantiationException e) {
+      throw new OrmException("Cannot create new encoder", e);
+    } catch (IllegalAccessException e) {
+      throw new OrmException("Cannot create new encoder", e);
+    } catch (ClassNotFoundException e) {
+      throw new OrmException("Cannot create new encoder", e);
+    }
+  }
+
+  private static JavaColumnModel[] scanFields(Class<?> in) throws OrmException {
+    final Collection<JavaColumnModel> col = new ArrayList<JavaColumnModel>();
+    while (in != null) {
+      for (final Field f : in.getDeclaredFields()) {
+        if (f.getAnnotation(Column.class) != null) {
+          col.add(new JavaColumnModel(f));
+        }
+      }
+      in = in.getSuperclass();
+    }
+    return sort(col);
+  }
+
+  private static JavaColumnModel[] sort(
+      final Collection<? extends ColumnModel> col) {
+    JavaColumnModel[] out = col.toArray(new JavaColumnModel[col.size()]);
+    Arrays.sort(out, new Comparator<JavaColumnModel>() {
+      @Override
+      public int compare(JavaColumnModel o1, JavaColumnModel o2) {
+        return o1.getColumnID() - o2.getColumnID();
+      }
+    });
+    return out;
+  }
+
+  @SuppressWarnings("unchecked")
+  private static <T> ProtobufCodec<T> cast(final Object c) {
+    return (ProtobufCodec<T>) c;
+  }
+
+  private void init() {
+    superTypeName = Type.getInternalName(ProtobufCodec.class);
+    implClassName = pojo.getName() + "_protobuf_" + Util.createRandomName();
+    implTypeName = implClassName.replace('.', '/');
+
+    cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+    cw.visit(V1_3, ACC_PUBLIC | ACC_FINAL | ACC_SUPER, implTypeName, null,
+        superTypeName, new String[] {});
+  }
+
+  private void implementConstructor() {
+    final String consName = "<init>";
+    final String consDesc =
+        Type.getMethodDescriptor(Type.VOID_TYPE, new Type[] {});
+    final MethodVisitor mv =
+        cw.visitMethod(ACC_PUBLIC, consName, consDesc, null, null);
+    mv.visitCode();
+
+    mv.visitVarInsn(ALOAD, 0);
+    mv.visitMethodInsn(INVOKESPECIAL, superTypeName, consName, consDesc);
+
+    mv.visitInsn(RETURN);
+    mv.visitMaxs(-1, -1);
+    mv.visitEnd();
+  }
+
+  private void implementSizeof() throws OrmException {
+    final MethodVisitor mv =
+        cw.visitMethod(ACC_PUBLIC, "sizeof", Type.getMethodDescriptor(
+            Type.INT_TYPE, new Type[] {object}), null, new String[] {});
+    mv.visitCode();
+    final SizeofCGS cgs = new SizeofCGS(mv);
+    cgs.setEntityType(pojoType);
+
+    mv.visitVarInsn(ALOAD, 1);
+    mv.visitTypeInsn(CHECKCAST, pojoType.getInternalName());
+    mv.visitVarInsn(ASTORE, 1);
+
+    cgs.push(0);
+    mv.visitVarInsn(ISTORE, cgs.sizeVar);
+    sizeofMessage(myFields, mv, cgs);
+
+    mv.visitVarInsn(ILOAD, cgs.sizeVar);
+    mv.visitInsn(IRETURN);
+    mv.visitMaxs(-1, -1);
+    mv.visitEnd();
+  }
+
+  private static void sizeofMessage(final JavaColumnModel[] myFields,
+      final MethodVisitor mv, final SizeofCGS cgs) throws OrmException {
+    for (final JavaColumnModel f : myFields) {
+      if (f.isNested()) {
+        final Label end = new Label();
+        cgs.setFieldReference(f);
+        cgs.pushFieldValue();
+        mv.visitJumpInsn(IFNULL, end);
+
+        final int oldVar = cgs.sizeVar;
+        final int msgVar = cgs.newLocal();
+        cgs.sizeVar = msgVar;
+        cgs.push(0);
+        mv.visitVarInsn(ISTORE, cgs.sizeVar);
+
+        sizeofMessage(sort(f.getNestedColumns()), mv, cgs);
+        cgs.sizeVar = oldVar;
+
+        cgs.push(f.getColumnID());
+        cgs.inc("computeTagSize", Type.INT_TYPE);
+
+        mv.visitVarInsn(ILOAD, msgVar);
+        cgs.inc("computeRawVarint32Size", Type.INT_TYPE);
+
+        mv.visitVarInsn(ILOAD, msgVar);
+        cgs.inc();
+
+        cgs.freeLocal(msgVar);
+        mv.visitLabel(end);
+      } else {
+        sizeofScalar(mv, cgs, f);
+      }
+    }
+  }
+
+  private static void sizeofScalar(final MethodVisitor mv, final SizeofCGS cgs,
+      final JavaColumnModel f) throws OrmException {
+    cgs.setFieldReference(f);
+
+    switch (Type.getType(f.getPrimitiveType()).getSort()) {
+      case Type.BOOLEAN:
+        cgs.push(f.getColumnID());
+        cgs.pushFieldValue();
+        cgs.inc("computeBoolSize", Type.INT_TYPE, Type.BOOLEAN_TYPE);
+        break;
+
+      case Type.CHAR:
+        cgs.push(f.getColumnID());
+        cgs.pushFieldValue();
+        cgs.inc("computeUInt32Size", Type.INT_TYPE, Type.INT_TYPE);
+        break;
+
+      case Type.BYTE:
+      case Type.SHORT:
+      case Type.INT:
+        cgs.push(f.getColumnID());
+        cgs.pushFieldValue();
+        cgs.inc("computeSInt32Size", Type.INT_TYPE, Type.INT_TYPE);
+        break;
+
+      case Type.FLOAT:
+        cgs.push(f.getColumnID());
+        cgs.pushFieldValue();
+        cgs.inc("computeFloatSize", Type.INT_TYPE, Type.FLOAT_TYPE);
+        break;
+
+      case Type.DOUBLE:
+        cgs.push(f.getColumnID());
+        cgs.pushFieldValue();
+        cgs.inc("computeDoubleSize", Type.INT_TYPE, Type.DOUBLE_TYPE);
+        break;
+
+      case Type.LONG:
+        cgs.push(f.getColumnID());
+        cgs.pushFieldValue();
+        cgs.inc("computeSInt64", Type.INT_TYPE, Type.LONG_TYPE);
+        break;
+
+      case Type.ARRAY:
+      case Type.OBJECT: {
+        final Label end = new Label();
+        cgs.pushFieldValue();
+        mv.visitJumpInsn(IFNULL, end);
+
+        if (f.getPrimitiveType() == byte[].class) {
+          cgs.push(f.getColumnID());
+          cgs.inc("computeTagSize", Type.INT_TYPE);
+
+          cgs.pushFieldValue();
+          mv.visitInsn(ARRAYLENGTH);
+          cgs.inc("computeRawVarint32Size", Type.INT_TYPE);
+
+          cgs.pushFieldValue();
+          mv.visitInsn(ARRAYLENGTH);
+          cgs.inc();
+
+        } else if (f.getPrimitiveType() == String.class) {
+          cgs.push(f.getColumnID());
+          cgs.pushFieldValue();
+          cgs.inc("computeStringSize", Type.INT_TYPE, string);
+
+        } else if (f.getPrimitiveType() == java.sql.Timestamp.class
+            || f.getPrimitiveType() == java.util.Date.class
+            || f.getPrimitiveType() == java.sql.Date.class) {
+          cgs.push(f.getColumnID());
+          String tsType = Type.getType(f.getPrimitiveType()).getInternalName();
+          mv.visitMethodInsn(INVOKEVIRTUAL, tsType, "getTime", Type
+              .getMethodDescriptor(Type.LONG_TYPE, new Type[] {}));
+          cgs.inc("computeFixed64Size", Type.INT_TYPE, Type.LONG_TYPE);
+
+        } else {
+          throw new OrmException("Type " + f.getPrimitiveType()
+              + " not supported for field " + f.getPathToFieldName());
+        }
+        mv.visitLabel(end);
+        break;
+      }
+
+      default:
+        throw new OrmException("Type " + f.getPrimitiveType()
+            + " not supported for field " + f.getPathToFieldName());
+    }
+  }
+
+  private void implementEncode() throws OrmException {
+    final MethodVisitor mv =
+        cw.visitMethod(ACC_PUBLIC, "encode", Type.getMethodDescriptor(
+            byteString, new Type[] {object}), null, new String[] {});
+    mv.visitCode();
+    final EncodeCGS cgs = new EncodeCGS(mv);
+    cgs.setEntityType(pojoType);
+
+    mv.visitVarInsn(ALOAD, 1);
+    mv.visitTypeInsn(CHECKCAST, pojoType.getInternalName());
+    mv.visitVarInsn(ASTORE, 1);
+
+    encodeMessage(myFields, mv, cgs);
+
+    mv.visitInsn(ARETURN);
+    mv.visitMaxs(-1, -1);
+    mv.visitEnd();
+  }
+
+  private static void encodeMessage(final JavaColumnModel[] myFields,
+      final MethodVisitor mv, final EncodeCGS cgs) throws OrmException {
+    final int oldVar = cgs.codedOutputStreamVar;
+    cgs.codedOutputStreamVar = cgs.newLocal();
+
+    final int strVar = cgs.newLocal();
+    mv.visitMethodInsn(INVOKESTATIC, byteString.getInternalName(), "newOutput",
+        Type.getMethodDescriptor(byteStringOutput, new Type[] {}));
+    mv.visitVarInsn(ASTORE, strVar);
+
+    mv.visitVarInsn(ALOAD, strVar);
+    mv.visitMethodInsn(INVOKESTATIC, codedOutputStream.getInternalName(),
+        "newInstance", Type.getMethodDescriptor(codedOutputStream,
+            new Type[] {Type.getType(OutputStream.class)}));
+    mv.visitVarInsn(ASTORE, cgs.codedOutputStreamVar);
+
+    for (final JavaColumnModel f : myFields) {
+      if (f.isNested()) {
+        final Label end = new Label();
+        cgs.setFieldReference(f);
+        cgs.pushFieldValue();
+        mv.visitJumpInsn(IFNULL, end);
+
+        final int v = cgs.newLocal();
+        encodeMessage(sort(f.getNestedColumns()), mv, cgs);
+        mv.visitVarInsn(ASTORE, v);
+
+        mv.visitVarInsn(ALOAD, v);
+        mv.visitMethodInsn(INVOKEVIRTUAL, byteString.getInternalName(), "size",
+            Type.getMethodDescriptor(Type.INT_TYPE, new Type[] {}));
+        mv.visitJumpInsn(IFEQ, end);
+
+        cgs.pushCodedOutputStream();
+        cgs.push(f.getColumnID());
+        mv.visitVarInsn(ALOAD, v);
+        cgs.write("writeBytes", byteString);
+
+        cgs.freeLocal(v);
+        mv.visitLabel(end);
+      } else {
+        encodeScalar(mv, cgs, f);
+      }
+    }
+
+    cgs.pushCodedOutputStream();
+    mv.visitMethodInsn(INVOKEVIRTUAL, codedOutputStream.getInternalName(),
+        "flush", Type.getMethodDescriptor(Type.VOID_TYPE, new Type[] {}));
+
+    cgs.freeLocal(cgs.codedOutputStreamVar);
+    cgs.codedOutputStreamVar = oldVar;
+
+    mv.visitVarInsn(ALOAD, strVar);
+    mv.visitMethodInsn(INVOKEVIRTUAL, byteStringOutput.getInternalName(),
+        "toByteString", Type.getMethodDescriptor(byteString, new Type[] {}));
+    cgs.freeLocal(strVar);
+  }
+
+  private static void encodeScalar(final MethodVisitor mv, final EncodeCGS cgs,
+      final JavaColumnModel f) throws OrmException {
+    cgs.setFieldReference(f);
+
+    switch (Type.getType(f.getPrimitiveType()).getSort()) {
+      case Type.BOOLEAN:
+        cgs.pushCodedOutputStream();
+        cgs.push(f.getColumnID());
+        cgs.pushFieldValue();
+        cgs.write("writeBool", Type.BOOLEAN_TYPE);
+        break;
+
+      case Type.CHAR:
+        cgs.pushCodedOutputStream();
+        cgs.push(f.getColumnID());
+        cgs.pushFieldValue();
+        cgs.write("writeUInt32", Type.INT_TYPE);
+        break;
+
+      case Type.BYTE:
+      case Type.SHORT:
+      case Type.INT:
+        cgs.pushCodedOutputStream();
+        cgs.push(f.getColumnID());
+        cgs.pushFieldValue();
+        cgs.write("writeSInt32", Type.INT_TYPE);
+        break;
+
+      case Type.FLOAT:
+        cgs.pushCodedOutputStream();
+        cgs.push(f.getColumnID());
+        cgs.pushFieldValue();
+        cgs.write("writeFloat", Type.FLOAT_TYPE);
+        break;
+
+      case Type.DOUBLE:
+        cgs.pushCodedOutputStream();
+        cgs.push(f.getColumnID());
+        cgs.pushFieldValue();
+        cgs.write("writeDouble", Type.DOUBLE_TYPE);
+        break;
+
+      case Type.LONG:
+        cgs.pushCodedOutputStream();
+        cgs.push(f.getColumnID());
+        cgs.pushFieldValue();
+        cgs.write("writeSInt64", Type.LONG_TYPE);
+        break;
+
+      case Type.ARRAY:
+      case Type.OBJECT: {
+        final Label end = new Label();
+        cgs.pushFieldValue();
+        mv.visitJumpInsn(IFNULL, end);
+
+        if (f.getPrimitiveType() == byte[].class) {
+          cgs.pushCodedOutputStream();
+          cgs.push(f.getColumnID());
+          cgs.push(WireFormat.FieldType.BYTES.getWireType());
+          mv.visitMethodInsn(INVOKEVIRTUAL,
+              codedOutputStream.getInternalName(), "writeTag", Type
+                  .getMethodDescriptor(Type.VOID_TYPE, new Type[] {
+                      Type.INT_TYPE, Type.INT_TYPE}));
+
+          cgs.pushCodedOutputStream();
+          cgs.pushFieldValue();
+          mv.visitInsn(ARRAYLENGTH);
+          mv.visitMethodInsn(INVOKEVIRTUAL,
+              codedOutputStream.getInternalName(), "writeRawVarint32", Type
+                  .getMethodDescriptor(Type.VOID_TYPE,
+                      new Type[] {Type.INT_TYPE}));
+
+          cgs.pushCodedOutputStream();
+          cgs.pushFieldValue();
+          mv.visitMethodInsn(INVOKEVIRTUAL,
+              codedOutputStream.getInternalName(), "writeRawBytes", Type
+                  .getMethodDescriptor(Type.VOID_TYPE, new Type[] {Type
+                      .getType(byte[].class)}));
+
+        } else {
+          cgs.pushCodedOutputStream();
+          cgs.push(f.getColumnID());
+          cgs.pushFieldValue();
+
+          if (f.getPrimitiveType() == String.class) {
+            cgs.write("writeString", string);
+
+          } else if (f.getPrimitiveType() == java.sql.Timestamp.class
+              || f.getPrimitiveType() == java.util.Date.class
+              || f.getPrimitiveType() == java.sql.Date.class) {
+            String tsType =
+                Type.getType(f.getPrimitiveType()).getInternalName();
+            mv.visitMethodInsn(INVOKEVIRTUAL, tsType, "getTime", Type
+                .getMethodDescriptor(Type.LONG_TYPE, new Type[] {}));
+            cgs.write("writeFixed64", Type.LONG_TYPE);
+
+          } else {
+            throw new OrmException("Type " + f.getPrimitiveType()
+                + " not supported for field " + f.getPathToFieldName());
+          }
+        }
+        mv.visitLabel(end);
+        break;
+      }
+
+      default:
+        throw new OrmException("Type " + f.getPrimitiveType()
+            + " not supported for field " + f.getPathToFieldName());
+    }
+  }
+
+  private void implementDecode() throws OrmException {
+    final Type retType = object;
+    final MethodVisitor mv =
+        cw.visitMethod(ACC_PROTECTED, "decode", Type.getMethodDescriptor(
+            retType, new Type[] {codedInputStream}), null, new String[] {});
+    mv.visitCode();
+    final DecodeCGS cgs = new DecodeCGS(mv);
+
+    cgs.setEntityType(pojoType);
+
+    mv.visitTypeInsn(NEW, pojoType.getInternalName());
+    mv.visitInsn(DUP);
+    mv.visitMethodInsn(INVOKESPECIAL, pojoType.getInternalName(), "<init>",
+        Type.getMethodDescriptor(Type.VOID_TYPE, new Type[] {}));
+    mv.visitVarInsn(ASTORE, cgs.objVar);
+
+    final int tagVar = cgs.newLocal();
+    decodeMessage(myFields, mv, cgs);
+
+    cgs.pushEntity();
+    mv.visitInsn(ARETURN);
+    mv.visitMaxs(-1, -1);
+    mv.visitEnd();
+  }
+
+  private static void decodeMessage(final JavaColumnModel[] myFields,
+      final MethodVisitor mv, final DecodeCGS cgs) throws OrmException {
+    final Label nextField = new Label();
+    final Label end = new Label();
+    mv.visitLabel(nextField);
+
+    // while (!ci.isAtEnd) { ...
+    cgs.call("readTag", Type.INT_TYPE);
+    mv.visitInsn(DUP);
+    mv.visitVarInsn(ISTORE, cgs.tagVar);
+
+    cgs.push(3);
+    mv.visitInsn(IUSHR);
+
+    final Label badField = new Label();
+    final int[] caseTags = new int[1 + myFields.length];
+    final Label[] caseLabels = new Label[caseTags.length];
+
+    caseTags[0] = 0;
+    caseLabels[0] = new Label();
+
+    int gaps = 0;
+    for (int i = 1; i < caseTags.length; i++) {
+      caseTags[i] = myFields[i - 1].getColumnID();
+      caseLabels[i] = new Label();
+      gaps += caseTags[i] - (caseTags[i - 1] + 1);
+    }
+
+    if (2 * gaps / 3 <= myFields.length) {
+      final int min = 0;
+      final int max = caseTags[caseTags.length - 1];
+      final Label[] table = new Label[max + 1];
+      Arrays.fill(table, badField);
+      for (int idx = 0; idx < caseTags.length; idx++) {
+        table[caseTags[idx]] = caseLabels[idx];
+      }
+      mv.visitTableSwitchInsn(min, max, badField, table);
+    } else {
+      mv.visitLookupSwitchInsn(badField, caseTags, caseLabels);
+    }
+
+    mv.visitLabel(caseLabels[0]);
+    mv.visitJumpInsn(GOTO, end);
+
+    for (int idx = 1; idx < caseTags.length; idx++) {
+      final JavaColumnModel f = myFields[idx - 1];
+      mv.visitLabel(caseLabels[idx]);
+      if (f.isNested()) {
+        final Label load = new Label();
+        cgs.setFieldReference(f);
+        cgs.pushFieldValue();
+        mv.visitJumpInsn(IFNONNULL, load);
+        cgs.fieldSetBegin();
+        mv.visitTypeInsn(NEW, Type.getType(f.getNestedClass())
+            .getInternalName());
+        mv.visitInsn(DUP);
+        mv.visitMethodInsn(INVOKESPECIAL, Type.getType(f.getNestedClass())
+            .getInternalName(), "<init>", Type.getMethodDescriptor(
+            Type.VOID_TYPE, new Type[] {}));
+        cgs.fieldSetEnd();
+
+        // read the length, set a new limit, decode the message, validate
+        // we stopped at the end of it as expected.
+        //
+        mv.visitLabel(load);
+        final int limitVar = cgs.newLocal();
+        cgs.pushCodedInputStream();
+        cgs.call("readRawVarint32", Type.INT_TYPE);
+        cgs.ncallInt("pushLimit", Type.INT_TYPE);
+        mv.visitVarInsn(ISTORE, limitVar);
+
+        decodeMessage(sort(f.getNestedColumns()), mv, cgs);
+
+        cgs.pushCodedInputStream();
+        mv.visitVarInsn(ILOAD, limitVar);
+        cgs.ncallInt("popLimit", Type.VOID_TYPE);
+        cgs.freeLocal(limitVar);
+
+      } else {
+        decodeScalar(mv, cgs, f);
+      }
+      mv.visitJumpInsn(GOTO, nextField);
+    }
+
+    // default:
+    mv.visitLabel(badField);
+    cgs.pushCodedInputStream();
+    mv.visitVarInsn(ILOAD, cgs.tagVar);
+    cgs.ncallInt("skipField", Type.BOOLEAN_TYPE);
+    mv.visitInsn(POP);
+    mv.visitJumpInsn(GOTO, nextField);
+
+    mv.visitLabel(end);
+    cgs.pushCodedInputStream();
+    cgs.push(0);
+    cgs.ncallInt("checkLastTagWas", Type.VOID_TYPE);
+  }
+
+  private static void decodeScalar(final MethodVisitor mv, final DecodeCGS cgs,
+      final JavaColumnModel f) throws OrmException {
+    cgs.setFieldReference(f);
+    cgs.fieldSetBegin();
+    switch (Type.getType(f.getPrimitiveType()).getSort()) {
+      case Type.BOOLEAN:
+        cgs.call("readBool", Type.BOOLEAN_TYPE);
+        break;
+
+      case Type.CHAR:
+        cgs.call("readUInt32", Type.INT_TYPE);
+        break;
+
+      case Type.BYTE:
+      case Type.SHORT:
+      case Type.INT:
+        cgs.call("readSInt32", Type.INT_TYPE);
+        break;
+
+      case Type.FLOAT:
+        cgs.call("readFloat", Type.FLOAT_TYPE);
+        break;
+
+      case Type.DOUBLE:
+        cgs.call("readDouble", Type.DOUBLE_TYPE);
+        break;
+
+      case Type.LONG:
+        cgs.call("readSInt64", Type.LONG_TYPE);
+        break;
+
+      default:
+        if (f.getPrimitiveType() == byte[].class) {
+          cgs.call("readBytes", byteString);
+          mv.visitMethodInsn(INVOKEVIRTUAL, byteString.getInternalName(),
+              "toByteArray", Type.getMethodDescriptor(Type
+                  .getType(byte[].class), new Type[] {}));
+
+        } else if (f.getPrimitiveType() == String.class) {
+          cgs.call("readString", string);
+
+        } else if (f.getPrimitiveType() == java.sql.Timestamp.class
+            || f.getPrimitiveType() == java.util.Date.class
+            || f.getPrimitiveType() == java.sql.Date.class) {
+          String tsType = Type.getType(f.getPrimitiveType()).getInternalName();
+          mv.visitTypeInsn(NEW, tsType);
+          mv.visitInsn(DUP);
+          cgs.call("readFixed64", Type.LONG_TYPE);
+          mv.visitMethodInsn(INVOKESPECIAL, tsType, "<init>", Type
+              .getMethodDescriptor(Type.VOID_TYPE, new Type[] {}));
+
+        } else {
+          throw new OrmException("Type " + f.getPrimitiveType()
+              + " not supported for field " + f.getPathToFieldName());
+        }
+        break;
+    }
+    cgs.fieldSetEnd();
+  }
+
+  private static final class SizeofCGS extends CodeGenSupport {
+    int sizeVar;
+
+    private SizeofCGS(MethodVisitor method) {
+      super(method);
+      sizeVar = newLocal();
+    }
+
+    void inc(String name, Type... args) {
+      mv.visitMethodInsn(INVOKESTATIC, codedOutputStream.getInternalName(),
+          name, Type.getMethodDescriptor(Type.INT_TYPE, args));
+      inc();
+    }
+
+    void inc() {
+      mv.visitVarInsn(ILOAD, sizeVar);
+      mv.visitInsn(IADD);
+      mv.visitVarInsn(ISTORE, sizeVar);
+    }
+
+    @Override
+    public void pushEntity() {
+      mv.visitVarInsn(ALOAD, 1);
+    }
+  }
+
+  private static final class EncodeCGS extends CodeGenSupport {
+    int codedOutputStreamVar;
+
+    private EncodeCGS(MethodVisitor method) {
+      super(method);
+    }
+
+    void pushCodedOutputStream() {
+      mv.visitVarInsn(ALOAD, codedOutputStreamVar);
+    }
+
+    void write(String name, Type arg) {
+      mv.visitMethodInsn(INVOKEVIRTUAL, codedOutputStream.getInternalName(),
+          name, Type.getMethodDescriptor(Type.VOID_TYPE, new Type[] {
+              Type.INT_TYPE, arg}));
+    }
+
+    @Override
+    public void pushEntity() {
+      mv.visitVarInsn(ALOAD, 1);
+    }
+  }
+
+  private static final class DecodeCGS extends CodeGenSupport {
+    final int codedInputStreamVar = 1;
+    final int objVar;
+    final int tagVar;
+
+    private DecodeCGS(MethodVisitor method) {
+      super(method);
+      objVar = newLocal();
+      tagVar = newLocal();
+    }
+
+    void pushCodedInputStream() {
+      mv.visitVarInsn(ALOAD, codedInputStreamVar);
+    }
+
+    void call(String name, Type ret) {
+      pushCodedInputStream();
+      mv.visitMethodInsn(INVOKEVIRTUAL, codedInputStream.getInternalName(),
+          name, Type.getMethodDescriptor(ret, new Type[] {}));
+    }
+
+    void ncallInt(String name, Type ret) {
+      mv.visitMethodInsn(INVOKEVIRTUAL, codedInputStream.getInternalName(),
+          name, Type.getMethodDescriptor(ret, new Type[] {Type.INT_TYPE}));
+    }
+
+    @Override
+    public void pushEntity() {
+      mv.visitVarInsn(ALOAD, objVar);
+    }
+  }
+}
diff --git a/src/main/java/com/google/gwtorm/protobuf/ProtobufCodec.java b/src/main/java/com/google/gwtorm/protobuf/ProtobufCodec.java
new file mode 100644
index 0000000..d13e7b3
--- /dev/null
+++ b/src/main/java/com/google/gwtorm/protobuf/ProtobufCodec.java
@@ -0,0 +1,46 @@
+// Copyright 2009 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.gwtorm.protobuf;
+
+import com.google.gwtorm.client.Column;
+import com.google.protobuf.ByteString;
+import com.google.protobuf.CodedInputStream;
+
+/**
+ * Encode and decode an arbitrary Java object as a Protobuf message.
+ * <p>
+ * The object must use the {@link Column} annotations to denote the fields that
+ * should be encoded or decoded.
+ */
+public abstract class ProtobufCodec<T> {
+  /** Encode the object into an immutable byte string. */
+  public abstract ByteString encode(T obj);
+
+  /** Compute the number of bytes of the encoded form of the object. */
+  public abstract int sizeof(T obj);
+
+  /** Decode a byte string into an object instance. */
+  public T decode(ByteString buf) {
+    return decode(buf.newCodedInput());
+  }
+
+  /** Decode a byte string into an object instance. */
+  public T decode(byte[] buf) {
+    return decode(CodedInputStream.newInstance(buf));
+  }
+
+  /** Decode an object by reading it from the stream. */
+  protected abstract T decode(CodedInputStream in);
+}
diff --git a/src/main/java/com/google/gwtorm/schema/java/JavaColumnModel.java b/src/main/java/com/google/gwtorm/schema/java/JavaColumnModel.java
index 082a6a2..984da77 100644
--- a/src/main/java/com/google/gwtorm/schema/java/JavaColumnModel.java
+++ b/src/main/java/com/google/gwtorm/schema/java/JavaColumnModel.java
@@ -26,10 +26,10 @@
 import java.util.List;
 
 
-class JavaColumnModel extends ColumnModel {
+public class JavaColumnModel extends ColumnModel {
   private final Field field;
 
-  JavaColumnModel(final Field columnField) throws OrmException {
+  public JavaColumnModel(final Field columnField) throws OrmException {
     field = columnField;
     initName(field.getName(), field.getAnnotation(Column.class));
 
@@ -78,6 +78,10 @@
     return isPrimitive() ? null : field.getType().getName();
   }
 
+  public Class<?> getNestedClass() {
+    return field.getType();
+  }
+
   private boolean isPrimitive() {
     return Util.isSqlPrimitive(field.getType());
   }
diff --git a/src/test/java/com/google/gwtorm/data/TestAddress.java b/src/test/java/com/google/gwtorm/data/TestAddress.java
index f3df900..d5e330f 100644
--- a/src/test/java/com/google/gwtorm/data/TestAddress.java
+++ b/src/test/java/com/google/gwtorm/data/TestAddress.java
@@ -74,4 +74,8 @@
   public String location() {
     return location;
   }
+
+  public TestAddress.Key key() {
+    return city;
+  }
 }
diff --git a/src/test/java/com/google/gwtorm/protobuf/ProtobufEncoderTest.java b/src/test/java/com/google/gwtorm/protobuf/ProtobufEncoderTest.java
new file mode 100644
index 0000000..15fc754
--- /dev/null
+++ b/src/test/java/com/google/gwtorm/protobuf/ProtobufEncoderTest.java
@@ -0,0 +1,70 @@
+// Copyright 2009 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.gwtorm.protobuf;
+
+import com.google.gwtorm.data.TestAddress;
+import com.google.gwtorm.data.TestPerson;
+
+import junit.framework.TestCase;
+
+import java.io.UnsupportedEncodingException;
+
+public class ProtobufEncoderTest extends TestCase {
+  @SuppressWarnings("cast")
+  public void testPerson() throws UnsupportedEncodingException {
+    final ProtobufCodec<TestPerson> e = CodecFactory.encoder(TestPerson.class);
+    final byte[] bin = new byte[] {
+    //
+        // name
+        0x0a, 0x09,
+        // name.name
+        0x0a, 0x07, 0x74, 0x65, 0x73, 0x74, 0x69, 0x6e, 0x67, //
+        // age
+        0x10, (byte) 0x96, 0x01, //
+        // registered (true)
+        0x18, 0x01 //
+        //
+        };
+    TestPerson p = e.decode(bin);
+    assertNotNull(p);
+    assertTrue(p instanceof TestPerson);
+    assertEquals("testing", p.name());
+    assertEquals(75, p.age());
+    assertTrue(p.isRegistered());
+
+    final byte[] out = e.encode(p).toByteArray();
+    assertEquals(new String(bin, "ISO-8859-1"), new String(out, "ISO-8859-1"));
+    assertEquals(bin.length, e.sizeof(p));
+  }
+
+  public void testAddress() {
+    final ProtobufCodec<TestAddress> e =
+        CodecFactory.encoder(TestAddress.class);
+    TestAddress a = e.decode(new byte[0]);
+    assertNotNull(a);
+    assertNull(a.location());
+
+    TestPerson.Key k = new TestPerson.Key("bob");
+    TestPerson p = new TestPerson(k, 42);
+    TestAddress b = new TestAddress(new TestAddress.Key(k, "ny"), "ny");
+
+    byte[] act = e.encode(b).toByteArray();
+
+    TestAddress c = e.decode(act);
+    assertEquals(c.location(), b.location());
+    assertEquals(c.city(), b.city());
+    assertEquals(c.key(), b.key());
+  }
+}