diff --git a/cosmos_client/assets/images/blocks/build_block.png b/cosmos_client/assets/images/blocks/build_block.png
new file mode 100644
index 000000000..371b68028
Binary files /dev/null and b/cosmos_client/assets/images/blocks/build_block.png differ
diff --git a/cosmos_client/src/entities/player/player_movement.rs b/cosmos_client/src/entities/player/player_movement.rs
index bedf2f69e..1a823fe8c 100644
--- a/cosmos_client/src/entities/player/player_movement.rs
+++ b/cosmos_client/src/entities/player/player_movement.rs
@@ -2,7 +2,7 @@
 
 use bevy::prelude::*;
 use bevy_rapier3d::prelude::Velocity;
-use cosmos_core::structure::ship::pilot::Pilot;
+use cosmos_core::structure::ship::{build_mode::BuildMode, pilot::Pilot};
 
 use crate::{
     input::inputs::{CosmosInputs, InputChecker, InputHandler},
@@ -15,7 +15,10 @@ use crate::{
 fn process_player_movement(
     time: Res<Time>,
     input_handler: InputChecker,
-    mut query: Query<(Entity, &mut Velocity, &Transform, Option<&PlayerAlignment>), (With<LocalPlayer>, Without<Pilot>)>,
+    mut query: Query<
+        (Entity, &mut Velocity, &Transform, Option<&PlayerAlignment>),
+        (With<LocalPlayer>, Without<Pilot>, Without<BuildMode>),
+    >,
     cam_query: Query<&Transform, With<MainCamera>>,
     parent_query: Query<&Parent>,
     global_transform_query: Query<&GlobalTransform>,
diff --git a/cosmos_client/src/input/inputs.rs b/cosmos_client/src/input/inputs.rs
index c36141fa2..100e4553a 100644
--- a/cosmos_client/src/input/inputs.rs
+++ b/cosmos_client/src/input/inputs.rs
@@ -100,6 +100,9 @@ pub enum CosmosInputs {
     ToggleInventory,
     /// "Shift-Clicking" an item in minecraft
     AutoMoveItem,
+
+    /// Toggles the player between being in build mode and not on a ship
+    ToggleBuildMode,
 }
 
 fn init_input(mut input_handler: ResMut<CosmosInputHandler>) {
@@ -154,6 +157,8 @@ fn init_input(mut input_handler: ResMut<CosmosInputHandler>) {
 
     input_handler.set_keycode(CosmosInputs::ToggleInventory, KeyCode::T);
     input_handler.set_keycode(CosmosInputs::AutoMoveItem, KeyCode::ShiftLeft);
+
+    input_handler.set_keycode(CosmosInputs::ToggleBuildMode, KeyCode::B);
 }
 
 #[derive(Resource, Default, Debug)]
diff --git a/cosmos_client/src/netty/gameplay/receiver.rs b/cosmos_client/src/netty/gameplay/receiver.rs
index b229ba9a5..5275ce77f 100644
--- a/cosmos_client/src/netty/gameplay/receiver.rs
+++ b/cosmos_client/src/netty/gameplay/receiver.rs
@@ -36,7 +36,12 @@ use cosmos_core::{
         dynamic_structure::DynamicStructure,
         full_structure::FullStructure,
         planet::{biosphere::BiosphereMarker, planet_builder::TPlanetBuilder},
-        ship::{pilot::Pilot, ship_builder::TShipBuilder, Ship},
+        ship::{
+            build_mode::{EnterBuildModeEvent, ExitBuildModeEvent},
+            pilot::Pilot,
+            ship_builder::TShipBuilder,
+            Ship,
+        },
         ChunkInitEvent, Structure,
     },
 };
@@ -173,6 +178,8 @@ pub(crate) fn client_sync_players(
     mut pilot_change_event_writer: EventWriter<ChangePilotEvent>,
     mut requested_entities: ResMut<RequestedEntities>,
     time: Res<Time>,
+
+    (mut build_mode_enter, mut build_mode_exit): (EventWriter<EnterBuildModeEvent>, EventWriter<ExitBuildModeEvent>),
 ) {
     let client_id = transport.client_id();
 
@@ -580,6 +587,24 @@ pub(crate) fn client_sync_players(
                     }
                 }
             }
+            ServerReliableMessages::PlayerEnterBuildMode {
+                player_entity,
+                structure_entity,
+            } => {
+                if let Some(player_entity) = network_mapping.client_from_server(&player_entity) {
+                    if let Some(structure_entity) = network_mapping.client_from_server(&structure_entity) {
+                        build_mode_enter.send(EnterBuildModeEvent {
+                            player_entity,
+                            structure_entity,
+                        });
+                    }
+                }
+            }
+            ServerReliableMessages::PlayerExitBuildMode { player_entity } => {
+                if let Some(player_entity) = network_mapping.client_from_server(&player_entity) {
+                    build_mode_exit.send(ExitBuildModeEvent { player_entity });
+                }
+            }
         }
     }
 }
