diff --git a/CMakeLists.txt b/CMakeLists.txt
index 771e864c..e1aecf59 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -101,6 +101,7 @@ option(FGE_BUILD_TESTS "Build tests" ON)
 
 option(FGE_ENABLE_SERVER_NETWORK_RANDOM_LOST "enable/disable random packet lost for server" OFF)
 option(FGE_ENABLE_CLIENT_NETWORK_RANDOM_LOST "enable/disable random packet lost for client" OFF)
+option(FGE_ENABLE_PACKET_DEBUG_VERBOSE "enable/disable verbose packet debug printing" OFF)
 
 #Check if Doxygen is installed
 if (FGE_BUILD_DOC)
@@ -184,6 +185,14 @@ if (${FGE_ENABLE_CLIENT_NETWORK_RANDOM_LOST})
     endif()
 endif()
 
+if (${FGE_ENABLE_PACKET_DEBUG_VERBOSE})
+    target_compile_definitions(${FGE_LIB_NAME} PUBLIC FGE_ENABLE_PACKET_DEBUG_VERBOSE)
+    target_compile_definitions(${FGE_SERVER_LIB_NAME} PUBLIC FGE_ENABLE_PACKET_DEBUG_VERBOSE)
+    if (NOT ${FGE_DEBUG})
+        message(WARNING "FGE_ENABLE_PACKET_DEBUG_VERBOSE is enabled, but FGE_DEBUG is disabled")
+    endif()
+endif()
+
 target_compile_definitions(${FGE_SERVER_LIB_NAME} PUBLIC FGE_DEF_SERVER)
 
 #Includes path
diff --git a/examples/clientServerLifeSimulator_004/client/main.cpp b/examples/clientServerLifeSimulator_004/client/main.cpp
index 4509d893..bba14250 100644
--- a/examples/clientServerLifeSimulator_004/client/main.cpp
+++ b/examples/clientServerLifeSimulator_004/client/main.cpp
@@ -275,7 +275,7 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[])
                 std::cout << "connection ok" << std::endl;
 
                 server.enableReturnPacket(true);
-                server.getClientContext()._reorderer.setMaximumSize(FGE_NET_PACKET_REORDERER_CACHE_COMPUTE(
+                server._client._context._reorderer.setMaximumSize(FGE_NET_PACKET_REORDERER_CACHE_COMPUTE(
                         FGE_NET_DEFAULT_RETURN_PACKET_RATE.count(), LIFESIM_SERVER_TICK));
 
                 auto transmissionPacket = fge::net::CreatePacket(ls::LS_PROTOCOL_C_PLEASE_CONNECT_ME);
@@ -369,9 +369,15 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[])
                                   << '\n'
                                   << "Update count: " << mainScene->getUpdateCount() << '\n'
                                   << "Lost packets: " << server._client.getLostPacketCount() << '\n'
-                                  << "Realm: " << static_cast<unsigned int>(server._client.getCurrentRealm())
-                                  << ", CurrentCounter: " << server._client.getCurrentPacketCounter()
-                                  << ", ClientCounter: " << server._client.getClientPacketCounter();
+                                  << "Realm: " << static_cast<unsigned int>(server._client.getCurrentRealm()) << '\n'
+                                  << "Peer counter: "
+                                  << server._client.getPacketCounter(fge::net::Client::Targets::PEER)
+                                  << ", Peer reorderedCounter: "
+                                  << server._client.getReorderedPacketCounter(fge::net::Client::Targets::PEER) << '\n'
+                                  << "Host counter: "
+                                  << server._client.getPacketCounter(fge::net::Client::Targets::HOST)
+                                  << ", Host reorderedCounter: "
+                                  << server._client.getReorderedPacketCounter(fge::net::Client::Targets::HOST);
 
                 latencyText->setString(tiny_utf8::string(latencyTextStream.str()));
 
diff --git a/examples/clientServerLifeSimulator_004/server/main.cpp b/examples/clientServerLifeSimulator_004/server/main.cpp
index 5e5d0dcb..b7324819 100644
--- a/examples/clientServerLifeSimulator_004/server/main.cpp
+++ b/examples/clientServerLifeSimulator_004/server/main.cpp
@@ -343,7 +343,7 @@ int main([[maybe_unused]] int argc, [[maybe_unused]] char* argv[])
                 }
 
                 //Make sure that the client is not busy with another packet
-                if (!it->second->isPendingPacketsEmpty())
+                if (!it->second->isReadyToAcceptMorePendingPackets())
                 {
                     continue;
                 }
diff --git a/includes/FastEngine/network/C_client.hpp b/includes/FastEngine/network/C_client.hpp
index 89436bd7..d45cf8d7 100644
--- a/includes/FastEngine/network/C_client.hpp
+++ b/includes/FastEngine/network/C_client.hpp
@@ -240,6 +240,13 @@ class FGE_API Client
 public:
     Client();
     ~Client();
+
+    enum class Targets
+    {
+        PEER,
+        HOST
+    };
+
     /**
      * \brief Constructor with default latencies
      *
@@ -372,6 +379,7 @@ class FGE_API Client
      */
     void pushPacket(TransmitPacketPtr pck);
     void pushForcedFrontPacket(TransmitPacketPtr pck);
+    [[nodiscard]] bool isReadyToAcceptMorePendingPackets() const;
     /**
      * \brief Pop a packet from the queue
      *
@@ -384,6 +392,7 @@ class FGE_API Client
      * \return True if the queue is empty, false otherwise
      */
     bool isPendingPacketsEmpty() const;
+    void allowMorePendingPackets(bool allow);
 
     void disconnect(bool pushDisconnectPacket = true);
 
@@ -392,15 +401,15 @@ class FGE_API Client
     void setCurrentRealm(ProtocolPacket::RealmType realm);
     ProtocolPacket::RealmType advanceCurrentRealm();
 
-    [[nodiscard]] ProtocolPacket::CounterType getCurrentPacketCounter() const;
-    ProtocolPacket::CounterType advanceCurrentPacketCounter();
-    void setCurrentPacketCounter(ProtocolPacket::CounterType counter);
+    [[nodiscard]] ProtocolPacket::CounterType getPacketCounter(Targets target) const;
+    ProtocolPacket::CounterType advancePacketCounter(Targets target);
+    void setPacketCounter(Targets target, ProtocolPacket::CounterType count);
 
-    [[nodiscard]] ProtocolPacket::CounterType getClientPacketCounter() const;
-    ProtocolPacket::CounterType advanceClientPacketCounter();
-    void setClientPacketCounter(ProtocolPacket::CounterType counter);
-    void resetLastReorderedPacketCounter();
-    [[nodiscard]] ProtocolPacket::CounterType getLastReorderedPacketCounter() const;
+    [[nodiscard]] ProtocolPacket::CounterType getReorderedPacketCounter(Targets target) const;
+    ProtocolPacket::CounterType advanceReorderedPacketCounter(Targets target);
+    void setReorderedPacketCounter(Targets target, ProtocolPacket::CounterType count);
+
+    void resetAllCounters();
 
     void acknowledgeReception(ReceivedPacketPtr const& packet);
     [[nodiscard]] std::unordered_set<PacketCache::Label, PacketCache::Label::Hash> const& getAcknowledgedList() const;
@@ -443,9 +452,11 @@ class FGE_API Client
 
     std::chrono::steady_clock::time_point g_lastRealmChangeTimePoint;
     ProtocolPacket::RealmType g_currentRealm{FGE_NET_DEFAULT_REALM};
-    ProtocolPacket::CounterType g_currentPacketCounter{0};
-    ProtocolPacket::CounterType g_lastReorderedPacketCounter{0};
-    ProtocolPacket::CounterType g_clientPacketCounter{0};
+
+    ProtocolPacket::CounterType g_hostPacketCounter{0};
+    ProtocolPacket::CounterType g_hostReorderedPacketCounter{0};
+    ProtocolPacket::CounterType g_peerPacketCounter{0};
+    ProtocolPacket::CounterType g_peerReorderedPacketCounter{0};
 
     std::unordered_set<PacketCache::Label, PacketCache::Label::Hash> g_acknowledgedPackets;
     uint32_t g_lostPacketCount{0};
@@ -457,6 +468,8 @@ class FGE_API Client
 
     ClientStatus g_status;
     CryptInfo g_cryptInfo;
