diff --git a/README.md b/README.md
index da8ae7924..c2bc67225 100644
--- a/README.md
+++ b/README.md
@@ -7,14 +7,14 @@ If you're interested, join our new discord server here:
 
 ## Screenshots
 
-Cosmos has ships that you can pilot through space. (And yes those are working laser cannons.)
-![](./showcase/ship_in_space.png)
+Cosmos is a game where you can create your dream spaceship that you can pilot through space. (And add those are working laser cannons.)
+![](./showcase/gunship_top.png)
 
-Build your own ship block by block and walk inside while flying through space.
-![](./showcase/inside_ship.png)
+Build your own ship block by block and walk inside with friends while cruising through space.
+![](./showcase/gunner_flying_towards_planet.png)
 
 Once you reach your destination, make a _hopefully safer than this_ landing.
-![](./showcase/ship_on_ground.png)
+![](./showcase/safely_landed_gunner.png)
 
 ## Compilation
 
@@ -34,10 +34,6 @@ For the server, navigate to the cosmos_server directory and run
 
 For release builds, append the `--release` flag to the build/run commands.
 
-To compile the workspace (not normally necessary), navigate to the root directory of the repo and run
-
-`cargo build`
-
 ## Documentation
 
 The first time you view the cosmos documentation, run the following commands
