diff --git a/JKMP.Plugin.Multiplayer/Game/Components/PlayerStateTransmitter.cs b/JKMP.Plugin.Multiplayer/Game/Components/PlayerStateTransmitter.cs
index fb7569c..27689a1 100644
--- a/JKMP.Plugin.Multiplayer/Game/Components/PlayerStateTransmitter.cs
+++ b/JKMP.Plugin.Multiplayer/Game/Components/PlayerStateTransmitter.cs
@@ -77,12 +77,7 @@ protected override void LateUpdate(float delta)
         private void SendState()
         {
             if (body == null || listener == null)
-                throw new InvalidOperationException("SendTranmission was called before component was initialized");
-
-            // Only send message if the connected players mutex isn't locked (prevents potential lag spikes)
-            // Note that there's still a chance it will be locked after this check and before the broadcast happens, but it should (hopefully) lower lag spikes significantly
-            if (p2p.ConnectedPlayersMtx.IsLocked)
-                return;
+                throw new InvalidOperationException("SendState was called before component was initialized");
 
             var surfaceType = listener.CurrentSurfaceType;
             bool wearingShoes = SkinManager.IsWearingSkin(Items.Shoes);
diff --git a/JKMP.Plugin.Multiplayer/Game/Entities/GameEntity.cs b/JKMP.Plugin.Multiplayer/Game/Entities/GameEntity.cs
index 4897a0a..7c566fc 100644
--- a/JKMP.Plugin.Multiplayer/Game/Entities/GameEntity.cs
+++ b/JKMP.Plugin.Multiplayer/Game/Entities/GameEntity.cs
@@ -28,6 +28,7 @@ public class GameEntity : BaseManagerEntity
         
         private LocalPlayerListener plrListener = null!;
         private Chat chatWidget = null!;
+        private StatusPanel statusPanel = null!;
 
         private float timeSincePositionUpdate;
         private const float PositionUpdateInterval = 30; // Send a position update every 30 seconds
@@ -43,6 +44,7 @@ protected override void OnFirstUpdate()
             chatWidget = UIManager.AddWidget(new Chat());
             localPlayer = EntityManager.instance.Find<PlayerEntity>();
             localPlayer.AddComponents(new PlayerStateTransmitter(P2P), new AudioListenerComponent());
+            statusPanel = UIManager.AddWidget(new StatusPanel());
             
             MatchmakingManager.Instance.Events.NearbyClientsReceived += OnNearbyClientsReceived;
         }
@@ -55,6 +57,7 @@ protected override void OnDestroy()
             plrListener.Dispose();
             P2P.Dispose();
             UIManager.RemoveWidget(chatWidget);
+            UIManager.RemoveWidget(statusPanel);
         }
 
         private void OnNearbyClientsReceived(ICollection<ulong> steamIds)
@@ -78,6 +81,7 @@ protected override void Update(float delta)
             P2P.Update(delta);
             Sound.Update(delta);
             chatWidget.Update(delta);
+            statusPanel.Update(delta);
         }
     }
 }
