diff --git a/akka-actor-tests/src/main/scala/akka/testing/Serializers.scala b/akka-actor-tests/src/main/scala/akka/testing/Serializers.scala
deleted file mode 100644
index de7d0924ea..0000000000
--- a/akka-actor-tests/src/main/scala/akka/testing/Serializers.scala
+++ /dev/null
@@ -1,75 +0,0 @@
-/**
- * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
- */
-
-package akka.testing
-
-import akka.serialization.Serializer
-import com.google.protobuf.Message
-import org.codehaus.jackson.map.ObjectMapper
-import java.io.{ ObjectOutputStream, ByteArrayOutputStream, ObjectInputStream, ByteArrayInputStream }
-import akka.util.ClassLoaderObjectInputStream
-import sjson.json._
-
-class ProtobufSerializer extends Serializer {
-  val ARRAY_OF_BYTE_ARRAY = Array[Class[_]](classOf[Array[Byte]])
-
-  def identifier = 2: Byte
-
-  def toBinary(obj: AnyRef): Array[Byte] = {
-    if (!obj.isInstanceOf[Message]) throw new IllegalArgumentException(
-      "Can't serialize a non-protobuf message using protobuf [" + obj + "]")
-    obj.asInstanceOf[Message].toByteArray
-  }
-
-  def fromBinary(bytes: Array[Byte], clazz: Option[Class[_]], classLoader: Option[ClassLoader] = None): AnyRef = {
-    if (!clazz.isDefined) throw new IllegalArgumentException(
-      "Need a protobuf message class to be able to serialize bytes using protobuf")
-    clazz.get.getDeclaredMethod("parseFrom", ARRAY_OF_BYTE_ARRAY: _*).invoke(null, bytes).asInstanceOf[Message]
-  }
-}
-object ProtobufSerializer extends ProtobufSerializer
-
-class JavaJSONSerializer extends Serializer {
-  private val mapper = new ObjectMapper
-
-  def identifier = 3: Byte
-
-  def toBinary(obj: AnyRef): Array[Byte] = {
-    val bos = new ByteArrayOutputStream
-    val out = new ObjectOutputStream(bos)
-    mapper.writeValue(out, obj)
-    out.close
-    bos.toByteArray
-  }
-
-  def fromBinary(bytes: Array[Byte], clazz: Option[Class[_]], classLoader: Option[ClassLoader] = None): AnyRef = {
-    if (!clazz.isDefined) throw new IllegalArgumentException(
-      "Can't deserialize JSON to instance if no class is provided")
-    val in =
-      if (classLoader.isDefined) new ClassLoaderObjectInputStream(classLoader.get, new ByteArrayInputStream(bytes))
-      else new ObjectInputStream(new ByteArrayInputStream(bytes))
-    val obj = mapper.readValue(in, clazz.get).asInstanceOf[AnyRef]
-    in.close
-    obj
-  }
-}
-object JavaJSONSerializer extends JavaJSONSerializer
-
-class SJSONSerializer extends Serializer {
-
-  def identifier = 4: Byte
-
-  def toBinary(obj: AnyRef): Array[Byte] =
-    sjson.json.Serializer.SJSON.out(obj)
-
-  def fromBinary(bytes: Array[Byte], clazz: Option[Class[_]], cl: Option[ClassLoader] = None): AnyRef = {
-    if (!clazz.isDefined) throw new IllegalArgumentException(
-      "Can't deserialize JSON to instance if no class is provided")
-
-    import sjson.json.Serializer._
-    val sj = new SJSON with DefaultConstructor { val classLoader = cl }
-    sj.in(bytes, clazz.get.getName)
-  }
-}
-object SJSONSerializer extends SJSONSerializer
diff --git a/akka-actor-tests/src/test/scala/akka/serialization/SerializeSpec.scala b/akka-actor-tests/src/test/scala/akka/serialization/SerializeSpec.scala
index f90f651065..51dc26d6c5 100644
--- a/akka-actor-tests/src/test/scala/akka/serialization/SerializeSpec.scala
+++ b/akka-actor-tests/src/test/scala/akka/serialization/SerializeSpec.scala
@@ -4,8 +4,6 @@
 
 package akka.serialization
 
-import akka.serialization.Serialization._
-import scala.reflect._
 import akka.testkit.AkkaSpec
 import com.typesafe.config.ConfigFactory
 import akka.actor._
@@ -13,6 +11,26 @@ import java.io._
 import akka.dispatch.Await
 import akka.util.Timeout
 import akka.util.duration._
