diff --git a/Cargo.lock b/Cargo.lock
index f96abb4..ad9f568 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4368,6 +4368,7 @@ dependencies = [
  "bevy",
  "bevy_disturbulence",
  "bevy_rapier2d",
+ "iyes_loopless",
  "jwt-compact",
  "k8s-openapi",
  "kube",
@@ -4398,6 +4399,7 @@ dependencies = [
  "chrono",
  "crossbeam-channel",
  "futures-lite",
+ "iyes_loopless",
  "konst",
  "names",
  "num",
diff --git a/libs/client_lib/src/lib.rs b/libs/client_lib/src/lib.rs
index 59dd327..1048703 100644
--- a/libs/client_lib/src/lib.rs
+++ b/libs/client_lib/src/lib.rs
@@ -31,7 +31,7 @@ use bevy::{
     diagnostic::FrameTimeDiagnosticsPlugin,
     ecs::{
         entity::Entity,
-        schedule::{IntoSystemDescriptor, ShouldRun, State, StateError, SystemStage},
+        schedule::{IntoSystemDescriptor, ShouldRun, SystemStage},
         system::{Commands, IntoSystem, Local, Res, ResMut, Resource, SystemParam},
     },
     hierarchy::BuildChildren,
@@ -52,8 +52,8 @@ use mr_shared_lib::{
     game::client_factories::VisibilitySettings,
     messages::{EntityNetId, PlayerNetId},
     net::{ConnectionState, ConnectionStatus, MessageId},
-    GameState, GameTime, MuddleSharedPlugin, SimulationTime, COMPONENT_FRAMEBUFFER_LIMIT,
-    SIMULATIONS_PER_SECOND, TICKS_PER_NETWORK_BROADCAST,
+    AppState, GameSessionState, GameTime, MuddleSharedPlugin, SimulationTime,
+    COMPONENT_FRAMEBUFFER_LIMIT, SIMULATIONS_PER_SECOND, TICKS_PER_NETWORK_BROADCAST,
 };
 use std::{marker::PhantomData, net::SocketAddr};
 use url::Url;
@@ -77,9 +77,9 @@ pub struct MuddleClientPlugin;
 impl Plugin for MuddleClientPlugin {
     fn build(&self, app: &mut App) {
         let input_stage = SystemStage::single_threaded()
-            // Processing network events should happen before tracking input
-            // because we reset current's player inputs on each delta update.
             .with_system(maintain_connection_system)
+            // Processing network events should happen before tracking input:
+            // we rely on resetting current's player inputs on each delta update message (event).
             .with_system(process_network_events_system.after(maintain_connection_system))
             .with_system(input::track_input_events_system.after(process_network_events_system))
             .with_system(input::cast_mouse_ray_system.after(input::track_input_events_system));
@@ -144,28 +144,30 @@ impl Plugin for MuddleClientPlugin {
             .add_system(process_control_points_input_system.after("builder_system_set"))
             .add_system(spawn_control_points_system.after("builder_system_set"));
 
-        let world = &mut app.world;
-        world
+        // There's also `GameSessionState`, which is added by `MuddleSharedPlugin`.
+        app.add_state(AppState::Loading);
+
+        app.world
             .get_resource_mut::<WorldInspectorParams>()
             .unwrap()
             .enabled = false;
-        world.get_resource_or_insert_with(InitialRtt::default);
-        world.get_resource_or_insert_with(EstimatedServerTime::default);
-        world.get_resource_or_insert_with(GameTicksPerSecond::default);
-        world.get_resource_or_insert_with(TargetFramesAhead::default);
-        world.get_resource_or_insert_with(DelayServerTime::default);
-        world.get_resource_or_insert_with(ui::debug_ui::DebugUiState::default);
-        world.get_resource_or_insert_with(CurrentPlayerNetId::default);
-        world.get_resource_or_insert_with(ConnectionState::default);
-        world.get_resource_or_insert_with(PlayerRequestsQueue::default);
-        world.get_resource_or_insert_with(EditedLevelObject::default);
-        world.get_resource_or_insert_with(LevelObjectRequestsQueue::default);
-        world.get_resource_or_insert_with(LevelObjectCorrelations::default);
-        world.get_resource_or_insert_with(MouseRay::default);
-        world.get_resource_or_insert_with(MouseWorldPosition::default);
-        world.get_resource_or_insert_with(VisibilitySettings::default);
-        world.get_resource_or_insert_with(ServerToConnect::default);
-        world.get_resource_or_insert_with(OfflineAuthConfig::default);
+        app.init_resource::<InitialRtt>();
+        app.init_resource::<EstimatedServerTime>();
+        app.init_resource::<GameTicksPerSecond>();
+        app.init_resource::<TargetFramesAhead>();
+        app.init_resource::<DelayServerTime>();
+        app.init_resource::<ui::debug_ui::DebugUiState>();
+        app.init_resource::<CurrentPlayerNetId>();
+        app.init_resource::<ConnectionState>();
+        app.init_resource::<PlayerRequestsQueue>();
+        app.init_resource::<EditedLevelObject>();
+        app.init_resource::<LevelObjectRequestsQueue>();
+        app.init_resource::<LevelObjectCorrelations>();
+        app.init_resource::<MouseRay>();
+        app.init_resource::<MouseWorldPosition>();
+        app.init_resource::<VisibilitySettings>();
+        app.init_resource::<ServerToConnect>();
+        app.init_resource::<OfflineAuthConfig>();
     }
 }
 
@@ -297,7 +299,8 @@ pub struct MainCameraPivotEntity(pub Entity);
 pub struct MainCameraEntity(pub Entity);
 
 fn pause_simulation_system(
-    mut game_state: ResMut<State<GameState>>,
+    mut commands: Commands,
+    game_state: Res<CurrentState<GameSessionState>>,
     connection_state: Res<ConnectionState>,
     game_time: Res<GameTime>,
     estimated_server_time: Res<EstimatedServerTime>,
@@ -312,37 +315,24 @@ fn pause_simulation_system(
         .saturating_sub(estimated_server_time.frame_number.value())
         < COMPONENT_FRAMEBUFFER_LIMIT / 2;
 
-    // We always assume that `GameState::Playing` is the initial state and
-    // `GameState::Paused` is pushed to the top of the stack.
-    if let GameState::Paused = game_state.current() {
+    if let GameSessionState::Paused = game_state.0 {
         if is_connected && has_server_updates {
-            let result = game_state.pop();
-            match result {
-                Ok(()) => {
-                    log::info!("Unpausing the game");
-                }
-                Err(StateError::StateAlreadyQueued) => {
-                    // TODO: investigate why this runs more than once before
-                    // changing the state sometimes.
-                }
-                Err(StateError::StackEmpty | StateError::AlreadyInState) => unreachable!(),
-            }
+            log::info!(
+                "Changing the game session state to {:?}",
+                GameSessionState::Playing
+            );
+            commands.insert_resource(NextState(GameSessionState::Playing));
             return;
         }
     }
 
-    if !is_connected || !has_server_updates {
-        let result = game_state.push(GameState::Paused);
-        match result {
-            Ok(()) => {
-                log::info!("Pausing the game");
-            }
-            Err(StateError::AlreadyInState) | Err(StateError::StateAlreadyQueued) => {
-                // It's ok. Bevy won't let us push duplicate values - that's
-                // what we rely on.
-            }
-            Err(StateError::StackEmpty) => unreachable!(),
-        }
+    // We can pause the game only when we are actually playing (not loading).
+    if matches!(game_state.0, GameSessionState::Playing) && (!is_connected || !has_server_updates) {
+        log::info!(
+            "Changing the game session state to {:?}",
+            GameSessionState::Paused
+        );
+        commands.insert_resource(NextState(GameSessionState::Paused));
     }
 }
 
@@ -498,7 +488,7 @@ fn net_adaptive_run_criteria(
     mut state: Local<NetAdaptiveRunCriteriaState>,
     time: Res<Time>,
     game_ticks_per_second: Res<GameTicksPerSecond>,
-    game_state: Res<State<GameState>>,
+    game_state: Res<CurrentState<GameSessionState>>,
 ) -> ShouldRun {
     #[cfg(feature = "profiler")]
     puffin::profile_function!();
@@ -515,7 +505,7 @@ fn net_adaptive_run_criteria(
 
     // In the scenario when a client was frozen (minimized, for example) and it got
     // disconnected, we don't want to replay all the accumulated frames.
-    if game_state.current() != &GameState::Playing {
+    if game_state.0 != GameSessionState::Playing {
         state.accumulator = state.accumulator.min(1.0);
     }
 
diff --git a/libs/client_lib/src/net/mod.rs b/libs/client_lib/src/net/mod.rs
index 6162913..5365ca5 100644
--- a/libs/client_lib/src/net/mod.rs
+++ b/libs/client_lib/src/net/mod.rs
@@ -14,13 +14,14 @@ use auth::{AuthMessage, AuthRequest};
 use bevy::{ecs::system::SystemParam, log, prelude::*, utils::Instant};
 use bevy_disturbulence::{NetworkEvent, NetworkResource};
 use futures::{select, FutureExt};
+use iyes_loopless::state::NextState;
 use mr_messages_lib::{MatchmakerMessage, MatchmakerRequest, Server};
 use mr_shared_lib::{
     framebuffer::{FrameNumber, Framebuffer},
     game::{
         commands::{
-            DeferredQueue, DespawnLevelObject, DespawnPlayer, DespawnReason, RestartGame,
-            SpawnPlayer, SwitchPlayerRole, UpdateLevelObject,
+            DeferredQueue, DespawnLevelObject, DespawnPlayer, DespawnReason, SpawnPlayer,
+            SwitchPlayerRole, UpdateLevelObject,
         },
         components::{PlayerDirection, Spawned},
     },
@@ -35,7 +36,8 @@ use mr_shared_lib::{
     },
     player::{Player, PlayerDirectionUpdate, PlayerRole, PlayerUpdates, Players},
     registry::EntityRegistry,
-    GameTime, SimulationTime, COMPONENT_FRAMEBUFFER_LIMIT, SIMULATIONS_PER_SECOND,
+    AppState, GameSessionState, GameTime, LevelObjectsToSpawnToLoad, SimulationTime,
+    COMPONENT_FRAMEBUFFER_LIMIT, SIMULATIONS_PER_SECOND,
 };
 use std::{
     future::Future,
@@ -69,7 +71,6 @@ pub struct UpdateParams<'w, 's> {
     delay_server_time: ResMut<'w, DelayServerTime>,
     initial_rtt: ResMut<'w, InitialRtt>,
     player_updates: ResMut<'w, PlayerUpdates>,
-    restart_game_commands: ResMut<'w, DeferredQueue<RestartGame>>,
     level_object_correlations: ResMut<'w, LevelObjectCorrelations>,
     spawn_level_object_commands: ResMut<'w, DeferredQueue<UpdateLevelObject>>,
     despawn_level_object_commands: ResMut<'w, DeferredQueue<DespawnLevelObject>>,
@@ -281,12 +282,13 @@ where
 pub struct MatchmakerParams<'w, 's> {
     matchmaker_state: Option<ResMut<'w, MatchmakerState>>,
     server_to_connect: ResMut<'w, ServerToConnect>,
-    main_menu_ui_channels: Option<Res<'w, MainMenuUiChannels>>,
+    main_menu_ui_channels: Option<ResMut<'w, MainMenuUiChannels>>,
     #[system_param(ignore)]
     marker: PhantomData<&'s ()>,
 }
 
 pub fn process_network_events_system(
+    mut commands: Commands,
     mut network_params: NetworkParams,
     mut network_events: EventReader<NetworkEvent>,
     mut current_player_net_id: ResMut<CurrentPlayerNetId>,
@@ -399,14 +401,26 @@ pub fn process_network_events_system(
                         },
                     ));
 
-                    // This seems to be the most reliable place to do this. `StartGame` might come
-                    // after the first `DeltaUpdate`, so it's not super reliable to restart a game
-                    // there. `Handshake`, on the contrary, always comes before both `DeltaUpdate`
-                    // and `StartGame`. Restarting on disconnect might work just fine too, but I
+                    current_player_net_id.0 = None;
+                    // This seems to be the most reliable place to switch the sate. `StartGame`
+                    // might come after the first `DeltaUpdate`, so it's not
+                    // super reliable to reset the game world there (which is implied by entering
+                    // the `GameSessionState::Loading` state. `Handshake`, on
+                    // the contrary, always comes before both `DeltaUpdate`
+                    // and `StartGame`. Resetting on disconnect might work just fine too, but I
                     // thought that `Handshake` probably comes with less edge-cases, since we
                     // always get it before starting the game.
-                    current_player_net_id.0 = None;
-                    update_params.restart_game_commands.push(RestartGame);
+                    log::info!("Changing the app state to {:?}", AppState::Playing);
+                    commands.insert_resource(NextState(AppState::Playing));
+                    // On game start, `GameSessionState::Loading` is likely current state as
+                    // well, we rely on `iyes_loopless` behaviour to run the
+                    // enter stage regardless of whether current state
+                    // equals next one.
+                    log::info!(
+                        "Changing the game session state to {:?}",
+                        GameSessionState::Loading
+                    );
+                    commands.insert_resource(NextState(GameSessionState::Loading));
                 }
                 UnreliableServerMessage::DeltaUpdate(update) => {
                     let mut skip_update = false;
@@ -548,6 +562,10 @@ pub fn process_network_events_system(
                         .connection_state
                         .set_status(ConnectionStatus::Connecting);
                 }
+                ReliableServerMessage::Loading => {
+                    // TODO: reflect this message in the UI.
+                    log::info!("The server is loading...");
+                }
                 ReliableServerMessage::StartGame(start_game) => {
                     let expected_handshake_id =
                         network_params.connection_state.handshake_id - MessageId::new(1);
@@ -569,6 +587,7 @@ pub fn process_network_events_system(
                         start_game.game_state.frame_number
                     );
                     process_start_game_message(
+                        &mut commands,
                         start_game,
                         &mut network_params.connection_state,
                         &mut current_player_net_id,
@@ -701,9 +720,7 @@ pub fn process_network_events_system(
 pub fn maintain_connection_system(
     time: Res<GameTime>,
     client_config: Res<MuddleClientConfig>,
-    matchmaker_state: Option<ResMut<MatchmakerState>>,
-    matchmaker_channels: Option<ResMut<MainMenuUiChannels>>,
-    mut server_to_connect: ResMut<ServerToConnect>,
+    mut matchmaker_params: MatchmakerParams,
     mut network_params: NetworkParams,
     mut initial_rtt: ResMut<InitialRtt>,
 ) {
@@ -713,10 +730,10 @@ pub fn maintain_connection_system(
     if matches!(
         network_params.connection_state.status(),
         ConnectionStatus::Connected
-    ) && server_to_connect.is_some()
+    ) && matchmaker_params.server_to_connect.is_some()
     {
-        **server_to_connect = None;
-        if let Some(matchmaker_channels) = matchmaker_channels.as_ref() {
+        **matchmaker_params.server_to_connect = None;
+        if let Some(matchmaker_channels) = matchmaker_params.main_menu_ui_channels.as_ref() {
             matchmaker_channels
                 .connection_request_tx
                 .send(false)
@@ -724,7 +741,9 @@ pub fn maintain_connection_system(
         }
     }
 
-    let mut matchmaker = matchmaker_state.zip(matchmaker_channels);
+    let mut matchmaker = matchmaker_params
+        .matchmaker_state
+        .zip(matchmaker_params.main_menu_ui_channels);
     if let Some((matchmaker_state, matchmaker_channels)) = matchmaker.as_mut() {
         loop {
             match matchmaker_channels.status_rx.try_recv() {
@@ -746,15 +765,15 @@ pub fn maintain_connection_system(
     );
 
     // TODO: if a client isn't getting any updates, we may also want to pause the
-    // game and wait for  some time for a server to respond.
+    // game and wait for some time for a server to respond.
 
-    let connection_timeout = Instant::now().duration_since(
+    let connection_has_timed_out = Instant::now().duration_since(
         network_params
             .connection_state
             .last_valid_message_received_at,
     ) > Duration::from_millis(CONNECTION_TIMEOUT_MILLIS);
 
-    if connection_timeout && !connection_is_uninitialized {
+    if connection_has_timed_out && !connection_is_uninitialized {
         log::warn!("Connection timeout, resetting");
     }
 
@@ -779,7 +798,7 @@ pub fn maintain_connection_system(
         );
     }
 
-    if !connection_is_uninitialized && connection_timeout
+    if !connection_is_uninitialized && connection_has_timed_out
         || is_falling_behind
         || matches!(
             network_params.connection_state.status(),
@@ -793,6 +812,9 @@ pub fn maintain_connection_system(
             .set_status(ConnectionStatus::Uninitialized);
     }
 
+    // TODO! so I left off after just finishing with the loading states, need to
+    //  sort out the menu app state and running conditions
+
     if network_params.net.connections.is_empty() {
         let addr = if let Some((matchmaker_state, matchmaker_channels)) = matchmaker.as_mut() {
             if matches!(matchmaker_state.status, TcpConnectionStatus::Disconnected) {
@@ -804,7 +826,7 @@ pub fn maintain_connection_system(
                 return;
             }
 
-            let Some(server) = &**server_to_connect else {
+            let Some(server) = &**matchmaker_params.server_to_connect else {
                 return;
             };
             log::info!("Connecting to {}: {}", server.name, server.addr);
@@ -1250,6 +1272,7 @@ fn sync_clock(
 }
 
 fn process_start_game_message(
+    commands: &mut Commands,
     start_game: StartGame,
     connection_state: &mut ConnectionState,
     current_player_net_id: &mut CurrentPlayerNetId,
@@ -1349,6 +1372,7 @@ fn process_start_game_message(
             );
         }
     }
+    commands.insert_resource(LevelObjectsToSpawnToLoad(start_game.objects.len()));
     for spawn_level_object in start_game.objects {
         update_params
             .spawn_level_object_commands
diff --git a/libs/client_lib/src/ui/debug_ui.rs b/libs/client_lib/src/ui/debug_ui.rs
index 4e4a184..0f06da5 100644
--- a/libs/client_lib/src/ui/debug_ui.rs
+++ b/libs/client_lib/src/ui/debug_ui.rs
@@ -8,6 +8,7 @@ use bevy::{
     prelude::*,
 };
 use bevy_egui::{egui, egui::epaint::RectShape, EguiContext};
+use iyes_loopless::state::CurrentState;
 use mr_shared_lib::{
     client::components::DebugUiVisibility,
     framebuffer::FrameNumber,
@@ -23,13 +24,13 @@ use mr_shared_lib::{
     net::ConnectionState,
     player::Players,
     registry::EntityRegistry,
-    GameState, SimulationTime,
+    GameSessionState, SimulationTime,
 };
 use std::{collections::VecDeque, marker::PhantomData};
 
 #[derive(SystemParam)]
 pub struct DebugData<'w, 's> {
-    game_state: Res<'w, State<GameState>>,
+    game_state: Res<'w, CurrentState<GameSessionState>>,
     time: Res<'w, SimulationTime>,
     current_ticks_per_second: Res<'w, GameTicksPerSecond>,
     delay_server_time: Res<'w, DelayServerTime>,
@@ -47,7 +48,7 @@ pub struct DebugUiState {
     pub fps_history_len: usize,
     pub pause: bool,
 
-    pub game_state: GameState,
+    pub game_state: GameSessionState,
     pub actual_frames_ahead: u16,
     pub target_frames_ahead: u16,
     pub current_ticks_per_second: f32,
@@ -87,7 +88,7 @@ pub fn update_debug_ui_state_system(
     if debug_ui_state.pause {
         return;
     }
-    debug_ui_state.game_state = debug_data.game_state.current().clone();
+    debug_ui_state.game_state = debug_data.game_state.0.clone();
     debug_ui_state.actual_frames_ahead = debug_data.time.player_frames_ahead();
     debug_ui_state.target_frames_ahead = debug_data.target_frames_ahead.target;
     debug_ui_state.current_ticks_per_second = debug_data.current_ticks_per_second.value;
diff --git a/libs/server_lib/Cargo.toml b/libs/server_lib/Cargo.toml
index 07ccdad..682c0c9 100644
--- a/libs/server_lib/Cargo.toml
+++ b/libs/server_lib/Cargo.toml
@@ -15,6 +15,7 @@ anyhow = "1.0"
 bevy = { version = "0.9.1", default-features = false }
 bevy_disturbulence = { git = "https://github.com/mvlabat/bevy_disturbulence.git", branch = "wip", features = ["server"] }
 bevy_rapier2d = "0.19"
+iyes_loopless = "0.9"
 jwt-compact = { version = "0.6", features = ["std", "clock", "with_rsa"], default-features = false }
 kube = "0.77.0"
 local-ip-address = "0.5"
diff --git a/libs/server_lib/src/lib.rs b/libs/server_lib/src/lib.rs
index b8ecedc..6ae3ebd 100644
--- a/libs/server_lib/src/lib.rs
+++ b/libs/server_lib/src/lib.rs
@@ -7,8 +7,9 @@ pub use mr_shared_lib::{game::PlayerEventSender, player::PlayerEvent};
 use crate::{
     game_events::{process_player_events_system, process_scheduled_spawns_system},
     net::{
-        process_network_events_system, send_network_updates_system, startup, ConnectionStates,
-        FetchedLevelInfo, NewPlayerConnections, PlayerConnections,
+        broadcast_disconnected_players_system, process_network_events_system,
+        send_network_updates_system, startup, ConnectionStates, FetchedLevelInfo,
+        NewPlayerConnections, PlayerConnections,
     },
     persistence::{
         create_level, get_user, handle_persistence_requests, init_jwks_polling, load_level,
@@ -26,6 +27,7 @@ use bevy::{
     prelude::*,
     time::{FixedTimestep, TimePlugin},
 };
+use iyes_loopless::prelude::*;
 use kube::Client;
 use mr_messages_lib::{InitLevel, LevelData};
 use mr_shared_lib::{
@@ -41,7 +43,8 @@ use mr_shared_lib::{
     },
     player::{PlayerRole, Players},
     registry::IncrementId,
-    MuddleSharedPlugin, SIMULATIONS_PER_SECOND,
+    AppState, GameSessionState, LevelObjectsToSpawnToLoad, MuddleSharedPlugin,
+    SIMULATIONS_PER_SECOND,
 };
 use mr_utils_lib::kube_discovery;
 use reqwest::Url;
@@ -175,8 +178,9 @@ impl Plugin for MuddleServerPlugin {
         let post_game_stage = SystemStage::single_threaded()
             .with_system(process_player_events_system)
             .with_system(save_level_system);
-        let broadcast_updates_stage =
-            SystemStage::single_threaded().with_system(send_network_updates_system);
+        let broadcast_updates_stage = SystemStage::single_threaded()
+            .with_system(broadcast_disconnected_players_system)
+            .with_system(send_network_updates_system.run_in_state(GameSessionState::Playing));
 
         // Game.
         app.add_plugin(MuddleSharedPlugin::new(
@@ -188,40 +192,39 @@ impl Plugin for MuddleServerPlugin {
             None,
         ));
 
-        let world = &mut app.world;
-        world.get_resource_or_insert_with(EntityNetIdCounter::default);
-        world.get_resource_or_insert_with(PlayerNetIdCounter::default);
-        world.get_resource_or_insert_with(PlayerConnections::default);
-        world.get_resource_or_insert_with(NewPlayerConnections::default);
-        world.get_resource_or_insert_with(ConnectionStates::default);
-        world.get_resource_or_insert_with(DeferredPlayerQueues::<RunnerInput>::default);
-        world.get_resource_or_insert_with(DeferredPlayerQueues::<PlayerRole>::default);
-        world.get_resource_or_insert_with(
-            DeferredPlayerQueues::<messages::SpawnLevelObjectRequestBody>::default,
-        );
-        world.get_resource_or_insert_with(DeferredPlayerQueues::<SpawnLevelObjectRequest>::default);
-        world.get_resource_or_insert_with(DeferredPlayerQueues::<LevelObject>::default);
-        world.get_resource_or_insert_with(DeferredPlayerQueues::<EntityNetId>::default);
-        world.get_resource_or_insert_with(DeferredMessagesQueue::<RespawnPlayer>::default);
-        world.get_resource_or_insert_with(DeferredMessagesQueue::<SpawnLevelObject>::default);
-        world.get_resource_or_insert_with(DeferredMessagesQueue::<UpdateLevelObject>::default);
-        world.get_resource_or_insert_with(DeferredMessagesQueue::<DespawnLevelObject>::default);
-        world.get_resource_or_insert_with(|| LastPlayerDisconnectedAt(Instant::now()));
-        world.get_resource_or_insert_with(|| {
-            IdleTimeout(
-                server_config
-                    .idle_timeout_millis
-                    .map(Duration::from_millis)
-                    .unwrap_or_else(|| {
-                        log::info!(
-                            "Using the default value for MUDDLE_IDLE_TIMEOUT: {}",
-                            DEFAULT_IDLE_TIMEOUT_MILLIS
-                        );
-                        Duration::from_millis(DEFAULT_IDLE_TIMEOUT_MILLIS)
-                    }),
-            )
-        });
-        world.get_resource_or_insert_with(Jwks::default);
+        // We override the initial state for server as we aren't using the loading state
+        // atm.
+        app.insert_resource(CurrentState(AppState::Playing));
+
+        app.init_resource::<EntityNetIdCounter>();
+        app.init_resource::<PlayerNetIdCounter>();
+        app.init_resource::<PlayerConnections>();
+        app.init_resource::<NewPlayerConnections>();
+        app.init_resource::<ConnectionStates>();
+        app.init_resource::<DeferredPlayerQueues<RunnerInput>>();
+        app.init_resource::<DeferredPlayerQueues<PlayerRole>>();
+        app.init_resource::<DeferredPlayerQueues<messages::SpawnLevelObjectRequestBody>>();
+        app.init_resource::<DeferredPlayerQueues<SpawnLevelObjectRequest>>();
+        app.init_resource::<DeferredPlayerQueues<LevelObject>>();
+        app.init_resource::<DeferredPlayerQueues<EntityNetId>>();
+        app.init_resource::<DeferredMessagesQueue<RespawnPlayer>>();
+        app.init_resource::<DeferredMessagesQueue<SpawnLevelObject>>();
+        app.init_resource::<DeferredMessagesQueue<UpdateLevelObject>>();
+        app.init_resource::<DeferredMessagesQueue<DespawnLevelObject>>();
+        app.insert_resource(LastPlayerDisconnectedAt(Instant::now()));
+        app.insert_resource(IdleTimeout(
+            server_config
+                .idle_timeout_millis
+                .map(Duration::from_millis)
+                .unwrap_or_else(|| {
+                    log::info!(
+                        "Using the default value for MUDDLE_IDLE_TIMEOUT: {}",
+                        DEFAULT_IDLE_TIMEOUT_MILLIS
+                    );
+                    Duration::from_millis(DEFAULT_IDLE_TIMEOUT_MILLIS)
+                }),
+        ));
+        app.init_resource::<Jwks>();
     }
 }
 
@@ -357,11 +360,19 @@ fn default_level_objects() -> Vec<LevelObject> {
 }
 
 pub fn init_level(
+    mut commands: Commands,
     mut init_level_objects: ResMut<InitLevelObjects>,
     mut entity_net_id_counter: ResMut<EntityNetIdCounter>,
     mut spawn_level_object_commands: ResMut<DeferredQueue<UpdateLevelObject>>,
 ) {
-    for level_object in std::mem::take(&mut init_level_objects.0) {
+    let level_objects_to_spawn = std::mem::take(&mut init_level_objects.0);
+    commands.insert_resource(LevelObjectsToSpawnToLoad(level_objects_to_spawn.len()));
+    log::info!(
+        "Level objects to spawn to load: {}",
+        level_objects_to_spawn.len()
+    );
+
+    for level_object in level_objects_to_spawn {
         assert_eq!(entity_net_id_counter.increment(), level_object.net_id);
         spawn_level_object_commands.push(UpdateLevelObject {
             frame_number: FrameNumber::new(0),
diff --git a/libs/server_lib/src/net.rs b/libs/server_lib/src/net.rs
index f564ec0..69b5152 100644
--- a/libs/server_lib/src/net.rs
+++ b/libs/server_lib/src/net.rs
@@ -821,19 +821,34 @@ pub struct LevelParams<'w, 's> {
     marker: PhantomData<&'s ()>,
 }
 
+#[derive(SystemParam)]
+pub struct PlayerParams<'w, 's> {
+    players: Res<'w, Players>,
+    player_entities: Query<
+        'w,
+        's,
+        (
+            Entity,
+            &'static Position,
+            &'static PlayerDirection,
+            &'static Spawned,
+        ),
+    >,
+    players_registry: Res<'w, EntityRegistry<PlayerNetId>>,
+}
+
 pub fn send_network_updates_system(
     mut network_params: NetworkParams,
     time: Res<SimulationTime>,
     level_params: LevelParams,
-    players: Res<Players>,
-    player_entities: Query<(Entity, &Position, &PlayerDirection, &Spawned)>,
-    players_registry: Res<EntityRegistry<PlayerNetId>>,
+    player_params: PlayerParams,
     mut deferred_message_queues: DeferredMessageQueues,
 ) {
     #[cfg(feature = "profiler")]
     puffin::profile_function!();
-    // We run this system after we've concluded the simulation. As we don't have
-    // updates for the next frame yet, we decrement the frame number.
+    // We run this system after we've concluded the simulation and incremented the
+    // frame number. As we don't have updates for the next frame yet, we
+    // use the previous frame number just for this system run.
     let time = time.prev_frame();
 
     broadcast_start_game_messages(
@@ -844,13 +859,11 @@ pub fn send_network_updates_system(
             .as_deref()
             .map(|info| info.deref()),
         &level_params.level_state,
-        &players,
-        &player_entities,
-        &players_registry,
+        &player_params.players,
+        &player_params.player_entities,
+        &player_params.players_registry,
     );
 
-    broadcast_disconnected_players(&mut network_params);
-
     for (&_connection_player_net_id, &connection_handle) in network_params.player_connections.iter()
     {
         let connection_state = network_params
@@ -865,9 +878,9 @@ pub fn send_network_updates_system(
         broadcast_delta_update_messages(
             &mut network_params.net,
             &time,
-            &players,
-            &player_entities,
-            &players_registry,
+            &player_params.players,
+            &player_params.player_entities,
+            &player_params.players_registry,
             connection_handle,
             connection_state,
         );
@@ -875,7 +888,7 @@ pub fn send_network_updates_system(
         send_new_player_messages(
             &mut network_params.net,
             &network_params.new_player_connections,
-            &players,
+            &player_params.players,
             connection_handle,
             connection_state,
         )
@@ -940,7 +953,7 @@ pub fn send_network_updates_system(
     network_params.new_player_connections.clear();
 }
 
-fn broadcast_disconnected_players(network_params: &mut NetworkParams) {
+pub fn broadcast_disconnected_players_system(mut network_params: NetworkParams) {
     let mut disconnected_players = Vec::new();
     for (&connection_handle, connection_state) in network_params.connection_states.iter_mut() {
         let ConnectionStatus::Disconnecting(reason) = connection_state.status() else {
diff --git a/libs/server_lib/src/persistence.rs b/libs/server_lib/src/persistence.rs
index 828cc6f..25cd956 100644
--- a/libs/server_lib/src/persistence.rs
+++ b/libs/server_lib/src/persistence.rs
@@ -78,7 +78,7 @@ pub async fn get_user(persistence_url: Url, user_id: i64) -> anyhow::Result<GetU
     Ok(response)
 }
 
-#[derive(Resource)]
+#[derive(Resource, Deref, DerefMut)]
 pub struct InitLevelObjects(pub Vec<LevelObject>);
 
 pub async fn load_level(
diff --git a/libs/shared_lib/Cargo.toml b/libs/shared_lib/Cargo.toml
index ad7d108..45fe30d 100644
--- a/libs/shared_lib/Cargo.toml
+++ b/libs/shared_lib/Cargo.toml
@@ -17,15 +17,16 @@ bevy_egui = { version = "0.18", optional = true }
 bevy_mod_picking = { version = "0.11", optional = true }
 bevy_disturbulence = { git = "https://github.com/mvlabat/bevy_disturbulence.git", branch = "wip" }
 bevy_rapier2d = { version = "0.19", features = ["wasm-bindgen", "serde-serialize"] }
-rapier2d = "0.16.1"
 chrono = "0.4.19"
 crossbeam-channel = "0.5.5"
 futures-lite = "1.12.0"
+iyes_loopless = "0.9"
 konst = "0.2.13"
 names = { version = "0.14.0", default-features = false }
 num = "0.4.0"
 puffin = { version = "0.13", optional = true }
 rand = "0.8.4"
+rapier2d = "0.16.1"
 serde = "1.0"
 serde_json = "1.0"
 thiserror = "1.0.30"
diff --git a/libs/shared_lib/src/game/commands.rs b/libs/shared_lib/src/game/commands.rs
index 1f8ef87..2a71803 100644
--- a/libs/shared_lib/src/game/commands.rs
+++ b/libs/shared_lib/src/game/commands.rs
@@ -53,11 +53,7 @@ impl<T: DeferredCommand> DeferredQueue<T> {
 }
 
 // NOTE: after adding a new command, remember to clean them up in the
-// `restart_game` system.
-
-pub struct RestartGame;
-
-impl DeferredCommand for RestartGame {}
+// `reset_game_world_system` system.
 
 pub struct SwitchPlayerRole {
     pub net_id: PlayerNetId,
diff --git a/libs/shared_lib/src/game/mod.rs b/libs/shared_lib/src/game/mod.rs
index 3d6fa39..54022a0 100644
--- a/libs/shared_lib/src/game/mod.rs
+++ b/libs/shared_lib/src/game/mod.rs
@@ -8,8 +8,8 @@ use crate::{
 use crate::{
     game::{
         commands::{
-            DeferredQueue, DespawnLevelObject, DespawnPlayer, RestartGame, SpawnPlayer,
-            SwitchPlayerRole, UpdateLevelObject,
+            DeferredQueue, DespawnLevelObject, DespawnPlayer, SpawnPlayer, SwitchPlayerRole,
+            UpdateLevelObject,
         },
         components::{LevelObjectServerGhostParent, LevelObjectStaticGhostParent, PlayerSensor},
     },
@@ -28,6 +28,7 @@ use bevy::{
     },
     log,
     prelude::{Deref, DerefMut},
+    time::Time,
 };
 
 pub mod client_factories;
@@ -44,15 +45,15 @@ pub mod spawn;
 pub struct PlayerEventSender(pub Option<tokio::sync::mpsc::UnboundedSender<PlayerEvent>>);
 
 // TODO: track https://github.com/bevyengine/rfcs/pull/16.
-pub fn restart_game_system(world: &mut World) {
-    let mut restart_game_commands = world
-        .get_resource_mut::<DeferredQueue<RestartGame>>()
-        .unwrap();
-    if restart_game_commands.drain(&Default::default()).is_empty() {
+pub fn reset_game_world_system(world: &mut World) {
+    let time = world.get_resource_mut::<Time>().unwrap();
+    if time.first_update() == time.last_update() {
+        // It's an initial app start, we don't need to reset the world. Resetting it
+        // will prevent server to spawn starting level objects.
         return;
     }
 
-    log::info!("Restarting the game");
+    log::info!("Resetting the game world");
 
     let mut players = world.get_resource_mut::<Players>().unwrap();
     players.clear();
@@ -145,7 +146,10 @@ pub fn restart_game_system(world: &mut World) {
     *world
         .get_resource_mut::<DeferredQueue<DespawnLevelObject>>()
         .unwrap() = Default::default();
-    *world.get_resource_mut::<PlayerUpdates>().unwrap() = PlayerUpdates::default();
+    *world
+        .get_resource_mut::<DeferredQueue<SwitchPlayerRole>>()
+        .unwrap() = Default::default();
+    *world.get_resource_mut().unwrap() = PlayerUpdates::default();
 }
 
 pub fn switch_player_role_system(
diff --git a/libs/shared_lib/src/game/spawn.rs b/libs/shared_lib/src/game/spawn.rs
index e46f3c3..c7459bc 100644
--- a/libs/shared_lib/src/game/spawn.rs
+++ b/libs/shared_lib/src/game/spawn.rs
@@ -22,7 +22,8 @@ use crate::{
     messages::{EntityNetId, PlayerNetId},
     registry::EntityRegistry,
     util::{dedup_by_key_unsorted, player_sensor_outline},
-    GameTime, SimulationTime, PLAYER_RADIUS, PLAYER_SENSOR_RADIUS,
+    GameSessionState, GameTime, LevelObjectsToSpawnToLoad, SimulationTime, PLAYER_RADIUS,
+    PLAYER_SENSOR_RADIUS,
 };
 use bevy::{
     ecs::{
@@ -38,6 +39,7 @@ use bevy_rapier2d::{
     prelude::CollisionGroups,
     rapier::geometry::ColliderShape,
 };
+use iyes_loopless::state::NextState;
 use std::fmt::Debug;
 
 #[derive(WorldQuery)]
@@ -354,6 +356,7 @@ pub fn update_level_objects_system(
     mut pbr_client_params: PbrClientParams,
     mut update_level_object_commands: ResMut<DeferredQueue<UpdateLevelObject>>,
     mut level_object_params: LevelObjectsParams,
+    mut level_objects_to_spawn_to_load: Option<ResMut<LevelObjectsToSpawnToLoad>>,
     shape_sender: Res<ColliderShapeSender>,
 ) {
     #[cfg(feature = "profiler")]
@@ -458,6 +461,16 @@ pub fn update_level_objects_system(
             .insert(spawned_component);
 
         if let Some(ref shape) = shape {
+            // This resource exists if we've just started the game. Once all the objects are
+            // spawned, we must remove the resource and switch to the
+            // `GameSessionState::Playing` state.
+            //
+            // IMPORTANT: the same logic is present in `poll_calculating_shapes_system`,
+            // remember to update it as well if there are any changes to this code.
+            if let Some(level_objects_to_spawn_to_load) = &mut level_objects_to_spawn_to_load {
+                level_objects_to_spawn_to_load.0 -= 1;
+            }
+
             let (physics_bundle, sensor) = command
                 .object
                 .desc
@@ -526,6 +539,17 @@ pub fn update_level_objects_system(
             }
         }
     }
+
+    if let Some(level_objects_to_spawn_to_load) = &mut level_objects_to_spawn_to_load {
+        if level_objects_to_spawn_to_load.0 == 0 {
+            log::info!(
+                "Changing the game session state to {:?}",
+                GameSessionState::Playing
+            );
+            commands.insert_resource(NextState(GameSessionState::Playing));
+            commands.remove_resource::<LevelObjectsToSpawnToLoad>();
+        }
+    }
 }
 
 type GhostEntites = Option<(
@@ -535,6 +559,7 @@ type GhostEntites = Option<(
 
 pub fn poll_calculating_shapes_system(
     mut commands: Commands,
+    mut level_objects_to_spawn_to_load: Option<ResMut<LevelObjectsToSpawnToLoad>>,
     time: Res<GameTime>,
     level_state: Res<LevelState>,
     mut pbr_client_params: PbrClientParams,
@@ -574,6 +599,16 @@ pub fn poll_calculating_shapes_system(
             }
         };
 
+        // This resource exists if we've just started the game. Once all the objects are
+        // spawned, we must remove the resource and switch to the
+        // `GameSessionState::Playing` state.
+        //
+        // IMPORTANT: the same logic is present in `update_level_objects_system`,
+        // remember to update it as well if there are any changes to this code.
+        if let Some(level_objects_to_spawn_to_load) = &mut level_objects_to_spawn_to_load {
+            level_objects_to_spawn_to_load.0 -= 1;
+        }
+
         let (physics_bundle, sensor) = level_object
             .desc
             .physics_bundle(shape.clone(), cfg!(not(feature = "client")));
diff --git a/libs/shared_lib/src/lib.rs b/libs/shared_lib/src/lib.rs
index 8b99675..ebb804f 100644
--- a/libs/shared_lib/src/lib.rs
+++ b/libs/shared_lib/src/lib.rs
@@ -11,8 +11,8 @@ use crate::{
     game::{
         collisions::{process_collision_events_system, process_players_with_new_collisions_system},
         commands::{
-            DeferredQueue, DespawnLevelObject, DespawnPlayer, RestartGame, SpawnPlayer,
-            SwitchPlayerRole, UpdateLevelObject,
+            DeferredQueue, DespawnLevelObject, DespawnPlayer, SpawnPlayer, SwitchPlayerRole,
+            UpdateLevelObject,
         },
         components::PlayerFrameSimulated,
         events::{CollisionLogicChanged, PlayerDeath, PlayerFinish},
@@ -24,7 +24,7 @@ use crate::{
             isolate_client_mispredicted_world_system, load_object_positions_system,
             player_movement_system, read_movement_updates_system, sync_position_system,
         },
-        remove_disconnected_players_system, restart_game_system,
+        remove_disconnected_players_system, reset_game_world_system,
         spawn::{
             despawn_level_objects_system, despawn_players_system, poll_calculating_shapes_system,
             process_spawned_entities_system, spawn_players_system, update_level_objects_system,
@@ -47,6 +47,7 @@ use bevy_rapier2d::{
     pipeline::CollisionEvent,
     plugin::{PhysicsStages, RapierConfiguration, RapierPhysicsPlugin, TimestepMode},
 };
+use iyes_loopless::prelude::*;
 use messages::{EntityNetId, PlayerNetId};
 use std::sync::Mutex;
 
@@ -67,15 +68,21 @@ pub mod wrapped_counter;
 // Constants.
 pub mod stage {
     pub const WRITE_INPUT_UPDATES: &str = "mr_shared_write_input_updates";
-
-    pub const MAIN_SCHEDULE: &str = "mr_shared_main_schedule";
-    pub const STATE_DRIVER: &str = "mr_shared_state_driver";
+    pub const APP_STATE_TRANSITION: &str = "mr_shared_app_state_transition";
+    pub const GAME_SESSION_STATE_TRANSITION: &str = "mr_shared_game_session_state_transition";
     pub const READ_INPUT_UPDATES: &str = "mr_shared_read_input_updates";
+    // Here, between `WRITE_INPUT_UPDATES` and `BROADCAST_UPDATES` runs the main
+    // schedule, which also includes the `SIMULATION_SCHEDULE` (running the game
+    // logic and physics).
+    // ...
+    pub const MAIN_SCHEDULE: &str = "mr_shared_main_schedule";
+    pub const SIMULATION_SCHEDULE: &str = "mr_shared_simulation_schedule";
+    // ...
     pub const BROADCAST_UPDATES: &str = "mr_shared_broadcast_updates";
     pub const POST_SIMULATIONS: &str = "mr_shared_post_simulations";
     pub const POST_TICK: &str = "mr_shared_post_tick";
 
-    pub const SIMULATION_SCHEDULE: &str = "mr_shared_simulation_schedule";
+    // Stages of the `SIMULATION_SCHEDULE`:
     pub const SPAWN: &str = "mr_shared_spawn";
     pub const PRE_GAME: &str = "mr_shared_pre_game";
     pub const FINALIZE_PHYSICS: &str = "mr_shared_finalize_physics";
@@ -287,7 +294,24 @@ impl<S: System<In = (), Out = ShouldRun>> Plugin for MuddleSharedPlugin<S> {
             .with_stage(
                 stage::POST_SIMULATIONS,
                 SystemStage::single_threaded()
-                    .with_system(tick_game_frame_system)
+                    // If the game is loading, these systems won't run (as the simulation schedule
+                    // isn't run), but we still need as spawning level objects is part of loading.
+                    .with_system(
+                        poll_calculating_shapes_system
+                            .run_in_state(GameSessionState::Loading)
+                            .label("poll_shapes"),
+                    )
+                    .with_system(
+                        update_level_objects_system
+                            .run_in_state(GameSessionState::Loading)
+                            .label("update_level_objects")
+                            .after("poll_shapes"),
+                    )
+                    .with_system(
+                        tick_game_frame_system
+                            .run_not_in_state(GameSessionState::Paused)
+                            .after("update_level_objects"),
+                    )
                     .with_system(process_spawned_entities_system.after(tick_game_frame_system))
                     // Removing disconnected players doesn't depend on ticks, so it's fine to have
                     // in unordered.
@@ -308,11 +332,35 @@ impl<S: System<In = (), Out = ShouldRun>> Plugin for MuddleSharedPlugin<S> {
             stage::MAIN_SCHEDULE,
             stage::READ_INPUT_UPDATES,
             SystemStage::single_threaded()
-                .with_system(restart_game_system.at_start())
-                .with_system(
-                    read_movement_updates_system
-                        .with_run_criteria(State::on_update(GameState::Playing)),
-                ),
+                .with_system(read_movement_updates_system.run_in_state(GameSessionState::Playing)),
+        );
+        // We predefine every enter/exit stage to mark them as single-threaded.
+        // Atm, Bevy suffers from from the scheduler overhead to plan running systems in
+        // parallel, which negates the parallelisation.
+        app.add_stage_before(
+            stage::READ_INPUT_UPDATES,
+            stage::GAME_SESSION_STATE_TRANSITION,
+            StateTransitionStage::new(GameSessionState::Loading)
+                .with_enter_stage(
+                    GameSessionState::Loading,
+                    SystemStage::single_threaded().with_system(reset_game_world_system.at_start()),
+                )
+                .with_exit_stage(GameSessionState::Loading, SystemStage::single_threaded())
+                .with_enter_stage(GameSessionState::Playing, SystemStage::single_threaded())
+                .with_exit_stage(GameSessionState::Playing, SystemStage::single_threaded())
+                .with_enter_stage(GameSessionState::Paused, SystemStage::single_threaded())
+                .with_exit_stage(GameSessionState::Paused, SystemStage::single_threaded()),
+        );
+        app.add_stage_before(
+            stage::GAME_SESSION_STATE_TRANSITION,
+            stage::APP_STATE_TRANSITION,
+            StateTransitionStage::new(AppState::Loading)
+                .with_enter_stage(AppState::Loading, SystemStage::single_threaded())
+                .with_exit_stage(AppState::Loading, SystemStage::single_threaded())
+                .with_enter_stage(AppState::MainMenu, SystemStage::single_threaded())
+                .with_exit_stage(AppState::MainMenu, SystemStage::single_threaded())
+                .with_enter_stage(AppState::Playing, SystemStage::single_threaded())
+                .with_exit_stage(AppState::Playing, SystemStage::single_threaded()),
         );
         app.add_stage_before(
             stage::READ_INPUT_UPDATES,
@@ -322,10 +370,6 @@ impl<S: System<In = (), Out = ShouldRun>> Plugin for MuddleSharedPlugin<S> {
                 .expect("Can't initialize the plugin more than once"),
         );
 
-        // Is `GameState::Paused` for client (see `init_state`).
-        app.add_state(GameState::Playing);
-        app.add_state_to_stage(stage::READ_INPUT_UPDATES, GameState::Playing);
-
         app.add_startup_system(network_setup_system);
 
         #[cfg(feature = "client")]
@@ -336,7 +380,6 @@ impl<S: System<In = (), Out = ShouldRun>> Plugin for MuddleSharedPlugin<S> {
         world.get_resource_or_insert_with(SimulationTime::default);
         world.get_resource_or_insert_with(LevelState::default);
         world.get_resource_or_insert_with(PlayerUpdates::default);
-        world.get_resource_or_insert_with(DeferredQueue::<RestartGame>::default);
         world.get_resource_or_insert_with(DeferredQueue::<SpawnPlayer>::default);
         world.get_resource_or_insert_with(DeferredQueue::<DespawnPlayer>::default);
         world.get_resource_or_insert_with(DeferredQueue::<UpdateLevelObject>::default);
@@ -359,17 +402,47 @@ impl<S: System<In = (), Out = ShouldRun>> Plugin for MuddleSharedPlugin<S> {
 }
 
 #[derive(Clone, Debug, Eq, PartialEq, Hash)]
-pub enum GameState {
-    Paused,
+pub enum AppState {
+    /// Currently, this state is used only for clients.
+    /// We use this state to spawn dummy PBR entities to trigger shaders
+    /// loading. This is useful for browsers in the first place, as loading
+    /// shaders is blocking there and freezes the app (so a loading screen
+    /// should be shown).
+    Loading,
+    /// This state is used when a client is launched in the mode when going
+    /// through the authentication and matchmaking menus is required before
+    /// connecting to a server.
+    MainMenu,
+    /// A level is being loaded or played.
+    Playing,
+}
+
+impl Default for AppState {
+    fn default() -> Self {
+        Self::Loading
+    }
+}
+
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub enum GameSessionState {
+    Loading,
     Playing,
+    Paused,
 }
 
-impl Default for GameState {
+impl Default for GameSessionState {
     fn default() -> Self {
-        Self::Paused
+        Self::Loading
     }
 }
 
+/// The resource is added when a client/server starts spawning level objects on
+/// loading the level. When every level object is spawned, the counter reaches
+/// zero. After that, we remove the resource and switch `GameSessionState` to
+/// `Playing`.
+#[derive(Resource, Deref, DerefMut)]
+pub struct LevelObjectsToSpawnToLoad(pub usize);
+
 #[derive(Resource, Default, Clone, Debug, PartialEq, Eq)]
 pub struct GameTime {
     pub session: usize,
@@ -550,7 +623,7 @@ pub struct SimulationTickRunCriteriaState {
 
 fn simulation_tick_run_criteria(
     mut state: Local<SimulationTickRunCriteriaState>,
-    game_state: Res<State<GameState>>,
+    game_state: Res<CurrentState<GameSessionState>>,
     game_time: Res<GameTime>,
     simulation_time: Res<SimulationTime>,
 ) -> ShouldRun {
@@ -562,7 +635,7 @@ fn simulation_tick_run_criteria(
         state.last_game_frame = Some(game_time.frame_number);
     } else if state.last_player_frame == simulation_time.player_frame
         && state.last_server_frame == simulation_time.server_frame
-        && game_state.current() == &GameState::Playing
+        && game_state.0 == GameSessionState::Playing
     {
         panic!(
             "Simulation frame hasn't advanced: {}, {}",
@@ -573,7 +646,7 @@ fn simulation_tick_run_criteria(
     state.last_server_frame = simulation_time.server_frame;
 
     if state.last_player_frame <= game_time.frame_number
-        && game_state.current() == &GameState::Playing
+        && game_state.0 == GameSessionState::Playing
     {
         trace!(
             "Run and loop a simulation schedule (simulation: {}, game: {}, state: {:?})",
diff --git a/libs/shared_lib/src/messages.rs b/libs/shared_lib/src/messages.rs
index a24cf3c..ca59ff2 100644
--- a/libs/shared_lib/src/messages.rs
+++ b/libs/shared_lib/src/messages.rs
@@ -116,7 +116,11 @@ pub enum ReliableServerMessage {
     /// A kludge message basically, to let our networking stack to initialize
     /// properly for webrtc.
     Initialize,
-    /// Is sent as a response to client's `ReliableClientMessage::Handshake`.
+    /// Is sent if a server is still in the loading state when a client joins
+    /// (as a response to client's `ReliableClientMessage::Handshake`).
+    Loading,
+    /// Is sent as a response to client's `ReliableClientMessage::Handshake` or
+    /// when the game is started if a client is already joined.
     StartGame(StartGame),
     ConnectedPlayer((PlayerNetId, Player)),
     DisconnectedPlayer(DisconnectedPlayer),
diff --git a/libs/shared_lib/src/net.rs b/libs/shared_lib/src/net.rs
index 9d8fb3e..0d5b295 100644
--- a/libs/shared_lib/src/net.rs
+++ b/libs/shared_lib/src/net.rs
@@ -32,8 +32,11 @@ pub enum ConnectionStatus {
     Connected,
     /// We've received a `Disconnect` event or triggered the process manually.
     /// After we finish the needed clean-up, we switch the status to
-    /// `Disconnected`.
+    /// `Disconnected` (or immediately to `Uninitialized` for clients).
     Disconnecting(DisconnectReason),
+    /// This status must never be set manually (it's only set in the
+    /// `broadcast_disconnected_players` function, once all the necessary
+    /// updates have been processed).
     Disconnected,
 }