diff --git a/server/game/benchmarks/bench.rs b/server/game/benchmarks/bench.rs
index b9504308..197b956b 100644
--- a/server/game/benchmarks/bench.rs
+++ b/server/game/benchmarks/bench.rs
@@ -95,7 +95,13 @@ fn managers(c: &mut Criterion) {
             for level_id in 0..100 {
                 for account_id in 0..10 {
                     manager.add_to_level(level_id, level_id * 10 + account_id);
-                    manager.set_player_data(level_id * 10 + account_id, &PlayerData {});
+                    manager.set_player_data(
+                        level_id * 10 + account_id,
+                        &PlayerData {
+                            percentage: 0,
+                            attempts: 0,
+                        },
+                    );
                 }
             }
 
diff --git a/server/game/src/data/packets/client/game.rs b/server/game/src/data/packets/client/game.rs
index 1c087076..b31991c4 100644
--- a/server/game/src/data/packets/client/game.rs
+++ b/server/game/src/data/packets/client/game.rs
@@ -1,5 +1,11 @@
 use crate::data::*;
 
+#[derive(Packet, Decodable)]
+#[packet(id = 12000, encrypted = false)]
+pub struct RequestPlayerProfilesPacket {
+    pub requested: i32, // 0 to get all ppl on the level
+}
+
 #[derive(Packet, Decodable)]
 #[packet(id = 12001, encrypted = false)]
 pub struct LevelJoinPacket {
@@ -16,13 +22,6 @@ pub struct PlayerDataPacket {
     pub data: PlayerData,
 }
 
-#[derive(Packet, Decodable)]
-#[packet(id = 12004, encrypted = false)]
-pub struct SyncPlayerMetadataPacket {
-    pub data: PlayerMetadata,
-    pub requested: Option<i32>,
-}
-
 #[derive(Packet, Decodable)]
 #[packet(id = 12010, encrypted = true)]
 pub struct VoicePacket {
diff --git a/server/game/src/data/packets/server/game.rs b/server/game/src/data/packets/server/game.rs
index 675f207b..3a265dd6 100644
--- a/server/game/src/data/packets/server/game.rs
+++ b/server/game/src/data/packets/server/game.rs
@@ -5,12 +5,12 @@ use crate::data::*;
 */
 
 #[derive(Packet, Encodable)]
-#[packet(id = 22001, encrypted = false)]
-pub struct LevelDataPacket;
+#[packet(id = 22000, encrypted = false)]
+pub struct PlayerProfilesPacket;
 
 #[derive(Packet, Encodable)]
-#[packet(id = 22002, encrypted = false)]
-pub struct PlayerMetadataPacket;
+#[packet(id = 22001, encrypted = false)]
+pub struct LevelDataPacket;
 
 #[derive(Packet, Encodable)]
 #[packet(id = 22010, encrypted = true)]
diff --git a/server/game/src/data/types/gd.rs b/server/game/src/data/types/gd.rs
index b1a57d41..f24acff0 100644
--- a/server/game/src/data/types/gd.rs
+++ b/server/game/src/data/types/gd.rs
@@ -146,7 +146,10 @@ pub enum IconType {
 /* PlayerData (data in a level) */
 
 #[derive(Clone, Default, Encodable, KnownSize, Decodable)]
-pub struct PlayerData {}
+pub struct PlayerData {
+    pub percentage: u16,
+    pub attempts: i32,
+}
 
 /* AssociatedPlayerData */
 
@@ -155,19 +158,3 @@ pub struct AssociatedPlayerData {
     pub account_id: i32,
     pub data: PlayerData,
 }
-
-/* PlayerMetadata (things like your percentage in a level, attempt count) */
-
-#[derive(Copy, Clone, Default, Encodable, KnownSize, Decodable)]
-pub struct PlayerMetadata {
-    percentage: u16,
-    attempts: i32,
-}
-
-/* FullPlayerMetadata */
-
-#[derive(Clone, Default, Encodable, KnownSize)]
-pub struct FullPlayerMetadata {
-    pub account_data: PlayerAccountData,
-    pub metadata: PlayerMetadata,
-}
diff --git a/server/game/src/managers/player.rs b/server/game/src/managers/player.rs
index 0164c155..c0ac6f4b 100644
--- a/server/game/src/managers/player.rs
+++ b/server/game/src/managers/player.rs
@@ -1,20 +1,11 @@
 use nohash_hasher::IntMap;
 
-use crate::data::{
-    types::{AssociatedPlayerData, PlayerData},
-    PlayerMetadata,
-};
-
-#[derive(Default)]
-pub struct PlayerEntry {
-    pub data: AssociatedPlayerData,
-    pub meta: PlayerMetadata,
-}
+use crate::data::types::{AssociatedPlayerData, PlayerData};
 
 #[derive(Default)]
 pub struct PlayerManager {
-    pub players: IntMap<i32, PlayerEntry>, // player id : associated data
-    pub levels: IntMap<i32, Vec<i32>>,     // level id : [player id]
+    pub players: IntMap<i32, AssociatedPlayerData>, // player id : associated data
+    pub levels: IntMap<i32, Vec<i32>>,              // level id : [player id]
 }
 
 impl PlayerManager {
@@ -23,36 +14,29 @@ impl PlayerManager {
     }
 
     pub fn get_player_data(&self, account_id: i32) -> Option<&AssociatedPlayerData> {
-        self.players.get(&account_id).map(|entry| &entry.data)
-    }
-
-    pub fn get_player_metadata(&self, account_id: i32) -> Option<&PlayerMetadata> {
-        self.players.get(&account_id).map(|entry| &entry.meta)
+        self.players.get(&account_id)
     }
 
     pub fn create_player(&mut self, account_id: i32) {
-        let mut entry = PlayerEntry::default();
-        entry.data.account_id = account_id;
-
-        self.players.insert(account_id, entry);
+        self.players.insert(
+            account_id,
+            AssociatedPlayerData {
+                account_id,
+                ..Default::default()
+            },
+        );
     }
 
-    fn get_or_create_player(&mut self, account_id: i32) -> &mut PlayerEntry {
-        self.players.entry(account_id).or_insert_with(|| {
-            let mut entry = PlayerEntry::default();
-            entry.data.account_id = account_id;
-            entry
+    fn get_or_create_player(&mut self, account_id: i32) -> &mut AssociatedPlayerData {
+        self.players.entry(account_id).or_insert_with(|| AssociatedPlayerData {
+            account_id,
+            ..Default::default()
         })
     }
 
     /// set player's data, inserting a new entry if doesn't already exist
     pub fn set_player_data(&mut self, account_id: i32, data: &PlayerData) {
-        self.get_or_create_player(account_id).data.data.clone_from(data);
-    }
-
-    /// set player's metadata, inserting a new entry if it doesn't already exist
-    pub fn set_player_metadata(&mut self, account_id: i32, data: &PlayerMetadata) {
-        self.get_or_create_player(account_id).meta.clone_from(data);
+        self.get_or_create_player(account_id).data.clone_from(data);
     }
 
     /// remove the player from the list of players
@@ -78,7 +62,7 @@ impl PlayerManager {
     /// run a function `f` on each player on a level given its ID, with possibility to pass additional data
     pub fn for_each_player_on_level<F, A>(&self, level_id: i32, f: F, additional: &mut A) -> usize
     where
-        F: Fn(&PlayerEntry, usize, &mut A) -> bool,
+        F: Fn(&AssociatedPlayerData, usize, &mut A) -> bool,
     {
         if let Some(ids) = self.levels.get(&level_id) {
             ids.iter()
@@ -92,7 +76,7 @@ impl PlayerManager {
     /// run a function `f` on each player in this `PlayerManager`, with possibility to pass additional data
     pub fn for_each_player<F, A>(&self, f: F, additional: &mut A) -> usize
     where
-        F: Fn(&PlayerEntry, usize, &mut A) -> bool,
+        F: Fn(&AssociatedPlayerData, usize, &mut A) -> bool,
     {
         self.players
             .values()
diff --git a/server/game/src/server_thread/handlers/game.rs b/server/game/src/server_thread/handlers/game.rs
index 7520993c..67590b75 100644
--- a/server/game/src/server_thread/handlers/game.rs
+++ b/server/game/src/server_thread/handlers/game.rs
@@ -79,8 +79,8 @@ impl GameServerThread {
                     level_id,
                     |player, count, buf| {
                         // we do additional length check because player count may have increased since 1st lock
-                        if count < written_players && player.data.account_id != account_id {
-                            buf.write_value(&player.data);
+                        if count < written_players && player.account_id != account_id {
+                            buf.write_value(player);
                             true
                         } else {
                             false
@@ -100,7 +100,7 @@ impl GameServerThread {
         Ok(())
     });
 
-    gs_handler!(self, handle_sync_player_metadata, SyncPlayerMetadataPacket, packet, {
+    gs_handler!(self, handle_request_profiles, RequestPlayerProfilesPacket, packet, {
         let account_id = gs_needauth!(self);
 
         let level_id = self.level_id.load(Ordering::Relaxed);
@@ -111,7 +111,6 @@ impl GameServerThread {
         let room_id = self.room_id.load(Ordering::Relaxed);
 
         let total_players = self.game_server.state.room_manager.with_any(room_id, |pm| {
-            pm.set_player_metadata(account_id, &packet.data);
             // this unwrap should be safe and > 0 given that self.level_id != 0, but we leave a default just in case
             pm.get_player_count_on_level(level_id).unwrap_or(1) - 1
         });
@@ -121,54 +120,41 @@ impl GameServerThread {
             return Ok(());
         }
 
-        let written_players = if packet.requested.is_some() { 1 } else { total_players };
+        let written_players = if packet.requested != 0 { 1 } else { total_players };
 
-        let calc_size = size_of_types!(PacketHeader, u32) + size_of_types!(FullPlayerMetadata) * written_players;
+        let calc_size = size_of_types!(PacketHeader, u32) + size_of_types!(PlayerAccountData) * written_players;
 
         gs_inline_encode!(self, calc_size, buf, {
-            buf.write_packet_header::<PlayerMetadataPacket>();
+            buf.write_packet_header::<PlayerProfilesPacket>();
             buf.write_u32(written_players as u32);
 
-            let written = self.game_server.state.room_manager.with_any(room_id, |pm| {
-                // if they requested one specific player, encode just them (if we find them)
-                if let Some(player_id) = packet.requested {
-                    if let Some(meta) = pm.get_player_metadata(player_id) {
-                        let account_data = self.game_server.get_player_account_data(player_id);
-                        if account_data.is_some() {
-                            let fpm = FullPlayerMetadata {
-                                metadata: *meta,
-                                account_data: account_data.unwrap(),
-                            };
-
-                            buf.write_value(&fpm);
-                            return 1;
-                        }
-                    }
-
-                    return 0;
+            // if they requested one specific player, encode just them (if we find them)
+            let written = if packet.requested != 0 {
+                let account_data = self.game_server.get_player_account_data(packet.requested);
+                if let Some(data) = account_data {
+                    buf.write_value(&data);
+                    1
+                } else {
+                    0
                 }
-
-                // otherwise, encode everyone on the level
-                pm.for_each_player_on_level(
-                    level_id,
-                    |player, count, buf| {
-                        let account_data = self.game_server.get_player_account_data(player.data.account_id);
-                        // we do additional length check because player count may have changed since 1st lock
-                        if count < written_players && player.data.account_id != account_id && account_data.is_some() {
-                            let fpm = FullPlayerMetadata {
-                                metadata: player.meta,
-                                account_data: account_data.unwrap(),
-                            };
-
-                            buf.write_value(&fpm);
-                            true
-                        } else {
-                            false
-                        }
-                    },
-                    &mut buf,
-                )
-            });
+            } else {
+                self.game_server.state.room_manager.with_any(room_id, |pm| {
+                    // otherwise, encode everyone on the level
+                    pm.for_each_player_on_level(
+                        level_id,
+                        |player, count, buf| {
+                            // we do additional length check because player count may have changed since 1st lock
+                            if count < written_players && player.account_id != account_id {
+                                let account_data = self.game_server.get_player_account_data(player.account_id);
+                                account_data.map(|data| buf.write_value(&data)).is_some()
+                            } else {
+                                false
+                            }
+                        },
+                        &mut buf,
+                    )
+                })
+            };
 
             // if the player count has instead decreased, we now lied and the client will fail decoding. re-encode the actual count.
             if written != written_players {
diff --git a/server/game/src/server_thread/mod.rs b/server/game/src/server_thread/mod.rs
index 2aea6abe..57779d77 100644
--- a/server/game/src/server_thread/mod.rs
+++ b/server/game/src/server_thread/mod.rs
@@ -431,10 +431,10 @@ impl GameServerThread {
             RequestRoomPlayerListPacket::PACKET_ID => self.handle_request_room_list(&mut data).await,
 
             /* game related */
+            RequestPlayerProfilesPacket::PACKET_ID => self.handle_request_profiles(&mut data).await,
             LevelJoinPacket::PACKET_ID => self.handle_level_join(&mut data).await,
             LevelLeavePacket::PACKET_ID => self.handle_level_leave(&mut data).await,
             PlayerDataPacket::PACKET_ID => self.handle_player_data(&mut data).await,
-            SyncPlayerMetadataPacket::PACKET_ID => self.handle_sync_player_metadata(&mut data).await,
 
             VoicePacket::PACKET_ID => self.handle_voice(&mut data).await,
             ChatMessagePacket::PACKET_ID => self.handle_chat_message(&mut data).await,
diff --git a/server/game/tests/test.rs b/server/game/tests/test.rs
index 8b947787..72f06155 100644
--- a/server/game/tests/test.rs
+++ b/server/game/tests/test.rs
@@ -106,7 +106,13 @@ fn test_player_manager() {
     for level_id in 0..100 {
         for account_id in 0..100 {
             manager.add_to_level(level_id, level_id * 100 + account_id);
-            manager.set_player_data(level_id * 100 + account_id, &PlayerData {});
+            manager.set_player_data(
+                level_id * 100 + account_id,
+                &PlayerData {
+                    percentage: 0,
+                    attempts: 0,
+                },
+            );
         }
     }
 
diff --git a/server/protocol.md b/server/protocol.md
index c63c76f2..febf8650 100644
--- a/server/protocol.md
+++ b/server/protocol.md
@@ -37,10 +37,10 @@ General
 
 Game related
 
+* 12000 - RequestPlayerProfilesPacket - request account data of another player (or all people on the level)
 * 12001 - LevelJoinPacket - join a level
 * 12002 - LevelLeavePacket - leave a level
 * 12003 - PlayerDataPacket - player data
-* 12004^ - SyncPlayerMetadataPacket - request player account data & metadata and sync own
 * 12010+ - VoicePacket - voice frame
 * 12011?^+ - ChatMessagePacket - chat message
 
@@ -67,7 +67,7 @@ General
 
 Game related
 
+* 22000 - PlayerProfilesPacket - list of requested profiles
 * 22001 - LevelDataPacket - level data
-* 22002 - PlayerMetadataPacket - list of player metadata
 * 22010+ - VoiceBroadcastPacket - voice frame from another user
 * 22011+ - ChatMessageBroadcastPacket - chat message from another user
\ No newline at end of file
diff --git a/src/audio/manager.cpp b/src/audio/manager.cpp
index a3ecd664..986d8c9a 100644
--- a/src/audio/manager.cpp
+++ b/src/audio/manager.cpp
@@ -36,7 +36,10 @@ std::vector<AudioRecordingDevice> GlobedAudioManager::getRecordingDevices() {
     )
 
     for (int i = 0; i < numDrivers; i++) {
-        out.push_back(this->getRecordingDevice(i));
+        auto dev = this->getRecordingDevice(i);
+        if (dev.has_value()) {
+            out.push_back(dev.value());
+        }
     }
 
     return out;
@@ -52,23 +55,28 @@ std::vector<AudioPlaybackDevice> GlobedAudioManager::getPlaybackDevices() {
     )
 
     for (int i = 0; i < numDrivers; i++) {
-        out.push_back(this->getPlaybackDevice(i));
+        auto dev = this->getPlaybackDevice(i);
+        if (dev.has_value()) {
+            out.push_back(dev.value());
+        }
     }
 
     return out;
 }
 
-AudioRecordingDevice GlobedAudioManager::getRecordingDevice(int deviceId) {
+std::optional<AudioRecordingDevice> GlobedAudioManager::getRecordingDevice(int deviceId) {
     AudioRecordingDevice device;
     char name[256];
-    FMOD_ERR_CHECK(this->getSystem()->getRecordDriverInfo(
+    if (this->getSystem()->getRecordDriverInfo(
         deviceId, name, 256,
         &device.guid,
         &device.sampleRate,
         &device.speakerMode,
         &device.speakerModeChannels,
         &device.driverState
-    ), "System::getRecordDriverInfo")
+    ) != FMOD_OK) {
+        return std::nullopt;
+    }
 
     device.id = deviceId;
     device.name = std::string(name);
@@ -76,16 +84,18 @@ AudioRecordingDevice GlobedAudioManager::getRecordingDevice(int deviceId) {
     return device;
 }
 
-AudioPlaybackDevice GlobedAudioManager::getPlaybackDevice(int deviceId) {
+std::optional<AudioPlaybackDevice> GlobedAudioManager::getPlaybackDevice(int deviceId) {
     AudioPlaybackDevice device;
     char name[256];
-    FMOD_ERR_CHECK(this->getSystem()->getDriverInfo(
+    if (this->getSystem()->getDriverInfo(
         deviceId, name, 256,
         &device.guid,
         &device.sampleRate,
         &device.speakerMode,
         &device.speakerModeChannels
-    ), "System::getDriverInfo")
+    ) != FMOD_OK) {
+        return std::nullopt;
+    }
 
     device.id = deviceId;
     device.name = std::string(name);
@@ -99,18 +109,16 @@ bool GlobedAudioManager::isRecordingDeviceSet() {
 
 void GlobedAudioManager::validateDevices() {
     if (recordDevice.id != -1) {
-        try {
-            recordDevice = this->getRecordingDevice(recordDevice.id);
-        } catch (const std::exception& e) {
-            geode::log::info("Invalidating recording device {}: {}", recordDevice.id, e.what());
+        this->setActiveRecordingDevice(recordDevice.id);
+        if (recordDevice.id == -1) {
+            geode::log::info("Invalidating recording device {}", recordDevice.id);
         }
     }
 
     if (playbackDevice.id != -1) {
-        try {
-            playbackDevice = this->getPlaybackDevice(playbackDevice.id);
-        } catch (const std::exception& e) {
-            geode::log::info("Invalidating playback device {}: {}", playbackDevice.id, e.what());
+        this->setActivePlaybackDevice(playbackDevice.id);
+        if (playbackDevice.id == -1) {
+            geode::log::info("Invalidating playback device {}", playbackDevice.id);
         }
     }
 }
@@ -265,11 +273,21 @@ void GlobedAudioManager::setActiveRecordingDevice(int deviceId) {
         GLOBED_REQUIRE(!this->isRecording(), "attempting to change the recording device while recording")
     }
 
-    recordDevice = this->getRecordingDevice(deviceId);
+    auto dev = this->getRecordingDevice(deviceId);
+    if (dev.has_value()) {
+        recordDevice = dev.value();
+    } else {
+        recordDevice.id = -1;
+    }
 }
 
 void GlobedAudioManager::setActivePlaybackDevice(int deviceId) {
-    playbackDevice = this->getPlaybackDevice(deviceId);
+    auto dev = this->getPlaybackDevice(deviceId);
+    if (dev.has_value()) {
+        playbackDevice = dev.value();
+    } else {
+        playbackDevice.id = -1;
+    }
 }
 
 void GlobedAudioManager::recordInvokeCallback() {
@@ -277,8 +295,8 @@ void GlobedAudioManager::recordInvokeCallback() {
 
     try {
         recordCallback(recordFrame);
-    } catch (const std::exception& e) {
-        ErrorQueues::get().error(std::string("Exception in audio callback: ") + e.what());
+    } CATCH {
+        ErrorQueues::get().error(std::string("Exception in audio callback: ") + CATCH_GET_EXC);
     }
 
     recordFrame.clear();
@@ -346,8 +364,8 @@ void GlobedAudioManager::audioThreadFunc() {
 
             try {
                 recordFrame.pushOpusFrame(encoder.encode(pcmbuf));
-            } catch (const std::exception& e) {
-                ErrorQueues::get().error(std::string("Exception in audio thread: ") + e.what());
+            } CATCH {
+                ErrorQueues::get().error(std::string("Exception in audio thread: ") + CATCH_GET_EXC);
                 continue;
             }
         }
diff --git a/src/audio/manager.hpp b/src/audio/manager.hpp
index 980948cc..c3da477e 100644
--- a/src/audio/manager.hpp
+++ b/src/audio/manager.hpp
@@ -48,9 +48,9 @@ class GlobedAudioManager : GLOBED_SINGLETON(GlobedAudioManager) {
     std::vector<AudioPlaybackDevice> getPlaybackDevices();
 
     // get the record device by device ID
-    AudioRecordingDevice getRecordingDevice(int deviceId);
+    std::optional<AudioRecordingDevice> getRecordingDevice(int deviceId);
     // get the playback device by device ID
-    AudioPlaybackDevice getPlaybackDevice(int deviceId);
+    std::optional<AudioPlaybackDevice> getPlaybackDevice(int deviceId);
 
     // get the current active record device
     AudioRecordingDevice getRecordingDevice();
diff --git a/src/data/bytebuffer.hpp b/src/data/bytebuffer.hpp
index 9db30b6e..d6725703 100644
--- a/src/data/bytebuffer.hpp
+++ b/src/data/bytebuffer.hpp
@@ -362,5 +362,6 @@ class ByteBuffer {
 
     inline void boundsCheck(size_t readBytes) {
         GLOBED_REQUIRE(_position + readBytes <= _data.size(), "ByteBuffer out of bounds read")
+        // throw 1;
     }
 };
\ No newline at end of file
diff --git a/src/data/packets/all.cpp b/src/data/packets/all.cpp
index a9c4199c..06aec23e 100644
--- a/src/data/packets/all.cpp
+++ b/src/data/packets/all.cpp
@@ -24,8 +24,8 @@ std::shared_ptr<Packet> matchPacket(packetid_t packetId) {
 
         // game related
 
+        PACKET(PlayerProfilesPacket);
         PACKET(LevelDataPacket);
-        PACKET(PlayerMetadataPacket);
 #if GLOBED_VOICE_SUPPORT
         PACKET(VoiceBroadcastPacket);
 #endif
diff --git a/src/data/packets/client/game.hpp b/src/data/packets/client/game.hpp
index da0428fa..446225aa 100644
--- a/src/data/packets/client/game.hpp
+++ b/src/data/packets/client/game.hpp
@@ -2,6 +2,24 @@
 #include <data/packets/packet.hpp>
 #include <data/types/gd.hpp>
 
+class RequestPlayerProfilesPacket : public Packet {
+    GLOBED_PACKET(12000, false)
+
+    GLOBED_PACKET_ENCODE {
+        buf.writeI32(requested);
+    }
+
+    GLOBED_PACKET_DECODE_UNIMPL
+
+    RequestPlayerProfilesPacket(int requested) : requested(requested) {}
+
+    static std::shared_ptr<Packet> create(int requested) {
+        return std::make_shared<RequestPlayerProfilesPacket>(requested);
+    }
+
+    int requested;
+};
+
 class LevelJoinPacket : public Packet {
     GLOBED_PACKET(12001, false)
 
@@ -51,32 +69,6 @@ class PlayerDataPacket : public Packet {
     PlayerData data;
 };
 
-class SyncPlayerMetadataPacket : public Packet {
-    GLOBED_PACKET(12004, false)
-
-    GLOBED_PACKET_ENCODE {
-        buf.writeValue(data);
-
-        // what a dogshit fucking language that refuses to work unless i write down a whole essay in my variable declaration
-        std::function<void(ByteBuffer&, const int&)> ef = [](auto& buf, const int& val) {
-            buf.writeI32(val);
-        };
-
-        buf.writeOptionalValue(requested, ef);
-    }
-
-    GLOBED_PACKET_DECODE_UNIMPL
-
-    SyncPlayerMetadataPacket(const PlayerMetadata& data, const std::optional<int>& requested) : data(data), requested(requested) {}
-
-    static std::shared_ptr<Packet> create(const PlayerMetadata& data, const std::optional<int>& requested) {
-        return std::make_shared<SyncPlayerMetadataPacket>(data, requested);
-    }
-
-    PlayerMetadata data;
-    std::optional<int> requested;
-};
-
 #if GLOBED_VOICE_SUPPORT
 
 #include <audio/frame.hpp>
diff --git a/src/data/packets/server/game.hpp b/src/data/packets/server/game.hpp
index 0f321685..ee24857f 100644
--- a/src/data/packets/server/game.hpp
+++ b/src/data/packets/server/game.hpp
@@ -2,26 +2,26 @@
 #include <data/packets/packet.hpp>
 #include <data/types/gd.hpp>
 
-class LevelDataPacket : public Packet {
-    GLOBED_PACKET(22001, false)
+class PlayerProfilesPacket : public Packet {
+    GLOBED_PACKET(22000, false)
 
     GLOBED_PACKET_ENCODE_UNIMPL
     GLOBED_PACKET_DECODE {
-        players = buf.readValueVector<AssociatedPlayerData>();
+        players = buf.readValueVector<PlayerAccountData>();
     }
 
-    std::vector<AssociatedPlayerData> players;
+    std::vector<PlayerAccountData> players;
 };
 
-class PlayerMetadataPacket : public Packet {
-    GLOBED_PACKET(22002, false)
+class LevelDataPacket : public Packet {
+    GLOBED_PACKET(22001, false)
 
     GLOBED_PACKET_ENCODE_UNIMPL
     GLOBED_PACKET_DECODE {
-        players = buf.readValueVector<FullPlayerMetadata>();
+        players = buf.readValueVector<AssociatedPlayerData>();
     }
 
-    std::vector<FullPlayerMetadata> players;
+    std::vector<AssociatedPlayerData> players;
 };
 
 #if GLOBED_VOICE_SUPPORT
diff --git a/src/data/types/gd.hpp b/src/data/types/gd.hpp
index f4e5a4e9..8f408846 100644
--- a/src/data/types/gd.hpp
+++ b/src/data/types/gd.hpp
@@ -164,35 +164,15 @@ class PlayerRoomPreviewAccountData {
 
 class PlayerData {
 public:
-    PlayerData() {}
-    GLOBED_ENCODE {}
-    GLOBED_DECODE {}
-};
-
-class AssociatedPlayerData {
-public:
-    AssociatedPlayerData(int accountId, PlayerData data) : accountId(accountId), data(data) {}
-    AssociatedPlayerData() {}
-
-    GLOBED_ENCODE {
-        buf.writeI32(accountId);
-        buf.writeValue(data);
-    }
-
-    GLOBED_DECODE {
-        accountId = buf.readI32();
-        data = buf.readValue<PlayerData>();
-    }
-
-    int accountId;
-    PlayerData data;
-};
-
-class PlayerMetadata {
-public:
-    PlayerMetadata(uint16_t percentage, int32_t attempts) : percentage(percentage), attempts(attempts) {}
-    PlayerMetadata() {}
+    PlayerData(
+        uint16_t percentage,
+        int32_t attempts
+    )
+    : percentage(percentage),
+      attempts(attempts)
+    {}
 
+    PlayerData() {}
     GLOBED_ENCODE {
         buf.writeU16(percentage);
         buf.writeI32(attempts);
@@ -207,21 +187,21 @@ class PlayerMetadata {
     int32_t attempts;
 };
 
-class FullPlayerMetadata {
+class AssociatedPlayerData {
 public:
-    FullPlayerMetadata(const PlayerAccountData& accountData, const PlayerMetadata& metadata) : accountData(accountData), metadata(metadata) {}
-    FullPlayerMetadata() {}
+    AssociatedPlayerData(int accountId, PlayerData data) : accountId(accountId), data(data) {}
+    AssociatedPlayerData() {}
 
     GLOBED_ENCODE {
-        buf.writeValue(accountData);
-        buf.writeValue(metadata);
+        buf.writeI32(accountId);
+        buf.writeValue(data);
     }
 
     GLOBED_DECODE {
-        accountData = buf.readValue<PlayerAccountData>();
-        metadata = buf.readValue<PlayerMetadata>();
+        accountId = buf.readI32();
+        data = buf.readValue<PlayerData>();
     }
 
-    PlayerAccountData accountData;
-    PlayerMetadata metadata;
+    int accountId;
+    PlayerData data;
 };
diff --git a/src/defs/assert.hpp b/src/defs/assert.hpp
index 067d1101..6868f57c 100644
--- a/src/defs/assert.hpp
+++ b/src/defs/assert.hpp
@@ -1,6 +1,6 @@
 #pragma once
 #include "basic.hpp"
-#include <stdexcept>
+#include "util.hpp"
 
 /*
 * GLOBED_CAN_USE_SOURCE_LOCATION - 0 or 1, whether <source_location> header is available
@@ -31,7 +31,7 @@
         auto ev_msg = (message); \
         auto loc = GLOBED_SOURCE; \
         geode::log::warn("Condition failed at {}: {}", fmt::format("{}:{} ({})", loc.file_name(), loc.line(), loc.function_name()), ev_msg); \
-        throw std::runtime_error(std::string(ev_msg)); \
+        THROW(std::runtime_error(std::string(ev_msg))); \
     }
 # define GLOBED_HARD_ASSERT(condition,message) \
     if (!(condition)) [[unlikely]] { \
@@ -45,7 +45,7 @@
     if (!(condition)) [[unlikely]] { \
         auto ev_msg = (message); \
         geode::log::error(std::string("Condition failed: ") + ev_msg); \
-        throw std::runtime_error(std::string(ev_msg)); \
+        THROW(std::runtime_error(std::string(ev_msg))); \
     }
 # define GLOBED_HARD_ASSERT(condition,message) \
     if (!(condition)) [[unlikely]] { \
diff --git a/src/defs/util.hpp b/src/defs/util.hpp
index 7733d428..a3ca8cfc 100644
--- a/src/defs/util.hpp
+++ b/src/defs/util.hpp
@@ -1,5 +1,7 @@
 #pragma once
 #include "basic.hpp"
+#include "platform.hpp"
+#include <stdexcept>
 
 // singleton classes
 
@@ -20,3 +22,52 @@ class SingletonBase {
 };
 
 #define GLOBED_SINGLETON(cls) public SingletonBase<cls>
+
+// exception handler (i cannot handle this language anymore dude)
+// explanation for people with sanity:
+// tl;dr - https://discord.com/channels/911701438269386882/979402752121765898/1183817498668318891
+//
+// on android, for some reason, exception handlers crash in various weird circumstances.
+// adding -fexceptions doesn't work, and neither does anything else i've tried.
+// thanks to this workaround, whenever you throw an exception, it sets a global variable to the exception message string,
+// so that you can do `catch(...)` (shorthand - CATCH) but still get the exception message via shorthand `CATCH_GET_EXC`.
+// That makes it not thread safe, and therefore not the best practice.
+// But let's be honest, what are the odds of 2 exceptions occurring in two threads at the same time? ;)
+
+#ifdef GLOBED_ANDROID
+
+class _GExceptionStore {
+public:
+    static void throw_exc(const char* err) {
+        if (what != nullptr) {
+            delete[] what;
+        }
+
+        auto len = strlen(err);
+        what = new char[len + 1];
+        strcpy(what, err);
+        what[len] = '\0';
+    }
+
+    static const char* get() {
+        return what ? what : "no error";
+    }
+
+private:
+    inline static char* what = nullptr;
+};
+
+#define THROW(x) {\
+    ::_GExceptionStore::throw_exc(x.what()); \
+    throw 0; } // throwing 0 instead of x has a higher chance of working
+
+#define CATCH catch(...)
+#define CATCH_GET_EXC ::_GExceptionStore::get()
+
+#else // GLOBED_ANDROID
+
+#define THROW(x) throw x;
+#define CATCH catch(const std::runtime_error& _caughtException)
+#define CATCH_GET_EXC _caughtException.what()
+
+#endif // GLOBED_ANDROID
diff --git a/src/managers/central_server_manager.cpp b/src/managers/central_server_manager.cpp
index e7788131..26714e61 100644
--- a/src/managers/central_server_manager.cpp
+++ b/src/managers/central_server_manager.cpp
@@ -126,8 +126,8 @@ void CentralServerManager::reload() {
 
         ByteBuffer buf(decoded);
         *servers = buf.readValueVector<CentralServer>();
-    } catch (const std::exception& e) {
-        ErrorQueues::get().warn(std::string("failed to load servers: ") + e.what());
+    } CATCH {
+        ErrorQueues::get().warn(std::string("failed to load servers: ") + CATCH_GET_EXC);
     }
 }
 
diff --git a/src/managers/game_server_manager.cpp b/src/managers/game_server_manager.cpp
index 13d5cdf6..e13bfa2b 100644
--- a/src/managers/game_server_manager.cpp
+++ b/src/managers/game_server_manager.cpp
@@ -62,7 +62,7 @@ std::optional<GameServer> GameServerManager::getActiveServer() {
 GameServer GameServerManager::getServer(const std::string& id) {
     auto data = _data.lock();
     if (!data->servers.contains(id)) {
-        throw std::runtime_error(std::string("invalid server ID, no such server exists: ") + id);
+        THROW(std::runtime_error(std::string("invalid server ID, no such server exists: ") + id));
     }
 
     return data->servers.at(id).server;
diff --git a/src/managers/profile_cache.cpp b/src/managers/profile_cache.cpp
index f99ca009..7672a556 100644
--- a/src/managers/profile_cache.cpp
+++ b/src/managers/profile_cache.cpp
@@ -2,11 +2,11 @@
 
 ProfileCacheManager::ProfileCacheManager() {}
 
-void ProfileCacheManager::insert(const FullPlayerMetadata& data) {
-    cache[data.accountData.id] = data;
+void ProfileCacheManager::insert(const PlayerAccountData& data) {
+    cache[data.id] = data;
 }
 
-std::optional<FullPlayerMetadata> ProfileCacheManager::getData(int32_t accountId) {
+std::optional<PlayerAccountData> ProfileCacheManager::getData(int32_t accountId) {
     if (cache.contains(accountId)) {
         return cache.at(accountId);
     }
diff --git a/src/managers/profile_cache.hpp b/src/managers/profile_cache.hpp
index 79ebb166..c30b4bec 100644
--- a/src/managers/profile_cache.hpp
+++ b/src/managers/profile_cache.hpp
@@ -7,8 +7,8 @@ class ProfileCacheManager : GLOBED_SINGLETON(ProfileCacheManager) {
 public:
     ProfileCacheManager();
 
-    void insert(const FullPlayerMetadata& data);
-    std::optional<FullPlayerMetadata> getData(int32_t accountId);
+    void insert(const PlayerAccountData& data);
+    std::optional<PlayerAccountData> getData(int32_t accountId);
     void clear();
 
     // gather player's icons and call `setOwnData`;
@@ -18,6 +18,6 @@ class ProfileCacheManager : GLOBED_SINGLETON(ProfileCacheManager) {
 
     bool pendingChanges = false;
 private:
-    std::unordered_map<int32_t, FullPlayerMetadata> cache;
+    std::unordered_map<int32_t, PlayerAccountData> cache;
     PlayerIconData ownData;
 };
\ No newline at end of file
diff --git a/src/net/game_socket.cpp b/src/net/game_socket.cpp
index c7369720..8ed9ff91 100644
--- a/src/net/game_socket.cpp
+++ b/src/net/game_socket.cpp
@@ -53,9 +53,9 @@ std::shared_ptr<Packet> GameSocket::recvPacket() {
 
     try {
         packet->decode(buf);
-    } catch (const std::exception& e) {
-        geode::log::warn("Decoding packet ID {} failed: {}", header.id, e.what());
-        throw;
+    } CATCH {
+        auto msg = fmt::format("Decoding packet ID {} failed: {}", header.id, CATCH_GET_EXC);
+        THROW(std::runtime_error(msg));
     }
 
     return packet;
diff --git a/src/net/network_manager.cpp b/src/net/network_manager.cpp
index d36ed310..5c253229 100644
--- a/src/net/network_manager.cpp
+++ b/src/net/network_manager.cpp
@@ -80,8 +80,8 @@ NetworkManager::~NetworkManager() {
         log::debug("disconnecting from the server..");
         try {
             this->disconnect(false);
-        } catch (const std::exception& e) {
-            log::warn("error trying to disconnect: {}", e.what());
+        } CATCH {
+            log::warn("error trying to disconnect: {}", CATCH_GET_EXC);
         }
     }
 
@@ -120,9 +120,9 @@ void NetworkManager::connectWithView(const GameServer& gsview) {
     try {
         this->connect(gsview.address.ip, gsview.address.port);
         GameServerManager::get().setActive(gsview.id);
-    } catch (const std::exception& e) {
+    } CATCH {
         this->disconnect(true);
-        ErrorQueues::get().error(std::string("Connection failed: ") + e.what());
+        ErrorQueues::get().error(std::string("Connection failed: ") + CATCH_GET_EXC);
     }
 }
 
@@ -132,9 +132,9 @@ void NetworkManager::connectStandalone() {
     try {
         this->connect(server.address.ip, server.address.port, true);
         GameServerManager::get().setActive(GameServerManager::STANDALONE_ID);
-    } catch (const std::exception& e) {
+    } CATCH {
         this->disconnect(true);
-        ErrorQueues::get().error(std::string("Connection failed: ") + e.what());
+        ErrorQueues::get().error(std::string("Connection failed: ") + CATCH_GET_EXC);
     }
 }
 
@@ -202,8 +202,8 @@ void NetworkManager::threadMainFunc() {
                         try {
                             auto pingId = sm.startPing(serverId);
                             gameSocket.sendPacketTo(PingPacket::create(pingId), server.address.ip, server.address.port);
-                        } catch (const std::exception& e) {
-                            ErrorQueues::get().warn(e.what());
+                        } CATCH {
+                            ErrorQueues::get().warn(CATCH_GET_EXC);
                         }
                     }
                 }
@@ -215,8 +215,8 @@ void NetworkManager::threadMainFunc() {
         for (auto packet : messages) {
             try {
                 gameSocket.sendPacket(packet);
-            } catch (const std::exception& e) {
-                ErrorQueues::get().error(e.what());
+            } CATCH {
+                ErrorQueues::get().error(CATCH_GET_EXC);
             }
         }
     }
@@ -235,8 +235,8 @@ void NetworkManager::threadRecvFunc() {
 
         try {
             packet = gameSocket.recvPacket();
-        } catch (const std::exception& e) {
-            ErrorQueues::get().debugWarn(fmt::format("failed to receive a packet: {}", e.what()));
+        } CATCH {
+            ErrorQueues::get().debugWarn(fmt::format("failed to receive a packet: {}", CATCH_GET_EXC));
             continue;
         }
 
@@ -291,8 +291,8 @@ void NetworkManager::maybeDisconnectIfDead() {
         ErrorQueues::get().error("The server you were connected to is not responding to any requests. <cy>You have been disconnected.</c>");
         try {
             this->disconnect();
-        } catch (const std::exception& e) {
-            log::warn("failed to disconnect from a dead server: {}", e.what());
+        } CATCH {
+            log::warn("failed to disconnect from a dead server: {}", CATCH_GET_EXC);
         }
     }
 }
diff --git a/src/ui/hooks/play_layer.hpp b/src/ui/hooks/play_layer.hpp
index 5eb4db23..17a044f0 100644
--- a/src/ui/hooks/play_layer.hpp
+++ b/src/ui/hooks/play_layer.hpp
@@ -50,16 +50,16 @@ class $modify(GlobedPlayLayer, PlayLayer) {
         // set the audio device
         try {
             GlobedAudioManager::get().setActiveRecordingDevice(m_fields->settings.audioDevice);
-        } catch (const std::exception& e) {
+        } CATCH {
             // try default device, if we have no mic then just do nothing
             try {
                 GlobedAudioManager::get().setActiveRecordingDevice(0);
-            } catch (const std::exception& e) {}
+            } CATCH {}
         }
 
-        // send LevelJoinPacket and SyncPlayerMetadataPacket
+        // send LevelJoinPacket and RequestPlayerProfilesPacket
         nm.send(LevelJoinPacket::create(m_level->m_levelID));
-        nm.send(SyncPlayerMetadataPacket::create(this->gatherPlayerMeta(), std::nullopt));
+        nm.send(RequestPlayerProfilesPacket::create(0));
 
         // send SyncIconsPacket if our icons have changed since the last time we sent it
         auto& pcm = ProfileCacheManager::get();
@@ -91,7 +91,7 @@ class $modify(GlobedPlayLayer, PlayLayer) {
         auto& nm = NetworkManager::get();
 
         // clean up the listeners
-        nm.removeListener<PlayerMetadataPacket>();
+        nm.removeListener<PlayerProfilesPacket>();
         nm.removeListener<LevelDataPacket>();
         nm.removeListener<VoiceBroadcastPacket>();
 
@@ -106,7 +106,7 @@ class $modify(GlobedPlayLayer, PlayLayer) {
     void setupEventListeners() {
         auto& nm = NetworkManager::get();
 
-        nm.addListener<PlayerMetadataPacket>([](PlayerMetadataPacket* packet) {
+        nm.addListener<PlayerProfilesPacket>([](PlayerProfilesPacket* packet) {
             auto& pcm = ProfileCacheManager::get();
             for (auto& player : packet->players) {
                 pcm.insert(player);
@@ -195,15 +195,6 @@ class $modify(GlobedPlayLayer, PlayLayer) {
         NetworkManager::get().send(PlayerDataPacket::create(this->gatherPlayerData()));
     }
 
-    // selSendSyncMeta - runs once a minute
-    void selSendSyncMeta(float) {
-        if (!this->established()) return;
-        if (!this->isCurrentPlayLayer()) return;
-        if (!this->accountForSpeedhack(1, 60.0f, 0.95f))
-
-        NetworkManager::get().send(SyncPlayerMetadataPacket::create(this->gatherPlayerMeta(), std::nullopt));
-    }
-
     /* private utilities */
 
     bool established() {
@@ -212,11 +203,7 @@ class $modify(GlobedPlayLayer, PlayLayer) {
     }
 
     PlayerData gatherPlayerData() {
-        return PlayerData();
-    }
-
-    PlayerMetadata gatherPlayerMeta() {
-        return PlayerMetadata(m_level->m_normalPercent.value(), m_level->m_attempts); // TODO verify this is correct
+        return PlayerData(m_level->m_normalPercent.value(), m_level->m_attempts);
     }
 
     void handlePlayerJoin(int playerId) {
@@ -227,8 +214,7 @@ class $modify(GlobedPlayLayer, PlayLayer) {
             ErrorQueues::get().error(std::string("Failed to prepare audio stream: ") + e.what());
         }
 #endif // GLOBED_VOICE_SUPPORT
-
-        NetworkManager::get().send(SyncPlayerMetadataPacket::create(this->gatherPlayerMeta(), playerId));
+        NetworkManager::get().send(RequestPlayerProfilesPacket::create(playerId));
     }
 
     void handlePlayerLeave(int playerId) {
@@ -249,11 +235,16 @@ class $modify(GlobedPlayLayer, PlayLayer) {
         auto ts = sched->getTimeScale();
         if (!util::math::equal(ts, m_fields->lastKnownTimeScale)) {
             sched->unscheduleSelector(schedule_selector(GlobedPlayLayer::selSendPlayerData), this);
-            sched->unscheduleSelector(schedule_selector(GlobedPlayLayer::selSendSyncMeta), this);
             this->rescheduleSenders();
         }
 
         auto now = util::time::now();
+
+        if (!m_fields->lastSentPacket.contains(uniqueKey)) {
+            m_fields->lastSentPacket[uniqueKey] = now;
+            return true;
+        }
+
         auto lastSent = m_fields->lastSentPacket[uniqueKey];
 
         auto passed = util::time::asMillis(now - lastSent);
@@ -274,10 +265,8 @@ class $modify(GlobedPlayLayer, PlayLayer) {
         m_fields->lastKnownTimeScale = timescale;
 
         float pdInterval = (1.0f / m_fields->configuredTps) * timescale;
-        float smInterval = 60.0f * timescale;
 
         sched->scheduleSelector(schedule_selector(GlobedPlayLayer::selSendPlayerData), this, pdInterval, false);
-        sched->scheduleSelector(schedule_selector(GlobedPlayLayer::selSendSyncMeta), this, smInterval, false);
     }
 
     // TODO remove if impostor playlayer gets fixed
diff --git a/src/ui/menu/main/globed_menu_layer.cpp b/src/ui/menu/main/globed_menu_layer.cpp
index 5de5173f..b4fdf390 100644
--- a/src/ui/menu/main/globed_menu_layer.cpp
+++ b/src/ui/menu/main/globed_menu_layer.cpp
@@ -249,8 +249,8 @@ void GlobedMenuLayer::requestServerList() {
                             server["region"].as_string()
                         );
                     }
-                } catch (const std::exception& e) {
-                    ErrorQueues::get().error("Failed to parse server list: <cy>{}</c>", e.what());
+                } CATCH {
+                    ErrorQueues::get().error("Failed to parse server list: <cy>{}</c>", CATCH_GET_EXC);
                     gsm.clear();
                 }
             }
diff --git a/src/ui/menu/main/server_list_cell.cpp b/src/ui/menu/main/server_list_cell.cpp
index a2dc8c13..5c1834cb 100644
--- a/src/ui/menu/main/server_list_cell.cpp
+++ b/src/ui/menu/main/server_list_cell.cpp
@@ -114,11 +114,11 @@ void ServerListCell::requestTokenAndConnect() {
     std::string authcode;
     try {
         authcode = am.generateAuthCode();
-    } catch (const std::exception& e) {
+    } CATCH {
         // invalid authkey? clear it so the user can relog. happens if user changes their password
         ErrorQueues::get().error(fmt::format(
             "Failed to generate authcode! Please try to login and connect again.\n\nReason for the error: <cy>{}</c>",
-            e.what()
+            CATCH_GET_EXC
         ));
         am.clearAuthKey();
         return;
diff --git a/src/util/net.cpp b/src/util/net.cpp
index 166c0c33..71928c94 100644
--- a/src/util/net.cpp
+++ b/src/util/net.cpp
@@ -55,7 +55,7 @@ namespace util::net {
     [[noreturn]] void throwLastError() {
         auto message = lastErrorString();
         geode::log::error(std::string("Throwing network exception: ") + message);
-        throw std::runtime_error(std::string("Network error: ") + message);
+        THROW(std::runtime_error(std::string("Network error: ") + message));
     }
 
     std::string webUserAgent() {