diff --git a/cosmos_client/src/structure/planet/align_player.rs b/cosmos_client/src/structure/planet/align_player.rs
index 5a512b34f..a669d62b8 100644
--- a/cosmos_client/src/structure/planet/align_player.rs
+++ b/cosmos_client/src/structure/planet/align_player.rs
@@ -122,7 +122,7 @@ pub enum Axis {
     Z,
 }
 
-#[derive(Debug, Component, Default)]
+#[derive(Debug, Component, Default, Clone, Copy, PartialEq, Eq)]
 /// Used to represent the player's orientation on a planet
 pub struct PlayerAlignment(pub Axis);
 
diff --git a/cosmos_client/src/structure/ship/build_mode.rs b/cosmos_client/src/structure/ship/build_mode.rs
new file mode 100644
index 000000000..26b638929
--- /dev/null
+++ b/cosmos_client/src/structure/ship/build_mode.rs
@@ -0,0 +1,109 @@
+//! Handles the build mode logic on the client-side
+
+use bevy::{
+    prelude::{in_state, App, IntoSystemConfigs, Query, Res, ResMut, Transform, Update, Vec3, With, Without},
+    time::Time,
+};
+use bevy_rapier3d::prelude::Velocity;
+use bevy_renet::renet::RenetClient;
+use cosmos_core::{
+    netty::{client_reliable_messages::ClientReliableMessages, cosmos_encoder, NettyChannelClient},
+    structure::{chunk::CHUNK_DIMENSIONSF, ship::build_mode::BuildMode},
+};
+
+use crate::{
+    input::inputs::{CosmosInputs, InputChecker, InputHandler},
+    netty::flags::LocalPlayer,
+    rendering::MainCamera,
+    state::game_state::GameState,
+    structure::planet::align_player::{self, PlayerAlignment},
+};
+
+fn exit_build_mode(
+    input_handler: InputChecker,
+    local_player_in_build_mode: Query<(), (With<LocalPlayer>, With<BuildMode>)>,
+    mut client: ResMut<RenetClient>,
+) {
+    if local_player_in_build_mode.get_single().is_ok() {
+        if input_handler.check_just_pressed(CosmosInputs::ToggleBuildMode) {
+            client.send_message(
+                NettyChannelClient::Reliable,
+                cosmos_encoder::serialize(&ClientReliableMessages::ExitBuildMode),
+            );
+        }
+    }
+}
+
+fn control_build_mode(
+    input_handler: InputChecker,
+    cam_query: Query<&Transform, With<MainCamera>>,
+    time: Res<Time>,
+    mut query: Query<(&mut Transform, &mut Velocity, Option<&PlayerAlignment>), (With<LocalPlayer>, With<BuildMode>, Without<MainCamera>)>,
+) {
+    if let Ok((mut transform, mut velocity, player_alignment)) = query.get_single_mut() {
+        velocity.linvel = Vec3::ZERO;
+        velocity.angvel = Vec3::ZERO;
+
+        let cam_trans = transform.mul_transform(*cam_query.single());
+
+        let max_speed: f32 = match input_handler.check_pressed(CosmosInputs::Sprint) {
+            false => 5.0,
+            true => 20.0,
+        };
+
+        let mut forward = cam_trans.forward();
+        let mut right = cam_trans.right();
+        let up = transform.up();
+
+        match player_alignment.copied().unwrap_or_default().0 {
+            align_player::Axis::X => {
+                forward.x = 0.0;
+                right.x = 0.0;
+            }
+            align_player::Axis::Y => {
+                forward.y = 0.0;
+                right.y = 0.0;
+            }
+            align_player::Axis::Z => {
+                forward.z = 0.0;
+                right.z = 0.0;
+            }
+        }
+
+        forward = forward.normalize_or_zero() * max_speed;
+        right = right.normalize_or_zero() * max_speed;
+        let movement_up = up * max_speed;
+
+        let time = time.delta_seconds();
+
+        if input_handler.check_pressed(CosmosInputs::MoveForward) {
+            transform.translation += forward * time;
+        }
+        if input_handler.check_pressed(CosmosInputs::MoveBackward) {
+            transform.translation -= forward * time;
+        }
+        if input_handler.check_pressed(CosmosInputs::MoveUp) {
+            transform.translation += movement_up * time;
+        }
+        if input_handler.check_pressed(CosmosInputs::MoveDown) {
+            transform.translation -= movement_up * time;
+        }
+        if input_handler.check_pressed(CosmosInputs::MoveLeft) {
+            transform.translation -= right * time;
+        }
+        if input_handler.check_pressed(CosmosInputs::MoveRight) {
+            transform.translation += right * time;
+        }
+
+        let max = CHUNK_DIMENSIONSF * 10.0;
+
+        transform.translation = transform.translation.clamp(Vec3::new(-max, -max, -max), Vec3::new(max, max, max));
+    }
+}
+
+pub(super) fn register(app: &mut App) {
+    app.add_systems(
+        Update,
+        (exit_build_mode, control_build_mode).chain().run_if(in_state(GameState::Playing)),
+    );
+}
diff --git a/cosmos_client/src/structure/ship/mod.rs b/cosmos_client/src/structure/ship/mod.rs
index 1e72472d1..c51dca597 100644
--- a/cosmos_client/src/structure/ship/mod.rs
+++ b/cosmos_client/src/structure/ship/mod.rs
@@ -11,7 +11,7 @@ use cosmos_core::{
     physics::location::{handle_child_syncing, Location},
     structure::{
         chunk::CHUNK_DIMENSIONSF,
-        ship::{pilot::Pilot, Ship},
+        ship::{build_mode::BuildMode, pilot::Pilot, Ship},
         Structure,
     },
 };
