diff --git a/README.md b/README.md
index c2bc67225..e81a2287b 100644
--- a/README.md
+++ b/README.md
@@ -69,8 +69,6 @@ See [the issues page](https://github.com/AnthonyTornetta/Cosmos/issues) for the
       - [ ] Perhaps done via a sphere surrounding the planet that always faces the nearest star
     - [ ] Sun-set skybox
     - [ ] Night-side skybox
-  - [ ] Caves
-    - [ ] Lit up underground blocks
 - [ ] Animated textures
 - [ ] Sounds
   - [x] Laser cannon fire
@@ -80,10 +78,10 @@ See [the issues page](https://github.com/AnthonyTornetta/Cosmos/issues) for the
   - [x] Background space music
   - [ ] Block break
 - [ ] Place rotated blocks
-- [ ] Multiblock machines (if enough time)
-  - [ ] Revamp power generation to use reactor multiblock structure
-  - [ ] Colored laser
-    - [ ] Colored glass placed in front of laser
+- [x] Multiblock machines
+  - [x] Revamp power generation to use reactor multiblock structure
+- [ ] Colored laser
+  - [ ] Colored glass placed in front of laser
 - [x] Inventory GUI
   - [x] Able to open inventory
   - [x] Abstract the 3d block GUI camera
diff --git a/cosmos_client/assets/blocks/laser_cannon.json b/cosmos_client/assets/blocks/laser_cannon.json
index a992386ae..073e9414b 100644
--- a/cosmos_client/assets/blocks/laser_cannon.json
+++ b/cosmos_client/assets/blocks/laser_cannon.json
@@ -1,7 +1,7 @@
 {
     "texture": {
-        "back": "laser_cannon_back",
-        "front": "laser_cannon_front",
+        "front": "laser_cannon_back",
+        "back": "laser_cannon_front",
         "left": "laser_cannon_left_right",
         "right": "laser_cannon_left_right",
         "top": "laser_cannon_top_bottom",
diff --git a/cosmos_client/assets/blocks/reactor_controller.json b/cosmos_client/assets/blocks/reactor_controller.json
new file mode 100644
index 000000000..806b5dbe8
--- /dev/null
+++ b/cosmos_client/assets/blocks/reactor_controller.json
@@ -0,0 +1,6 @@
+{
+    "texture": {
+        "all": "reactor_casing",
+        "back": "reactor_controller"
+    }
+}
\ No newline at end of file
diff --git a/cosmos_client/assets/images/blocks/reactor_casing.png b/cosmos_client/assets/images/blocks/reactor_casing.png
new file mode 100644
index 000000000..c22c71a89
Binary files /dev/null and b/cosmos_client/assets/images/blocks/reactor_casing.png differ
diff --git a/cosmos_client/assets/images/blocks/reactor_cell.png b/cosmos_client/assets/images/blocks/reactor_cell.png
new file mode 100644
index 000000000..489e5f396
Binary files /dev/null and b/cosmos_client/assets/images/blocks/reactor_cell.png differ
diff --git a/cosmos_client/assets/images/blocks/reactor_controller.png b/cosmos_client/assets/images/blocks/reactor_controller.png
new file mode 100644
index 000000000..4d09d39ea
Binary files /dev/null and b/cosmos_client/assets/images/blocks/reactor_controller.png differ
diff --git a/cosmos_client/assets/images/blocks/reactor_window.png b/cosmos_client/assets/images/blocks/reactor_window.png
new file mode 100644
index 000000000..d98df825b
Binary files /dev/null and b/cosmos_client/assets/images/blocks/reactor_window.png differ
diff --git a/cosmos_client/assets/lang/blocks/en_us.lang b/cosmos_client/assets/lang/blocks/en_us.lang
index 332b3a64a..40c7c6712 100644
--- a/cosmos_client/assets/lang/blocks/en_us.lang
+++ b/cosmos_client/assets/lang/blocks/en_us.lang
@@ -41,3 +41,7 @@ cosmos:ship_hull_dark_red=Dark Red Ship Hull
 cosmos:ship_hull_yellow=Yellow Ship Hull
 cosmos:ship_hull_dark_yellow=Dark Yellow Ship Hull
 cosmos:ship_hull_mint=Mint Ship Hull
+cosmos:reactor_controller=Reactor Controller
+cosmos:reactor_casing=Reactor Casing
+cosmos:reactor_window=Reactor Window
+cosmos:reactor_cell=Reactor Power Cell
\ No newline at end of file
diff --git a/cosmos_client/src/events/block/block_events.rs b/cosmos_client/src/events/block/block_events.rs
index a245ea7c2..f7771aeea 100644
--- a/cosmos_client/src/events/block/block_events.rs
+++ b/cosmos_client/src/events/block/block_events.rs
@@ -3,7 +3,7 @@
 use bevy::prelude::*;
 use bevy_renet::renet::RenetClient;
 use cosmos_core::{
-    block::BlockFace,
+    block::{block_events::BlockInteractEvent, BlockFace},
     netty::{client_reliable_messages::ClientReliableMessages, cosmos_encoder, NettyChannelClient},
     structure::structure_block::StructureBlock,
 };
@@ -34,15 +34,6 @@ pub struct BlockPlaceEvent {
     pub block_up: BlockFace,
 }
 
-#[derive(Debug, Event)]
-/// Sent whenever the player interacts with a block
-pub struct BlockInteractEvent {
-    /// The structure this block is on
-    pub structure_entity: Entity,
-    /// block coords
-    pub coords: StructureBlock,
-}
-
 fn handle_block_break(
     mut event_reader: EventReader<BlockBreakEvent>,
     mut client: ResMut<RenetClient>,
@@ -88,7 +79,7 @@ fn handle_block_interact(
             NettyChannelClient::Reliable,
             cosmos_encoder::serialize(&ClientReliableMessages::InteractWithBlock {
                 structure_entity: network_mapping.server_from_client(&ev.structure_entity).unwrap(),
-                block: ev.coords,
+                block: ev.structure_block,
             }),
         );
     }
diff --git a/cosmos_client/src/interactions/block_interactions.rs b/cosmos_client/src/interactions/block_interactions.rs
index d7e534057..a209d8f39 100644
--- a/cosmos_client/src/interactions/block_interactions.rs
+++ b/cosmos_client/src/interactions/block_interactions.rs
@@ -3,7 +3,7 @@
 use bevy::prelude::*;
 use bevy_rapier3d::prelude::{QueryFilter, RapierContext, DEFAULT_WORLD_ID};
 use cosmos_core::{
-    block::BlockFace,
+    block::{block_events::BlockInteractEvent, BlockFace},
     blockitems::BlockItems,
     inventory::Inventory,
     item::Item,
@@ -58,7 +58,7 @@ fn process_player_interaction(
     }
 
     // this fails if the player is a pilot
-    let Ok((player_body, mut inventory, looking_at)) = player_body.get_single_mut() else {
+    let Ok((player_entity, mut inventory, looking_at)) = player_body.get_single_mut() else {
         return;
     };
 
@@ -75,7 +75,7 @@ fn process_player_interaction(
         cam_trans.forward(),
         10.0,
         true,
-        QueryFilter::new().exclude_rigid_body(player_body), // don't want to hit yourself
+        QueryFilter::new().exclude_rigid_body(player_entity), // don't want to hit yourself
     ) else {
         if let Some(mut looking_at) = looking_at {
             looking_at.looking_at_block = None;
@@ -110,7 +110,7 @@ fn process_player_interaction(
         if let Some(mut looking_at) = looking_at {
             looking_at.looking_at_block = looking_at_block;
         } else {
-            commands.entity(player_body).insert(LookingAt { looking_at_block });
+            commands.entity(player_entity).insert(LookingAt { looking_at_block });
         }
     }
 
@@ -163,7 +163,8 @@ fn process_player_interaction(
         if let Ok(coords) = structure.relative_coords_to_local_coords_checked(point.x, point.y, point.z) {
             interact_writer.send(BlockInteractEvent {
                 structure_entity: structure.get_entity().unwrap(),
-                coords: StructureBlock::new(coords),
+                structure_block: StructureBlock::new(coords),
+                interactor: player_entity,
             });
         }
     }
diff --git a/cosmos_client/src/netty/gameplay/receiver.rs b/cosmos_client/src/netty/gameplay/receiver.rs
index d5d60f2de..fdf3eff51 100644
--- a/cosmos_client/src/netty/gameplay/receiver.rs
+++ b/cosmos_client/src/netty/gameplay/receiver.rs
@@ -56,7 +56,10 @@ use crate::{
     rendering::MainCamera,
     state::game_state::GameState,
     structure::{planet::client_planet_builder::ClientPlanetBuilder, ship::client_ship_builder::ClientShipBuilder},
-    ui::crosshair::CrosshairOffset,
+    ui::{
+        crosshair::CrosshairOffset,
+        message::{HudMessage, HudMessages},
+    },
 };
 
 #[derive(Component)]
@@ -99,9 +102,16 @@ fn update_crosshair(
     }
 }
 
+#[derive(Resource, Debug, Clone, Copy)]
+struct RequestedEntity {
+    server_entity: Entity,
+    client_entity: Entity,
+    seconds_since_request: f32,
+}
+
 #[derive(Resource, Debug, Default)]
 pub(crate) struct RequestedEntities {
-    entities: Vec<(Entity, f32)>,
+    entities: Vec<RequestedEntity>,
 }
 
 #[derive(Component, Debug, Clone, Copy, Eq, PartialEq, PartialOrd, Ord)]
@@ -182,20 +192,21 @@ pub(crate) fn client_sync_players(
     time: Res<Time>,
     local_player: Query<Entity, With<LocalPlayer>>,
 
+    mut hud_messages: ResMut<HudMessages>,
+
     (mut build_mode_enter, mut build_mode_exit): (EventWriter<EnterBuildModeEvent>, EventWriter<ExitBuildModeEvent>),
 ) {
     let client_id = transport.client_id();
 
-    let mut new_entities = Vec::with_capacity(requested_entities.entities.len());
-
-    for ent in requested_entities.entities.iter_mut() {
-        ent.1 += time.delta_seconds();
-        if ent.1 < 10.0 {
-            new_entities.push(*ent);
+    requested_entities.entities.retain_mut(|x| {
+        x.seconds_since_request += time.delta_seconds();
+        if x.seconds_since_request < 10.0 {
+            true
+        } else {
+            commands.entity(x.client_entity).despawn_recursive();
+            false
         }
-    }
-
-    requested_entities.entities = new_entities;
+    });
 
     while let Some(message) = client.receive_message(NettyChannelServer::Unreliable) {
         let msg: ServerUnreliableMessages = cosmos_encoder::deserialize(&message).unwrap();
@@ -240,8 +251,15 @@ pub(crate) fn client_sync_players(
                                 commands.entity(entity).insert((loc, body.create_velocity(), LerpTowards(body)));
                             }
                         }
-                    } else if !requested_entities.entities.iter().any(|x| x.0 == *server_entity) {
-                        requested_entities.entities.push((*server_entity, 0.0));
+                    } else if !requested_entities.entities.iter().any(|x| x.server_entity == *server_entity) {
+                        let client_entity = commands.spawn_empty().id();
+
+                        requested_entities.entities.push(RequestedEntity {
+                            server_entity: *server_entity,
+                            client_entity,
+                            seconds_since_request: 0.0,
+                        });
+                        network_mapping.add_mapping(client_entity, *server_entity);
 
                         client.send_message(
                             NettyChannelClient::Reliable,
@@ -273,7 +291,7 @@ pub(crate) fn client_sync_players(
                 // Prevents creation of duplicate players
                 if lobby.players.contains_key(&id) {
                     warn!("DUPLICATE PLAYER RECEIVED {id}");
-                    break;
+                    continue;
                 }
 
                 let Ok(body) = body.map(&network_mapping) else {
@@ -392,22 +410,17 @@ pub(crate) fn client_sync_players(
                 biosphere,
                 location,
             } => {
-                if network_mapping.contains_server_entity(server_entity) {
-                    warn!("Got duplicate planet! Is the server lagging?");
-                    break;
-                }
+                let Some(entity) = network_mapping.client_from_server(&server_entity) else {
+                    continue;
+                };
 
-                let mut entity_cmds = commands.spawn_empty();
+                let mut entity_cmds = commands.entity(entity);
                 let mut structure = Structure::Dynamic(DynamicStructure::new(dimensions));
 
                 let builder = ClientPlanetBuilder::default();
                 builder.insert_planet(&mut entity_cmds, location, &mut structure, planet);
 
                 entity_cmds.insert((structure, BiosphereMarker::new(biosphere)));
-
-                let entity = entity_cmds.id();
-
-                network_mapping.add_mapping(entity, server_entity);
             }
             ServerReliableMessages::Ship {
                 entity: server_entity,
@@ -415,10 +428,9 @@ pub(crate) fn client_sync_players(
                 dimensions,
                 chunks_needed,
             } => {
-                if network_mapping.contains_server_entity(server_entity) {
-                    warn!("Got duplicate ship! Is the server lagging?");
-                    break;
-                }
+                let Some(entity) = network_mapping.client_from_server(&server_entity) else {
+                    continue;
+                };
 
                 let Ok(body) = body.map(&network_mapping) else {
                     continue;
@@ -433,7 +445,7 @@ pub(crate) fn client_sync_players(
                     }
                 };
 
-                let mut entity_cmds = commands.spawn_empty();
+                let mut entity_cmds = commands.entity(entity);
                 let mut structure = Structure::Full(FullStructure::new(dimensions));
 
                 let builder = ClientShipBuilder::default();
@@ -441,10 +453,6 @@ pub(crate) fn client_sync_players(
 
                 entity_cmds.insert((structure, chunks_needed));
 
-                let entity = entity_cmds.id();
-
-                network_mapping.add_mapping(entity, server_entity);
-
                 client.send_message(
                     NettyChannelClient::Reliable,
                     cosmos_encoder::serialize(&ClientReliableMessages::PilotQuery {
@@ -488,7 +496,7 @@ pub(crate) fn client_sync_players(
                 }
             }
             ServerReliableMessages::MOTD { motd } => {
-                info!("Server MOTD: {motd}");
+                hud_messages.display_message(motd.into());
             }
             ServerReliableMessages::BlockChange {
                 blocks_changed_packet,
@@ -616,6 +624,20 @@ pub(crate) fn client_sync_players(
                     commands.entity(player_entity).insert(build_mode);
                 }
             }
+            ServerReliableMessages::InvalidReactor { reason } => {
+                hud_messages.display_message(HudMessage::with_colored_string(
+                    format!("Invalid reactor setup: {reason}"),
+                    Color::ORANGE_RED,
+                ));
+            }
+            ServerReliableMessages::Reactors { reactors, structure } => {
+                if let Some(structure_entity) = network_mapping.client_from_server(&structure) {
+                    commands.entity(structure_entity).insert(reactors);
+                }
+            }
+            ServerReliableMessages::RequestedEntityReceived(entity) => {
+                requested_entities.entities.retain(|x| x.server_entity != entity);
+            }
         }
     }
 }
diff --git a/cosmos_client/src/structure/asteroid/sync.rs b/cosmos_client/src/structure/asteroid/sync.rs
index 898ebe77c..621805237 100644
--- a/cosmos_client/src/structure/asteroid/sync.rs
+++ b/cosmos_client/src/structure/asteroid/sync.rs
@@ -20,13 +20,21 @@ fn receive_asteroids(
     mut client: ResMut<RenetClient>,
     query_loc: Query<&Location>,
     mut commands: Commands,
-    mut network_mapping: ResMut<NetworkMapping>,
+    network_mapping: ResMut<NetworkMapping>,
 ) {
     while let Some(message) = client.receive_message(NettyChannelServer::Asteroid) {
         let msg: AsteroidServerMessages = cosmos_encoder::deserialize(&message).unwrap();
 
         match msg {
-            AsteroidServerMessages::Asteroid { entity, body, dimensions } => {
+            AsteroidServerMessages::Asteroid {
+                entity: server_entity,
+                body,
+                dimensions,
+            } => {
+                let Some(entity) = network_mapping.client_from_server(&server_entity) else {
+                    continue;
+                };
+
                 let Ok(body) = body.map(&network_mapping) else {
                     continue;
                 };
@@ -40,7 +48,7 @@ fn receive_asteroids(
                     }
                 };
 
-                let mut entity_cmds = commands.spawn_empty();
+                let mut entity_cmds = commands.entity(entity);
 
                 let mut structure = Structure::Full(FullStructure::new(dimensions));
 
@@ -49,8 +57,6 @@ fn receive_asteroids(
                 builder.insert_asteroid(&mut entity_cmds, location, &mut structure);
 
                 entity_cmds.insert(structure);
-
-                network_mapping.add_mapping(entity_cmds.id(), entity);
             }
         }
     }
diff --git a/cosmos_client/src/structure/chunk_retreiver.rs b/cosmos_client/src/structure/chunk_retreiver.rs
index 956e04126..808673263 100644
--- a/cosmos_client/src/structure/chunk_retreiver.rs
+++ b/cosmos_client/src/structure/chunk_retreiver.rs
@@ -19,11 +19,11 @@ use crate::NetworkMapping;
 pub struct NeedsPopulated;
 
 fn populate_structures(
-    mut commands: Commands,
     player_location: Query<&Location, With<LocalPlayer>>,
     query: Query<(Entity, &Location), (With<NeedsPopulated>, With<Structure>)>,
     mut client: ResMut<RenetClient>,
     network_mapping: Res<NetworkMapping>,
+    mut commands: Commands,
 ) {
     let Ok(player_location) = player_location.get_single() else {
         return;
diff --git a/cosmos_client/src/structure/ship/build_mode.rs b/cosmos_client/src/structure/ship/build_mode.rs
index e25f3ce05..b38fd41c1 100644
--- a/cosmos_client/src/structure/ship/build_mode.rs
+++ b/cosmos_client/src/structure/ship/build_mode.rs
@@ -17,7 +17,7 @@ use cosmos_core::{
         coordinates::BlockCoordinate,
         ship::{
             build_mode::{BuildAxis, BuildMode, ExitBuildModeEvent},
-            core::DieWithStructure,
+            core::DespawnWithStructure,
         },
         Structure,
     },
@@ -242,7 +242,7 @@ fn change_visuals(
             visuals.0 = Some(
                 ecmds
                     .spawn((
-                        DieWithStructure,
+                        DespawnWithStructure,
                         NotShadowCaster,
                         NotShadowReceiver,
                         Name::new("X Axis - build mode"),
@@ -273,7 +273,7 @@ fn change_visuals(
             visuals.1 = Some(
                 ecmds
                     .spawn((
-                        DieWithStructure,
+                        DespawnWithStructure,
                         NotShadowCaster,
                         NotShadowReceiver,
                         Name::new("Y Axis - build mode"),
@@ -304,7 +304,7 @@ fn change_visuals(
             visuals.2 = Some(
                 ecmds
                     .spawn((
-                        DieWithStructure,
+                        DespawnWithStructure,
                         NotShadowCaster,
                         NotShadowReceiver,
                         Name::new("Z Axis - build mode"),
diff --git a/cosmos_client/src/ui/message.rs b/cosmos_client/src/ui/message.rs
new file mode 100644
index 000000000..03e06030b
--- /dev/null
+++ b/cosmos_client/src/ui/message.rs
@@ -0,0 +1,210 @@
+//! Displays any messages the player needs to see
+
+use std::{collections::VecDeque, time::Duration};
+
+use bevy::{
+    prelude::{
+        in_state, App, AssetServer, BuildChildren, Color, Commands, Component, DespawnRecursiveExt, IntoSystemConfigs, Name, NodeBundle,
+        Parent, Query, Res, ResMut, Resource, TextBundle, Update,
+    },
+    text::{Text, TextAlignment, TextSection, TextStyle},
+    time::Time,
+    ui::{JustifyContent, PositionType, Style, Val},
+};
+
+use crate::state::game_state::GameState;
+
+const HUD_DISPLAY_DURATION: Duration = Duration::from_secs(7);
+const FADE_DURATION: Duration = Duration::from_secs(3);
+
+#[derive(Debug, Clone)]
+/// A way of describing colored text used in the HUD message
+pub struct RichText {
+    /// The color this text should be (default is white)
+    pub color: Color,
+    /// The text to display
+    pub text: String,
+}
+
+impl RichText {
+    /// Creates a new rich text with these fields
+    pub fn new(text: String, color: Color) -> Self {
+        Self { color, text }
+    }
+}
+
+impl Default for RichText {
+    fn default() -> Self {
+        Self {
+            color: Color::WHITE,
+            text: "".to_owned(),
+        }
+    }
+}
+
+impl From<String> for RichText {
+    fn from(text: String) -> Self {
+        Self {
+            text,
+            ..Default::default()
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+/// A message that can be displayed in the HUD
+pub struct HudMessage {
+    text: Vec<RichText>,
+}
+
+impl From<String> for HudMessage {
+    fn from(value: String) -> Self {
+        Self::with_string(value)
+    }
+}
+
+impl HudMessage {
+    /// The text will be displayed in the order it is given
+    ///
+    /// Useful for creating multicolored strings
+    pub fn new(text: Vec<RichText>) -> Self {
+        Self { text }
+    }
+
+    /// Creates this from a string - same as `HudMessage::from(String)`
+    pub fn with_string(text: String) -> Self {
+        Self { text: vec![text.into()] }
+    }
+
+    /// Creates this from a colored string
+    pub fn with_colored_string(text: String, color: Color) -> Self {
+        Self {
+            text: vec![RichText { text, color }],
+        }
+    }
+}
+
+#[derive(Debug)]
+struct CurrentDisplayedHudCache {
+    time_needs_reset: bool,
+    cached_message: HudMessage,
+}
+
+#[derive(Resource, Debug, Default)]
+/// Used to interact with messages shown to the user in the above-hotbar dislay area.
+pub struct HudMessages(VecDeque<HudMessage>, Option<CurrentDisplayedHudCache>);
+
+impl HudMessages {
+    /// Adds this HUD message to the queue of messages to be displayed, and will display it when it is ready.
+    ///
+    /// Note that this will check for hud messages with the same text and prevent duplicate entries
+    pub fn display_message(&mut self, message: HudMessage) {
+        let check_duplicate =
+            |m: &HudMessage| m.text.len() == message.text.len() && m.text.iter().zip(message.text.iter()).all(|(x, y)| x.text == y.text);
+
+        if let Some(currently_displayed_hud_cache) = self.1.as_mut() {
+            if check_duplicate(&currently_displayed_hud_cache.cached_message) {
+                currently_displayed_hud_cache.time_needs_reset = true;
+                return;
+            }
+        }
+
+        if self.0.iter().any(check_duplicate) {
+            return;
+        }
+
+        self.0.push_back(message);
+    }
+}
+
+#[derive(Component, Debug, Clone, Copy)]
+struct ShownHudMessage {
+    time_created: f32,
+}
+
+fn display_hud_messages(
+    mut commands: Commands,
+    mut shown_hud_message: Query<(&Parent, &mut ShownHudMessage, &mut Text)>,
+    mut hud_messages: ResMut<HudMessages>,
+    asset_server: Res<AssetServer>,
+    time: Res<Time>,
+) {
+    if let Ok((parent, mut shown_hud_message, mut text)) = shown_hud_message.get_single_mut() {
+        let time_now = time.elapsed_seconds();
+
+        if let Some(current_hud_message) = hud_messages.1.as_mut() {
+            if current_hud_message.time_needs_reset {
+                shown_hud_message.time_created = time_now;
+                current_hud_message.time_needs_reset = false;
+            }
+        }
+
+        let time_remaining = HUD_DISPLAY_DURATION.as_secs_f32() - (time_now - shown_hud_message.time_created);
+
+        if time_remaining <= 0.0 {
+            commands.entity(parent.get()).despawn_recursive();
+            hud_messages.1 = None;
+        } else {
+            for section in text.sections.iter_mut() {
+                section.style.color.set_a((time_remaining / FADE_DURATION.as_secs_f32()).min(1.0));
+            }
+        }
+    } else if let Some(hud_message) = hud_messages.0.pop_front() {
+        let shown_hud_message = ShownHudMessage {
+            time_created: time.elapsed_seconds(),
+        };
+
+        hud_messages.1 = Some(CurrentDisplayedHudCache {
+            cached_message: hud_message.clone(),
+            time_needs_reset: false,
+        });
+
+        commands
+            .spawn((
+                Name::new("HUD Message"),
+                NodeBundle {
+                    style: Style {
+                        width: Val::Percent(100.0),
+                        height: Val::Percent(100.0),
+                        justify_content: JustifyContent::Center,
+                        ..Default::default()
+                    },
+                    ..Default::default()
+                },
+            ))
+            .with_children(|p| {
+                p.spawn((
+                    shown_hud_message,
+                    TextBundle {
+                        style: Style {
+                            position_type: PositionType::Absolute,
+                            bottom: Val::Px(125.0),
+                            ..Default::default()
+                        },
+                        text: Text {
+                            sections: hud_message
+                                .text
+                                .into_iter()
+                                .map(|x| TextSection {
+                                    value: x.text,
+                                    style: TextStyle {
+                                        color: x.color,
+                                        font: asset_server.load("fonts/PixeloidSans.ttf"),
+                                        font_size: 24.0,
+                                    },
+                                })
+                                .collect(),
+                            alignment: TextAlignment::Center,
+                            ..Default::default()
+                        },
+                        ..Default::default()
+                    },
+                ));
+            });
+    }
+}
+
+pub(super) fn register(app: &mut App) {
+    app.init_resource::<HudMessages>()
+        .add_systems(Update, display_hud_messages.run_if(in_state(GameState::Playing)));
+}
diff --git a/cosmos_client/src/ui/mod.rs b/cosmos_client/src/ui/mod.rs
index f2e7460ee..1adc557b1 100644
--- a/cosmos_client/src/ui/mod.rs
+++ b/cosmos_client/src/ui/mod.rs
@@ -6,10 +6,12 @@ pub mod crosshair;
 pub mod debug_info_display;
 pub mod hotbar;
 pub mod item_renderer;
+pub mod message;
 
 pub(super) fn register(app: &mut App) {
     crosshair::register(app);
     hotbar::register(app);
     debug_info_display::register(app);
     item_renderer::register(app);
+    message::register(app);
 }
diff --git a/cosmos_server/src/events/blocks/block_events.rs b/cosmos_core/src/block/block_events.rs
similarity index 86%
rename from cosmos_server/src/events/blocks/block_events.rs
rename to cosmos_core/src/block/block_events.rs
index 04c575c66..90cb52f17 100644
--- a/cosmos_server/src/events/blocks/block_events.rs
+++ b/cosmos_core/src/block/block_events.rs
@@ -1,18 +1,12 @@
 //! Contains the various types of block events
 
-use bevy::{prelude::*, utils::HashMap};
-use bevy_renet::renet::RenetServer;
-use cosmos_core::{
-    block::{blocks::AIR_BLOCK_ID, Block, BlockFace},
+use bevy::prelude::*;
+
+use crate::{
     blockitems::BlockItems,
     events::block_events::BlockChangedEvent,
     inventory::Inventory,
     item::Item,
-    netty::{
-        cosmos_encoder,
-        server_reliable_messages::{BlockChanged, BlocksChangedPacket, ServerReliableMessages},
-        NettyChannelServer,
-    },
     registry::{identifiable::Identifiable, Registry},
     structure::{
         coordinates::{BlockCoordinate, CoordinateType, UnboundCoordinateType},
@@ -22,7 +16,7 @@ use cosmos_core::{
     },
 };
 
-use crate::GameState;
+use super::{blocks::AIR_BLOCK_ID, Block, BlockFace};
 
 /// This is sent whenever a player breaks a block
 #[derive(Debug, Event)]
@@ -262,37 +256,9 @@ fn handle_block_place_events(
     }
 }
 
-fn handle_block_changed_event(mut event_reader: EventReader<BlockChangedEvent>, mut server: ResMut<RenetServer>) {
-    let iter_len = event_reader.iter().len();
-    let mut map = HashMap::new();
-    for ev in event_reader.iter() {
-        if !map.contains_key(&ev.structure_entity) {
-            map.insert(ev.structure_entity, Vec::with_capacity(iter_len));
-        }
-        map.get_mut(&ev.structure_entity).expect("Set above").push(BlockChanged {
-            coordinates: ev.block,
-            block_id: ev.new_block,
-            block_up: ev.new_block_up,
-        });
-    }
-
-    for (entity, v) in map {
-        server.broadcast_message(
-            NettyChannelServer::Reliable,
-            cosmos_encoder::serialize(&ServerReliableMessages::BlockChange {
-                structure_entity: entity,
-                blocks_changed_packet: BlocksChangedPacket(v),
-            }),
-        );
-    }
-}
-
 pub(super) fn register(app: &mut App) {
     app.add_event::<BlockBreakEvent>()
         .add_event::<BlockPlaceEvent>()
         .add_event::<BlockInteractEvent>()
-        .add_systems(
-            Update,
-            (handle_block_break_events, handle_block_place_events, handle_block_changed_event).run_if(in_state(GameState::Playing)),
-        );
+        .add_systems(Update, (handle_block_break_events, handle_block_place_events));
 }
diff --git a/cosmos_core/src/block/blocks.rs b/cosmos_core/src/block/blocks.rs
index c7cd514f4..1ba216ea2 100644
--- a/cosmos_core/src/block/blocks.rs
+++ b/cosmos_core/src/block/blocks.rs
@@ -206,6 +206,34 @@ fn add_cosmos_blocks(
         );
     }
 
+    blocks.register(
+        BlockBuilder::new("cosmos:reactor_controller", 2.0, 20.0)
+            .add_property(BlockProperty::Opaque)
+            .add_property(BlockProperty::Full)
+            .create(),
+    );
+
+    blocks.register(
+        BlockBuilder::new("cosmos:reactor_casing", 2.0, 20.0)
+            .add_property(BlockProperty::Opaque)
+            .add_property(BlockProperty::Full)
+            .create(),
+    );
+
+    blocks.register(
+        BlockBuilder::new("cosmos:reactor_window", 2.0, 20.0)
+            .add_property(BlockProperty::Transparent)
+            .add_property(BlockProperty::Full)
+            .create(),
+    );
+
+    blocks.register(
+        BlockBuilder::new("cosmos:reactor_cell", 2.0, 20.0)
+            .add_property(BlockProperty::Opaque)
+            .add_property(BlockProperty::Full)
+            .create(),
+    );
+
     loading.finish_loading(id, &mut end_writer);
 }
 
@@ -228,7 +256,7 @@ fn add_air_block(
     loader.finish_loading(id, &mut done_loading_event);
 }
 
-pub(super) fn register<T: States + Clone + Copy>(app: &mut App, pre_loading_state: T, loading_state: T) {
+pub(super) fn register<T: States>(app: &mut App, pre_loading_state: T, loading_state: T) {
     registry::create_registry::<Block>(app);
 
     app.add_systems(OnEnter(pre_loading_state), add_air_block);
diff --git a/cosmos_core/src/block/mod.rs b/cosmos_core/src/block/mod.rs
index e9a779e78..0d6d4d2f0 100644
--- a/cosmos_core/src/block/mod.rs
+++ b/cosmos_core/src/block/mod.rs
@@ -8,10 +8,12 @@ use bevy::{
 };
 use serde::{Deserialize, Serialize};
 
-use crate::registry::identifiable::Identifiable;
+use crate::{registry::identifiable::Identifiable, structure::coordinates::UnboundBlockCoordinate};
 
 pub mod block_builder;
+pub mod block_events;
 pub mod blocks;
+pub mod multiblock;
 
 #[derive(Reflect, Debug, Eq, PartialEq, Clone, Copy, Hash)]
 /// Represents different properties a block can has
@@ -87,6 +89,18 @@ impl BlockFace {
         }
     }
 
+    /// Returns the direction each face represents as an UnboundBlockCoordinate
+    pub fn direction_coordinates(&self) -> UnboundBlockCoordinate {
+        match *self {
+            Self::Front => UnboundBlockCoordinate::new(0, 0, 1),
+            Self::Back => UnboundBlockCoordinate::new(0, 0, -1),
+            Self::Left => UnboundBlockCoordinate::new(-1, 0, 0),
+            Self::Right => UnboundBlockCoordinate::new(1, 0, 0),
+            Self::Top => UnboundBlockCoordinate::new(0, 1, 0),
+            Self::Bottom => UnboundBlockCoordinate::new(0, -1, 0),
+        }
+    }
+
     /// Returns the string representation of this face.
     pub fn as_str(&self) -> &'static str {
         match *self {
@@ -115,6 +129,54 @@ impl BlockFace {
         }
     }
 
+    /// Gets the opposite face for this block face (example: `BlockFace::Left` -> `BlockFace::Right`)
+    pub fn inverse(&self) -> BlockFace {
+        match self {
+            Self::Top => Self::Bottom,
+            Self::Bottom => Self::Top,
+            Self::Left => Self::Right,
+            Self::Right => Self::Left,
+            Self::Back => Self::Front,
+            Self::Front => Self::Back,
+        }
+    }
+
+    #[inline(always)]
+    /// Returns the `BlockFace` that is this blockface's top
+    pub fn local_top(self) -> BlockFace {
+        Self::rotate_face(self, BlockFace::Top)
+    }
+
+    #[inline(always)]
+    /// Returns the `BlockFace` that is this blockface's bottom
+    pub fn local_bottom(self) -> BlockFace {
+        Self::rotate_face(self, BlockFace::Bottom)
+    }
+
+    #[inline(always)]
+    /// Returns the `BlockFace` that is this blockface's left
+    pub fn local_left(self) -> BlockFace {
+        Self::rotate_face(self, BlockFace::Left)
+    }
+
+    #[inline(always)]
+    /// Returns the `BlockFace` that is this blockface's right
+    pub fn local_right(self) -> BlockFace {
+        Self::rotate_face(self, BlockFace::Right)
+    }
+
+    #[inline(always)]
+    /// Returns the `BlockFace` that is this blockface's back
+    pub fn local_back(self) -> BlockFace {
+        Self::rotate_face(self, BlockFace::Back)
+    }
+
+    #[inline(always)]
+    /// Returns the `BlockFace` that is this blockface's front
+    pub fn local_front(self) -> BlockFace {
+        Self::rotate_face(self, BlockFace::Front)
+    }
+
     /// BlockFace::Top will result in no rotation being made
     pub fn rotate_face(face: BlockFace, top_face: BlockFace) -> BlockFace {
         match top_face {
@@ -275,8 +337,16 @@ impl PartialEq for Block {
     }
 }
 
-pub(super) fn register<T: States + Clone + Copy>(app: &mut App, pre_loading_state: T, loading_state: T) {
+pub(super) fn register<T: States + Clone + Copy>(
+    app: &mut App,
+    pre_loading_state: T,
+    loading_state: T,
+    post_loading_state: T,
+    playing_state: T,
+) {
     blocks::register(app, pre_loading_state, loading_state);
+    block_events::register(app);
+    multiblock::register(app, post_loading_state, playing_state);
 
     app.register_type::<BlockFace>();
 }
diff --git a/cosmos_core/src/block/multiblock/mod.rs b/cosmos_core/src/block/multiblock/mod.rs
new file mode 100644
index 000000000..2de665638
--- /dev/null
+++ b/cosmos_core/src/block/multiblock/mod.rs
@@ -0,0 +1,14 @@
+//! Common multiblock functionality
+
+use bevy::prelude::{App, States};
+
+pub mod reactor;
+
+// enum Multiblock {
+//     Blueprint { layout: Vec<String>, key: HashMap<String, String> },
+//     Multiblock { size: BlockCoordinate, blocks: Vec<u16> },
+// }
+
+pub(super) fn register<T: States>(app: &mut App, post_loading_state: T, playing_state: T) {
+    reactor::register(app, post_loading_state, playing_state);
+}
diff --git a/cosmos_core/src/block/multiblock/reactor.rs b/cosmos_core/src/block/multiblock/reactor.rs
new file mode 100644
index 000000000..9b981beb0
--- /dev/null
+++ b/cosmos_core/src/block/multiblock/reactor.rs
@@ -0,0 +1,211 @@
+//! Represents the logic behind the reactor multiblock system
+
+use bevy::{
+    prelude::{
+        in_state, Added, App, Commands, Component, Deref, DerefMut, Entity, EventReader, IntoSystemConfigs, OnEnter, Query, Res, ResMut,
+        States, Update, Without,
+    },
+    reflect::Reflect,
+    time::Time,
+};
+use serde::{Deserialize, Serialize};
+
+use crate::{
+    block::Block,
+    events::block_events::BlockChangedEvent,
+    registry::{create_registry, identifiable::Identifiable, Registry},
+    structure::{
+        coordinates::BlockCoordinate,
+        structure_block::StructureBlock,
+        systems::{energy_storage_system::EnergyStorageSystem, Systems},
+        Structure,
+    },
+};
+
+#[derive(Debug, Clone, Copy, Reflect, Serialize, Deserialize)]
+/// The inclusive bounds of a reactor, including its casing
+pub struct ReactorBounds {
+    /// Inclusive negative-most coordinates of a reactor (include casing)
+    pub negative_coords: BlockCoordinate,
+    /// Inclusive positive-most coordinates of a reactor (include casing)
+    pub positive_coords: BlockCoordinate,
+}
+
+#[derive(Clone, Copy, Debug, Reflect, Serialize, Deserialize)]
+/// Represents a constructed reactor
+pub struct Reactor {
+    controller: StructureBlock,
+    power_per_second: f32,
+    bounds: ReactorBounds,
+}
+
+impl Reactor {
+    /// Creates a new constructed reactor
+    pub fn new(controller: StructureBlock, power_per_second: f32, bounds: ReactorBounds) -> Self {
+        Self {
+            bounds,
+            controller,
+            power_per_second,
+        }
+    }
+
+    /// Decreases the power-per-second generated in this reactor.
+    pub fn decrease_power_per_second(&mut self, amount: f32) {
+        self.power_per_second -= amount;
+        self.power_per_second = self.power_per_second.max(0.0);
+    }
+
+    /// Increases the power-per-second generated in this reactor
+    pub fn increase_power_per_second(&mut self, amount: f32) {
+        self.power_per_second += amount;
+    }
+
+    /// Returns the block where the controller for this reactor is
+    pub fn controller_block(&self) -> StructureBlock {
+        self.controller
+    }
+}
+
+#[derive(Debug, Component, Default, Reflect, DerefMut, Deref, Serialize, Deserialize, Clone)]
+/// Stores the entities of all the reactors in a structure and their controller blocks for quick access
+pub struct Reactors(Vec<Reactor>);
+
+impl Reactors {
+    /// Adds a reactor to the structure
+    pub fn add_reactor(&mut self, reactor: Reactor) {
+        self.0.push(reactor);
+    }
+}
+
+#[derive(Debug, Clone)]
+/// A block that can be used in a reactor to generate power
+pub struct ReactorPowerGenerationBlock {
+    power_per_second: f32,
+
+    id: u16,
+    unlocalized_name: String,
+}
+
+impl Identifiable for ReactorPowerGenerationBlock {
+    fn id(&self) -> u16 {
+        self.id
+    }
+
+    fn set_numeric_id(&mut self, id: u16) {
+        self.id = id;
+    }
+
+    fn unlocalized_name(&self) -> &str {
+        &self.unlocalized_name
+    }
+}
+
+impl ReactorPowerGenerationBlock {
+    /// Creates a link to a block to make it usable within a reactor to create power
+    pub fn new(block: &Block, power_per_second: f32) -> Self {
+        Self {
+            power_per_second,
+            id: 0,
+            unlocalized_name: block.unlocalized_name().to_owned(),
+        }
+    }
+
+    /// The power per second this block will produce
+    pub fn power_per_second(&self) -> f32 {
+        self.power_per_second
+    }
+}
+
+fn register_power_blocks(blocks: Res<Registry<Block>>, mut registry: ResMut<Registry<ReactorPowerGenerationBlock>>) {
+    if let Some(reactor_block) = blocks.from_id("cosmos:reactor_cell") {
+        registry.register(ReactorPowerGenerationBlock::new(reactor_block, 1000.0));
+    }
+}
+
+impl Registry<ReactorPowerGenerationBlock> {
+    /// Gets the reactor power generation entry for this block
+    pub fn for_block(&self, block: &Block) -> Option<&ReactorPowerGenerationBlock> {
+        self.from_id(block.unlocalized_name())
+    }
+}
+
+fn on_structure_add(mut commands: Commands, query: Query<Entity, (Added<Structure>, Without<Reactors>)>) {
+    for ent in query.iter() {
+        commands.entity(ent).insert(Reactors::default());
+    }
+}
+
+fn on_modify_reactor(
+    mut reactors_query: Query<&mut Reactors>,
+    mut block_change_event: EventReader<BlockChangedEvent>,
+    blocks: Res<Registry<Block>>,
+    reactor_cells: Res<Registry<ReactorPowerGenerationBlock>>,
+) {
+    for ev in block_change_event.iter() {
+        let Ok(mut reactors) = reactors_query.get_mut(ev.structure_entity) else {
+            continue;
+        };
+
+        reactors.retain_mut(|reactor| {
+            let (neg, pos) = (reactor.bounds.negative_coords, reactor.bounds.positive_coords);
+
+            let within_x = neg.x <= ev.block.x && pos.x >= ev.block.x;
+            let within_y = neg.y <= ev.block.y && pos.y >= ev.block.y;
+            let within_z = neg.z <= ev.block.z && pos.z >= ev.block.z;
+
+            if (neg.x == ev.block.x || pos.x == ev.block.x) && (within_y && within_z)
+                || (neg.y == ev.block.y || pos.y == ev.block.y) && (within_x && within_z)
+                || (neg.z == ev.block.z || pos.z == ev.block.z) && (within_x && within_y)
+            {
+                // They changed the casing of the reactor - kill it
+                false
+            } else {
+                if within_x && within_y && within_z {
+                    // The innards of the reactor were changed, add/remove any needed power per second
+                    if let Some(reactor_cell) = reactor_cells.for_block(blocks.from_numeric_id(ev.old_block)) {
+                        reactor.decrease_power_per_second(reactor_cell.power_per_second());
+                    }
+
+                    if let Some(reactor_cell) = reactor_cells.for_block(blocks.from_numeric_id(ev.new_block)) {
+                        reactor.increase_power_per_second(reactor_cell.power_per_second());
+                    }
+                }
+
+                true
+            }
+        });
+    }
+}
+
+fn generate_power(
+    reactors: Query<(&Reactors, Entity)>,
+    structure: Query<&Systems>,
+    mut energy_storage_system_query: Query<&mut EnergyStorageSystem>,
+    time: Res<Time>,
+) {
+    for (reactors, structure_entity) in reactors.iter() {
+        let Ok(systems) = structure.get(structure_entity) else {
+            continue;
+        };
+
+        let Ok(mut system) = systems.query_mut(&mut energy_storage_system_query) else {
+            continue;
+        };
+
+        for reactor in reactors.iter() {
+            system.increase_energy(reactor.power_per_second * time.delta_seconds());
+        }
+    }
+}
+
+pub(super) fn register<T: States>(app: &mut App, post_loading_state: T, playing_state: T) {
+    create_registry::<ReactorPowerGenerationBlock>(app);
+
+    app.add_systems(OnEnter(post_loading_state), register_power_blocks)
+        .add_systems(
+            Update,
+            (on_structure_add, generate_power, on_modify_reactor).run_if(in_state(playing_state)),
+        )
+        .register_type::<Reactor>()
+        .register_type::<Reactors>();
+}
diff --git a/cosmos_core/src/netty/server_reliable_messages.rs b/cosmos_core/src/netty/server_reliable_messages.rs
index c73447c74..795a021e2 100644
--- a/cosmos_core/src/netty/server_reliable_messages.rs
+++ b/cosmos_core/src/netty/server_reliable_messages.rs
@@ -7,7 +7,7 @@ use bevy::prelude::{Component, Entity};
 use serde::{Deserialize, Serialize};
 
 use crate::{
-    block::BlockFace,
+    block::{multiblock::reactor::Reactors, BlockFace},
     entities::player::render_distance::RenderDistance,
     physics::location::Location,
     structure::{
@@ -162,4 +162,18 @@ pub enum ServerReliableMessages {
         /// The new build mode
         build_mode: BuildMode,
     },
+    /// Reactor creation failure
+    InvalidReactor {
+        /// The reason the reactor failed to be created
+        reason: String,
+    },
+    /// Updates the reactors for a specific structure
+    Reactors {
+        /// The reactors the structure now has
+        reactors: Reactors,
+        /// The structure this the reactors are a part of
+        structure: Entity,
+    },
+    /// This signifies that the server is sending information for a requested entity
+    RequestedEntityReceived(Entity),
 }
diff --git a/cosmos_core/src/plugin/cosmos_core_plugin.rs b/cosmos_core/src/plugin/cosmos_core_plugin.rs
index a155dc9f9..a09c78ee8 100644
--- a/cosmos_core/src/plugin/cosmos_core_plugin.rs
+++ b/cosmos_core/src/plugin/cosmos_core_plugin.rs
@@ -70,7 +70,13 @@ impl<T: States + Clone + Copy> Plugin for CosmosCorePlugin<T> {
             self.done_loading_state,
         );
 
-        block::register(app, self.pre_loading_state, self.loading_state);
+        block::register(
+            app,
+            self.pre_loading_state,
+            self.loading_state,
+            self.post_loading_state,
+            self.playing_state,
+        );
         item::register(app);
         blockitems::register(app, self.post_loading_state);
         physics::register(app, self.post_loading_state);
diff --git a/cosmos_core/src/structure/chunk.rs b/cosmos_core/src/structure/chunk.rs
index b8da8f646..efe826144 100644
--- a/cosmos_core/src/structure/chunk.rs
+++ b/cosmos_core/src/structure/chunk.rs
@@ -178,7 +178,7 @@ impl Chunk {
 }
 
 #[derive(Debug, Default, Reflect, Serialize, Deserialize, Clone, Copy, PartialEq, Eq)]
-/// This represents the information for a block. The first 3 bits are reserved for rotation data.
+/// This represents the information for a block. The first 3 rightmost bits are reserved for rotation data.
 ///
 /// All other bits can be used for anything else
 pub struct BlockInfo(u8);
diff --git a/cosmos_core/src/structure/coordinates.rs b/cosmos_core/src/structure/coordinates.rs
index 09720d155..f435f5e26 100644
--- a/cosmos_core/src/structure/coordinates.rs
+++ b/cosmos_core/src/structure/coordinates.rs
@@ -223,6 +223,15 @@ macro_rules! create_coordinate {
             pub fn front(&self) -> Self {
                 Self::new(self.x, self.y, self.z + 1)
             }
+
+            /// Computes the abs() of each value and converts to a bounded coordinate type
+            pub fn abs(&self) -> $name {
+                $name::new(
+                    self.x.abs() as CoordinateType,
+                    self.y.abs() as CoordinateType,
+                    self.z.abs() as CoordinateType,
+                )
+            }
         }
 
         impl std::fmt::Display for $unbounded {
diff --git a/cosmos_core/src/structure/ship/core.rs b/cosmos_core/src/structure/ship/core.rs
index 245066fc5..135e2fd90 100644
--- a/cosmos_core/src/structure/ship/core.rs
+++ b/cosmos_core/src/structure/ship/core.rs
@@ -36,13 +36,13 @@ fn monitor_block_events(mut commands: Commands, blocks: Res<Registry<Block>>, mu
 /// Marks a child of a structure as needing to be despawned when the structure itself is despawned.
 ///
 /// If something does not have this component and its parent ship is despawned, it will have its parent removed instead of being despawned.
-pub struct DieWithStructure;
+pub struct DespawnWithStructure;
 
 /// Makes sure that when the ship is despawned, only that ship is despawned and not
 /// any of the things docked to it (like the player walking on it)
 fn save_the_kids(
     query: Query<&Children, (With<NeedsDespawned>, With<Ship>)>,
-    is_this_structure: Query<(), Or<(With<ChunkEntity>, With<StructureSystem>, With<DieWithStructure>)>>,
+    is_this_structure: Query<(), Or<(With<ChunkEntity>, With<StructureSystem>, With<DespawnWithStructure>)>>,
     mut commands: Commands,
 ) {
     for children in query.iter() {
diff --git a/cosmos_core/src/structure/structure_block.rs b/cosmos_core/src/structure/structure_block.rs
index 9ba1ff6d1..ea2638d91 100644
--- a/cosmos_core/src/structure/structure_block.rs
+++ b/cosmos_core/src/structure/structure_block.rs
@@ -17,8 +17,9 @@ use super::{
 };
 
 #[derive(Clone, Deref, DerefMut, Debug, Reflect, Copy, PartialEq, Eq, Serialize, Deserialize)]
-/// A block that is a part of a structure
+/// A block that is a part of a structure.
 ///
+/// This is really just a wrapper around a BlockCoordinate, but this implies there is (or at least was) a block here.
 /// This may not be valid when it is used.
 pub struct StructureBlock(pub BlockCoordinate);
 
diff --git a/cosmos_core/src/structure/systems/energy_generation_system/mod.rs b/cosmos_core/src/structure/systems/energy_generation_system/mod.rs
index 6747d46a1..25b55e72b 100644
--- a/cosmos_core/src/structure/systems/energy_generation_system/mod.rs
+++ b/cosmos_core/src/structure/systems/energy_generation_system/mod.rs
@@ -53,7 +53,7 @@ impl EnergyGenerationSystem {
 
 fn register_energy_blocks(blocks: Res<Registry<Block>>, mut generation: ResMut<EnergyGenerationBlocks>) {
     if let Some(block) = blocks.from_id("cosmos:reactor") {
-        generation.insert(block, EnergyGenerationProperty { generation_rate: 1000.0 });
+        generation.insert(block, EnergyGenerationProperty { generation_rate: 100.0 });
     }
 
     if let Some(block) = blocks.from_id("cosmos:ship_core") {
diff --git a/cosmos_server/src/blocks/block_events.rs b/cosmos_server/src/blocks/block_events.rs
new file mode 100644
index 000000000..e2a30f5f6
--- /dev/null
+++ b/cosmos_server/src/blocks/block_events.rs
@@ -0,0 +1,41 @@
+use bevy::{prelude::*, utils::HashMap};
+use bevy_renet::renet::RenetServer;
+use cosmos_core::{
+    events::block_events::BlockChangedEvent,
+    netty::{
+        cosmos_encoder,
+        server_reliable_messages::{BlockChanged, BlocksChangedPacket, ServerReliableMessages},
+        NettyChannelServer,
+    },
+};
+
+use crate::state::GameState;
+
+fn handle_block_changed_event(mut event_reader: EventReader<BlockChangedEvent>, mut server: ResMut<RenetServer>) {
+    let iter_len = event_reader.iter().len();
+    let mut map = HashMap::new();
+    for ev in event_reader.iter() {
+        if !map.contains_key(&ev.structure_entity) {
+            map.insert(ev.structure_entity, Vec::with_capacity(iter_len));
+        }
+        map.get_mut(&ev.structure_entity).expect("Set above").push(BlockChanged {
+            coordinates: ev.block,
+            block_id: ev.new_block,
+            block_up: ev.new_block_up,
+        });
+    }
+
+    for (entity, v) in map {
+        server.broadcast_message(
+            NettyChannelServer::Reliable,
+            cosmos_encoder::serialize(&ServerReliableMessages::BlockChange {
+                structure_entity: entity,
+                blocks_changed_packet: BlocksChangedPacket(v),
+            }),
+        );
+    }
+}
+
+pub(super) fn register(app: &mut App) {
+    app.add_systems(Update, handle_block_changed_event.run_if(in_state(GameState::Playing)));
+}
diff --git a/cosmos_server/src/blocks/interactable/ship_core.rs b/cosmos_server/src/blocks/interactable/ship_core.rs
index 2d2f650ac..5747c553c 100644
--- a/cosmos_server/src/blocks/interactable/ship_core.rs
+++ b/cosmos_server/src/blocks/interactable/ship_core.rs
@@ -1,6 +1,6 @@
 use bevy::prelude::{in_state, App, EventReader, EventWriter, IntoSystemConfigs, Query, Res, Update, With};
 use cosmos_core::{
-    block::Block,
+    block::{block_events::BlockInteractEvent, Block},
     events::structure::change_pilot_event::ChangePilotEvent,
     registry::{identifiable::Identifiable, Registry},
     structure::{
@@ -9,7 +9,7 @@ use cosmos_core::{
     },
 };
 
-use crate::{events::blocks::block_events::BlockInteractEvent, state::GameState};
+use crate::state::GameState;
 
 fn handle_block_event(
     mut interact_events: EventReader<BlockInteractEvent>,
diff --git a/cosmos_server/src/blocks/mod.rs b/cosmos_server/src/blocks/mod.rs
index 25a3ba0ab..8de0fa0dc 100644
--- a/cosmos_server/src/blocks/mod.rs
+++ b/cosmos_server/src/blocks/mod.rs
@@ -2,8 +2,12 @@
 
 use bevy::prelude::App;
 
+mod block_events;
 pub mod interactable;
+pub mod multiblock;
 
 pub(super) fn register(app: &mut App) {
     interactable::register(app);
+    block_events::register(app);
+    multiblock::register(app);
 }
diff --git a/cosmos_server/src/blocks/multiblock/mod.rs b/cosmos_server/src/blocks/multiblock/mod.rs
new file mode 100644
index 000000000..1beba502a
--- /dev/null
+++ b/cosmos_server/src/blocks/multiblock/mod.rs
@@ -0,0 +1,11 @@
+//! Contains all the server logic related to multiblocks
+
+use bevy::prelude::App;
+
+pub mod reactor;
+pub mod reactor_persistence;
+
+pub(super) fn register(app: &mut App) {
+    reactor::register(app);
+    reactor_persistence::register(app);
+}
diff --git a/cosmos_server/src/blocks/multiblock/reactor.rs b/cosmos_server/src/blocks/multiblock/reactor.rs
new file mode 100644
index 000000000..b6a3564fd
--- /dev/null
+++ b/cosmos_server/src/blocks/multiblock/reactor.rs
@@ -0,0 +1,448 @@
+//! Handles the logic behind the creation of a reactor multiblock
+
+use bevy::prelude::{in_state, App, Changed, Entity, EventReader, IntoSystemConfigs, Query, Res, ResMut, Update};
+use bevy_renet::renet::RenetServer;
+use cosmos_core::{
+    block::{
+        block_events::BlockInteractEvent,
+        multiblock::reactor::{Reactor, ReactorBounds, ReactorPowerGenerationBlock, Reactors},
+        Block,
+    },
+    entities::player::Player,
+    netty::{cosmos_encoder, server_reliable_messages::ServerReliableMessages, NettyChannelServer},
+    registry::{identifiable::Identifiable, Registry},
+    structure::{
+        coordinates::{BlockCoordinate, CoordinateType, UnboundBlockCoordinate},
+        structure_block::StructureBlock,
+        Structure,
+    },
+};
+
+use crate::{netty::sync::entities::RequestedEntityEvent, state::GameState};
+
+/// Represents the maximum dimensions of the reactor, including the reactor casing
+const MAX_REACTOR_SIZE: CoordinateType = 11;
+
+fn find_wall_coords(
+    ub_controller_coords: UnboundBlockCoordinate,
+    structure: &Structure,
+    direction_a: UnboundBlockCoordinate,
+    direction_b: UnboundBlockCoordinate,
+    blocks: &Registry<Block>,
+    valid_blocks: &[&Block],
+) -> Option<(BlockCoordinate, BlockCoordinate)> {
+    let mut width = 0;
+
+    let mut found_coords = None;
+    {
+        let search_direction = direction_a;
+
+        let mut check_coords = search_direction;
+        for _ in 0..MAX_REACTOR_SIZE {
+            let Ok(check_here) = BlockCoordinate::try_from(check_coords + ub_controller_coords) else {
+                return None;
+            };
+
+            width += 1;
+
+            let block_here = structure.block_at(check_here, blocks);
+
+            if !valid_blocks.contains(&block_here) {
+                found_coords = Some(
+                    BlockCoordinate::try_from(UnboundBlockCoordinate::from(check_here) - search_direction)
+                        .expect("This is guarenteed from previous logic to be within the structure"),
+                );
+                break;
+            }
+
+            check_coords = check_coords + search_direction;
+        }
+    }
+
+    let Some(left_wall_coords) = found_coords else {
+        return None;
+    };
+
+    let mut found_coords = None;
+    {
+        let search_direction = direction_b;
+
+        let mut check_coords = search_direction;
+        for _ in width..=MAX_REACTOR_SIZE {
+            let Ok(check_here) = BlockCoordinate::try_from(check_coords + ub_controller_coords) else {
+                return None;
+            };
+
+            let block_here = structure.block_at(check_here, blocks);
+
+            if !valid_blocks.contains(&block_here) {
+                found_coords = Some(
+                    BlockCoordinate::try_from(UnboundBlockCoordinate::from(check_here) - search_direction)
+                        .expect("This is guarenteed from previous logic to be within the structure"),
+                );
+                break;
+            }
+
+            check_coords = check_coords + search_direction;
+        }
+    }
+
+    let Some(right_wall_coords) = found_coords else {
+        return None;
+    };
+
+    Some((left_wall_coords, right_wall_coords))
+}
+
+fn check_is_valid_multiblock(structure: &Structure, controller_coords: BlockCoordinate, blocks: &Registry<Block>) -> Option<ReactorBounds> {
+    let valid_blocks = [
+        blocks.from_id("cosmos:reactor_casing").expect("Missing reactor casing"),
+        blocks.from_id("cosmos:reactor_window").expect("Missing cosmos:reactor_window"),
+        blocks
+            .from_id("cosmos:reactor_controller")
+            .expect("Missing cosmos:reactor_controller"),
+    ];
+
+    let direction = structure.block_rotation(controller_coords);
+
+    let ub_controller_coords = UnboundBlockCoordinate::from(controller_coords);
+
+    let mut found_coords = None;
+
+    {
+        let search_direction = direction.local_back().direction_coordinates();
+
+        // Start 2 back to now allow a 2x2x2 reactor - minimum size is 3x3x3
+        let mut check_coords = search_direction + search_direction;
+        for _ in 0..MAX_REACTOR_SIZE - 2 {
+            let Ok(check_here) = BlockCoordinate::try_from(check_coords + ub_controller_coords) else {
+                return None;
+            };
+
+            let block_here = structure.block_at(check_here, blocks);
+
+            if valid_blocks.contains(&block_here) {
+                found_coords = Some(check_here);
+                break;
+            }
+
+            check_coords = check_coords + search_direction;
+        }
+    }
+
+    let Some(back_wall_coords) = found_coords else {
+        return None;
+    };
+
+    let Some((left_wall_coords, right_wall_coords)) = find_wall_coords(
+        ub_controller_coords,
+        structure,
+        direction.local_left().direction_coordinates(),
+        direction.local_right().direction_coordinates(),
+        blocks,
+        &valid_blocks,
+    ) else {
+        return None;
+    };
+
+    let Some((down_wall_coords, up_wall_coords)) = find_wall_coords(
+        ub_controller_coords,
+        structure,
+        direction.local_bottom().direction_coordinates(),
+        direction.local_top().direction_coordinates(),
+        blocks,
+        &valid_blocks,
+    ) else {
+        return None;
+    };
+
+    Some(ReactorBounds {
+        negative_coords: BlockCoordinate::new(
+            controller_coords
+                .x
+                .min(back_wall_coords.x)
+                .min(right_wall_coords.x)
+                .min(left_wall_coords.x)
+                .min(up_wall_coords.x)
+                .min(down_wall_coords.x),
+            controller_coords
+                .y
+                .min(back_wall_coords.y)
+                .min(right_wall_coords.y)
+                .min(left_wall_coords.y)
+                .min(up_wall_coords.y)
+                .min(down_wall_coords.y),
+            controller_coords
+                .z
+                .min(back_wall_coords.z)
+                .min(right_wall_coords.z)
+                .min(left_wall_coords.z)
+                .min(up_wall_coords.z)
+                .min(down_wall_coords.z),
+        ),
+        positive_coords: BlockCoordinate::new(
+            controller_coords
+                .x
+                .max(back_wall_coords.x)
+                .max(right_wall_coords.x)
+                .max(left_wall_coords.x)
+                .max(up_wall_coords.x)
+                .max(down_wall_coords.x),
+            controller_coords
+                .y
+                .max(back_wall_coords.y)
+                .max(right_wall_coords.y)
+                .max(left_wall_coords.y)
+                .max(up_wall_coords.y)
+                .max(down_wall_coords.y),
+            controller_coords
+                .z
+                .max(back_wall_coords.z)
+                .max(right_wall_coords.z)
+                .max(left_wall_coords.z)
+                .max(up_wall_coords.z)
+                .max(down_wall_coords.z),
+        ),
+    })
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+enum ReactorValidity {
+    Valid,
+    TooManyControllers(BlockCoordinate),
+    MissingCasing(BlockCoordinate),
+}
+
+fn check_block(
+    coords: BlockCoordinate,
+    valid_blocks: &[&Block],
+    controller_block: &Block,
+    structure: &Structure,
+    blocks: &Registry<Block>,
+    controller_coords: &mut Option<BlockCoordinate>,
+) -> ReactorValidity {
+    let block_here = structure.block_at(coords, blocks);
+    if controller_block == block_here {
+        if let Some(controller_coords) = controller_coords {
+            if *controller_coords != coords {
+                return ReactorValidity::TooManyControllers(coords);
+            }
+        } else {
+            *controller_coords = Some(coords);
+        }
+    } else if !valid_blocks.contains(&block_here) {
+        return ReactorValidity::MissingCasing(coords);
+    }
+
+    ReactorValidity::Valid
+}
+
+fn check_valid(bounds: ReactorBounds, structure: &Structure, blocks: &Registry<Block>) -> ReactorValidity {
+    let mut controller_location = None;
+
+    let valid_blocks = [
+        blocks.from_id("cosmos:reactor_casing").expect("Missing reactor casing"),
+        blocks.from_id("cosmos:reactor_window").expect("missing cosmos:reactor_window"),
+    ];
+
+    let controller_block = blocks
+        .from_id("cosmos:reactor_controller")
+        .expect("Missing cosmos:reactor_controller");
+
+    for z in bounds.negative_coords.z..=bounds.positive_coords.z {
+        for y in bounds.negative_coords.y..=bounds.positive_coords.y {
+            let res = check_block(
+                BlockCoordinate::new(bounds.negative_coords.x, y, z),
+                &valid_blocks,
+                controller_block,
+                structure,
+                blocks,
+                &mut controller_location,
+            );
+            if res != ReactorValidity::Valid {
+                return res;
+            }
+
+            let res = check_block(
+                BlockCoordinate::new(bounds.positive_coords.x, y, z),
+                &valid_blocks,
+                controller_block,
+                structure,
+                blocks,
+                &mut controller_location,
+            );
+            if res != ReactorValidity::Valid {
+                return res;
+            }
+        }
+    }
+
+    for y in bounds.negative_coords.y..=bounds.positive_coords.y {
+        for x in bounds.negative_coords.x..=bounds.positive_coords.x {
+            let res = check_block(
+                BlockCoordinate::new(x, y, bounds.negative_coords.z),
+                &valid_blocks,
+                controller_block,
+                structure,
+                blocks,
+                &mut controller_location,
+            );
+            if res != ReactorValidity::Valid {
+                return res;
+            }
+
+            let res = check_block(
+                BlockCoordinate::new(x, y, bounds.positive_coords.z),
+                &valid_blocks,
+                controller_block,
+                structure,
+                blocks,
+                &mut controller_location,
+            );
+            if res != ReactorValidity::Valid {
+                return res;
+            }
+        }
+    }
+
+    for z in bounds.negative_coords.z..=bounds.positive_coords.z {
+        for x in bounds.negative_coords.x..=bounds.positive_coords.x {
+            let res = check_block(
+                BlockCoordinate::new(x, bounds.negative_coords.y, z),
+                &valid_blocks,
+                controller_block,
+                structure,
+                blocks,
+                &mut controller_location,
+            );
+            if res != ReactorValidity::Valid {
+                return res;
+            }
+
+            let res = check_block(
+                BlockCoordinate::new(x, bounds.positive_coords.y, z),
+                &valid_blocks,
+                controller_block,
+                structure,
+                blocks,
+                &mut controller_location,
+            );
+            if res != ReactorValidity::Valid {
+                return res;
+            }
+        }
+    }
+
+    ReactorValidity::Valid
+}
+
+fn create_reactor(
+    structure: &Structure,
+    blocks: &Registry<Block>,
+    reactor_blocks: &Registry<ReactorPowerGenerationBlock>,
+    bounds: ReactorBounds,
+    controller: StructureBlock,
+) -> Reactor {
+    let mut power_per_second = 0.0;
+
+    for block in structure.block_iter(bounds.negative_coords.into(), bounds.positive_coords.into(), true) {
+        let block = block.block(structure, blocks);
+
+        if let Some(reactor_block) = reactor_blocks.for_block(block) {
+            power_per_second += reactor_block.power_per_second();
+        }
+    }
+
+    Reactor::new(controller, power_per_second, bounds)
+}
+
+fn on_interact_reactor(
+    mut structure_query: Query<(&Structure, &mut Reactors)>,
+    blocks: Res<Registry<Block>>,
+    reactor_blocks: Res<Registry<ReactorPowerGenerationBlock>>,
+    mut interaction: EventReader<BlockInteractEvent>,
+    mut server: ResMut<RenetServer>,
+    player_query: Query<&Player>,
+) {
+    for ev in interaction.iter() {
+        let Ok((structure, mut reactors)) = structure_query.get_mut(ev.structure_entity) else {
+            continue;
+        };
+
+        let block = structure.block_at(ev.structure_block.coords(), &blocks);
+
+        if block.unlocalized_name() == "cosmos:reactor_controller" {
+            if reactors.iter().any(|reactor| reactor.controller_block() == ev.structure_block) {
+                continue;
+            }
+
+            if let Some(bounds) = check_is_valid_multiblock(structure, ev.structure_block.coords(), &blocks) {
+                match check_valid(bounds, structure, &blocks) {
+                    ReactorValidity::MissingCasing(_) => {
+                        let Ok(player) = player_query.get(ev.interactor) else {
+                            continue;
+                        };
+                        server.send_message(
+                            player.id(),
+                            NettyChannelServer::Reliable,
+                            cosmos_encoder::serialize(&ServerReliableMessages::InvalidReactor {
+                                reason: "The reactor is missing required casing.".into(),
+                            }),
+                        );
+                    }
+                    ReactorValidity::TooManyControllers(_) => {
+                        let Ok(player) = player_query.get(ev.interactor) else {
+                            continue;
+                        };
+                        server.send_message(
+                            player.id(),
+                            NettyChannelServer::Reliable,
+                            cosmos_encoder::serialize(&ServerReliableMessages::InvalidReactor {
+                                reason: "The reactor can only have 1 controller.".into(),
+                            }),
+                        );
+                    }
+                    ReactorValidity::Valid => {
+                        let reactor = create_reactor(structure, &blocks, &reactor_blocks, bounds, ev.structure_block);
+
+                        reactors.add_reactor(reactor);
+                    }
+                };
+            }
+        }
+    }
+}
+
+fn request_reactor_event(query: Query<&Reactors>, mut event_reader: EventReader<RequestedEntityEvent>, mut server: ResMut<RenetServer>) {
+    for ev in event_reader.iter() {
+        if let Ok(reactors) = query.get(ev.entity) {
+            server.send_message(
+                ev.client_id,
+                NettyChannelServer::Reliable,
+                cosmos_encoder::serialize(&ServerReliableMessages::Reactors {
+                    reactors: reactors.clone(),
+                    structure: ev.entity,
+                }),
+            );
+        }
+    }
+}
+
+fn on_change_reactors(query: Query<(Entity, &Reactors), Changed<Reactors>>, mut server: ResMut<RenetServer>) {
+    for (entity, changed_reactor) in query.iter() {
+        server.broadcast_message(
+            NettyChannelServer::Reliable,
+            cosmos_encoder::serialize(&ServerReliableMessages::Reactors {
+                reactors: changed_reactor.clone(),
+                structure: entity,
+            }),
+        );
+    }
+}
+
+pub(super) fn register(app: &mut App) {
+    app.add_systems(
+        Update,
+        (on_interact_reactor, request_reactor_event, on_change_reactors).run_if(in_state(GameState::Playing)),
+    );
+}
diff --git a/cosmos_server/src/blocks/multiblock/reactor_persistence.rs b/cosmos_server/src/blocks/multiblock/reactor_persistence.rs
new file mode 100644
index 000000000..2ec1b1d01
--- /dev/null
+++ b/cosmos_server/src/blocks/multiblock/reactor_persistence.rs
@@ -0,0 +1,31 @@
+//! Handles the saving/unloading of reactors
+
+use bevy::prelude::{App, Commands, Entity, First, IntoSystemConfigs, Query, Update, With};
+use cosmos_core::block::multiblock::reactor::Reactors;
+
+use crate::persistence::{
+    loading::{begin_loading, done_loading, NeedsLoaded},
+    saving::{begin_saving, done_saving, NeedsSaved},
+    SerializedData,
+};
+
+fn on_save_reactors(mut reactors_query: Query<(&Reactors, &mut SerializedData), With<NeedsSaved>>) {
+    for (reactors, mut serialized_data) in reactors_query.iter_mut() {
+        serialized_data.serialize_data("cosmos:reactors", reactors);
+    }
+}
+
+fn on_load_reactors(mut commands: Commands, query: Query<(Entity, &SerializedData), With<NeedsLoaded>>) {
+    for (entity, serialized_data) in query.iter() {
+        let Some(reactors) = serialized_data.deserialize_data::<Reactors>("cosmos:reactors") else {
+            continue;
+        };
+
+        commands.entity(entity).insert(reactors);
+    }
+}
+
+pub(super) fn register(app: &mut App) {
+    app.add_systems(First, on_save_reactors.after(begin_saving).before(done_saving))
+        .add_systems(Update, on_load_reactors.after(begin_loading).before(done_loading));
+}
diff --git a/cosmos_server/src/events/blocks/mod.rs b/cosmos_server/src/events/blocks/mod.rs
deleted file mode 100644
index 858bc89cf..000000000
--- a/cosmos_server/src/events/blocks/mod.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//! Contains server-related information about blocks
-
-use bevy::prelude::App;
-
-pub mod block_events;
-
-pub(super) fn register(app: &mut App) {
-    block_events::register(app);
-}
diff --git a/cosmos_server/src/events/mod.rs b/cosmos_server/src/events/mod.rs
index 67f4c74cb..cbcb42ef5 100644
--- a/cosmos_server/src/events/mod.rs
+++ b/cosmos_server/src/events/mod.rs
@@ -2,7 +2,6 @@
 
 use bevy::prelude::App;
 
-pub mod blocks;
 pub mod create_ship_event;
 pub mod netty;
 pub mod structure;
@@ -11,5 +10,4 @@ pub(super) fn register(app: &mut App) {
     create_ship_event::register(app);
     structure::regsiter(app);
     netty::register(app);
-    blocks::register(app);
 }
diff --git a/cosmos_server/src/netty/server_listener.rs b/cosmos_server/src/netty/server_listener.rs
index 98e1e76d3..c543052f3 100644
--- a/cosmos_server/src/netty/server_listener.rs
+++ b/cosmos_server/src/netty/server_listener.rs
@@ -5,6 +5,7 @@
 use bevy::prelude::*;
 use bevy_rapier3d::prelude::Velocity;
 use bevy_renet::renet::RenetServer;
+use cosmos_core::block::block_events::{BlockBreakEvent, BlockInteractEvent, BlockPlaceEvent};
 use cosmos_core::netty::netty_rigidbody::NettyRigidBodyLocation;
 use cosmos_core::netty::{cosmos_encoder, NettyChannelClient, NettyChannelServer};
 use cosmos_core::physics::location::Location;
@@ -21,11 +22,7 @@ use cosmos_core::{
 };
 
 use crate::entities::player::PlayerLooking;
-use crate::events::{
-    blocks::block_events::{BlockBreakEvent, BlockInteractEvent, BlockPlaceEvent},
-    create_ship_event::CreateShipEvent,
-    structure::ship::ShipSetMovementEvent,
-};
+use crate::events::{create_ship_event::CreateShipEvent, structure::ship::ShipSetMovementEvent};
 use crate::structure::planet::generation::planet_generator::RequestChunkEvent;
 
 use super::network_helpers::ServerLobby;
@@ -141,7 +138,7 @@ pub fn server_listen_messages(
                             );
                         }
                     } else {
-                        warn!("!!! Server received invalid entity from client {client_id}");
+                        warn!("!!! Server received invalid entity from client {client_id}; entity = {server_entity:?}");
                     }
                 }
                 ClientReliableMessages::SendSingleChunk { structure_entity, chunk } => request_chunk_event_writer.send(RequestChunkEvent {
diff --git a/cosmos_server/src/netty/sync/sync_bodies.rs b/cosmos_server/src/netty/sync/sync_bodies.rs
index 99652876f..9d72bb09f 100644
--- a/cosmos_server/src/netty/sync/sync_bodies.rs
+++ b/cosmos_server/src/netty/sync/sync_bodies.rs
@@ -8,6 +8,7 @@ use cosmos_core::{
     netty::{
         cosmos_encoder,
         netty_rigidbody::{NettyRigidBody, NettyRigidBodyLocation},
+        server_reliable_messages::ServerReliableMessages,
         server_unreliable_messages::ServerUnreliableMessages,
         NettyChannelServer, NoSendEntity,
     },
@@ -17,6 +18,8 @@ use cosmos_core::{
 
 use crate::netty::{network_helpers::NetworkTick, server_listener::server_listen_messages};
 
+use super::entities::RequestedEntityEvent;
+
 /// Sends bodies to players only if it's within their render distance.
 fn send_bodies(
     players: &Query<(&Player, &RenderDistance, &Location)>,
@@ -87,11 +90,26 @@ fn server_sync_bodies(
     }
 }
 
+fn pinger(mut server: ResMut<RenetServer>, mut event_reader: EventReader<RequestedEntityEvent>, mut commands: Commands) {
+    for ev in event_reader.iter() {
+        if commands.get_entity(ev.entity).is_some() {
+            server.send_message(
+                ev.client_id,
+                NettyChannelServer::Reliable,
+                cosmos_encoder::serialize(&ServerReliableMessages::RequestedEntityReceived(ev.entity)),
+            );
+        }
+    }
+}
+
 pub(super) fn register(app: &mut App) {
     app.add_systems(
         Update,
         // This really needs to run immediately after `add_previous_location` to make sure nothing causes any desync
         // in location + transform, but for now it's fine.
-        server_sync_bodies.after(add_previous_location).before(server_listen_messages),
+        (
+            server_sync_bodies.after(add_previous_location).before(server_listen_messages),
+            pinger,
+        ),
     );
 }
diff --git a/cosmos_server/src/persistence/loading.rs b/cosmos_server/src/persistence/loading.rs
index 2851a6085..818a15d39 100644
--- a/cosmos_server/src/persistence/loading.rs
+++ b/cosmos_server/src/persistence/loading.rs
@@ -27,7 +27,7 @@ fn check_needs_loaded(query: Query<(Entity, &SaveFileIdentifier), (Without<Seria
     for (ent, nl) in query.iter() {
         let path = nl.get_save_file_path();
         let Ok(data) = fs::read(&path) else {
-            warn!("Error reading record at '{path}'. Is it corrupted?");
+            warn!("Error reading file at '{path}'. Is it there?");
             commands.entity(ent).despawn_recursive();
             continue;
         };
diff --git a/cosmos_server/src/structure/planet/biosphere/biome/mod.rs b/cosmos_server/src/structure/planet/biosphere/biome/mod.rs
index 2c8a4a31a..651ce870a 100644
--- a/cosmos_server/src/structure/planet/biosphere/biome/mod.rs
+++ b/cosmos_server/src/structure/planet/biosphere/biome/mod.rs
@@ -3,6 +3,7 @@
 use std::{
     hash::Hash,
     marker::PhantomData,
+    mem::size_of,
     sync::{Arc, RwLock, RwLockReadGuard},
 };
 
@@ -1000,7 +1001,7 @@ pub struct BiosphereBiomesRegistry<T: BiosphereMarkerComponent> {
     _phantom: PhantomData<T>,
 
     /// Contains a list of indicies to the biomes vec
-    lookup_table: Arc<RwLock<[u8; LOOKUP_TABLE_SIZE]>>,
+    lookup_table: Arc<RwLock<Box<[u8; LOOKUP_TABLE_SIZE]>>>,
 
     /// All the registered biomes
     biomes: Vec<Arc<RwLock<Box<dyn Biome>>>>,
@@ -1032,7 +1033,7 @@ impl<T: BiosphereMarkerComponent> BiosphereBiomesRegistry<T> {
     pub fn new() -> Self {
         Self {
             _phantom: Default::default(),
-            lookup_table: Arc::new(RwLock::new([0; LOOKUP_TABLE_SIZE])),
+            lookup_table: Arc::new(RwLock::new(Box::new([0; LOOKUP_TABLE_SIZE]))),
             biomes: vec![],
             todo_biomes: Default::default(),
         }
@@ -1041,7 +1042,7 @@ impl<T: BiosphereMarkerComponent> BiosphereBiomesRegistry<T> {
     fn construct_lookup_table(&mut self) {
         info!("Creating biome lookup table! This could take a bit...");
 
-        let mut lookup_table: std::sync::RwLockWriteGuard<'_, [u8; 1000000]> = self.lookup_table.write().unwrap();
+        let mut lookup_table: std::sync::RwLockWriteGuard<'_, Box<[u8; 1000000]>> = self.lookup_table.write().unwrap();
 
         for z in 0..LOOKUP_TABLE_PRECISION {
             for y in 0..LOOKUP_TABLE_PRECISION {
@@ -1137,8 +1138,28 @@ fn construct_lookup_tables<T: BiosphereMarkerComponent>(mut registry: ResMut<Bio
 ///
 /// You don't normally have to call this manually, because is automatically called in `register_biosphere`
 pub fn create_biosphere_biomes_registry<T: BiosphereMarkerComponent>(app: &mut App) {
+    println!("A");
+    println!("A");
+    println!("A");
+    println!("A");
+    println!("A");
+    println!("Size: {}", size_of::<BiosphereBiomesRegistry<T>>());
+
+    // let le = Box::new([0; LOOKUP_TABLE_SIZE]);
+
+    // let x = BiosphereBiomesRegistry::<T> {
+    //     biomes: vec![],
+    //     lookup_table: Arc::new(RwLock::new(le)),
+    //     todo_biomes: vec![],
+    //     _phantom: Default::default(),
+    // };
+
+    println!("made x!");
+
     app.init_resource::<BiosphereBiomesRegistry<T>>()
         .add_systems(OnExit(GameState::PostLoading), construct_lookup_tables::<T>);
+
+    println!("Inited resource!");
 }
 
 pub(super) fn register(app: &mut App) {
diff --git a/cosmos_server/src/structure/ship/build_mode.rs b/cosmos_server/src/structure/ship/build_mode.rs
index af1a776f9..faf1503cd 100644
--- a/cosmos_server/src/structure/ship/build_mode.rs
+++ b/cosmos_server/src/structure/ship/build_mode.rs
@@ -3,7 +3,7 @@
 use bevy::prelude::{in_state, App, Changed, EventReader, EventWriter, IntoSystemConfigs, Query, Res, ResMut, Update};
 use bevy_renet::renet::RenetServer;
 use cosmos_core::{
-    block::Block,
+    block::{block_events::BlockInteractEvent, Block},
     entities::player::Player,
     netty::{cosmos_encoder, server_reliable_messages::ServerReliableMessages, NettyChannelServer},
     registry::{identifiable::Identifiable, Registry},
@@ -13,7 +13,7 @@ use cosmos_core::{
     },
 };
 
-use crate::{events::blocks::block_events::BlockInteractEvent, state::GameState};
+use crate::state::GameState;
 
 fn interact_with_block(
     mut event_reader: EventReader<BlockInteractEvent>,
diff --git a/cosmos_server/src/universe/asteroid_spawner.rs b/cosmos_server/src/universe/asteroid_spawner.rs
index 4cb1a4e3d..eb242b9b7 100644
--- a/cosmos_server/src/universe/asteroid_spawner.rs
+++ b/cosmos_server/src/universe/asteroid_spawner.rs
@@ -121,10 +121,6 @@ fn spawn_asteroid(
     }
 }
 
-fn print_n(query: Query<&Asteroid>) {
-    println!("N: {}", query.iter().len());
-}
-
 pub(super) fn register(app: &mut App) {
     app.add_systems(
         Update,
@@ -132,6 +128,5 @@ pub(super) fn register(app: &mut App) {
             .run_if(on_timer(Duration::from_secs(1)))
             .run_if(in_state(GameState::Playing)),
     )
-    .insert_resource(CachedSectors::default())
-    .add_systems(Update, print_n);
+    .insert_resource(CachedSectors::default());
 }