diff --git a/src/main.cpp b/src/main.cpp
index f90d76a55..9bbd60e48 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -173,6 +173,7 @@
 #include "modes/demo_world.hpp"
 #include "modes/profile_world.hpp"
 #include "network/network_config.hpp"
+#include "network/network_string.hpp"
 #include "network/servers_manager.hpp"
 #include "network/stk_host.hpp"
 #include "online/profile_manager.hpp"
@@ -1669,6 +1670,7 @@ static void cleanUserConfig()
 void runUnitTests()
 {
     GraphicsRestrictions::unitTesting();
+    NewNetworkString::unitTesting();
     // Test easter mode: in 2015 Easter is 5th of April - check with 0 days
     // before and after
     int saved_easter_mode = UserConfigParams::m_easter_ear_mode;
@@ -1698,4 +1700,4 @@ void runUnitTests()
     assert( isEasterMode(22, 3, 2016, 5));
     assert(!isEasterMode(21, 3, 2016, 5));
     UserConfigParams::m_easter_ear_mode = saved_easter_mode;
-}   // unitTesting
+}   // runUnitTests
diff --git a/src/network/event.cpp b/src/network/event.cpp
index 0795af179..5bec7e7b3 100644
--- a/src/network/event.cpp
+++ b/src/network/event.cpp
@@ -46,20 +46,24 @@ Event::Event(ENetEvent* event)
     }
     if (m_type == EVENT_TYPE_MESSAGE)
     {
-        m_data = NetworkString(std::string((char*)(event->packet->data),
-                               event->packet->dataLength-1));
+        m_data = new NewNetworkString(event->packet->data, 
+                                      event->packet->dataLength);
     }
 
-    m_packet = NULL;
     if (event->packet)
     {
-        m_packet = event->packet;
         // we got all we need, just remove the data.
-        enet_packet_destroy(m_packet);
+        enet_packet_destroy(event->packet);
     }
-    m_packet = NULL;
 
     m_peer = STKHost::get()->getPeer(event->peer);
+    if(m_data->getToken()!=m_peer->getClientServerToken() )
+    {
+        Log::error("Event", "Received event with invalid token!");
+        Log::error("Event", "HostID %d Token %d message token %d",
+            m_peer->getHostId(), m_peer->getClientServerToken(),
+            m_data->getToken());
+    }
 }   // Event(ENetEvent)
 
 // ----------------------------------------------------------------------------
@@ -70,7 +74,7 @@ Event::~Event()
     // Do not delete m_peer, it's a pointer to the enet data structure
     // which is persistent.
     m_peer = NULL;
-    m_packet = NULL;
+    delete m_data;
 }   // ~Event
 
 // ----------------------------------------------------------------------------
@@ -79,6 +83,6 @@ Event::~Event()
  */
 void Event::removeFront(int size)
 {
-    m_data.removeFront(size);
+    m_data->removeFront(size);
 }   // removeFront
 
diff --git a/src/network/event.hpp b/src/network/event.hpp
index 60e324a93..4552b5dab 100644
--- a/src/network/event.hpp
+++ b/src/network/event.hpp
@@ -24,12 +24,12 @@
 #ifndef EVENT_HPP
 #define EVENT_HPP
 
-#include "network/network_string.hpp"
 #include "utils/leak_check.hpp"
 #include "utils/types.hpp"
 
 #include "enet/enet.h"
 
+class NewNetworkString;
 class STKPeer;
 
 /*!
@@ -57,11 +57,9 @@ class Event
 {
 private:
     LEAK_CHECK()
-    /** Copy of the data passed by the event. */
-    NetworkString m_data;
 
-    /** A pointer on the ENetPacket to be deleted. */
-    ENetPacket* m_packet;
+    /** Copy of the data passed by the event. */
+    NewNetworkString *m_data;
 
     /**  Type of the event. */
     EVENT_TYPE m_type;
@@ -85,12 +83,12 @@ public:
     /** \brief Get a const reference to the received data.
      *  This is empty for events like connection or disconnections. 
      */
-    const NetworkString& data() const { return m_data; }
+    const NewNetworkString& data() const { return *m_data; }
     // ------------------------------------------------------------------------
     /** \brief Get a non-const reference to the received data.
      *  A copy of the message data. This is empty for events like
      *  connection or disconnections. */
-    NetworkString& data() { return m_data; }
+    NewNetworkString& data() { return *m_data; }
     // ------------------------------------------------------------------------
 
 };   // class Event
diff --git a/src/network/network.cpp b/src/network/network.cpp
index 4e9ee517b..147f6f118 100755
--- a/src/network/network.cpp
+++ b/src/network/network.cpp
@@ -99,8 +99,7 @@ void Network::sendRawPacket(uint8_t* data, int length,
     sendto(m_host->socket, (char*)data, length, 0,(sockaddr*)&to, to_len);
     Log::verbose("Network", "Raw packet sent to %s",
                  dst.toString().c_str());
-    Network::logPacket(NetworkString(std::string((char*)(data), length)),
-                       false);
+    Network::logPacket(NewNetworkString(data, length), false);
 }   // sendRawPacket
 
 // ----------------------------------------------------------------------------
