diff --git a/README.md b/README.md
index a1a54f0..9639b5a 100644
--- a/README.md
+++ b/README.md
@@ -75,7 +75,7 @@ $ anbox-installer
 
 This will guide you through the installation process.
 
-**NOTE:** Anbox is currently in a **pre-alpha development state**. Don't expect a
+**NOTE:** Anbox is currently in a **alpha development state**. Don't expect a
 fully working system for a production system with all features you need. You will
 for sure see bugs and crashes. If you do so, please don't hestitate and report them!
 
diff --git a/docs/install.md b/docs/install.md
new file mode 100644
index 0000000..1735de8
--- /dev/null
+++ b/docs/install.md
@@ -0,0 +1,106 @@
+# Install Anbox
+
+To install Anbox your system need to support [snaps](https://snapcraft.io). We
+do not officially support any other distribution method of Anbox at the moment
+but there are community made packages for various distributions (e.g. Arch Linux).
+However please keep in mind that the Anbox project can give not support them
+and its solely in the responsibility of the community packager to keep up with
+upstream development and update the packaging to any new changes. Please feel
+free to report still any bugs you encounter as they may not be related to the
+packaging.
+
+If you don't know about snaps yet head over to [snapcraft.io](https://snapcraft.io/)
+to get an introduction of what snaps are, how to install support for them on your
+distribution and how to use them.
+
+The installation of Anbox consists of two steps.
+
+ 1. Install necessary kernel modules
+ 2. Install the Anbox snap
+
+In order to support the mandatory kernel subsystems ashmem and binder for the
+Android container you have to install two
+[DKMS](https://en.wikipedia.org/wiki/Dynamic_Kernel_Module_Support)
+based kernel modules. The source for the kernel modules is maintained by the
+Anbox project [here](https://github.com/anbox/anbox/tree/master/kernel).
+
+At the moment we only have packages prepared for Ubuntu in a PPA on Launchpad.
+If you want to help to get the packages in your favorite distribution please
+come and talk to us or submit a PR with the distribution specific packaging.
+
+The second step will install the Anbox snap from the store and will give you
+everything you need to run the full Anbox experience.
+
+## Install necessary kernel modules
+
+In order to add the PPA to your Ubuntu system please run the following commands:
+
+```
+ $ sudo add-apt-repository ppa:morphis/anbox-support
+ $ sudo apt update
+ $ sudo apt install anbox-modules-dkms
+```
+
+These will add the PPA to your system and install the `anbox-modules-dkms`
+package which contains the ashmem and binder kernel modules. They will be
+automatically rebuild everytime the kernel packages on your system update.
+
+After you installed the `anbox-modules-dkms` package you have to manually
+load the kernel modules. The next time your system starts they will be
+automatically loaded.
+
+```
+ $ sudo modprobe ashmem_linux
+ $ sudo modprobe binder_linux
+```
+
+Now you should have two new nodes in your systems `/dev` directory:
+
+```
+ $ ls -1 /dev/{ashmem,binder}
+ /dev/ashmem
+ /dev/binder
+```
+
+## Install the Anbox snap
+
+Installing the Anbox snap is very simple:
+
+```
+ $ snap install --devmode --beta anbox
+```
+
+If you didn't logged into the Ubuntu Store yet, the `snap` command will
+ask you to use `sudo snap ...` in order to install the snap:
+
+```
+ $ sudo snap install --devmode --beta anbox
+```
+
+At the moment we require the use of `--devmode` as the Anbox snap is not
+yet fully confined. Work has started with the upstream `snapd` project to
+get support for full confinement.
+
+As a side effect of using `--devmode` the snap will not automatically update.
+In order to update to a newer version you can run:
+
+```
+ $ snap refresh --beta --devmode anbox
+```
+
+Information about the currently available versions of the snap is available
+via:
+
+```
+ $ snap info anbox
+```
+
+## Available snap channels
+
+Currently we only use the beta and edge channels for the Anbox snap. The edge
+channel tracks the latest development is always synced with the state of the
+master branch on github. The beta channel is updated less frequently to provide
+a more stable and bug free experience.
+
+Once proper confinement for the Anbox snap exists we will also start using the
+candidate and stable channels.
diff --git a/scripts/gen-emugl-entries.py b/scripts/gen-emugl-entries.py
index d651fb2..b88137e 100755
--- a/scripts/gen-emugl-entries.py
+++ b/scripts/gen-emugl-entries.py
@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python2
 
 # Copyright 2015 The Android Open Source Project
 #
diff --git a/src/anbox/rpc/channel.cpp b/src/anbox/rpc/channel.cpp
index 71ffa80..b0c2ead 100644
--- a/src/anbox/rpc/channel.cpp
+++ b/src/anbox/rpc/channel.cpp
@@ -74,6 +74,7 @@ void Channel::send_message(const std::uint8_t &type,
                            google::protobuf::MessageLite const &message) {
   const size_t size = message.ByteSize();
   const unsigned char header_bytes[header_size] = {
+      static_cast<unsigned char>((size >>16) & 0xff),
       static_cast<unsigned char>((size >> 8) & 0xff),
       static_cast<unsigned char>((size >> 0) & 0xff), type,
   };
diff --git a/src/anbox/rpc/constants.h b/src/anbox/rpc/constants.h
index 1d4265a..4f5d04a 100644
--- a/src/anbox/rpc/constants.h
+++ b/src/anbox/rpc/constants.h
@@ -20,7 +20,7 @@
 
 namespace anbox {
 namespace rpc {
-static constexpr const long header_size{3};
+static constexpr const long header_size{4};
 static constexpr unsigned int const serialization_buffer_size{2048};
 
 enum MessageType {
diff --git a/src/anbox/rpc/message_processor.cpp b/src/anbox/rpc/message_processor.cpp
index 90e70ef..ba25a5a 100644
--- a/src/anbox/rpc/message_processor.cpp
+++ b/src/anbox/rpc/message_processor.cpp
@@ -47,9 +47,10 @@ bool MessageProcessor::process_data(const std::vector<std::uint8_t> &data) {
 
   while (buffer_.size() > 0) {
     const auto high = buffer_[0];
-    const auto low = buffer_[1];
-    size_t const message_size = (high << 8) + low;
-    const auto message_type = buffer_[2];
+    const auto medium = buffer_[1];
+    const auto low = buffer_[2];
+    size_t const message_size = (high << 16) + (medium << 8) + low;
+    const auto message_type = buffer_[3];
 
     // If we don't have yet all bytes for a new message return and wait
     // until we have all.
@@ -101,6 +102,7 @@ void MessageProcessor::send_response(::google::protobuf::uint32 id,
 
   const size_t size = send_response_buffer.size();
   const unsigned char header_bytes[header_size] = {
+      static_cast<unsigned char>((size >> 16) & 0xff),
       static_cast<unsigned char>((size >> 8) & 0xff),
       static_cast<unsigned char>((size >> 0) & 0xff), MessageType::response,
   };