\ No newline at end of file
diff --git a/JKMP.Plugin.Multiplayer/Game/UI/Widgets/StatusPanel.cs b/JKMP.Plugin.Multiplayer/Game/UI/Widgets/StatusPanel.cs
new file mode 100644
index 0000000..b762c22
--- /dev/null
+++ b/JKMP.Plugin.Multiplayer/Game/UI/Widgets/StatusPanel.cs
@@ -0,0 +1,70 @@
+using JKMP.Plugin.Multiplayer.Matchmaking;
+using JKMP.Plugin.Multiplayer.Networking;
+using JumpKing.PauseMenu;
+using Matchmaking.Client.EventData;
+using Myra.Graphics2D.UI;
+
+namespace JKMP.Plugin.Multiplayer.Game.UI.Widgets
+{
+    public class StatusPanel : ResourceWidget<StatusPanel>
+    {
+        public string TotalPlayers
+        {
+            get => totalPlayers.Text;
+            set => totalPlayers.Text = value;
+        }
+
+        public string GroupPlayers
+        {
+            get => groupPlayers.Text;
+            set => groupPlayers.Text = value;
+        }
+
+        public bool Connected
+        {
+            get => connected;
+            set
+            {
+                if (value == connected)
+                    return;
+                
+                connected = value;
+                
+                connectedContainer.Visible = connected;
+                disconnectedContainer.Visible = !connected;
+            }
+        }
+
+        private readonly Label totalPlayers;
+        private readonly Label groupPlayers;
+        private readonly Widget connectedContainer;
+        private readonly Widget disconnectedContainer;
+        private bool connected;
+
+        public StatusPanel() : base("UI/Status/StatusPanel.xmmp")
+        {
+            totalPlayers = EnsureWidgetById<Label>("TotalPlayers");
+            groupPlayers = EnsureWidgetById<Label>("GroupPlayers");
+            connectedContainer = EnsureWidgetById<Widget>("ConnectedContainer");
+            disconnectedContainer = EnsureWidgetById<Widget>("DisconnectedContainer");
+
+            connectedContainer.Visible = false;
+            
+            AcceptsKeyboardFocus = false;
+
+            MatchmakingManager.Instance.Events.ServerStatusUpdateReceived += OnServerStatusReceived;
+        }
+
+        private void OnServerStatusReceived(ServerStatus status)
+        {
+            TotalPlayers = status.TotalPlayers.ToString();
+            GroupPlayers = status.GroupPlayers.ToString();
+        }
+
+        public void Update(float delta)
+        {
+            Visible = PauseManager.instance.IsPaused;
+            Connected = MatchmakingManager.Instance.IsConnected;
+        }
+    }
+}
\ No newline at end of file
diff --git a/JKMP.Plugin.Multiplayer/MultiplayerPlugin.cs b/JKMP.Plugin.Multiplayer/MultiplayerPlugin.cs
index ec6663e..2b4f0c1 100644
--- a/JKMP.Plugin.Multiplayer/MultiplayerPlugin.cs
+++ b/JKMP.Plugin.Multiplayer/MultiplayerPlugin.cs
@@ -113,6 +113,7 @@ public override void Initialize()
             GameEvents.GameUpdate += gameTime =>
             {
                 SteamClient.RunCallbacks();
+
                 InputManager.Update(gameTime);
             };
 
diff --git a/JKMP.Plugin.Multiplayer/Networking/Framed.cs b/JKMP.Plugin.Multiplayer/Networking/Framed.cs
index 3338b83..5262194 100644
--- a/JKMP.Plugin.Multiplayer/Networking/Framed.cs
+++ b/JKMP.Plugin.Multiplayer/Networking/Framed.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Threading;
@@ -16,7 +17,8 @@ namespace JKMP.Plugin.Multiplayer.Networking
     {
         private bool isRunning = true;
 
-        private readonly ReusableTCS<TData?> tcs = new();
+        private TaskCompletionSource<bool>? tcs = new();
+        private readonly Queue<TData> queuedMessages = new();
         private readonly TCodec codec;
         private readonly byte[] sendBuffer = new byte[4096];
         
@@ -54,8 +56,9 @@ private async Task StartPolling()
                             Logger.Error(ex, "An unhandled exception was raised when decoding message from {steamId}", packet.SteamId);
                             continue;
                         }
-
-                        await tcs.SetResult(message);
+                        
+                        queuedMessages.Enqueue(message);
+                        tcs?.TrySetResult(true);
                     }
 
                     await Task.Delay(33).ConfigureAwait(false); // poll around 30 times per second
@@ -73,9 +76,19 @@ private async Task StartPolling()
             if (!isRunning)
                 return default;
 
-            await tcs;
-            TData? result = tcs.GetResult();
-            tcs.Reset();
+            if (tcs != null)
+            {
+                await tcs.Task;
+                tcs = null;
+            }
+
+            TData result = queuedMessages.Dequeue();
+
+            if (queuedMessages.Count == 0)
+            {
+                tcs = new();
+            }
+            
             return result;
         }
 
diff --git a/JKMP.Plugin.Multiplayer/Networking/Messages/Handlers/DisconnectedMessageHandler.cs b/JKMP.Plugin.Multiplayer/Networking/Messages/Handlers/DisconnectedMessageHandler.cs
index c156bac..1b16c27 100644
--- a/JKMP.Plugin.Multiplayer/Networking/Messages/Handlers/DisconnectedMessageHandler.cs
+++ b/JKMP.Plugin.Multiplayer/Networking/Messages/Handlers/DisconnectedMessageHandler.cs
@@ -7,8 +7,10 @@ internal class DisconnectedMessageHandler : IMessageHandler<Disconnected, Contex
     {
         public Task HandleMessage(Disconnected message, Context context)
         {
-            context.P2PManager.Disconnect(message.Sender);
-            return Task.CompletedTask;
+            return context.P2PManager.ExecuteOnGameThread(() =>
+            {
+                context.P2PManager.Disconnect(message.Sender);
+            });
         }
     }
 }