@@ -98,6 +94,15 @@ See [the issues page](https://github.com/AnthonyTornetta/Cosmos/issues) for the
 - [x] Update to bevy 0.11
   - [x] Update physics
   - [x] Update bevy
+- [x] GUI to interact with inventory
+  - [x] Easier way of adding 3d blocks to GUI
+  - [x] Move items around in inventory via mouse
+- [x] Structure build mode
+  - [x] Interact with build block to enter build mode
+  - [x] Build mode
+    - [x] Camera becomes a noclip free cam and goes outside of player's body.
+    - [x] Player no longer piloting ship, & is able to create + destroy blocks on the ship but ONLY the ship
+    - [x] Symmetry modes are added that will mirror blocks on user-defined axis
 
 ## Release 0.0.4a
 
@@ -251,14 +256,6 @@ See [the issues page](https://github.com/AnthonyTornetta/Cosmos/issues) for the
 
 ## Everything that will still have to be done after 0.0.5a
 
-- [ ] GUI to interact with inventory
-  - [ ] Easier way of adding 3d blocks to GUI
-  - [ ] Move items around in inventory via mouse
-- [ ] Structure build mode
-  - [ ] Press B while piloting ship to enter build mode
-  - [ ] Build mode
-    - [ ] Camera becomes a noclip free cam and goes outside of player's body.
-    - [ ] Player no longer piloting ship, & is able to create + destroy blocks on the ship but ONLY the ship
 - [ ] Mining beam system
   - [ ] Mining beam block
     - [ ] Can be placed in line to create more powerful miners
@@ -279,9 +276,6 @@ See [the issues page](https://github.com/AnthonyTornetta/Cosmos/issues) for the
   - [ ] Camera block
   - [ ] Use left/right to switch between ship cameras
     - [ ] Changes where your view is
-- [ ] Planet Generation
-  - [ ] New planet types
-  - [ ] A bunch of new blocks
 - [ ] Shops
   - [ ] Sell blocks/items
   - [ ] Buy blocks/items
diff --git a/cosmos_client/assets/cosmos/shaders/repeated.wgsl b/cosmos_client/assets/cosmos/shaders/repeated.wgsl
new file mode 100644
index 000000000..9fb9ccaf4
--- /dev/null
+++ b/cosmos_client/assets/cosmos/shaders/repeated.wgsl
@@ -0,0 +1,70 @@
+// Stolen and heavily modified from: https://github.com/janhohenheim/foxtrot/blob/main/assets/shaders/repeated.wgsl - TY!
+
+#import bevy_pbr::mesh_vertex_output MeshVertexOutput
+#import bevy_pbr::mesh_vertex_output as OutputTypes
+#import bevy_pbr::pbr_functions as PbrCore
+#import bevy_pbr::pbr_bindings as MaterialBindings
+#import bevy_pbr::pbr_types as PbrTypes
+#import bevy_pbr::mesh_view_bindings as ViewBindings
+
+struct Repeats {
+    horizontal: u32,
+    vertical: u32,
+    _wasm_padding1: u32,
+    _wasm_padding2: u32,
+}
+
+@group(1) @binding(0)
+var texture: texture_2d<f32>;
+@group(1) @binding(1)
+var texture_sampler: sampler;
+@group(1) @binding(2)
+var<uniform> repeats: Repeats;
+@group(1) @binding(3)
+var<uniform> color: vec4<f32>;
+
+fn get_texture_sample(coords: vec2<f32>) -> vec4<f32> {
+    let repeated_coords = vec2<f32>(
+        (coords.x % (1. / f32(repeats.horizontal))) * f32(repeats.horizontal),
+        (coords.y % (1. / f32(repeats.vertical))) * f32(repeats.vertical)
+    );
+    return textureSample(texture, texture_sampler, repeated_coords);
+}
+
+/// Adapted from <https://github.com/bevyengine/bevy/blob/main/crates/bevy_pbr/src/render/pbr.wgsl#L30>
+fn get_pbr_output(in: MeshVertexOutput) -> vec4<f32> {
+    var material = PbrTypes::standard_material_new();
+    material.perceptual_roughness = 1.0;
+
+    var output_color: vec4<f32> = color;
+    
+    output_color = PbrCore::alpha_discard(material, output_color);
+
+#ifdef TONEMAP_IN_SHADER
+        output_color = tone_mapping(output_color);
+#endif
+#ifdef DEBAND_DITHER
+    var output_rgb = output_color.rgb;
+    output_rgb = powsafe(output_rgb, 1.0 / 2.2);
+    output_rgb = output_rgb + screen_space_dither(in.frag_coord.xy);
+    // This conversion back to linear space is required because our output texture format is
+    // SRGB; the GPU will assume our output is linear and will apply an SRGB conversion.
+    output_rgb = powsafe(output_rgb, 2.2);
+    output_color = vec4(output_rgb, output_color.a);
+#endif
+#ifdef PREMULTIPLY_ALPHA
+        output_color = premultiply_alpha(material.flags, output_color);
+#endif
+    return output_color;
+}
+
+@fragment
+fn fragment(mesh: MeshVertexOutput) -> @location(0) vec4<f32> {
+    let texture = get_texture_sample(mesh.uv);
+    if (texture[3] < 0.5) {
+        discard;
+    }
+    let pbr_output = get_pbr_output(mesh);
+
+    return texture * pbr_output;
+}
\ No newline at end of file
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/assets/images/misc/symmetry.png b/cosmos_client/assets/images/misc/symmetry.png
new file mode 100644
index 000000000..9ae0ab903
Binary files /dev/null and b/cosmos_client/assets/images/misc/symmetry.png differ
diff --git a/cosmos_client/assets/lang/blocks/en_us.lang b/cosmos_client/assets/lang/blocks/en_us.lang
index 5d7ba5fad..68fd97c0a 100644
--- a/cosmos_client/assets/lang/blocks/en_us.lang
+++ b/cosmos_client/assets/lang/blocks/en_us.lang
@@ -18,3 +18,4 @@ cosmos:molten_stone=Molten Stone
 cosmos:cheese=Cheese (Lava)
 cosmos:ice=Ice
 cosmos:water=Water
+cosmos:build_block=Build Block
diff --git a/cosmos_client/src/asset/mod.rs b/cosmos_client/src/asset/mod.rs
index e72e60728..40fdacc5d 100644
--- a/cosmos_client/src/asset/mod.rs
+++ b/cosmos_client/src/asset/mod.rs
@@ -4,7 +4,9 @@ use bevy::prelude::App;
 
 pub mod asset_loader;
 pub mod asset_loading;
+pub mod repeating_material;
 
 pub(super) fn register(app: &mut App) {
     asset_loading::register(app);
+    repeating_material::register(app);
 }
diff --git a/cosmos_client/src/asset/repeating_material.rs b/cosmos_client/src/asset/repeating_material.rs
new file mode 100644
index 000000000..62d212260
--- /dev/null
+++ b/cosmos_client/src/asset/repeating_material.rs
@@ -0,0 +1,42 @@
+//! A garbage repeated material. Don't use this.
+
+use bevy::{
+    prelude::{AlphaMode, App, Color, Handle, Image, Material, MaterialPlugin},
+    reflect::{Reflect, TypeUuid},
+    render::render_resource::{AsBindGroup, ShaderRef, ShaderType},
+};
+
+#[repr(C, align(16))] // All WebGPU uniforms must be aligned to 16 bytes
+#[derive(Clone, Copy, ShaderType, Debug, Hash, Eq, PartialEq, Default, Reflect)]
+pub(crate) struct Repeats {
+    pub(crate) horizontal: u32,
+    pub(crate) vertical: u32,
+    pub(crate) _wasm_padding1: u32,
+    pub(crate) _wasm_padding2: u32,
+}
+
+#[derive(AsBindGroup, Debug, Clone, TypeUuid, Reflect)]
+#[uuid = "82d336c5-fd6c-41a3-bdd4-267cd4c9be22"]
+pub(crate) struct UnlitRepeatedMaterial {
+    #[texture(0)]
+    #[sampler(1)]
+    pub(crate) texture: Handle<Image>,
+    #[uniform(2)]
+    pub(crate) repeats: Repeats,
+    #[uniform(3)]
+    pub(crate) color: Color,
+}
+
+impl Material for UnlitRepeatedMaterial {
+    fn fragment_shader() -> ShaderRef {
+        "cosmos/shaders/repeated.wgsl".into()
+    }
+
+    fn alpha_mode(&self) -> AlphaMode {
+        AlphaMode::Mask(0.5)
+    }
+}
+
+pub(super) fn register(app: &mut App) {
+    app.add_plugins(MaterialPlugin::<UnlitRepeatedMaterial>::default());
+}
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/events/ship/create_ship.rs b/cosmos_client/src/events/ship/create_ship.rs
index 6abf14965..baed6e065 100644
--- a/cosmos_client/src/events/ship/create_ship.rs
+++ b/cosmos_client/src/events/ship/create_ship.rs
@@ -1,11 +1,15 @@
 //! Event & its processing for when a player wants to create a ship
 
-use bevy::prelude::{in_state, App, Event, EventReader, EventWriter, IntoSystemConfigs, ResMut, Update};
+use bevy::prelude::{in_state, App, Event, EventReader, EventWriter, IntoSystemConfigs, Query, ResMut, Update, With};
 use bevy_renet::renet::RenetClient;
-use cosmos_core::netty::{client_reliable_messages::ClientReliableMessages, cosmos_encoder, NettyChannelClient};
+use cosmos_core::{
+    netty::{client_reliable_messages::ClientReliableMessages, cosmos_encoder, NettyChannelClient},
+    structure::ship::build_mode::BuildMode,
+};
 
 use crate::{
     input::inputs::{CosmosInputs, InputChecker, InputHandler},
+    netty::flags::LocalPlayer,
     state::game_state::GameState,
 };
 
@@ -15,7 +19,16 @@ pub struct CreateShipEvent {
     name: String,
 }
 
-fn listener(input_handler: InputChecker, mut event_writer: EventWriter<CreateShipEvent>) {
+fn listener(
+    in_build_mode: Query<(), (With<LocalPlayer>, With<BuildMode>)>,
+    input_handler: InputChecker,
+    mut event_writer: EventWriter<CreateShipEvent>,
+) {
+    if in_build_mode.get_single().is_ok() {
+        // Don't create ships while in build mode
+        return;
+    }
+
     if input_handler.check_just_pressed(CosmosInputs::CreateShip) {
         event_writer.send(CreateShipEvent { name: "Cool name".into() });
     }
diff --git a/cosmos_client/src/input/inputs.rs b/cosmos_client/src/input/inputs.rs
index c36141fa2..5c319fbaf 100644
--- a/cosmos_client/src/input/inputs.rs
+++ b/cosmos_client/src/input/inputs.rs
@@ -100,6 +100,17 @@ 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,
+    /// A toggle to clear the symmetry - when combined with a symmetry key the symmetry will be cleared
+    ClearSymmetry,
+    /// Creates an X symmetry
+    SymmetryX,
+    /// Creates a Y symmetry
+    SymmetryY,
+    /// Creates a Z symmetry
+    SymmetryZ,
 }
 
 fn init_input(mut input_handler: ResMut<CosmosInputHandler>) {
@@ -154,6 +165,12 @@ 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);
+    input_handler.set_keycode(CosmosInputs::ClearSymmetry, KeyCode::ShiftLeft);
+    input_handler.set_keycode(CosmosInputs::SymmetryX, KeyCode::X);
+    input_handler.set_keycode(CosmosInputs::SymmetryY, KeyCode::Y);
+    input_handler.set_keycode(CosmosInputs::SymmetryZ, KeyCode::Z);
 }
 
 #[derive(Resource, Default, Debug)]
diff --git a/cosmos_client/src/interactions/block_interactions.rs b/cosmos_client/src/interactions/block_interactions.rs
index 4d99e8a56..d7e534057 100644
--- a/cosmos_client/src/interactions/block_interactions.rs
+++ b/cosmos_client/src/interactions/block_interactions.rs
@@ -28,10 +28,17 @@ pub enum InteractionType {
     Primary,
 }
 
+#[derive(Component, Debug)]
+/// Stores the block the player is last noted as looked at
+pub struct LookingAt {
+    /// The block the player is looking at
+    pub looking_at_block: Option<(Entity, StructureBlock)>,
+}
+
 fn process_player_interaction(
     input_handler: InputChecker,
     camera: Query<&GlobalTransform, With<MainCamera>>,
-    player_body: Query<Entity, (With<LocalPlayer>, Without<Pilot>)>,
+    mut player_body: Query<(Entity, &mut Inventory, Option<&mut LookingAt>), (With<LocalPlayer>, Without<Pilot>)>,
     rapier_context: Res<RapierContext>,
     parent_query: Query<&Parent>,
     chunk_physics_part: Query<&ChunkPhysicsPart>,
@@ -40,10 +47,10 @@ fn process_player_interaction(
     mut place_writer: EventWriter<BlockPlaceEvent>,
     mut interact_writer: EventWriter<BlockInteractEvent>,
     hotbar: Query<&Hotbar>,
-    mut inventory: Query<&mut Inventory, With<LocalPlayer>>,
     items: Res<Registry<Item>>,
     block_items: Res<BlockItems>,
     cursor_flags: Res<CursorFlags>,
+    mut commands: Commands,
 ) {
     // They're in a menu if the cursor isn't locked
     if !cursor_flags.is_cursor_locked() {
@@ -51,11 +58,14 @@ fn process_player_interaction(
     }
 
     // this fails if the player is a pilot
-    let Ok(player_body) = player_body.get_single() else {
+    let Ok((player_body, mut inventory, looking_at)) = player_body.get_single_mut() else {
         return;
     };
 
     let Ok(cam_trans) = camera.get_single() else {
+        if let Some(mut looking_at) = looking_at {
+            looking_at.looking_at_block = None;
+        }
         return;
     };
 
@@ -67,26 +77,44 @@ fn process_player_interaction(
         true,
         QueryFilter::new().exclude_rigid_body(player_body), // don't want to hit yourself
     ) else {
+        if let Some(mut looking_at) = looking_at {
+            looking_at.looking_at_block = None;
+        }
         return;
     };
 
     let entity = chunk_physics_part.get(entity).map(|x| x.chunk_entity).unwrap_or(entity);
 
     let Ok(parent) = parent_query.get(entity) else {
+        if let Some(mut looking_at) = looking_at {
+            looking_at.looking_at_block = None;
+        }
         return;
     };
 
     let Ok((structure, transform, is_planet)) = structure_query.get(parent.get()) else {
+        if let Some(mut looking_at) = looking_at {
+            looking_at.looking_at_block = None;
+        }
         return;
     };
 
     let structure_physics_transform = transform;
 
-    if input_handler.check_just_pressed(CosmosInputs::BreakBlock) {
-        let moved_point = intersection.point - intersection.normal * 0.3;
+    let moved_point = intersection.point - intersection.normal * 0.3;
 
-        let point = structure_physics_transform.compute_matrix().inverse().transform_point3(moved_point);
+    let point = structure_physics_transform.compute_matrix().inverse().transform_point3(moved_point);
 
+    if let Ok(coords) = structure.relative_coords_to_local_coords_checked(point.x, point.y, point.z) {
+        let looking_at_block = Some((parent.get(), StructureBlock::new(coords)));
+        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 });
+        }
+    }
+
+    if input_handler.check_just_pressed(CosmosInputs::BreakBlock) {
         if let Ok(coords) = structure.relative_coords_to_local_coords_checked(point.x, point.y, point.z) {
             break_writer.send(BlockBreakEvent {
                 structure_entity: structure.get_entity().unwrap(),
@@ -96,36 +124,34 @@ fn process_player_interaction(
     }
 
     if input_handler.check_just_pressed(CosmosInputs::PlaceBlock) {
-        if let Ok(mut inventory) = inventory.get_single_mut() {
-            if let Ok(hotbar) = hotbar.get_single() {
-                let inventory_slot = hotbar.selected_slot();
-
-                if let Some(is) = inventory.itemstack_at(inventory_slot) {
-                    let item = items.from_numeric_id(is.item_id());
-
-                    if let Some(block_id) = block_items.block_from_item(item) {
-                        let moved_point = intersection.point + intersection.normal * 0.75;
-
-                        let point = structure_physics_transform.compute_matrix().inverse().transform_point3(moved_point);
-
-                        if let Ok(coords) = structure.relative_coords_to_local_coords_checked(point.x, point.y, point.z) {
-                            if structure.is_within_blocks(coords) {
-                                inventory.decrease_quantity_at(inventory_slot, 1);
-
-                                let block_up = if is_planet.is_some() {
-                                    Planet::planet_face(structure, coords)
-                                } else {
-                                    BlockFace::Top
-                                };
-
-                                place_writer.send(BlockPlaceEvent {
-                                    structure_entity: structure.get_entity().unwrap(),
-                                    coords: StructureBlock::new(coords),
-                                    inventory_slot,
-                                    block_id,
-                                    block_up,
-                                });
-                            }
+        if let Ok(hotbar) = hotbar.get_single() {
+            let inventory_slot = hotbar.selected_slot();
+
+            if let Some(is) = inventory.itemstack_at(inventory_slot) {
+                let item = items.from_numeric_id(is.item_id());
+
+                if let Some(block_id) = block_items.block_from_item(item) {
+                    let moved_point = intersection.point + intersection.normal * 0.75;
+
+                    let point = structure_physics_transform.compute_matrix().inverse().transform_point3(moved_point);
+
+                    if let Ok(coords) = structure.relative_coords_to_local_coords_checked(point.x, point.y, point.z) {
+                        if structure.is_within_blocks(coords) {
+                            inventory.decrease_quantity_at(inventory_slot, 1);
+
+                            let block_up = if is_planet.is_some() {
+                                Planet::planet_face(structure, coords)
+                            } else {
+                                BlockFace::Top
+                            };
+
+                            place_writer.send(BlockPlaceEvent {
+                                structure_entity: structure.get_entity().unwrap(),
+                                coords: StructureBlock::new(coords),
+                                inventory_slot,
+                                block_id,
+                                block_up,
+                            });
                         }
                     }
                 }
@@ -134,10 +160,6 @@ fn process_player_interaction(
     }
 
     if input_handler.check_just_pressed(CosmosInputs::Interact) {
-        let moved_point = intersection.point - intersection.normal * 0.3;
-
-        let point = structure_physics_transform.compute_matrix().inverse().transform_point3(moved_point);
-
         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(),
diff --git a/cosmos_client/src/main.rs b/cosmos_client/src/main.rs
index 3b7010ab1..a424a6c68 100644
--- a/cosmos_client/src/main.rs
+++ b/cosmos_client/src/main.rs
@@ -30,7 +30,9 @@ pub mod universe;
 pub mod window;
 
 use std::env;
+use std::time::Duration;
 
+use bevy::asset::ChangeWatcher;
 use bevy::core::TaskPoolThreadAssignmentPolicy;
 use bevy_renet::transport::NetcodeClientPlugin;
 use cosmos_core::netty::get_local_ipaddress;
@@ -92,6 +94,14 @@ fn main() {
                         ..Default::default()
                     },
                 })
+                .set(AssetPlugin {
+                    watch_for_changes: if cfg!(debug_assertions) {
+                        ChangeWatcher::with_delay(Duration::from_secs(1))
+                    } else {
+                        None
+                    },
+                    ..Default::default()
+                })
                 .set(ImagePlugin::default_nearest()),
         )
         .add_plugins(CosmosCorePluginGroup::new(
diff --git a/cosmos_client/src/netty/gameplay/receiver.rs b/cosmos_client/src/netty/gameplay/receiver.rs
index b229ba9a5..111b4f730 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,
     },
 };
@@ -150,11 +155,13 @@ fn lerp_towards(
 
 pub(crate) fn client_sync_players(
     mut commands: Commands,
-    mut meshes: ResMut<Assets<Mesh>>,
-    mut client: ResMut<RenetClient>,
-    transport: Res<NetcodeClientTransport>,
-    mut lobby: ResMut<ClientLobby>,
-    mut network_mapping: ResMut<NetworkMapping>,
+    (mut meshes, mut client, transport, mut lobby, mut network_mapping): (
+        ResMut<Assets<Mesh>>,
+        ResMut<RenetClient>,
+        Res<NetcodeClientTransport>,
+        ResMut<ClientLobby>,
+        ResMut<NetworkMapping>,
+    ),
     mut set_chunk_event_writer: EventWriter<ChunkInitEvent>,
     mut block_change_event_writer: EventWriter<BlockChangedEvent>,
     (query_player, parent_query): (Query<&Player>, Query<&Parent>),
@@ -173,6 +180,9 @@ pub(crate) fn client_sync_players(
     mut pilot_change_event_writer: EventWriter<ChangePilotEvent>,
     mut requested_entities: ResMut<RequestedEntities>,
     time: Res<Time>,
+    local_player: Query<Entity, With<LocalPlayer>>,
+
+    (mut build_mode_enter, mut build_mode_exit): (EventWriter<EnterBuildModeEvent>, EventWriter<ExitBuildModeEvent>),
 ) {
     let client_id = transport.client_id();
 
@@ -339,6 +349,7 @@ pub(crate) fn client_sync_players(
                                 BloomSettings { ..Default::default() },
                                 CameraHelper::default(),
                                 Skybox(Handle::default()),
+                                Name::new("Main Camera"),
                                 MainCamera,
                                 // No double UI rendering
                                 UiCameraConfig { show_ui: false },
@@ -348,6 +359,7 @@ pub(crate) fn client_sync_players(
 
                     commands.spawn((
                         PlayerWorld { player: client_entity },
+                        Name::new("Player World"),
                         loc,
                         PhysicsWorld {
                             world_id: DEFAULT_WORLD_ID,
@@ -580,6 +592,29 @@ 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 });
+                }
+            }
+            ServerReliableMessages::UpdateBuildMode { build_mode } => {
+                if let Ok(player_entity) = local_player.get_single() {
+                    commands.entity(player_entity).insert(build_mode);
+                }
+            }
         }
     }
 }
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..e25f3ce05
--- /dev/null
+++ b/cosmos_client/src/structure/ship/build_mode.rs
@@ -0,0 +1,341 @@
+//! Handles the build mode logic on the client-side
+
+use bevy::{
+    pbr::{NotShadowCaster, NotShadowReceiver},
+    prelude::{
+        in_state, shape, App, AssetServer, Assets, BuildChildren, Changed, Color, Commands, Component, DespawnRecursiveExt, Entity,
+        EventReader, IntoSystemConfigs, MaterialMeshBundle, Mesh, Name, Parent, 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,
+        coordinates::BlockCoordinate,
+        ship::{
+            build_mode::{BuildAxis, BuildMode, ExitBuildModeEvent},
+            core::DieWithStructure,
+        },
+        Structure,
+    },
+};
+
+use crate::{
+    asset::repeating_material::{Repeats, UnlitRepeatedMaterial},
+    input::inputs::{CosmosInputs, InputChecker, InputHandler},
+    interactions::block_interactions::LookingAt,
+    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() && input_handler.check_just_pressed(CosmosInputs::ToggleBuildMode) {
+        client.send_message(
+            NettyChannelClient::Reliable,
+            cosmos_encoder::serialize(&ClientReliableMessages::ExitBuildMode),
+        );
+    }
+}
+
+#[derive(Component, Clone, Copy, Default)]
+struct SymmetryVisuals(Option<Entity>, Option<Entity>, Option<Entity>);
+
+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>)>,
+) {
+    let Ok((mut transform, mut velocity, player_alignment)) = query.get_single_mut() else {
+        return;
+    };
+    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));
+}
+
+fn place_symmetries(
+    mut client: ResMut<RenetClient>,
+    input_handler: InputChecker,
+    query: Query<&LookingAt, (With<LocalPlayer>, With<BuildMode>)>,
+) {
+    let Ok(looking_at) = query.get_single() else {
+        return;
+    };
+
+    let clearing = input_handler.check_pressed(CosmosInputs::ClearSymmetry);
+
+    let looking_at_block = if !clearing {
+        looking_at.looking_at_block.map(|x| x.1)
+    } else {
+        None
+    };
+
+    if !clearing && looking_at_block.is_none() {
+        return;
+    }
+
+    if input_handler.check_just_pressed(CosmosInputs::SymmetryX) {
+        client.send_message(
+            NettyChannelClient::Reliable,
+            cosmos_encoder::serialize(&ClientReliableMessages::SetSymmetry {
+                axis: BuildAxis::X,
+                coordinate: looking_at_block.map(|block| block.x),
+            }),
+        )
+    }
+
+    if input_handler.check_just_pressed(CosmosInputs::SymmetryY) {
+        client.send_message(
+            NettyChannelClient::Reliable,
+            cosmos_encoder::serialize(&ClientReliableMessages::SetSymmetry {
+                axis: BuildAxis::Y,
+                coordinate: looking_at_block.map(|block| block.y),
+            }),
+        )
+    }
+
+    if input_handler.check_just_pressed(CosmosInputs::SymmetryZ) {
+        client.send_message(
+            NettyChannelClient::Reliable,
+            cosmos_encoder::serialize(&ClientReliableMessages::SetSymmetry {
+                axis: BuildAxis::Z,
+                coordinate: looking_at_block.map(|block| block.z),
+            }),
+        )
+    }
+}
+
+fn clear_visuals(
+    parent_query: Query<&Parent>,
+    visuals_query: Query<&SymmetryVisuals>,
+    mut event_reader: EventReader<ExitBuildModeEvent>,
+    mut commands: Commands,
+) {
+    for ev in event_reader.iter() {
+        let Ok(parent) = parent_query.get(ev.player_entity).map(|p| p.get()) else {
+            continue;
+        };
+        let Some(mut ecmds) = commands.get_entity(parent) else {
+            continue;
+        };
+
+        ecmds.remove::<SymmetryVisuals>();
+
+        if let Ok(sym_visuals) = visuals_query.get(parent) {
+            if let Some(ent) = sym_visuals.0 {
+                commands.entity(ent).despawn_recursive();
+            }
+            if let Some(ent) = sym_visuals.1 {
+                commands.entity(ent).despawn_recursive();
+            }
+            if let Some(ent) = sym_visuals.2 {
+                commands.entity(ent).despawn_recursive();
+            }
+        }
+    }
+}
+
+fn change_visuals(
+    mut commands: Commands,
+    query: Query<(&BuildMode, &Parent), (With<LocalPlayer>, Changed<BuildMode>)>,
+    structure_query: Query<&Structure>,
+    visuals: Query<&SymmetryVisuals>,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<UnlitRepeatedMaterial>>,
+    asset_server: Res<AssetServer>,
+) {
+    let Ok((build_mode, parent)) = query.get_single() else {
+        return;
+    };
+    let structure_entity = parent.get();
+    let Ok(structure) = structure_query.get(structure_entity) else {
+        return;
+    };
+
+    let mut visuals = visuals.get(structure_entity).copied().unwrap_or_default();
+
+    if let Some(ent) = visuals.0 {
+        commands.entity(ent).despawn_recursive();
+        visuals.0 = None;
+    }
+    if let Some(ent) = visuals.1 {
+        commands.entity(ent).despawn_recursive();
+        visuals.1 = None;
+    }
+    if let Some(ent) = visuals.2 {
+        commands.entity(ent).despawn_recursive();
+        visuals.2 = None;
+    }
+
+    let texture_handle = asset_server.load("images/misc/symmetry.png");
+
+    let size = structure.block_dimensions().x;
+
+    if let Some(coords) = build_mode.get_symmetry(BuildAxis::X) {
+        let coords = structure.block_relative_position(BlockCoordinate::new(coords, 0, 0));
+
+        commands.entity(structure_entity).with_children(|ecmds| {
+            visuals.0 = Some(
+                ecmds
+                    .spawn((
+                        DieWithStructure,
+                        NotShadowCaster,
+                        NotShadowReceiver,
+                        Name::new("X Axis - build mode"),
+                        MaterialMeshBundle {
+                            mesh: meshes.add(shape::Box::new(0.001, size as f32, size as f32).into()),
+                            material: materials.add(UnlitRepeatedMaterial {
+                                repeats: Repeats {
+                                    horizontal: size as u32 / 4,
+                                    vertical: size as u32 / 4,
+                                    ..Default::default()
+                                },
+                                texture: texture_handle.clone(),
+                                color: Color::rgb(1.0, 0.0, 0.0),
+                            }),
+                            transform: Transform::from_xyz(coords.x, 0.5, 0.5),
+                            ..Default::default()
+                        },
+                    ))
+                    .id(),
+            );
+        });
+    }
+
+    if let Some(coords) = build_mode.get_symmetry(BuildAxis::Y) {
+        let coords = structure.block_relative_position(BlockCoordinate::new(0, coords, 0));
+
+        commands.entity(structure_entity).with_children(|ecmds| {
+            visuals.1 = Some(
+                ecmds
+                    .spawn((
+                        DieWithStructure,
+                        NotShadowCaster,
+                        NotShadowReceiver,
+                        Name::new("Y Axis - build mode"),
+                        MaterialMeshBundle {
+                            mesh: meshes.add(shape::Box::new(size as f32, 0.001, size as f32).into()),
+                            material: materials.add(UnlitRepeatedMaterial {
+                                repeats: Repeats {
+                                    horizontal: size as u32 / 4,
+                                    vertical: size as u32 / 4,
+                                    ..Default::default()
+                                },
+                                texture: texture_handle.clone(),
+                                color: Color::rgb(0.0, 1.0, 0.0),
+                            }),
+                            transform: Transform::from_xyz(0.5, coords.y, 0.5),
+                            ..Default::default()
+                        },
+                    ))
+                    .id(),
+            );
+        });
+    }
+
+    if let Some(coords) = build_mode.get_symmetry(BuildAxis::Z) {
+        let coords = structure.block_relative_position(BlockCoordinate::new(0, 0, coords));
+
+        commands.entity(structure_entity).with_children(|ecmds| {
+            visuals.2 = Some(
+                ecmds
+                    .spawn((
+                        DieWithStructure,
+                        NotShadowCaster,
+                        NotShadowReceiver,
+                        Name::new("Z Axis - build mode"),
+                        MaterialMeshBundle {
+                            mesh: meshes.add(shape::Box::new(size as f32, size as f32, 0.001).into()),
+                            material: materials.add(UnlitRepeatedMaterial {
+                                repeats: Repeats {
+                                    horizontal: size as u32 / 4,
+                                    vertical: size as u32 / 4,
+                                    ..Default::default()
+                                },
+                                texture: texture_handle.clone(),
+                                color: Color::rgb(0.0, 0.0, 1.0),
+                            }),
+                            transform: Transform::from_xyz(0.5, 0.5, coords.z),
+                            ..Default::default()
+                        },
+                    ))
+                    .id(),
+            );
+        });
+    }
+
+    commands.entity(structure_entity).insert(visuals);
+}
+
+pub(super) fn register(app: &mut App) {
+    app.add_systems(
+        Update,
+        (place_symmetries, exit_build_mode, control_build_mode, change_visuals, clear_visuals)
+            .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_client/src/universe/star.rs b/cosmos_client/src/universe/star.rs
index bb02c9fb0..7453c851c 100644
--- a/cosmos_client/src/universe/star.rs
+++ b/cosmos_client/src/universe/star.rs
@@ -5,8 +5,8 @@ use std::f32::consts::PI;
 use bevy::{
     pbr::NotShadowCaster,
     prelude::{
-        shape, Added, App, Assets, Commands, DirectionalLight, DirectionalLightBundle, Entity, EulerRot, Mesh, OnEnter, PbrBundle, Quat,
-        Query, ResMut, StandardMaterial, Transform, Update, Vec3, With, Without,
+        shape, Added, App, Assets, Commands, DirectionalLight, DirectionalLightBundle, Entity, EulerRot, Mesh, Name, OnEnter, PbrBundle,
+        Quat, Query, ResMut, StandardMaterial, Transform, Update, Vec3, With, Without,
     },
 };
 use cosmos_core::{physics::location::SECTOR_DIMENSIONS, universe::star::Star};
@@ -62,19 +62,22 @@ fn create_added_star(
 
 /// There is only ever one light source for stars, it is just moved around as needed
 fn create_star_light_source(mut commands: Commands) {
-    commands.spawn(DirectionalLightBundle {
-        directional_light: DirectionalLight {
-            illuminance: 30000.0,
-            shadows_enabled: true,
-            ..Default::default()
-        },
-        transform: Transform {
-            translation: Vec3::ZERO,
-            rotation: Quat::from_euler(EulerRot::XYZ, -PI / 4.0, 0.1, 0.1),
+    commands.spawn((
+        Name::new("Star Light Emitter"),
+        DirectionalLightBundle {
+            directional_light: DirectionalLight {
+                illuminance: 30000.0,
+                shadows_enabled: true,
+                ..Default::default()
+            },
+            transform: Transform {
+                translation: Vec3::ZERO,
+                rotation: Quat::from_euler(EulerRot::XYZ, -PI / 4.0, 0.1, 0.1),
+                ..Default::default()
+            },
             ..Default::default()
         },
-        ..Default::default()
-    });
+    ));
 }
 
 pub(super) fn register(app: &mut App) {
diff --git a/cosmos_core/src/block/blocks.rs b/cosmos_core/src/block/blocks.rs
index 504370632..93a73ca9a 100644
--- a/cosmos_core/src/block/blocks.rs
+++ b/cosmos_core/src/block/blocks.rs
@@ -43,13 +43,6 @@ fn add_cosmos_blocks(
             .create(),
     );
 
-    blocks.register(
-        BlockBuilder::new("cosmos:log", 3.0)
-            .add_property(BlockProperty::Opaque)
-            .add_property(BlockProperty::Full)
-            .create(),
-    );
-
     blocks.register(
         BlockBuilder::new("cosmos:cherry_leaf", 0.1)
             .add_property(BlockProperty::Transparent)
@@ -174,6 +167,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/item/mod.rs b/cosmos_core/src/item/mod.rs
index 137cba8a9..9722d171e 100644
--- a/cosmos_core/src/item/mod.rs
+++ b/cosmos_core/src/item/mod.rs
@@ -31,7 +31,7 @@ impl Identifiable for Item {
 }
 
 /// The max stack size for items, should load this from config file in future
-pub const DEFAULT_MAX_STACK_SIZE: u16 = 64;
+pub const DEFAULT_MAX_STACK_SIZE: u16 = 999;
 
 impl Item {
     /// Creates an item
diff --git a/cosmos_core/src/netty/client_reliable_messages.rs b/cosmos_core/src/netty/client_reliable_messages.rs
index 5891ade13..0474c054e 100644
--- a/cosmos_core/src/netty/client_reliable_messages.rs
+++ b/cosmos_core/src/netty/client_reliable_messages.rs
@@ -7,7 +7,11 @@ use serde::{Deserialize, Serialize};
 use crate::{
     block::BlockFace,
     entities::player::render_distance::RenderDistance,
-    structure::{coordinates::ChunkCoordinate, structure_block::StructureBlock},
+    structure::{
+        coordinates::{ChunkCoordinate, CoordinateType},
+        ship::build_mode::BuildAxis,
+        structure_block::StructureBlock,
+    },
 };
 
 #[derive(Debug, Serialize, Deserialize, Component)]
@@ -89,4 +93,15 @@ 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,
+    /// Sent by the player to update their symmetry
+    SetSymmetry {
+        /// The axis they are changing
+        axis: BuildAxis,
+        /// None if they want to remove it, otherwise the respective axis's coordinate
+        coordinate: Option<CoordinateType>,
+    },
 }
diff --git a/cosmos_core/src/netty/server_reliable_messages.rs b/cosmos_core/src/netty/server_reliable_messages.rs
index 22eefc3f5..c73447c74 100644
--- a/cosmos_core/src/netty/server_reliable_messages.rs
+++ b/cosmos_core/src/netty/server_reliable_messages.rs
@@ -14,6 +14,7 @@ use crate::{
         coordinates::{ChunkCoordinate, CoordinateType},
         loading::ChunksNeedLoaded,
         planet::Planet,
+        ship::build_mode::BuildMode,
         structure_block::StructureBlock,
     },
     universe::star::Star,
@@ -142,4 +143,23 @@ 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,
+    },
+    /// Updates the player's build mode.
+    ///
+    /// Only used to update symmetry axis.
+    UpdateBuildMode {
+        /// The new build mode
+        build_mode: BuildMode,
+    },
 }
diff --git a/cosmos_core/src/structure/asteroid/asteroid_builder.rs b/cosmos_core/src/structure/asteroid/asteroid_builder.rs
index b82e758ba..18744e4a0 100644
--- a/cosmos_core/src/structure/asteroid/asteroid_builder.rs
+++ b/cosmos_core/src/structure/asteroid/asteroid_builder.rs
@@ -1,6 +1,6 @@
 //! Used to build an asteroid
 
-use bevy::ecs::system::EntityCommands;
+use bevy::{ecs::system::EntityCommands, prelude::Name};
 use bevy_rapier3d::prelude::{RigidBody, Velocity};
 
 use crate::{
@@ -36,6 +36,7 @@ impl<T: TStructureBuilder> TAsteroidBuilder for AsteroidBuilder<T> {
 
         entity.insert((
             Asteroid,
+            Name::new("Asteroid"),
             RigidBody::Fixed,
             LoadingDistance::new(ASTEROID_LOAD_RADIUS, ASTEROID_UNLOAD_RADIUS),
         ));
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..f57d28ce9
--- /dev/null
+++ b/cosmos_core/src/structure/ship/build_mode.rs
@@ -0,0 +1,147 @@
+//! 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, Changed, Commands, Component, Entity, Event, EventReader, EventWriter, Parent, Query, Update, With, Without,
+    },
+    reflect::Reflect,
+};
+use bevy_rapier3d::prelude::{RigidBodyDisabled, Sensor};
+use serde::{Deserialize, Serialize};
+
+use crate::structure::coordinates::CoordinateType;
+
+type BuildModeSymmetries = (Option<CoordinateType>, Option<CoordinateType>, Option<CoordinateType>);
+
+#[derive(Component, Debug, Default, Reflect, Serialize, Deserialize, Clone, Copy)]
+/// Denotes that a player is in build mode
+///
+/// The player's parent will be the structure they are building
+pub struct BuildMode {
+    symmetries: BuildModeSymmetries,
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
+/// Represents the X/Y/Z symmetry axis
+pub enum BuildAxis {
+    /// X axis
+    X,
+    /// Y axis
+    Y,
+    /// Z axis
+    Z,
+}
+
+impl BuildMode {
+    fn internal_set_symmetry(&mut self, axis: BuildAxis, coordinate: Option<CoordinateType>) {
+        match axis {
+            BuildAxis::X => self.symmetries.0 = coordinate,
+            BuildAxis::Y => self.symmetries.1 = coordinate,
+            BuildAxis::Z => self.symmetries.2 = coordinate,
+        }
+    }
+
+    /// Sets the symmetry for this axis
+    pub fn set_symmetry(&mut self, axis: BuildAxis, coordinate: CoordinateType) {
+        self.internal_set_symmetry(axis, Some(coordinate));
+    }
+
+    /// Removes the symmetry from this axis
+    pub fn remove_symmetry(&mut self, axis: BuildAxis) {
+        self.internal_set_symmetry(axis, None);
+    }
+
+    /// Gets the symmetry for this axis - `None` if there is no symmetry present.
+    pub fn get_symmetry(&self, axis: BuildAxis) -> Option<CoordinateType> {
+        match axis {
+            BuildAxis::X => self.symmetries.0,
+            BuildAxis::Y => self.symmetries.1,
+            BuildAxis::Z => self.symmetries.2,
+        }
+    }
+}
+
+#[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>()
+            .remove::<InBuildModeFlag>();
+    }
+}
+
+#[derive(Component)]
+struct InBuildModeFlag;
+
+fn exit_build_mode_when_parent_dies(
+    query: Query<Entity, (With<BuildMode>, Without<Parent>)>,
+    changed_query: Query<(Entity, Option<&InBuildModeFlag>), (With<BuildMode>, Changed<Parent>)>,
+    mut event_writer: EventWriter<ExitBuildModeEvent>,
+    mut commands: Commands,
+) {
+    for entity in query.iter() {
+        event_writer.send(ExitBuildModeEvent { player_entity: entity });
+    }
+
+    for (entity, in_build_mode) in changed_query.iter() {
+        if in_build_mode.is_some() {
+            event_writer.send(ExitBuildModeEvent { player_entity: entity });
+        } else {
+            commands.entity(entity).insert(InBuildModeFlag);
+        }
+    }
+}
+
+pub(super) fn register(app: &mut App) {
+    app.add_systems(
+        Update,
+        (
+            enter_build_mode_listener,
+            exit_build_mode_when_parent_dies,
+            exit_build_mode_listener,
+        ),
+    )
+    .add_event::<EnterBuildModeEvent>()
+    .add_event::<ExitBuildModeEvent>()
+    .register_type::<BuildMode>();
+}
diff --git a/cosmos_core/src/structure/ship/core.rs b/cosmos_core/src/structure/ship/core.rs
index 7e53c8a8c..245066fc5 100644
--- a/cosmos_core/src/structure/ship/core.rs
+++ b/cosmos_core/src/structure/ship/core.rs
@@ -32,11 +32,17 @@ fn monitor_block_events(mut commands: Commands, blocks: Res<Registry<Block>>, mu
     }
 }
 
+#[derive(Component)]
+/// 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;
+
 /// 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>)>>,
+    is_this_structure: Query<(), Or<(With<ChunkEntity>, With<StructureSystem>, With<DieWithStructure>)>>,
     mut commands: Commands,
 ) {
     for children in query.iter() {
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/blocks/block_events.rs b/cosmos_server/src/events/blocks/block_events.rs
index 9e4f4a06c..04c575c66 100644
--- a/cosmos_server/src/events/blocks/block_events.rs
+++ b/cosmos_server/src/events/blocks/block_events.rs
@@ -5,7 +5,6 @@ use bevy_renet::renet::RenetServer;
 use cosmos_core::{
     block::{blocks::AIR_BLOCK_ID, Block, BlockFace},
     blockitems::BlockItems,
-    entities::player::Player,
     events::block_events::BlockChangedEvent,
     inventory::Inventory,
     item::Item,
@@ -15,7 +14,12 @@ use cosmos_core::{
         NettyChannelServer,
     },
     registry::{identifiable::Identifiable, Registry},
-    structure::{structure_block::StructureBlock, Structure},
+    structure::{
+        coordinates::{BlockCoordinate, CoordinateType, UnboundCoordinateType},
+        ship::build_mode::{BuildAxis, BuildMode},
+        structure_block::StructureBlock,
+        Structure,
+    },
 };
 
 use crate::GameState;
@@ -65,73 +69,193 @@ fn handle_block_break_events(
     blocks: Res<Registry<Block>>,
     items: Res<Registry<Item>>,
     block_items: Res<BlockItems>, // TODO: Replace this with drop table
-    mut inventory_query: Query<&mut Inventory>,
+    mut player_query: Query<(&mut Inventory, Option<&BuildMode>, Option<&Parent>)>,
     mut event_writer: EventWriter<BlockChangedEvent>,
 ) {
     for ev in event_reader.iter() {
-        if let Ok(mut structure) = query.get_mut(ev.structure_entity) {
-            let block = ev.structure_block.block(&structure, &blocks);
-
-            // Eventually seperate this into another event lsitener that some how interacts with this one
-            // Idk if bevy supports this yet without some hacky stuff?
-            if block.unlocalized_name() == "cosmos:ship_core" {
-                let mut itr = structure.all_blocks_iter(false);
-
-                // ship core               some other block
-                if itr.next().is_some() && itr.next().is_some() {
-                    // Do not allow player to mine ship core if another block exists on the ship
-                    return;
+        if let Ok((mut inventory, build_mode, parent)) = player_query.get_mut(ev.breaker) {
+            if let Ok(mut structure) = query.get_mut(ev.structure_entity) {
+                let mut structure_blocks = vec![(ev.structure_block.coords(), BlockFace::Top)];
+
+                if let (Some(build_mode), Some(parent)) = (build_mode, parent) {
+                    structure_blocks = calculate_build_mode_blocks(
+                        structure_blocks,
+                        build_mode,
+                        parent,
+                        ev.structure_entity,
+                        &mut inventory,
+                        &structure,
+                    );
                 }
-            }
 
-            let block_id = ev.structure_block.block_id(&structure);
+                for (coord, _) in structure_blocks {
+                    let block = structure.block_at(coord, &blocks);
 
-            if block_id != AIR_BLOCK_ID {
-                if let Ok(mut inventory) = inventory_query.get_mut(ev.breaker) {
-                    let block = blocks.from_numeric_id(block_id);
+                    // Eventually seperate this into another event lsitener that some how interacts with this one
+                    // Idk if bevy supports this yet without some hacky stuff?
+                    if block.unlocalized_name() == "cosmos:ship_core" {
+                        let mut itr = structure.all_blocks_iter(false);
 
-                    if let Some(item_id) = block_items.item_from_block(block) {
-                        let item = items.from_numeric_id(item_id);
+                        // ship core               some other block
+                        if itr.next().is_some() && itr.next().is_some() {
+                            // Do not allow player to mine ship core if another block exists on the ship
+                            return;
+                        }
+                    }
 
-                        inventory.insert(item, 1);
+                    if block.id() != AIR_BLOCK_ID {
+                        if let Some(item_id) = block_items.item_from_block(block) {
+                            let item = items.from_numeric_id(item_id);
+
+                            inventory.insert(item, 1);
+                        }
+
+                        structure.remove_block_at(coord, &blocks, Some(&mut event_writer));
                     }
                 }
+            }
+        }
+    }
+}
+
+/// Ensure we're not double-placing any blocks, which could happen if you place on the symmetry line
+fn unique_push(vec: &mut Vec<(BlockCoordinate, BlockFace)>, item: (BlockCoordinate, BlockFace)) {
+    for already_there in vec.iter() {
+        if already_there.0 == item.0 {
+            return;
+        }
+    }
+
+    vec.push(item);
+}
+
+fn calculate_build_mode_blocks(
+    mut structure_blocks: Vec<(BlockCoordinate, BlockFace)>,
+    build_mode: &BuildMode,
+    parent: &Parent,
+    structure_entity: Entity,
+    inventory: &mut Mut<'_, Inventory>,
+    structure: &Structure,
+) -> Vec<(BlockCoordinate, BlockFace)> {
+    if parent.get() != structure_entity {
+        // Tried to place a block on a structure they're not in build mode on
+
+        // Update player that they didn't place the block
+        inventory.set_changed();
+        return vec![];
+    }
+
+    if let Some(axis_coord) = build_mode.get_symmetry(BuildAxis::X) {
+        let axis_coord = axis_coord as UnboundCoordinateType;
+
+        let mut new_coords = vec![];
+
+        for (old_coords, block_up) in structure_blocks {
+            unique_push(&mut new_coords, (old_coords, block_up));
+
+            let new_x_coord = 2 * (axis_coord - old_coords.x as UnboundCoordinateType) + old_coords.x as UnboundCoordinateType;
+            if new_x_coord >= 0 {
+                let new_block_coords = BlockCoordinate::new(new_x_coord as CoordinateType, old_coords.y, old_coords.z);
+                if structure.is_within_blocks(new_block_coords) {
+                    unique_push(&mut new_coords, (new_block_coords, block_up));
+                }
+            }
+        }
+
+        structure_blocks = new_coords;
+    }
+
+    if let Some(axis_coord) = build_mode.get_symmetry(BuildAxis::Y) {
+        let axis_coord = axis_coord as UnboundCoordinateType;
+
+        let mut new_coords = vec![];
+
+        for (old_coords, block_up) in structure_blocks {
+            unique_push(&mut new_coords, (old_coords, block_up));
+
+            let new_y_coord = 2 * (axis_coord - old_coords.y as UnboundCoordinateType) + old_coords.y as UnboundCoordinateType;
+            if new_y_coord >= 0 {
+                let new_block_coords = BlockCoordinate::new(old_coords.x, new_y_coord as CoordinateType, old_coords.z);
+                if structure.is_within_blocks(new_block_coords) {
+                    unique_push(&mut new_coords, (new_block_coords, block_up));
+                }
+            }
+        }
+
+        structure_blocks = new_coords;
+    }
+
+    if let Some(axis_coord) = build_mode.get_symmetry(BuildAxis::Z) {
+        let axis_coord = axis_coord as UnboundCoordinateType;
+
+        let mut new_coords = vec![];
+
+        for (old_coords, block_up) in structure_blocks {
+            unique_push(&mut new_coords, (old_coords, block_up));
 
-                structure.remove_block_at(ev.structure_block.coords(), &blocks, Some(&mut event_writer));
+            let new_z_coord = 2 * (axis_coord - old_coords.z as UnboundCoordinateType) + old_coords.z as UnboundCoordinateType;
+            if new_z_coord >= 0 {
+                let new_block_coords = BlockCoordinate::new(old_coords.x, old_coords.y, new_z_coord as CoordinateType);
+                if structure.is_within_blocks(new_block_coords) {
+                    unique_push(&mut new_coords, (new_block_coords, block_up));
+                }
             }
         }
+
+        structure_blocks = new_coords;
     }
+
+    structure_blocks
 }
 
 fn handle_block_place_events(
     mut query: Query<&mut Structure>,
     mut event_reader: EventReader<BlockPlaceEvent>,
     mut event_writer: EventWriter<BlockChangedEvent>,
-    mut inventory_query: Query<(&mut Inventory, &Player)>,
+    mut player_query: Query<(&mut Inventory, Option<&BuildMode>, Option<&Parent>)>,
     items: Res<Registry<Item>>,
     blocks: Res<Registry<Block>>,
     block_items: Res<BlockItems>,
 ) {
     for ev in event_reader.iter() {
-        if let Ok((mut inv, player)) = inventory_query.get_mut(ev.placer) {
-            if let Some(is) = inv.itemstack_at(ev.inventory_slot) {
-                let item = items.from_numeric_id(is.item_id());
-
-                if let Some(block_id) = block_items.block_from_item(item) {
-                    if block_id != ev.block_id {
-                        warn!("Inventory out of sync between client {}!", player.name());
-                        break;
-                    }
+        let Ok((mut inv, build_mode, parent)) = player_query.get_mut(ev.placer) else {
+            continue;
+        };
 
-                    let block = blocks.from_numeric_id(block_id);
+        let Ok(mut structure) = query.get_mut(ev.structure_entity) else {
+            continue;
+        };
+        let mut structure_blocks = vec![(ev.structure_block.coords(), ev.block_up)];
 
-                    if let Ok(mut structure) = query.get_mut(ev.structure_entity) {
-                        inv.decrease_quantity_at(ev.inventory_slot, 1);
+        if let (Some(build_mode), Some(parent)) = (build_mode, parent) {
+            structure_blocks = calculate_build_mode_blocks(structure_blocks, build_mode, parent, ev.structure_entity, &mut inv, &structure);
+        }
 
-                        structure.set_block_at(ev.structure_block.coords(), block, ev.block_up, &blocks, Some(&mut event_writer));
-                    }
-                }
+        for (coords, block_up) in structure_blocks {
+            if structure.has_block_at(coords) {
+                continue;
+            }
+
+            let Some(is) = inv.itemstack_at(ev.inventory_slot) else {
+                break;
+            };
+
+            let item = items.from_numeric_id(is.item_id());
+
+            let Some(block_id) = block_items.block_from_item(item) else {
+                break;
+            };
+
+            if block_id != ev.block_id {
+                // May have run out of the item or it was swapped with something else (not really possible currently, but more checks never hurt anyone)
+                break;
+            }
+
+            let block = blocks.from_numeric_id(block_id);
 
+            if inv.decrease_quantity_at(ev.inventory_slot, 1) == 0 {
+                structure.set_block_at(coords, block, block_up, &blocks, Some(&mut event_writer));
+            } else {
                 break;
             }
         }
diff --git a/cosmos_server/src/events/netty/netty_events.rs b/cosmos_server/src/events/netty/netty_events.rs
index 95a031acc..489fdc6f1 100644
--- a/cosmos_server/src/events/netty/netty_events.rs
+++ b/cosmos_server/src/events/netty/netty_events.rs
@@ -6,6 +6,7 @@ use bevy_renet::renet::transport::NetcodeServerTransport;
 use bevy_renet::renet::{RenetServer, ServerEvent};
 use cosmos_core::ecs::NeedsDespawned;
 use cosmos_core::entities::player::render_distance::RenderDistance;
+use cosmos_core::inventory::itemstack::ItemStack;
 use cosmos_core::inventory::Inventory;
 use cosmos_core::item::Item;
 use cosmos_core::netty::netty_rigidbody::NettyRigidBodyLocation;
@@ -14,6 +15,7 @@ use cosmos_core::netty::{cosmos_encoder, NettyChannelServer};
 use cosmos_core::persistence::LoadingDistance;
 use cosmos_core::physics::location::{Location, Sector};
 use cosmos_core::physics::player_world::WorldWithin;
+use cosmos_core::registry::identifiable::Identifiable;
 use cosmos_core::registry::Registry;
 use cosmos_core::structure::chunk::CHUNK_DIMENSIONSF;
 use cosmos_core::{entities::player::Player, netty::netty_rigidbody::NettyRigidBody};
@@ -25,23 +27,27 @@ use crate::netty::network_helpers::{ClientTicks, ServerLobby};
 fn generate_player_inventory(items: &Registry<Item>) -> Inventory {
     let mut inventory = Inventory::new(9 * 6, Some(0..9));
 
-    inventory.insert_item_at(0, items.from_id("cosmos:ice").expect("Ice item to exist"), 1);
+    inventory.insert_item_at(0, items.from_id("cosmos:ship_hull").expect("Ship hull item to exist"), 999);
 
-    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:glass").expect("Glass item to exist"), 999);
 
-    inventory.insert_item_at(2, items.from_id("cosmos:glass").expect("Glass item to exist"), 64);
+    inventory.insert_item_at(2, items.from_id("cosmos:build_block").expect("Build block item to exist"), 999);
 
-    inventory.insert_item_at(3, items.from_id("cosmos:thruster").expect("Thruster item to exist"), 64);
+    inventory.insert_item_at(3, items.from_id("cosmos:thruster").expect("Thruster item to exist"), 999);
 
-    inventory.insert_item_at(4, items.from_id("cosmos:laser_cannon").expect("Laser cannon item to exist"), 64);
+    inventory.insert_item_at(4, items.from_id("cosmos:laser_cannon").expect("Laser cannon item to exist"), 999);
 
-    inventory.insert_item_at(5, items.from_id("cosmos:reactor").expect("Reactor cannon item to exist"), 64);
+    inventory.insert_item_at(5, items.from_id("cosmos:reactor").expect("Reactor item to exist"), 999);
 
-    inventory.insert_item_at(6, items.from_id("cosmos:energy_cell").expect("Energy cell item to exist"), 64);
+    inventory.insert_item_at(6, items.from_id("cosmos:energy_cell").expect("Energy cell item to exist"), 999);
 
-    inventory.insert_item_at(7, items.from_id("cosmos:ship_hull").expect("Ship hull item to exist"), 64);
+    inventory.insert_item_at(7, items.from_id("cosmos:light").expect("Light item to exist"), 999);
 
-    inventory.insert_item_at(8, items.from_id("cosmos:light").expect("Light item to exist"), 64);
+    inventory.insert_item_at(8, items.from_id("cosmos:redwood_log").expect("Redwood log item to exist"), 999);
+
+    for item in items.iter().filter(|item| item.unlocalized_name() != "cosmos:air") {
+        inventory.insert_itemstack(&ItemStack::with_quantity(item, 999));
+    }
 
     inventory
 }
diff --git a/cosmos_server/src/netty/server_listener.rs b/cosmos_server/src/netty/server_listener.rs
index 180494fc4..98e1e76d3 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::{BuildMode, ExitBuildModeEvent};
 use cosmos_core::structure::systems::{SystemActive, Systems};
 use cosmos_core::{
     entities::player::Player,
@@ -38,19 +39,31 @@ 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>,
+    mut build_mode: Query<&mut BuildMode>,
 ) {
     for client_id in server.clients_id().into_iter() {
         while let Some(message) = server.receive_message(client_id, NettyChannelClient::Unreliable) {
@@ -268,6 +281,22 @@ 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 });
+                    }
+                }
+                ClientReliableMessages::SetSymmetry { axis, coordinate } => {
+                    if let Some(player_entity) = lobby.player_from_id(client_id) {
+                        if let Ok(mut build_mode) = build_mode.get_mut(player_entity) {
+                            if let Some(coordinate) = coordinate {
+                                build_mode.set_symmetry(axis, coordinate);
+                            } else {
+                                build_mode.remove_symmetry(axis);
+                            }
+                        }
+                    }
+                }
             }
         }
     }
diff --git a/cosmos_server/src/physics/mod.rs b/cosmos_server/src/physics/mod.rs
index 8773028c1..5925d50e1 100644
--- a/cosmos_server/src/physics/mod.rs
+++ b/cosmos_server/src/physics/mod.rs
@@ -47,7 +47,12 @@ pub fn assign_player_world(
         let world_id = rapier_context.add_world(RapierWorld::default());
 
         let world_entity = commands
-            .spawn((PlayerWorld { player: player_entity }, *location, PhysicsWorld { world_id }))
+            .spawn((
+                Name::new("Player World"),
+                PlayerWorld { player: player_entity },
+                *location,
+                PhysicsWorld { world_id },
+            ))
             .id();
 
         commands
@@ -108,7 +113,12 @@ fn move_players_between_worlds(
                 let world_id = rapier_context.add_world(RapierWorld::default());
 
                 let world_entity = commands
-                    .spawn((PlayerWorld { player: entity }, *location, PhysicsWorld { world_id }))
+                    .spawn((
+                        Name::new("Player World"),
+                        PlayerWorld { player: entity },
+                        *location,
+                        PhysicsWorld { world_id },
+                    ))
                     .id();
 
                 let (mut world_within, mut body_world) = world_within_query.get_mut(entity).unwrap();
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..af1a776f9
--- /dev/null
+++ b/cosmos_server/src/structure/ship/build_mode.rs
@@ -0,0 +1,76 @@
+//! Handles server-side build mode logic
+
+use bevy::prelude::{in_state, App, Changed, EventReader, EventWriter, IntoSystemConfigs, Query, Res, ResMut, Update};
+use bevy_renet::renet::RenetServer;
+use cosmos_core::{
+    block::Block,
+    entities::player::Player,
+    netty::{cosmos_encoder, server_reliable_messages::ServerReliableMessages, NettyChannelServer},
+    registry::{identifiable::Identifiable, Registry},
+    structure::{
+        ship::build_mode::{BuildMode, 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,
+            }),
+        );
+    }
+}
+
+fn sync_build_mode(changed_build_modes: Query<(&Player, &BuildMode), Changed<BuildMode>>, mut server: ResMut<RenetServer>) {
+    for (player, build_mode) in changed_build_modes.iter() {
+        server.send_message(
+            player.id(),
+            NettyChannelServer::Reliable,
+            cosmos_encoder::serialize(&ServerReliableMessages::UpdateBuildMode { build_mode: *build_mode }),
+        );
+    }
+}
+
+pub(super) fn register(app: &mut App) {
+    app.add_systems(
+        Update,
+        (interact_with_block, enter_build_mode, exit_build_mode, sync_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);
 }
diff --git a/cosmos_server/src/universe/planet_spawner.rs b/cosmos_server/src/universe/planet_spawner.rs
index 37f47f59f..fadbcac0d 100644
--- a/cosmos_server/src/universe/planet_spawner.rs
+++ b/cosmos_server/src/universe/planet_spawner.rs
@@ -133,7 +133,7 @@ fn spawn_planet(
 
             let is_origin = sector.x() == 25 && sector.y() == 25 && sector.z() == 25;
 
-            if is_origin || rng.gen_range(0..1000) == 9 {
+            if !is_origin && rng.gen_range(0..1000) == 9 {
                 let location = Location::new(Vec3::ZERO, sector);
 
                 let mut closest_star = None;
diff --git a/showcase/flying_over_planet.png b/showcase/flying_over_planet.png
new file mode 100644
index 000000000..9b58bc1bf
Binary files /dev/null and b/showcase/flying_over_planet.png differ
diff --git a/showcase/gunner_flying_towards_planet.png b/showcase/gunner_flying_towards_planet.png
new file mode 100644
index 000000000..1fb932dfc
Binary files /dev/null and b/showcase/gunner_flying_towards_planet.png differ
diff --git a/showcase/gunship_below.png b/showcase/gunship_below.png
new file mode 100644
index 000000000..76220724c
Binary files /dev/null and b/showcase/gunship_below.png differ
diff --git a/showcase/gunship_front.png b/showcase/gunship_front.png
new file mode 100644
index 000000000..f27d19ca1
Binary files /dev/null and b/showcase/gunship_front.png differ
diff --git a/showcase/gunship_overhead.png b/showcase/gunship_overhead.png
new file mode 100644
index 000000000..650c7b4e0
Binary files /dev/null and b/showcase/gunship_overhead.png differ
diff --git a/showcase/gunship_top.png b/showcase/gunship_top.png
new file mode 100644
index 000000000..ae1a843e6
Binary files /dev/null and b/showcase/gunship_top.png differ
diff --git a/showcase/safely_landed_gunner.png b/showcase/safely_landed_gunner.png
new file mode 100644
index 000000000..a21c6877b
Binary files /dev/null and b/showcase/safely_landed_gunner.png differ