@@ -146,7 +145,7 @@ int Network::receiveRawPacket(char *buffer, int buf_len,
     if(len<0)
         return -1;
 
-    Network::logPacket(NetworkString(std::string(buffer, len)), true);
+    Network::logPacket(NewNetworkString((uint8_t*)buffer, len), true);
     sender->setIP(ntohl((uint32_t)(addr.sin_addr.s_addr)) );
     sender->setPort( ntohs(addr.sin_port) );
     if (addr.sin_family == AF_INET)
@@ -161,9 +160,9 @@ int Network::receiveRawPacket(char *buffer, int buf_len,
 /** \brief Broadcasts a packet to all peers.
  *  \param data : Data to send.
  */
-void Network::broadcastPacket(const NetworkString& data, bool reliable)
+void Network::broadcastPacket(const NewNetworkString& data, bool reliable)
 {
-    ENetPacket* packet = enet_packet_create(data.getBytes(), data.size() + 1,
+    ENetPacket* packet = enet_packet_create(data.getData(), data.size() + 1,
                                       reliable ? ENET_PACKET_FLAG_RELIABLE
                                                : ENET_PACKET_FLAG_UNSEQUENCED);
     enet_host_broadcast(m_host, 0, packet);
@@ -189,7 +188,7 @@ void Network::openLog()
  *  \param incoming : True if the packet comes from a peer.
  *  False if it's sent to a peer.
  */
-void Network::logPacket(const NetworkString &ns, bool incoming)
+void Network::logPacket(const NewNetworkString &ns, bool incoming)
 {
     if (m_log_file.getData() == NULL) // read only access, no need to lock
         return;
diff --git a/src/network/network.hpp b/src/network/network.hpp
index ad217caae..e42aab76a 100644
--- a/src/network/network.hpp
+++ b/src/network/network.hpp
@@ -33,7 +33,7 @@
 
 #include <stdio.h>
 
-class NetworkString;
+class NewNetworkString;
 class TransportAddress;
 
 /** \class EnetHost
@@ -57,14 +57,14 @@ public:
     virtual  ~Network();
 
     static void openLog();
-    static void logPacket(const NetworkString &ns, bool incoming);
+    static void logPacket(const NewNetworkString &ns, bool incoming);
     static void closeLog();
     ENetPeer *connectTo(const TransportAddress &address);
     void     sendRawPacket(uint8_t* data, int length,
                            const TransportAddress& dst);
     int receiveRawPacket(char *buffer, int buf_len,
                          TransportAddress* sender, int max_tries = -1);
-    void     broadcastPacket(const NetworkString& data,
+    void     broadcastPacket(const NewNetworkString& data,
                              bool reliable = true);
     // ------------------------------------------------------------------------
     /** Returns a pointer to the ENet host object. */
diff --git a/src/network/network_console.cpp b/src/network/network_console.cpp
index 43d744ebc..d7a0bfc59 100644
--- a/src/network/network_console.cpp
+++ b/src/network/network_console.cpp
@@ -173,7 +173,7 @@ void NetworkConsole::kickAllPlayers()
 }   // kickAllPlayers
 
 // ----------------------------------------------------------------------------
-void NetworkConsole::sendPacket(const NetworkString& data, bool reliable)
+void NetworkConsole::sendPacket(const NewNetworkString& data, bool reliable)
 {
     m_localhost->broadcastPacket(data, reliable);
 }   // sendPacket
diff --git a/src/network/network_console.hpp b/src/network/network_console.hpp
index 16cf9228a..5579d3fc1 100644
--- a/src/network/network_console.hpp
+++ b/src/network/network_console.hpp
@@ -23,7 +23,7 @@
 
 #include "pthread.h"
 
-class NetworkString;
+class NewNetworkString;
 class STKHost;
 
 class NetworkConsole
@@ -43,14 +43,14 @@ public:
     virtual ~NetworkConsole();
 
     virtual void run();
-
-    void setMaxPlayers(uint8_t count) { m_max_players = count; }
-    uint8_t getMaxPlayers() { return m_max_players; }
-
     void kickAllPlayers();
-
-    virtual void sendPacket(const NetworkString& data, bool reliable = true);
-
+    virtual void sendPacket(const NewNetworkString& data,
+                            bool reliable = true);
+    // ------------------------------------------------------------------------
+    void setMaxPlayers(uint8_t count) { m_max_players = count; }
+    // ------------------------------------------------------------------------
+    uint8_t getMaxPlayers() { return m_max_players; }
+    // ------------------------------------------------------------------------
     virtual bool isServer() { return true; }
 
 };   // class NetworkConsole
diff --git a/src/network/network_string.cpp b/src/network/network_string.cpp
index ab5779f54..973c62c64 100644
--- a/src/network/network_string.cpp
+++ b/src/network/network_string.cpp
@@ -27,7 +27,7 @@ NetworkString operator+(NetworkString const& a, NetworkString const& b)
 
 // ----------------------------------------------------------------------------
 /** Adds one byte for the length of the string, and then (up to 255 of)
-*  the characters of the given string. */
+ *  the characters of the given string. */
 NetworkString& NetworkString::encodeString(const std::string &value)
 {
     int len = value.size();
@@ -77,3 +77,96 @@ int NetworkString::decodeStringW(int pos, irr::core::stringw *out) const
     *out = StringUtils::utf8ToWide(s);
     return len;
 }   // decodeString 
+
+// ============================================================================
+void NewNetworkString::unitTesting()
+{
+    NewNetworkString s(PROTOCOL_LOBBY_ROOM);
+    assert(s.getProtocolType() == PROTOCOL_LOBBY_ROOM);
+    assert(s.getProtocolType() != PROTOCOL_KART_UPDATE);
+    assert(!s.isSynchronous());
+    s.setSynchronous(true);
+    assert(s.isSynchronous());
+    s.setSynchronous(false);
+    assert(!s.isSynchronous());
+
+    uint32_t token = 0x12345678;
+    // Check token setting and reading
+    s.setToken(token);
+    assert(s.getToken()==token);
+    assert(s.getToken()!=0x87654321);
+
+    // Append some values from the message
+    s.addUInt16(12345);
+    s.addFloat(1.2345f);
+
+    // Ignore message type and token
+    s.removeFront(5);
+
+    assert(s.getUInt16(0) == 12345);
+    float f = s.getFloat(2);
+    assert(f==1.2345f);
+
+    // Check modifying a token in an already assembled message
+    uint32_t new_token = 0x87654321;
+    s.setToken(new_token);
+    assert(s.getToken()!=token);
+    assert(s.getToken()==new_token);
+
+}   // unitTesting
+
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+/** Adds one byte for the length of the string, and then (up to 255 of)
+ *  the characters of the given string. */
+NewNetworkString& NewNetworkString::encodeString(const std::string &value)
+{
+    int len = value.size();
+    if(len<=255)
+        return this->addUInt8(len).addString(value);
+    else
+        return addUInt8(255).addString(value.substr(0, 255));
+}   // encodeString
+
+// ----------------------------------------------------------------------------
+ /** Adds one byte for the length of the string, and then (up to 255 of)
+ *  the characters of the given string. */
+NewNetworkString& NewNetworkString::encodeString(const irr::core::stringw &value)
+{
+    std::string v = StringUtils::wideToUtf8(value);
+    return encodeString(v);
+}   // encodeString
+
+// ----------------------------------------------------------------------------
+/** Returns a string at the given position. The first byte indicates the
+ *  length, followed by the actual string (not 0 terminated).
+ *  \param[in] pos Buffer position where the encoded string starts.
+ *  \param[out] out The decoded string.
+ *  \return number of bytes read = 1+length of string
+ */
+int NewNetworkString::decodeString(int pos, std::string *out) const
+{
+    uint8_t len = get<uint8_t>(pos);
+    *out = getString(pos+1, len);
+    return len+1;
+}    // decodeString
+
+// ----------------------------------------------------------------------------
+/** Returns an irrlicht wide string from the utf8 encoded string at the 
+ *  given position.
+ *  \param[in] pos Buffer position where the encoded string starts.
+ *  \param[out] out The decoded string.
+ *  \return number of bytes read. If there are no special characters in the
+ *          string that will be 1+length of string, but multi-byte encoded
+ *          characters can mean that the length of the returned string is
+ *          less than the number of bytes read.
+ */
+int NewNetworkString::decodeStringW(int pos, irr::core::stringw *out) const
+{
+    std::string s;
+    int len = decodeString(pos, &s);
+    *out = StringUtils::utf8ToWide(s);
+    return len;
+}   // decodeString 
+
diff --git a/src/network/network_string.hpp b/src/network/network_string.hpp
index dafc1f39b..39a0965bf 100644
--- a/src/network/network_string.hpp
+++ b/src/network/network_string.hpp
@@ -23,6 +23,7 @@
 #ifndef NETWORK_STRING_HPP
 #define NETWORK_STRING_HPP
 
+#include "network/protocol.hpp"
 #include "utils/types.hpp"
 #include "utils/vec3.hpp"
 
@@ -539,5 +540,290 @@ public:
 };   // class NetworkString
 
 NetworkString operator+(NetworkString const& a, NetworkString const& b);
+// ============================================================================
+
+/** A new implementation of NetworkString, which has a fixed format:
+ *  Byte 0: The type of the message, which is actually a bit field:
+ *          bit 7:    if set, the message needs to be handled synchronously,
+ *                    otherwise it can be handled by the separate protocol
+ *                    manager thread.
+ *          bits 6-0: The protocol ID, which identifies the receiving protocol
+ *                    for this message.
+ *  Byte 1-4: A token to authenticate the sender.
+ * 
+ *  Otherwise this class offers template functions to add arbitrary variables,
+ *  and retrieve them again. It kept the functionality of 'removing' bytes
+ *  (e.g. the ProtocolManager would remove the first byte - protocol type -
+ *  so that the protocols would not see this byte). But this is implemented
+ *  now by using a base pointer (and not by moving the buffer content).
+ */
+class NewNetworkString
+{
+private:
+    /** The actual buffer. */
+    std::vector<uint8_t> m_buffer;
+
+    /** To avoid copying the buffer when bytes are deleted (which only
+     *  happens at the front), use an offset index. All positions given
+     *  by the user will be relative to this index. Note that the type
+     *  should be left as signed, otherwise certain arithmetic (e.g.
+     *  1-m_current_offset in checkToken() will be done unsigned).
+     */
+    int m_current_offset;
+
+    // ------------------------------------------------------------------------
+    /** Returns a part of the network string as a std::string. This is an
+    *  internal function only, the user should call decodeString(W) instead.
+    *  \param pos First position to be in the string.
+    *  \param len Number of bytes to copy.
+    */
+    std::string getString(int pos, int len) const 
+    {
+        return std::string(m_buffer.begin() + (m_current_offset+pos      ),
+                           m_buffer.begin() + (m_current_offset+pos + len) ); 
+    }   // getString
+    // ------------------------------------------------------------------------
+    /** Adds a std::string. Internal use only. */
+    NewNetworkString& addString(const std::string& value)
+    {
+        for (unsigned int i = 0; i < value.size(); i++)
+            m_buffer.push_back((uint8_t)(value[i]));
+        return *this;
+    }   // addString
+
+public:
+    static void unitTesting();
+        
+    /** Constructor, sets the protocol type of this message. */
+    NewNetworkString(ProtocolType type,  int capacity=16)
+    {
+        m_buffer.reserve(capacity);
+        m_buffer.push_back(type);
+        m_current_offset = 0;
+    }   // NewNetworkString
+
+    // ------------------------------------------------------------------------
+    NewNetworkString(const uint8_t *data, int len)
+    {
+        m_buffer.resize(len);
+        memcpy(m_buffer.data(), data, len);
+    }   // NewNetworkString
+
+    // ------------------------------------------------------------------------
+    /** Returns a byte pointer to the content of the network string. */
+    uint8_t* getData() { return &m_buffer[0]; };
+
+    // ------------------------------------------------------------------------
+    /** Returns a byte pointer to the content of the network string. */
+    const uint8_t* getData() const { return &m_buffer[0]; };
+
+    // ------------------------------------------------------------------------
+    /** Returns the protocol type of this message. */
+    ProtocolType getProtocolType() const
+    {
+        assert(!m_buffer.empty());
+        return (ProtocolType)m_buffer[0];
+    }   // getProtocolType
+
+    // ------------------------------------------------------------------------
+    /** Sets if this message is to be sent synchronous or asynchronous. */
+    void setSynchronous(bool b)
+    {
+        if(b)
+            m_buffer[0] |= PROTOCOL_SYNCHRONOUS;
+        else
+            m_buffer[0] &= !PROTOCOL_SYNCHRONOUS;
+    }   // setSynchronous
+    // ------------------------------------------------------------------------
+    /** Returns if this message is synchronous or not. */
+    bool isSynchronous() const
+    {
+        return (m_buffer[0] & PROTOCOL_SYNCHRONOUS) != 0;
+    }   // isSynchronous
+    // ------------------------------------------------------------------------
+    /** Sets a token for a message. Note that the token in an already
+    *  assembled message might be updated (e.g. if the same message is sent
+    *  from the server to a set of clients). */
+    void setToken(uint32_t token)
+    {
+        // Make sure there is enough space for the token:
+        if(m_buffer.size()<5)
+            m_buffer.resize(5);
+
+        m_buffer[1] = (token >> 24) & 0xff;
+        m_buffer[2] = (token >> 16) & 0xff;
+        m_buffer[3] = (token >>  8) & 0xff;
+        m_buffer[4] =  token        & 0xff;
+    }   // setToken
+
+    // ------------------------------------------------------------------------
+    /** Returns if the security token of this message is the same as the
+     *  specified token. */
+    uint32_t getToken() const 
+    {
+        // Since m_current_offset might be set, we need to make sure
+        // to really access bytes 1-4
+        return getUInt32(1-m_current_offset);
+    }   // getToken
+    // ------------------------------------------------------------------------
+    /** Returns the current length of the network string. */
+    int size() const { return (int)m_buffer.size(); }
+    // ------------------------------------------------------------------------
+    /** Returns the content of the network string as a std::string. */
+    const std::string std_string() const
+    {
+        std::string str(m_buffer.begin(), m_buffer.end());
+        return str;
+    }   // std_string
+    // ------------------------------------------------------------------------
+
+    // All functions related to adding data to a network string
+    // ========================================================
+    /** Add 8 bit unsigned int. */
+    NewNetworkString& addUInt8(const uint8_t value)
+    {
+        m_buffer.push_back(value);
+        return *this;
+    }   // addUInt8
+
+    // ------------------------------------------------------------------------
+    /** Adds 16 bit unsigned int. */
+    NewNetworkString& addUInt16(const uint16_t value)
+    {
+        m_buffer.push_back((value >> 8) & 0xff);
+        m_buffer.push_back(value & 0xff);
+        return *this;
+    }   // addUInt16
+
+    // ------------------------------------------------------------------------
+    /** Adds unsigned 32 bit integer. */
+    NewNetworkString& addUInt32(const uint32_t& value)
+    {
+        m_buffer.push_back((value >> 24) & 0xff);
+        m_buffer.push_back((value >> 16) & 0xff);
+        m_buffer.push_back((value >>  8) & 0xff);
+        m_buffer.push_back( value        & 0xff);
+        return *this;
+    }   // addUInt32
+
+    // ------------------------------------------------------------------------
+    /** Adds a 4 byte floating point value. */
+    NewNetworkString& addFloat(const float value)
+    {
+        uint32_t *p = (uint32_t*)&value;
+        return addUInt32(*p);
+    }   // addFloat
+
+    // ------------------------------------------------------------------------
+    /** Adds the content of another network string. */
+    NewNetworkString& operator+=(NewNetworkString const& value)
+    {
+        m_buffer.insert(m_buffer.end(), value.m_buffer.begin(), 
+                        value.m_buffer.end()   );
+        return *this;
+    }   // operator+=
+
+    // ------------------------------------------------------------------------
+    /** Adds the xyz components of a Vec3 to the string. */
+    NewNetworkString& add(const Vec3 &xyz)
+    {
+        return addFloat(xyz.getX()).addFloat(xyz.getY()).addFloat(xyz.getZ());
+    }   // add
+
+    // ------------------------------------------------------------------------
+    /** Adds the four components of a quaternion. */
+    NewNetworkString& add(const btQuaternion &quat)
+    {
+        return addFloat(quat.getX()).addFloat(quat.getY())
+              .addFloat(quat.getZ()).addFloat(quat.getW());
+    }   // add
+
+    // Functions related to getting data from a network string
+    // =======================================================
+    /** Ignore the next num_bytes from the message.
+     */
+    void removeFront(unsigned int num_bytes)
+    {
+        assert(m_current_offset + num_bytes <= m_buffer.size());
+        m_current_offset += num_bytes;
+    }   // removeFront
+
+    // ------------------------------------------------------------------------
+    /** Gets the byte at the specified position (taking current offset into
+     *  account). */
+    uint8_t operator[](const int pos) const
+    {
+        return m_buffer[m_current_offset + pos];
+    }   // operator[]
+
+private:
+    // ------------------------------------------------------------------------
+    /** Template to get n bytes from a buffer into a single data type. */
+    template<typename T, size_t n>
+    T get(int pos) const
+    {
+        int a = n;
+        T result = 0;
+        int offset = m_current_offset + pos + n -1;
+        while (a--)
+        {
+            result <<= 8; // offset one byte
+                          // add the data to result
+            result += m_buffer[offset - a];
+        }
+        return result;
+    }   // get(int pos)
+    // ------------------------------------------------------------------------
+    /** Another function for n == 1 to surpress warnings in clang. */
+    template<typename T>
+    T get(int pos) const
+    {
+        return m_buffer[pos];
+    }   // get
+
+public:
+    // ------------------------------------------------------------------------
+    /** Returns a unsigned 32 bit integer. */
+    inline uint32_t getUInt32(int pos = 0) const { return get<uint32_t, 4>(pos); }
+    // ------------------------------------------------------------------------
+    /** Returns an unsigned 16 bit integer. */
+    inline uint16_t getUInt16(int pos=0) const { return get<uint16_t, 2>(pos); }
+    // ------------------------------------------------------------------------
+    /** Returns an unsigned 8-bit integer. */
+    inline uint8_t getUInt8(int pos = 0)  const
+    {
+        return m_buffer[m_current_offset + pos];
+    }   // getUInt8
+    
+    // ------------------------------------------------------------------------
+    /** Gets a 4 byte floating point value. */
+    float getFloat(int pos=0) const
+    {
+        uint32_t u = getUInt32(pos);
+        return *(float*)&u;
+    }   // getFloat
+
+    // ------------------------------------------------------------------------
+    /** Gets a Vec3. */
+    Vec3 getVec3(int pos=0) const
+    {
+        return Vec3(getFloat(pos), getFloat(pos+4), getFloat(pos+8));
+    }   // getVec3
+    // ------------------------------------------------------------------------
+    /** Gets a Vec3. */
+    btQuaternion getQuat(int pos=0) const
+    {
+        return btQuaternion(getFloat(pos),   getFloat(pos+ 4),
+                            getFloat(pos+8), getFloat(pos+12) );
+    }   // getQuat
+    // ------------------------------------------------------------------------
+    NewNetworkString& encodeString(const std::string &value);
+    NewNetworkString& encodeString(const irr::core::stringw &value);
+    int decodeString(int n, std::string *out) const;
+    int decodeStringW(int n, irr::core::stringw *out) const;
+    // ------------------------------------------------------------------------
+
+};   // class NetworkString
+
 
 #endif // NETWORK_STRING_HPP
diff --git a/src/network/protocol.cpp b/src/network/protocol.cpp
index 7ac7807a0..1c3e3d1d0 100644
--- a/src/network/protocol.cpp
+++ b/src/network/protocol.cpp
@@ -19,6 +19,7 @@
 #include "network/protocol.hpp"
 
 #include "network/event.hpp"
+#include "network/network_string.hpp"
 #include "network/protocol_manager.hpp"
 #include "network/stk_host.hpp"
 #include "network/stk_peer.hpp"
@@ -46,10 +47,19 @@ Protocol::~Protocol()
 {
 }   // ~Protocol
 
+// ----------------------------------------------------------------------------
+/** Returns a network string with the given type.
+ *  \capacity Default preallocated size for the message.
+ */
+NewNetworkString* Protocol::getNetworkString(int capacity)
+{
+    return new NewNetworkString(m_type, capacity);
+}   // getNetworkString
+
 // ----------------------------------------------------------------------------
 bool Protocol::checkDataSizeAndToken(Event* event, int minimum_size)
 {
-    const NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
     if (data.size() < minimum_size || data[0] != 4)
     {
         Log::warn("Protocol", "Receiving a badly "
@@ -58,7 +68,7 @@ bool Protocol::checkDataSizeAndToken(Event* event, int minimum_size)
         return false;
     }
     STKPeer* peer = event->getPeer();
-    uint32_t token = data.gui32(1);
+    uint32_t token = data.getUInt32(1);
     if (token != peer->getClientServerToken())
     {
         Log::warn("Protocol", "Peer sending bad token. Request "
@@ -71,7 +81,7 @@ bool Protocol::checkDataSizeAndToken(Event* event, int minimum_size)
 // ----------------------------------------------------------------------------
 bool Protocol::isByteCorrect(Event* event, int byte_nb, int value)
 {
-    const NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
     if (data[byte_nb] != value)
     {
         Log::info("Protocol", "Bad byte at pos %d. %d "
@@ -117,50 +127,28 @@ void Protocol::requestTerminate()
 /** Sends a message to all peers, inserting the peer's token into the message.
  *  The message is composed of a 1-byte message (usually the message type)
  *  followed by the token of this client and then actual message).
- *  \param type The first byte of the combined message.
  *  \param message The actual message content.
 */
-void Protocol::sendMessageToPeersChangingToken(uint8_t type,
-                                               const NetworkString &message)
+void Protocol::sendMessageToPeersChangingToken(NewNetworkString *message)
 {
     const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
     for (unsigned int i = 0; i < peers.size(); i++)
     {
-        NetworkString combined(1+4+message.size());
-        combined.addUInt8(type).addUInt8(4)
-                .addUInt32(peers[i]->getClientServerToken());
-        combined+=message;
-        ProtocolManager::getInstance()->sendMessage(this, peers[i], combined);
+        message->setToken(peers[i]->getClientServerToken());
+        ProtocolManager::getInstance()->sendMessage(peers[i], *message);
     }
 }   // sendMessageToPeersChangingToken
 
 // ----------------------------------------------------------------------------
-void Protocol::sendMessage(const NetworkString& message, bool reliable)
+void Protocol::sendMessage(const NewNetworkString &message, bool reliable)
 {
-    ProtocolManager::getInstance()->sendMessage(this, message, reliable,
-                                                /*synchronous*/false);
+    ProtocolManager::getInstance()->sendMessage(message, reliable);
 }   // sendMessage
 
 // ----------------------------------------------------------------------------
-void Protocol::sendSynchronousMessage(const NetworkString& message, 
-                                      bool reliable)
-{
-    ProtocolManager::getInstance()->sendMessage(this, message, reliable,
-                                                /*synchron*/true);
-}   // sendMessage
-// ----------------------------------------------------------------------------
-void Protocol::sendMessage(STKPeer* peer, const NetworkString& message,
+void Protocol::sendMessage(STKPeer* peer, const NewNetworkString &message,
                            bool reliable)
 {
-    ProtocolManager::getInstance()->sendMessage(this, peer, message, reliable,
-                                                /*synchronous*/false);
+    ProtocolManager::getInstance()->sendMessage(peer, message, reliable);
 }   // sendMessage
 
-// ----------------------------------------------------------------------------
-void Protocol::sendSynchronousMessage(STKPeer* peer,
-                                      const NetworkString& message,
-                                      bool reliable)
-{
-    ProtocolManager::getInstance()->sendMessage(this, peer, message, reliable,
-                                                /*synchronous*/true);
-}   // sendSynchronousMessage
diff --git a/src/network/protocol.hpp b/src/network/protocol.hpp
index c67ef3d81..36804bd0f 100644
--- a/src/network/protocol.hpp
+++ b/src/network/protocol.hpp
@@ -23,12 +23,12 @@
 #ifndef PROTOCOL_HPP
 #define PROTOCOL_HPP
 
-#include "network/network_string.hpp"
 #include "utils/leak_check.hpp"
 #include "utils/no_copy.hpp"
 #include "utils/types.hpp"
 
 class Event;
+class NewNetworkString;
 class STKPeer;
 
 
@@ -121,18 +121,14 @@ public:
     virtual void asynchronousUpdate() = 0;
 
     /// functions to check incoming data easily
+    NewNetworkString* getNetworkString(int capacity=16);
     bool checkDataSizeAndToken(Event* event, int minimum_size);
     bool isByteCorrect(Event* event, int byte_nb, int value);
-    void sendMessageToPeersChangingToken(uint8_t type,
-                                         const NetworkString &message);
-    void sendMessage(const NetworkString& message,
+    void sendMessageToPeersChangingToken(NewNetworkString *message);
+    void sendMessage(const NewNetworkString &message,
                      bool reliable = true);
-    void sendMessage(STKPeer* peer, const NetworkString& message,
+    void sendMessage(STKPeer* peer, const NewNetworkString &message,
                      bool reliable = true);
-    void sendSynchronousMessage(const NetworkString& message, 
-                                bool reliable=true);
-    void sendSynchronousMessage(STKPeer* peer, const NetworkString& message,
-                                bool reliable = true);
     void requestStart();
     void requestPause();
     void requestUnpause();
diff --git a/src/network/protocol_manager.cpp b/src/network/protocol_manager.cpp
index e5bcb8a7a..109dab5fc 100644
--- a/src/network/protocol_manager.cpp
+++ b/src/network/protocol_manager.cpp
@@ -177,43 +177,25 @@ void ProtocolManager::propagateEvent(Event* event)
 }   // propagateEvent
 
 // ----------------------------------------------------------------------------
-void ProtocolManager::sendMessage(Protocol* sender, const NetworkString& message,
-                                  bool reliable, bool send_synchronously)
+void ProtocolManager::sendMessage(const NewNetworkString &message, bool reliable)
 {
-    NetworkString new_message(1+message.size());
-    ProtocolType type = sender->getProtocolType();
-    // Set flag if the message must be handled synchronously on arrivat
-    if(send_synchronously)
-        type = ProtocolType(type | PROTOCOL_SYNCHRONOUS);
-    new_message.ai8(type); // add one byte to add protocol type
-    new_message += message;
-    STKHost::get()->sendMessage(new_message, reliable);
+    STKHost::get()->sendMessage(message, reliable);
 }   // sendMessage
 
 // ----------------------------------------------------------------------------
-void ProtocolManager::sendMessage(Protocol* sender, STKPeer* peer,
-                                  const NetworkString& message, bool reliable,
-                                  bool send_synchronously)
+void ProtocolManager::sendMessage(STKPeer *peer,
+                                  const NewNetworkString &message,
+                                  bool reliable)
 {
-    NetworkString new_message(1+message.size());
-    ProtocolType type = sender->getProtocolType();
-    // Set flag if the message must be handled synchronously on arrivat
-    if(send_synchronously)
-        type = ProtocolType(type | PROTOCOL_SYNCHRONOUS);
-    new_message.ai8(type); // add one byte to add protocol type
-    new_message += message;
-    peer->sendPacket(new_message, reliable);
+    peer->sendPacket(message, reliable);
 }   // sendMessage
 
 // ----------------------------------------------------------------------------
-void ProtocolManager::sendMessageExcept(Protocol* sender, STKPeer* peer,
-                                        const NetworkString& message,
+void ProtocolManager::sendMessageExcept(STKPeer *peer,
+                                        const NewNetworkString &message,
                                         bool reliable)
 {
-    NetworkString new_message(1+message.size());
-    new_message.ai8(sender->getProtocolType()); // add one byte to add protocol type
-    new_message += message;
-    STKHost::get()->sendPacketExcept(peer, new_message, reliable);
+    STKHost::get()->sendPacketExcept(peer, message, reliable);
 }   // sendMessageExcept
 
 // ----------------------------------------------------------------------------
diff --git a/src/network/protocol_manager.hpp b/src/network/protocol_manager.hpp
index d05b9833e..67bf7c7f0 100644
--- a/src/network/protocol_manager.hpp
+++ b/src/network/protocol_manager.hpp
@@ -162,16 +162,13 @@ private:
 public:
     virtual void      abort();
     virtual void      propagateEvent(Event* event);
-    virtual void      sendMessage(Protocol* sender,
-                                  const NetworkString& message,
-                                  bool reliable = true,
-                                  bool send_synchronously = false);
-    virtual void      sendMessage(Protocol* sender, STKPeer* peer,
-                                  const NetworkString& message,
-                                  bool reliable = true,
-                                  bool send_synchronously = false);
-    virtual void      sendMessageExcept(Protocol* sender, STKPeer* peer,
-                                        const NetworkString& message,
+    virtual void      sendMessage(const NewNetworkString &message,
+                                  bool reliable = true);
+    virtual void      sendMessage(STKPeer* peer,
+                                  const NewNetworkString &message,
+                                  bool reliable = true);
+    virtual void      sendMessageExcept(STKPeer* peer,
+                                        const NewNetworkString &message,
                                         bool reliable = true);
     virtual uint32_t  requestStart(Protocol* protocol);
     virtual void      requestPause(Protocol* protocol);
diff --git a/src/network/protocols/client_lobby_room_protocol.cpp b/src/network/protocols/client_lobby_room_protocol.cpp
index 15c9d20a7..9a2041eca 100644
--- a/src/network/protocols/client_lobby_room_protocol.cpp
+++ b/src/network/protocols/client_lobby_room_protocol.cpp
@@ -60,44 +60,55 @@ void ClientLobbyRoomProtocol::setup()
 
 void ClientLobbyRoomProtocol::requestKartSelection(const std::string &kart_name)
 {
-    NetworkString request(6+1+kart_name.size());
+    NewNetworkString *request = getNetworkString(6+1+kart_name.size());
     // size_token (4), token, size kart name, kart name
-    request.ai8(LE_KART_SELECTION).ai8(4).ai32(m_server->getClientServerToken())
-           .encodeString(kart_name);
-    sendMessage(request, true);
+    request->setToken(m_server->getClientServerToken());
+    request->addUInt8(LE_KART_SELECTION).encodeString(kart_name);
+
+    NewNetworkString *r = getNetworkString(7+kart_name.size());
+    r->setToken(m_server->getClientServerToken());
+    r->addUInt8(LE_KART_SELECTION).addUInt8(4).encodeString(kart_name);
+    sendMessage(*r, true);
+    delete r;
 }   // requestKartSelection
 
 //-----------------------------------------------------------------------------
 
 void ClientLobbyRoomProtocol::voteMajor(uint32_t major)
 {
-    NetworkString request(8);
+    NewNetworkString *request = getNetworkString(8);
+    request->setToken(m_server->getClientServerToken());
     // size_token (4), token, size major(1),major
-    request.ai8(LE_VOTE_MAJOR).ai8(4)
-           .ai32(m_server->getClientServerToken()).ai8(4).addUInt32(major);
-    sendMessage(request, true);
+    request->addUInt8(LE_VOTE_MAJOR).addUInt8(4)
+           .addUInt8(4).addUInt32(major);
+    sendMessage(*request, true);
+    delete request;
 }   // voteMajor
 
 //-----------------------------------------------------------------------------
 
 void ClientLobbyRoomProtocol::voteRaceCount(uint8_t count)
 {
-    NetworkString request(8);
+    NewNetworkString *request = getNetworkString(8);
+    request->setToken(m_server->getClientServerToken());
     // size_token (4), token, size race count(1), count
-    request.ai8(LE_VOTE_RACE_COUNT).ai8(4)
-           .ai32(m_server->getClientServerToken()).ai8(1).ai8(count);
-    sendMessage(request, true);
+    request->addUInt8(LE_VOTE_RACE_COUNT).addUInt8(4)
+           .addUInt8(1).addUInt8(count);
+    sendMessage(*request, true);
+    delete request;
 }   // voteRaceCount
 
 //-----------------------------------------------------------------------------
 
 void ClientLobbyRoomProtocol::voteMinor(uint32_t minor)
 {
-    NetworkString request(8);
+    NewNetworkString *request = getNetworkString(8);
+    request->setToken(m_server->getClientServerToken());
     // size_token (4), token, size minor(1),minor
-    request.ai8(LE_VOTE_MINOR).ai8(4).ai32(m_server->getClientServerToken())
-           .ai8(4).addUInt32(minor);
-    sendMessage(request, true);
+    request->addUInt8(LE_VOTE_MINOR).addUInt8(4)
+           .addUInt8(4).addUInt32(minor);
+    sendMessage(*request, true);
+    delete request;
 }   // voteMinor
 
 //-----------------------------------------------------------------------------
@@ -105,33 +116,38 @@ void ClientLobbyRoomProtocol::voteMinor(uint32_t minor)
 void ClientLobbyRoomProtocol::voteTrack(const std::string &track,
                                         uint8_t track_nb)
 {
-    NetworkString request(8+1+track.size());
+    NewNetworkString *request = getNetworkString(8+1+track.size());
+    request->setToken(m_server->getClientServerToken());
     // size_token (4), token, size track, track, size #track, #track
-    request.ai8(LE_VOTE_TRACK).ai8(4).ai32(m_server->getClientServerToken())
-           .encodeString(track).ai8(1).ai8(track_nb);
-    sendMessage(request, true);
+    request->addUInt8(LE_VOTE_TRACK).addUInt8(4)
+           .encodeString(track).addUInt8(1).addUInt8(track_nb);
+    sendMessage(*request, true);
+    delete request;
 }   // voteTrack
 
 //-----------------------------------------------------------------------------
 
 void ClientLobbyRoomProtocol::voteReversed(bool reversed, uint8_t track_nb)
 {
-    NetworkString request(9);
+    NewNetworkString *request = getNetworkString(9);
+    request->setToken(m_server->getClientServerToken());
     // size_token (4), token, size reversed(1),reversed, size #track, #track
-    request.ai8(LE_VOTE_REVERSE).ai8(4).ai32(m_server->getClientServerToken())
-           .ai8(1).ai8(reversed).ai8(1).ai8(track_nb);
-    sendMessage(request, true);
+    request->addUInt8(LE_VOTE_REVERSE).addUInt8(4)
+           .addUInt8(1).addUInt8(reversed).addUInt8(1).addUInt8(track_nb);
+    sendMessage(*request, true);
+    delete request;
 }   // voteReversed
 
 //-----------------------------------------------------------------------------
 
 void ClientLobbyRoomProtocol::voteLaps(uint8_t laps, uint8_t track_nb)
 {
-    NetworkString request(10);
+    NewNetworkString *request = getNetworkString(10);
+    request->setToken(m_server->getClientServerToken());
     // size_token (4), token, size laps(1),laps, size #track, #track
-    request.ai8(LE_VOTE_LAPS).ai8(4).ai32(m_server->getClientServerToken())
-           .ai8(1).ai8(laps).ai8(1).ai8(track_nb);
-    sendMessage(request, true);
+    request->addUInt8(LE_VOTE_LAPS)
+           .addUInt8(1).addUInt8(laps).addUInt8(1).addUInt8(track_nb);
+    sendMessage(*request, true);
 }   // voteLaps
 
 //-----------------------------------------------------------------------------
@@ -151,7 +167,7 @@ bool ClientLobbyRoomProtocol::notifyEvent(Event* event)
     assert(m_setup); // assert that the setup exists
     if (event->getType() == EVENT_TYPE_MESSAGE)
     {
-        const NetworkString &data = event->data();
+        const NewNetworkString &data = event->data();
         assert(data.size()); // assert that data isn't empty
         uint8_t message_type = data[0];
         if (message_type != LE_KART_SELECTION_UPDATE &&
@@ -178,7 +194,7 @@ bool ClientLobbyRoomProtocol::notifyEventAsynchronous(Event* event)
     assert(m_setup); // assert that the setup exists
     if (event->getType() == EVENT_TYPE_MESSAGE)
     {
-        const NetworkString &data = event->data();
+        const NewNetworkString &data = event->data();
         assert(data.size()); // assert that data isn't empty
         uint8_t message_type = data[0];
 
@@ -244,11 +260,13 @@ void ClientLobbyRoomProtocol::update()
 
         std::string name_u8 = StringUtils::wideToUtf8(name);
         const std::string &password = NetworkConfig::get()->getPassword();
-        NetworkString ns(6+1+name_u8.size()+1+password.size());
+        NewNetworkString *ns = getNetworkString(6+1+name_u8.size()
+                                                 +1+password.size());
         // 4 (size of id), global id
-        ns.ai8(LE_CONNECTION_REQUESTED).encodeString(name)
+        ns->addUInt8(LE_CONNECTION_REQUESTED).encodeString(name)
           .encodeString(NetworkConfig::get()->getPassword());
-        sendMessage(ns);
+        sendMessage(*ns);
+        delete ns;
         m_state = REQUESTING_CONNECTION;
     }
     break;
@@ -301,7 +319,7 @@ void ClientLobbyRoomProtocol::update()
  */
 void ClientLobbyRoomProtocol::newPlayer(Event* event)
 {
-    const NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
     if (data[0] != 1)
     {
         Log::error("ClientLobbyRoomProtocol",
@@ -310,7 +328,7 @@ void ClientLobbyRoomProtocol::newPlayer(Event* event)
         return;
     }
 
-    uint8_t player_id = data.gui8(1);
+    uint8_t player_id = data.getUInt8(1);
 
     core::stringw name;
     data.decodeStringW(2, &name);
@@ -349,7 +367,7 @@ void ClientLobbyRoomProtocol::newPlayer(Event* event)
  */
 void ClientLobbyRoomProtocol::disconnectedPlayer(Event* event)
 {
-    const NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
     if (data.size() != 2 || data[0] != 1)
     {
         Log::error("ClientLobbyRoomProtocol",
@@ -383,7 +401,7 @@ void ClientLobbyRoomProtocol::disconnectedPlayer(Event* event)
  */
 void ClientLobbyRoomProtocol::connectionAccepted(Event* event)
 {
-    NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
     // At least 12 bytes should remain now
     if (data.size() < 9|| data[0] != 1 || data[2] != 4)
     {
@@ -418,7 +436,7 @@ void ClientLobbyRoomProtocol::connectionAccepted(Event* event)
     STKHost::get()->getGameSetup()->setLocalMaster(my_player_id);
     m_setup->setNumLocalPlayers(1);
     // connection token
-    uint32_t token = data.gui32(3);
+    uint32_t token = data.getUInt32(3);
     peer->setClientServerToken(token);
 
     // Add all players
@@ -467,7 +485,7 @@ void ClientLobbyRoomProtocol::connectionAccepted(Event* event)
  */
 void ClientLobbyRoomProtocol::connectionRefused(Event* event)
 {
-    const NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
     if (data.size() != 2 || data[0] != 1) // 2 bytes remains now
     {
         Log::error("ClientLobbyRoomProtocol",
@@ -508,7 +526,7 @@ void ClientLobbyRoomProtocol::connectionRefused(Event* event)
  */
 void ClientLobbyRoomProtocol::kartSelectionRefused(Event* event)
 {
-    const NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
     if (data.size() != 2 || data[0] != 1)
     {
         Log::error("ClientLobbyRoomProtocol",
@@ -547,7 +565,7 @@ void ClientLobbyRoomProtocol::kartSelectionRefused(Event* event)
  */
 void ClientLobbyRoomProtocol::kartSelectionUpdate(Event* event)
 {
-    const NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
     if (data.size() < 3 || data[0] != 1)
     {
         Log::error("ClientLobbyRoomProtocol", 
@@ -582,14 +600,14 @@ void ClientLobbyRoomProtocol::kartSelectionUpdate(Event* event)
  */
 void ClientLobbyRoomProtocol::startGame(Event* event)
 {
-    const NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
     if (data.size() < 5 || data[0] != 4)
     {
         Log::error("ClientLobbyRoomProtocol", "A message notifying a kart "
                    "selection update wasn't formated as expected.");
         return;
     }
-    uint32_t token = data.gui32(1);
+    uint32_t token = data.getUInt32(1);
     if (token == STKHost::get()->getPeers()[0]->getClientServerToken())
     {
         m_state = PLAYING;
@@ -616,14 +634,14 @@ void ClientLobbyRoomProtocol::startGame(Event* event)
  */
 void ClientLobbyRoomProtocol::startSelection(Event* event)
 {
-    const NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
     if (data.size() < 5 || data[0] != 4)
     {
         Log::error("ClientLobbyRoomProtocol", "A message notifying a kart "
                    "selection update wasn't formated as expected.");
         return;
     }
-    uint32_t token = data.gui32(1);
+    uint32_t token = data.getUInt32(1);
     if (token == STKHost::get()->getPeers()[0]->getClientServerToken())
     {
         m_state = KART_SELECTION;
@@ -648,13 +666,13 @@ void ClientLobbyRoomProtocol::startSelection(Event* event)
  */
 void ClientLobbyRoomProtocol::raceFinished(Event* event)
 {
-    NetworkString &data = event->data();
+    NewNetworkString &data = event->data();
     if (data.size() < 5)
     {
         Log::error("ClientLobbyRoomProtocol", "Not enough data provided.");
         return;
     }
-    if (event->getPeer()->getClientServerToken() != data.gui32(1))
+    if (event->getPeer()->getClientServerToken() != data.getUInt32(1))
     {
         Log::error("ClientLobbyRoomProtocol", "Bad token");
         return;
@@ -731,7 +749,7 @@ void ClientLobbyRoomProtocol::raceFinished(Event* event)
  */
 void ClientLobbyRoomProtocol::playerMajorVote(Event* event)
 {
-    const NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
     if (!checkDataSizeAndToken(event, 9))
         return;
     if (!isByteCorrect(event, 5, 1))
@@ -754,7 +772,7 @@ void ClientLobbyRoomProtocol::playerMajorVote(Event* event)
  */
 void ClientLobbyRoomProtocol::playerRaceCountVote(Event* event)
 {
-    const NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
     if (!checkDataSizeAndToken(event, 9))
         return;
     if (!isByteCorrect(event, 5, 1))
@@ -777,7 +795,7 @@ void ClientLobbyRoomProtocol::playerRaceCountVote(Event* event)
  */
 void ClientLobbyRoomProtocol::playerMinorVote(Event* event)
 {
-    const NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
     if (!checkDataSizeAndToken(event, 9))
         return;
     if (!isByteCorrect(event, 5, 1))
@@ -801,7 +819,7 @@ void ClientLobbyRoomProtocol::playerMinorVote(Event* event)
  */
 void ClientLobbyRoomProtocol::playerTrackVote(Event* event)
 {
-    const NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
     if (!checkDataSizeAndToken(event, 10))
         return;
     if (!isByteCorrect(event, 5, 1))
@@ -828,7 +846,7 @@ void ClientLobbyRoomProtocol::playerTrackVote(Event* event)
  */
 void ClientLobbyRoomProtocol::playerReversedVote(Event* event)
 {
-    const NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
     if (!checkDataSizeAndToken(event, 11))
         return;
     if (!isByteCorrect(event, 5, 1))
@@ -854,7 +872,7 @@ void ClientLobbyRoomProtocol::playerReversedVote(Event* event)
  */
 void ClientLobbyRoomProtocol::playerLapsVote(Event* event)
 {
-    const NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
     if (!checkDataSizeAndToken(event, 9))
         return;
     if (!isByteCorrect(event, 5, 1))
diff --git a/src/network/protocols/controller_events_protocol.cpp b/src/network/protocols/controller_events_protocol.cpp
index e71c72f74..0a7530362 100644
--- a/src/network/protocols/controller_events_protocol.cpp
+++ b/src/network/protocols/controller_events_protocol.cpp
@@ -50,7 +50,7 @@ bool ControllerEventsProtocol::notifyEventAsynchronous(Event* event)
     if (event->getType() != EVENT_TYPE_MESSAGE)
         return true;
 
-    const NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
     if (data.size() < 17)
     {
         Log::error("ControllerEventsProtocol",
@@ -58,15 +58,15 @@ bool ControllerEventsProtocol::notifyEventAsynchronous(Event* event)
                     data.size());
         return true;
     }
-    uint32_t token = data.gui32();
-    NetworkString pure_message = data;
+    uint32_t token = data.getUInt32();
+    NewNetworkString pure_message = data;
     pure_message.removeFront(4);
     if (token != event->getPeer()->getClientServerToken())
     {
         Log::error("ControllerEventsProtocol", "Bad token from peer.");
         return true;
     }
-    NetworkString ns = pure_message;
+    NewNetworkString ns = pure_message;
 
     ns.removeFront(4);
     uint8_t client_index = -1;
@@ -80,9 +80,9 @@ bool ControllerEventsProtocol::notifyEventAsynchronous(Event* event)
                       kart_id);
             return true;
         }
-        uint8_t serialized_1   = ns.gui8(1);
-        PlayerAction action    = (PlayerAction)(ns.gui8(4));
-        int action_value       = ns.gui32(5);
+        uint8_t serialized_1   = ns.getUInt8(1);
+        PlayerAction action    = (PlayerAction)(ns.getUInt8(4));
+        int action_value       = ns.getUInt32(5);
         Controller *controller = World::getWorld()->getKart(kart_id)
                                                   ->getController();
         KartControl *controls  = controller->getControls();
@@ -113,11 +113,9 @@ bool ControllerEventsProtocol::notifyEventAsynchronous(Event* event)
             // was sent from originally
             if(peer != event->getPeer())
             {
-                NetworkString ns2(4+pure_message.size());
-                ns2.ai32(peer->getClientServerToken());
-                ns2 += pure_message;
-                ProtocolManager::getInstance()->sendMessage(this, peer, 
-                                                            ns2, false);
+                pure_message.setToken(peer->getClientServerToken());
+                ProtocolManager::getInstance()->sendMessage(peer, pure_message,
+                                                            false);
             }   // if peer != event->getPeer()
         }   // for i in peers
     }   // if server
@@ -159,14 +157,13 @@ void ControllerEventsProtocol::controllerAction(Controller* controller,
     uint8_t serialized_2 = (uint8_t)(controls->m_accel*255.0);
     uint8_t serialized_3 = (uint8_t)(controls->m_steer*127.0);
 
-    NetworkString ns(17);
-    uint32_t token = STKHost::get()->getPeers()[0]->getClientServerToken();
-    ns.ai32(token);
-    ns.af(World::getWorld()->getTime());
-    ns.addUInt8(controller->getKart()->getWorldKartId());
-    ns.ai8(serialized_1).ai8(serialized_2).ai8(serialized_3);
-    ns.ai8((uint8_t)(action)).ai32(value);
+    NewNetworkString *ns = getNetworkString(17);
+    ns->setToken(STKHost::get()->getPeers()[0]->getClientServerToken());
+    ns->addFloat(World::getWorld()->getTime());
+    ns->addUInt8(controller->getKart()->getWorldKartId());
+    ns->addUInt8(serialized_1).addUInt8(serialized_2).addUInt8(serialized_3);
+    ns->addUInt8((uint8_t)(action)).addUInt32(value);
 
     Log::info("ControllerEventsProtocol", "Action %d value %d", action, value);
-    sendMessage(ns, false); // send message to server
+    sendMessage(*ns, false); // send message to server
 }   // controllerAction
diff --git a/src/network/protocols/game_events_protocol.cpp b/src/network/protocols/game_events_protocol.cpp
index a7ac82308..3d19a61b0 100644
--- a/src/network/protocols/game_events_protocol.cpp
+++ b/src/network/protocols/game_events_protocol.cpp
@@ -38,18 +38,18 @@ bool GameEventsProtocol::notifyEvent(Event* event)
 {
     if (event->getType() != EVENT_TYPE_MESSAGE)
         return true;
-    NetworkString &data = event->data();
+    NewNetworkString &data = event->data();
     if (data.size() < 5) // for token and type
     {
         Log::warn("GameEventsProtocol", "Too short message.");
         return true;
     }
-    if ( event->getPeer()->getClientServerToken() != data.gui32())
+    if ( event->getPeer()->getClientServerToken() != data.getUInt32())
     {
         Log::warn("GameEventsProtocol", "Bad token.");
         return true;
     }
-    int8_t type = data.gui8(4);
+    int8_t type = data.getUInt8(4);
     data.removeFront(5);
     switch (type)
     {
@@ -85,8 +85,9 @@ void GameEventsProtocol::collectedItem(Item* item, AbstractKart* kart)
     const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
     for (unsigned int i = 0; i < peers.size(); i++)
     {
-        NetworkString ns(11);
-        ns.ai32(peers[i]->getClientServerToken());
+        NewNetworkString *ns = getNetworkString(11);
+        ns->setToken(peers[i]->getClientServerToken());
+        ns->setSynchronous(true);
         // Item picked : send item id, powerup type and kart race id
         uint8_t powerup = 0;
         if (item->getType() == Item::ITEM_BANANA)
@@ -95,11 +96,11 @@ void GameEventsProtocol::collectedItem(Item* item, AbstractKart* kart)
             powerup = (((int)(kart->getPowerup()->getType()) << 4) & 0xf0) 
                            + (kart->getPowerup()->getNum()         & 0x0f);
 
-        ns.ai8(GE_ITEM_COLLECTED).ai32(item->getItemId()).ai8(powerup)
-          .ai8(kart->getWorldKartId());
-        ProtocolManager::getInstance()->sendMessage(this, peers[i], ns,
-                                                    /*reliable*/true,
-                                                    /*synchronous*/true);
+        ns->addUInt8(GE_ITEM_COLLECTED).addUInt32(item->getItemId())
+           .addUInt8(powerup).addUInt8(kart->getWorldKartId());
+        ProtocolManager::getInstance()->sendMessage(peers[i], *ns,
+                                                    /*reliable*/true);
+        delete ns;
         Log::info("GameEventsProtocol",
                   "Notified a peer that a kart collected item %d.",
                   (int)(kart->getPowerup()->getType()));
@@ -109,15 +110,15 @@ void GameEventsProtocol::collectedItem(Item* item, AbstractKart* kart)
 // ----------------------------------------------------------------------------
 /** Called on the client when an itemCollected message is received.
  */
-void GameEventsProtocol::collectedItem(const NetworkString &data)
+void GameEventsProtocol::collectedItem(const NewNetworkString &data)
 {
     if (data.size() < 6)
     {
             Log::warn("GameEventsProtocol", "Too short message.");
         }
-        uint32_t item_id = data.gui32();
-        uint8_t powerup_type = data.gui8(4);
-        uint8_t kart_id = data.gui8(5);
+        uint32_t item_id = data.getUInt32();
+        uint8_t powerup_type = data.getUInt8(4);
+        uint8_t kart_id = data.getUInt8(5);
         // now set the kart powerup
         AbstractKart* kart = World::getWorld()->getKart(kart_id);
         ItemManager::get()->collectedItem(ItemManager::get()->getItem(item_id),
@@ -134,18 +135,20 @@ void GameEventsProtocol::collectedItem(const NetworkString &data)
  */
 void GameEventsProtocol::kartFinishedRace(AbstractKart *kart, float time)
 {
-    NetworkString ns(20);
-
+    NewNetworkString *ns = getNetworkString(20);
+    ns->setSynchronous(true);
     const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
+
+    // FIXME - TODO THIS APPEARS COMPLETELY BROKEN!!!
     for (unsigned int i = 0; i < peers.size(); i++)
     {
-        ns.addUInt32(peers[i]->getClientServerToken())
+        ns->addUInt32(peers[i]->getClientServerToken())
           .addUInt8(GE_KART_FINISHED_RACE)
           .addUInt8(kart->getWorldKartId()).addFloat(time);
 
-        ProtocolManager::getInstance()->sendMessage(this, peers[i], ns,
-                                                    /*reliable*/true,
-                                                    /*synchronous*/true);
+        ProtocolManager::getInstance()->sendMessage(peers[i], *ns,
+                                                    /*reliable*/true);
+        delete ns;
     }   // for i in peers
 }   // kartFinishedRace
 
@@ -154,7 +157,7 @@ void GameEventsProtocol::kartFinishedRace(AbstractKart *kart, float time)
  *  event from the server. It updates the game with this information.
  *  \param ns The message from the server.
  */
-void GameEventsProtocol::kartFinishedRace(const NetworkString &ns)
+void GameEventsProtocol::kartFinishedRace(const NewNetworkString &ns)
 {
     uint8_t kart_id = ns.getUInt8(0);
     float time      = ns.getFloat(1);
diff --git a/src/network/protocols/game_events_protocol.hpp b/src/network/protocols/game_events_protocol.hpp
index 7389b93aa..ba571edb8 100644
--- a/src/network/protocols/game_events_protocol.hpp
+++ b/src/network/protocols/game_events_protocol.hpp
@@ -22,9 +22,9 @@ public:
     virtual void setup();
     virtual void update();
     void collectedItem(Item* item, AbstractKart* kart);
-    void collectedItem(const NetworkString &ns);
+    void collectedItem(const NewNetworkString &ns);
     void kartFinishedRace(AbstractKart *kart, float time);
-    void kartFinishedRace(const NetworkString &ns);
+    void kartFinishedRace(const NewNetworkString &ns);
     // ------------------------------------------------------------------------
     virtual void asynchronousUpdate() {}
     // ------------------------------------------------------------------------
diff --git a/src/network/protocols/get_public_address.cpp b/src/network/protocols/get_public_address.cpp
index 402c53f80..d1a3e640c 100644
--- a/src/network/protocols/get_public_address.cpp
+++ b/src/network/protocols/get_public_address.cpp
@@ -21,6 +21,7 @@
 #include "config/user_config.hpp"
 #include "network/network.hpp"
 #include "network/network_config.hpp"
+#include "network/network_string.hpp"
 #include "network/protocols/connect_to_server.hpp"
 #include "utils/log.hpp"
 
diff --git a/src/network/protocols/kart_update_protocol.cpp b/src/network/protocols/kart_update_protocol.cpp
index 1b1b965b5..a6e6242ba 100644
--- a/src/network/protocols/kart_update_protocol.cpp
+++ b/src/network/protocols/kart_update_protocol.cpp
@@ -38,7 +38,7 @@ bool KartUpdateProtocol::notifyEvent(Event* event)
 {
     if (event->getType() != EVENT_TYPE_MESSAGE)
         return true;
-    NetworkString &ns = event->data();
+    NewNetworkString &ns = event->data();
     if (ns.size() < 33)
     {
         Log::info("KartUpdateProtocol", "Message too short.");
@@ -48,9 +48,8 @@ bool KartUpdateProtocol::notifyEvent(Event* event)
     while(ns.size() >= 29)
     {
         uint8_t kart_id = ns.getUInt8(0);
-        Vec3 xyz;
-        btQuaternion quat;
-        ns.get(&xyz, 1).get(&quat, 13);
+        Vec3 xyz = ns.getVec3(1);
+        btQuaternion quat = ns.getQuat(13);
         m_next_positions  [kart_id] = xyz;
         m_next_quaternions[kart_id] = quat;
         ns.removeFront(29);
@@ -81,35 +80,40 @@ void KartUpdateProtocol::update()
         if (NetworkConfig::get()->isServer())
         {
             World *world = World::getWorld();
-            NetworkString ns(4+world->getNumKarts()*29);
-            ns.af( world->getTime() );
+            NewNetworkString *ns = getNetworkString(4+world->getNumKarts()*29);
+            ns->setSynchronous(true);
+            ns->addFloat( world->getTime() );
             for (unsigned int i = 0; i < world->getNumKarts(); i++)
             {
                 AbstractKart* kart = world->getKart(i);
                 Vec3 xyz = kart->getXYZ();
-                ns.addUInt8( kart->getWorldKartId());
-                ns.add(xyz).add(kart->getRotation());
+                ns->addUInt8( kart->getWorldKartId());
+                ns->add(xyz).add(kart->getRotation());
                 Log::verbose("KartUpdateProtocol",
                              "Sending %d's positions %f %f %f",
                              kart->getWorldKartId(), xyz[0], xyz[1], xyz[2]);
             }
-            sendSynchronousMessage(ns, false);
+            sendMessage(*ns, /*reliable*/false);
+            delete ns;
         }
         else
         {
-            NetworkString ns(4+29*race_manager->getNumLocalPlayers());
-            ns.af(World::getWorld()->getTime());
+            NewNetworkString *ns =
+                     getNetworkString(4+29*race_manager->getNumLocalPlayers());
+            ns->setSynchronous(true);
+            ns->addFloat(World::getWorld()->getTime());
             for(unsigned int i=0; i<race_manager->getNumLocalPlayers(); i++)
             {
                 AbstractKart *kart = World::getWorld()->getLocalPlayerKart(i);
                 const Vec3 &xyz = kart->getXYZ();
-                ns.addUInt8(kart->getWorldKartId());
-                ns.add(xyz).add(kart->getRotation());
+                ns->addUInt8(kart->getWorldKartId());
+                ns->add(xyz).add(kart->getRotation());
                 Log::verbose("KartUpdateProtocol",
                              "Sending %d's positions %f %f %f",
                               kart->getWorldKartId(), xyz[0], xyz[1], xyz[2]);
             }
-            sendSynchronousMessage(ns, false);
+            sendMessage(*ns, /*reliable*/false);
+            delete ns;
         }   // if server
     }   // if (current_time > time + 0.1)
 
diff --git a/src/network/protocols/server_lobby_room_protocol.cpp b/src/network/protocols/server_lobby_room_protocol.cpp
index 9bb3e4ea4..7e028c731 100644
--- a/src/network/protocols/server_lobby_room_protocol.cpp
+++ b/src/network/protocols/server_lobby_room_protocol.cpp
@@ -78,7 +78,7 @@ bool ServerLobbyRoomProtocol::notifyEventAsynchronous(Event* event)
     assert(m_setup); // assert that the setup exists
     if (event->getType() == EVENT_TYPE_MESSAGE)
     {
-        const NetworkString &data = event->data();
+        const NewNetworkString &data = event->data();
         assert(data.size()); // message not empty
         uint8_t message_type;
         message_type = data[0];
@@ -226,9 +226,11 @@ void ServerLobbyRoomProtocol::startGame()
     const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
     for (unsigned int i = 0; i < peers.size(); i++)
     {
-        NetworkString ns(6);
-        ns.ai8(LE_START_RACE).ai8(4).ai32(peers[i]->getClientServerToken());
-        sendMessage(peers[i], ns, true); // reliably
+        NewNetworkString *ns = getNetworkString(6);
+        ns->setToken(peers[i]->getClientServerToken());
+        ns->addUInt8(LE_START_RACE).addUInt8(4);
+        sendMessage(peers[i], *ns, true); // reliably
+        delete ns;
     }
     Protocol *p = new StartGameProtocol(m_setup);
     p->requestStart();
@@ -251,10 +253,12 @@ void ServerLobbyRoomProtocol::startSelection(const Event *event)
     const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
     for (unsigned int i = 0; i < peers.size(); i++)
     {
-        NetworkString ns(6);
+        NewNetworkString *ns = getNetworkString(6);
+        ns->setToken(peers[i]->getClientServerToken());
         // start selection
-        ns.ai8(LE_START_SELECTION).ai8(4).ai32(peers[i]->getClientServerToken());
-        sendMessage(peers[i], ns, true); // reliably
+        ns->addUInt8(LE_START_SELECTION).addUInt8(4);
+        sendMessage(peers[i], *ns, true); // reliably
+        delete ns;
     }
     m_selection_enabled = true;
 
@@ -338,19 +342,22 @@ void ServerLobbyRoomProtocol::checkRaceFinished()
 
         const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
 
-        NetworkString queue(karts_results.size()*2);
+        NewNetworkString *queue = getNetworkString(karts_results.size()*2);
         for (unsigned int i = 0; i < karts_results.size(); i++)
         {
-            queue.ai8(1).ai8(karts_results[i]); // kart pos = i+1
+            queue->addUInt8(1).addUInt8(karts_results[i]); // kart pos = i+1
             Log::info("ServerLobbyRoomProtocol", "Kart %d finished #%d",
                       karts_results[i], i + 1);
         }
         for (unsigned int i = 0; i < peers.size(); i++)
         {
-            NetworkString ns(6);
-            ns.ai8(LE_RACE_FINISHED).ai8(4).ai32(peers[i]->getClientServerToken());
-            NetworkString total = ns + queue;
-            sendSynchronousMessage(peers[i], total, true);
+            NewNetworkString *total = getNetworkString();
+            total->setSynchronous(true);
+            total->setToken(peers[i]->getClientServerToken());
+            total->addUInt8(LE_RACE_FINISHED).addUInt8(4);
+            *total += *queue;
+            sendMessage(peers[i], *total, /*reliable*/true);
+            delete total;
         }
         Log::info("ServerLobbyRoomProtocol", "End of game message sent");
         m_in_race = false;
@@ -395,10 +402,11 @@ void ServerLobbyRoomProtocol::kartDisconnected(Event* event)
     STKPeer* peer = event->getPeer();
     if (peer->getPlayerProfile() != NULL) // others knew him
     {
-        NetworkString msg(3);
-        msg.ai8(LE_PLAYER_DISCONNECTED).ai8(1)
-           .ai8(peer->getPlayerProfile()->getGlobalPlayerId());
-        sendMessage(msg);
+        NewNetworkString *msg = getNetworkString(3);
+        msg->addUInt8(LE_PLAYER_DISCONNECTED).addUInt8(1)
+           .addUInt8(peer->getPlayerProfile()->getGlobalPlayerId());
+        sendMessage(*msg);
+        delete msg;
         Log::info("ServerLobbyRoomProtocol", "Player disconnected : id %d",
                   peer->getPlayerProfile()->getGlobalPlayerId());
         m_setup->removePlayer(peer->getPlayerProfile());
@@ -425,19 +433,20 @@ void ServerLobbyRoomProtocol::kartDisconnected(Event* event)
 void ServerLobbyRoomProtocol::connectionRequested(Event* event)
 {
     STKPeer* peer = event->getPeer();
-    const NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
 
     // can we add the player ?
     if (m_setup->getPlayerCount() >= NetworkConfig::get()->getMaxPlayers() ||
         m_state!=ACCEPTING_CLIENTS                                           )
     {
-        NetworkString message(3);
+        NewNetworkString *message = getNetworkString(3);
         // Len, error code: 2 = busy, 0 = too many players
-        message.ai8(LE_CONNECTION_REFUSED).ai8(1)
-                .ai8(m_state!=ACCEPTING_CLIENTS ? 2 : 0);
+        message->addUInt8(LE_CONNECTION_REFUSED).addUInt8(1)
+                .addUInt8(m_state!=ACCEPTING_CLIENTS ? 2 : 0);
 
         // send only to the peer that made the request
-        sendMessage(peer, message);
+        sendMessage(peer, *message);
+        delete message;
         Log::verbose("ServerLobbyRoomProtocol", "Player refused");
         return;
     }
@@ -465,11 +474,12 @@ void ServerLobbyRoomProtocol::connectionRequested(Event* event)
 
     // Notify everybody that there is a new player
     // -------------------------------------------
-    NetworkString message(8);
+    NewNetworkString *message = getNetworkString(8);
     // size of id -- id -- size of local id -- local id;
-    message.ai8(LE_NEW_PLAYER_CONNECTED).ai8(1).ai8(new_player_id)
+    message->addUInt8(LE_NEW_PLAYER_CONNECTED).addUInt8(1).addUInt8(new_player_id)
            .encodeString(name_u8).addUInt8(new_host_id);
-    ProtocolManager::getInstance()->sendMessageExcept(this, peer, message);
+    ProtocolManager::getInstance()->sendMessageExcept(peer, *message);
+    delete message;
 
     // Now answer to the peer that just connected
     // ------------------------------------------
@@ -483,19 +493,21 @@ void ServerLobbyRoomProtocol::connectionRequested(Event* event)
     const std::vector<NetworkPlayerProfile*> &players = m_setup->getPlayers();
     // send a message to the one that asked to connect
     // Size is overestimated, probably one player's data will not be sent
-    NetworkString message_ack(14 + players.size() * 7);
+    NewNetworkString *message_ack = getNetworkString(14 + players.size() * 7);
+    message_ack->setToken(token);
     // connection success -- size of token -- token
-    message_ack.ai8(LE_CONNECTION_ACCEPTED).ai8(1).ai8(new_player_id).ai8(4)
-               .ai32(token).addUInt8(new_host_id).addUInt8(is_authorised);
+    message_ack->addUInt8(LE_CONNECTION_ACCEPTED).addUInt8(1).addUInt8(new_player_id).addUInt8(4)
+               .addUInt8(new_host_id).addUInt8(is_authorised);
     // Add all players so that this user knows (this new player is only added
     // to the list of players later, so the new player's info is not included)
     for (unsigned int i = 0; i < players.size(); i++)
     {
-        message_ack.ai8(1).ai8(players[i]->getGlobalPlayerId())
+        message_ack->addUInt8(1).addUInt8(players[i]->getGlobalPlayerId())
                    .encodeString(players[i]->getName())
                    .addUInt8(players[i]->getHostId());
     }
-    sendMessage(peer, message_ack);
+    sendMessage(peer, *message_ack);
+    delete message_ack;
 
     NetworkPlayerProfile* profile = new NetworkPlayerProfile(new_player_id, name);
     profile->setHostId(new_host_id);
@@ -516,10 +528,10 @@ void ServerLobbyRoomProtocol::connectionRequested(Event* event)
  *
  *  Format of the data :
  *  Byte 0   1            5                    6           N+6
- *       ---------------------------------------------------
- *  Size | 1 |      4     |          1         |     N     |
- *  Data | 4 | priv token | N (kart name size) | kart name |
- *       ---------------------------------------------------
+ *       -----------------------------------------------
+ *  Size |      4     |          1         |     N     |
+ *  Data | priv token | N (kart name size) | kart name |
+ *       -----------------------------------------------
  */
 void ServerLobbyRoomProtocol::kartSelectionRequested(Event* event)
 {
@@ -530,7 +542,7 @@ void ServerLobbyRoomProtocol::kartSelectionRequested(Event* event)
         return;
     }
 
-    const NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
     STKPeer* peer = event->getPeer();
     if (!checkDataSizeAndToken(event, 6))
         return;
@@ -540,38 +552,43 @@ void ServerLobbyRoomProtocol::kartSelectionRequested(Event* event)
     // check if selection is possible
     if (!m_selection_enabled)
     {
-        NetworkString answer(3);
+        NewNetworkString *answer = getNetworkString(3);
         // selection still not started
-        answer.ai8(LE_KART_SELECTION_REFUSED).ai8(1).ai8(2);
-        sendMessage(peer, answer);
+        answer->addUInt8(LE_KART_SELECTION_REFUSED).addUInt8(1).addUInt8(2);
+        sendMessage(peer, *answer);
+        delete answer;
         return;
     }
     // check if somebody picked that kart
     if (!m_setup->isKartAvailable(kart_name))
     {
-        NetworkString answer(3);
+        NewNetworkString *answer = getNetworkString(3);
         // kart is already taken
-        answer.ai8(LE_KART_SELECTION_REFUSED).ai8(1).ai8(0);
-        sendMessage(peer, answer);
+        answer->addUInt8(LE_KART_SELECTION_REFUSED).addUInt8(1).addUInt8(0);
+        sendMessage(peer, *answer);
+        delete answer;
         return;
     }
     // check if this kart is authorized
     if (!m_setup->isKartAllowed(kart_name))
     {
-        NetworkString answer(3);
+        NewNetworkString *answer = getNetworkString(3);
         // kart is not authorized
-        answer.ai8(LE_KART_SELECTION_REFUSED).ai8(1).ai8(1);
-        sendMessage(peer, answer);
+        answer->addUInt8(LE_KART_SELECTION_REFUSED).addUInt8(1).addUInt8(1);
+        sendMessage(peer, *answer);
+        delete answer;
         return;
     }
     // send a kart update to everyone
-    NetworkString answer(3+1+kart_name.size());
+    NewNetworkString *answer = getNetworkString(3+1+kart_name.size());
+    // This message must be handled synchronously on the client.
+    answer->setSynchronous(true);
     // kart update (3), 1, race id
     uint8_t player_id = peer->getPlayerProfile()->getGlobalPlayerId();
-    answer.ai8(LE_KART_SELECTION_UPDATE).ai8(1).ai8(player_id)
+    answer->addUInt8(LE_KART_SELECTION_UPDATE).addUInt8(1).addUInt8(player_id)
           .encodeString(kart_name);
-    // This message must be handled synchronously on the client.
-    sendSynchronousMessage(answer);
+    sendMessage(*answer);
+    delete answer;
     m_setup->setPlayerKart(player_id, kart_name);
 }   // kartSelectionRequested
 
@@ -589,7 +606,7 @@ void ServerLobbyRoomProtocol::kartSelectionRequested(Event* event)
  */
 void ServerLobbyRoomProtocol::playerMajorVote(Event* event)
 {
-    NetworkString &data = event->data();
+    NewNetworkString &data = event->data();
     STKPeer* peer = event->getPeer();
     if (!checkDataSizeAndToken(event, 7))
         return;
@@ -600,10 +617,11 @@ void ServerLobbyRoomProtocol::playerMajorVote(Event* event)
     m_setup->getRaceConfig()->setPlayerMajorVote(player_id, major);
     // Send the vote to everybody (including the sender)
     data.removeFront(5); // remove the token
-    NetworkString other(5+data.size());
-    other.ai8(1).ai8(player_id); // add the player id
-    other += data; // add the data
-    sendMessageToPeersChangingToken(LE_VOTE_MAJOR, other);
+    NewNetworkString *other = getNetworkString(6+data.size());
+    other->addUInt8(LE_VOTE_MAJOR).addUInt8(1).addUInt8(player_id); // add the player id
+    *other += data; // add the data
+    sendMessageToPeersChangingToken(other);
+    delete other;
 }   // playerMajorVote
 
 //-----------------------------------------------------------------------------
@@ -620,7 +638,7 @@ void ServerLobbyRoomProtocol::playerMajorVote(Event* event)
  */
 void ServerLobbyRoomProtocol::playerRaceCountVote(Event* event)
 {
-    NetworkString &data = event->data();
+    NewNetworkString &data = event->data();
     STKPeer* peer = event->getPeer();
     if (!checkDataSizeAndToken(event, 7))
         return;
@@ -630,10 +648,12 @@ void ServerLobbyRoomProtocol::playerRaceCountVote(Event* event)
     m_setup->getRaceConfig()->setPlayerRaceCountVote(player_id, data[6]);
     // Send the vote to everybody (including the sender)
     data.removeFront(5); // remove the token
-    NetworkString other(2+data.size());
-    other.ai8(1).ai8(player_id); // add the player id
-    other += data; // add the data
-    sendMessageToPeersChangingToken(LE_VOTE_RACE_COUNT, other);
+    NewNetworkString *other = getNetworkString(3+data.size());
+    other->addUInt8(LE_VOTE_RACE_COUNT).addUInt8(1)
+          .addUInt8(player_id); // add the player id
+    *other += data; // add the data
+    sendMessageToPeersChangingToken(other);
+    delete other;
 }   // playerRaceCountVote
 
 //-----------------------------------------------------------------------------
@@ -650,7 +670,7 @@ void ServerLobbyRoomProtocol::playerRaceCountVote(Event* event)
  */
 void ServerLobbyRoomProtocol::playerMinorVote(Event* event)
 {
-    NetworkString &data = event->data();
+    NewNetworkString &data = event->data();
     STKPeer* peer = event->getPeer();
     if (!checkDataSizeAndToken(event, 7))
         return;
@@ -661,10 +681,11 @@ void ServerLobbyRoomProtocol::playerMinorVote(Event* event)
     m_setup->getRaceConfig()->setPlayerMinorVote(player_id, minor);
     // Send the vote to everybody (including the sender)
     data.removeFront(5); // remove the token
-    NetworkString other(2+data.size());
-    other.ai8(1).ai8(player_id); // add the player id
-    other += data; // add the data
-    sendMessageToPeersChangingToken(LE_VOTE_MINOR, other);
+    NewNetworkString *other = getNetworkString(3+data.size());
+    other->addUInt8(LE_VOTE_MINOR).addUInt8(1).addUInt8(player_id); 
+    *other += data; // add the data
+    sendMessageToPeersChangingToken(other);
+    delete other;
 }   // playerMinorVote
 
 //-----------------------------------------------------------------------------
@@ -681,7 +702,7 @@ void ServerLobbyRoomProtocol::playerMinorVote(Event* event)
  */
 void ServerLobbyRoomProtocol::playerTrackVote(Event* event)
 {
-    NetworkString &data = event->data();
+    NewNetworkString &data = event->data();
     STKPeer* peer = event->getPeer();
     if (!checkDataSizeAndToken(event, 8))
         return;
@@ -693,10 +714,11 @@ void ServerLobbyRoomProtocol::playerTrackVote(Event* event)
     m_setup->getRaceConfig()->setPlayerTrackVote(player_id, track_name, data[N+6]);
     // Send the vote to everybody (including the sender)
     data.removeFront(5); // remove the token
-    NetworkString other(2+data.size());
-    other.ai8(1).ai8(player_id); // add the player id
-    other += data; // add the data
-    sendMessageToPeersChangingToken(LE_VOTE_TRACK, other);
+    NewNetworkString *other = getNetworkString(3+data.size());
+    other->addUInt8(LE_VOTE_TRACK).addUInt8(1).addUInt8(player_id);
+    *other += data; // add the data
+    sendMessageToPeersChangingToken(other);
+    delete other;
     if(m_setup->getRaceConfig()->getNumTrackVotes()==m_setup->getPlayerCount())
         startGame();
 }   // playerTrackVote
@@ -715,7 +737,7 @@ void ServerLobbyRoomProtocol::playerTrackVote(Event* event)
  */
 void ServerLobbyRoomProtocol::playerReversedVote(Event* event)
 {
-    NetworkString &data = event->data();
+    NewNetworkString &data = event->data();
     STKPeer* peer = event->getPeer();
     if (!checkDataSizeAndToken(event, 9))
         return;
@@ -728,10 +750,11 @@ void ServerLobbyRoomProtocol::playerReversedVote(Event* event)
                                                     data[6]!=0, data[8]);
     // Send the vote to everybody (including the sender)
     data.removeFront(5); // remove the token
-    NetworkString other(2+data.size());
-    other.ai8(1).ai8(player_id); // add the player id
-    other += data; // add the data
-    sendMessageToPeersChangingToken(LE_VOTE_REVERSE, other);
+    NewNetworkString *other = getNetworkString(3+data.size());
+    other->addUInt8(LE_VOTE_REVERSE).addUInt8(1).addUInt8(player_id);
+    *other += data; // add the data
+    sendMessageToPeersChangingToken(other);
+    delete other;
 }   // playerReversedVote
 
 //-----------------------------------------------------------------------------
@@ -748,7 +771,7 @@ void ServerLobbyRoomProtocol::playerReversedVote(Event* event)
  */
 void ServerLobbyRoomProtocol::playerLapsVote(Event* event)
 {
-    NetworkString &data = event->data();
+    NewNetworkString &data = event->data();
     STKPeer* peer = event->getPeer();
     if (!checkDataSizeAndToken(event, 9))
         return;
@@ -760,10 +783,11 @@ void ServerLobbyRoomProtocol::playerLapsVote(Event* event)
     m_setup->getRaceConfig()->setPlayerLapsVote(player_id, data[6], data[8]);
     // Send the vote to everybody (including the sender)
     data.removeFront(5); // remove the token
-    NetworkString other(2+data.size());
-    other.ai8(1).ai8(player_id); // add the player id
-    other += data; // add the data
-    sendMessageToPeersChangingToken(LE_VOTE_LAPS, other);
+    NewNetworkString *other = getNetworkString(3+data.size());
+    other->addUInt8(LE_VOTE_LAPS).addUInt8(1).addUInt8(player_id);
+    *other += data; // add the data
+    sendMessageToPeersChangingToken(other);
+    delete other;
 }   // playerLapsVote
 
 //-----------------------------------------------------------------------------
diff --git a/src/network/protocols/start_game_protocol.cpp b/src/network/protocols/start_game_protocol.cpp
index 16a4cdc2b..b238f3ea3 100644
--- a/src/network/protocols/start_game_protocol.cpp
+++ b/src/network/protocols/start_game_protocol.cpp
@@ -123,14 +123,14 @@ void StartGameProtocol::setup()
 // ----------------------------------------------------------------------------
 bool StartGameProtocol::notifyEventAsynchronous(Event* event)
 {
-    const NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
     if (data.size() < 5)
     {
         Log::error("StartGameProtocol", "Too short message.");
         return true;
     }
-    uint32_t token = data.gui32();
-    uint8_t ready = data.gui8(4);
+    uint32_t token = data.getUInt32();
+    uint8_t ready = data.getUInt8(4);
     STKPeer* peer = event->getPeer();
     if (peer->getClientServerToken() != token)
     {
@@ -219,10 +219,12 @@ void StartGameProtocol::ready()
     if (NetworkConfig::get()->isClient())
     {
         assert(STKHost::get()->getPeerCount() == 1);
-        NetworkString ns(5);
-        ns.ai32(STKHost::get()->getPeers()[0]->getClientServerToken()).ai8(1);
+        NewNetworkString *ns = getNetworkString(5);
+        ns->setToken(STKHost::get()->getPeers()[0]->getClientServerToken());
+        ns->addUInt8(1);
         Log::info("StartGameProtocol", "Player ready, notifying server.");
-        sendMessage(ns, true);
+        sendMessage(*ns, /*reliable*/true);
+        delete ns;
         m_state = READY;
         m_ready = true;
         return;
diff --git a/src/network/protocols/synchronization_protocol.cpp b/src/network/protocols/synchronization_protocol.cpp
index 4dd58af90..d36ce70c6 100644
--- a/src/network/protocols/synchronization_protocol.cpp
+++ b/src/network/protocols/synchronization_protocol.cpp
@@ -43,15 +43,15 @@ bool SynchronizationProtocol::notifyEventAsynchronous(Event* event)
     if (event->getType() != EVENT_TYPE_MESSAGE)
         return true;
 
-    const NetworkString &data = event->data();
+    const NewNetworkString &data = event->data();
     if (data.size() < 9)
     {
         Log::warn("SynchronizationProtocol", "Received a too short message.");
         return true;
     }
-    uint32_t token    = data.gui32(0);
-    uint32_t request  = data.gui8(4);
-    uint32_t sequence = data.gui32(5);
+    uint32_t token    = data.getUInt32(0);
+    uint32_t request  = data.getUInt8(4);
+    uint32_t sequence = data.getUInt32(5);
 
     const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
     assert(peers.size() > 0);
@@ -79,17 +79,19 @@ bool SynchronizationProtocol::notifyEventAsynchronous(Event* event)
     {
         // Only a client should receive a request for a ping response
         assert(NetworkConfig::get()->isClient());
-        NetworkString response(10);
+        NewNetworkString *response = getNetworkString(10);
+        response->setToken(token);
         // The '0' indicates a response to a ping request
-        response.ai32(token).ai8(0).ai32(sequence);
-        sendMessage(event->getPeer(), response, false);
+        response->addUInt8(0).addUInt32(sequence);
+        sendMessage(event->getPeer(), *response, false);
+        delete response;
         Log::verbose("SynchronizationProtocol", "Answering sequence %u at %lf",
                      sequence, StkTime::getRealTime());
 
         // countdown time in the message
         if (data.size() == 13)
         {
-            uint32_t time_to_start = data.gui32(9);
+            uint32_t time_to_start = data.getUInt32(9);
             Log::debug("SynchronizationProtocol",
                        "Request to start game in %d.", time_to_start);
             if (!m_countdown_activated)
@@ -169,15 +171,15 @@ void SynchronizationProtocol::asynchronousUpdate()
         const std::vector<STKPeer*> &peers = STKHost::get()->getPeers();
         for (unsigned int i = 0; i < peers.size(); i++)
         {
-            NetworkString ping_request(13);
-            ping_request.addUInt32(peers[i]->getClientServerToken())
-                        .addUInt8(1).addUInt32(m_pings[i].size());
+            NewNetworkString *ping_request = getNetworkString(13);
+            ping_request->setToken(peers[i]->getClientServerToken());
+            ping_request->addUInt8(1).addUInt32(m_pings[i].size());
             // Server adds the countdown if it has started. This will indicate
             // to the client to start the countdown as well (first time the 
             // message is received), or to update the countdown time.
             if (m_countdown_activated )
             {
-                ping_request.addUInt32((int)(m_countdown*1000.0));
+                ping_request->addUInt32((int)(m_countdown*1000.0));
                 Log::debug("SynchronizationProtocol",
                            "CNTActivated: Countdown value : %f", m_countdown);
             }
@@ -185,7 +187,8 @@ void SynchronizationProtocol::asynchronousUpdate()
                          "Added sequence number %u for peer %d at %lf",
                          m_pings[i].size(), i, StkTime::getRealTime());
             m_pings[i] [ m_pings_count ] = current_time;
-            sendMessage(peers[i], ping_request, false);
+            sendMessage(peers[i], *ping_request, false);
+            delete ping_request;
         }   // for i M peers
         m_last_time = current_time;
         m_pings_count++;
diff --git a/src/network/stk_host.cpp b/src/network/stk_host.cpp
index eee521197..11c1ca7f8 100644
--- a/src/network/stk_host.cpp
+++ b/src/network/stk_host.cpp
@@ -440,7 +440,7 @@ bool STKHost::connect(const TransportAddress& address)
  *  \param data Message to sent.
  *  \param reliable If the message is to be sent reliable.
  */
-void STKHost::sendMessage(const NetworkString& data, bool reliable)
+void STKHost::sendMessage(const NewNetworkString& data, bool reliable)
 {
     if (NetworkConfig::get()->isServer())
         broadcastPacket(data, reliable);
@@ -604,13 +604,13 @@ void STKHost::handleLANRequests()
         // current players, and the client's ip address and port
         // number (which solves the problem which network interface
         // might be the right one if there is more than one).
-        NetworkString s;
+        NewNetworkString s(PROTOCOL_NONE);
         s.encodeString(name);
         s.addUInt8(NetworkConfig::get()->getMaxPlayers());
         s.addUInt8(0);   // FIXME: current number of connected players
         s.addUInt32(sender.getIP());
         s.addUInt16(sender.getPort());
-        m_lan_network->sendRawPacket(s.getBytes(), s.size(), sender);
+        m_lan_network->sendRawPacket(s.getData(), s.size(), sender);
     }   // if message is server-requested
     else if (std::string(buffer, len) == "connection-request")
     {
@@ -740,7 +740,7 @@ uint16_t STKHost::getPort() const
  *  \param data Data to sent.
  *  \param reliable If the data should be sent reliable or now.
  */
-void STKHost::sendPacketExcept(STKPeer* peer, const NetworkString& data,
+void STKHost::sendPacketExcept(STKPeer* peer, const NewNetworkString &data,
                                bool reliable)
 {
     for (unsigned int i = 0; i < m_peers.size(); i++)
diff --git a/src/network/stk_host.hpp b/src/network/stk_host.hpp
index 2a0c3b31e..8879169fb 100644
--- a/src/network/stk_host.hpp
+++ b/src/network/stk_host.hpp
@@ -145,9 +145,9 @@ public:
     void requestShutdown();
     void shutdown();
 
-    void sendMessage(const NetworkString& data, bool reliable = true);
+    void sendMessage(const NewNetworkString& data, bool reliable = true);
     void sendPacketExcept(STKPeer* peer,
-                          const NetworkString& data,
+                          const NewNetworkString& data,
                           bool reliable = true);
     void        setupClient(int peer_count, int channel_limit,
                             uint32_t max_incoming_bandwidth,
@@ -181,7 +181,7 @@ public:
     }   // receiveRawPacket
 
     // --------------------------------------------------------------------
-    void broadcastPacket(const NetworkString& data,
+    void broadcastPacket(const NewNetworkString& data,
                          bool reliable = true)
     {
         m_network->broadcastPacket(data, reliable);
diff --git a/src/network/stk_peer.cpp b/src/network/stk_peer.cpp
index eed96862f..5f1012541 100644
--- a/src/network/stk_peer.cpp
+++ b/src/network/stk_peer.cpp
@@ -62,13 +62,13 @@ void STKPeer::disconnect()
  *  \param data The data to send.
  *  \param reliable If the data is sent reliable or not.
  */
-void STKPeer::sendPacket(NetworkString const& data, bool reliable)
+void STKPeer::sendPacket(NewNetworkString const& data, bool reliable)
 {
     TransportAddress a(m_enet_peer->address);
     Log::verbose("STKPeer", "sending packet of size %d to %s",
                  data.size(), a.toString().c_str());
          
-    ENetPacket* packet = enet_packet_create(data.getBytes(), data.size() + 1,
+    ENetPacket* packet = enet_packet_create(data.getData(), data.size() + 1,
                                     (reliable ? ENET_PACKET_FLAG_RELIABLE
                                               : ENET_PACKET_FLAG_UNSEQUENCED));
     enet_peer_send(m_enet_peer, 0, packet);
diff --git a/src/network/stk_peer.hpp b/src/network/stk_peer.hpp
index 49ebe7b25..eba8e664b 100644
--- a/src/network/stk_peer.hpp
+++ b/src/network/stk_peer.hpp
@@ -29,7 +29,7 @@
 #include <enet/enet.h>
 
 class NetworkPlayerProfile;
-class NetworkString;
+class NewNetworkString;
 class TransportAddress;
 
 /*! \class STKPeer
@@ -59,7 +59,8 @@ public:
              STKPeer(ENetPeer *enet_peer);
     virtual ~STKPeer();
 
-    virtual void sendPacket(const NetworkString& data, bool reliable = true);
+    virtual void sendPacket(const NewNetworkString &data,
+                            bool reliable = true);
     void disconnect();
     bool isConnected() const;
     bool exists() const;
diff --git a/src/states_screens/networking_lobby.cpp b/src/states_screens/networking_lobby.cpp
index fd67427f4..1860735f1 100644
--- a/src/states_screens/networking_lobby.cpp
+++ b/src/states_screens/networking_lobby.cpp
@@ -141,9 +141,8 @@ void NetworkingLobby::eventCallback(Widget* widget, const std::string& name,
     if(name==m_start_button->m_properties[PROP_ID])
     {
         // Send a message to the server to start
-        NetworkString start;
-        start.addUInt8(PROTOCOL_LOBBY_ROOM)
-             .addUInt8(LobbyRoomProtocol::LE_REQUEST_BEGIN);
+        NewNetworkString start(PROTOCOL_LOBBY_ROOM);
+        start.addUInt8(LobbyRoomProtocol::LE_REQUEST_BEGIN);
         STKHost::get()->sendMessage(start, true);
     }