\ No newline at end of file
diff --git a/JKMP.Plugin.Multiplayer/Networking/Messages/Handlers/HandshakeRequestHandler.cs b/JKMP.Plugin.Multiplayer/Networking/Messages/Handlers/HandshakeRequestHandler.cs
index a4c48b2..2a8cfdd 100644
--- a/JKMP.Plugin.Multiplayer/Networking/Messages/Handlers/HandshakeRequestHandler.cs
+++ b/JKMP.Plugin.Multiplayer/Networking/Messages/Handlers/HandshakeRequestHandler.cs
@@ -12,7 +12,7 @@ internal class HandshakeRequestHandler : IMessageHandler<HandshakeRequest, Conte
     {
         private static readonly ILogger Logger = LogManager.CreateLogger<HandshakeRequestHandler>();
         
-        public Task HandleMessage(HandshakeRequest message, Context context)
+        public async Task HandleMessage(HandshakeRequest message, Context context)
         {
             var authResult = SteamUser.BeginAuthSession(message.AuthSessionTicket, message.Sender);
 
@@ -26,25 +26,31 @@ public Task HandleMessage(HandshakeRequest message, Context context)
                     ErrorMessage = $"Steam auth result = {authResult}"
                 });
 
-                context.P2PManager.Disconnect(message.Sender);
-                return Task.CompletedTask;
+                await context.P2PManager.ExecuteOnGameThread(() =>
+                {
+                    context.P2PManager.Disconnect(message.Sender);
+                });
+                return;
             }
 
-            var plrListener = EntityManager.instance.Find<GameEntity>().PlayerListener;
-            var playerState = new PlayerStateChanged
-            {
-                Position = plrListener.Position,
-                State = plrListener.CurrentState,
-                WalkDirection = (sbyte)plrListener.WalkDirection
-            };
+            PlayerStateChanged? playerState = null;
 
+            await context.P2PManager.ExecuteOnGameThread(() =>
+            {
+                var plrListener = EntityManager.instance.Find<GameEntity>().PlayerListener;
+                playerState = new PlayerStateChanged
+                {
+                    Position = plrListener.Position,
+                    State = plrListener.CurrentState,
+                    WalkDirection = (sbyte)plrListener.WalkDirection
+                };
+            });
+            
             context.Messages.Send(message.Sender, new HandshakeResponse
             {
                 Success = true,
                 PlayerState = playerState
             });
-
-            return Task.CompletedTask;
         }
     }
 }
\ No newline at end of file
diff --git a/JKMP.Plugin.Multiplayer/Networking/Messages/Handlers/HandshakeResponseHandler.cs b/JKMP.Plugin.Multiplayer/Networking/Messages/Handlers/HandshakeResponseHandler.cs
index b0e766a..e419fa6 100644
--- a/JKMP.Plugin.Multiplayer/Networking/Messages/Handlers/HandshakeResponseHandler.cs
+++ b/JKMP.Plugin.Multiplayer/Networking/Messages/Handlers/HandshakeResponseHandler.cs
@@ -26,8 +26,12 @@ public async Task HandleMessage(HandshakeResponse message, Context context)
                     throw new NotImplementedException("User info is null, this shouldn't happen");
 
                 using var guard = await context.P2PManager.ConnectedPlayersMtx.LockAsync();
-                RemotePlayer player = guard.Value[message.Sender];
-                player.InitializeFromHandshakeResponse(message, userInfo.Value);
+
+                await context.P2PManager.ExecuteOnGameThread(() =>
+                {
+                    RemotePlayer player = guard.Value[message.Sender];
+                    player.InitializeFromHandshakeResponse(message, userInfo.Value);
+                });
             }
         }
     }