+
+    bool g_allowMorePackets{true};
 };
 
 /**
diff --git a/includes/FastEngine/network/C_packet.hpp b/includes/FastEngine/network/C_packet.hpp
index 038af0f8..188ff0b6 100644
--- a/includes/FastEngine/network/C_packet.hpp
+++ b/includes/FastEngine/network/C_packet.hpp
@@ -53,11 +53,13 @@ class FGE_API Packet
 public:
     Packet();
     Packet(Packet&& pck) noexcept;
-    Packet(Packet& pck) = default;
     Packet(Packet const& pck) = default;
     explicit Packet(std::size_t reserveSize);
     virtual ~Packet() = default;
 
+    Packet& operator=(Packet const& pck) = default;
+    Packet& operator=(Packet&& pck) noexcept;
+
     void clear();
     void flush();
     void reserve(std::size_t reserveSize);
diff --git a/includes/FastEngine/network/C_protocol.hpp b/includes/FastEngine/network/C_protocol.hpp
index 756e6ece..b1fd10f7 100644
--- a/includes/FastEngine/network/C_protocol.hpp
+++ b/includes/FastEngine/network/C_protocol.hpp
@@ -42,14 +42,17 @@
 
 #define FGE_NET_BAD_ID 0
 
-#define FGE_NET_PACKET_CACHE_DELAY_FACTOR 1.2f
+#define FGE_NET_PACKET_CACHE_DELAY_FACTOR 2.2f
 #define FGE_NET_PACKET_CACHE_MAX 100
 #define FGE_NET_PACKET_CACHE_MIN_LATENCY_MS 10
 
 #define FGE_NET_DEFAULT_REALM 0
 #define FGE_NET_DEFAULT_PACKET_REORDERER_CACHE_SIZE 5
 #define FGE_NET_PACKET_REORDERER_CACHE_COMPUTE(_clientReturnRate, _serverTickRate)                                     \
-    (((_clientReturnRate) * FGE_NET_PACKET_CACHE_DELAY_FACTOR / (_serverTickRate) + 1) * 2)
+    ((static_cast<unsigned>(static_cast<float>(_clientReturnRate) * FGE_NET_PACKET_CACHE_DELAY_FACTOR /                \
+                            static_cast<float>(_serverTickRate)) +                                                     \
+      1) *                                                                                                             \
+     2)
 
 #define FGE_NET_HANDSHAKE_STRING "FGE:HANDSHAKE:AZCgMVg4d4Sl2xYvZcqXqljIOqSrKX6H"
 
@@ -62,7 +65,7 @@ class Compressor;
 
 namespace fge::net
 {
-
+class NetFluxUdp;
 class Client;
 
 using Timestamp = uint16_t;
@@ -122,7 +125,7 @@ class FGE_API ProtocolPacket : public Packet, public std::enable_shared_from_thi
     constexpr static std::size_t IdPosition = 0;
     constexpr static std::size_t RealmPosition = sizeof(IdType);
     constexpr static std::size_t CounterPosition = sizeof(IdType) + sizeof(RealmType);
-    constexpr static std::size_t LastCounterPosition = sizeof(IdType) + sizeof(RealmType) + sizeof(CounterType);
+    constexpr static std::size_t ReorderedCounterPosition = sizeof(IdType) + sizeof(RealmType) + sizeof(CounterType);
 
     inline ProtocolPacket(Packet const& pck,
                           Identity const& id,
@@ -152,7 +155,7 @@ class FGE_API ProtocolPacket : public Packet, public std::enable_shared_from_thi
     [[nodiscard]] inline std::optional<IdType> retrieveFullHeaderId() const;
     [[nodiscard]] inline std::optional<RealmType> retrieveRealm() const;
     [[nodiscard]] inline std::optional<CounterType> retrieveCounter() const;
-    [[nodiscard]] inline std::optional<CounterType> retrieveLastCounter() const;
+    [[nodiscard]] inline std::optional<CounterType> retrieveReorderedCounter() const;
     [[nodiscard]] inline std::optional<Header> retrieveHeader() const;
 
     [[nodiscard]] inline bool isFragmented() const;
@@ -170,7 +173,7 @@ class FGE_API ProtocolPacket : public Packet, public std::enable_shared_from_thi
 
     inline ProtocolPacket& setRealm(RealmType realm);
     inline ProtocolPacket& setCounter(CounterType counter);
-    inline ProtocolPacket& setLastReorderedPacketCounter(CounterType counter);
+    inline ProtocolPacket& setReorderedCounter(CounterType counter);
 
     inline void setTimestamp(Timestamp timestamp);
     [[nodiscard]] inline Timestamp getTimeStamp() const;
@@ -356,16 +359,26 @@ class FGE_API PacketReorderer
 
     void clear();
 
+    bool process(Client& client, NetFluxUdp& flux, bool ignoreRealm);
+
     void push(ReceivedPacketPtr&& packet);
+
+    [[nodiscard]] static Stats checkStat(ReceivedPacketPtr const& packet, Client const& client, bool ignoreRealm);
     [[nodiscard]] static Stats checkStat(ReceivedPacketPtr const& packet,
-                                         ProtocolPacket::CounterType currentCounter,
-                                         ProtocolPacket::RealmType currentRealm);
-    [[nodiscard]] bool isForced() const;
-    [[nodiscard]] std::optional<Stats> checkStat(ProtocolPacket::CounterType currentCounter,
-                                                 ProtocolPacket::RealmType currentRealm) const;
+                                         ProtocolPacket::CounterType peerCounter,
+                                         ProtocolPacket::CounterType peerReorderedCounter,
+                                         ProtocolPacket::RealmType peerRealm,
+                                         bool ignoreRealm);
+    [[nodiscard]] std::optional<Stats> checkStat(Client const& client, bool ignoreRealm) const;
+    [[nodiscard]] std::optional<Stats> checkStat(ProtocolPacket::CounterType peerCounter,
+                                                 ProtocolPacket::CounterType peerReorderedCounter,
+                                                 ProtocolPacket::RealmType peerRealm,
+                                                 bool ignoreRealm) const;
+
     [[nodiscard]] ReceivedPacketPtr pop();
 
     [[nodiscard]] bool isEmpty() const;
+    [[nodiscard]] bool isForced() const;
 
     void setMaximumSize(std::size_t size);
     [[nodiscard]] std::size_t getMaximumSize() const;
@@ -381,12 +394,14 @@ class FGE_API PacketReorderer
         Data& operator=(Data const& r) = delete;
         Data& operator=(Data&& r) noexcept;
 
-        [[nodiscard]] Stats checkStat(ProtocolPacket::CounterType currentCounter,
-                                      ProtocolPacket::RealmType currentRealm) const;
+        [[nodiscard]] Stats checkStat(ProtocolPacket::CounterType peerCounter,
+                                      ProtocolPacket::CounterType peerReorderedCounter,
+                                      ProtocolPacket::RealmType peerRealm,
+                                      bool ignoreRealm) const;
 
         ReceivedPacketPtr _packet;
         ProtocolPacket::CounterType _counter;
-        ProtocolPacket::CounterType _lastCounter;
+        ProtocolPacket::CounterType _reorderedCounter;
         ProtocolPacket::RealmType _realm;
 
         struct Compare
@@ -395,7 +410,7 @@ class FGE_API PacketReorderer
             {
                 if (l._realm == r._realm)
                 {
-                    return l._counter > r._counter;
+                    return l._reorderedCounter > r._reorderedCounter;
                 }
                 return l._realm > r._realm;
             }
@@ -438,7 +453,7 @@ class FGE_API PacketCache
         };
     };
 
-    PacketCache() = default;
+    PacketCache();
     PacketCache(PacketCache const& r) = delete;
     PacketCache(PacketCache&& r) noexcept;
     ~PacketCache() = default;
@@ -449,6 +464,7 @@ class FGE_API PacketCache
     void clear();
     [[nodiscard]] bool isEmpty() const;
     [[nodiscard]] bool isEnabled() const;
+    [[nodiscard]] bool isAlarmed() const;
     void enable(bool enable);
 
     //Transmit
@@ -458,9 +474,7 @@ class FGE_API PacketCache
     void acknowledgeReception(std::span<Label> labels);
 
     //Check for unacknowledged packet
-    [[nodiscard]] bool check(std::chrono::steady_clock::time_point const& timePoint,
-                             std::chrono::milliseconds clientDelay);
-    [[nodiscard]] TransmitPacketPtr pop();
+    bool process(std::chrono::steady_clock::time_point const& timePoint, Client& client);
 
 private:
     struct Data
@@ -473,15 +487,14 @@ class FGE_API PacketCache
         TransmitPacketPtr _packet;
         Label _label;
         std::chrono::steady_clock::time_point _time{};
+        unsigned int _tryCount{0};
     };
 
     mutable std::mutex g_mutex;
 
-    //Circular buffer
-    std::vector<Data> g_cache{FGE_NET_PACKET_CACHE_MAX};
-    std::size_t g_start{0};
-    std::size_t g_end{0};
+    std::vector<Data> g_cache;
 
+    bool g_alarm{false};
     bool g_enable{false};
 };
 
diff --git a/includes/FastEngine/network/C_protocol.inl b/includes/FastEngine/network/C_protocol.inl
index 31964bb5..891e8ecf 100644
--- a/includes/FastEngine/network/C_protocol.inl
+++ b/includes/FastEngine/network/C_protocol.inl
@@ -152,12 +152,12 @@ inline std::optional<ProtocolPacket::CounterType> ProtocolPacket::retrieveCounte
     }
     return std::nullopt;
 }
-inline std::optional<ProtocolPacket::CounterType> ProtocolPacket::retrieveLastCounter() const
+inline std::optional<ProtocolPacket::CounterType> ProtocolPacket::retrieveReorderedCounter() const
 {
     if (this->haveCorrectHeaderSize())
     {
         CounterType counter;
-        this->unpack(LastCounterPosition, &counter, sizeof(CounterType));
+        this->unpack(ReorderedCounterPosition, &counter, sizeof(CounterType));
         return counter;
     }
     return std::nullopt;
@@ -170,7 +170,7 @@ inline std::optional<ProtocolPacket::Header> ProtocolPacket::retrieveHeader() co
         this->unpack(IdPosition, &header._id, sizeof(IdType));
         this->unpack(RealmPosition, &header._realm, sizeof(RealmType));
         this->unpack(CounterPosition, &header._counter, sizeof(CounterType));
-        this->unpack(LastCounterPosition, &header._lastCounter, sizeof(CounterType));
+        this->unpack(ReorderedCounterPosition, &header._lastCounter, sizeof(CounterType));
         return header;
     }
     return std::nullopt;
@@ -190,7 +190,7 @@ inline ProtocolPacket& ProtocolPacket::setHeader(Header const& header)
     this->pack(IdPosition, &header._id, sizeof(IdType));
     this->pack(RealmPosition, &header._realm, sizeof(RealmType));
     this->pack(CounterPosition, &header._counter, sizeof(CounterType));
-    this->pack(LastCounterPosition, &header._lastCounter, sizeof(CounterType));
+    this->pack(ReorderedCounterPosition, &header._lastCounter, sizeof(CounterType));
     return *this;
 }
 inline ProtocolPacket& ProtocolPacket::setHeaderId(IdType id)
@@ -271,9 +271,9 @@ inline ProtocolPacket& ProtocolPacket::setCounter(CounterType counter)
     this->pack(CounterPosition, &counter, sizeof(CounterType));
     return *this;
 }
-inline ProtocolPacket& ProtocolPacket::setLastReorderedPacketCounter(CounterType counter)
+inline ProtocolPacket& ProtocolPacket::setReorderedCounter(CounterType counter)
 {
-    this->pack(LastCounterPosition, &counter, sizeof(CounterType));
+    this->pack(ReorderedCounterPosition, &counter, sizeof(CounterType));
     return *this;
 }
 
diff --git a/includes/FastEngine/network/C_server.hpp b/includes/FastEngine/network/C_server.hpp
index a702739e..ce31aa58 100644
--- a/includes/FastEngine/network/C_server.hpp
+++ b/includes/FastEngine/network/C_server.hpp
@@ -19,10 +19,10 @@
 
 #include "FastEngine/fge_extern.hpp"
 #include "C_socket.hpp"
+#include "FastEngine/C_flag.hpp"
 #include "FastEngine/network/C_clientList.hpp"
 #include "FastEngine/network/C_netCommand.hpp"
 #include "FastEngine/network/C_packet.hpp"
-#include "FastEngine/network/C_packetLZ4.hpp"
 #include "FastEngine/network/C_protocol.hpp"
 #include <condition_variable>
 #include <future>
@@ -31,6 +31,7 @@
 #include <queue>
 #include <thread>
 
+
 #if defined(FGE_ENABLE_SERVER_NETWORK_RANDOM_LOST) || defined(FGE_ENABLE_CLIENT_NETWORK_RANDOM_LOST)
     #include "FastEngine/C_random.hpp"
 #endif
@@ -133,11 +134,6 @@ class FGE_API NetFluxUdp
     bool pushPacket(ReceivedPacketPtr&& fluxPck);
     void forcePushPacket(ReceivedPacketPtr fluxPck);
     void forcePushPacketFront(ReceivedPacketPtr fluxPck);
-    [[nodiscard]] FluxProcessResults processReorder(PacketReorderer& reorderer,
-                                                    ReceivedPacketPtr& packet,
-                                                    ProtocolPacket::CounterType currentCounter,
-                                                    ProtocolPacket::RealmType clientRealm,
-                                                    bool ignoreRealm);
 
     mutable std::mutex _g_mutexFlux;
     std::deque<ReceivedPacketPtr> _g_packets;
@@ -148,6 +144,7 @@ class FGE_API NetFluxUdp
     bool g_isDefaultFlux{false};
 
     friend class ServerSideNetUdp;
+    friend class PacketReorderer;
 };
 
 class FGE_API ServerNetFluxUdp : public NetFluxUdp, public ReturnPacketHandler
@@ -321,13 +318,18 @@ class FGE_API ClientSideNetUdp : public NetFluxUdp
     [[nodiscard]] std::size_t waitForPackets(std::chrono::milliseconds time_ms);
 
     [[nodiscard]] Identity const& getClientIdentity() const;
-    [[nodiscard]] ClientContext const& getClientContext() const;
-    [[nodiscard]] ClientContext& getClientContext();
 
     template<class TPacket = Packet>
     void sendTo(TransmitPacketPtr& pck, Identity const& id);
 
-    [[nodiscard]] FluxProcessResults process(ReceivedPacketPtr& packet);
+    enum ProcessOptions : uint32_t
+    {
+        OPTION_NONE = 0,
+        OPTION_NO_TIMEOUT = 1 << 0,
+        OPTION_ONE_SHOT = 1 << 1
+    };
+    [[nodiscard]] FluxProcessResults process(ReceivedPacketPtr& packet,
+                                             EnumFlags<ProcessOptions> options = OPTION_NONE);
 
     void resetReturnPacket();
     TransmitPacketPtr& startReturnEvent(ReturnEvents event);
@@ -366,7 +368,6 @@ class FGE_API ClientSideNetUdp : public NetFluxUdp
     Identity g_clientIdentity;
 
     std::recursive_mutex g_mutexCommands;
-    ClientContext g_clientContext;
 
     bool g_returnPacketEnabled{false};
     TransmitPacketPtr g_returnPacket;
diff --git a/includes/FastEngine/network/C_socket.hpp b/includes/FastEngine/network/C_socket.hpp
index 2ea9dbe5..ad15cf95 100644
--- a/includes/FastEngine/network/C_socket.hpp
+++ b/includes/FastEngine/network/C_socket.hpp
@@ -36,6 +36,13 @@
 #define FGE_SOCKET_IPV6_HEADER_SIZE 40
 #define FGE_SOCKET_UDP_HEADER_SIZE 8
 
+//TODO: Openssl still doesn't have the possibility to allow records size more than 16kB.
+// https://github.com/openssl/openssl/pull/27916
+// https://github.com/openssl/openssl/pull/18248
+// Record Size Limit Extension (RFC 8449)
+// So for now we keep the max datagram size to 16kB
+#define FGE_SOCKET_MAX_MTU (16384)
+
 #define FGE_SOCKET_FULL_DATAGRAM_SIZE (0xFFFF)
 #define FGE_SOCKET_IPV4_MAX_DATAGRAM_SIZE                                                                              \
     (FGE_SOCKET_FULL_DATAGRAM_SIZE - FGE_SOCKET_IPV4_HEADER_SIZE - FGE_SOCKET_UDP_HEADER_SIZE)
diff --git a/sources/network/C_client.cpp b/sources/network/C_client.cpp
index 150eaed6..204c04fc 100644
--- a/sources/network/C_client.cpp
+++ b/sources/network/C_client.cpp
@@ -19,6 +19,8 @@
 #include "private/fge_crypt.hpp"
 #include <limits>
 
+#include "private/fge_debug.hpp"
+
 namespace fge::net
 {
 
@@ -225,6 +227,12 @@ void Client::clearPackets()
 }
 void Client::pushPacket(TransmitPacketPtr pck)
 {
+    if (pck == nullptr)
+    {
+        FGE_DEBUG_PRINT("Client::pushPacket tried to push a nullptr packet");
+        return;
+    }
+
     if (this->g_status.isDisconnected())
     {
         return;
@@ -232,19 +240,12 @@ void Client::pushPacket(TransmitPacketPtr pck)
 
     std::scoped_lock const lck(this->g_mutex);
 
-#ifdef FGE_DEF_SERVER
-    pck->setCounter(this->advanceCurrentPacketCounter());
-#else
-    pck->setCounter(this->advanceClientPacketCounter());
-#endif
-
     pck->setRealm(this->getCurrentRealm());
-
-    pck->setLastReorderedPacketCounter(this->getLastReorderedPacketCounter());
+    pck->setCounter(this->advancePacketCounter(Targets::HOST));
 
     if (!pck->checkFlags(FGE_NET_HEADER_DO_NOT_REORDER_FLAG))
     {
-        this->resetLastReorderedPacketCounter();
+        pck->setReorderedCounter(this->advanceReorderedPacketCounter(Targets::HOST));
     }
 
     if (this->g_status.isInEncryptedState())
@@ -255,9 +256,20 @@ void Client::pushPacket(TransmitPacketPtr pck)
 }
 void Client::pushForcedFrontPacket(TransmitPacketPtr pck)
 {
+    if (pck == nullptr)
+    {
+        FGE_DEBUG_PRINT("Client::pushForcedFrontPacket tried to push a nullptr packet");
+        return;
+    }
+
     std::scoped_lock const lck(this->g_mutex);
     this->g_pendingTransmitPackets.push_front(std::move(pck));
 }
+bool Client::isReadyToAcceptMorePendingPackets() const
+{
+    std::scoped_lock const lck(this->g_mutex);
+    return this->g_allowMorePackets && this->g_pendingTransmitPackets.empty();
+}
 TransmitPacketPtr Client::popPacket()
 {
     std::scoped_lock const lck(this->g_mutex);
@@ -275,6 +287,12 @@ bool Client::isPendingPacketsEmpty() const
     std::scoped_lock const lck(this->g_mutex);
     return this->g_pendingTransmitPackets.empty();
 }
+void Client::allowMorePendingPackets(bool allow)
+{
+    std::scoped_lock const lck(this->g_mutex);
+    this->g_allowMorePackets = allow;
+}
+
 void Client::disconnect(bool pushDisconnectPacket)
 {
     std::scoped_lock const lck(this->g_mutex);
@@ -302,7 +320,8 @@ void Client::setCurrentRealm(ProtocolPacket::RealmType realm)
     std::scoped_lock const lck(this->g_mutex);
     if (this->g_currentRealm != realm)
     {
-        this->g_currentPacketCounter = 0;
+        this->g_hostPacketCounter = 0;
+        this->g_peerPacketCounter = 0;
         this->g_lastRealmChangeTimePoint = std::chrono::steady_clock::now();
         this->g_currentRealm = realm;
     }
@@ -310,62 +329,77 @@ void Client::setCurrentRealm(ProtocolPacket::RealmType realm)
 ProtocolPacket::RealmType Client::advanceCurrentRealm()
 {
     std::scoped_lock const lck(this->g_mutex);
-    this->g_currentPacketCounter = 0;
+    this->g_hostPacketCounter = 0;
+    this->g_peerPacketCounter = 0;
     this->g_lastRealmChangeTimePoint = std::chrono::steady_clock::now();
     return ++this->g_currentRealm;
 }
 
-ProtocolPacket::CounterType Client::getCurrentPacketCounter() const
+ProtocolPacket::CounterType Client::getPacketCounter(Targets target) const
 {
     std::scoped_lock const lck(this->g_mutex);
-    return this->g_currentPacketCounter;
+    if (target == Targets::HOST)
+    {
+        return this->g_hostPacketCounter;
+    }
+    return this->g_peerPacketCounter;
 }
-ProtocolPacket::CounterType Client::advanceCurrentPacketCounter()
+ProtocolPacket::CounterType Client::advancePacketCounter(Targets target)
 {
     std::scoped_lock const lck(this->g_mutex);
-    return ++this->g_currentPacketCounter;
+    if (target == Targets::HOST)
+    {
+        return ++this->g_hostPacketCounter;
+    }
+    return ++this->g_peerPacketCounter;
 }
-void Client::setCurrentPacketCounter(ProtocolPacket::CounterType counter)
+void Client::setPacketCounter(Targets target, ProtocolPacket::CounterType count)
 {
     std::scoped_lock const lck(this->g_mutex);
-    this->g_currentPacketCounter = counter;
-#ifdef FGE_DEF_SERVER
-    this->g_lastReorderedPacketCounter = counter;
-#endif
+    if (target == Targets::HOST)
+    {
+        this->g_hostPacketCounter = count;
+        return;
+    }
+    this->g_peerPacketCounter = count;
 }
 
-ProtocolPacket::CounterType Client::getClientPacketCounter() const
+ProtocolPacket::CounterType Client::getReorderedPacketCounter(Targets target) const
 {
     std::scoped_lock const lck(this->g_mutex);
-    return this->g_clientPacketCounter;
+    if (target == Targets::HOST)
+    {
+        return this->g_hostReorderedPacketCounter;
+    }
+    return this->g_peerReorderedPacketCounter;
 }
-ProtocolPacket::CounterType Client::advanceClientPacketCounter()
+ProtocolPacket::CounterType Client::advanceReorderedPacketCounter(Targets target)
 {
     std::scoped_lock const lck(this->g_mutex);
-    return this->g_clientPacketCounter++;
+    if (target == Targets::HOST)
+    {
+        return ++this->g_hostReorderedPacketCounter;
+    }
+    return ++this->g_peerReorderedPacketCounter;
 }
-void Client::setClientPacketCounter(ProtocolPacket::CounterType countId)
+void Client::setReorderedPacketCounter(Targets target, ProtocolPacket::CounterType count)
 {
     std::scoped_lock const lck(this->g_mutex);
-    this->g_clientPacketCounter = countId;
-#ifndef FGE_DEF_SERVER
-    this->g_lastReorderedPacketCounter = countId;
-#endif
+    if (target == Targets::HOST)
+    {
+        this->g_hostReorderedPacketCounter = count;
+        return;
+    }
+    this->g_peerReorderedPacketCounter = count;
 }
 
-void Client::resetLastReorderedPacketCounter()
-{
-    std::scoped_lock const lck(this->g_mutex);
-#ifdef FGE_DEF_SERVER
-    this->g_lastReorderedPacketCounter = this->g_currentPacketCounter;
-#else
-    this->g_lastReorderedPacketCounter = this->g_clientPacketCounter;
-#endif
-}
-ProtocolPacket::CounterType Client::getLastReorderedPacketCounter() const
+void Client::resetAllCounters()
 {
     std::scoped_lock const lck(this->g_mutex);
-    return this->g_lastReorderedPacketCounter;
+    this->g_hostPacketCounter = 0;
+    this->g_peerPacketCounter = 0;
+    this->g_hostReorderedPacketCounter = 0;
+    this->g_peerReorderedPacketCounter = 0;
 }
 
 void Client::acknowledgeReception(ReceivedPacketPtr const& packet)
diff --git a/sources/network/C_netClient.cpp b/sources/network/C_netClient.cpp
index f22b09fb..1da4b748 100644
--- a/sources/network/C_netClient.cpp
+++ b/sources/network/C_netClient.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "FastEngine/C_compressorLZ4.hpp"
 #include "FastEngine/manager/network_manager.hpp"
 #include "FastEngine/network/C_server.hpp"
 #include "private/fge_crypt.hpp"
@@ -118,9 +119,8 @@ void ClientSideNetUdp::stop()
         //Clear client
         this->_client.clearPackets();
         this->_client.clearLostPacketCount();
-        this->_client.setClientPacketCounter(0);
+        this->_client.resetAllCounters();
         this->_client.setCurrentRealm(FGE_NET_DEFAULT_REALM);
-        this->_client.setCurrentPacketCounter(0);
 
         CryptClientDestroy(this->_client.getCryptInfo());
         CryptUninit(this->g_crypt_ctx);
@@ -149,11 +149,11 @@ std::future<uint16_t> ClientSideNetUdp::retrieveMTU()
         throw Exception("Cannot retrieve MTU without a running client");
     }
 
-    auto command = std::make_unique<NetMTUCommand>(&this->g_clientContext._commands);
+    auto command = std::make_unique<NetMTUCommand>(&this->_client._context._commands);
     auto future = command->get_future();
 
     std::scoped_lock const lock(this->g_mutexCommands);
-    this->g_clientContext._commands.push_back(std::move(command));
+    this->_client._context._commands.push_back(std::move(command));
 
     return future;
 }
@@ -164,12 +164,12 @@ std::future<bool> ClientSideNetUdp::connect(std::string_view versioningString)
         throw Exception("Cannot connect without a running client");
     }
 
-    auto command = std::make_unique<NetConnectCommand>(&this->g_clientContext._commands);
+    auto command = std::make_unique<NetConnectCommand>(&this->_client._context._commands);
     auto future = command->get_future();
     command->setVersioningString(versioningString);
 
     std::scoped_lock const lock(this->g_mutexCommands);
-    this->g_clientContext._commands.push_back(std::move(command));
+    this->_client._context._commands.push_back(std::move(command));
 
     return future;
 }
@@ -185,11 +185,11 @@ std::future<void> ClientSideNetUdp::disconnect()
 
     this->enableReturnPacket(false);
 
-    auto command = std::make_unique<NetDisconnectCommand>(&this->g_clientContext._commands);
+    auto command = std::make_unique<NetDisconnectCommand>(&this->_client._context._commands);
     auto future = command->get_future();
 
     std::scoped_lock const lock(this->g_mutexCommands);
-    this->g_clientContext._commands.push_back(std::move(command));
+    this->_client._context._commands.push_back(std::move(command));
 
     return future;
 }
@@ -198,18 +198,9 @@ Identity const& ClientSideNetUdp::getClientIdentity() const
 {
     return this->g_clientIdentity;
 }
-ClientContext const& ClientSideNetUdp::getClientContext() const
-{
-    return this->g_clientContext;
-}
-ClientContext& ClientSideNetUdp::getClientContext()
-{
-    return this->g_clientContext;
-}
 
-FluxProcessResults ClientSideNetUdp::process(ReceivedPacketPtr& packet)
+FluxProcessResults ClientSideNetUdp::process(ReceivedPacketPtr& packet, EnumFlags<ProcessOptions> options)
 {
-    ///TODO: no lock ?
     packet.reset();
 
     if (this->_client.getStatus().isDisconnected())
@@ -218,78 +209,113 @@ FluxProcessResults ClientSideNetUdp::process(ReceivedPacketPtr& packet)
         return FluxProcessResults::NONE_AVAILABLE;
     }
 
-    //Checking timeout
-    if (this->_client.getStatus().isTimeout())
+    if (options.has(OPTION_ONE_SHOT))
     {
-        this->_client.getStatus().setNetworkStatus(ClientStatus::NetworkStatus::TIMEOUT);
-        this->_g_remainingPackets = 0;
-        this->clearPackets();
-        this->_onClientTimeout.call(*this);
-        return FluxProcessResults::NONE_AVAILABLE;
+        options.set(OPTION_NO_TIMEOUT);
     }
 
-    //Checking return packet
-    if (this->isReturnPacketEnabled())
+    //Checking timeout
+    if (!options.has(OPTION_NO_TIMEOUT))
     {
-        auto const now = std::chrono::steady_clock::now();
-        if (now - this->g_returnPacketTimePoint >= this->_client.getPacketReturnRate())
+        if (this->_client.getStatus().isTimeout())
         {
-            this->g_returnPacketTimePoint = now;
-            auto returnPacket = this->prepareAndRetrieveReturnPacket();
-            this->_onTransmitReturnPacket.call(*this, returnPacket);
-            this->_client.pushPacket(std::move(returnPacket));
+            this->_client.getStatus().setNetworkStatus(ClientStatus::NetworkStatus::TIMEOUT);
+            this->_g_remainingPackets = 0;
+            this->clearPackets();
+            this->_onClientTimeout.call(*this);
+            return FluxProcessResults::NONE_AVAILABLE;
         }
     }
 
-    if (this->_g_remainingPackets == 0)
+    //Checking return packet
+    if (!options.has(OPTION_ONE_SHOT))
     {
-        this->_g_remainingPackets = this->getPacketsSize();
-        return FluxProcessResults::NONE_AVAILABLE;
-    }
+        if (this->isReturnPacketEnabled())
+        {
+            auto const now = std::chrono::steady_clock::now();
+            if (now - this->g_returnPacketTimePoint >= this->_client.getPacketReturnRate())
+            {
+                this->g_returnPacketTimePoint = now;
+                auto returnPacket = this->prepareAndRetrieveReturnPacket();
+                this->_onTransmitReturnPacket.call(*this, returnPacket);
+                this->_client.pushPacket(std::move(returnPacket));
+            }
+        }
 
-    //Popping the next packet
-    packet = this->popNextPacket();
-    if (!packet)
+        if (this->_g_remainingPackets == 0)
+        {
+            this->_g_remainingPackets = this->getPacketsSize();
+            return FluxProcessResults::NONE_AVAILABLE;
+        }
+
+        //Popping the next packet
+        packet = this->popNextPacket();
+        if (!packet)
+        {
+            this->_g_remainingPackets = this->getPacketsSize();
+            return FluxProcessResults::NONE_AVAILABLE;
+        }
+        --this->_g_remainingPackets;
+    }
+    else
     {
-        this->_g_remainingPackets = this->getPacketsSize();
-        return FluxProcessResults::NONE_AVAILABLE;
+        packet = this->popNextPacket();
+        if (!packet)
+        {
+            return FluxProcessResults::NONE_AVAILABLE;
+        }
     }
-    --this->_g_remainingPackets;
+
+#ifdef FGE_ENABLE_PACKET_DEBUG_VERBOSE
+    auto const counter = packet->retrieveCounter().value();
+    auto const reorderedCounter = packet->retrieveReorderedCounter().value();
+    FGE_DEBUG_PRINT("Checking packet [{}/{}]", counter, reorderedCounter);
+#endif
 
     if (!packet->isMarkedAsLocallyReordered())
     {
+#ifdef FGE_ENABLE_PACKET_DEBUG_VERBOSE
+        FGE_DEBUG_PRINT("Acknowledging reception of packet [{}/{}]", counter, reorderedCounter);
+#endif
         this->_client.acknowledgeReception(packet);
     }
 
-    auto const stat = PacketReorderer::checkStat(packet, this->_client.getCurrentPacketCounter(),
-                                                 this->_client.getCurrentRealm());
+    auto const stat = PacketReorderer::checkStat(packet, this->_client, false);
+
+    bool const doNotDiscard = packet->checkFlags(FGE_NET_HEADER_DO_NOT_DISCARD_FLAG);
+    bool const doNotReorder = packet->checkFlags(FGE_NET_HEADER_DO_NOT_REORDER_FLAG);
+
+#ifdef FGE_ENABLE_PACKET_DEBUG_VERBOSE
+    FGE_DEBUG_PRINT("Packet is doNotDiscard {} and doNotReorder {}", doNotDiscard, doNotReorder);
+#endif
 
-    if (!packet->checkFlags(FGE_NET_HEADER_DO_NOT_DISCARD_FLAG))
+    if (!doNotDiscard)
     {
         if (stat == PacketReorderer::Stats::OLD_REALM || stat == PacketReorderer::Stats::OLD_COUNTER)
         {
 #ifdef FGE_DEF_DEBUG
-            auto const packetCounter = packet->retrieveCounter().value();
             auto const packetRealm = packet->retrieveRealm().value();
-            auto const currentCounter = this->_client.getCurrentPacketCounter();
+            auto const packetCounter = packet->retrieveCounter().value();
+            auto const packetReorderedCounter = packet->retrieveReorderedCounter().value();
+            auto const peerCounter = this->_client.getPacketCounter(Client::Targets::PEER);
+            auto const peerReorderedCounter = this->_client.getReorderedPacketCounter(Client::Targets::PEER);
 #endif
-            FGE_DEBUG_PRINT("Packet is old, discarding it packetCounter: {}, packetRealm: {}, currentCounter: {}",
-                            packetCounter, packetRealm, currentCounter);
+            FGE_DEBUG_PRINT("Packet is old, discarding it. Packet realm: {}, counter: {}, reorderedCounter: {}. Peer "
+                            "counter: {}, reorderedCounter: {}",
+                            packetRealm, packetCounter, packetReorderedCounter, peerCounter, peerReorderedCounter);
             this->_client.advanceLostPacketCount();
             return FluxProcessResults::INTERNALLY_DISCARDED;
         }
     }
 
-    bool const doNotReorder = packet->checkFlags(FGE_NET_HEADER_DO_NOT_REORDER_FLAG);
-    if (!doNotReorder && !packet->isMarkedAsLocallyReordered())
+    if (!doNotReorder && !packet->isMarkedAsLocallyReordered() && stat != PacketReorderer::Stats::RETRIEVABLE)
     {
-        auto reorderResult =
-                this->processReorder(this->g_clientContext._reorderer, packet, this->_client.getCurrentPacketCounter(),
-                                     this->_client.getCurrentRealm(), false);
-        if (reorderResult != FluxProcessResults::USER_RETRIEVABLE)
-        {
-            return reorderResult;
-        }
+#ifdef FGE_ENABLE_PACKET_DEBUG_VERBOSE
+        FGE_DEBUG_PRINT("Packet goes into the reorderer");
+#endif
+        this->_client._context._reorderer.push(std::move(packet));
+        this->_client._context._reorderer.process(this->_client, *this, false);
+        return FluxProcessResults::INTERNALLY_HANDLED;
     }
 
     if (packet->retrieveHeaderId().value() == NET_INTERNAL_ID_DISCONNECT)
@@ -304,22 +330,39 @@ FluxProcessResults ClientSideNetUdp::process(ReceivedPacketPtr& packet)
     if (stat == PacketReorderer::Stats::WAITING_NEXT_REALM || stat == PacketReorderer::Stats::WAITING_NEXT_COUNTER)
     {
 #ifdef FGE_DEF_DEBUG
-        auto const packetCounter = packet->retrieveCounter().value();
         auto const packetRealm = packet->retrieveRealm().value();
-        auto const currentCounter = this->_client.getCurrentPacketCounter();
+        auto const packetCounter = packet->retrieveCounter().value();
+        auto const packetReorderedCounter = packet->retrieveReorderedCounter().value();
+        auto const peerCounter = this->_client.getPacketCounter(Client::Targets::PEER);
+        auto const peerReorderedCounter = this->_client.getReorderedPacketCounter(Client::Targets::PEER);
 #endif
-        FGE_DEBUG_PRINT("We lose a packet packetCounter: {}, packetRealm: {}, currentCounter: {}", packetCounter,
-                        packetRealm, currentCounter);
+        FGE_DEBUG_PRINT("We lose a packet. Packet realm: {}, counter: {}, reorderedCounter: {}. Peer counter: {}, "
+                        "reorderedCounter: {}",
+                        packetRealm, packetCounter, packetReorderedCounter, peerCounter, peerReorderedCounter);
         this->_client.advanceLostPacketCount(); //We are missing a packet
     }
 
-    if (!doNotReorder)
+    if (stat != PacketReorderer::Stats::OLD_REALM && stat != PacketReorderer::Stats::OLD_COUNTER)
     {
-        auto const serverCountId = packet->retrieveCounter().value();
-        this->_client.setCurrentPacketCounter(serverCountId);
+#ifdef FGE_ENABLE_PACKET_DEBUG_VERBOSE
+        auto const wasRealm = this->_client.getCurrentRealm();
+        auto const wasCounter = this->_client.getPacketCounter(Client::Targets::PEER);
+        auto const wasReorderedCounter = this->_client.getReorderedPacketCounter(Client::Targets::PEER);
+        FGE_DEBUG_PRINT("Was : realm {}, counter {}, reorderedCounter {}", wasRealm, wasCounter, wasReorderedCounter);
+#endif
+        auto const peerRealm = packet->retrieveRealm().value();
+        this->_client.setCurrentRealm(peerRealm);
+        auto const peerCounter = packet->retrieveCounter().value();
+        this->_client.setPacketCounter(Client::Targets::PEER, peerCounter);
+        auto const peerReorderedCounter = packet->retrieveReorderedCounter().value();
+        this->_client.setReorderedPacketCounter(Client::Targets::PEER, peerReorderedCounter);
+#ifdef FGE_ENABLE_PACKET_DEBUG_VERBOSE
+        FGE_DEBUG_PRINT("Updating peer state to realm {}, counter {}, reorderedCounter {}", peerRealm, peerCounter,
+                        peerReorderedCounter);
+#endif
     }
-    auto const serverRealm = packet->retrieveRealm().value();
-    this->_client.setCurrentRealm(serverRealm);
+
+    this->_client._context._reorderer.process(this->_client, *this, false);
 
     return FluxProcessResults::USER_RETRIEVABLE;
 }
@@ -443,7 +486,7 @@ std::optional<Error> ClientSideNetUdp::loopbackReturnPacket(ReturnPacketHandler
 
     ClientSharedPtr const clientPtr = std::shared_ptr<Client>(&this->_client, [](Client*) {});
 
-    return handler.handleReturnPacket(clientPtr, this->g_clientContext, returnPacket);
+    return handler.handleReturnPacket(clientPtr, this->_client._context, returnPacket);
 }
 
 std::size_t ClientSideNetUdp::waitForPackets(std::chrono::milliseconds time_ms)
@@ -474,7 +517,7 @@ void ClientSideNetUdp::threadReception()
             }
 
 #ifdef FGE_ENABLE_CLIENT_NETWORK_RANDOM_LOST
-            if (fge::_random.range(0, 1000) <= 10)
+            if (fge::_random.range(0, 5000) <= 10)
             {
                 continue;
             }
@@ -496,6 +539,7 @@ void ClientSideNetUdp::threadReception()
             //Here we consider that the packet is not encrypted
             if (!packet->haveCorrectHeader())
             {
+                FGE_DEBUG_PRINT("A packet have incorrect header, discarding it");
                 continue;
             }
             //Skip the header for reading
@@ -504,10 +548,10 @@ void ClientSideNetUdp::threadReception()
             //Check if the packet is a fragment
             if (packet->isFragmented())
             {
-                auto const result = this->g_clientContext._defragmentation.process(std::move(packet));
+                auto const result = this->_client._context._defragmentation.process(std::move(packet));
                 if (result._result == PacketDefragmentation::Results::RETRIEVABLE)
                 {
-                    packet = this->g_clientContext._defragmentation.retrieve(result._id, this->g_clientIdentity);
+                    packet = this->_client._context._defragmentation.retrieve(result._id, this->g_clientIdentity);
                 }
                 else
                 {
@@ -566,10 +610,10 @@ void ClientSideNetUdp::threadReception()
             //Checking commands
             {
                 std::scoped_lock const commandLock(this->g_mutexCommands);
-                if (!this->g_clientContext._commands.empty())
+                if (!this->_client._context._commands.empty())
                 {
-                    this->g_clientContext._commands.front()->onReceive(packet, this->g_socket.getAddressType(),
-                                                                       this->_client);
+                    this->_client._context._commands.front()->onReceive(packet, this->g_socket.getAddressType(),
+                                                                        this->_client);
 
                     //Commands can drop the packet
                     if (!packet)
@@ -605,14 +649,14 @@ void ClientSideNetUdp::threadTransmission()
         if (commandsTime >= FGE_NET_CMD_UPDATE_TICK_MS)
         {
             std::scoped_lock const commandLock(this->g_mutexCommands);
-            if (!this->g_clientContext._commands.empty())
+            if (!this->_client._context._commands.empty())
             {
                 TransmitPacketPtr possiblePacket;
-                auto const result = this->g_clientContext._commands.front()->update(
+                auto const result = this->_client._context._commands.front()->update(
                         possiblePacket, this->g_socket.getAddressType(), this->_client, commandsTime);
                 if (result == NetCommandResults::SUCCESS || result == NetCommandResults::FAILURE)
                 {
-                    this->g_clientContext._commands.pop_front();
+                    this->_client._context._commands.pop_front();
                 }
 
                 if (possiblePacket)
diff --git a/sources/network/C_netCommand.cpp b/sources/network/C_netCommand.cpp
index 406dc7e1..e948e671 100644
--- a/sources/network/C_netCommand.cpp
+++ b/sources/network/C_netCommand.cpp
@@ -164,8 +164,8 @@ void NetMTUCommand::onReceive(std::unique_ptr<ProtocolPacket>& packet,
 
             FGE_DEBUG_PRINT("MTU: targetMTU: {}", targetMTU);
 
-            auto const ourCurrentMTU = static_cast<uint16_t>(FGE_SOCKET_FULL_DATAGRAM_SIZE);
-            //socket.retrieveCurrentAdapterMTU().value_or(FGE_SOCKET_FULL_DATAGRAM_SIZE); TODO
+            auto const ourCurrentMTU = static_cast<uint16_t>(FGE_SOCKET_MAX_MTU);
+            //socket.retrieveCurrentAdapterMTU().value_or(FGE_SOCKET_MAX_MTU); TODO
             if (targetMTU == 0)
             {
                 //We have to figure it ourselves
@@ -372,8 +372,7 @@ void NetConnectCommand::internalUpdate(TransmitPacketPtr& buffPacket,
             FGE_DEBUG_PRINT("TX CONNECTED");
             client.getStatus().setNetworkStatus(ClientStatus::NetworkStatus::CONNECTED);
             client.getStatus().setTimeout(FGE_NET_STATUS_DEFAULT_CONNECTED_TIMEOUT);
-            client.setClientPacketCounter(0);
-            client.setCurrentPacketCounter(0);
+            client.resetAllCounters();
             this->g_promise.set_value(true);
             this->g_state = States::CONNECTED;
             this->markAsSucceeded();
@@ -434,8 +433,7 @@ void NetConnectCommand::internalUpdate(TransmitPacketPtr& buffPacket,
             FGE_DEBUG_PRINT("CONNECTED");
             client.getStatus().setNetworkStatus(ClientStatus::NetworkStatus::CONNECTED);
             client.getStatus().setTimeout(FGE_NET_STATUS_DEFAULT_CONNECTED_TIMEOUT);
-            client.setClientPacketCounter(0);
-            client.setCurrentPacketCounter(0);
+            client.resetAllCounters();
             this->g_promise.set_value(true);
             this->markAsSucceeded();
         }
@@ -599,8 +597,7 @@ void NetConnectHandlerCommand::internalUpdate(TransmitPacketPtr& buffPacket,
             FGE_DEBUG_PRINT("TX CONNECTED");
             client.getStatus().setNetworkStatus(ClientStatus::NetworkStatus::CONNECTED);
             client.getStatus().setTimeout(FGE_NET_STATUS_DEFAULT_CONNECTED_TIMEOUT);
-            client.setClientPacketCounter(0);
-            client.setCurrentPacketCounter(0);
+            client.resetAllCounters();
             this->g_promise.set_value(true);
             this->g_state = States::CONNECTED;
             this->markAsSucceeded();
@@ -661,9 +658,9 @@ void NetConnectHandlerCommand::internalUpdate(TransmitPacketPtr& buffPacket,
             FGE_DEBUG_PRINT("CONNECTED");
             client.getStatus().setNetworkStatus(ClientStatus::NetworkStatus::CONNECTED);
             client.getStatus().setTimeout(FGE_NET_STATUS_DEFAULT_CONNECTED_TIMEOUT);
-            client.setClientPacketCounter(0);
-            client.setCurrentPacketCounter(0);
+            client.resetAllCounters();
             this->g_promise.set_value(true);
+            this->g_state = States::CONNECTED;
             this->markAsSucceeded();
         }
         break;
diff --git a/sources/network/C_netServer.cpp b/sources/network/C_netServer.cpp
index 099efba5..d243a278 100644
--- a/sources/network/C_netServer.cpp
+++ b/sources/network/C_netServer.cpp
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "FastEngine/C_compressorLZ4.hpp"
 #include "FastEngine/manager/network_manager.hpp"
 #include "FastEngine/network/C_server.hpp"
 #include "private/fge_crypt.hpp"
@@ -370,18 +371,7 @@ void ServerSideNetUdp::threadTransmission()
                 auto& client = itClient->second;
 
                 //check cache
-                {
-                    auto const clientLatency =
-                            client->getPacketReturnRate() * FGE_NET_PACKET_CACHE_DELAY_FACTOR +
-                            std::chrono::milliseconds(client->_latencyPlanner.getRoundTripTime().value_or(1));
-
-                    while (client->_context._cache.check(
-                            timePoint, std::chrono::duration_cast<std::chrono::milliseconds>(clientLatency)))
-                    {
-                        FGE_DEBUG_PRINT("re-transmit packet as client didn't acknowledge it");
-                        client->pushForcedFrontPacket(client->_context._cache.pop());
-                    }
-                }
+                client->_context._cache.process(timePoint, *client);
 
                 if (client->isPendingPacketsEmpty())
                 {
@@ -405,6 +395,7 @@ void ServerSideNetUdp::threadTransmission()
                         {
                             if (!transmissionPacket->compress(compressor))
                             {
+                                FGE_DEBUG_PRINT("Error while compressing a packet");
                                 continue;
                             }
                         }
@@ -425,6 +416,14 @@ void ServerSideNetUdp::threadTransmission()
                     }
 
                     auto fragments = transmissionPacket->fragment(mtu);
+#ifdef FGE_ENABLE_PACKET_DEBUG_VERBOSE
+                    auto const fragmentCount = fragments.size();
+                    if (fragmentCount > 1)
+                    {
+                        auto const originalSize = transmissionPacket->getDataSize();
+                        FGE_DEBUG_PRINT("Fragmenting packet of size {} into {} fragments", originalSize, fragmentCount);
+                    }
+#endif
                     for (std::size_t iFragment = 0; iFragment < fragments.size(); ++iFragment)
                     {
                         if (iFragment == 0)
@@ -433,6 +432,8 @@ void ServerSideNetUdp::threadTransmission()
                         }
                         else
                         {
+                            fragments[iFragment]
+                                    ->markAsCached(); //TODO: maybe allow fragments to be cached individually?
                             client->pushForcedFrontPacket(std::move(fragments[iFragment]));
                         }
                     }
@@ -441,6 +442,7 @@ void ServerSideNetUdp::threadTransmission()
 
                 if (!transmissionPacket->packet() || !transmissionPacket->haveCorrectHeaderSize())
                 { //Last verification of the packet
+                    FGE_DEBUG_PRINT("Invalid packet before sending");
                     continue;
                 }
 
@@ -449,6 +451,7 @@ void ServerSideNetUdp::threadTransmission()
                 {
                     if (!CryptEncrypt(*client, *transmissionPacket))
                     {
+                        FGE_DEBUG_PRINT("Error while encrypting a packet");
                         continue;
                     }
                 }
diff --git a/sources/network/C_packet.cpp b/sources/network/C_packet.cpp
index 62e9eccd..bf6b8101 100644
--- a/sources/network/C_packet.cpp
+++ b/sources/network/C_packet.cpp
@@ -58,14 +58,30 @@ Packet::Packet(Packet&& pck) noexcept :
 }
 
 Packet::Packet(std::size_t reserveSize) :
-        _g_transmitPos(0),
-        _g_transmitCacheValid(false),
-        g_readPos(0),
-        g_valid(true)
+        Packet()
 {
     this->g_data.reserve(reserveSize);
 }
 
+Packet& Packet::operator=(Packet&& pck) noexcept
+{
+    if (this != &pck)
+    {
+        this->_g_transmitCache = std::move(pck._g_transmitCache);
+        this->_g_transmitPos = pck._g_transmitPos;
+        this->_g_transmitCacheValid = pck._g_transmitCacheValid;
+        this->g_data = std::move(pck.g_data);
+        this->g_readPos = pck.g_readPos;
+        this->g_valid = pck.g_valid;
+
+        pck._g_transmitCacheValid = false;
+        pck.g_valid = true;
+        pck.g_readPos = 0;
+        pck._g_transmitPos = 0;
+    }
+    return *this;
+}
+
 void Packet::clear()
 {
     this->_g_transmitPos = 0;
diff --git a/sources/network/C_protocol.cpp b/sources/network/C_protocol.cpp
index eb0cdad6..d08356c6 100644
--- a/sources/network/C_protocol.cpp
+++ b/sources/network/C_protocol.cpp
@@ -15,6 +15,8 @@
  */
 
 #include "FastEngine/network/C_protocol.hpp"