+import scala.reflect.BeanInfo
+import com.google.protobuf.Message
+
+class ProtobufSerializer extends Serializer {
+  val ARRAY_OF_BYTE_ARRAY = Array[Class[_]](classOf[Array[Byte]])
+  def includeManifest: Boolean = true
+  def identifier = 2
+
+  def toBinary(obj: AnyRef): Array[Byte] = {
+    if (!obj.isInstanceOf[Message]) throw new IllegalArgumentException(
+      "Can't serialize a non-protobuf message using protobuf [" + obj + "]")
+    obj.asInstanceOf[Message].toByteArray
+  }
+
+  def fromBinary(bytes: Array[Byte], clazz: Option[Class[_]], classLoader: Option[ClassLoader] = None): AnyRef = {
+    if (!clazz.isDefined) throw new IllegalArgumentException(
+      "Need a protobuf message class to be able to serialize bytes using protobuf")
+    clazz.get.getDeclaredMethod("parseFrom", ARRAY_OF_BYTE_ARRAY: _*).invoke(null, bytes).asInstanceOf[Message]
+  }
+}
 
 object SerializeSpec {
 
@@ -21,14 +39,10 @@ object SerializeSpec {
       actor {
         serializers {
           java = "akka.serialization.JavaSerializer"
-          proto = "akka.testing.ProtobufSerializer"
-          sjson = "akka.testing.SJSONSerializer"
-          default = "akka.serialization.JavaSerializer"
         }
     
         serialization-bindings {
-          java = ["akka.serialization.SerializeSpec$Address", "akka.serialization.MyJavaSerializableActor", "akka.serialization.MyStatelessActorWithMessagesInMailbox", "akka.serialization.MyActorWithProtobufMessagesInMailbox"]
-          sjson = ["akka.serialization.SerializeSpec$Person"]
+          java = ["akka.serialization.SerializeSpec$Person", "akka.serialization.SerializeSpec$Address", "akka.serialization.MyJavaSerializableActor", "akka.serialization.MyStatelessActorWithMessagesInMailbox", "akka.serialization.MyActorWithProtobufMessagesInMailbox"]
           proto = ["com.google.protobuf.Message", "akka.actor.ProtobufProtocol$MyMessage"]
         }
       }
@@ -57,7 +71,7 @@ class SerializeSpec extends AkkaSpec(SerializeSpec.serializationConf) {
 
     "have correct bindings" in {
       ser.bindings(addr.getClass.getName) must be("java")
-      ser.bindings(person.getClass.getName) must be("sjson")
+      ser.bindings("akka.actor.ProtobufProtocol$MyMessage") must be("proto")
     }
 
     "serialize Address" in {
@@ -143,14 +157,12 @@ object VerifySerializabilitySpec {
 
         serializers {
           java = "akka.serialization.JavaSerializer"
-          proto = "akka.testing.ProtobufSerializer"
-          sjson = "akka.testing.SJSONSerializer"
+          proto = "akka.serialization.ProtobufSerializer"
           default = "akka.serialization.JavaSerializer"
         }
 
         serialization-bindings {
           java = ["akka.serialization.SerializeSpec$Address", "akka.serialization.MyJavaSerializableActor", "akka.serialization.MyStatelessActorWithMessagesInMailbox", "akka.serialization.MyActorWithProtobufMessagesInMailbox"]
-          sjson = ["akka.serialization.SerializeSpec$Person"]
           proto = ["com.google.protobuf.Message", "akka.actor.ProtobufProtocol$MyMessage"]
         }
       }
diff --git a/akka-actor/src/main/resources/reference.conf b/akka-actor/src/main/resources/reference.conf
index 6dd2b2a452..8e45379592 100644
--- a/akka-actor/src/main/resources/reference.conf
+++ b/akka-actor/src/main/resources/reference.conf
@@ -197,8 +197,7 @@ akka {
     # class is not found, then the default serializer (Java serialization) is used.
     serializers {
       # java = "akka.serialization.JavaSerializer"
-      # proto = "akka.testing.ProtobufSerializer"
-      # sjson = "akka.testing.SJSONSerializer"
+      # proto = "akka.serialization.ProtobufSerializer"
 
       default = "akka.serialization.JavaSerializer"
     }
@@ -208,7 +207,6 @@ akka {
     #           "akka.serialization.MyJavaSerializableActor",
     #           "akka.serialization.MyStatelessActorWithMessagesInMailbox",
     #           "akka.serialization.MyActorWithProtobufMessagesInMailbox"]
-    #   sjson = ["akka.serialization.SerializeSpec$Person"]
     #   proto = ["com.google.protobuf.Message",
     #            "akka.actor.ProtobufProtocol$MyMessage"]
     # }
diff --git a/akka-actor/src/main/scala/akka/actor/ActorRefProvider.scala b/akka-actor/src/main/scala/akka/actor/ActorRefProvider.scala
index d5f9b5ed54..d940aa2c20 100644
--- a/akka-actor/src/main/scala/akka/actor/ActorRefProvider.scala
+++ b/akka-actor/src/main/scala/akka/actor/ActorRefProvider.scala
@@ -560,9 +560,7 @@ class DefaultScheduler(hashedWheelTimer: HashedWheelTimer, log: LoggingAdapter,
 
   private def createSingleTask(runnable: Runnable): TimerTask =
     new TimerTask() {
-      def run(timeout: org.jboss.netty.akka.util.Timeout) {
-        dispatcher.dispatchTask(() ⇒ runnable.run())
-      }
+      def run(timeout: org.jboss.netty.akka.util.Timeout) { dispatcher.execute(runnable) }
     }
 
   private def createSingleTask(receiver: ActorRef, message: Any): TimerTask =
@@ -575,7 +573,7 @@ class DefaultScheduler(hashedWheelTimer: HashedWheelTimer, log: LoggingAdapter,
   private def createSingleTask(f: ⇒ Unit): TimerTask =
     new TimerTask {
       def run(timeout: org.jboss.netty.akka.util.Timeout) {
-        dispatcher.dispatchTask(() ⇒ f)
+        dispatcher.execute(new Runnable { def run = f })
       }
     }
 
@@ -598,7 +596,7 @@ class DefaultScheduler(hashedWheelTimer: HashedWheelTimer, log: LoggingAdapter,
   private def createContinuousTask(delay: Duration, f: ⇒ Unit): TimerTask = {
     new TimerTask {
       def run(timeout: org.jboss.netty.akka.util.Timeout) {
-        dispatcher.dispatchTask(() ⇒ f)
+        dispatcher.execute(new Runnable { def run = f })
         try timeout.getTimer.newTimeout(this, delay) catch {
           case _: IllegalStateException ⇒ // stop recurring if timer is stopped
         }
@@ -609,7 +607,7 @@ class DefaultScheduler(hashedWheelTimer: HashedWheelTimer, log: LoggingAdapter,
   private def createContinuousTask(delay: Duration, runnable: Runnable): TimerTask = {
     new TimerTask {
       def run(timeout: org.jboss.netty.akka.util.Timeout) {
-        dispatcher.dispatchTask(() ⇒ runnable.run())
+        dispatcher.execute(runnable)
         try timeout.getTimer.newTimeout(this, delay) catch {
           case _: IllegalStateException ⇒ // stop recurring if timer is stopped
         }
diff --git a/akka-actor/src/main/scala/akka/actor/TypedActor.scala b/akka-actor/src/main/scala/akka/actor/TypedActor.scala
index e23128c2a8..3dc5d4c000 100644
--- a/akka-actor/src/main/scala/akka/actor/TypedActor.scala
+++ b/akka-actor/src/main/scala/akka/actor/TypedActor.scala
@@ -184,7 +184,7 @@ object TypedActor extends ExtensionId[TypedActorExtension] with ExtensionIdProvi
      * @throws the underlying exception if there's an InvocationTargetException thrown on the invocation
      */
     def apply(instance: AnyRef): AnyRef = try {
-      parameters match { //TODO: We do not yet obey Actor.SERIALIZE_MESSAGES
+      parameters match {
         case null                     ⇒ method.invoke(instance)
         case args if args.length == 0 ⇒ method.invoke(instance)
         case args                     ⇒ method.invoke(instance, args: _*)
@@ -193,7 +193,7 @@ object TypedActor extends ExtensionId[TypedActorExtension] with ExtensionIdProvi
 
     private def writeReplace(): AnyRef = parameters match {
       case null                 ⇒ SerializedMethodCall(method.getDeclaringClass, method.getName, method.getParameterTypes, null, null)
-      case ps if ps.length == 0 ⇒ SerializedMethodCall(method.getDeclaringClass, method.getName, method.getParameterTypes, Array[Serializer.Identifier](), Array[Array[Byte]]())
+      case ps if ps.length == 0 ⇒ SerializedMethodCall(method.getDeclaringClass, method.getName, method.getParameterTypes, Array[Int](), Array[Array[Byte]]())
       case ps ⇒
         val serializers: Array[Serializer] = ps map SerializationExtension(Serialization.currentSystem.value).findSerializerFor
         val serializedParameters: Array[Array[Byte]] = Array.ofDim[Array[Byte]](serializers.length)
@@ -207,7 +207,7 @@ object TypedActor extends ExtensionId[TypedActorExtension] with ExtensionIdProvi
   /**
    * Represents the serialized form of a MethodCall, uses readResolve and writeReplace to marshall the call
    */
-  case class SerializedMethodCall(ownerType: Class[_], methodName: String, parameterTypes: Array[Class[_]], serializerIdentifiers: Array[Serializer.Identifier], serializedParameters: Array[Array[Byte]]) {
+  case class SerializedMethodCall(ownerType: Class[_], methodName: String, parameterTypes: Array[Class[_]], serializerIdentifiers: Array[Int], serializedParameters: Array[Array[Byte]]) {
 
     //TODO implement writeObject and readObject to serialize
     //TODO Possible optimization is to special encode the parameter-types to conserve space
@@ -390,6 +390,7 @@ object TypedActor extends ExtensionId[TypedActorExtension] with ExtensionIdProvi
   private[akka] class TypedActorInvocationHandler(val extension: TypedActorExtension, val actorVar: AtomVar[ActorRef], val timeout: Timeout) extends InvocationHandler {
     def actor = actorVar.get
 
+    @throws(classOf[Throwable])
     def invoke(proxy: AnyRef, method: Method, args: Array[AnyRef]): AnyRef = method.getName match {
       case "toString" ⇒ actor.toString
       case "equals"   ⇒ (args.length == 1 && (proxy eq args(0)) || actor == extension.getActorRefFor(args(0))).asInstanceOf[AnyRef] //Force boxing of the boolean
diff --git a/akka-actor/src/main/scala/akka/dispatch/AbstractDispatcher.scala b/akka-actor/src/main/scala/akka/dispatch/AbstractDispatcher.scala
index 24b9da4447..52f35fd952 100644
--- a/akka-actor/src/main/scala/akka/dispatch/AbstractDispatcher.scala
+++ b/akka-actor/src/main/scala/akka/dispatch/AbstractDispatcher.scala
@@ -74,10 +74,10 @@ case class ChildTerminated(child: ActorRef) extends SystemMessage // sent to sup
 case class Link(subject: ActorRef) extends SystemMessage // sent to self from ActorCell.watch
 case class Unlink(subject: ActorRef) extends SystemMessage // sent to self from ActorCell.unwatch
 
-final case class TaskInvocation(eventStream: EventStream, function: () ⇒ Unit, cleanup: () ⇒ Unit) extends Runnable {
+final case class TaskInvocation(eventStream: EventStream, runnable: Runnable, cleanup: () ⇒ Unit) extends Runnable {
   def run() {
     try {
-      function()
+      runnable.run()
     } catch {
       // FIXME catching all and continue isn't good for OOME, ticket #1418
       case e ⇒ eventStream.publish(Error(e, "TaskInvocation", e.getMessage))
@@ -87,15 +87,48 @@ final case class TaskInvocation(eventStream: EventStream, function: () ⇒ Unit,
   }
 }
 
+object ExecutionContext {
+  implicit def defaultExecutionContext(implicit system: ActorSystem): ExecutionContext = system.dispatcher
+
+  /**
+   * Creates an ExecutionContext from the given ExecutorService
+   */
+  def fromExecutorService(e: ExecutorService): ExecutionContext = new WrappedExecutorService(e)
+
+  /**
+   * Creates an ExecutionContext from the given Executor
+   */
+  def fromExecutor(e: Executor): ExecutionContext = new WrappedExecutor(e)
+
+  private class WrappedExecutorService(val executor: ExecutorService) extends ExecutorServiceDelegate with ExecutionContext
+
+  private class WrappedExecutor(val executor: Executor) extends Executor with ExecutionContext {
+    override final def execute(runnable: Runnable): Unit = executor.execute(runnable)
+  }
+}
+
+/**
+ * An ExecutionContext is essentially the same thing as a java.util.concurrent.Executor
+ * This interface/trait exists to decouple the concept of execution from Actors & MessageDispatchers
+ * It is also needed to provide a fallback implicit default instance (in the companion object).
+ */
+trait ExecutionContext {
+
+  /**
+   * Submits the runnable for execution
+   */
+  def execute(runnable: Runnable): Unit
+}
+
 object MessageDispatcher {
   val UNSCHEDULED = 0 //WARNING DO NOT CHANGE THE VALUE OF THIS: It relies on the faster init of 0 in AbstractMessageDispatcher
   val SCHEDULED = 1
   val RESCHEDULED = 2
 
-  implicit def defaultDispatcher(implicit system: ActorSystem) = system.dispatcher
+  implicit def defaultDispatcher(implicit system: ActorSystem): MessageDispatcher = system.dispatcher
 }
 
-abstract class MessageDispatcher(val prerequisites: DispatcherPrerequisites) extends AbstractMessageDispatcher with Serializable {
+abstract class MessageDispatcher(val prerequisites: DispatcherPrerequisites) extends AbstractMessageDispatcher with Serializable with Executor with ExecutionContext {
 
   import MessageDispatcher._
   import AbstractMessageDispatcher.{ inhabitantsUpdater, shutdownScheduleUpdater }
@@ -131,8 +164,8 @@ abstract class MessageDispatcher(val prerequisites: DispatcherPrerequisites) ext
     ifSensibleToDoSoThenScheduleShutdown()
   }
 
-  protected[akka] final def dispatchTask(block: () ⇒ Unit) {
-    val invocation = TaskInvocation(eventStream, block, taskCleanup)
+  final def execute(runnable: Runnable) {
+    val invocation = TaskInvocation(eventStream, runnable, taskCleanup)
     inhabitantsUpdater.incrementAndGet(this)
     try {
       executeTask(invocation)
diff --git a/akka-actor/src/main/scala/akka/dispatch/Future.scala b/akka-actor/src/main/scala/akka/dispatch/Future.scala
index 59996e9311..fea97fbaf3 100644
--- a/akka-actor/src/main/scala/akka/dispatch/Future.scala
+++ b/akka-actor/src/main/scala/akka/dispatch/Future.scala
@@ -21,8 +21,9 @@ import scala.annotation.tailrec
 import scala.collection.mutable.Stack
 import akka.util.{ Switch, Duration, BoxedType }
 import java.util.concurrent.atomic.{ AtomicReferenceFieldUpdater, AtomicInteger, AtomicBoolean }
-import java.util.concurrent.{ TimeoutException, ConcurrentLinkedQueue, TimeUnit, Callable }
 import akka.dispatch.Await.CanAwait
+import java.util.concurrent._
+import akka.actor.ActorSystem
 
 object Await {
   sealed trait CanAwait
@@ -55,37 +56,37 @@ object Futures {
   /**
    * Java API, equivalent to Future.apply
    */
-  def future[T](body: Callable[T], dispatcher: MessageDispatcher): Future[T] = Future(body.call)(dispatcher)
+  def future[T](body: Callable[T], executor: ExecutionContext): Future[T] = Future(body.call)(executor)
 
   /**
    * Java API, equivalent to Promise.apply
    */
-  def promise[T](dispatcher: MessageDispatcher): Promise[T] = Promise[T]()(dispatcher)
+  def promise[T](executor: ExecutionContext): Promise[T] = Promise[T]()(executor)
 
   /**
    * Java API, creates an already completed Promise with the specified exception
    */
-  def failed[T](exception: Throwable, dispatcher: MessageDispatcher): Promise[T] = Promise.failed(exception)(dispatcher)
+  def failed[T](exception: Throwable, executor: ExecutionContext): Promise[T] = Promise.failed(exception)(executor)
 
   /**
    * Java API, Creates an already completed Promise with the specified result
    */
-  def successful[T](result: T, dispatcher: MessageDispatcher): Promise[T] = Promise.successful(result)(dispatcher)
+  def successful[T](result: T, executor: ExecutionContext): Promise[T] = Promise.successful(result)(executor)
 
   /**
    * Java API.
    * Returns a Future that will hold the optional result of the first Future with a result that matches the predicate
    */
-  def find[T <: AnyRef](futures: JIterable[Future[T]], predicate: JFunc[T, java.lang.Boolean], dispatcher: MessageDispatcher): Future[JOption[T]] = {
-    Future.find[T]((scala.collection.JavaConversions.iterableAsScalaIterable(futures)))(predicate.apply(_))(dispatcher).map(JOption.fromScalaOption(_))
+  def find[T <: AnyRef](futures: JIterable[Future[T]], predicate: JFunc[T, java.lang.Boolean], executor: ExecutionContext): Future[JOption[T]] = {
+    Future.find[T]((scala.collection.JavaConversions.iterableAsScalaIterable(futures)))(predicate.apply(_))(executor).map(JOption.fromScalaOption(_))
   }
 
   /**
    * Java API.
    * Returns a Future to the result of the first future in the list that is completed
    */
-  def firstCompletedOf[T <: AnyRef](futures: JIterable[Future[T]], dispatcher: MessageDispatcher): Future[T] =
-    Future.firstCompletedOf(scala.collection.JavaConversions.iterableAsScalaIterable(futures))(dispatcher)
+  def firstCompletedOf[T <: AnyRef](futures: JIterable[Future[T]], executor: ExecutionContext): Future[T] =
+    Future.firstCompletedOf(scala.collection.JavaConversions.iterableAsScalaIterable(futures))(executor)
 
   /**
    * Java API
@@ -94,23 +95,23 @@ object Futures {
    * the result will be the first failure of any of the futures, or any failure in the actual fold,
    * or the result of the fold.
    */
-  def fold[T <: AnyRef, R <: AnyRef](zero: R, futures: JIterable[Future[T]], fun: akka.japi.Function2[R, T, R], dispatcher: MessageDispatcher): Future[R] =
-    Future.fold(scala.collection.JavaConversions.iterableAsScalaIterable(futures))(zero)(fun.apply _)(dispatcher)
+  def fold[T <: AnyRef, R <: AnyRef](zero: R, futures: JIterable[Future[T]], fun: akka.japi.Function2[R, T, R], executor: ExecutionContext): Future[R] =
+    Future.fold(scala.collection.JavaConversions.iterableAsScalaIterable(futures))(zero)(fun.apply _)(executor)
 
   /**
    * Java API.
    * Initiates a fold over the supplied futures where the fold-zero is the result value of the Future that's completed first
    */
-  def reduce[T <: AnyRef, R >: T](futures: JIterable[Future[T]], fun: akka.japi.Function2[R, T, T], dispatcher: MessageDispatcher): Future[R] =
-    Future.reduce(scala.collection.JavaConversions.iterableAsScalaIterable(futures))(fun.apply _)(dispatcher)
+  def reduce[T <: AnyRef, R >: T](futures: JIterable[Future[T]], fun: akka.japi.Function2[R, T, T], executor: ExecutionContext): Future[R] =
+    Future.reduce(scala.collection.JavaConversions.iterableAsScalaIterable(futures))(fun.apply _)(executor)
 
   /**
    * Java API.
    * Simple version of Future.traverse. Transforms a JIterable[Future[A]] into a Future[JIterable[A]].
    * Useful for reducing many Futures into a single Future.
    */
-  def sequence[A](in: JIterable[Future[A]], dispatcher: MessageDispatcher): Future[JIterable[A]] = {
-    implicit val d = dispatcher
+  def sequence[A](in: JIterable[Future[A]], executor: ExecutionContext): Future[JIterable[A]] = {
+    implicit val d = executor
     scala.collection.JavaConversions.iterableAsScalaIterable(in).foldLeft(Future(new JLinkedList[A]()))((fr, fa) ⇒
       for (r ← fr; a ← fa) yield {
         r add a
@@ -124,8 +125,8 @@ object Futures {
    * This is useful for performing a parallel map. For example, to apply a function to all items of a list
    * in parallel.
    */
-  def traverse[A, B](in: JIterable[A], fn: JFunc[A, Future[B]], dispatcher: MessageDispatcher): Future[JIterable[B]] = {
-    implicit val d = dispatcher
+  def traverse[A, B](in: JIterable[A], fn: JFunc[A, Future[B]], executor: ExecutionContext): Future[JIterable[B]] = {
+    implicit val d = executor
     scala.collection.JavaConversions.iterableAsScalaIterable(in).foldLeft(Future(new JLinkedList[B]())) { (fr, a) ⇒
       val fb = fn(a)
       for (r ← fr; b ← fb) yield { r add b; r }
@@ -139,18 +140,19 @@ object Future {
    * This method constructs and returns a Future that will eventually hold the result of the execution of the supplied body
    * The execution is performed by the specified Dispatcher.
    */
-  def apply[T](body: ⇒ T)(implicit dispatcher: MessageDispatcher): Future[T] = {
+  def apply[T](body: ⇒ T)(implicit executor: ExecutionContext): Future[T] = {
     val promise = Promise[T]()
-    dispatcher dispatchTask { () ⇒
-      promise complete {
-        try {
-          Right(body)
-        } catch {
-          // FIXME catching all and continue isn't good for OOME, ticket #1418
-          case e ⇒ Left(e)
+    executor.execute(new Runnable {
+      def run =
+        promise complete {
+          try {
+            Right(body)
+          } catch {
+            // FIXME catching all and continue isn't good for OOME, ticket #1418
+            case e ⇒ Left(e)
+          }
         }
-      }
-    }
+    })
     promise
   }
 
@@ -161,13 +163,13 @@ object Future {
    * Simple version of Futures.traverse. Transforms a Traversable[Future[A]] into a Future[Traversable[A]].
    * Useful for reducing many Futures into a single Future.
    */
-  def sequence[A, M[_] <: Traversable[_]](in: M[Future[A]])(implicit cbf: CanBuildFrom[M[Future[A]], A, M[A]], dispatcher: MessageDispatcher): Future[M[A]] =
+  def sequence[A, M[_] <: Traversable[_]](in: M[Future[A]])(implicit cbf: CanBuildFrom[M[Future[A]], A, M[A]], executor: ExecutionContext): Future[M[A]] =
     in.foldLeft(Promise.successful(cbf(in)): Future[Builder[A, M[A]]])((fr, fa) ⇒ for (r ← fr; a ← fa.asInstanceOf[Future[A]]) yield (r += a)).map(_.result)
 
   /**
    * Returns a Future to the result of the first future in the list that is completed
    */
-  def firstCompletedOf[T](futures: Traversable[Future[T]])(implicit dispatcher: MessageDispatcher): Future[T] = {
+  def firstCompletedOf[T](futures: Traversable[Future[T]])(implicit executor: ExecutionContext): Future[T] = {
     val futureResult = Promise[T]()
 
     val completeFirst: Either[Throwable, T] ⇒ Unit = futureResult complete _
@@ -179,7 +181,7 @@ object Future {
   /**
    * Returns a Future that will hold the optional result of the first Future with a result that matches the predicate
    */
-  def find[T](futures: Traversable[Future[T]])(predicate: T ⇒ Boolean)(implicit dispatcher: MessageDispatcher): Future[Option[T]] = {
+  def find[T](futures: Traversable[Future[T]])(predicate: T ⇒ Boolean)(implicit executor: ExecutionContext): Future[Option[T]] = {
     if (futures.isEmpty) Promise.successful[Option[T]](None)
     else {
       val result = Promise[Option[T]]()
@@ -210,7 +212,7 @@ object Future {
    *   val result = Await.result(Future.fold(futures)(0)(_ + _), 5 seconds)
    * </pre>
    */
-  def fold[T, R](futures: Traversable[Future[T]])(zero: R)(foldFun: (R, T) ⇒ R)(implicit dispatcher: MessageDispatcher): Future[R] = {
+  def fold[T, R](futures: Traversable[Future[T]])(zero: R)(foldFun: (R, T) ⇒ R)(implicit executor: ExecutionContext): Future[R] = {
     if (futures.isEmpty) Promise.successful(zero)
     else sequence(futures).map(_.foldLeft(zero)(foldFun))
   }
@@ -222,7 +224,7 @@ object Future {
    *   val result = Await.result(Futures.reduce(futures)(_ + _), 5 seconds)
    * </pre>
    */
-  def reduce[T, R >: T](futures: Traversable[Future[T]])(op: (R, T) ⇒ T)(implicit dispatcher: MessageDispatcher): Future[R] = {
+  def reduce[T, R >: T](futures: Traversable[Future[T]])(op: (R, T) ⇒ T)(implicit executor: ExecutionContext): Future[R] = {
     if (futures.isEmpty) Promise[R].failure(new NoSuchElementException("reduce attempted on empty collection"))
     else sequence(futures).map(_ reduce op)
   }
@@ -234,7 +236,7 @@ object Future {
    * val myFutureList = Future.traverse(myList)(x ⇒ Future(myFunc(x)))
    * </pre>
    */
-  def traverse[A, B, M[_] <: Traversable[_]](in: M[A])(fn: A ⇒ Future[B])(implicit cbf: CanBuildFrom[M[A], B, M[B]], dispatcher: MessageDispatcher): Future[M[B]] =
+  def traverse[A, B, M[_] <: Traversable[_]](in: M[A])(fn: A ⇒ Future[B])(implicit cbf: CanBuildFrom[M[A], B, M[B]], executor: ExecutionContext): Future[M[B]] =
     in.foldLeft(Promise.successful(cbf(in)): Future[Builder[B, M[B]]]) { (fr, a) ⇒
       val fb = fn(a.asInstanceOf[A])
       for (r ← fr; b ← fb) yield (r += b)
@@ -256,7 +258,7 @@ object Future {
    *
    * The Delimited Continuations compiler plugin must be enabled in order to use this method.
    */
-  def flow[A](body: ⇒ A @cps[Future[Any]])(implicit dispatcher: MessageDispatcher): Future[A] = {
+  def flow[A](body: ⇒ A @cps[Future[Any]])(implicit executor: ExecutionContext): Future[A] = {
     val future = Promise[A]
     dispatchTask({ () ⇒
       (reify(body) foreachFull (future success, future failure): Future[Any]) onFailure {
@@ -290,7 +292,7 @@ object Future {
    * }
    * </pre>
    */
-  def blocking(implicit dispatcher: MessageDispatcher): Unit =
+  def blocking(implicit executor: ExecutionContext): Unit =
     _taskStack.get match {
       case Some(taskStack) if taskStack.nonEmpty ⇒
         val tasks = taskStack.elems
@@ -308,32 +310,38 @@ object Future {
   /**
    * Internal API, do not call
    */
-  private[akka] def dispatchTask(task: () ⇒ Unit, force: Boolean = false)(implicit dispatcher: MessageDispatcher): Unit =
+  private[akka] def dispatchTask(task: () ⇒ Unit, force: Boolean = false)(implicit executor: ExecutionContext): Unit =
     _taskStack.get match {
       case Some(taskStack) if !force ⇒ taskStack push task
-      case _ ⇒
-        dispatcher dispatchTask { () ⇒
-          try {
-            val taskStack = Stack[() ⇒ Unit](task)
-            _taskStack set Some(taskStack)
-            while (taskStack.nonEmpty) {
-              val next = taskStack.pop()
-              try {
-                next.apply()
-              } catch {
-                case e ⇒
-                  // FIXME catching all and continue isn't good for OOME, ticket #1418
-                  dispatcher.prerequisites.eventStream.publish(Error(e, "Future.dispatchTask", "Failed to dispatch task, due to: " + e.getMessage))
+      case _ ⇒ executor.execute(
+        new Runnable {
+          def run =
+            try {
+              val taskStack = Stack[() ⇒ Unit](task)
+              _taskStack set Some(taskStack)
+              while (taskStack.nonEmpty) {
+                val next = taskStack.pop()
+                try {
+                  next.apply()
+                } catch {
+                  case e ⇒
+                    // FIXME catching all and continue isn't good for OOME, ticket #1418
+                    executor match {
+                      case m: MessageDispatcher ⇒
+                        m.prerequisites.eventStream.publish(Error(e, "Future.dispatchTask", e.getMessage))
+                      case other ⇒
+                        e.printStackTrace()
+                    }
+                }
               }
-            }
-          } finally { _taskStack set None }
-        }
+            } finally { _taskStack set None }
+        })
     }
 }
 
 sealed trait Future[+T] extends japi.Future[T] with Await.Awaitable[T] {
 
-  implicit def dispatcher: MessageDispatcher
+  implicit def executor: ExecutionContext
 
   protected final def resolve[X](source: Either[Throwable, X]): Either[Throwable, X] = source match {
     case Left(t: scala.runtime.NonLocalReturnControl[_]) ⇒ Right(t.value.asInstanceOf[X])
@@ -462,8 +470,8 @@ sealed trait Future[+T] extends japi.Future[T] with Await.Awaitable[T] {
         future complete (try {
           Right(f(res))
         } catch {
-          case e: Exception ⇒
-            dispatcher.prerequisites.eventStream.publish(Error(e, "Future.map", e.getMessage))
+          case e ⇒
+            logError("Future.map", e)
             Left(e)
         })
     }
@@ -511,19 +519,25 @@ sealed trait Future[+T] extends japi.Future[T] with Await.Awaitable[T] {
         try {
           p completeWith f(r)
         } catch {
-          case e: Exception ⇒
+          case e ⇒
             p complete Left(e)
-            dispatcher.prerequisites.eventStream.publish(Error(e, "Future.flatMap", e.getMessage))
+            logError("Future.flatMap", e)
         }
     }
     p
   }
 
+  /**
+   * Same as onSuccess { case r => f(r) } but is also used in for-comprehensions
+   */
   final def foreach(f: T ⇒ Unit): Unit = onComplete {
     case Right(r) ⇒ f(r)
     case _        ⇒
   }
 
+  /**
+   * Used by for-comprehensions
+   */
   final def withFilter(p: T ⇒ Boolean) = new FutureWithFilter[T](this, p)
 
   final class FutureWithFilter[+A](self: Future[A], p: A ⇒ Boolean) {
@@ -533,6 +547,11 @@ sealed trait Future[+T] extends japi.Future[T] with Await.Awaitable[T] {
     def withFilter(q: A ⇒ Boolean): FutureWithFilter[A] = new FutureWithFilter[A](self, x ⇒ p(x) && q(x))
   }
 
+  /**
+   * Returns a new Future that will hold the successful result of this Future if it matches
+   * the given predicate, if it doesn't match, the resulting Future will be a failed Future
+   * with a MatchError, of if this Future fails, that failure will be propagated to the returned Future
+   */
   final def filter(pred: T ⇒ Boolean): Future[T] = {
     val p = Promise[T]()
     onComplete {
@@ -540,13 +559,20 @@ sealed trait Future[+T] extends japi.Future[T] with Await.Awaitable[T] {
       case r @ Right(res) ⇒ p complete (try {
         if (pred(res)) r else Left(new MatchError(res))
       } catch {
-        case e: Exception ⇒
-          dispatcher.prerequisites.eventStream.publish(Error(e, "Future.filter", e.getMessage))
+        case e ⇒
+          logError("Future.filter", e)
           Left(e)
       })
     }
     p
   }
+
+  protected def logError(msg: String, problem: Throwable): Unit = {
+    executor match {
+      case m: MessageDispatcher ⇒ m.prerequisites.eventStream.publish(Error(problem, msg, problem.getMessage))
+      case other                ⇒ problem.printStackTrace()
+    }
+  }
 }
 
 object Promise {
@@ -555,17 +581,17 @@ object Promise {
    *
    * Scala API
    */
-  def apply[A]()(implicit dispatcher: MessageDispatcher): Promise[A] = new DefaultPromise[A]()
+  def apply[A]()(implicit executor: ExecutionContext): Promise[A] = new DefaultPromise[A]()
 
   /**
    * Creates an already completed Promise with the specified exception
    */
-  def failed[T](exception: Throwable)(implicit dispatcher: MessageDispatcher): Promise[T] = new KeptPromise[T](Left(exception))
+  def failed[T](exception: Throwable)(implicit executor: ExecutionContext): Promise[T] = new KeptPromise[T](Left(exception))
 
   /**
    * Creates an already completed Promise with the specified result
    */
-  def successful[T](result: T)(implicit dispatcher: MessageDispatcher): Promise[T] = new KeptPromise[T](Right(result))
+  def successful[T](result: T)(implicit executor: ExecutionContext): Promise[T] = new KeptPromise[T](Right(result))
 }
 
 /**
@@ -621,8 +647,8 @@ trait Promise[T] extends Future[T] {
       try {
         fr completeWith cont(thisPromise)
       } catch {
-        case e: Exception ⇒
-          dispatcher.prerequisites.eventStream.publish(Error(e, "Promise.completeWith", e.getMessage))
+        case e ⇒
+          logError("Promise.completeWith", e)
           fr failure e
       }
     }
@@ -636,8 +662,8 @@ trait Promise[T] extends Future[T] {
       try {
         fr completeWith cont(f)
       } catch {
-        case e: Exception ⇒
-          dispatcher.prerequisites.eventStream.publish(Error(e, "Promise.completeWith", e.getMessage))
+        case e ⇒
+          logError("Promise.completeWith", e)
           fr failure e
       }
     }
@@ -669,7 +695,7 @@ private[dispatch] object DefaultPromise {
 /**
  * The default concrete Future implementation.
  */
-class DefaultPromise[T](implicit val dispatcher: MessageDispatcher) extends AbstractPromise with Promise[T] {
+class DefaultPromise[T](implicit val executor: ExecutionContext) extends AbstractPromise with Promise[T] {
   self ⇒
 
   import DefaultPromise.{ FState, Success, Failure, Pending }
@@ -759,7 +785,7 @@ class DefaultPromise[T](implicit val dispatcher: MessageDispatcher) extends Abst
   }
 
   private final def notifyCompleted(func: Either[Throwable, T] ⇒ Unit, result: Either[Throwable, T]) {
-    try { func(result) } catch { case e ⇒ dispatcher.prerequisites.eventStream.publish(Error(e, "Future", "Future onComplete-callback raised an exception")) }
+    try { func(result) } catch { case e ⇒ logError("Future onComplete-callback raised an exception", e) }
   }
 }
 
@@ -767,7 +793,7 @@ class DefaultPromise[T](implicit val dispatcher: MessageDispatcher) extends Abst
  * An already completed Future is seeded with it's result at creation, is useful for when you are participating in
  * a Future-composition but you already have a value to contribute.
  */
-final class KeptPromise[T](suppliedValue: Either[Throwable, T])(implicit val dispatcher: MessageDispatcher) extends Promise[T] {
+final class KeptPromise[T](suppliedValue: Either[Throwable, T])(implicit val executor: ExecutionContext) extends Promise[T] {
   val value = Some(resolve(suppliedValue))
 
   def tryComplete(value: Either[Throwable, T]): Boolean = true
diff --git a/akka-actor/src/main/scala/akka/serialization/Serialization.scala b/akka-actor/src/main/scala/akka/serialization/Serialization.scala
index d1764e8390..7fe3703150 100644
--- a/akka-actor/src/main/scala/akka/serialization/Serialization.scala
+++ b/akka-actor/src/main/scala/akka/serialization/Serialization.scala
@@ -14,18 +14,26 @@ import akka.actor.{ Extension, ActorSystem, ActorSystemImpl }
 case class NoSerializerFoundException(m: String) extends AkkaException(m)
 
 object Serialization {
-
-  // TODO ensure that these are always set (i.e. withValue()) when doing deserialization
-  val currentSystem = new DynamicVariable[ActorSystemImpl](null)
+  /**
+   * This holds a reference to the current ActorSystem (the surrounding context)
+   * during serialization and deserialization.
+   *
+   * If you are using Serializers yourself, outside of SerializationExtension,
+   * you'll need to surround the serialization/deserialization with:
+   *
+   * currentSystem.withValue(system) {
+   *   ...code...
+   * }
+   */
+  val currentSystem = new DynamicVariable[ActorSystem](null)
 
   class Settings(val config: Config) {
 
     import scala.collection.JavaConverters._
     import config._
 
-    val Serializers: Map[String, String] = {
-      toStringMap(getConfig("akka.actor.serializers"))
-    }
+    val Serializers: Map[String, String] =
+      getConfig("akka.actor.serializers").root.unwrapped.asScala.toMap.map { case (k, v) ⇒ (k, v.toString) }
 
     val SerializationBindings: Map[String, Seq[String]] = {
       val configPath = "akka.actor.serialization-bindings"
@@ -40,9 +48,6 @@ object Serialization {
 
       }
     }
-
-    private def toStringMap(mapConfig: Config): Map[String, String] =
-      mapConfig.root.unwrapped.asScala.toMap.map { case (k, v) ⇒ (k, v.toString) }
   }
 }
 
@@ -55,27 +60,53 @@ class Serialization(val system: ActorSystemImpl) extends Extension {
 
   val settings = new Settings(system.settings.config)
 
-  //TODO document me
+  /**
+   * Serializes the given AnyRef/java.lang.Object according to the Serialization configuration
+   * to either an Array of Bytes or an Exception if one was thrown.
+   */
   def serialize(o: AnyRef): Either[Exception, Array[Byte]] =
     try { Right(findSerializerFor(o).toBinary(o)) } catch { case e: Exception ⇒ Left(e) }
 
-  //TODO document me
+  /**
+   * Deserializes the given array of bytes using the specified serializer id,
+   * using the optional type hint to the Serializer and the optional ClassLoader ot load it into.
+   * Returns either the resulting object or an Exception if one was thrown.
+   */
+  def deserialize(bytes: Array[Byte],
+                  serializerId: Int,
+                  clazz: Option[Class[_]],
+                  classLoader: Option[ClassLoader]): Either[Exception, AnyRef] =
+    try {
+      currentSystem.withValue(system) {
+        Right(serializerByIdentity(serializerId).fromBinary(bytes, clazz, classLoader))
+      }
+    } catch { case e: Exception ⇒ Left(e) }
+
+  /**
+   * Deserializes the given array of bytes using the specified type to look up what Serializer should be used.
+   * You can specify an optional ClassLoader to load the object into.
+   * Returns either the resulting object or an Exception if one was thrown.
+   */
   def deserialize(
     bytes: Array[Byte],
     clazz: Class[_],
     classLoader: Option[ClassLoader]): Either[Exception, AnyRef] =
     try {
-      currentSystem.withValue(system) {
-        Right(serializerFor(clazz).fromBinary(bytes, Some(clazz), classLoader))
-      }
+      currentSystem.withValue(system) { Right(serializerFor(clazz).fromBinary(bytes, Some(clazz), classLoader)) }
     } catch { case e: Exception ⇒ Left(e) }
 
+  /**
+   * Returns the Serializer configured for the given object, returns the NullSerializer if it's null,
+   * falls back to the Serializer named "default"
+   */
   def findSerializerFor(o: AnyRef): Serializer = o match {
     case null  ⇒ NullSerializer
     case other ⇒ serializerFor(other.getClass)
   }
 
-  //TODO document me
+  /**
+   * Returns the configured Serializer for the given Class, falls back to the Serializer named "default"
+   */
   def serializerFor(clazz: Class[_]): Serializer = //TODO fall back on BestMatchClass THEN default AND memoize the lookups
     serializerMap.get(clazz.getName).getOrElse(serializers("default"))
 
@@ -85,6 +116,9 @@ class Serialization(val system: ActorSystemImpl) extends Extension {
   def serializerOf(serializerFQN: String): Either[Exception, Serializer] =
     ReflectiveAccess.createInstance(serializerFQN, ReflectiveAccess.noParams, ReflectiveAccess.noArgs)
 
+  /**
+   * FIXME implement support for this
+   */
   private def serializerForBestMatchClass(cl: Class[_]): Either[Exception, Serializer] = {
     if (bindings.isEmpty)
       Left(NoSerializerFoundException("No mapping serializer found for " + cl))
@@ -116,14 +150,11 @@ class Serialization(val system: ActorSystemImpl) extends Extension {
    *  bindings is a Map whose keys = FQN of class that is serializable and values = the alias of the serializer to be used
    */
   lazy val bindings: Map[String, String] = {
-    val configBindings = settings.SerializationBindings
-    configBindings.foldLeft(Map[String, String]()) {
-      case (result, (k: String, vs: Seq[_])) ⇒
-        //All keys which are lists, take the Strings from them and Map them
-        result ++ (vs collect { case v: String ⇒ (v, k) })
-      case (result, x) ⇒
-        //For any other values, just skip them
-        result
+    settings.SerializationBindings.foldLeft(Map[String, String]()) {
+      //All keys which are lists, take the Strings from them and Map them
+      case (result, (k: String, vs: Seq[_])) ⇒ result ++ (vs collect { case v: String ⇒ (v, k) })
+      //For any other values, just skip them
+      case (result, _)                       ⇒ result
     }
   }
 
@@ -133,9 +164,9 @@ class Serialization(val system: ActorSystemImpl) extends Extension {
   lazy val serializerMap: Map[String, Serializer] = bindings mapValues serializers
 
   /**
-   * Maps from a Serializer.Identifier (Byte) to a Serializer instance (optimization)
+   * Maps from a Serializer Identity (Int) to a Serializer instance (optimization)
    */
-  lazy val serializerByIdentity: Map[Serializer.Identifier, Serializer] =
+  lazy val serializerByIdentity: Map[Int, Serializer] =
     Map(NullSerializer.identifier -> NullSerializer) ++ serializers map { case (_, v) ⇒ (v.identifier, v) }
 }
 
diff --git a/akka-actor/src/main/scala/akka/serialization/SerializationExtension.scala b/akka-actor/src/main/scala/akka/serialization/SerializationExtension.scala
index 851e598221..6bc47ecf41 100644
--- a/akka-actor/src/main/scala/akka/serialization/SerializationExtension.scala
+++ b/akka-actor/src/main/scala/akka/serialization/SerializationExtension.scala
@@ -5,6 +5,10 @@ package akka.serialization
 
 import akka.actor.{ ActorSystem, ExtensionId, ExtensionIdProvider, ActorSystemImpl }
 
+/**
+ * SerializationExtension is an Akka Extension to interact with the Serialization
+ * that is built into Akka
+ */
 object SerializationExtension extends ExtensionId[Serialization] with ExtensionIdProvider {
   override def get(system: ActorSystem): Serialization = super.get(system)
   override def lookup = SerializationExtension
diff --git a/akka-actor/src/main/scala/akka/serialization/Serializer.scala b/akka-actor/src/main/scala/akka/serialization/Serializer.scala
index 893e974859..a39f77b210 100644
--- a/akka-actor/src/main/scala/akka/serialization/Serializer.scala
+++ b/akka-actor/src/main/scala/akka/serialization/Serializer.scala
@@ -7,38 +7,67 @@ package akka.serialization
 import java.io.{ ObjectOutputStream, ByteArrayOutputStream, ObjectInputStream, ByteArrayInputStream }
 import akka.util.ClassLoaderObjectInputStream
 
-object Serializer {
-  val defaultSerializerName = classOf[JavaSerializer].getName
-  type Identifier = Byte
-}
-
 /**
  * A Serializer represents a bimap between an object and an array of bytes representing that object
  */
 trait Serializer extends scala.Serializable {
   /**
-   * Completely unique Byte value to identify this implementation of Serializer, used to optimize network traffic
+   * Completely unique value to identify this implementation of Serializer, used to optimize network traffic
    * Values from 0 to 16 is reserved for Akka internal usage
    */
-  def identifier: Serializer.Identifier
+  def identifier: Int
 
   /**
    * Serializes the given object into an Array of Byte
    */
   def toBinary(o: AnyRef): Array[Byte]
 
+  /**
+   * Returns whether this serializer needs a manifest in the fromBinary method
+   */
+  def includeManifest: Boolean
+
+  /**
+   * Deserializes the given Array of Bytes into an AnyRef
+   */
+  def fromBinary(bytes: Array[Byte]): AnyRef = fromBinary(bytes, None, None)
+
+  /**
+   * Deserializes the given Array of Bytes into an AnyRef with an optional type hint
+   */
+  def fromBinary(bytes: Array[Byte], manifest: Option[Class[_]]): AnyRef = fromBinary(bytes, manifest, None)
+
   /**
    *  Produces an object from an array of bytes, with an optional type-hint and a classloader to load the class into
    */
-  def fromBinary(bytes: Array[Byte], clazz: Option[Class[_]] = None, classLoader: Option[ClassLoader] = None): AnyRef
+  def fromBinary(bytes: Array[Byte], manifest: Option[Class[_]], classLoader: Option[ClassLoader]): AnyRef
+}
+
+/**
+ * Java API for creating a Serializer
+ */
+abstract class JSerializer extends Serializer {
+  def fromBinary(bytes: Array[Byte], manifest: Option[Class[_]] = None, classLoader: Option[ClassLoader] = None): AnyRef =
+    fromBinary(bytes, manifest.orNull, classLoader.orNull)
+
+  /**
+   * This method should be overridden,
+   * manifest and classLoader may be null.
+   */
+  def fromBinary(bytes: Array[Byte], manifest: Class[_], classLoader: ClassLoader): AnyRef
 }
 
 object JavaSerializer extends JavaSerializer
 object NullSerializer extends NullSerializer
 
+/**
+ * This Serializer uses standard Java Serialization
+ */
 class JavaSerializer extends Serializer {
 
-  def identifier = 1: Byte
+  def includeManifest: Boolean = false
+
+  def identifier = 1
 
   def toBinary(o: AnyRef): Array[Byte] = {
     val bos = new ByteArrayOutputStream
@@ -59,11 +88,13 @@ class JavaSerializer extends Serializer {
   }
 }
 
+/**
+ * This is a special Serializer that Serializes and deserializes nulls only
+ */
 class NullSerializer extends Serializer {
-
   val nullAsBytes = Array[Byte]()
-
-  def identifier = 0: Byte
+  def includeManifest: Boolean = false
+  def identifier = 0
   def toBinary(o: AnyRef) = nullAsBytes
   def fromBinary(bytes: Array[Byte], clazz: Option[Class[_]] = None, classLoader: Option[ClassLoader] = None): AnyRef = null
 }
diff --git a/akka-docs/general/addressing.rst b/akka-docs/general/addressing.rst
index a9485fd1b2..cc87da61f3 100644
--- a/akka-docs/general/addressing.rst
+++ b/akka-docs/general/addressing.rst
@@ -175,7 +175,7 @@ Looking up Actors by Concrete Path
 In addition, actor references may be looked up using the
 :meth:`ActorSystem.actorFor` method, which returns an (unverified) local,
 remote or clustered actor reference. Sending messages to such a reference or
-attempting to observe its livelyhood will traverse the actor hierarchy of the
+attempting to observe its liveness will traverse the actor hierarchy of the
 actor system from top to bottom by passing messages from parent to child until
 either the target is reached or failure is certain, i.e. a name in the path
 does not exist (in practice this process will be optimized using caches, but it
diff --git a/akka-docs/java/code/akka/docs/serialization/SerializationDocTest.scala b/akka-docs/java/code/akka/docs/serialization/SerializationDocTest.scala
new file mode 100644
index 0000000000..538756d48a
--- /dev/null
+++ b/akka-docs/java/code/akka/docs/serialization/SerializationDocTest.scala
@@ -0,0 +1,8 @@
+/**
+ * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
+ */
+package akka.docs.serialization
+
+import org.scalatest.junit.JUnitSuite
+
+class SerializationDocTest extends SerializationDocTestBase with JUnitSuite
diff --git a/akka-docs/java/code/akka/docs/serialization/SerializationDocTestBase.java b/akka-docs/java/code/akka/docs/serialization/SerializationDocTestBase.java
new file mode 100644
index 0000000000..677fd051b5
--- /dev/null
+++ b/akka-docs/java/code/akka/docs/serialization/SerializationDocTestBase.java
@@ -0,0 +1,136 @@
+/**
+ * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
+ */
+package akka.docs.serialization;
+
+import akka.serialization.JSerializer;
+import akka.serialization.Serialization;
+import akka.serialization.SerializationExtension;
+import akka.serialization.Serializer;
+import org.junit.Test;
+import static org.junit.Assert.*;
+//#imports
+
+import akka.serialization.*;
+import akka.actor.ActorSystem;
+import com.typesafe.config.*;
+
+//#imports
+
+public class SerializationDocTestBase {
+  //#my-own-serializer
+    public static class MyOwnSerializer extends JSerializer {
+
+      // This is whether "fromBinary" requires a "clazz" or not
+      @Override public boolean includeManifest() {
+          return false;
+      }
+
+      // Pick a unique identifier for your Serializer,
+      // you've got a couple of billions to choose from,
+      // 0 - 16 is reserved by Akka itself
+      @Override public int identifier() {
+          return 1234567;
+      }
+
+      // "toBinary" serializes the given object to an Array of Bytes
+      @Override public byte[] toBinary(Object obj) {
+        // Put the code that serializes the object here
+        //#...
+        return new byte[0];
+        //#...
+      }
+
+      // "fromBinary" deserializes the given array,
+      // using the type hint (if any, see "includeManifest" above)
+      // into the optionally provided classLoader.
+      @Override public Object fromBinary(byte[] bytes,
+                     Class clazz,
+                     ClassLoader classLoader) {
+        // Put your code that deserializes here
+        //#...
+        return null;
+        //#...
+      }
+    }
+//#my-own-serializer
+    @Test public void haveExamples() {
+        /*
+        //#serialize-messages-config
+        akka {
+          actor {
+            serialize-messages = on
+          }
+        }
+        //#serialize-messages-config
+
+        //#serialize-creators-config
+        akka {
+          actor {
+            serialize-creators = on
+          }
+        }
+        //#serialize-creators-config
+
+
+        //#serialize-serializers-config
+        akka {
+          actor {
+            serializers {
+              default = "akka.serialization.JavaSerializer"
+
+              myown = "akka.docs.serialization.MyOwnSerializer"
+            }
+          }
+        }
+        //#serialize-serializers-config
+
+        //#serialization-bindings-config
+        akka {
+          actor {
+            serializers {
+              default = "akka.serialization.JavaSerializer"
+              java = "akka.serialization.JavaSerializer"
+              myown = "akka.docs.serialization.MyOwnSerializer"
+            }
+
+            serialization-bindings {
+             java = ["java.lang.String",
+                     "app.my.Customer"]
+             myown = ["my.own.BusinessObject",
+                      "something.equally.Awesome",
+                      "java.lang.Boolean"]
+           }
+          }
+        }
+        //#serialization-bindings-config
+        */
+    }
+
+    @Test public void demonstrateTheProgrammaticAPI() {
+      //#programmatic
+      ActorSystem system = ActorSystem.create("example");
+
+      // Get the Serialization Extension
+      Serialization serialization = SerializationExtension.get(system);
+
+      // Have something to serialize
+      String original = "woohoo";
+
+      // Find the Serializer for it
+      Serializer serializer = serialization.findSerializerFor(original);
+
+      // Turn it into bytes
+      byte[] bytes = serializer.toBinary(original);
+
+      // Turn it back into an object,
+      // the nulls are for the class manifest and for the classloader
+      String back = (String)serializer.fromBinary(bytes);
+
+      // Voilá!
+      assertEquals(original, back);
+
+      //#programmatic
+      system.shutdown();
+    }
+}
diff --git a/akka-docs/java/serialization.rst b/akka-docs/java/serialization.rst
index 3d30f62864..1ead054d75 100644
--- a/akka-docs/java/serialization.rst
+++ b/akka-docs/java/serialization.rst
@@ -5,8 +5,90 @@
  Serialization (Java)
 #####################
 
-Serialization will soon be documented.
+.. sidebar:: Contents
 
-Until then we refer to the following section in the configuration file:
+   .. contents:: :local:
 
-* `Serializers <https://github.com/jboner/akka/blob/master/akka-actor/src/main/resources/reference.conf#L180>`_
\ No newline at end of file
+Akka has a built-in Extension for serialization,
+and it is both possible to use the built-in serializers and to write your own.
+
+The serialization mechanism is both used by Akka internally to serialize messages,
+and available for ad-hoc serialization of whatever you might need it for.
+
+Usage
+=====
+
+Configuration
+-------------
+
+For Akka to know which ``Serializer`` to use for what, you need edit your Akka Configuration,
+in the "akka.actor.serializers"-section you bind names to implementations of the ``akka.serialization.Serializer``
+you wish to use, like this:
+
+.. includecode:: code/akka/docs/serialization/SerializationDocTestBase.java#serialize-serializers-config
+
+.. note::
+
+   The name ``default`` is special in the sense that the ``Serializer``
+   mapped to it will be used as default.
+
+After you've bound names to different implementations of ``Serializer`` you need to wire which classes
+should be serialized using which ``Serializer``, this is done in the "akka.actor.serialization-bindings"-section:
+
+.. includecode:: code/akka/docs/serialization/SerializationDocTestBase.java#serialization-bindings-config
+
+.. note::
+
+   Akka currently only checks for absolute equality of Classes, i.e. it does not yet check ``isAssignableFrom``,
+   this means that you'll need to list the specific classes.
+
+Verification
+------------
+
+If you want to verify that your messages are serializable you can enable the following config option:
+
+.. includecode:: code/akka/docs/serialization/SerializationDocTestBase.java#serialize-messages-config
+
+.. warning::
+
+   We only recommend using the config option turned on when you're running tests.
+   It is completely pointless to have it turned on in other scenarios.
+
+If you want to verify that your ``Props`` are serializable you can enable the following config option:
+
+.. includecode:: code/akka/docs/serialization/SerializationDocTestBase.java#serialize-creators-config
+
+.. warning::
+
+   We only recommend using the config option turned on when you're running tests.
+   It is completely pointless to have it turned on in other scenarios.
+
+Programmatic
+------------
+
+If you want to programmatically serialize/deserialize using Akka Serialization,
+here's some examples:
+
+.. includecode:: code/akka/docs/serialization/SerializationDocTestBase.java
+   :include: imports,programmatic
+
+For more information, have a look at the ``ScalaDoc`` for ``akka.serialization._``
+
+Customization
+=============
+
+So, lets say that you want to create your own ``Serializer``,
+you saw the ``akka.docs.serialization.MyOwnSerializer`` in the config example above?
+
+Creating new Serializers
+------------------------
+
+First you need to create a class definition of your ``Serializer``,
+which is done by extending ``akka.serialization.JSerializer``, like this:
+
+.. includecode:: code/akka/docs/serialization/SerializationDocTestBase.java
+   :include: imports,my-own-serializer
+   :exclude: ...
+
+Then you only need to fill in the blanks, bind it to a name in your Akka Configuration and then
+list which classes that should be serialized using it.
\ No newline at end of file
diff --git a/akka-docs/scala/code/akka/docs/future/FutureDocSpec.scala b/akka-docs/scala/code/akka/docs/future/FutureDocSpec.scala
index fa42c0c402..1b6a755ede 100644
--- a/akka-docs/scala/code/akka/docs/future/FutureDocSpec.scala
+++ b/akka-docs/scala/code/akka/docs/future/FutureDocSpec.scala
@@ -70,8 +70,6 @@ class FutureDocSpec extends AkkaSpec {
     import akka.dispatch.Future
     import akka.util.duration._
 
-    implicit def dispatcher = system.dispatcher
-
     val future = Future {
       "Hello" + "World"
     }
diff --git a/akka-docs/scala/code/akka/docs/serialization/SerializationDocSpec.scala b/akka-docs/scala/code/akka/docs/serialization/SerializationDocSpec.scala
new file mode 100644
index 0000000000..ea6bdf8c33
--- /dev/null
+++ b/akka-docs/scala/code/akka/docs/serialization/SerializationDocSpec.scala
@@ -0,0 +1,157 @@
+/**
+ * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
+ */
+package akka.docs.serialization
+
+import org.scalatest.matchers.MustMatchers
+import akka.testkit._
+//#imports
+import akka.actor.ActorSystem
+import akka.serialization._
+import com.typesafe.config.ConfigFactory
+
+//#imports
+
+//#my-own-serializer
+class MyOwnSerializer extends Serializer {
+
+  // This is whether "fromBinary" requires a "clazz" or not
+  def includeManifest: Boolean = false
+
+  // Pick a unique identifier for your Serializer,
+  // you've got a couple of billions to choose from,
+  // 0 - 16 is reserved by Akka itself
+  def identifier = 1234567
+
+  // "toBinary" serializes the given object to an Array of Bytes
+  def toBinary(obj: AnyRef): Array[Byte] = {
+    // Put the code that serializes the object here
+    //#...
+    Array[Byte]()
+    //#...
+  }
+
+  // "fromBinary" deserializes the given array,
+  // using the type hint (if any, see "includeManifest" above)
+  // into the optionally provided classLoader.
+  def fromBinary(bytes: Array[Byte],
+                 clazz: Option[Class[_]],
+                 classLoader: Option[ClassLoader] = None): AnyRef = {
+    // Put your code that deserializes here
+    //#...
+    null
+    //#...
+  }
+}
+//#my-own-serializer
+
+class SerializationDocSpec extends AkkaSpec {
+  "demonstrate configuration of serialize messages" in {
+    //#serialize-messages-config
+    val config = ConfigFactory.parseString("""
+      akka {
+        actor {
+          serialize-messages = on
+        }
+      }
+    """)
+    //#serialize-messages-config
+    val a = ActorSystem("system", config)
+    a.settings.SerializeAllMessages must be(true)
+    a.shutdown()
+  }
+
+  "demonstrate configuration of serialize creators" in {
+    //#serialize-creators-config
+    val config = ConfigFactory.parseString("""
+      akka {
+        actor {
+          serialize-creators = on
+        }
+      }
+    """)
+    //#serialize-creators-config
+    val a = ActorSystem("system", config)
+    a.settings.SerializeAllCreators must be(true)
+    a.shutdown()
+  }
+
+  "demonstrate configuration of serializers" in {
+    //#serialize-serializers-config
+    val config = ConfigFactory.parseString("""
+      akka {
+        actor {
+          serializers {
+            default = "akka.serialization.JavaSerializer"
+
+            myown = "akka.docs.serialization.MyOwnSerializer"
+          }
+        }
+      }
+    """)
+    //#serialize-serializers-config
+    val a = ActorSystem("system", config)
+    SerializationExtension(a).serializers("default").getClass.getName must equal("akka.serialization.JavaSerializer")
+    SerializationExtension(a).serializers("myown").getClass.getName must equal("akka.docs.serialization.MyOwnSerializer")
+    a.shutdown()
+  }
+
+  "demonstrate configuration of serialization-bindings" in {
+    //#serialization-bindings-config
+    val config = ConfigFactory.parseString("""
+      akka {
+        actor {
+          serializers {
+            default = "akka.serialization.JavaSerializer"
+            java = "akka.serialization.JavaSerializer"
+            myown = "akka.docs.serialization.MyOwnSerializer"
+          }
+
+          serialization-bindings {
+           java = ["java.lang.String",
+                   "app.my.Customer"]
+           myown = ["my.own.BusinessObject",
+                    "something.equally.Awesome",
+                    "java.lang.Boolean"]
+         }
+        }
+      }
+    """)
+    //#serialization-bindings-config
+    val a = ActorSystem("system", config)
+    SerializationExtension(a).serializers("default").getClass.getName must equal("akka.serialization.JavaSerializer")
+    SerializationExtension(a).serializers("java").getClass.getName must equal("akka.serialization.JavaSerializer")
+    SerializationExtension(a).serializers("myown").getClass.getName must equal("akka.docs.serialization.MyOwnSerializer")
+    SerializationExtension(a).serializerFor(classOf[String]).getClass.getName must equal("akka.serialization.JavaSerializer")
+    SerializationExtension(a).serializerFor(classOf[java.lang.Boolean]).getClass.getName must equal("akka.docs.serialization.MyOwnSerializer")
+    a.shutdown()
+  }
+
+  "demonstrate the programmatic API" in {
+    //#programmatic
+    val system = ActorSystem("example")
+
+    // Get the Serialization Extension
+    val serialization = SerializationExtension(system)
+
+    // Have something to serialize
+    val original = "woohoo"
+
+    // Find the Serializer for it
+    val serializer = serialization.findSerializerFor(original)
+
+    // Turn it into bytes
+    val bytes = serializer.toBinary(original)
+
+    // Turn it back into an object
+    val back = serializer.fromBinary(bytes,
+      manifest = None,
+      classLoader = None)
+
+    // Voilá!
+    back must equal(original)
+
+    //#programmatic
+    system.shutdown()
+  }
+}
diff --git a/akka-docs/scala/serialization.rst b/akka-docs/scala/serialization.rst
index 0f7dce63b4..716bcc4eb7 100644
--- a/akka-docs/scala/serialization.rst
+++ b/akka-docs/scala/serialization.rst
@@ -5,8 +5,89 @@
  Serialization (Scala)
 ######################
 
-Serialization will soon be documented.
+.. sidebar:: Contents
 
-Until then we refer to the following section in the configuration file:
+   .. contents:: :local:
 
-* `Serializers <https://github.com/jboner/akka/blob/master/akka-actor/src/main/resources/reference.conf#L180>`_
\ No newline at end of file
+Akka has a built-in Extension for serialization,
+and it is both possible to use the built-in serializers and to write your own.
+
+The serialization mechanism is both used by Akka internally to serialize messages,
+and available for ad-hoc serialization of whatever you might need it for.
+
+Usage
+=====
+
+Configuration
+-------------
+
+For Akka to know which ``Serializer`` to use for what, you need edit your Akka Configuration,
+in the "akka.actor.serializers"-section you bind names to implementations of the ``akka.serialization.Serializer``
+you wish to use, like this:
+
+.. includecode:: code/akka/docs/serialization/SerializationDocSpec.scala#serialize-serializers-config
+
+.. note::
+
+   The name ``default`` is special in the sense that the ``Serializer``
+   mapped to it will be used as default.
+
+After you've bound names to different implementations of ``Serializer`` you need to wire which classes
+should be serialized using which ``Serializer``, this is done in the "akka.actor.serialization-bindings"-section:
+
+.. includecode:: code/akka/docs/serialization/SerializationDocSpec.scala#serialization-bindings-config
+
+.. note::
+
+   Akka currently only checks for absolute equality of Classes, i.e. it does not yet check ``isAssignableFrom``,
+   this means that you'll need to list the specific classes.
+
+Verification
+------------
+
+If you want to verify that your messages are serializable you can enable the following config option:
+
+.. includecode:: code/akka/docs/serialization/SerializationDocSpec.scala#serialize-messages-config
+
+.. warning::
+
+   We only recommend using the config option turned on when you're running tests.
+   It is completely pointless to have it turned on in other scenarios.
+
+If you want to verify that your ``Props`` are serializable you can enable the following config option:
+
+.. includecode:: code/akka/docs/serialization/SerializationDocSpec.scala#serialize-creators-config
+
+.. warning::
+
+   We only recommend using the config option turned on when you're running tests.
+   It is completely pointless to have it turned on in other scenarios.
+
+Programmatic
+------------
+
+If you want to programmatically serialize/deserialize using Akka Serialization,
+here's some examples:
+
+.. includecode:: code/akka/docs/serialization/SerializationDocSpec.scala
+   :include: imports,programmatic
+
+For more information, have a look at the ``ScalaDoc`` for ``akka.serialization._``
+
+Customization
+=============
+
+So, lets say that you want to create your own ``Serializer``,
+you saw the ``akka.docs.serialization.MyOwnSerializer`` in the config example above?
+
+Creating new Serializers
+------------------------
+
+First you need to create a class definition of your ``Serializer`` like so:
+
+.. includecode:: code/akka/docs/serialization/SerializationDocSpec.scala
+   :include: imports,my-own-serializer
+   :exclude: ...
+
+Then you only need to fill in the blanks, bind it to a name in your Akka Configuration and then
+list which classes that should be serialized using it.
\ No newline at end of file
diff --git a/akka-remote/src/main/java/akka/remote/RemoteProtocol.java b/akka-remote/src/main/java/akka/remote/RemoteProtocol.java
index 663e534bb2..90c493e176 100644
--- a/akka-remote/src/main/java/akka/remote/RemoteProtocol.java
+++ b/akka-remote/src/main/java/akka/remote/RemoteProtocol.java
@@ -460,7 +460,7 @@ public final class RemoteProtocol {
       private static Builder create() {
         return new Builder();
       }
-      
+
       public Builder clear() {
         super.clear();
         if (messageBuilder_ == null) {
@@ -477,20 +477,20 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000002);
         return this;
       }
-      
+
       public Builder clone() {
         return create().mergeFrom(buildPartial());
       }
-      
+
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
         return akka.remote.RemoteProtocol.AkkaRemoteProtocol.getDescriptor();
       }
-      
+
       public akka.remote.RemoteProtocol.AkkaRemoteProtocol getDefaultInstanceForType() {
         return akka.remote.RemoteProtocol.AkkaRemoteProtocol.getDefaultInstance();
       }
-      
+
       public akka.remote.RemoteProtocol.AkkaRemoteProtocol build() {
         akka.remote.RemoteProtocol.AkkaRemoteProtocol result = buildPartial();
         if (!result.isInitialized()) {
@@ -498,7 +498,7 @@ public final class RemoteProtocol {
         }
         return result;
       }
-      
+
       private akka.remote.RemoteProtocol.AkkaRemoteProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
         akka.remote.RemoteProtocol.AkkaRemoteProtocol result = buildPartial();
@@ -508,7 +508,7 @@ public final class RemoteProtocol {
         }
         return result;
       }
-      
+
       public akka.remote.RemoteProtocol.AkkaRemoteProtocol buildPartial() {
         akka.remote.RemoteProtocol.AkkaRemoteProtocol result = new akka.remote.RemoteProtocol.AkkaRemoteProtocol(this);
         int from_bitField0_ = bitField0_;
@@ -533,7 +533,7 @@ public final class RemoteProtocol {
         onBuilt();
         return result;
       }
-      
+
       public Builder mergeFrom(com.google.protobuf.Message other) {
         if (other instanceof akka.remote.RemoteProtocol.AkkaRemoteProtocol) {
           return mergeFrom((akka.remote.RemoteProtocol.AkkaRemoteProtocol)other);
@@ -542,7 +542,7 @@ public final class RemoteProtocol {
           return this;
         }
       }
-      
+
       public Builder mergeFrom(akka.remote.RemoteProtocol.AkkaRemoteProtocol other) {
         if (other == akka.remote.RemoteProtocol.AkkaRemoteProtocol.getDefaultInstance()) return this;
         if (other.hasMessage()) {
@@ -554,23 +554,23 @@ public final class RemoteProtocol {
         this.mergeUnknownFields(other.getUnknownFields());
         return this;
       }
-      
+
       public final boolean isInitialized() {
         if (hasMessage()) {
           if (!getMessage().isInitialized()) {
-            
+
             return false;
           }
         }
         if (hasInstruction()) {
           if (!getInstruction().isInitialized()) {
-            
+
             return false;
           }
         }
         return true;
       }
-      
+
       public Builder mergeFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
@@ -615,9 +615,9 @@ public final class RemoteProtocol {
           }
         }
       }
-      
+
       private int bitField0_;
-      
+
       // optional .RemoteMessageProtocol message = 1;
       private akka.remote.RemoteProtocol.RemoteMessageProtocol message_ = akka.remote.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
@@ -695,7 +695,7 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.remote.RemoteProtocol.RemoteMessageProtocol, akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder, akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.RemoteMessageProtocol, akka.remote.RemoteProtocol.RemoteMessageProtocol.Builder, akka.remote.RemoteProtocol.RemoteMessageProtocolOrBuilder>
           getMessageFieldBuilder() {
         if (messageBuilder_ == null) {
           messageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
@@ -707,7 +707,7 @@ public final class RemoteProtocol {
         }
         return messageBuilder_;
       }
-      
+
       // optional .RemoteControlProtocol instruction = 2;
       private akka.remote.RemoteProtocol.RemoteControlProtocol instruction_ = akka.remote.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
@@ -785,7 +785,7 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.remote.RemoteProtocol.RemoteControlProtocol, akka.remote.RemoteProtocol.RemoteControlProtocol.Builder, akka.remote.RemoteProtocol.RemoteControlProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.RemoteControlProtocol, akka.remote.RemoteProtocol.RemoteControlProtocol.Builder, akka.remote.RemoteProtocol.RemoteControlProtocolOrBuilder>
           getInstructionFieldBuilder() {
         if (instructionBuilder_ == null) {
           instructionBuilder_ = new com.google.protobuf.SingleFieldBuilder<
@@ -797,42 +797,42 @@ public final class RemoteProtocol {
         }
         return instructionBuilder_;
       }
-      
+
       // @@protoc_insertion_point(builder_scope:AkkaRemoteProtocol)
     }
-    
+
     static {
       defaultInstance = new AkkaRemoteProtocol(true);
       defaultInstance.initFields();
     }
-    
+
     // @@protoc_insertion_point(class_scope:AkkaRemoteProtocol)
   }
-  
+
   public interface RemoteMessageProtocolOrBuilder
       extends com.google.protobuf.MessageOrBuilder {
-    
+
     // required .ActorRefProtocol recipient = 1;
     boolean hasRecipient();
     akka.remote.RemoteProtocol.ActorRefProtocol getRecipient();
     akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder getRecipientOrBuilder();
-    
+
     // required .MessageProtocol message = 2;
     boolean hasMessage();
     akka.remote.RemoteProtocol.MessageProtocol getMessage();
     akka.remote.RemoteProtocol.MessageProtocolOrBuilder getMessageOrBuilder();
-    
+
     // optional .ActorRefProtocol sender = 4;
     boolean hasSender();
     akka.remote.RemoteProtocol.ActorRefProtocol getSender();
     akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder getSenderOrBuilder();
-    
+
     // repeated .MetadataEntryProtocol metadata = 5;
-    java.util.List<akka.remote.RemoteProtocol.MetadataEntryProtocol> 
+    java.util.List<akka.remote.RemoteProtocol.MetadataEntryProtocol>
         getMetadataList();
     akka.remote.RemoteProtocol.MetadataEntryProtocol getMetadata(int index);
     int getMetadataCount();
-    java.util.List<? extends akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder> 
+    java.util.List<? extends akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder>
         getMetadataOrBuilderList();
     akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder getMetadataOrBuilder(
         int index);
@@ -845,26 +845,26 @@ public final class RemoteProtocol {
       super(builder);
     }
     private RemoteMessageProtocol(boolean noInit) {}
-    
+
     private static final RemoteMessageProtocol defaultInstance;
     public static RemoteMessageProtocol getDefaultInstance() {
       return defaultInstance;
     }
-    
+
     public RemoteMessageProtocol getDefaultInstanceForType() {
       return defaultInstance;
     }
-    
+
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
       return akka.remote.RemoteProtocol.internal_static_RemoteMessageProtocol_descriptor;
     }
-    
+
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
       return akka.remote.RemoteProtocol.internal_static_RemoteMessageProtocol_fieldAccessorTable;
     }
-    
+
     private int bitField0_;
     // required .ActorRefProtocol recipient = 1;
     public static final int RECIPIENT_FIELD_NUMBER = 1;
@@ -878,7 +878,7 @@ public final class RemoteProtocol {
     public akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder getRecipientOrBuilder() {
       return recipient_;
     }
-    
+
     // required .MessageProtocol message = 2;
     public static final int MESSAGE_FIELD_NUMBER = 2;
     private akka.remote.RemoteProtocol.MessageProtocol message_;
@@ -891,7 +891,7 @@ public final class RemoteProtocol {
     public akka.remote.RemoteProtocol.MessageProtocolOrBuilder getMessageOrBuilder() {
       return message_;
     }
-    
+
     // optional .ActorRefProtocol sender = 4;
     public static final int SENDER_FIELD_NUMBER = 4;
     private akka.remote.RemoteProtocol.ActorRefProtocol sender_;
@@ -904,14 +904,14 @@ public final class RemoteProtocol {
     public akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder getSenderOrBuilder() {
       return sender_;
     }
-    
+
     // repeated .MetadataEntryProtocol metadata = 5;
     public static final int METADATA_FIELD_NUMBER = 5;
     private java.util.List<akka.remote.RemoteProtocol.MetadataEntryProtocol> metadata_;
     public java.util.List<akka.remote.RemoteProtocol.MetadataEntryProtocol> getMetadataList() {
       return metadata_;
     }
-    public java.util.List<? extends akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder> 
+    public java.util.List<? extends akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder>
         getMetadataOrBuilderList() {
       return metadata_;
     }
@@ -925,7 +925,7 @@ public final class RemoteProtocol {
         int index) {
       return metadata_.get(index);
     }
-    
+
     private void initFields() {
       recipient_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
       message_ = akka.remote.RemoteProtocol.MessageProtocol.getDefaultInstance();
@@ -936,7 +936,7 @@ public final class RemoteProtocol {
     public final boolean isInitialized() {
       byte isInitialized = memoizedIsInitialized;
       if (isInitialized != -1) return isInitialized == 1;
-      
+
       if (!hasRecipient()) {
         memoizedIsInitialized = 0;
         return false;
@@ -968,7 +968,7 @@ public final class RemoteProtocol {
       memoizedIsInitialized = 1;
       return true;
     }
-    
+
     public void writeTo(com.google.protobuf.CodedOutputStream output)
                         throws java.io.IOException {
       getSerializedSize();
@@ -986,12 +986,12 @@ public final class RemoteProtocol {
       }
       getUnknownFields().writeTo(output);
     }
-    
+
     private int memoizedSerializedSize = -1;
     public int getSerializedSize() {
       int size = memoizedSerializedSize;
       if (size != -1) return size;
-    
+
       size = 0;
       if (((bitField0_ & 0x00000001) == 0x00000001)) {
         size += com.google.protobuf.CodedOutputStream
@@ -1013,14 +1013,14 @@ public final class RemoteProtocol {
       memoizedSerializedSize = size;
       return size;
     }
-    
+
     private static final long serialVersionUID = 0L;
     @java.lang.Override
     protected java.lang.Object writeReplace()
         throws java.io.ObjectStreamException {
       return super.writeReplace();
     }
-    
+
     public static akka.remote.RemoteProtocol.RemoteMessageProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
@@ -1087,14 +1087,14 @@ public final class RemoteProtocol {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    
+
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
     public static Builder newBuilder(akka.remote.RemoteProtocol.RemoteMessageProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
-    
+
     @java.lang.Override
     protected Builder newBuilderForType(
         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
@@ -1108,17 +1108,17 @@ public final class RemoteProtocol {
           getDescriptor() {
         return akka.remote.RemoteProtocol.internal_static_RemoteMessageProtocol_descriptor;
       }
-      
+
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
         return akka.remote.RemoteProtocol.internal_static_RemoteMessageProtocol_fieldAccessorTable;
       }
-      
+
       // Construct using akka.remote.RemoteProtocol.RemoteMessageProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
-      
+
       private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
@@ -1134,7 +1134,7 @@ public final class RemoteProtocol {
       private static Builder create() {
         return new Builder();
       }
-      
+
       public Builder clear() {
         super.clear();
         if (recipientBuilder_ == null) {
@@ -1163,20 +1163,20 @@ public final class RemoteProtocol {
         }
         return this;
       }
-      
+
       public Builder clone() {
         return create().mergeFrom(buildPartial());
       }
-      
+
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
         return akka.remote.RemoteProtocol.RemoteMessageProtocol.getDescriptor();
       }
-      
+
       public akka.remote.RemoteProtocol.RemoteMessageProtocol getDefaultInstanceForType() {
         return akka.remote.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance();
       }
-      
+
       public akka.remote.RemoteProtocol.RemoteMessageProtocol build() {
         akka.remote.RemoteProtocol.RemoteMessageProtocol result = buildPartial();
         if (!result.isInitialized()) {
@@ -1184,7 +1184,7 @@ public final class RemoteProtocol {
         }
         return result;
       }
-      
+
       private akka.remote.RemoteProtocol.RemoteMessageProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
         akka.remote.RemoteProtocol.RemoteMessageProtocol result = buildPartial();
@@ -1194,7 +1194,7 @@ public final class RemoteProtocol {
         }
         return result;
       }
-      
+
       public akka.remote.RemoteProtocol.RemoteMessageProtocol buildPartial() {
         akka.remote.RemoteProtocol.RemoteMessageProtocol result = new akka.remote.RemoteProtocol.RemoteMessageProtocol(this);
         int from_bitField0_ = bitField0_;
@@ -1236,7 +1236,7 @@ public final class RemoteProtocol {
         onBuilt();
         return result;
       }
-      
+
       public Builder mergeFrom(com.google.protobuf.Message other) {
         if (other instanceof akka.remote.RemoteProtocol.RemoteMessageProtocol) {
           return mergeFrom((akka.remote.RemoteProtocol.RemoteMessageProtocol)other);
@@ -1245,7 +1245,7 @@ public final class RemoteProtocol {
           return this;
         }
       }
-      
+
       public Builder mergeFrom(akka.remote.RemoteProtocol.RemoteMessageProtocol other) {
         if (other == akka.remote.RemoteProtocol.RemoteMessageProtocol.getDefaultInstance()) return this;
         if (other.hasRecipient()) {
@@ -1275,7 +1275,7 @@ public final class RemoteProtocol {
               metadataBuilder_ = null;
               metadata_ = other.metadata_;
               bitField0_ = (bitField0_ & ~0x00000008);
-              metadataBuilder_ = 
+              metadataBuilder_ =
                 com.google.protobuf.GeneratedMessage.alwaysUseFieldBuilders ?
                    getMetadataFieldBuilder() : null;
             } else {
@@ -1286,39 +1286,39 @@ public final class RemoteProtocol {
         this.mergeUnknownFields(other.getUnknownFields());
         return this;
       }
-      
+
       public final boolean isInitialized() {
         if (!hasRecipient()) {
-          
+
           return false;
         }
         if (!hasMessage()) {
-          
+
           return false;
         }
         if (!getRecipient().isInitialized()) {
-          
+
           return false;
         }
         if (!getMessage().isInitialized()) {
-          
+
           return false;
         }
         if (hasSender()) {
           if (!getSender().isInitialized()) {
-            
+
             return false;
           }
         }
         for (int i = 0; i < getMetadataCount(); i++) {
           if (!getMetadata(i).isInitialized()) {
-            
+
             return false;
           }
         }
         return true;
       }
-      
+
       public Builder mergeFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
@@ -1378,9 +1378,9 @@ public final class RemoteProtocol {
           }
         }
       }
-      
+
       private int bitField0_;
-      
+
       // required .ActorRefProtocol recipient = 1;
       private akka.remote.RemoteProtocol.ActorRefProtocol recipient_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
@@ -1458,7 +1458,7 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.remote.RemoteProtocol.ActorRefProtocol, akka.remote.RemoteProtocol.ActorRefProtocol.Builder, akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.ActorRefProtocol, akka.remote.RemoteProtocol.ActorRefProtocol.Builder, akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder>
           getRecipientFieldBuilder() {
         if (recipientBuilder_ == null) {
           recipientBuilder_ = new com.google.protobuf.SingleFieldBuilder<
@@ -1470,7 +1470,7 @@ public final class RemoteProtocol {
         }
         return recipientBuilder_;
       }
-      
+
       // required .MessageProtocol message = 2;
       private akka.remote.RemoteProtocol.MessageProtocol message_ = akka.remote.RemoteProtocol.MessageProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
@@ -1548,7 +1548,7 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.remote.RemoteProtocol.MessageProtocol, akka.remote.RemoteProtocol.MessageProtocol.Builder, akka.remote.RemoteProtocol.MessageProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.MessageProtocol, akka.remote.RemoteProtocol.MessageProtocol.Builder, akka.remote.RemoteProtocol.MessageProtocolOrBuilder>
           getMessageFieldBuilder() {
         if (messageBuilder_ == null) {
           messageBuilder_ = new com.google.protobuf.SingleFieldBuilder<
@@ -1560,7 +1560,7 @@ public final class RemoteProtocol {
         }
         return messageBuilder_;
       }
-      
+
       // optional .ActorRefProtocol sender = 4;
       private akka.remote.RemoteProtocol.ActorRefProtocol sender_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
@@ -1638,7 +1638,7 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.remote.RemoteProtocol.ActorRefProtocol, akka.remote.RemoteProtocol.ActorRefProtocol.Builder, akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.ActorRefProtocol, akka.remote.RemoteProtocol.ActorRefProtocol.Builder, akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder>
           getSenderFieldBuilder() {
         if (senderBuilder_ == null) {
           senderBuilder_ = new com.google.protobuf.SingleFieldBuilder<
@@ -1650,7 +1650,7 @@ public final class RemoteProtocol {
         }
         return senderBuilder_;
       }
-      
+
       // repeated .MetadataEntryProtocol metadata = 5;
       private java.util.List<akka.remote.RemoteProtocol.MetadataEntryProtocol> metadata_ =
         java.util.Collections.emptyList();
@@ -1660,10 +1660,10 @@ public final class RemoteProtocol {
           bitField0_ |= 0x00000008;
          }
       }
-      
+
       private com.google.protobuf.RepeatedFieldBuilder<
           akka.remote.RemoteProtocol.MetadataEntryProtocol, akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder, akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder> metadataBuilder_;
-      
+
       public java.util.List<akka.remote.RemoteProtocol.MetadataEntryProtocol> getMetadataList() {
         if (metadataBuilder_ == null) {
           return java.util.Collections.unmodifiableList(metadata_);
@@ -1801,7 +1801,7 @@ public final class RemoteProtocol {
           return metadataBuilder_.getMessageOrBuilder(index);
         }
       }
-      public java.util.List<? extends akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder> 
+      public java.util.List<? extends akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder>
            getMetadataOrBuilderList() {
         if (metadataBuilder_ != null) {
           return metadataBuilder_.getMessageOrBuilderList();
@@ -1818,12 +1818,12 @@ public final class RemoteProtocol {
         return getMetadataFieldBuilder().addBuilder(
             index, akka.remote.RemoteProtocol.MetadataEntryProtocol.getDefaultInstance());
       }
-      public java.util.List<akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder> 
+      public java.util.List<akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder>
            getMetadataBuilderList() {
         return getMetadataFieldBuilder().getBuilderList();
       }
       private com.google.protobuf.RepeatedFieldBuilder<
-          akka.remote.RemoteProtocol.MetadataEntryProtocol, akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder, akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.MetadataEntryProtocol, akka.remote.RemoteProtocol.MetadataEntryProtocol.Builder, akka.remote.RemoteProtocol.MetadataEntryProtocolOrBuilder>
           getMetadataFieldBuilder() {
         if (metadataBuilder_ == null) {
           metadataBuilder_ = new com.google.protobuf.RepeatedFieldBuilder<
@@ -1836,29 +1836,29 @@ public final class RemoteProtocol {
         }
         return metadataBuilder_;
       }
-      
+
       // @@protoc_insertion_point(builder_scope:RemoteMessageProtocol)
     }
-    
+
     static {
       defaultInstance = new RemoteMessageProtocol(true);
       defaultInstance.initFields();
     }
-    
+
     // @@protoc_insertion_point(class_scope:RemoteMessageProtocol)
   }
-  
+
   public interface RemoteControlProtocolOrBuilder
       extends com.google.protobuf.MessageOrBuilder {
-    
+
     // required .CommandType commandType = 1;
     boolean hasCommandType();
     akka.remote.RemoteProtocol.CommandType getCommandType();
-    
+
     // optional string cookie = 2;
     boolean hasCookie();
     String getCookie();
-    
+
     // optional .AddressProtocol origin = 3;
     boolean hasOrigin();
     akka.remote.RemoteProtocol.AddressProtocol getOrigin();
@@ -1872,26 +1872,26 @@ public final class RemoteProtocol {
       super(builder);
     }
     private RemoteControlProtocol(boolean noInit) {}
-    
+
     private static final RemoteControlProtocol defaultInstance;
     public static RemoteControlProtocol getDefaultInstance() {
       return defaultInstance;
     }
-    
+
     public RemoteControlProtocol getDefaultInstanceForType() {
       return defaultInstance;
     }
-    
+
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
       return akka.remote.RemoteProtocol.internal_static_RemoteControlProtocol_descriptor;
     }
-    
+
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
       return akka.remote.RemoteProtocol.internal_static_RemoteControlProtocol_fieldAccessorTable;
     }
-    
+
     private int bitField0_;
     // required .CommandType commandType = 1;
     public static final int COMMANDTYPE_FIELD_NUMBER = 1;
@@ -1902,7 +1902,7 @@ public final class RemoteProtocol {
     public akka.remote.RemoteProtocol.CommandType getCommandType() {
       return commandType_;
     }
-    
+
     // optional string cookie = 2;
     public static final int COOKIE_FIELD_NUMBER = 2;
     private java.lang.Object cookie_;
@@ -1914,7 +1914,7 @@ public final class RemoteProtocol {
       if (ref instanceof String) {
         return (String) ref;
       } else {
-        com.google.protobuf.ByteString bs = 
+        com.google.protobuf.ByteString bs =
             (com.google.protobuf.ByteString) ref;
         String s = bs.toStringUtf8();
         if (com.google.protobuf.Internal.isValidUtf8(bs)) {
@@ -1926,7 +1926,7 @@ public final class RemoteProtocol {
     private com.google.protobuf.ByteString getCookieBytes() {
       java.lang.Object ref = cookie_;
       if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
+        com.google.protobuf.ByteString b =
             com.google.protobuf.ByteString.copyFromUtf8((String) ref);
         cookie_ = b;
         return b;
@@ -1934,7 +1934,7 @@ public final class RemoteProtocol {
         return (com.google.protobuf.ByteString) ref;
       }
     }
-    
+
     // optional .AddressProtocol origin = 3;
     public static final int ORIGIN_FIELD_NUMBER = 3;
     private akka.remote.RemoteProtocol.AddressProtocol origin_;
@@ -1947,7 +1947,7 @@ public final class RemoteProtocol {
     public akka.remote.RemoteProtocol.AddressProtocolOrBuilder getOriginOrBuilder() {
       return origin_;
     }
-    
+
     private void initFields() {
       commandType_ = akka.remote.RemoteProtocol.CommandType.CONNECT;
       cookie_ = "";
@@ -1957,7 +1957,7 @@ public final class RemoteProtocol {
     public final boolean isInitialized() {
       byte isInitialized = memoizedIsInitialized;
       if (isInitialized != -1) return isInitialized == 1;
-      
+
       if (!hasCommandType()) {
         memoizedIsInitialized = 0;
         return false;
@@ -1971,7 +1971,7 @@ public final class RemoteProtocol {
       memoizedIsInitialized = 1;
       return true;
     }
-    
+
     public void writeTo(com.google.protobuf.CodedOutputStream output)
                         throws java.io.IOException {
       getSerializedSize();
@@ -1986,12 +1986,12 @@ public final class RemoteProtocol {
       }
       getUnknownFields().writeTo(output);
     }
-    
+
     private int memoizedSerializedSize = -1;
     public int getSerializedSize() {
       int size = memoizedSerializedSize;
       if (size != -1) return size;
-    
+
       size = 0;
       if (((bitField0_ & 0x00000001) == 0x00000001)) {
         size += com.google.protobuf.CodedOutputStream
@@ -2009,14 +2009,14 @@ public final class RemoteProtocol {
       memoizedSerializedSize = size;
       return size;
     }
-    
+
     private static final long serialVersionUID = 0L;
     @java.lang.Override
     protected java.lang.Object writeReplace()
         throws java.io.ObjectStreamException {
       return super.writeReplace();
     }
-    
+
     public static akka.remote.RemoteProtocol.RemoteControlProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
@@ -2083,14 +2083,14 @@ public final class RemoteProtocol {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    
+
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
     public static Builder newBuilder(akka.remote.RemoteProtocol.RemoteControlProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
-    
+
     @java.lang.Override
     protected Builder newBuilderForType(
         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
@@ -2104,17 +2104,17 @@ public final class RemoteProtocol {
           getDescriptor() {
         return akka.remote.RemoteProtocol.internal_static_RemoteControlProtocol_descriptor;
       }
-      
+
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
         return akka.remote.RemoteProtocol.internal_static_RemoteControlProtocol_fieldAccessorTable;
       }
-      
+
       // Construct using akka.remote.RemoteProtocol.RemoteControlProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
-      
+
       private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
@@ -2127,7 +2127,7 @@ public final class RemoteProtocol {
       private static Builder create() {
         return new Builder();
       }
-      
+
       public Builder clear() {
         super.clear();
         commandType_ = akka.remote.RemoteProtocol.CommandType.CONNECT;
@@ -2142,20 +2142,20 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000004);
         return this;
       }
-      
+
       public Builder clone() {
         return create().mergeFrom(buildPartial());
       }
-      
+
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
         return akka.remote.RemoteProtocol.RemoteControlProtocol.getDescriptor();
       }
-      
+
       public akka.remote.RemoteProtocol.RemoteControlProtocol getDefaultInstanceForType() {
         return akka.remote.RemoteProtocol.RemoteControlProtocol.getDefaultInstance();
       }
-      
+
       public akka.remote.RemoteProtocol.RemoteControlProtocol build() {
         akka.remote.RemoteProtocol.RemoteControlProtocol result = buildPartial();
         if (!result.isInitialized()) {
@@ -2163,7 +2163,7 @@ public final class RemoteProtocol {
         }
         return result;
       }
-      
+
       private akka.remote.RemoteProtocol.RemoteControlProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
         akka.remote.RemoteProtocol.RemoteControlProtocol result = buildPartial();
@@ -2173,7 +2173,7 @@ public final class RemoteProtocol {
         }
         return result;
       }
-      
+
       public akka.remote.RemoteProtocol.RemoteControlProtocol buildPartial() {
         akka.remote.RemoteProtocol.RemoteControlProtocol result = new akka.remote.RemoteProtocol.RemoteControlProtocol(this);
         int from_bitField0_ = bitField0_;
@@ -2198,7 +2198,7 @@ public final class RemoteProtocol {
         onBuilt();
         return result;
       }
-      
+
       public Builder mergeFrom(com.google.protobuf.Message other) {
         if (other instanceof akka.remote.RemoteProtocol.RemoteControlProtocol) {
           return mergeFrom((akka.remote.RemoteProtocol.RemoteControlProtocol)other);
@@ -2207,7 +2207,7 @@ public final class RemoteProtocol {
           return this;
         }
       }
-      
+
       public Builder mergeFrom(akka.remote.RemoteProtocol.RemoteControlProtocol other) {
         if (other == akka.remote.RemoteProtocol.RemoteControlProtocol.getDefaultInstance()) return this;
         if (other.hasCommandType()) {
@@ -2222,21 +2222,21 @@ public final class RemoteProtocol {
         this.mergeUnknownFields(other.getUnknownFields());
         return this;
       }
-      
+
       public final boolean isInitialized() {
         if (!hasCommandType()) {
-          
+
           return false;
         }
         if (hasOrigin()) {
           if (!getOrigin().isInitialized()) {
-            
+
             return false;
           }
         }
         return true;
       }
-      
+
       public Builder mergeFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
@@ -2288,9 +2288,9 @@ public final class RemoteProtocol {
           }
         }
       }
-      
+
       private int bitField0_;
-      
+
       // required .CommandType commandType = 1;
       private akka.remote.RemoteProtocol.CommandType commandType_ = akka.remote.RemoteProtocol.CommandType.CONNECT;
       public boolean hasCommandType() {
@@ -2314,7 +2314,7 @@ public final class RemoteProtocol {
         onChanged();
         return this;
       }
-      
+
       // optional string cookie = 2;
       private java.lang.Object cookie_ = "";
       public boolean hasCookie() {
@@ -2350,7 +2350,7 @@ public final class RemoteProtocol {
         cookie_ = value;
         onChanged();
       }
-      
+
       // optional .AddressProtocol origin = 3;
       private akka.remote.RemoteProtocol.AddressProtocol origin_ = akka.remote.RemoteProtocol.AddressProtocol.getDefaultInstance();
       private com.google.protobuf.SingleFieldBuilder<
@@ -2428,7 +2428,7 @@ public final class RemoteProtocol {
         }
       }
       private com.google.protobuf.SingleFieldBuilder<
-          akka.remote.RemoteProtocol.AddressProtocol, akka.remote.RemoteProtocol.AddressProtocol.Builder, akka.remote.RemoteProtocol.AddressProtocolOrBuilder> 
+          akka.remote.RemoteProtocol.AddressProtocol, akka.remote.RemoteProtocol.AddressProtocol.Builder, akka.remote.RemoteProtocol.AddressProtocolOrBuilder>
           getOriginFieldBuilder() {
         if (originBuilder_ == null) {
           originBuilder_ = new com.google.protobuf.SingleFieldBuilder<
@@ -2440,21 +2440,21 @@ public final class RemoteProtocol {
         }
         return originBuilder_;
       }
-      
+
       // @@protoc_insertion_point(builder_scope:RemoteControlProtocol)
     }
-    
+
     static {
       defaultInstance = new RemoteControlProtocol(true);
       defaultInstance.initFields();
     }
-    
+
     // @@protoc_insertion_point(class_scope:RemoteControlProtocol)
   }
-  
+
   public interface ActorRefProtocolOrBuilder
       extends com.google.protobuf.MessageOrBuilder {
-    
+
     // required string path = 1;
     boolean hasPath();
     String getPath();
@@ -2467,26 +2467,26 @@ public final class RemoteProtocol {
       super(builder);
     }
     private ActorRefProtocol(boolean noInit) {}
-    
+
     private static final ActorRefProtocol defaultInstance;
     public static ActorRefProtocol getDefaultInstance() {
       return defaultInstance;
     }
-    
+
     public ActorRefProtocol getDefaultInstanceForType() {
       return defaultInstance;
     }
-    
+
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
       return akka.remote.RemoteProtocol.internal_static_ActorRefProtocol_descriptor;
     }
-    
+
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
       return akka.remote.RemoteProtocol.internal_static_ActorRefProtocol_fieldAccessorTable;
     }
-    
+
     private int bitField0_;
     // required string path = 1;
     public static final int PATH_FIELD_NUMBER = 1;
@@ -2499,7 +2499,7 @@ public final class RemoteProtocol {
       if (ref instanceof String) {
         return (String) ref;
       } else {
-        com.google.protobuf.ByteString bs = 
+        com.google.protobuf.ByteString bs =
             (com.google.protobuf.ByteString) ref;
         String s = bs.toStringUtf8();
         if (com.google.protobuf.Internal.isValidUtf8(bs)) {
@@ -2511,7 +2511,7 @@ public final class RemoteProtocol {
     private com.google.protobuf.ByteString getPathBytes() {
       java.lang.Object ref = path_;
       if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
+        com.google.protobuf.ByteString b =
             com.google.protobuf.ByteString.copyFromUtf8((String) ref);
         path_ = b;
         return b;
@@ -2519,7 +2519,7 @@ public final class RemoteProtocol {
         return (com.google.protobuf.ByteString) ref;
       }
     }
-    
+
     private void initFields() {
       path_ = "";
     }
@@ -2527,7 +2527,7 @@ public final class RemoteProtocol {
     public final boolean isInitialized() {
       byte isInitialized = memoizedIsInitialized;
       if (isInitialized != -1) return isInitialized == 1;
-      
+
       if (!hasPath()) {
         memoizedIsInitialized = 0;
         return false;
@@ -2535,7 +2535,7 @@ public final class RemoteProtocol {
       memoizedIsInitialized = 1;
       return true;
     }
-    
+
     public void writeTo(com.google.protobuf.CodedOutputStream output)
                         throws java.io.IOException {
       getSerializedSize();
@@ -2544,12 +2544,12 @@ public final class RemoteProtocol {
       }
       getUnknownFields().writeTo(output);
     }
-    
+
     private int memoizedSerializedSize = -1;
     public int getSerializedSize() {
       int size = memoizedSerializedSize;
       if (size != -1) return size;
-    
+
       size = 0;
       if (((bitField0_ & 0x00000001) == 0x00000001)) {
         size += com.google.protobuf.CodedOutputStream
@@ -2559,14 +2559,14 @@ public final class RemoteProtocol {
       memoizedSerializedSize = size;
       return size;
     }
-    
+
     private static final long serialVersionUID = 0L;
     @java.lang.Override
     protected java.lang.Object writeReplace()
         throws java.io.ObjectStreamException {
       return super.writeReplace();
     }
-    
+
     public static akka.remote.RemoteProtocol.ActorRefProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
@@ -2633,14 +2633,14 @@ public final class RemoteProtocol {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    
+
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
     public static Builder newBuilder(akka.remote.RemoteProtocol.ActorRefProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
-    
+
     @java.lang.Override
     protected Builder newBuilderForType(
         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
@@ -2654,17 +2654,17 @@ public final class RemoteProtocol {
           getDescriptor() {
         return akka.remote.RemoteProtocol.internal_static_ActorRefProtocol_descriptor;
       }
-      
+
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
         return akka.remote.RemoteProtocol.internal_static_ActorRefProtocol_fieldAccessorTable;
       }
-      
+
       // Construct using akka.remote.RemoteProtocol.ActorRefProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
-      
+
       private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
@@ -2676,27 +2676,27 @@ public final class RemoteProtocol {
       private static Builder create() {
         return new Builder();
       }
-      
+
       public Builder clear() {
         super.clear();
         path_ = "";
         bitField0_ = (bitField0_ & ~0x00000001);
         return this;
       }
-      
+
       public Builder clone() {
         return create().mergeFrom(buildPartial());
       }
-      
+
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
         return akka.remote.RemoteProtocol.ActorRefProtocol.getDescriptor();
       }
-      
+
       public akka.remote.RemoteProtocol.ActorRefProtocol getDefaultInstanceForType() {
         return akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
       }
-      
+
       public akka.remote.RemoteProtocol.ActorRefProtocol build() {
         akka.remote.RemoteProtocol.ActorRefProtocol result = buildPartial();
         if (!result.isInitialized()) {
@@ -2704,7 +2704,7 @@ public final class RemoteProtocol {
         }
         return result;
       }
-      
+
       private akka.remote.RemoteProtocol.ActorRefProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
         akka.remote.RemoteProtocol.ActorRefProtocol result = buildPartial();
@@ -2714,7 +2714,7 @@ public final class RemoteProtocol {
         }
         return result;
       }
-      
+
       public akka.remote.RemoteProtocol.ActorRefProtocol buildPartial() {
         akka.remote.RemoteProtocol.ActorRefProtocol result = new akka.remote.RemoteProtocol.ActorRefProtocol(this);
         int from_bitField0_ = bitField0_;
@@ -2727,7 +2727,7 @@ public final class RemoteProtocol {
         onBuilt();
         return result;
       }
-      
+
       public Builder mergeFrom(com.google.protobuf.Message other) {
         if (other instanceof akka.remote.RemoteProtocol.ActorRefProtocol) {
           return mergeFrom((akka.remote.RemoteProtocol.ActorRefProtocol)other);
@@ -2736,7 +2736,7 @@ public final class RemoteProtocol {
           return this;
         }
       }
-      
+
       public Builder mergeFrom(akka.remote.RemoteProtocol.ActorRefProtocol other) {
         if (other == akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance()) return this;
         if (other.hasPath()) {
@@ -2745,15 +2745,15 @@ public final class RemoteProtocol {
         this.mergeUnknownFields(other.getUnknownFields());
         return this;
       }
-      
+
       public final boolean isInitialized() {
         if (!hasPath()) {
-          
+
           return false;
         }
         return true;
       }
-      
+
       public Builder mergeFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
@@ -2785,9 +2785,9 @@ public final class RemoteProtocol {
           }
         }
       }
-      
+
       private int bitField0_;
-      
+
       // required string path = 1;
       private java.lang.Object path_ = "";
       public boolean hasPath() {
@@ -2823,26 +2823,30 @@ public final class RemoteProtocol {
         path_ = value;
         onChanged();
       }
-      
+
       // @@protoc_insertion_point(builder_scope:ActorRefProtocol)
     }
-    
+
     static {
       defaultInstance = new ActorRefProtocol(true);
       defaultInstance.initFields();
     }
-    
+
     // @@protoc_insertion_point(class_scope:ActorRefProtocol)
   }
-  
+
   public interface MessageProtocolOrBuilder
       extends com.google.protobuf.MessageOrBuilder {
-    
+
     // required bytes message = 1;
     boolean hasMessage();
     com.google.protobuf.ByteString getMessage();
-    
-    // optional bytes messageManifest = 2;
+
+    // required int32 serializerId = 2;
+    boolean hasSerializerId();
+    int getSerializerId();
+
+    // optional bytes messageManifest = 3;
     boolean hasMessageManifest();
     com.google.protobuf.ByteString getMessageManifest();
   }
@@ -2854,26 +2858,26 @@ public final class RemoteProtocol {
       super(builder);
     }
     private MessageProtocol(boolean noInit) {}
-    
+
     private static final MessageProtocol defaultInstance;
     public static MessageProtocol getDefaultInstance() {
       return defaultInstance;
     }
-    
+
     public MessageProtocol getDefaultInstanceForType() {
       return defaultInstance;
     }
-    
+
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
       return akka.remote.RemoteProtocol.internal_static_MessageProtocol_descriptor;
     }
-    
+
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
       return akka.remote.RemoteProtocol.internal_static_MessageProtocol_fieldAccessorTable;
     }
-    
+
     private int bitField0_;
     // required bytes message = 1;
     public static final int MESSAGE_FIELD_NUMBER = 1;
@@ -2884,34 +2888,49 @@ public final class RemoteProtocol {
     public com.google.protobuf.ByteString getMessage() {
       return message_;
     }
-    
-    // optional bytes messageManifest = 2;
-    public static final int MESSAGEMANIFEST_FIELD_NUMBER = 2;
+
+    // required int32 serializerId = 2;
+    public static final int SERIALIZERID_FIELD_NUMBER = 2;
+    private int serializerId_;
+    public boolean hasSerializerId() {
+      return ((bitField0_ & 0x00000002) == 0x00000002);
+    }
+    public int getSerializerId() {
+      return serializerId_;
+    }
+
+    // optional bytes messageManifest = 3;
+    public static final int MESSAGEMANIFEST_FIELD_NUMBER = 3;
     private com.google.protobuf.ByteString messageManifest_;
     public boolean hasMessageManifest() {
-      return ((bitField0_ & 0x00000002) == 0x00000002);
+      return ((bitField0_ & 0x00000004) == 0x00000004);
     }
     public com.google.protobuf.ByteString getMessageManifest() {
       return messageManifest_;
     }
-    
+
     private void initFields() {
       message_ = com.google.protobuf.ByteString.EMPTY;
+      serializerId_ = 0;
       messageManifest_ = com.google.protobuf.ByteString.EMPTY;
     }
     private byte memoizedIsInitialized = -1;
     public final boolean isInitialized() {
       byte isInitialized = memoizedIsInitialized;
       if (isInitialized != -1) return isInitialized == 1;
-      
+
       if (!hasMessage()) {
         memoizedIsInitialized = 0;
         return false;
       }
+      if (!hasSerializerId()) {
+        memoizedIsInitialized = 0;
+        return false;
+      }
       memoizedIsInitialized = 1;
       return true;
     }
-    
+
     public void writeTo(com.google.protobuf.CodedOutputStream output)
                         throws java.io.IOException {
       getSerializedSize();
@@ -2919,16 +2938,19 @@ public final class RemoteProtocol {
         output.writeBytes(1, message_);
       }
       if (((bitField0_ & 0x00000002) == 0x00000002)) {
-        output.writeBytes(2, messageManifest_);
+        output.writeInt32(2, serializerId_);
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        output.writeBytes(3, messageManifest_);
       }
       getUnknownFields().writeTo(output);
     }
-    
+
     private int memoizedSerializedSize = -1;
     public int getSerializedSize() {
       int size = memoizedSerializedSize;
       if (size != -1) return size;
-    
+
       size = 0;
       if (((bitField0_ & 0x00000001) == 0x00000001)) {
         size += com.google.protobuf.CodedOutputStream
@@ -2936,20 +2958,24 @@ public final class RemoteProtocol {
       }
       if (((bitField0_ & 0x00000002) == 0x00000002)) {
         size += com.google.protobuf.CodedOutputStream
-          .computeBytesSize(2, messageManifest_);
+          .computeInt32Size(2, serializerId_);
+      }
+      if (((bitField0_ & 0x00000004) == 0x00000004)) {
+        size += com.google.protobuf.CodedOutputStream
+          .computeBytesSize(3, messageManifest_);
       }
       size += getUnknownFields().getSerializedSize();
       memoizedSerializedSize = size;
       return size;
     }
-    
+
     private static final long serialVersionUID = 0L;
     @java.lang.Override
     protected java.lang.Object writeReplace()
         throws java.io.ObjectStreamException {
       return super.writeReplace();
     }
-    
+
     public static akka.remote.RemoteProtocol.MessageProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
@@ -3016,14 +3042,14 @@ public final class RemoteProtocol {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    
+
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
     public static Builder newBuilder(akka.remote.RemoteProtocol.MessageProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
-    
+
     @java.lang.Override
     protected Builder newBuilderForType(
         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
@@ -3037,17 +3063,17 @@ public final class RemoteProtocol {
           getDescriptor() {
         return akka.remote.RemoteProtocol.internal_static_MessageProtocol_descriptor;
       }
-      
+
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
         return akka.remote.RemoteProtocol.internal_static_MessageProtocol_fieldAccessorTable;
       }
-      
+
       // Construct using akka.remote.RemoteProtocol.MessageProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
-      
+
       private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
@@ -3059,29 +3085,31 @@ public final class RemoteProtocol {
       private static Builder create() {
         return new Builder();
       }
-      
+
       public Builder clear() {
         super.clear();
         message_ = com.google.protobuf.ByteString.EMPTY;
         bitField0_ = (bitField0_ & ~0x00000001);
-        messageManifest_ = com.google.protobuf.ByteString.EMPTY;
+        serializerId_ = 0;
         bitField0_ = (bitField0_ & ~0x00000002);
+        messageManifest_ = com.google.protobuf.ByteString.EMPTY;
+        bitField0_ = (bitField0_ & ~0x00000004);
         return this;
       }
-      
+
       public Builder clone() {
         return create().mergeFrom(buildPartial());
       }
-      
+
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
         return akka.remote.RemoteProtocol.MessageProtocol.getDescriptor();
       }
-      
+
       public akka.remote.RemoteProtocol.MessageProtocol getDefaultInstanceForType() {
         return akka.remote.RemoteProtocol.MessageProtocol.getDefaultInstance();
       }
-      
+
       public akka.remote.RemoteProtocol.MessageProtocol build() {
         akka.remote.RemoteProtocol.MessageProtocol result = buildPartial();
         if (!result.isInitialized()) {
@@ -3089,7 +3117,7 @@ public final class RemoteProtocol {
         }
         return result;
       }
-      
+
       private akka.remote.RemoteProtocol.MessageProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
         akka.remote.RemoteProtocol.MessageProtocol result = buildPartial();
@@ -3099,7 +3127,7 @@ public final class RemoteProtocol {
         }
         return result;
       }
-      
+
       public akka.remote.RemoteProtocol.MessageProtocol buildPartial() {
         akka.remote.RemoteProtocol.MessageProtocol result = new akka.remote.RemoteProtocol.MessageProtocol(this);
         int from_bitField0_ = bitField0_;
@@ -3111,12 +3139,16 @@ public final class RemoteProtocol {
         if (((from_bitField0_ & 0x00000002) == 0x00000002)) {
           to_bitField0_ |= 0x00000002;
         }
+        result.serializerId_ = serializerId_;
+        if (((from_bitField0_ & 0x00000004) == 0x00000004)) {
+          to_bitField0_ |= 0x00000004;
+        }
         result.messageManifest_ = messageManifest_;
         result.bitField0_ = to_bitField0_;
         onBuilt();
         return result;
       }
-      
+
       public Builder mergeFrom(com.google.protobuf.Message other) {
         if (other instanceof akka.remote.RemoteProtocol.MessageProtocol) {
           return mergeFrom((akka.remote.RemoteProtocol.MessageProtocol)other);
@@ -3125,27 +3157,34 @@ public final class RemoteProtocol {
           return this;
         }
       }
-      
+
       public Builder mergeFrom(akka.remote.RemoteProtocol.MessageProtocol other) {
         if (other == akka.remote.RemoteProtocol.MessageProtocol.getDefaultInstance()) return this;
         if (other.hasMessage()) {
           setMessage(other.getMessage());
         }
+        if (other.hasSerializerId()) {
+          setSerializerId(other.getSerializerId());
+        }
         if (other.hasMessageManifest()) {
           setMessageManifest(other.getMessageManifest());
         }
         this.mergeUnknownFields(other.getUnknownFields());
         return this;
       }
-      
+
       public final boolean isInitialized() {
         if (!hasMessage()) {
-          
+
+          return false;
+        }
+        if (!hasSerializerId()) {
+
           return false;
         }
         return true;
       }
-      
+
       public Builder mergeFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
@@ -3174,17 +3213,22 @@ public final class RemoteProtocol {
               message_ = input.readBytes();
               break;
             }
-            case 18: {
+            case 16: {
               bitField0_ |= 0x00000002;
+              serializerId_ = input.readInt32();
+              break;
+            }
+            case 26: {
+              bitField0_ |= 0x00000004;
               messageManifest_ = input.readBytes();
               break;
             }
           }
         }
       }
-      
+
       private int bitField0_;
-      
+
       // required bytes message = 1;
       private com.google.protobuf.ByteString message_ = com.google.protobuf.ByteString.EMPTY;
       public boolean hasMessage() {
@@ -3208,11 +3252,32 @@ public final class RemoteProtocol {
         onChanged();
         return this;
       }
-      
-      // optional bytes messageManifest = 2;
+
+      // required int32 serializerId = 2;
+      private int serializerId_ ;
+      public boolean hasSerializerId() {
+        return ((bitField0_ & 0x00000002) == 0x00000002);
+      }
+      public int getSerializerId() {
+        return serializerId_;
+      }
+      public Builder setSerializerId(int value) {
+        bitField0_ |= 0x00000002;
+        serializerId_ = value;
+        onChanged();
+        return this;
+      }
+      public Builder clearSerializerId() {
+        bitField0_ = (bitField0_ & ~0x00000002);
+        serializerId_ = 0;
+        onChanged();
+        return this;
+      }
+
+      // optional bytes messageManifest = 3;
       private com.google.protobuf.ByteString messageManifest_ = com.google.protobuf.ByteString.EMPTY;
       public boolean hasMessageManifest() {
-        return ((bitField0_ & 0x00000002) == 0x00000002);
+        return ((bitField0_ & 0x00000004) == 0x00000004);
       }
       public com.google.protobuf.ByteString getMessageManifest() {
         return messageManifest_;
@@ -3221,36 +3286,36 @@ public final class RemoteProtocol {
         if (value == null) {
     throw new NullPointerException();
   }
-  bitField0_ |= 0x00000002;
+  bitField0_ |= 0x00000004;
         messageManifest_ = value;
         onChanged();
         return this;
       }
       public Builder clearMessageManifest() {
-        bitField0_ = (bitField0_ & ~0x00000002);
+        bitField0_ = (bitField0_ & ~0x00000004);
         messageManifest_ = getDefaultInstance().getMessageManifest();
         onChanged();
         return this;
       }
-      
+
       // @@protoc_insertion_point(builder_scope:MessageProtocol)
     }
-    
+
     static {
       defaultInstance = new MessageProtocol(true);
       defaultInstance.initFields();
     }
-    
+
     // @@protoc_insertion_point(class_scope:MessageProtocol)
   }
-  
+
   public interface MetadataEntryProtocolOrBuilder
       extends com.google.protobuf.MessageOrBuilder {
-    
+
     // required string key = 1;
     boolean hasKey();
     String getKey();
-    
+
     // required bytes value = 2;
     boolean hasValue();
     com.google.protobuf.ByteString getValue();
@@ -3263,26 +3328,26 @@ public final class RemoteProtocol {
       super(builder);
     }
     private MetadataEntryProtocol(boolean noInit) {}
-    
+
     private static final MetadataEntryProtocol defaultInstance;
     public static MetadataEntryProtocol getDefaultInstance() {
       return defaultInstance;
     }
-    
+
     public MetadataEntryProtocol getDefaultInstanceForType() {
       return defaultInstance;
     }
-    
+
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
       return akka.remote.RemoteProtocol.internal_static_MetadataEntryProtocol_descriptor;
     }
-    
+
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
       return akka.remote.RemoteProtocol.internal_static_MetadataEntryProtocol_fieldAccessorTable;
     }
-    
+
     private int bitField0_;
     // required string key = 1;
     public static final int KEY_FIELD_NUMBER = 1;
@@ -3295,7 +3360,7 @@ public final class RemoteProtocol {
       if (ref instanceof String) {
         return (String) ref;
       } else {
-        com.google.protobuf.ByteString bs = 
+        com.google.protobuf.ByteString bs =
             (com.google.protobuf.ByteString) ref;
         String s = bs.toStringUtf8();
         if (com.google.protobuf.Internal.isValidUtf8(bs)) {
@@ -3307,7 +3372,7 @@ public final class RemoteProtocol {
     private com.google.protobuf.ByteString getKeyBytes() {
       java.lang.Object ref = key_;
       if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
+        com.google.protobuf.ByteString b =
             com.google.protobuf.ByteString.copyFromUtf8((String) ref);
         key_ = b;
         return b;
@@ -3315,7 +3380,7 @@ public final class RemoteProtocol {
         return (com.google.protobuf.ByteString) ref;
       }
     }
-    
+
     // required bytes value = 2;
     public static final int VALUE_FIELD_NUMBER = 2;
     private com.google.protobuf.ByteString value_;
@@ -3325,7 +3390,7 @@ public final class RemoteProtocol {
     public com.google.protobuf.ByteString getValue() {
       return value_;
     }
-    
+
     private void initFields() {
       key_ = "";
       value_ = com.google.protobuf.ByteString.EMPTY;
@@ -3334,7 +3399,7 @@ public final class RemoteProtocol {
     public final boolean isInitialized() {
       byte isInitialized = memoizedIsInitialized;
       if (isInitialized != -1) return isInitialized == 1;
-      
+
       if (!hasKey()) {
         memoizedIsInitialized = 0;
         return false;
@@ -3346,7 +3411,7 @@ public final class RemoteProtocol {
       memoizedIsInitialized = 1;
       return true;
     }
-    
+
     public void writeTo(com.google.protobuf.CodedOutputStream output)
                         throws java.io.IOException {
       getSerializedSize();
@@ -3358,12 +3423,12 @@ public final class RemoteProtocol {
       }
       getUnknownFields().writeTo(output);
     }
-    
+
     private int memoizedSerializedSize = -1;
     public int getSerializedSize() {
       int size = memoizedSerializedSize;
       if (size != -1) return size;
-    
+
       size = 0;
       if (((bitField0_ & 0x00000001) == 0x00000001)) {
         size += com.google.protobuf.CodedOutputStream
@@ -3377,14 +3442,14 @@ public final class RemoteProtocol {
       memoizedSerializedSize = size;
       return size;
     }
-    
+
     private static final long serialVersionUID = 0L;
     @java.lang.Override
     protected java.lang.Object writeReplace()
         throws java.io.ObjectStreamException {
       return super.writeReplace();
     }
-    
+
     public static akka.remote.RemoteProtocol.MetadataEntryProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
@@ -3451,14 +3516,14 @@ public final class RemoteProtocol {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    
+
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
     public static Builder newBuilder(akka.remote.RemoteProtocol.MetadataEntryProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
-    
+
     @java.lang.Override
     protected Builder newBuilderForType(
         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
@@ -3472,17 +3537,17 @@ public final class RemoteProtocol {
           getDescriptor() {
         return akka.remote.RemoteProtocol.internal_static_MetadataEntryProtocol_descriptor;
       }
-      
+
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
         return akka.remote.RemoteProtocol.internal_static_MetadataEntryProtocol_fieldAccessorTable;
       }
-      
+
       // Construct using akka.remote.RemoteProtocol.MetadataEntryProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
-      
+
       private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
@@ -3494,7 +3559,7 @@ public final class RemoteProtocol {
       private static Builder create() {
         return new Builder();
       }
-      
+
       public Builder clear() {
         super.clear();
         key_ = "";
@@ -3503,20 +3568,20 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000002);
         return this;
       }
-      
+
       public Builder clone() {
         return create().mergeFrom(buildPartial());
       }
-      
+
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
         return akka.remote.RemoteProtocol.MetadataEntryProtocol.getDescriptor();
       }
-      
+
       public akka.remote.RemoteProtocol.MetadataEntryProtocol getDefaultInstanceForType() {
         return akka.remote.RemoteProtocol.MetadataEntryProtocol.getDefaultInstance();
       }
-      
+
       public akka.remote.RemoteProtocol.MetadataEntryProtocol build() {
         akka.remote.RemoteProtocol.MetadataEntryProtocol result = buildPartial();
         if (!result.isInitialized()) {
@@ -3524,7 +3589,7 @@ public final class RemoteProtocol {
         }
         return result;
       }
-      
+
       private akka.remote.RemoteProtocol.MetadataEntryProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
         akka.remote.RemoteProtocol.MetadataEntryProtocol result = buildPartial();
@@ -3534,7 +3599,7 @@ public final class RemoteProtocol {
         }
         return result;
       }
-      
+
       public akka.remote.RemoteProtocol.MetadataEntryProtocol buildPartial() {
         akka.remote.RemoteProtocol.MetadataEntryProtocol result = new akka.remote.RemoteProtocol.MetadataEntryProtocol(this);
         int from_bitField0_ = bitField0_;
@@ -3551,7 +3616,7 @@ public final class RemoteProtocol {
         onBuilt();
         return result;
       }
-      
+
       public Builder mergeFrom(com.google.protobuf.Message other) {
         if (other instanceof akka.remote.RemoteProtocol.MetadataEntryProtocol) {
           return mergeFrom((akka.remote.RemoteProtocol.MetadataEntryProtocol)other);
@@ -3560,7 +3625,7 @@ public final class RemoteProtocol {
           return this;
         }
       }
-      
+
       public Builder mergeFrom(akka.remote.RemoteProtocol.MetadataEntryProtocol other) {
         if (other == akka.remote.RemoteProtocol.MetadataEntryProtocol.getDefaultInstance()) return this;
         if (other.hasKey()) {
@@ -3572,19 +3637,19 @@ public final class RemoteProtocol {
         this.mergeUnknownFields(other.getUnknownFields());
         return this;
       }
-      
+
       public final boolean isInitialized() {
         if (!hasKey()) {
-          
+
           return false;
         }
         if (!hasValue()) {
-          
+
           return false;
         }
         return true;
       }
-      
+
       public Builder mergeFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
@@ -3621,9 +3686,9 @@ public final class RemoteProtocol {
           }
         }
       }
-      
+
       private int bitField0_;
-      
+
       // required string key = 1;
       private java.lang.Object key_ = "";
       public boolean hasKey() {
@@ -3659,7 +3724,7 @@ public final class RemoteProtocol {
         key_ = value;
         onChanged();
       }
-      
+
       // required bytes value = 2;
       private com.google.protobuf.ByteString value_ = com.google.protobuf.ByteString.EMPTY;
       public boolean hasValue() {
@@ -3683,29 +3748,29 @@ public final class RemoteProtocol {
         onChanged();
         return this;
       }
-      
+
       // @@protoc_insertion_point(builder_scope:MetadataEntryProtocol)
     }
-    
+
     static {
       defaultInstance = new MetadataEntryProtocol(true);
       defaultInstance.initFields();
     }
-    
+
     // @@protoc_insertion_point(class_scope:MetadataEntryProtocol)
   }
-  
+
   public interface AddressProtocolOrBuilder
       extends com.google.protobuf.MessageOrBuilder {
-    
+
     // required string system = 1;
     boolean hasSystem();
     String getSystem();
-    
+
     // required string hostname = 2;
     boolean hasHostname();
     String getHostname();
-    
+
     // required uint32 port = 3;
     boolean hasPort();
     int getPort();
@@ -3718,26 +3783,26 @@ public final class RemoteProtocol {
       super(builder);
     }
     private AddressProtocol(boolean noInit) {}
-    
+
     private static final AddressProtocol defaultInstance;
     public static AddressProtocol getDefaultInstance() {
       return defaultInstance;
     }
-    
+
     public AddressProtocol getDefaultInstanceForType() {
       return defaultInstance;
     }
-    
+
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
       return akka.remote.RemoteProtocol.internal_static_AddressProtocol_descriptor;
     }
-    
+
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
       return akka.remote.RemoteProtocol.internal_static_AddressProtocol_fieldAccessorTable;
     }
-    
+
     private int bitField0_;
     // required string system = 1;
     public static final int SYSTEM_FIELD_NUMBER = 1;
@@ -3750,7 +3815,7 @@ public final class RemoteProtocol {
       if (ref instanceof String) {
         return (String) ref;
       } else {
-        com.google.protobuf.ByteString bs = 
+        com.google.protobuf.ByteString bs =
             (com.google.protobuf.ByteString) ref;
         String s = bs.toStringUtf8();
         if (com.google.protobuf.Internal.isValidUtf8(bs)) {
@@ -3762,7 +3827,7 @@ public final class RemoteProtocol {
     private com.google.protobuf.ByteString getSystemBytes() {
       java.lang.Object ref = system_;
       if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
+        com.google.protobuf.ByteString b =
             com.google.protobuf.ByteString.copyFromUtf8((String) ref);
         system_ = b;
         return b;
@@ -3770,7 +3835,7 @@ public final class RemoteProtocol {
         return (com.google.protobuf.ByteString) ref;
       }
     }
-    
+
     // required string hostname = 2;
     public static final int HOSTNAME_FIELD_NUMBER = 2;
     private java.lang.Object hostname_;
@@ -3782,7 +3847,7 @@ public final class RemoteProtocol {
       if (ref instanceof String) {
         return (String) ref;
       } else {
-        com.google.protobuf.ByteString bs = 
+        com.google.protobuf.ByteString bs =
             (com.google.protobuf.ByteString) ref;
         String s = bs.toStringUtf8();
         if (com.google.protobuf.Internal.isValidUtf8(bs)) {
@@ -3794,7 +3859,7 @@ public final class RemoteProtocol {
     private com.google.protobuf.ByteString getHostnameBytes() {
       java.lang.Object ref = hostname_;
       if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
+        com.google.protobuf.ByteString b =
             com.google.protobuf.ByteString.copyFromUtf8((String) ref);
         hostname_ = b;
         return b;
@@ -3802,7 +3867,7 @@ public final class RemoteProtocol {
         return (com.google.protobuf.ByteString) ref;
       }
     }
-    
+
     // required uint32 port = 3;
     public static final int PORT_FIELD_NUMBER = 3;
     private int port_;
@@ -3812,7 +3877,7 @@ public final class RemoteProtocol {
     public int getPort() {
       return port_;
     }
-    
+
     private void initFields() {
       system_ = "";
       hostname_ = "";
@@ -3822,7 +3887,7 @@ public final class RemoteProtocol {
     public final boolean isInitialized() {
       byte isInitialized = memoizedIsInitialized;
       if (isInitialized != -1) return isInitialized == 1;
-      
+
       if (!hasSystem()) {
         memoizedIsInitialized = 0;
         return false;
@@ -3838,7 +3903,7 @@ public final class RemoteProtocol {
       memoizedIsInitialized = 1;
       return true;
     }
-    
+
     public void writeTo(com.google.protobuf.CodedOutputStream output)
                         throws java.io.IOException {
       getSerializedSize();
@@ -3853,12 +3918,12 @@ public final class RemoteProtocol {
       }
       getUnknownFields().writeTo(output);
     }
-    
+
     private int memoizedSerializedSize = -1;
     public int getSerializedSize() {
       int size = memoizedSerializedSize;
       if (size != -1) return size;
-    
+
       size = 0;
       if (((bitField0_ & 0x00000001) == 0x00000001)) {
         size += com.google.protobuf.CodedOutputStream
@@ -3876,14 +3941,14 @@ public final class RemoteProtocol {
       memoizedSerializedSize = size;
       return size;
     }
-    
+
     private static final long serialVersionUID = 0L;
     @java.lang.Override
     protected java.lang.Object writeReplace()
         throws java.io.ObjectStreamException {
       return super.writeReplace();
     }
-    
+
     public static akka.remote.RemoteProtocol.AddressProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
@@ -3950,14 +4015,14 @@ public final class RemoteProtocol {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    
+
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
     public static Builder newBuilder(akka.remote.RemoteProtocol.AddressProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
-    
+
     @java.lang.Override
     protected Builder newBuilderForType(
         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
@@ -3971,17 +4036,17 @@ public final class RemoteProtocol {
           getDescriptor() {
         return akka.remote.RemoteProtocol.internal_static_AddressProtocol_descriptor;
       }
-      
+
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
         return akka.remote.RemoteProtocol.internal_static_AddressProtocol_fieldAccessorTable;
       }
-      
+
       // Construct using akka.remote.RemoteProtocol.AddressProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
-      
+
       private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
@@ -3993,7 +4058,7 @@ public final class RemoteProtocol {
       private static Builder create() {
         return new Builder();
       }
-      
+
       public Builder clear() {
         super.clear();
         system_ = "";
@@ -4004,20 +4069,20 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000004);
         return this;
       }
-      
+
       public Builder clone() {
         return create().mergeFrom(buildPartial());
       }
-      
+
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
         return akka.remote.RemoteProtocol.AddressProtocol.getDescriptor();
       }
-      
+
       public akka.remote.RemoteProtocol.AddressProtocol getDefaultInstanceForType() {
         return akka.remote.RemoteProtocol.AddressProtocol.getDefaultInstance();
       }
-      
+
       public akka.remote.RemoteProtocol.AddressProtocol build() {
         akka.remote.RemoteProtocol.AddressProtocol result = buildPartial();
         if (!result.isInitialized()) {
@@ -4025,7 +4090,7 @@ public final class RemoteProtocol {
         }
         return result;
       }
-      
+
       private akka.remote.RemoteProtocol.AddressProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
         akka.remote.RemoteProtocol.AddressProtocol result = buildPartial();
@@ -4035,7 +4100,7 @@ public final class RemoteProtocol {
         }
         return result;
       }
-      
+
       public akka.remote.RemoteProtocol.AddressProtocol buildPartial() {
         akka.remote.RemoteProtocol.AddressProtocol result = new akka.remote.RemoteProtocol.AddressProtocol(this);
         int from_bitField0_ = bitField0_;
@@ -4056,7 +4121,7 @@ public final class RemoteProtocol {
         onBuilt();
         return result;
       }
-      
+
       public Builder mergeFrom(com.google.protobuf.Message other) {
         if (other instanceof akka.remote.RemoteProtocol.AddressProtocol) {
           return mergeFrom((akka.remote.RemoteProtocol.AddressProtocol)other);
@@ -4065,7 +4130,7 @@ public final class RemoteProtocol {
           return this;
         }
       }
-      
+
       public Builder mergeFrom(akka.remote.RemoteProtocol.AddressProtocol other) {
         if (other == akka.remote.RemoteProtocol.AddressProtocol.getDefaultInstance()) return this;
         if (other.hasSystem()) {
@@ -4080,23 +4145,23 @@ public final class RemoteProtocol {
         this.mergeUnknownFields(other.getUnknownFields());
         return this;
       }
-      
+
       public final boolean isInitialized() {
         if (!hasSystem()) {
-          
+
           return false;
         }
         if (!hasHostname()) {
-          
+
           return false;
         }
         if (!hasPort()) {
-          
+
           return false;
         }
         return true;
       }
-      
+
       public Builder mergeFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
@@ -4138,9 +4203,9 @@ public final class RemoteProtocol {
           }
         }
       }
-      
+
       private int bitField0_;
-      
+
       // required string system = 1;
       private java.lang.Object system_ = "";
       public boolean hasSystem() {
@@ -4176,7 +4241,7 @@ public final class RemoteProtocol {
         system_ = value;
         onChanged();
       }
-      
+
       // required string hostname = 2;
       private java.lang.Object hostname_ = "";
       public boolean hasHostname() {
@@ -4212,7 +4277,7 @@ public final class RemoteProtocol {
         hostname_ = value;
         onChanged();
       }
-      
+
       // required uint32 port = 3;
       private int port_ ;
       public boolean hasPort() {
@@ -4233,25 +4298,25 @@ public final class RemoteProtocol {
         onChanged();
         return this;
       }
-      
+
       // @@protoc_insertion_point(builder_scope:AddressProtocol)
     }
-    
+
     static {
       defaultInstance = new AddressProtocol(true);
       defaultInstance.initFields();
     }
-    
+
     // @@protoc_insertion_point(class_scope:AddressProtocol)
   }
-  
+
   public interface ExceptionProtocolOrBuilder
       extends com.google.protobuf.MessageOrBuilder {
-    
+
     // required string classname = 1;
     boolean hasClassname();
     String getClassname();
-    
+
     // required string message = 2;
     boolean hasMessage();
     String getMessage();
@@ -4264,26 +4329,26 @@ public final class RemoteProtocol {
       super(builder);
     }
     private ExceptionProtocol(boolean noInit) {}
-    
+
     private static final ExceptionProtocol defaultInstance;
     public static ExceptionProtocol getDefaultInstance() {
       return defaultInstance;
     }
-    
+
     public ExceptionProtocol getDefaultInstanceForType() {
       return defaultInstance;
     }
-    
+
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
       return akka.remote.RemoteProtocol.internal_static_ExceptionProtocol_descriptor;
     }
-    
+
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
       return akka.remote.RemoteProtocol.internal_static_ExceptionProtocol_fieldAccessorTable;
     }
-    
+
     private int bitField0_;
     // required string classname = 1;
     public static final int CLASSNAME_FIELD_NUMBER = 1;
@@ -4296,7 +4361,7 @@ public final class RemoteProtocol {
       if (ref instanceof String) {
         return (String) ref;
       } else {
-        com.google.protobuf.ByteString bs = 
+        com.google.protobuf.ByteString bs =
             (com.google.protobuf.ByteString) ref;
         String s = bs.toStringUtf8();
         if (com.google.protobuf.Internal.isValidUtf8(bs)) {
@@ -4308,7 +4373,7 @@ public final class RemoteProtocol {
     private com.google.protobuf.ByteString getClassnameBytes() {
       java.lang.Object ref = classname_;
       if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
+        com.google.protobuf.ByteString b =
             com.google.protobuf.ByteString.copyFromUtf8((String) ref);
         classname_ = b;
         return b;
@@ -4316,7 +4381,7 @@ public final class RemoteProtocol {
         return (com.google.protobuf.ByteString) ref;
       }
     }
-    
+
     // required string message = 2;
     public static final int MESSAGE_FIELD_NUMBER = 2;
     private java.lang.Object message_;
@@ -4328,7 +4393,7 @@ public final class RemoteProtocol {
       if (ref instanceof String) {
         return (String) ref;
       } else {
-        com.google.protobuf.ByteString bs = 
+        com.google.protobuf.ByteString bs =
             (com.google.protobuf.ByteString) ref;
         String s = bs.toStringUtf8();
         if (com.google.protobuf.Internal.isValidUtf8(bs)) {
@@ -4340,7 +4405,7 @@ public final class RemoteProtocol {
     private com.google.protobuf.ByteString getMessageBytes() {
       java.lang.Object ref = message_;
       if (ref instanceof String) {
-        com.google.protobuf.ByteString b = 
+        com.google.protobuf.ByteString b =
             com.google.protobuf.ByteString.copyFromUtf8((String) ref);
         message_ = b;
         return b;
@@ -4348,7 +4413,7 @@ public final class RemoteProtocol {
         return (com.google.protobuf.ByteString) ref;
       }
     }
-    
+
     private void initFields() {
       classname_ = "";
       message_ = "";
@@ -4357,7 +4422,7 @@ public final class RemoteProtocol {
     public final boolean isInitialized() {
       byte isInitialized = memoizedIsInitialized;
       if (isInitialized != -1) return isInitialized == 1;
-      
+
       if (!hasClassname()) {
         memoizedIsInitialized = 0;
         return false;
@@ -4369,7 +4434,7 @@ public final class RemoteProtocol {
       memoizedIsInitialized = 1;
       return true;
     }
-    
+
     public void writeTo(com.google.protobuf.CodedOutputStream output)
                         throws java.io.IOException {
       getSerializedSize();
@@ -4381,12 +4446,12 @@ public final class RemoteProtocol {
       }
       getUnknownFields().writeTo(output);
     }
-    
+
     private int memoizedSerializedSize = -1;
     public int getSerializedSize() {
       int size = memoizedSerializedSize;
       if (size != -1) return size;
-    
+
       size = 0;
       if (((bitField0_ & 0x00000001) == 0x00000001)) {
         size += com.google.protobuf.CodedOutputStream
@@ -4400,14 +4465,14 @@ public final class RemoteProtocol {
       memoizedSerializedSize = size;
       return size;
     }
-    
+
     private static final long serialVersionUID = 0L;
     @java.lang.Override
     protected java.lang.Object writeReplace()
         throws java.io.ObjectStreamException {
       return super.writeReplace();
     }
-    
+
     public static akka.remote.RemoteProtocol.ExceptionProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
@@ -4474,14 +4539,14 @@ public final class RemoteProtocol {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    
+
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
     public static Builder newBuilder(akka.remote.RemoteProtocol.ExceptionProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
-    
+
     @java.lang.Override
     protected Builder newBuilderForType(
         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
@@ -4495,17 +4560,17 @@ public final class RemoteProtocol {
           getDescriptor() {
         return akka.remote.RemoteProtocol.internal_static_ExceptionProtocol_descriptor;
       }
-      
+
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
         return akka.remote.RemoteProtocol.internal_static_ExceptionProtocol_fieldAccessorTable;
       }
-      
+
       // Construct using akka.remote.RemoteProtocol.ExceptionProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
-      
+
       private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
@@ -4517,7 +4582,7 @@ public final class RemoteProtocol {
       private static Builder create() {
         return new Builder();
       }
-      
+
       public Builder clear() {
         super.clear();
         classname_ = "";
@@ -4526,20 +4591,20 @@ public final class RemoteProtocol {
         bitField0_ = (bitField0_ & ~0x00000002);
         return this;
       }
-      
+
       public Builder clone() {
         return create().mergeFrom(buildPartial());
       }
-      
+
       public com.google.protobuf.Descriptors.Descriptor
           getDescriptorForType() {
         return akka.remote.RemoteProtocol.ExceptionProtocol.getDescriptor();
       }
-      
+
       public akka.remote.RemoteProtocol.ExceptionProtocol getDefaultInstanceForType() {
         return akka.remote.RemoteProtocol.ExceptionProtocol.getDefaultInstance();
       }
-      
+
       public akka.remote.RemoteProtocol.ExceptionProtocol build() {
         akka.remote.RemoteProtocol.ExceptionProtocol result = buildPartial();
         if (!result.isInitialized()) {
@@ -4547,7 +4612,7 @@ public final class RemoteProtocol {
         }
         return result;
       }
-      
+
       private akka.remote.RemoteProtocol.ExceptionProtocol buildParsed()
           throws com.google.protobuf.InvalidProtocolBufferException {
         akka.remote.RemoteProtocol.ExceptionProtocol result = buildPartial();
@@ -4557,7 +4622,7 @@ public final class RemoteProtocol {
         }
         return result;
       }
-      
+
       public akka.remote.RemoteProtocol.ExceptionProtocol buildPartial() {
         akka.remote.RemoteProtocol.ExceptionProtocol result = new akka.remote.RemoteProtocol.ExceptionProtocol(this);
         int from_bitField0_ = bitField0_;
@@ -4574,7 +4639,7 @@ public final class RemoteProtocol {
         onBuilt();
         return result;
       }
-      
+
       public Builder mergeFrom(com.google.protobuf.Message other) {
         if (other instanceof akka.remote.RemoteProtocol.ExceptionProtocol) {
           return mergeFrom((akka.remote.RemoteProtocol.ExceptionProtocol)other);
@@ -4583,7 +4648,7 @@ public final class RemoteProtocol {
           return this;
         }
       }
-      
+
       public Builder mergeFrom(akka.remote.RemoteProtocol.ExceptionProtocol other) {
         if (other == akka.remote.RemoteProtocol.ExceptionProtocol.getDefaultInstance()) return this;
         if (other.hasClassname()) {
@@ -4595,19 +4660,19 @@ public final class RemoteProtocol {
         this.mergeUnknownFields(other.getUnknownFields());
         return this;
       }
-      
+
       public final boolean isInitialized() {
         if (!hasClassname()) {
-          
+
           return false;
         }
         if (!hasMessage()) {
-          
+
           return false;
         }
         return true;
       }
-      
+
       public Builder mergeFrom(
           com.google.protobuf.CodedInputStream input,
           com.google.protobuf.ExtensionRegistryLite extensionRegistry)
@@ -4644,9 +4709,9 @@ public final class RemoteProtocol {
           }
         }
       }
-      
+
       private int bitField0_;
-      
+
       // required string classname = 1;
       private java.lang.Object classname_ = "";
       public boolean hasClassname() {
@@ -4682,7 +4747,7 @@ public final class RemoteProtocol {
         classname_ = value;
         onChanged();
       }
-      
+
       // required string message = 2;
       private java.lang.Object message_ = "";
       public boolean hasMessage() {
@@ -4718,31 +4783,31 @@ public final class RemoteProtocol {
         message_ = value;
         onChanged();
       }
-      
+
       // @@protoc_insertion_point(builder_scope:ExceptionProtocol)
     }
-    
+
     static {
       defaultInstance = new ExceptionProtocol(true);
       defaultInstance.initFields();
     }
-    
+
     // @@protoc_insertion_point(class_scope:ExceptionProtocol)
   }
-  
+
   public interface DurableMailboxMessageProtocolOrBuilder
       extends com.google.protobuf.MessageOrBuilder {
-    
+
     // required .ActorRefProtocol recipient = 1;
     boolean hasRecipient();
     akka.remote.RemoteProtocol.ActorRefProtocol getRecipient();
     akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder getRecipientOrBuilder();
-    
+
     // optional .ActorRefProtocol sender = 2;
     boolean hasSender();
     akka.remote.RemoteProtocol.ActorRefProtocol getSender();
     akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder getSenderOrBuilder();
-    
+
     // required bytes message = 3;
     boolean hasMessage();
     com.google.protobuf.ByteString getMessage();
@@ -4755,26 +4820,26 @@ public final class RemoteProtocol {
       super(builder);
     }
     private DurableMailboxMessageProtocol(boolean noInit) {}
-    
+
     private static final DurableMailboxMessageProtocol defaultInstance;
     public static DurableMailboxMessageProtocol getDefaultInstance() {
       return defaultInstance;
     }
-    
+
     public DurableMailboxMessageProtocol getDefaultInstanceForType() {
       return defaultInstance;
     }
-    
+
     public static final com.google.protobuf.Descriptors.Descriptor
         getDescriptor() {
       return akka.remote.RemoteProtocol.internal_static_DurableMailboxMessageProtocol_descriptor;
     }
-    
+
     protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
         internalGetFieldAccessorTable() {
       return akka.remote.RemoteProtocol.internal_static_DurableMailboxMessageProtocol_fieldAccessorTable;
     }
-    
+
     private int bitField0_;
     // required .ActorRefProtocol recipient = 1;
     public static final int RECIPIENT_FIELD_NUMBER = 1;
@@ -4788,7 +4853,7 @@ public final class RemoteProtocol {
     public akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder getRecipientOrBuilder() {
       return recipient_;
     }
-    
+
     // optional .ActorRefProtocol sender = 2;
     public static final int SENDER_FIELD_NUMBER = 2;
     private akka.remote.RemoteProtocol.ActorRefProtocol sender_;
@@ -4801,7 +4866,7 @@ public final class RemoteProtocol {
     public akka.remote.RemoteProtocol.ActorRefProtocolOrBuilder getSenderOrBuilder() {
       return sender_;
     }
-    
+
     // required bytes message = 3;
     public static final int MESSAGE_FIELD_NUMBER = 3;
     private com.google.protobuf.ByteString message_;
@@ -4811,7 +4876,7 @@ public final class RemoteProtocol {
     public com.google.protobuf.ByteString getMessage() {
       return message_;
     }
-    
+
     private void initFields() {
       recipient_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
       sender_ = akka.remote.RemoteProtocol.ActorRefProtocol.getDefaultInstance();
@@ -4821,7 +4886,7 @@ public final class RemoteProtocol {
     public final boolean isInitialized() {
       byte isInitialized = memoizedIsInitialized;
       if (isInitialized != -1) return isInitialized == 1;
-      
+
       if (!hasRecipient()) {
         memoizedIsInitialized = 0;
         return false;
@@ -4843,7 +4908,7 @@ public final class RemoteProtocol {
       memoizedIsInitialized = 1;
       return true;
     }
-    
+
     public void writeTo(com.google.protobuf.CodedOutputStream output)
                         throws java.io.IOException {
       getSerializedSize();
@@ -4858,12 +4923,12 @@ public final class RemoteProtocol {
       }
       getUnknownFields().writeTo(output);
     }
-    
+
     private int memoizedSerializedSize = -1;
     public int getSerializedSize() {
       int size = memoizedSerializedSize;
       if (size != -1) return size;
-    
+
       size = 0;
       if (((bitField0_ & 0x00000001) == 0x00000001)) {
         size += com.google.protobuf.CodedOutputStream
@@ -4881,14 +4946,14 @@ public final class RemoteProtocol {
       memoizedSerializedSize = size;
       return size;
     }
-    
+
     private static final long serialVersionUID = 0L;
     @java.lang.Override
     protected java.lang.Object writeReplace()
         throws java.io.ObjectStreamException {
       return super.writeReplace();
     }
-    
+
     public static akka.remote.RemoteProtocol.DurableMailboxMessageProtocol parseFrom(
         com.google.protobuf.ByteString data)
         throws com.google.protobuf.InvalidProtocolBufferException {
@@ -4955,14 +5020,14 @@ public final class RemoteProtocol {
       return newBuilder().mergeFrom(input, extensionRegistry)
                .buildParsed();
     }
-    
+
     public static Builder newBuilder() { return Builder.create(); }
     public Builder newBuilderForType() { return newBuilder(); }
     public static Builder newBuilder(akka.remote.RemoteProtocol.DurableMailboxMessageProtocol prototype) {
       return newBuilder().mergeFrom(prototype);
     }
     public Builder toBuilder() { return newBuilder(this); }
-    
+
     @java.lang.Override
     protected Builder newBuilderForType(
         com.google.protobuf.GeneratedMessage.BuilderParent parent) {
@@ -4976,17 +5041,17 @@ public final class RemoteProtocol {
           getDescriptor() {
         return akka.remote.RemoteProtocol.internal_static_DurableMailboxMessageProtocol_descriptor;
       }
-      
+
       protected com.google.protobuf.GeneratedMessage.FieldAccessorTable
           internalGetFieldAccessorTable() {
         return akka.remote.RemoteProtocol.internal_static_DurableMailboxMessageProtocol_fieldAccessorTable;
       }
-      
+
       // Construct using akka.remote.RemoteProtocol.DurableMailboxMessageProtocol.newBuilder()
       private Builder() {
         maybeForceBuilderInitialization();
       }
-      
+
       private Builder(com.google.protobuf.GeneratedMessage.BuilderParent parent) {
         super(parent);
         maybeForceBuilderInitialization();
@@ -5447,32 +5512,32 @@ public final class RemoteProtocol {
       descriptor;
   static {
     java.lang.String[] descriptorData = {
-      "\n\035protocol/RemoteProtocol.proto\"j\n\022AkkaR" +
-      "emoteProtocol\022\'\n\007message\030\001 \001(\0132\026.RemoteM" +
-      "essageProtocol\022+\n\013instruction\030\002 \001(\0132\026.Re" +
-      "moteControlProtocol\"\255\001\n\025RemoteMessagePro" +
-      "tocol\022$\n\trecipient\030\001 \002(\0132\021.ActorRefProto" +
-      "col\022!\n\007message\030\002 \002(\0132\020.MessageProtocol\022!" +
-      "\n\006sender\030\004 \001(\0132\021.ActorRefProtocol\022(\n\010met" +
-      "adata\030\005 \003(\0132\026.MetadataEntryProtocol\"l\n\025R" +
-      "emoteControlProtocol\022!\n\013commandType\030\001 \002(" +
-      "\0162\014.CommandType\022\016\n\006cookie\030\002 \001(\t\022 \n\006origi",
-      "n\030\003 \001(\0132\020.AddressProtocol\" \n\020ActorRefPro" +
-      "tocol\022\014\n\004path\030\001 \002(\t\";\n\017MessageProtocol\022\017" +
-      "\n\007message\030\001 \002(\014\022\027\n\017messageManifest\030\002 \001(\014" +
-      "\"3\n\025MetadataEntryProtocol\022\013\n\003key\030\001 \002(\t\022\r" +
-      "\n\005value\030\002 \002(\014\"A\n\017AddressProtocol\022\016\n\006syst" +
-      "em\030\001 \002(\t\022\020\n\010hostname\030\002 \002(\t\022\014\n\004port\030\003 \002(\r" +
-      "\"7\n\021ExceptionProtocol\022\021\n\tclassname\030\001 \002(\t" +
-      "\022\017\n\007message\030\002 \002(\t\"y\n\035DurableMailboxMessa" +
-      "geProtocol\022$\n\trecipient\030\001 \002(\0132\021.ActorRef" +
-      "Protocol\022!\n\006sender\030\002 \001(\0132\021.ActorRefProto",
-      "col\022\017\n\007message\030\003 \002(\014*(\n\013CommandType\022\013\n\007C" +
-      "ONNECT\020\001\022\014\n\010SHUTDOWN\020\002*K\n\026ReplicationSto" +
-      "rageType\022\r\n\tTRANSIENT\020\001\022\023\n\017TRANSACTION_L" +
-      "OG\020\002\022\r\n\tDATA_GRID\020\003*>\n\027ReplicationStrate" +
-      "gyType\022\021\n\rWRITE_THROUGH\020\001\022\020\n\014WRITE_BEHIN" +
-      "D\020\002B\017\n\013akka.remoteH\001"
+      "\n\024RemoteProtocol.proto\"j\n\022AkkaRemoteProt" +
+      "ocol\022\'\n\007message\030\001 \001(\0132\026.RemoteMessagePro" +
+      "tocol\022+\n\013instruction\030\002 \001(\0132\026.RemoteContr" +
+      "olProtocol\"\255\001\n\025RemoteMessageProtocol\022$\n\t" +
+      "recipient\030\001 \002(\0132\021.ActorRefProtocol\022!\n\007me" +
+      "ssage\030\002 \002(\0132\020.MessageProtocol\022!\n\006sender\030" +
+      "\004 \001(\0132\021.ActorRefProtocol\022(\n\010metadata\030\005 \003" +
+      "(\0132\026.MetadataEntryProtocol\"l\n\025RemoteCont" +
+      "rolProtocol\022!\n\013commandType\030\001 \002(\0162\014.Comma" +
+      "ndType\022\016\n\006cookie\030\002 \001(\t\022 \n\006origin\030\003 \001(\0132\020",
+      ".AddressProtocol\" \n\020ActorRefProtocol\022\014\n\004" +
+      "path\030\001 \002(\t\"Q\n\017MessageProtocol\022\017\n\007message" +
+      "\030\001 \002(\014\022\024\n\014serializerId\030\002 \002(\005\022\027\n\017messageM" +
+      "anifest\030\003 \001(\014\"3\n\025MetadataEntryProtocol\022\013" +
+      "\n\003key\030\001 \002(\t\022\r\n\005value\030\002 \002(\014\"A\n\017AddressPro" +
+      "tocol\022\016\n\006system\030\001 \002(\t\022\020\n\010hostname\030\002 \002(\t\022" +
+      "\014\n\004port\030\003 \002(\r\"7\n\021ExceptionProtocol\022\021\n\tcl" +
+      "assname\030\001 \002(\t\022\017\n\007message\030\002 \002(\t\"y\n\035Durabl" +
+      "eMailboxMessageProtocol\022$\n\trecipient\030\001 \002" +
+      "(\0132\021.ActorRefProtocol\022!\n\006sender\030\002 \001(\0132\021.",
+      "ActorRefProtocol\022\017\n\007message\030\003 \002(\014*(\n\013Com" +
+      "mandType\022\013\n\007CONNECT\020\001\022\014\n\010SHUTDOWN\020\002*K\n\026R" +
+      "eplicationStorageType\022\r\n\tTRANSIENT\020\001\022\023\n\017" +
+      "TRANSACTION_LOG\020\002\022\r\n\tDATA_GRID\020\003*>\n\027Repl" +
+      "icationStrategyType\022\021\n\rWRITE_THROUGH\020\001\022\020" +
+      "\n\014WRITE_BEHIND\020\002B\017\n\013akka.remoteH\001"
     };
     com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner assigner =
       new com.google.protobuf.Descriptors.FileDescriptor.InternalDescriptorAssigner() {
@@ -5516,7 +5581,7 @@ public final class RemoteProtocol {
           internal_static_MessageProtocol_fieldAccessorTable = new
             com.google.protobuf.GeneratedMessage.FieldAccessorTable(
               internal_static_MessageProtocol_descriptor,
-              new java.lang.String[] { "Message", "MessageManifest", },
+              new java.lang.String[] { "Message", "SerializerId", "MessageManifest", },
               akka.remote.RemoteProtocol.MessageProtocol.class,
               akka.remote.RemoteProtocol.MessageProtocol.Builder.class);
           internal_static_MetadataEntryProtocol_descriptor =
diff --git a/akka-remote/src/main/protocol/RemoteProtocol.proto b/akka-remote/src/main/protocol/RemoteProtocol.proto
index 3f54b5a633..557d4376a1 100644
--- a/akka-remote/src/main/protocol/RemoteProtocol.proto
+++ b/akka-remote/src/main/protocol/RemoteProtocol.proto
@@ -73,7 +73,8 @@ message ActorRefProtocol {
  */
 message MessageProtocol {
   required bytes message = 1;
-  optional bytes messageManifest = 2;
+  required int32 serializerId = 2;
+  optional bytes messageManifest = 3;
 }
 
 /**
diff --git a/akka-remote/src/main/resources/reference.conf b/akka-remote/src/main/resources/reference.conf
index 98a7c75329..3399f68639 100644
--- a/akka-remote/src/main/resources/reference.conf
+++ b/akka-remote/src/main/resources/reference.conf
@@ -37,8 +37,16 @@ akka {
   }
 
   remote {
+
+    # Which implementation of akka.remote.RemoteSupport to use
+    # default is a TCP-based remote transport based on Netty
     transport = "akka.remote.netty.NettyRemoteSupport"
 
+    # In case of increased latency / overflow how long
+    # should we wait (blocking the sender) until we deem the send to be cancelled?
+    # 0 means "never backoff", any positive number will indicate time to block at most.
+    backoff-timeout = 0ms
+
     use-compression = off
 
     # Generate your own with '$AKKA_HOME/scripts/generate_config_with_secure_cookie.sh'
diff --git a/akka-remote/src/main/scala/akka/remote/MessageSerializer.scala b/akka-remote/src/main/scala/akka/remote/MessageSerializer.scala
index 03e10e770b..56c8ec2ed8 100644
--- a/akka-remote/src/main/scala/akka/remote/MessageSerializer.scala
+++ b/akka-remote/src/main/scala/akka/remote/MessageSerializer.scala
@@ -5,29 +5,40 @@
 package akka.remote
 
 import akka.remote.RemoteProtocol._
-import akka.serialization.Serialization
 import com.google.protobuf.ByteString
 import akka.actor.ActorSystem
 import akka.serialization.SerializationExtension
+import akka.util.ReflectiveAccess
 
 object MessageSerializer {
 
   def deserialize(system: ActorSystem, messageProtocol: MessageProtocol, classLoader: Option[ClassLoader] = None): AnyRef = {
-    val clazz = loadManifest(classLoader, messageProtocol)
-    SerializationExtension(system).deserialize(messageProtocol.getMessage.toByteArray,
-      clazz, classLoader).fold(x ⇒ throw x, identity)
+    val clazz = if (messageProtocol.hasMessageManifest) {
+      Option(ReflectiveAccess.getClassFor[AnyRef](
+        messageProtocol.getMessageManifest.toStringUtf8,
+        classLoader.getOrElse(ReflectiveAccess.loader)) match {
+          case Left(e)  ⇒ throw e
+          case Right(r) ⇒ r
+        })
+    } else None
+    SerializationExtension(system).deserialize(
+      messageProtocol.getMessage.toByteArray,
+      messageProtocol.getSerializerId,
+      clazz,
+      classLoader) match {
+        case Left(e)  ⇒ throw e
+        case Right(r) ⇒ r
+      }
   }
 
   def serialize(system: ActorSystem, message: AnyRef): MessageProtocol = {
+    val s = SerializationExtension(system)
+    val serializer = s.findSerializerFor(message)
     val builder = MessageProtocol.newBuilder
-    val bytes = SerializationExtension(system).serialize(message).fold(x ⇒ throw x, identity)
-    builder.setMessage(ByteString.copyFrom(bytes))
-    builder.setMessageManifest(ByteString.copyFromUtf8(message.getClass.getName))
+    builder.setMessage(ByteString.copyFrom(serializer.toBinary(message)))
+    builder.setSerializerId(serializer.identifier)
+    if (serializer.includeManifest)
+      builder.setMessageManifest(ByteString.copyFromUtf8(message.getClass.getName))
     builder.build
   }
-
-  private def loadManifest(classLoader: Option[ClassLoader], messageProtocol: MessageProtocol): Class[_] = {
-    val manifest = messageProtocol.getMessageManifest.toStringUtf8
-    classLoader map (_.loadClass(manifest)) getOrElse (Class.forName(manifest))
-  }
 }
diff --git a/akka-remote/src/main/scala/akka/remote/RemoteExtension.scala b/akka-remote/src/main/scala/akka/remote/RemoteExtension.scala
index 67f5b6f8c9..c8ce919944 100644
--- a/akka-remote/src/main/scala/akka/remote/RemoteExtension.scala
+++ b/akka-remote/src/main/scala/akka/remote/RemoteExtension.scala
@@ -23,6 +23,7 @@ class RemoteSettings(val config: Config, val systemName: String) extends Extensi
   val RemoteSystemDaemonAckTimeout = Duration(config.getMilliseconds("akka.remote.remote-daemon-ack-timeout"), MILLISECONDS)
   val InitalDelayForGossip = Duration(config.getMilliseconds("akka.remote.gossip.initialDelay"), MILLISECONDS)
   val GossipFrequency = Duration(config.getMilliseconds("akka.remote.gossip.frequency"), MILLISECONDS)
+  val BackoffTimeout = Duration(config.getMilliseconds("akka.remote.backoff-timeout"), MILLISECONDS)
 
   // TODO cluster config will go into akka-cluster/reference.conf when we enable that module
   val ClusterName = getString("akka.cluster.name")
diff --git a/akka-remote/src/main/scala/akka/remote/netty/NettyRemoteSupport.scala b/akka-remote/src/main/scala/akka/remote/netty/NettyRemoteSupport.scala
index 3832d0b8fa..24ae131a29 100644
--- a/akka-remote/src/main/scala/akka/remote/netty/NettyRemoteSupport.scala
+++ b/akka-remote/src/main/scala/akka/remote/netty/NettyRemoteSupport.scala
@@ -18,14 +18,14 @@ import org.jboss.netty.handler.timeout.{ ReadTimeoutHandler, ReadTimeoutExceptio
 import org.jboss.netty.util.{ TimerTask, Timeout, HashedWheelTimer }
 import scala.collection.mutable.HashMap
 import java.net.InetSocketAddress
-import java.util.concurrent._
 import java.util.concurrent.atomic._
 import akka.AkkaException
 import akka.event.Logging
-import locks.ReentrantReadWriteLock
 import org.jboss.netty.channel._
 import akka.actor.ActorSystemImpl
 import org.jboss.netty.handler.execution.{ ExecutionHandler, OrderedMemoryAwareThreadPoolExecutor }
+import java.util.concurrent._
+import locks.ReentrantReadWriteLock
 
 class RemoteClientMessageBufferException(message: String, cause: Throwable = null) extends AkkaException(message, cause) {
   def this(msg: String) = this(msg, null)
@@ -73,16 +73,21 @@ abstract class RemoteClient private[akka] (
    */
   private def send(request: (Any, Option[ActorRef], ActorRef)): Unit = {
     try {
-      currentChannel.write(request).addListener(
+      val channel = currentChannel
+      val f = channel.write(request)
+      f.addListener(
         new ChannelFutureListener {
           def operationComplete(future: ChannelFuture) {
-            if (future.isCancelled) {
-              //Not interesting at the moment
-            } else if (!future.isSuccess) {
+            if (future.isCancelled || !future.isSuccess) {
               remoteSupport.notifyListeners(RemoteClientWriteFailed(request, future.getCause, remoteSupport, remoteAddress))
             }
           }
         })
+      // Check if we should back off
+      if (!channel.isWritable) {
+        val backoff = remoteSupport.remote.remoteSettings.BackoffTimeout
+        if (backoff.length > 0 && !f.await(backoff.length, backoff.unit)) f.cancel() //Waited as long as we could, now back off
+      }
     } catch {
       case e: Exception ⇒ remoteSupport.notifyListeners(RemoteClientError(e, remoteSupport, remoteAddress))
     }
diff --git a/akka-remote/src/main/scala/akka/serialization/ProtobufSerializer.scala b/akka-remote/src/main/scala/akka/serialization/ProtobufSerializer.scala
new file mode 100644
index 0000000000..af206a4234
--- /dev/null
+++ b/akka-remote/src/main/scala/akka/serialization/ProtobufSerializer.scala
@@ -0,0 +1,27 @@
+/**
+ * Copyright (C) 2009-2011 Typesafe Inc. <http://www.typesafe.com>
+ */
+
+package akka.serialization
+
+import com.google.protobuf.Message
+
+/**
+ * This Serializer serializes `com.google.protobuf.Message`s
+ */
+class ProtobufSerializer extends Serializer {
+  val ARRAY_OF_BYTE_ARRAY = Array[Class[_]](classOf[Array[Byte]])
+  def includeManifest: Boolean = true
+  def identifier = 2
+
+  def toBinary(obj: AnyRef): Array[Byte] = obj match {
+    case m: Message ⇒ m.toByteArray
+    case _          ⇒ throw new IllegalArgumentException("Can't serialize a non-protobuf message using protobuf [" + obj + "]")
+  }
+
+  def fromBinary(bytes: Array[Byte], clazz: Option[Class[_]], classLoader: Option[ClassLoader] = None): AnyRef =
+    clazz match {
+      case None    ⇒ throw new IllegalArgumentException("Need a protobuf message class to be able to serialize bytes using protobuf")
+      case Some(c) ⇒ c.getDeclaredMethod("parseFrom", ARRAY_OF_BYTE_ARRAY: _*).invoke(null, bytes).asInstanceOf[Message]
+    }
+}
\ No newline at end of file
diff --git a/akka-remote/src/test/scala/akka/remote/RemoteConfigSpec.scala b/akka-remote/src/test/scala/akka/remote/RemoteConfigSpec.scala
index 1132d1a733..cd8c3c8eb5 100644
--- a/akka-remote/src/test/scala/akka/remote/RemoteConfigSpec.scala
+++ b/akka-remote/src/test/scala/akka/remote/RemoteConfigSpec.scala
@@ -15,6 +15,7 @@ class RemoteConfigSpec extends AkkaSpec("akka.cluster.nodename = node1") {
       getString("akka.remote.transport") must equal("akka.remote.netty.NettyRemoteSupport")
       getString("akka.remote.secure-cookie") must equal("")
       getBoolean("akka.remote.use-passive-connections") must equal(true)
+      getMilliseconds("akka.remote.backoff-timeout") must equal(0)
       // getMilliseconds("akka.remote.remote-daemon-ack-timeout") must equal(30 * 1000)
 
       //akka.remote.server