diff --git a/JKMP.Plugin.Multiplayer/Networking/Messages/Handlers/LocalChatMessageHandler.cs b/JKMP.Plugin.Multiplayer/Networking/Messages/Handlers/LocalChatMessageHandler.cs
index 4033383..8698136 100644
--- a/JKMP.Plugin.Multiplayer/Networking/Messages/Handlers/LocalChatMessageHandler.cs
+++ b/JKMP.Plugin.Multiplayer/Networking/Messages/Handlers/LocalChatMessageHandler.cs
@@ -41,7 +41,10 @@ public async Task HandleMessage(LocalChatMessage message, Context context)
             
             Logger.Information("[{channel}, {senderId}] {senderName}: {message}", ChatChannel.Local, message.Sender, senderName, trimmedMessage);
 
-            context.P2PManager.Events.OnIncomingChatMessage(new ChatMessage(ChatChannel.Local, message.Sender.Value, senderName, trimmedMessage));
+            await context.P2PManager.ExecuteOnGameThread(() =>
+            {
+                context.P2PManager.Events.OnIncomingChatMessage(new ChatMessage(ChatChannel.Local, message.Sender.Value, senderName, trimmedMessage));
+            });
         }
     }
 }
\ No newline at end of file
diff --git a/JKMP.Plugin.Multiplayer/Networking/Messages/Handlers/PlayerStateChangedHandler.cs b/JKMP.Plugin.Multiplayer/Networking/Messages/Handlers/PlayerStateChangedHandler.cs
index 5840896..4a0dc02 100644
--- a/JKMP.Plugin.Multiplayer/Networking/Messages/Handlers/PlayerStateChangedHandler.cs
+++ b/JKMP.Plugin.Multiplayer/Networking/Messages/Handlers/PlayerStateChangedHandler.cs
@@ -11,15 +11,18 @@ internal class PlayerStateChangedHandler : IMessageHandler<PlayerStateChanged, C
         
         public async Task HandleMessage(PlayerStateChanged message, Context context)
         {
-            using var guard = await context.P2PManager.ConnectedPlayersMtx.LockAsync();
+            await context.P2PManager.ExecuteOnGameThread(() =>
+            {
+                using var guard = context.P2PManager.ConnectedPlayersMtx.Lock();
 
-            if (!guard.Value.TryGetValue(message.Sender, out var player))
-                return;
+                if (!guard.Value.TryGetValue(message.Sender, out var player))
+                    return;
 
-            if (player.State != PlayerNetworkState.Connected)
-                return;
-                
-            player.UpdateFromState(message);
+                if (player.State != PlayerNetworkState.Connected)
+                    return;
+
+                player.UpdateFromState(message);
+            });
         }
     }
 }
\ No newline at end of file
diff --git a/JKMP.Plugin.Multiplayer/Networking/P2PManager.cs b/JKMP.Plugin.Multiplayer/Networking/P2PManager.cs
index cfcbb1f..63b049a 100644
--- a/JKMP.Plugin.Multiplayer/Networking/P2PManager.cs
+++ b/JKMP.Plugin.Multiplayer/Networking/P2PManager.cs
@@ -27,7 +27,7 @@ public class P2PManager : IDisposable
 
         private static readonly ILogger Logger = LogManager.CreateLogger<P2PManager>();
 
-        private readonly Queue<Action> pendingGameThreadActions = new();
+        private readonly Queue<(Action action, TaskCompletionSource<bool> tcs)> pendingGameThreadActions = new();
 
         private readonly HashSet<(DateTime, SteamId)> recentlyDisconnectedPeers = new();
 
@@ -177,7 +177,7 @@ private async Task ProcessMessages()
                     if (message is not PlayerStateChanged)
                         Logger.Verbose("Incoming message {message}", message.GetType().Name);
 
-                    processor.PushMessage(message, context);
+                    await processor.HandleMessage(message, context);
                 }
 
                 Logger.Verbose("Finished message processing");
@@ -190,19 +190,23 @@ private async Task ProcessMessages()
         }
 
         /// <summary>
-        /// Executes the action on the game thread on the next update.
+        /// Executes the action on the game thread on the next update and waits for it to be executed.
         /// </summary>