@@ -22,6 +22,7 @@ use crate::{
     state::game_state::GameState,
 };
 
+pub mod build_mode;
 pub mod client_ship_builder;
 pub mod ship_movement;
 
@@ -129,14 +130,14 @@ fn respond_to_collisions(
 }
 
 fn remove_parent_when_too_far(
-    mut query: Query<(Entity, &Parent, &mut Location, &Transform), (With<LocalPlayer>, Without<Ship>)>,
+    mut query: Query<(Entity, &Parent, &mut Location, &Transform), (With<LocalPlayer>, Without<Ship>, Without<BuildMode>)>,
     is_ship: Query<&Location, With<Ship>>,
     mut commands: Commands,
     mut renet_client: ResMut<RenetClient>,
 ) {
     if let Ok((player_entity, parent, mut player_loc, player_trans)) = query.get_single_mut() {
         if let Ok(ship_loc) = is_ship.get(parent.get()) {
-            if player_loc.distance_sqrd(ship_loc).sqrt() >= CHUNK_DIMENSIONSF * 2.0 {
+            if player_loc.distance_sqrd(ship_loc).sqrt() >= CHUNK_DIMENSIONSF * 10.0 {
                 commands.entity(player_entity).remove_parent();
 
                 player_loc.last_transform_loc = Some(player_trans.translation);
@@ -151,6 +152,7 @@ fn remove_parent_when_too_far(
 }
 
 pub(super) fn register(app: &mut App) {
+    build_mode::register(app);
     client_ship_builder::register(app);
     ship_movement::register(app);
 
diff --git a/cosmos_client/src/structure/ship/ship_movement.rs b/cosmos_client/src/structure/ship/ship_movement.rs
index 0e27510b3..46363489f 100644
--- a/cosmos_client/src/structure/ship/ship_movement.rs
+++ b/cosmos_client/src/structure/ship/ship_movement.rs
@@ -8,6 +8,7 @@ use bevy_renet::renet::RenetClient;
 use cosmos_core::netty::client_reliable_messages::ClientReliableMessages;
 use cosmos_core::netty::client_unreliable_messages::ClientUnreliableMessages;
 use cosmos_core::netty::{cosmos_encoder, NettyChannelClient};
+use cosmos_core::structure::ship::build_mode::BuildMode;
 use cosmos_core::structure::ship::pilot::Pilot;
 use cosmos_core::structure::ship::ship_movement::ShipMovement;
 
@@ -19,7 +20,7 @@ use crate::window::setup::DeltaCursorPosition;
 
 fn process_ship_movement(
     input_handler: InputChecker,
-    query: Query<Entity, (With<LocalPlayer>, With<Pilot>)>,
+    query: Query<Entity, (With<LocalPlayer>, With<Pilot>, Without<BuildMode>)>,
     mut client: ResMut<RenetClient>,
     mut crosshair_offset: ResMut<CrosshairOffset>,
     cursor_delta_position: Res<DeltaCursorPosition>,
diff --git a/cosmos_core/src/block/blocks.rs b/cosmos_core/src/block/blocks.rs
index 504370632..e951721b0 100644
--- a/cosmos_core/src/block/blocks.rs
+++ b/cosmos_core/src/block/blocks.rs
@@ -174,6 +174,13 @@ fn add_cosmos_blocks(
             .create(),
     );
 
+    blocks.register(
+        BlockBuilder::new("cosmos:build_block", 2.0)
+            .add_property(BlockProperty::Opaque)
+            .add_property(BlockProperty::Full)
+            .create(),
+    );
+
     loading.finish_loading(id, &mut end_writer);
 }
 
diff --git a/cosmos_core/src/block/hardness/mod.rs b/cosmos_core/src/block/hardness/mod.rs
index 793205c20..13dadfd05 100644
--- a/cosmos_core/src/block/hardness/mod.rs
+++ b/cosmos_core/src/block/hardness/mod.rs
@@ -74,6 +74,7 @@ fn register_block_hardness(blocks: Res<Registry<Block>>, mut registry: ResMut<Re
     register_hardness(&mut registry, 100.0, &blocks, "cosmos:ship_core");
     register_hardness(&mut registry, 20.0, &blocks, "cosmos:energy_cell");
     register_hardness(&mut registry, 20.0, &blocks, "cosmos:reactor");
+    register_hardness(&mut registry, 20.0, &blocks, "cosmos:build_block");
     register_hardness(&mut registry, 20.0, &blocks, "cosmos:laser_cannon");
     register_hardness(&mut registry, 20.0, &blocks, "cosmos:thruster");
     register_hardness(&mut registry, 20.0, &blocks, "cosmos:light");
diff --git a/cosmos_core/src/netty/client_reliable_messages.rs b/cosmos_core/src/netty/client_reliable_messages.rs
index 5891ade13..31baa2831 100644
--- a/cosmos_core/src/netty/client_reliable_messages.rs
+++ b/cosmos_core/src/netty/client_reliable_messages.rs
@@ -89,4 +89,8 @@ pub enum ClientReliableMessages {
         /// The ship the player wants to walk on
         ship_entity: Entity,
     },
+    /// Sent whenever a client wants to exit build mode
+    ///
+    /// Requires server confirmation via [`ServerReliableMessages::PlayerExitBuildMode`] or client will do nothing
+    ExitBuildMode,
 }
diff --git a/cosmos_core/src/netty/server_reliable_messages.rs b/cosmos_core/src/netty/server_reliable_messages.rs
index 22eefc3f5..a6982f345 100644
--- a/cosmos_core/src/netty/server_reliable_messages.rs
+++ b/cosmos_core/src/netty/server_reliable_messages.rs
@@ -142,4 +142,16 @@ pub enum ServerReliableMessages {
         /// The ship the player is walking on
         ship_entity: Entity,
     },
+    /// Sent when a player enters build mode
+    PlayerEnterBuildMode {
+        /// The player entity on the server
+        player_entity: Entity,
+        /// The structure entity they're building on the server
+        structure_entity: Entity,
+    },
+    /// Sent whenever a player exits build mode
+    PlayerExitBuildMode {
+        /// The server's player entity that's exiting
+        player_entity: Entity,
+    },
 }
diff --git a/cosmos_core/src/structure/ship/build_mode.rs b/cosmos_core/src/structure/ship/build_mode.rs
new file mode 100644
index 000000000..c7ccb3d5f
--- /dev/null
+++ b/cosmos_core/src/structure/ship/build_mode.rs
@@ -0,0 +1,59 @@
+//! Handles build-mode functionality
+//!
+//! Note that build mode is currently only intended for ships, but is not yet manually limited to only ships.
+
+use bevy::prelude::{App, BuildChildren, Commands, Component, Entity, Event, EventReader, Update};
+use bevy_rapier3d::prelude::{RigidBodyDisabled, Sensor};
+
+#[derive(Component, Default)]
+/// Denotes that a player is in build mode
+pub struct BuildMode;
+
+#[derive(Event)]
+/// This event is sent when a player is entering build mode
+pub struct EnterBuildModeEvent {
+    /// The player that's entering build mode
+    pub player_entity: Entity,
+    /// The structure they are entering build mode for
+    ///
+    /// Multiple players can be building on the same structure
+    pub structure_entity: Entity,
+}
+
+#[derive(Event)]
+/// This event is sent when a player is done being in build mode
+pub struct ExitBuildModeEvent {
+    /// The player done being in build mode
+    pub player_entity: Entity,
+}
+
+fn enter_build_mode_listener(mut commands: Commands, mut event_reader: EventReader<EnterBuildModeEvent>) {
+    for ev in event_reader.iter() {
+        let Some(mut ecmds) = commands.get_entity(ev.player_entity) else {
+            continue;
+        };
+
+        ecmds
+            .insert(BuildMode::default())
+            .insert(RigidBodyDisabled)
+            .insert(Sensor)
+            .set_parent(ev.structure_entity);
+    }
+}
+
+fn exit_build_mode_listener(mut commands: Commands, mut event_reader: EventReader<ExitBuildModeEvent>) {
+    for ev in event_reader.iter() {
+        let Some(mut ecmds) = commands.get_entity(ev.player_entity) else {
+            continue;
+        };
+
+        // Keep them as a child of the ship
+        ecmds.remove::<BuildMode>().remove::<RigidBodyDisabled>().remove::<Sensor>();
+    }
+}
+
+pub(super) fn register(app: &mut App) {
+    app.add_systems(Update, (enter_build_mode_listener, exit_build_mode_listener))
+        .add_event::<EnterBuildModeEvent>()
+        .add_event::<ExitBuildModeEvent>();
+}
diff --git a/cosmos_core/src/structure/ship/mod.rs b/cosmos_core/src/structure/ship/mod.rs
index 9bbf97542..e88ea7638 100644
--- a/cosmos_core/src/structure/ship/mod.rs
+++ b/cosmos_core/src/structure/ship/mod.rs
@@ -7,6 +7,7 @@ use bevy::prelude::Component;
 use bevy::prelude::States;
 use bevy::reflect::Reflect;
 
+pub mod build_mode;
 pub mod core;
 pub mod pilot;
 pub mod ship_builder;
@@ -21,4 +22,5 @@ pub(super) fn register<T: States + Clone + Copy>(app: &mut App, playing_state: T
     ship_movement::register(app);
     core::register(app, playing_state);
     ship_builder::register(app);
+    build_mode::register(app);
 }
diff --git a/cosmos_core/src/structure/ship/ship_builder.rs b/cosmos_core/src/structure/ship/ship_builder.rs
index 9b41232c3..32c4407e9 100644
--- a/cosmos_core/src/structure/ship/ship_builder.rs
+++ b/cosmos_core/src/structure/ship/ship_builder.rs
@@ -2,7 +2,7 @@
 
 use bevy::{
     ecs::system::EntityCommands,
-    prelude::{Added, App, Commands, Entity, Query, Update},
+    prelude::{Added, App, Commands, Entity, Name, Query, Update},
 };
 use bevy_rapier3d::prelude::{Ccd, ExternalImpulse, ReadMassProperties, RigidBody, Velocity};
 
@@ -49,6 +49,7 @@ fn on_add_ship(query: Query<Entity, Added<Ship>>, mut commands: Commands) {
             Ccd::enabled(),
             ExternalImpulse::default(),
             LoadingDistance::new(6, 7),
+            Name::new("Ship"),
         ));
     }
 }
diff --git a/cosmos_server/src/events/netty/netty_events.rs b/cosmos_server/src/events/netty/netty_events.rs
index 95a031acc..045249102 100644
--- a/cosmos_server/src/events/netty/netty_events.rs
+++ b/cosmos_server/src/events/netty/netty_events.rs
@@ -27,7 +27,7 @@ fn generate_player_inventory(items: &Registry<Item>) -> Inventory {
 
     inventory.insert_item_at(0, items.from_id("cosmos:ice").expect("Ice item to exist"), 1);
 
-    inventory.insert_item_at(1, items.from_id("cosmos:water").expect("Water item to exist"), 1);
+    inventory.insert_item_at(1, items.from_id("cosmos:build_block").expect("Water item to exist"), 64);
 
     inventory.insert_item_at(2, items.from_id("cosmos:glass").expect("Glass item to exist"), 64);
 
diff --git a/cosmos_server/src/netty/server_listener.rs b/cosmos_server/src/netty/server_listener.rs
index 180494fc4..589f3ba63 100644
--- a/cosmos_server/src/netty/server_listener.rs
+++ b/cosmos_server/src/netty/server_listener.rs
@@ -8,6 +8,7 @@ use bevy_renet::renet::RenetServer;
 use cosmos_core::netty::netty_rigidbody::NettyRigidBodyLocation;
 use cosmos_core::netty::{cosmos_encoder, NettyChannelClient, NettyChannelServer};
 use cosmos_core::physics::location::Location;
+use cosmos_core::structure::ship::build_mode::ExitBuildModeEvent;
 use cosmos_core::structure::systems::{SystemActive, Systems};
 use cosmos_core::{
     entities::player::Player,
@@ -38,19 +39,30 @@ pub fn server_listen_messages(
     mut server: ResMut<RenetServer>,
     lobby: ResMut<ServerLobby>,
     structure_query: Query<&Structure>,
-    mut systems_query: Query<&mut Systems>,
-    mut break_block_event: EventWriter<BlockBreakEvent>,
-    mut block_interact_event: EventWriter<BlockInteractEvent>,
-    mut place_block_event: EventWriter<BlockPlaceEvent>,
-    mut create_ship_event_writer: EventWriter<CreateShipEvent>,
-
+    (
+        mut systems_query,
+        mut break_block_event,
+        mut place_block_event,
+        mut block_interact_event,
+        mut exit_build_mode_writer,
+        mut create_ship_event_writer,
+        mut requested_entities_writer,
+        mut request_chunk_event_writer,
+    ): (
+        Query<&mut Systems>,
+        EventWriter<BlockBreakEvent>,
+        EventWriter<BlockPlaceEvent>,
+        EventWriter<BlockInteractEvent>,
+        EventWriter<ExitBuildModeEvent>,
+        EventWriter<CreateShipEvent>,
+        EventWriter<RequestedEntityEvent>,
+        EventWriter<RequestChunkEvent>,
+    ),
     (mut ship_movement_event_writer, mut pilot_change_event_writer): (EventWriter<ShipSetMovementEvent>, EventWriter<ChangePilotEvent>),
     pilot_query: Query<&Pilot>,
     player_parent_location: Query<&Location, Without<Player>>,
     mut change_player_query: Query<(&mut Transform, &mut Location, &mut PlayerLooking, &mut Velocity), With<Player>>,
     non_player_transform_query: Query<&Transform, Without<Player>>,
-    mut requested_entities_writer: EventWriter<RequestedEntityEvent>,
-    mut request_chunk_event_writer: EventWriter<RequestChunkEvent>,
 ) {
     for client_id in server.clients_id().into_iter() {
         while let Some(message) = server.receive_message(client_id, NettyChannelClient::Unreliable) {
@@ -268,6 +280,11 @@ pub fn server_listen_messages(
                         }
                     }
                 }
+                ClientReliableMessages::ExitBuildMode => {
+                    if let Some(player_entity) = lobby.player_from_id(client_id) {
+                        exit_build_mode_writer.send(ExitBuildModeEvent { player_entity });
+                    }
+                }
             }
         }
     }
diff --git a/cosmos_server/src/structure/ship/build_mode.rs b/cosmos_server/src/structure/ship/build_mode.rs
new file mode 100644
index 000000000..60fe43bde
--- /dev/null
+++ b/cosmos_server/src/structure/ship/build_mode.rs
@@ -0,0 +1,65 @@
+//! Handles server-side build mode logic
+
+use bevy::prelude::{in_state, App, EventReader, EventWriter, IntoSystemConfigs, Query, Res, ResMut, Update};
+use bevy_renet::renet::RenetServer;
+use cosmos_core::{
+    block::Block,
+    netty::{cosmos_encoder, server_reliable_messages::ServerReliableMessages, NettyChannelServer},
+    registry::{identifiable::Identifiable, Registry},
+    structure::{
+        ship::build_mode::{EnterBuildModeEvent, ExitBuildModeEvent},
+        Structure,
+    },
+};
+
+use crate::{events::blocks::block_events::BlockInteractEvent, state::GameState};
+
+fn interact_with_block(
+    mut event_reader: EventReader<BlockInteractEvent>,
+    structure_query: Query<&Structure>,
+    mut enter_writer: EventWriter<EnterBuildModeEvent>,
+    blocks: Res<Registry<Block>>,
+) {
+    for ev in event_reader.iter() {
+        if let Ok(structure) = structure_query.get(ev.structure_entity) {
+            if ev.structure_block.block(structure, &blocks).unlocalized_name() == "cosmos:build_block" {
+                enter_writer.send(EnterBuildModeEvent {
+                    player_entity: ev.interactor,
+                    structure_entity: ev.structure_entity,
+                });
+            }
+        }
+    }
+}
+
+fn enter_build_mode(mut server: ResMut<RenetServer>, mut event_reader: EventReader<EnterBuildModeEvent>) {
+    for ev in event_reader.iter() {
+        server.broadcast_message(
+            NettyChannelServer::Reliable,
+            cosmos_encoder::serialize(&ServerReliableMessages::PlayerEnterBuildMode {
+                player_entity: ev.player_entity,
+                structure_entity: ev.structure_entity,
+            }),
+        );
+    }
+}
+
+fn exit_build_mode(mut server: ResMut<RenetServer>, mut event_reader: EventReader<ExitBuildModeEvent>) {
+    for ev in event_reader.iter() {
+        server.broadcast_message(
+            NettyChannelServer::Reliable,
+            cosmos_encoder::serialize(&ServerReliableMessages::PlayerExitBuildMode {
+                player_entity: ev.player_entity,
+            }),
+        );
+    }
+}
+
+pub(super) fn register(app: &mut App) {
+    app.add_systems(
+        Update,
+        (interact_with_block, enter_build_mode, exit_build_mode)
+            .chain()
+            .run_if(in_state(GameState::Playing)),
+    );
+}
diff --git a/cosmos_server/src/structure/ship/mod.rs b/cosmos_server/src/structure/ship/mod.rs
index cfe9d1226..6a5e985e0 100644
--- a/cosmos_server/src/structure/ship/mod.rs
+++ b/cosmos_server/src/structure/ship/mod.rs
@@ -2,6 +2,7 @@
 
 use bevy::prelude::App;
 
+pub mod build_mode;
 mod change_pilot_event_listener;
 pub mod loading;
 mod persistence;
@@ -13,4 +14,5 @@ pub(super) fn register(app: &mut App) {
     loading::register(app);
     persistence::register(app);
     sync::register(app);
+    build_mode::register(app);
 }