+
+#include "FastEngine/C_alloca.hpp"
 #include "FastEngine/C_compressor.hpp"
 #include "FastEngine/fge_except.hpp"
 #include "FastEngine/network/C_server.hpp"
@@ -178,6 +180,9 @@ PacketDefragmentation::Result PacketDefragmentation::process(ReceivedPacketPtr&&
 {
     auto const id = packet->retrieveRealm().value();
     auto const counter = packet->retrieveCounter().value();
+#ifdef FGE_ENABLE_PACKET_DEBUG_VERBOSE
+    FGE_DEBUG_PRINT("Defragmentation: Processing fragment for id {}, counter {}.", id, counter);
+#endif
 
     for (auto itData = this->g_data.begin(); itData != this->g_data.end(); ++itData)
     {
@@ -257,8 +262,77 @@ void PacketReorderer::clear()
     decltype(this->g_cache)().swap(this->g_cache);
 }
 
+bool PacketReorderer::process(Client& client, NetFluxUdp& flux, bool ignoreRealm)
+{
+    auto statOpt = this->checkStat(client, ignoreRealm);
+    if (!statOpt)
+    {
+        return false; //Empty
+    }
+
+    if (statOpt.value() == Stats::OLD_COUNTER || statOpt.value() == Stats::OLD_REALM)
+    {
+#ifdef FGE_DEF_DEBUG
+        auto packet = this->pop();
+        auto const packetRealm = packet->retrieveRealm().value();
+        auto const packetCounter = packet->retrieveCounter().value();
+        auto const packetReorderedCounter = packet->retrieveReorderedCounter().value();
+        FGE_DEBUG_PRINT("Reorderer: Packet is old, discarding it. Packet realm: {}, counter: {}, reorderedCounter: {}.",
+                        packetRealm, packetCounter, packetReorderedCounter);
+#else
+        (void) this->pop();
+#endif
+        client.advanceLostPacketCount();
+        return false; //We can't process old packets
+    }
+
+    if (!this->g_forceRetrieve && statOpt.value() != Stats::RETRIEVABLE)
+    {
+        return false; //We can't process the packet now
+    }
+
+    ProtocolPacket::CounterType peerCounter{0};
+    ProtocolPacket::CounterType peerReorderedCounter{0};
+    ProtocolPacket::RealmType currentRealm{0};
+
+    auto const reordererMaxSize = this->getMaximumSize();
+    std::size_t containerInvertedSize = 0;
+    auto* containerInverted = FGE_ALLOCA_T(ReceivedPacketPtr, reordererMaxSize);
+    FGE_PLACE_CONSTRUCT(ReceivedPacketPtr, reordererMaxSize, containerInverted);
+
+    do {
+        auto packet = this->pop();
+        peerCounter = packet->retrieveCounter().value();
+        peerReorderedCounter = packet->retrieveReorderedCounter().value();
+        currentRealm = packet->retrieveRealm().value();
+
+        //Add it to the container (we are going to push in front of the queue, so we need to invert the order)
+        containerInverted[containerInvertedSize++] = std::move(packet);
+
+        statOpt = this->checkStat(peerCounter, peerReorderedCounter, currentRealm, ignoreRealm);
+    } while (statOpt.has_value() && (statOpt.value() == Stats::RETRIEVABLE || this->g_forceRetrieve));
+
+    //Now we push the packets (until the last one) in the correct order in the flux queue
+    for (std::size_t i = containerInvertedSize; i != 0; --i)
+    {
+        flux.forcePushPacketFront(std::move(containerInverted[i - 1]));
+    }
+
+    FGE_PLACE_DESTRUCT(ReceivedPacketPtr, reordererMaxSize, containerInverted);
+
+    this->g_forceRetrieve = false;
+    return true;
+}
+
 void PacketReorderer::push(ReceivedPacketPtr&& packet)
 {
+    if (packet->checkFlags(FGE_NET_HEADER_DO_NOT_REORDER_FLAG))
+    {
+        FGE_DEBUG_PRINT("Reorderer: Packet has DO_NOT_REORDER flag, cannot be pushed to reorderer");
+        return;
+    }
+
+    packet->markAsLocallyReordered();
     this->g_cache.emplace(std::move(packet));
     if (this->g_cache.size() >= this->g_cacheSize)
     {
@@ -266,36 +340,57 @@ void PacketReorderer::push(ReceivedPacketPtr&& packet)
         //as the cache is full, the waiting packet is considered lost
         //and we can move on. (if he is still missing)
         this->g_forceRetrieve = true;
-        FGE_DEBUG_PRINT("PacketReorderer: Cache is full, we can't wait anymore for the correct packet to arrive");
+        FGE_DEBUG_PRINT("Reorderer: Cache is full, we can't wait anymore for the correct packet to arrive");
     }
 }
+
+PacketReorderer::Stats
+PacketReorderer::checkStat(ReceivedPacketPtr const& packet, Client const& client, bool ignoreRealm)
+{
+    return PacketReorderer::checkStat(packet, client.getPacketCounter(Client::Targets::PEER),
+                                      client.getReorderedPacketCounter(Client::Targets::PEER), client.getCurrentRealm(),
+                                      ignoreRealm);
+}
 PacketReorderer::Stats PacketReorderer::checkStat(ReceivedPacketPtr const& packet,
-                                                  ProtocolPacket::CounterType currentCounter,
-                                                  ProtocolPacket::RealmType currentRealm)
+                                                  ProtocolPacket::CounterType peerCounter,
+                                                  ProtocolPacket::CounterType peerReorderedCounter,
+                                                  ProtocolPacket::RealmType peerRealm,
+                                                  bool ignoreRealm)
 {
-    auto const lastCounter = packet->retrieveLastCounter().value();
-    auto counter = packet->retrieveCounter().value();
+    auto const packetCounter = packet->retrieveCounter().value();
+    auto const packetReorderedCounter = packet->retrieveReorderedCounter().value();
+    auto const packetRealm = packet->retrieveRealm().value();
 
-    counter = (counter == lastCounter) ? counter : (lastCounter + 1);
+    auto const currentRealm = ignoreRealm ? packetRealm : peerRealm;
 
-    auto const realm = packet->retrieveRealm().value();
+    auto const doNotReorderFlag = packet->checkFlags(FGE_NET_HEADER_DO_NOT_REORDER_FLAG);
 
-    if (realm < currentRealm && currentRealm + 1 != 0)
+    if (packetRealm < currentRealm && currentRealm + 1 != 0)
     {
         return Stats::OLD_REALM;
     }
 
-    if (currentRealm != realm && counter != 0)
+    if (currentRealm != packetRealm && packetCounter != 0)
     { //Different realm, we can switch to the new realm only if the counter is 0 (first packet of the new realm)
         return Stats::WAITING_NEXT_REALM;
     }
 
-    if (counter == currentCounter + 1)
+    if (doNotReorderFlag)
+    {
+        if (packetCounter < peerCounter)
+        { //We are missing a packet
+            //TODO: we do not handle case where there is a overflow
+            return Stats::OLD_COUNTER;
+        }
+        return Stats::RETRIEVABLE;
+    }
+
+    if (packetReorderedCounter == peerReorderedCounter + 1)
     { //Same realm, we can switch to the next counter
         return Stats::RETRIEVABLE;
     }
 
-    if (counter < currentCounter)
+    if (packetReorderedCounter < peerReorderedCounter)
     { //We are missing a packet
         return Stats::OLD_COUNTER;
     }
@@ -303,20 +398,25 @@ PacketReorderer::Stats PacketReorderer::checkStat(ReceivedPacketPtr const& packe
     //We can't switch to the next counter, we wait for the correct packet to arrive
     return Stats::WAITING_NEXT_COUNTER;
 }
-bool PacketReorderer::isForced() const
+std::optional<PacketReorderer::Stats> PacketReorderer::checkStat(Client const& client, bool ignoreRealm) const
 {
-    return this->g_forceRetrieve;
+    return this->checkStat(client.getPacketCounter(Client::Targets::PEER),
+                           client.getReorderedPacketCounter(Client::Targets::PEER), client.getCurrentRealm(),
+                           ignoreRealm);
 }
-std::optional<PacketReorderer::Stats> PacketReorderer::checkStat(ProtocolPacket::CounterType currentCounter,
-                                                                 ProtocolPacket::RealmType currentRealm) const
+std::optional<PacketReorderer::Stats> PacketReorderer::checkStat(ProtocolPacket::CounterType peerCounter,
+                                                                 ProtocolPacket::CounterType peerReorderedCounter,
+                                                                 ProtocolPacket::RealmType peerRealm,
+                                                                 bool ignoreRealm) const
 {
     if (this->g_cache.empty())
     {
         return std::nullopt;
     }
 
-    return this->g_cache.top().checkStat(currentCounter, currentRealm);
+    return this->g_cache.top().checkStat(peerCounter, peerReorderedCounter, peerRealm, ignoreRealm);
 }
+
 ReceivedPacketPtr PacketReorderer::pop()
 {
     if (this->g_cache.empty())
@@ -339,6 +439,10 @@ bool PacketReorderer::isEmpty() const
 {
     return this->g_cache.empty();
 }
+bool PacketReorderer::isForced() const
+{
+    return this->g_forceRetrieve;
+}
 
 void PacketReorderer::setMaximumSize(std::size_t size)
 {
@@ -353,13 +457,13 @@ std::size_t PacketReorderer::getMaximumSize() const
 PacketReorderer::Data::Data(ReceivedPacketPtr&& packet) :
         _packet(std::move(packet)),
         _counter(_packet->retrieveCounter().value()),
-        _lastCounter(_packet->retrieveLastCounter().value()),
+        _reorderedCounter(_packet->retrieveReorderedCounter().value()),
         _realm(_packet->retrieveRealm().value())
 {}
 PacketReorderer::Data::Data(Data&& r) noexcept :
         _packet(std::move(r._packet)),
         _counter(r._counter),
-        _lastCounter(r._lastCounter),
+        _reorderedCounter(r._reorderedCounter),
         _realm(r._realm)
 {}
 PacketReorderer::Data::~Data() = default;
@@ -368,49 +472,60 @@ PacketReorderer::Data& PacketReorderer::Data::operator=(Data&& r) noexcept
 {
     this->_packet = std::move(r._packet);
     this->_counter = r._counter;
-    this->_lastCounter = r._lastCounter;
+    this->_reorderedCounter = r._reorderedCounter;
     this->_realm = r._realm;
     return *this;
 }
 
-PacketReorderer::Stats PacketReorderer::Data::checkStat(ProtocolPacket::CounterType currentCounter,
-                                                        ProtocolPacket::RealmType currentRealm) const
+PacketReorderer::Stats PacketReorderer::Data::checkStat(ProtocolPacket::CounterType peerCounter,
+                                                        ProtocolPacket::CounterType peerReorderedCounter,
+                                                        ProtocolPacket::RealmType peerRealm,
+                                                        bool ignoreRealm) const
 {
-    FGE_DEBUG_PRINT("PacketReorderer: currentCounter {}, currentRealm {}, packetCounter {}->{}, packetRealm {}",
-                    currentCounter, currentRealm, this->_lastCounter, this->_counter, this->_realm);
-
-    if (this->_realm < currentRealm && currentRealm + 1 != 0)
+#ifdef FGE_ENABLE_PACKET_DEBUG_VERBOSE
+    FGE_DEBUG_PRINT("Reorderer::Data: Peer counters[{}/{}], realm {}. Packet counters[{}/{}], realm {}", peerCounter,
+                    peerReorderedCounter, peerRealm, this->_counter, this->_reorderedCounter, this->_realm);
+#endif
+
+#ifndef FGE_ENABLE_PACKET_DEBUG_VERBOSE
+    return PacketReorderer::checkStat(this->_packet, peerCounter, peerReorderedCounter, peerRealm, ignoreRealm);
+#else
+    auto const stat =
+            PacketReorderer::checkStat(this->_packet, peerCounter, peerReorderedCounter, peerRealm, ignoreRealm);
+
+    switch (stat)
     {
-        FGE_DEBUG_PRINT("\tPacketReorderer: Old realm");
-        return Stats::OLD_REALM;
-    }
-
-    if (currentRealm != this->_realm && this->_counter != 0)
-    { //Different realm, we can switch to the new realm only if the counter is 0 (first packet of the new realm)
-        FGE_DEBUG_PRINT("\tPacketReorderer: Different realm, we can switch to the new realm only if the counter is 0 "
+    case Stats::OLD_REALM:
+        FGE_DEBUG_PRINT("\tReorderer::Data: Old realm");
+        break;
+    case Stats::WAITING_NEXT_REALM:
+        FGE_DEBUG_PRINT("\tReorderer::Data: Different realm, we can switch to the new realm only if the counter is 0 "
                         "(first packet of the new realm)");
-        return Stats::WAITING_NEXT_REALM;
-    }
-
-    if (this->_lastCounter == currentCounter)
-    { //Same realm, we can switch to the next counter
-        FGE_DEBUG_PRINT("\tPacketReorderer: Same realm, correct counter, retrievable");
-        return Stats::RETRIEVABLE;
-    }
-
-    if (this->_lastCounter < currentCounter)
-    { //We are missing a packet
-        FGE_DEBUG_PRINT("\tPacketReorderer: We are missing a packet");
-        return Stats::OLD_COUNTER;
-    }
-
-    FGE_DEBUG_PRINT("\tPacketReorderer: We can't switch to the next counter, we wait for the correct packet to arrive");
-    //We can't switch to the next counter, we wait for the correct packet to arrive
-    return Stats::WAITING_NEXT_COUNTER;
+        break;
+    case Stats::OLD_COUNTER:
+        FGE_DEBUG_PRINT("\tReorderer::Data: We are missing a packet");
+        break;
+    case Stats::WAITING_NEXT_COUNTER:
+        FGE_DEBUG_PRINT(
+                "\tReorderer::Data: We can't switch to the next counter, we wait for the correct packet to arrive");
+        break;
+    case Stats::RETRIEVABLE:
+        FGE_DEBUG_PRINT("\tReorderer::Data: Same realm, correct counter, retrievable");
+        break;
+    default:
+        FGE_DEBUG_PRINT("\tReorderer::Data: Result is UNKNOWN");
+        break;
+    }
+    return stat;
+#endif
 }
 
 //PacketCache
 
+PacketCache::PacketCache()
+{
+    this->g_cache.reserve(FGE_NET_PACKET_CACHE_MAX);
+}
 PacketCache::PacketCache(PacketCache&& r) noexcept :
         PacketCache()
 {
@@ -418,14 +533,12 @@ PacketCache::PacketCache(PacketCache&& r) noexcept :
     std::scoped_lock const lockR(r.g_mutex);
 
     this->g_cache = std::move(r.g_cache);
-    this->g_start = r.g_start;
-    this->g_end = r.g_end;
+    this->g_alarm = r.g_enable;
     this->g_enable = r.g_enable;
 
     r.g_cache.clear();
-    r.g_cache.resize(FGE_NET_PACKET_CACHE_MAX);
-    r.g_start = 0;
-    r.g_end = 0;
+    r.g_cache.reserve(FGE_NET_PACKET_CACHE_MAX);
+    r.g_alarm = false;
 }
 
 PacketCache& PacketCache::operator=(PacketCache&& r) noexcept
@@ -436,14 +549,12 @@ PacketCache& PacketCache::operator=(PacketCache&& r) noexcept
         std::scoped_lock const lockR(r.g_mutex);
 
         this->g_cache = std::move(r.g_cache);
-        this->g_start = r.g_start;
-        this->g_end = r.g_end;
+        this->g_alarm = r.g_enable;
         this->g_enable = r.g_enable;
 
         r.g_cache.clear();
-        r.g_cache.resize(FGE_NET_PACKET_CACHE_MAX);
-        r.g_start = 0;
-        r.g_end = 0;
+        r.g_cache.reserve(FGE_NET_PACKET_CACHE_MAX);
+        r.g_alarm = false;
     }
     return *this;
 }
@@ -452,21 +563,25 @@ void PacketCache::clear()
 {
     std::scoped_lock const lock(this->g_mutex);
     this->g_cache.clear();
-    this->g_cache.resize(FGE_NET_PACKET_CACHE_MAX);
-    this->g_start = 0;
-    this->g_end = 0;
+    this->g_cache.reserve(FGE_NET_PACKET_CACHE_MAX);
+    this->g_alarm = false;
 }
 
 bool PacketCache::isEmpty() const
 {
     std::scoped_lock const lock(this->g_mutex);
-    return this->g_start == this->g_end;
+    return this->g_cache.empty();
 }
 bool PacketCache::isEnabled() const
 {
     std::scoped_lock const lock(this->g_mutex);
     return this->g_enable;
 }
+bool PacketCache::isAlarmed() const
+{
+    std::scoped_lock const lock(this->g_mutex);
+    return this->g_alarm;
+}
 void PacketCache::enable(bool enable)
 {
     std::scoped_lock const lock(this->g_mutex);
@@ -481,107 +596,105 @@ void PacketCache::push(TransmitPacketPtr const& packet)
         return;
     }
 
-    auto const next = (this->g_end + 1) % FGE_NET_PACKET_CACHE_MAX;
-
-    if (next == this->g_start)
+    this->g_cache.emplace_back(std::make_unique<ProtocolPacket>(*packet))._packet->markAsCached();
+    if (this->g_cache.size() >= FGE_NET_PACKET_CACHE_MAX)
     {
-        //Cache is full, we need to replace the oldest packet
-        FGE_DEBUG_PRINT("PacketCache: Cache is full, replacing the oldest packet {}",
-                        this->g_cache[this->g_start]._label._counter);
-        this->g_cache[this->g_start] = std::make_unique<ProtocolPacket>(*packet);
-        this->g_cache[this->g_start]._packet->markAsCached();
-        this->g_start = (this->g_start + 1) % FGE_NET_PACKET_CACHE_MAX;
-        this->g_end = next;
-        return;
+        FGE_DEBUG_PRINT("PacketCache: Cache reached maximum size");
+        this->g_alarm = true;
     }
-
-    this->g_cache[next] = std::make_unique<ProtocolPacket>(*packet);
-    this->g_cache[next]._packet->markAsCached();
-    this->g_end = next;
 }
 
 void PacketCache::acknowledgeReception(std::span<Label> labels)
 {
-    if (this->isEmpty())
+    std::scoped_lock const lock(this->g_mutex);
+
+    if (this->g_cache.empty())
     {
+        this->g_alarm = false;
         return;
     }
 
-    std::scoped_lock const lock(this->g_mutex);
-
     for (auto const& label: labels)
     {
-        auto index = this->g_start;
-
-        do {
-            auto& data = this->g_cache[index];
-            index = (index + 1) % FGE_NET_PACKET_CACHE_MAX;
-
-            if (!data._packet)
-            { //Already acknowledged
-                continue;
-            }
-
-            if (data._label == label)
-            {                           //We found the packet
-                data._packet = nullptr; //We acknowledge the packet by setting it to nullptr
+        for (auto it = this->g_cache.begin(); it != this->g_cache.end(); ++it)
+        {
+            if (it->_label == label)
+            {
+                this->g_cache.erase(it);
                 break;
             }
-        } while (index != this->g_end);
+        }
+    }
+
+    if (this->g_cache.empty())
+    {
+        this->g_alarm = false;
     }
 }
 
-bool PacketCache::check(std::chrono::steady_clock::time_point const& timePoint, std::chrono::milliseconds clientDelay)
+bool PacketCache::process(std::chrono::steady_clock::time_point const& timePoint, Client& client)
 {
-    if (this->isEmpty())
+    std::scoped_lock const lock(this->g_mutex);
+
+    if (this->g_cache.empty())
     {
+        client.allowMorePendingPackets(!this->g_alarm);
         return false;
     }
 
-    std::scoped_lock const lock(this->g_mutex);
+    auto clientDelay =
+            std::chrono::milliseconds(static_cast<std::chrono::milliseconds::rep>(
+                    static_cast<float>(client.getPacketReturnRate().count()) * FGE_NET_PACKET_CACHE_DELAY_FACTOR)) +
+            std::chrono::milliseconds(client._latencyPlanner.getRoundTripTime().value_or(1));
 
     if (clientDelay.count() < FGE_NET_PACKET_CACHE_MIN_LATENCY_MS)
     {
         clientDelay = std::chrono::milliseconds(FGE_NET_PACKET_CACHE_MIN_LATENCY_MS);
     }
 
-    auto index = this->g_start;
-    do {
-        auto& data = this->g_cache[index];
-        index = (index + 1) % FGE_NET_PACKET_CACHE_MAX;
+    bool needSetAlarm = false;
+    for (auto it = this->g_cache.begin(); it != this->g_cache.end();)
+    {
+        if (timePoint - it->_time >= clientDelay)
+        { //Packet has expired, advise the code to resend it
+            if (it->_tryCount++ == 3)
+            { //We loose this packet
+#ifdef FGE_DEF_DEBUG
+                auto const counter = it->_packet->retrieveCounter().value();
+                auto const reorderedCounter = it->_packet->retrieveReorderedCounter().value();
+                FGE_DEBUG_PRINT("PacketCache: Packet [{}/{}] lost after all tries", counter, reorderedCounter);
+#endif
+                it = this->g_cache.erase(it);
+                client.advanceLostPacketCount();
+                continue;
+            }
 
-        if (!data._packet)
-        { //Packet is acknowledged, let's remove it
-            this->g_start = index;
-            continue;
-        }
+            it->_time = timePoint;
 
-        if (timePoint - data._time >= clientDelay)
-        { //Packet has expired, advise the code to resend it
-            return true;
-        }
-        return false;
-    } while (index != this->g_end);
+#ifdef FGE_DEF_DEBUG
+            auto const counter = it->_packet->retrieveCounter().value();
+            auto const reorderedCounter = it->_packet->retrieveReorderedCounter().value();
+            FGE_DEBUG_PRINT("re-transmit packet [{}/{}] try {}, as client didn't acknowledge it", counter,
+                            reorderedCounter, it->_tryCount);
+#endif
 
-    //If we are here, it means that every packet that was in the cache has been acknowledged, so it's good
-    return false;
-}
+            client.pushForcedFrontPacket(std::make_unique<ProtocolPacket>(*it->_packet));
 
-TransmitPacketPtr PacketCache::pop()
-{
-    if (this->isEmpty())
-    {
-        return nullptr;
-    }
+            needSetAlarm = true;
+        }
+        else if (it->_tryCount > 0)
+        {
+            //We are in a current retransmission, set the alarm again
+            needSetAlarm = true;
+        }
 
-    std::scoped_lock const lock(this->g_mutex);
+        ++it;
+    }
 
-    //check() must be called before pop(), so we can remove index verification
-    //else it will be undefined behavior
+    client.allowMorePendingPackets(!needSetAlarm);
+    this->g_alarm = needSetAlarm;
 
-    auto const start = this->g_start;
-    this->g_start = (this->g_start + 1) % FGE_NET_PACKET_CACHE_MAX;
-    return std::move(this->g_cache[start]._packet);
+    return needSetAlarm;
 }
 
 PacketCache::Data::Data(TransmitPacketPtr&& packet) :
diff --git a/sources/network/C_server.cpp b/sources/network/C_server.cpp
index 4297cb55..9d71b9ed 100644
--- a/sources/network/C_server.cpp
+++ b/sources/network/C_server.cpp
@@ -187,81 +187,6 @@ void NetFluxUdp::forcePushPacketFront(ReceivedPacketPtr fluxPck)
     this->_g_packets.push_front(std::move(fluxPck));
 }
 
-FluxProcessResults NetFluxUdp::processReorder(PacketReorderer& reorderer,
-                                              ReceivedPacketPtr& packet,
-                                              ProtocolPacket::CounterType currentCounter,
-                                              ProtocolPacket::RealmType clientRealm,
-                                              bool ignoreRealm)
-{
-    auto currentRealm = ignoreRealm ? packet->retrieveRealm().value() : clientRealm;
-
-    if (reorderer.isEmpty())
-    {
-        auto const stat = PacketReorderer::checkStat(packet, currentCounter, currentRealm);
-
-        if (stat == PacketReorderer::Stats::RETRIEVABLE)
-        {
-            packet->markAsLocallyReordered();
-            return FluxProcessResults::USER_RETRIEVABLE;
-        }
-
-        reorderer.push(std::move(packet));
-        return FluxProcessResults::INTERNALLY_HANDLED;
-    }
-
-    //We push the packet in the reorderer
-    reorderer.push(std::move(packet));
-
-    //At this point we are sure that the reorderer contains at least 2 packets
-
-    bool forced = reorderer.isForced();
-    auto const stat = reorderer.checkStat(currentCounter, currentRealm).value();
-    if (!forced && stat != PacketReorderer::Stats::RETRIEVABLE)
-    {
-        return FluxProcessResults::INTERNALLY_HANDLED;
-    }
-
-    packet = reorderer.pop();
-    packet->markAsLocallyReordered();
-    currentCounter = packet->retrieveCounter().value();
-    currentRealm = packet->retrieveRealm().value();
-
-    auto const packerReordererMaxSize = reorderer.getMaximumSize();
-    std::size_t containerInversedSize = 0;
-    auto* containerInversed = FGE_ALLOCA_T(ReceivedPacketPtr, packerReordererMaxSize);
-    FGE_PLACE_CONSTRUCT(ReceivedPacketPtr, packerReordererMaxSize, containerInversed);
-
-    while (auto const stat = reorderer.checkStat(currentCounter, currentRealm))
-    {
-        if (!(stat == PacketReorderer::Stats::RETRIEVABLE || forced))
-        {
-            break;
-        }
-
-        auto reorderedPacket = reorderer.pop();
-
-        //Mark them as reordered
-        reorderedPacket->markAsLocallyReordered();
-
-        currentCounter = reorderedPacket->retrieveCounter().value();
-        currentRealm = reorderedPacket->retrieveRealm().value();
-
-        //Add it to the container (we are going to push in front of the flux queue, so we need to inverse the order)
-        containerInversed[containerInversedSize++] = std::move(reorderedPacket);
-    }
-
-    //Now we push the packets (until the last one) in the correct order in the flux queue
-    for (std::size_t i = containerInversedSize; i != 0; --i)
-    {
-        this->forcePushPacketFront(std::move(containerInversed[i - 1]));
-        ++this->_g_remainingPackets;
-    }
-
-    FGE_PLACE_DESTRUCT(ReceivedPacketPtr, packerReordererMaxSize, containerInversed);
-
-    return FluxProcessResults::USER_RETRIEVABLE;
-}
-
 ReceivedPacketPtr NetFluxUdp::popNextPacket()
 {
     std::scoped_lock const lock(this->_g_mutexFlux);
@@ -495,35 +420,35 @@ FluxProcessResults ServerNetFluxUdp::process(ClientSharedPtr& refClient, Receive
         return FluxProcessResults::INTERNALLY_DISCARDED;
     }
 
-    auto const stat =
-            PacketReorderer::checkStat(packet, refClient->getClientPacketCounter(), refClient->getCurrentRealm());
+    auto const stat = PacketReorderer::checkStat(packet, *refClient, true);
 
-    if (!packet->checkFlags(FGE_NET_HEADER_DO_NOT_DISCARD_FLAG))
+    bool const doNotDiscard = packet->checkFlags(FGE_NET_HEADER_DO_NOT_DISCARD_FLAG);
+    bool const doNotReorder = packet->checkFlags(FGE_NET_HEADER_DO_NOT_REORDER_FLAG);
+
+    if (!doNotDiscard)
     {
         if (stat == PacketReorderer::Stats::OLD_COUNTER)
         {
 #ifdef FGE_DEF_DEBUG
-            auto const packetCounter = packet->retrieveCounter().value();
             auto const packetRealm = packet->retrieveRealm().value();
-            auto const currentCounter = refClient->getClientPacketCounter();
+            auto const packetCounter = packet->retrieveCounter().value();
+            auto const packetReorderedCounter = packet->retrieveReorderedCounter().value();
+            auto const peerCounter = refClient->getPacketCounter(Client::Targets::PEER);
+            auto const peerReorderedCounter = refClient->getReorderedPacketCounter(Client::Targets::PEER);
 #endif
-            FGE_DEBUG_PRINT("Packet is old, discarding it packetCounter: {}, packetRealm: {}, currentCounter: {}",
-                            packetCounter, packetRealm, currentCounter);
+            FGE_DEBUG_PRINT("Packet is old, discarding it. Packet realm: {}, counter: {}, reorderedCounter: {}. Peer "
+                            "counter: {}, reorderedCounter: {}",
+                            packetRealm, packetCounter, packetReorderedCounter, peerCounter, peerReorderedCounter);
             refClient->advanceLostPacketCount();
             return FluxProcessResults::INTERNALLY_DISCARDED;
         }
     }
 
-    bool const doNotReorder = packet->checkFlags(FGE_NET_HEADER_DO_NOT_REORDER_FLAG);
-    if (!doNotReorder && !packet->isMarkedAsLocallyReordered())
+    if (!doNotReorder && !packet->isMarkedAsLocallyReordered() && stat != PacketReorderer::Stats::RETRIEVABLE)
     {
-        auto reorderResult =
-                this->processReorder(refClient->_context._reorderer, packet, refClient->getClientPacketCounter(),
-                                     refClient->getCurrentRealm(), true);
-        if (reorderResult != FluxProcessResults::USER_RETRIEVABLE)
-        {
-            return reorderResult;
-        }
+        refClient->_context._reorderer.push(std::move(packet));
+        refClient->_context._reorderer.process(*refClient, *this, true);
+        return FluxProcessResults::INTERNALLY_HANDLED;
     }
 
     //Verify the realm
@@ -536,19 +461,26 @@ FluxProcessResults ServerNetFluxUdp::process(ClientSharedPtr& refClient, Receive
     if (stat == PacketReorderer::Stats::WAITING_NEXT_REALM || stat == PacketReorderer::Stats::WAITING_NEXT_COUNTER)
     {
 #ifdef FGE_DEF_DEBUG
-        auto const packetCounter = packet->retrieveCounter().value();
         auto const packetRealm = packet->retrieveRealm().value();
-        auto const currentCounter = refClient->getClientPacketCounter();
+        auto const packetCounter = packet->retrieveCounter().value();
+        auto const packetReorderedCounter = packet->retrieveReorderedCounter().value();
+        auto const peerCounter = refClient->getPacketCounter(Client::Targets::PEER);
+        auto const peerReorderedCounter = refClient->getReorderedPacketCounter(Client::Targets::PEER);
 #endif
-        FGE_DEBUG_PRINT("We lose a packet packetCounter: {}, packetRealm: {}, currentCounter: {}", packetCounter,
-                        packetRealm, currentCounter);
+        FGE_DEBUG_PRINT("We lose a packet. Packet realm: {}, counter: {}, reorderedCounter: {}. Peer counter: {}, "
+                        "reorderedCounter: {}",
+                        packetRealm, packetCounter, packetReorderedCounter, peerCounter, peerReorderedCounter);
         refClient->advanceLostPacketCount(); //We are missing a packet
     }
 
-    if (!doNotReorder)
+    if (stat != PacketReorderer::Stats::OLD_REALM && stat != PacketReorderer::Stats::OLD_COUNTER)
     {
-        auto const countId = packet->retrieveCounter().value();
-        refClient->setClientPacketCounter(countId);
+        auto const peerRealm = packet->retrieveRealm().value();
+        refClient->setCurrentRealm(peerRealm);
+        auto const peerCounter = packet->retrieveCounter().value();
+        refClient->setPacketCounter(Client::Targets::PEER, peerCounter);
+        auto const peerReorderedCounter = packet->retrieveReorderedCounter().value();
+        refClient->setReorderedPacketCounter(Client::Targets::PEER, peerReorderedCounter);
     }
 
     //Check if the packet is a return packet, and if so, handle it
@@ -567,6 +499,8 @@ FluxProcessResults ServerNetFluxUdp::process(ClientSharedPtr& refClient, Receive
         return FluxProcessResults::INTERNALLY_HANDLED;
     }
 
+    refClient->_context._reorderer.process(*refClient, *this, true);
+
     return FluxProcessResults::USER_RETRIEVABLE;
 }
 
diff --git a/sources/private/fge_crypt.cpp b/sources/private/fge_crypt.cpp
index 38a47bf0..9a9fcaa1 100644
--- a/sources/private/fge_crypt.cpp
+++ b/sources/private/fge_crypt.cpp
@@ -20,6 +20,8 @@
 #include <openssl/err.h>
 #include <openssl/ssl.h>
 
+#include "private/fge_debug.hpp"
+
 namespace fge::priv
 {
 
@@ -322,9 +324,19 @@ void CryptClientDestroy(net::CryptInfo& client)
 
 bool CryptEncrypt(net::Client& client, net::Packet& packet)
 {
+    if (packet.getDataSize() > 16384)
+    {
+        //TODO: see C_socket.hpp, records can be up to 16384 bytes
+        FGE_DEBUG_PRINT("CryptEncrypt: packet size is bigger than a DTLS record (16384 bytes) !");
+        return false;
+    }
+
     auto& info = client.getCryptInfo();
 
-    SSL_write(static_cast<SSL*>(info._ssl), packet.getData(), packet.getDataSize());
+    if (SSL_write(static_cast<SSL*>(info._ssl), packet.getData(), packet.getDataSize()) <= 0)
+    {
+        return false;
+    }
 
     packet.clear();
     auto const pendingSize = BIO_ctrl_pending(static_cast<BIO*>(info._wbio));
@@ -333,20 +345,28 @@ bool CryptEncrypt(net::Client& client, net::Packet& packet)
         return false;
     }
     packet.append(pendingSize);
-    BIO_read(static_cast<BIO*>(info._wbio), packet.getData(), pendingSize);
+
+    if (BIO_read(static_cast<BIO*>(info._wbio), packet.getData(), pendingSize) < 0)
+    {
+        return false;
+    }
     return true;
 }
 bool CryptDecrypt(net::Client& client, net::Packet& packet)
 {
     auto& info = client.getCryptInfo();
 
-    BIO_write(static_cast<BIO*>(info._rbio), packet.getData(), packet.getDataSize());
+    if (BIO_write(static_cast<BIO*>(info._rbio), packet.getData(), packet.getDataSize()) <= 0)
+    {
+        return false;
+    }
 
     auto const result = SSL_read(static_cast<SSL*>(info._ssl), packet.getData(), packet.getDataSize());
     if (result <= 0)
     {
         return false;
     }
+
     packet.shrink(packet.getDataSize() - result);
     return true;
 }