-        public void ExecuteOnGameThread(Action action)
+        public async Task ExecuteOnGameThread(Action action)
         {
             if (action == null) throw new ArgumentNullException(nameof(action));
-            pendingGameThreadActions.Enqueue(action);
+            var tcs = new TaskCompletionSource<bool>(false);
+            pendingGameThreadActions.Enqueue((action, tcs));
+            await tcs.Task;
         }
 
         public void Update(float delta)
         {
             while (pendingGameThreadActions.Count > 0)
             {
-                pendingGameThreadActions.Dequeue()();
+                (Action action, TaskCompletionSource<bool> tcs) = pendingGameThreadActions.Dequeue();
+                action();
+                tcs.SetResult(true);
             }
             
             if (recentlyDisconnectedPeers.Count > 0)
@@ -220,8 +224,6 @@ public void Update(float delta)
 
                 recentlyDisconnectedPeers.RemoveWhere(item => toRemove.Contains(item));
             }
-
-            processor.HandlePendingMessages().Wait();
         }
 
         internal void Broadcast(GameMessage message, P2PSend sendType = P2PSend.Reliable) => BroadcastAsync(message, sendType).Wait();
diff --git a/JKMP.Plugin.Multiplayer/Networking/ReusableTCS.cs b/JKMP.Plugin.Multiplayer/Networking/ReusableTCS.cs
deleted file mode 100644
index 93ca910..0000000
--- a/JKMP.Plugin.Multiplayer/Networking/ReusableTCS.cs
+++ /dev/null
@@ -1,52 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.CompilerServices;
-using System.Threading.Tasks;
-
-namespace JKMP.Plugin.Multiplayer.Networking
-{
-    /// <summary>
-    /// A reusable task completion source
-    /// </summary>
-    internal class ReusableTCS<T> : INotifyCompletion
-    {
-        private bool isCompleted;
-        private T? result;
-
-        public bool IsCompleted => isCompleted;
-
-        private Action? onCompleted;
-        
-        public void OnCompleted(Action continuation)
-        {
-            if (onCompleted != null)
-                throw new NotSupportedException("Multiple awaiters is not supported");
-            
-            onCompleted = continuation;
-        }
-
-        public void Reset()
-        {
-            isCompleted = false;
-            result = default;
-            onCompleted = null;
-        }
-
-        public async Task SetResult(T? result)
-        {
-            if (isCompleted)
-                throw new InvalidOperationException("Result is already set. Make sure to call Reset before calling SetResult again.");
-            
-            this.result = result;
-            isCompleted = true;
-
-            if (onCompleted != null)
-                await Task.Run(onCompleted).ConfigureAwait(false);
-        }
-
-        public ReusableTCS<T> GetAwaiter() => this;
-
-        public T? GetResult() => result;
-    }
-}
\ No newline at end of file
diff --git a/JKMP.Plugin.Multiplayer/Steam/SteamManager.cs b/JKMP.Plugin.Multiplayer/Steam/SteamManager.cs
index 20c261f..15d73da 100644
--- a/JKMP.Plugin.Multiplayer/Steam/SteamManager.cs
+++ b/JKMP.Plugin.Multiplayer/Steam/SteamManager.cs
@@ -15,7 +15,7 @@ public static bool InitializeSteam()
         {
             try
             {
-                SteamClient.Init(1061090, true);
+                SteamClient.Init(1061090, asyncCallbacks: false);
             }
             catch (Exception ex)
             {
diff --git a/JKMP.Plugin.Multiplayer/Threading/Mutex.cs b/JKMP.Plugin.Multiplayer/Threading/Mutex.cs
index 3b9b752..ca8321b 100644
--- a/JKMP.Plugin.Multiplayer/Threading/Mutex.cs
+++ b/JKMP.Plugin.Multiplayer/Threading/Mutex.cs
@@ -14,6 +14,8 @@ public class Mutex<T>
     {
         private T value;
         private readonly SemaphoreSlim semaphore;
+
+        private StackTrace? lastLockTrace;
         
         public Mutex(T value)
         {
@@ -25,13 +27,27 @@ public Mutex(T value)
 
         public async Task<MutexGuard<T>> LockAsync()
         {
+            if (semaphore.CurrentCount == 0)
+            {
+                LogManager.TempLogger.Verbose("last: {stackTrace}", lastLockTrace);
+                LogManager.TempLogger.Verbose("new: {stackTrace}", new StackTrace().ToString());
+            }
+            
             await semaphore.WaitAsync();
+            lastLockTrace = new();
             return new MutexGuard<T>(semaphore, value);
         }
 
         public MutexGuard<T> Lock()
         {
+            if (semaphore.CurrentCount == 0)
+            {
+                LogManager.TempLogger.Verbose("last: {stackTrace}", lastLockTrace);
+                LogManager.TempLogger.Verbose("new: {stackTrace}", new StackTrace().ToString());
+            }
+            
             semaphore.Wait();
+            lastLockTrace = new();
             return new MutexGuard<T>(semaphore, value);
         }
 
diff --git a/Matchmaking.Client/EventData/ServerStatus.cs b/Matchmaking.Client/EventData/ServerStatus.cs
new file mode 100644
index 0000000..5d58eb5
--- /dev/null
+++ b/Matchmaking.Client/EventData/ServerStatus.cs
@@ -0,0 +1,14 @@
+namespace Matchmaking.Client.EventData
+{
+    public class ServerStatus
+    {
+        public uint TotalPlayers { get; set; }
+        public uint GroupPlayers { get; set; }
+
+        public ServerStatus(uint totalPlayers, uint groupPlayers)
+        {
+            TotalPlayers = totalPlayers;
+            GroupPlayers = groupPlayers;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Matchmaking.Client/Events.cs b/Matchmaking.Client/Events.cs
index ee64bf2..2312588 100644
--- a/Matchmaking.Client/Events.cs
+++ b/Matchmaking.Client/Events.cs
@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using Matchmaking.Client.Chat;
+using Matchmaking.Client.EventData;
 using Matchmaking.Client.Messages;
 
 namespace Matchmaking.Client
@@ -25,5 +26,14 @@ internal void OnChatMessageReceived(ChatMessage message)
         {
             ChatMessageReceived?.Invoke(message);
         }
+
+        public delegate void ServerStatusUpdateReceivedHandler(ServerStatus status);
+
+        public event ServerStatusUpdateReceivedHandler? ServerStatusUpdateReceived;
+        
+        internal void OnServerStatusUpdateReceived(ServerStatus status)
+        {
+            ServerStatusUpdateReceived?.Invoke(status);
+        }
     }
 }
\ No newline at end of file
diff --git a/Matchmaking.Client/MatchmakingClient.cs b/Matchmaking.Client/MatchmakingClient.cs
index c273409..2a3a02f 100644
--- a/Matchmaking.Client/MatchmakingClient.cs
+++ b/Matchmaking.Client/MatchmakingClient.cs
@@ -18,7 +18,7 @@ namespace Matchmaking.Client
 {
     public class MatchmakingClient
     {
-        public const uint Version = 1;
+        public const uint Version = 2;
         
         public string? Password { get; private set; }
         
diff --git a/Matchmaking.Client/Messages/Handlers/MatchmakingMessageProcessor.cs b/Matchmaking.Client/Messages/Handlers/MatchmakingMessageProcessor.cs
index 0eafb17..016c12b 100644
--- a/Matchmaking.Client/Messages/Handlers/MatchmakingMessageProcessor.cs
+++ b/Matchmaking.Client/Messages/Handlers/MatchmakingMessageProcessor.cs
@@ -8,6 +8,7 @@ public MatchmakingMessageProcessor()
         {
             RegisterHandler(new InformNearbyClientsHandler());
             RegisterHandler(new OutgoingChatMessageHandler());
+            RegisterHandler(new ServerStatusUpdateHandler());
         }
     }
 }
\ No newline at end of file
diff --git a/Matchmaking.Client/Messages/Handlers/ServerStatusUpdateHandler.cs b/Matchmaking.Client/Messages/Handlers/ServerStatusUpdateHandler.cs
new file mode 100644
index 0000000..787723e
--- /dev/null
+++ b/Matchmaking.Client/Messages/Handlers/ServerStatusUpdateHandler.cs
@@ -0,0 +1,20 @@
+using System.Threading.Tasks;
+using Matchmaking.Client.EventData;
+using Matchmaking.Client.Messages.Processing;
+using Serilog;
+
+namespace Matchmaking.Client.Messages.Handlers
+{
+    internal class ServerStatusUpdateHandler : IMessageHandler<ServerStatusUpdate, Context>
+    {
+        private static readonly ILogger Logger = Log.ForContext<ServerStatusUpdateHandler>();
+        
+        public Task HandleMessage(ServerStatusUpdate message, Context context)
+        {
+            Logger.Information("Received server status. Total players: {totalPlayers}, group players: {groupPlayers}", message.TotalPlayers, message.GroupPlayers);
+            context.MatchmakingClient.Events.OnServerStatusUpdateReceived(new ServerStatus(message.TotalPlayers, message.GroupPlayers));
+            
+            return Task.CompletedTask;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Matchmaking.Client/Messages/ServerStatusUpdate.cs b/Matchmaking.Client/Messages/ServerStatusUpdate.cs
new file mode 100644
index 0000000..ea531cd
--- /dev/null
+++ b/Matchmaking.Client/Messages/ServerStatusUpdate.cs
@@ -0,0 +1,22 @@
+using System;
+using System.IO;
+
+namespace Matchmaking.Client.Messages
+{
+    internal class ServerStatusUpdate : Message
+    {
+        public uint TotalPlayers { get; set; }
+        public uint GroupPlayers { get; set; }
+        
+        public override void Serialize(BinaryWriter writer)
+        {
+            throw new NotSupportedException();
+        }
+
+        public override void Deserialize(BinaryReader reader)
+        {
+            TotalPlayers = (uint)reader.ReadVarInt();
+            GroupPlayers = (uint)reader.ReadVarInt();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Matchmaking.Client/Networking/MessageType.cs b/Matchmaking.Client/Networking/MessageType.cs
index 543a5e6..4c7223b 100644
--- a/Matchmaking.Client/Networking/MessageType.cs
+++ b/Matchmaking.Client/Networking/MessageType.cs
@@ -10,6 +10,7 @@ internal enum MessageType
         /// <summary>Incoming chat message from a client (to server)</summary>
         IncomingChatMessage,
         /// <summary>Outgoing chat message from server (to client)</summary>
-        OutgoingChatMessage
+        OutgoingChatMessage,
+        ServerStatusUpdate,
     }
 }
\ No newline at end of file
diff --git a/Matchmaking.Client/Networking/MessagesCodec.cs b/Matchmaking.Client/Networking/MessagesCodec.cs
index bb233bd..f848cbf 100644
--- a/Matchmaking.Client/Networking/MessagesCodec.cs
+++ b/Matchmaking.Client/Networking/MessagesCodec.cs
@@ -18,7 +18,8 @@ internal class MessagesCodec : CodecSink<Message>
             { MessageType.SetMatchmakingPassword, typeof(SetMatchmakingPassword) },
             { MessageType.InformNearbyClients, typeof(InformNearbyClients) },
             { MessageType.IncomingChatMessage, typeof(IncomingChatMessage) },
-            { MessageType.OutgoingChatMessage, typeof(OutgoingChatMessage) }
+            { MessageType.OutgoingChatMessage, typeof(OutgoingChatMessage) },
+            { MessageType.ServerStatusUpdate, typeof(ServerStatusUpdate) }
         };
 
         private static readonly Dictionary<Type, MessageType> MessageTypesReversed = MessageTypes.ToDictionary(kv => kv.Value, kv => kv.Key);
diff --git a/Resources/UI/Status/StatusPanel.xmmp b/Resources/UI/Status/StatusPanel.xmmp
new file mode 100644
index 0000000..211ec68
--- /dev/null
+++ b/Resources/UI/Status/StatusPanel.xmmp
@@ -0,0 +1,15 @@
+<Panel Padding="20" Margin="10, 10, 0, 0" HorizontalAlignment="Left" VerticalAlignment="Top" Background="#00000096">
+    <VerticalStackPanel Id="ConnectedContainer">
+        <HorizontalStackPanel>
+            <Label Text="Players online: " Font="Fonts/OpenSans-Bold.ttf:22" />
+            <Label Id="TotalPlayers" Text="..." Font="Fonts/OpenSans-Bold.ttf:22" />
+        </HorizontalStackPanel>
+        <HorizontalStackPanel>
+            <Label Text="Players in your group: " Font="Fonts/OpenSans-Bold.ttf:22" />
+            <Label Id="GroupPlayers" Text="..." Font="Fonts/OpenSans-Bold.ttf:22" />
+        </HorizontalStackPanel>
+    </VerticalStackPanel>
+    <VerticalStackPanel Id="DisconnectedContainer">
+        <Label Text="Reconnecting..." Font="Fonts/OpenSans-Bold.ttf:22" />
+    </VerticalStackPanel>
+</Panel>
\ No newline at end of file