diff --git a/Cargo.lock b/Cargo.lock
index b27aa7160e..ef8a66c119 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5443,7 +5443,7 @@ dependencies = [
  "veloren-common-frontend",
  "veloren-common-net",
  "veloren-common-state",
- "veloren-common-sys",
+ "veloren-common-systems",
  "veloren-network",
 ]
 
@@ -5557,7 +5557,7 @@ dependencies = [
 ]
 
 [[package]]
-name = "veloren-common-sys"
+name = "veloren-common-systems"
 version = "0.9.0"
 dependencies = [
  "hashbrown",
@@ -5682,7 +5682,7 @@ dependencies = [
  "veloren-common-ecs",
  "veloren-common-net",
  "veloren-common-state",
- "veloren-common-sys",
+ "veloren-common-systems",
  "veloren-network",
  "veloren-plugin-api",
  "veloren-world",
@@ -5770,7 +5770,7 @@ dependencies = [
  "veloren-common-frontend",
  "veloren-common-net",
  "veloren-common-state",
- "veloren-common-sys",
+ "veloren-common-systems",
  "veloren-server",
  "veloren-voxygen-anim",
  "veloren-world",
diff --git a/Cargo.toml b/Cargo.toml
index 2eb30662d7..d1cfa92648 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -7,7 +7,7 @@ members = [
     "common/ecs",
     "common/net",
     "common/state",
-    "common/sys",
+    "common/systems",
     "common/frontend",
     "client",
     "plugin/api",
diff --git a/client/Cargo.toml b/client/Cargo.toml
index 8f7619c628..e0113e12f2 100644
--- a/client/Cargo.toml
+++ b/client/Cargo.toml
@@ -5,7 +5,7 @@ authors = ["Joshua Barretto <joshua.s.barretto@gmail.com>"]
 edition = "2018"
 
 [features]
-tracy = ["common/tracy", "common-base/tracy", "common-sys/tracy", "common-net/tracy", "common-frontend/tracy"]
+tracy = ["common/tracy", "common-base/tracy", "common-state/tracy", "common-systems/tracy", "common-net/tracy", "common-frontend/tracy"]
 simd = ["vek/platform_intrinsics"]
 plugins = ["common-state/plugins"]
 bin_bot = ["common-ecs", "serde", "ron", "clap", "rustyline", "common-frontend", "async-channel"]
@@ -16,7 +16,7 @@ default = ["simd"]
 common = { package = "veloren-common", path = "../common", features = ["no-assets"] }
 common-base = { package = "veloren-common-base", path = "../common/base" }
 common-state = { package = "veloren-common-state", path = "../common/state", default-features = false }
-common-sys = { package = "veloren-common-sys", path = "../common/sys", default-features = false }
+common-systems = { package = "veloren-common-systems", path = "../common/systems", default-features = false }
 common-net = { package = "veloren-common-net", path = "../common/net" }
 network = { package = "veloren-network", path = "../network", features = ["compression"], default-features = false }
 
@@ -32,6 +32,7 @@ vek = { version = "=0.14.1", features = ["serde"] }
 hashbrown = { version = "0.9", features = ["rayon", "serde", "nightly"] }
 authc = { git = "https://gitlab.com/veloren/auth.git", rev = "fb3dcbc4962b367253f8f2f92760ef44d2679c9a" }
 
+#TODO: put bot in a different crate
 #bot only
 async-channel = { version = "1.6", optional = true }
 common-ecs = { package = "veloren-common-ecs", path = "../common/ecs", optional = true }
diff --git a/client/src/lib.rs b/client/src/lib.rs
index 5f225758bc..347326ad81 100644
--- a/client/src/lib.rs
+++ b/client/src/lib.rs
@@ -55,7 +55,7 @@ use common_net::{
     sync::WorldSyncExt,
 };
 use common_state::State;
-use common_sys::add_local_systems;
+use common_systems::add_local_systems;
 use comp::BuffKind;
 use futures_util::FutureExt;
 use hashbrown::{HashMap, HashSet};
diff --git a/common/state/src/lib.rs b/common/state/src/lib.rs
index c633e60771..8c1ce6bbcb 100644
--- a/common/state/src/lib.rs
+++ b/common/state/src/lib.rs
@@ -1,589 +1,8 @@
+//! This crate contains the [`State`] and shared between
+//! server (`veloren-server`) and the client (`veloren-client`)
+
 #[cfg(feature = "plugins")] pub mod plugin;
+mod state;
 
-#[cfg(feature = "plugins")]
-use crate::plugin::memory_manager::EcsWorld;
-#[cfg(feature = "plugins")]
-use crate::plugin::PluginMgr;
-#[cfg(feature = "plugins")]
-use common::uid::UidAllocator;
-use common::{
-    comp,
-    depot::{Depot, Id},
-    event::{EventBus, LocalEvent, ServerEvent},
-    outcome::Outcome,
-    region::RegionMap,
-    resources::{DeltaTime, GameMode, PlayerEntity, PlayerPhysicsSettings, Time, TimeOfDay},
-    slowjob::SlowJobPool,
-    terrain::{Block, TerrainChunk, TerrainGrid},
-    time::DayPeriod,
-    trade::Trades,
-    vol::{ReadVol, WriteVol},
-};
-use common_base::span;
-use common_ecs::{PhysicsMetrics, SysMetrics};
-use common_net::sync::{interpolation as sync_interp, WorldSyncExt};
-use core::{convert::identity, time::Duration};
-use hashbrown::{hash_map, HashMap, HashSet};
-use rayon::{ThreadPool, ThreadPoolBuilder};
-use specs::{
-    prelude::Resource,
-    shred::{Fetch, FetchMut},
-    storage::{MaskedStorage as EcsMaskedStorage, Storage as EcsStorage},
-    Component, DispatcherBuilder, Entity as EcsEntity, WorldExt,
-};
-use std::sync::Arc;
-use vek::*;
-
-/// How much faster should an in-game day be compared to a real day?
-// TODO: Don't hard-code this.
-const DAY_CYCLE_FACTOR: f64 = 24.0 * 2.0;
-
-/// At what point should we stop speeding up physics to compensate for lag? If
-/// we speed physics up too fast, we'd skip important physics events like
-/// collisions. This constant determines the upper limit. If delta time exceeds
-/// this value, the game's physics will begin to produce time lag. Ideally, we'd
-/// avoid such a situation.
-const MAX_DELTA_TIME: f32 = 1.0;
-
-/// NOTE: Please don't add `Deserialize` without checking to make sure we
-/// can guarantee the invariant that every entry in `area_names` points to a
-/// valid id in `areas`.
-#[derive(Default)]
-pub struct BuildAreas {
-    areas: Depot<Aabb<i32>>,
-    area_names: HashMap<String, Id<Aabb<i32>>>,
-}
-
-pub enum BuildAreaError {
-    /// This build area name is reserved by the system.
-    Reserved,
-    /// The build area name was not found.
-    NotFound,
-}
-
-/// Build area names that can only be inserted, not removed.
-const RESERVED_BUILD_AREA_NAMES: &[&str] = &["world"];
-
-impl BuildAreas {
-    pub fn areas(&self) -> &Depot<geom::Aabb<i32>> { &self.areas }
-
-    pub fn area_names(&self) -> &HashMap<String, Id<Aabb<i32>>> { &self.area_names }
-
-    /// If the area_name is already in the map, returns Err(area_name).
-    pub fn insert(&mut self, area_name: String, area: Aabb<i32>) -> Result<Id<Aabb<i32>>, String> {
-        let area_name_entry = match self.area_names.entry(area_name) {
-            hash_map::Entry::Occupied(o) => return Err(o.replace_key()),
-            hash_map::Entry::Vacant(v) => v,
-        };
-        let bb_id = self.areas.insert(area.made_valid());
-        area_name_entry.insert(bb_id);
-        Ok(bb_id)
-    }
-
-    pub fn remove(&mut self, area_name: &str) -> Result<Aabb<i32>, BuildAreaError> {
-        if RESERVED_BUILD_AREA_NAMES.contains(&area_name) {
-            return Err(BuildAreaError::Reserved);
-        }
-        let bb_id = self
-            .area_names
-            .remove(area_name)
-            .ok_or(BuildAreaError::NotFound)?;
-        let area = self.areas.remove(bb_id).expect(
-            "Entries in `areas` are added before entries in `area_names` in `insert`, and that is \
-             the only exposed way to add elements to `area_names`.",
-        );
-        Ok(area)
-    }
-}
-
-#[derive(Default)]
-pub struct BlockChange {
-    blocks: HashMap<Vec3<i32>, Block>,
-}
-
-impl BlockChange {
-    pub fn set(&mut self, pos: Vec3<i32>, block: Block) { self.blocks.insert(pos, block); }
-
-    pub fn try_set(&mut self, pos: Vec3<i32>, block: Block) -> Option<()> {
-        if !self.blocks.contains_key(&pos) {
-            self.blocks.insert(pos, block);
-            Some(())
-        } else {
-            None
-        }
-    }
-
-    pub fn clear(&mut self) { self.blocks.clear(); }
-}
-
-#[derive(Default)]
-pub struct TerrainChanges {
-    pub new_chunks: HashSet<Vec2<i32>>,
-    pub modified_chunks: HashSet<Vec2<i32>>,
-    pub removed_chunks: HashSet<Vec2<i32>>,
-    pub modified_blocks: HashMap<Vec3<i32>, Block>,
-}
-
-impl TerrainChanges {
-    pub fn clear(&mut self) {
-        self.new_chunks.clear();
-        self.modified_chunks.clear();
-        self.removed_chunks.clear();
-    }
-}
-
-#[derive(Copy, Clone)]
-pub enum ExecMode {
-    Server,
-    Client,
-    Singleplayer,
-}
-
-/// A type used to represent game state stored on both the client and the
-/// server. This includes things like entity components, terrain data, and
-/// global states like weather, time of day, etc.
-pub struct State {
-    ecs: specs::World,
-    // Avoid lifetime annotation by storing a thread pool instead of the whole dispatcher
-    thread_pool: Arc<ThreadPool>,
-}
-
-impl State {
-    /// Create a new `State` in client mode.
-    pub fn client() -> Self { Self::new(GameMode::Client) }
-
-    /// Create a new `State` in server mode.
-    pub fn server() -> Self { Self::new(GameMode::Server) }
-
-    pub fn new(game_mode: GameMode) -> Self {
-        let thread_name_infix = match game_mode {
-            GameMode::Server => "s",
-            GameMode::Client => "c",
-            GameMode::Singleplayer => "sp",
-        };
-
-        let thread_pool = Arc::new(
-            ThreadPoolBuilder::new()
-                .thread_name(move |i| format!("rayon-{}-{}", thread_name_infix, i))
-                .build()
-                .unwrap(),
-        );
-        Self {
-            ecs: Self::setup_ecs_world(game_mode, &thread_pool),
-            thread_pool,
-        }
-    }
-
-    /// Creates ecs world and registers all the common components and resources
-    // TODO: Split up registering into server and client (e.g. move
-    // EventBus<ServerEvent> to the server)
-    fn setup_ecs_world(game_mode: GameMode, thread_pool: &Arc<ThreadPool>) -> specs::World {
-        let mut ecs = specs::World::new();
-        // Uids for sync
-        ecs.register_sync_marker();
-        // Register server -> all clients synced components.
-        ecs.register::<comp::Body>();
-        ecs.register::<comp::Player>();
-        ecs.register::<comp::Stats>();
-        ecs.register::<comp::SkillSet>();
-        ecs.register::<comp::Buffs>();
-        ecs.register::<comp::Auras>();
-        ecs.register::<comp::Energy>();
-        ecs.register::<comp::Combo>();
-        ecs.register::<comp::Health>();
-        ecs.register::<comp::Poise>();
-        ecs.register::<comp::CanBuild>();
-        ecs.register::<comp::LightEmitter>();
-        ecs.register::<comp::Item>();
-        ecs.register::<comp::Scale>();
-        ecs.register::<comp::Mounting>();
-        ecs.register::<comp::MountState>();
-        ecs.register::<comp::Mass>();
-        ecs.register::<comp::Density>();
-        ecs.register::<comp::Collider>();
-        ecs.register::<comp::Sticky>();
-        ecs.register::<comp::CharacterState>();
-        ecs.register::<comp::Object>();
-        ecs.register::<comp::Group>();
-        ecs.register::<comp::Shockwave>();
-        ecs.register::<comp::ShockwaveHitEntities>();
-        ecs.register::<comp::BeamSegment>();
-
-        // Register components send from clients -> server
-        ecs.register::<comp::Controller>();
-
-        // Register components send directly from server -> all but one client
-        ecs.register::<comp::PhysicsState>();
-
-        // Register components synced from client -> server -> all other clients
-        ecs.register::<comp::Pos>();
-        ecs.register::<comp::Vel>();
-        ecs.register::<comp::Ori>();
-        ecs.register::<comp::Inventory>();
-
-        // Register common unsynced components
-        ecs.register::<comp::PreviousPhysCache>();
-        ecs.register::<comp::PosVelDefer>();
-
-        // Register client-local components
-        // TODO: only register on the client
-        ecs.register::<comp::LightAnimation>();
-        ecs.register::<sync_interp::InterpBuffer<comp::Pos>>();
-        ecs.register::<sync_interp::InterpBuffer<comp::Vel>>();
-        ecs.register::<sync_interp::InterpBuffer<comp::Ori>>();
-
-        // Register server-local components
-        // TODO: only register on the server
-        ecs.register::<comp::Last<comp::Pos>>();
-        ecs.register::<comp::Last<comp::Vel>>();
-        ecs.register::<comp::Last<comp::Ori>>();
-        ecs.register::<comp::Alignment>();
-        ecs.register::<comp::Agent>();
-        ecs.register::<comp::WaypointArea>();
-        ecs.register::<comp::ForceUpdate>();
-        ecs.register::<comp::InventoryUpdate>();
-        ecs.register::<comp::Admin>();
-        ecs.register::<comp::Waypoint>();
-        ecs.register::<comp::Projectile>();
-        ecs.register::<comp::Melee>();
-        ecs.register::<comp::ItemDrop>();
-        ecs.register::<comp::ChatMode>();
-        ecs.register::<comp::Faction>();
-        ecs.register::<comp::invite::Invite>();
-        ecs.register::<comp::invite::PendingInvites>();
-        ecs.register::<comp::Beam>();
-
-        // Register synced resources used by the ECS.
-        ecs.insert(TimeOfDay(0.0));
-
-        // Register unsynced resources used by the ECS.
-        ecs.insert(Time(0.0));
-        ecs.insert(DeltaTime(0.0));
-        ecs.insert(PlayerEntity(None));
-        ecs.insert(TerrainGrid::new().unwrap());
-        ecs.insert(BlockChange::default());
-        ecs.insert(BuildAreas::default());
-        ecs.insert(TerrainChanges::default());
-        ecs.insert(EventBus::<LocalEvent>::default());
-        ecs.insert(game_mode);
-        ecs.insert(Vec::<common::outcome::Outcome>::new());
-
-        let slow_limit = thread_pool.current_num_threads().max(2) as u64;
-        let slow_limit = slow_limit / 2 + slow_limit / 4;
-        tracing::trace!(?slow_limit, "Slow Thread limit");
-        ecs.insert(SlowJobPool::new(slow_limit, Arc::clone(&thread_pool)));
-
-        // TODO: only register on the server
-        ecs.insert(EventBus::<ServerEvent>::default());
-        ecs.insert(comp::group::GroupManager::default());
-        ecs.insert(RegionMap::new());
-        ecs.insert(SysMetrics::default());
-        ecs.insert(PhysicsMetrics::default());
-        ecs.insert(Trades::default());
-        ecs.insert(PlayerPhysicsSettings::default());
-
-        // Load plugins from asset directory
-        #[cfg(feature = "plugins")]
-        ecs.insert(match PluginMgr::from_assets() {
-            Ok(plugin_mgr) => {
-                let ecs_world = EcsWorld {
-                    entities: &ecs.entities(),
-                    health: ecs.read_component().into(),
-                    uid: ecs.read_component().into(),
-                    uid_allocator: &ecs.read_resource::<UidAllocator>().into(),
-                    player: ecs.read_component().into(),
-                };
-                if let Err(e) = plugin_mgr
-                    .execute_event(&ecs_world, &plugin_api::event::PluginLoadEvent {
-                        game_mode,
-                    })
-                {
-                    tracing::debug!(?e, "Failed to run plugin init");
-                    tracing::info!("Plugins disabled, enable debug logging for more information.");
-                    PluginMgr::default()
-                } else {
-                    plugin_mgr
-                }
-            },
-            Err(e) => {
-                tracing::debug!(?e, "Failed to read plugins from assets");
-                tracing::info!("Plugins disabled, enable debug logging for more information.");
-                PluginMgr::default()
-            },
-        });
-
-        ecs
-    }
-
-    /// Register a component with the state's ECS.
-    pub fn with_component<T: Component>(mut self) -> Self
-    where
-        <T as Component>::Storage: Default,
-    {
-        self.ecs.register::<T>();
-        self
-    }
-
-    /// Write a component attributed to a particular entity, ignoring errors.
-    ///
-    /// This should be used *only* when we can guarantee that the rest of the
-    /// code does not rely on the insert having succeeded (meaning the
-    /// entity is no longer alive!).
-    ///
-    /// Returns None if the entity was dead or there was no previous entry for
-    /// this component; otherwise, returns Some(old_component).
-    pub fn write_component_ignore_entity_dead<C: Component>(
-        &mut self,
-        entity: EcsEntity,
-        comp: C,
-    ) -> Option<C> {
-        self.ecs
-            .write_storage()
-            .insert(entity, comp)
-            .ok()
-            .and_then(identity)
-    }
-
-    /// Delete a component attributed to a particular entity.
-    pub fn delete_component<C: Component>(&mut self, entity: EcsEntity) -> Option<C> {
-        self.ecs.write_storage().remove(entity)
-    }
-
-    /// Read a component attributed to a particular entity.
-    pub fn read_component_cloned<C: Component + Clone>(&self, entity: EcsEntity) -> Option<C> {
-        self.ecs.read_storage().get(entity).cloned()
-    }
-
-    /// Read a component attributed to a particular entity.
-    pub fn read_component_copied<C: Component + Copy>(&self, entity: EcsEntity) -> Option<C> {
-        self.ecs.read_storage().get(entity).copied()
-    }
-
-    /// Given mutable access to the resource R, assuming the resource
-    /// component exists (this is already the behavior of functions like `fetch`
-    /// and `write_component_ignore_entity_dead`).  Since all of our resources
-    /// are generated up front, any failure here is definitely a code bug.
-    pub fn mut_resource<R: Resource>(&mut self) -> &mut R {
-        self.ecs.get_mut::<R>().expect(
-            "Tried to fetch an invalid resource even though all our resources should be known at \
-             compile time.",
-        )
-    }
-
-    /// Get a read-only reference to the storage of a particular component type.
-    pub fn read_storage<C: Component>(&self) -> EcsStorage<C, Fetch<EcsMaskedStorage<C>>> {
-        self.ecs.read_storage::<C>()
-    }
-
-    /// Get a reference to the internal ECS world.
-    pub fn ecs(&self) -> &specs::World { &self.ecs }
-
-    /// Get a mutable reference to the internal ECS world.
-    pub fn ecs_mut(&mut self) -> &mut specs::World { &mut self.ecs }
-
-    /// Get a reference to the `TerrainChanges` structure of the state. This
-    /// contains information about terrain state that has changed since the
-    /// last game tick.
-    pub fn terrain_changes(&self) -> Fetch<TerrainChanges> { self.ecs.read_resource() }
-
-    /// Get the current in-game time of day.
-    ///
-    /// Note that this should not be used for physics, animations or other such
-    /// localised timings.
-    pub fn get_time_of_day(&self) -> f64 { self.ecs.read_resource::<TimeOfDay>().0 }
-
-    /// Get the current in-game day period (period of the day/night cycle)
-    /// Get the current in-game day period (period of the day/night cycle)
-    pub fn get_day_period(&self) -> DayPeriod { self.get_time_of_day().into() }
-
-    /// Get the current in-game time.
-    ///
-    /// Note that this does not correspond to the time of day.
-    pub fn get_time(&self) -> f64 { self.ecs.read_resource::<Time>().0 }
-
-    /// Get the current delta time.
-    pub fn get_delta_time(&self) -> f32 { self.ecs.read_resource::<DeltaTime>().0 }
-
-    /// Get a reference to this state's terrain.
-    pub fn terrain(&self) -> Fetch<TerrainGrid> { self.ecs.read_resource() }
-
-    /// Get a reference to this state's terrain.
-    pub fn slow_job_pool(&self) -> Fetch<SlowJobPool> { self.ecs.read_resource() }
-
-    /// Get a writable reference to this state's terrain.
-    pub fn terrain_mut(&self) -> FetchMut<TerrainGrid> { self.ecs.write_resource() }
-
-    /// Get a block in this state's terrain.
-    pub fn get_block(&self, pos: Vec3<i32>) -> Option<Block> {
-        self.terrain().get(pos).ok().copied()
-    }
-
-    /// Set a block in this state's terrain.
-    pub fn set_block(&self, pos: Vec3<i32>, block: Block) {
-        self.ecs.write_resource::<BlockChange>().set(pos, block);
-    }
-
-    /// Check if the block at given position `pos` has already been modified
-    /// this tick.
-    pub fn can_set_block(&self, pos: Vec3<i32>) -> bool {
-        !self
-            .ecs
-            .read_resource::<BlockChange>()
-            .blocks
-            .contains_key(&pos)
-    }
-
-    /// Removes every chunk of the terrain.
-    pub fn clear_terrain(&mut self) {
-        let removed_chunks = &mut self.ecs.write_resource::<TerrainChanges>().removed_chunks;
-
-        self.terrain_mut().drain().for_each(|(key, _)| {
-            removed_chunks.insert(key);
-        });
-    }
-
-    /// Insert the provided chunk into this state's terrain.
-    pub fn insert_chunk(&mut self, key: Vec2<i32>, chunk: TerrainChunk) {
-        if self
-            .ecs
-            .write_resource::<TerrainGrid>()
-            .insert(key, Arc::new(chunk))
-            .is_some()
-        {
-            self.ecs
-                .write_resource::<TerrainChanges>()
-                .modified_chunks
-                .insert(key);
-        } else {
-            self.ecs
-                .write_resource::<TerrainChanges>()
-                .new_chunks
-                .insert(key);
-        }
-    }
-
-    /// Remove the chunk with the given key from this state's terrain, if it
-    /// exists.
-    pub fn remove_chunk(&mut self, key: Vec2<i32>) {
-        if self
-            .ecs
-            .write_resource::<TerrainGrid>()
-            .remove(key)
-            .is_some()
-        {
-            self.ecs
-                .write_resource::<TerrainChanges>()
-                .removed_chunks
-                .insert(key);
-        }
-    }
-
-    // Run RegionMap tick to update entity region occupancy
-    pub fn update_region_map(&self) {
-        span!(_guard, "update_region_map", "State::update_region_map");
-        self.ecs.write_resource::<RegionMap>().tick(
-            self.ecs.read_storage::<comp::Pos>(),
-            self.ecs.read_storage::<comp::Vel>(),
-            self.ecs.entities(),
-        );
-    }
-
-    // Apply terrain changes
-    pub fn apply_terrain_changes(&self) {
-        span!(
-            _guard,
-            "apply_terrain_changes",
-            "State::apply_terrain_changes"
-        );
-        let mut terrain = self.ecs.write_resource::<TerrainGrid>();
-        let mut modified_blocks =
-            std::mem::take(&mut self.ecs.write_resource::<BlockChange>().blocks);
-        // Apply block modifications
-        // Only include in `TerrainChanges` if successful
-        modified_blocks.retain(|pos, block| terrain.set(*pos, *block).is_ok());
-        self.ecs.write_resource::<TerrainChanges>().modified_blocks = modified_blocks;
-    }
-
-    /// Execute a single tick, simulating the game state by the given duration.
-    pub fn tick(
-        &mut self,
-        dt: Duration,
-        add_systems: impl Fn(&mut DispatcherBuilder),
-        update_terrain_and_regions: bool,
-    ) {
-        span!(_guard, "tick", "State::tick");
-        // Change the time accordingly.
-        self.ecs.write_resource::<TimeOfDay>().0 += dt.as_secs_f64() * DAY_CYCLE_FACTOR;
-        self.ecs.write_resource::<Time>().0 += dt.as_secs_f64();
-
-        // Update delta time.
-        // Beyond a delta time of MAX_DELTA_TIME, start lagging to avoid skipping
-        // important physics events.
-        self.ecs.write_resource::<DeltaTime>().0 = dt.as_secs_f32().min(MAX_DELTA_TIME);
-
-        if update_terrain_and_regions {
-            self.update_region_map();
-        }
-
-        span!(guard, "create dispatcher");
-        // Run systems to update the world.
-        // Create and run a dispatcher for ecs systems.
-        let mut dispatch_builder =
-            DispatcherBuilder::new().with_pool(Arc::clone(&self.thread_pool));
-        // TODO: Consider alternative ways to do this
-        add_systems(&mut dispatch_builder);
-        // This dispatches all the systems in parallel.
-        let mut dispatcher = dispatch_builder.build();
-        drop(guard);
-        span!(guard, "run systems");
-        dispatcher.dispatch(&self.ecs);
-        drop(guard);
-
-        span!(guard, "maintain ecs");
-        self.ecs.maintain();
-        drop(guard);
-
-        if update_terrain_and_regions {
-            self.apply_terrain_changes();
-        }
-
-        // Process local events
-        span!(guard, "process local events");
-        let events = self.ecs.read_resource::<EventBus<LocalEvent>>().recv_all();
-        for event in events {
-            let mut velocities = self.ecs.write_storage::<comp::Vel>();
-            let physics = self.ecs.read_storage::<comp::PhysicsState>();
-            match event {
-                LocalEvent::Jump(entity, impulse) => {
-                    if let Some(vel) = velocities.get_mut(entity) {
-                        vel.0.z = impulse + physics.get(entity).map_or(0.0, |ps| ps.ground_vel.z);
-                    }
-                },
-                LocalEvent::ApplyImpulse { entity, impulse } => {
-                    if let Some(vel) = velocities.get_mut(entity) {
-                        vel.0 = impulse;
-                    }
-                },
-                LocalEvent::Boost {
-                    entity,
-                    vel: extra_vel,
-                } => {
-                    if let Some(vel) = velocities.get_mut(entity) {
-                        vel.0 += extra_vel;
-                    }
-                },
-                LocalEvent::CreateOutcome(outcome) => {
-                    self.ecs.write_resource::<Vec<Outcome>>().push(outcome);
-                },
-            }
-        }
-        drop(guard);
-    }
-
-    /// Clean up the state after a tick.
-    pub fn cleanup(&mut self) {
-        span!(_guard, "cleanup", "State::cleanup");
-        // Clean up data structures from the last tick.
-        self.ecs.write_resource::<TerrainChanges>().clear();
-    }
-}
+// TODO: breakup state module and remove globs
+pub use state::*;
diff --git a/common/state/src/state.rs b/common/state/src/state.rs
new file mode 100644
index 0000000000..27d9e1d8d7
--- /dev/null
+++ b/common/state/src/state.rs
@@ -0,0 +1,588 @@
+#[cfg(feature = "plugins")]
+use crate::plugin::memory_manager::EcsWorld;
+#[cfg(feature = "plugins")]
+use crate::plugin::PluginMgr;
+#[cfg(feature = "plugins")]
+use common::uid::UidAllocator;
+use common::{
+    comp,
+    depot::{Depot, Id},
+    event::{EventBus, LocalEvent, ServerEvent},
+    outcome::Outcome,
+    region::RegionMap,
+    resources::{DeltaTime, GameMode, PlayerEntity, PlayerPhysicsSettings, Time, TimeOfDay},
+    slowjob::SlowJobPool,
+    terrain::{Block, TerrainChunk, TerrainGrid},
+    time::DayPeriod,
+    trade::Trades,
+    vol::{ReadVol, WriteVol},
+};
+use common_base::span;
+use common_ecs::{PhysicsMetrics, SysMetrics};
+use common_net::sync::{interpolation as sync_interp, WorldSyncExt};
+use core::{convert::identity, time::Duration};
+use hashbrown::{hash_map, HashMap, HashSet};
+use rayon::{ThreadPool, ThreadPoolBuilder};
+use specs::{
+    prelude::Resource,
+    shred::{Fetch, FetchMut},
+    storage::{MaskedStorage as EcsMaskedStorage, Storage as EcsStorage},
+    Component, DispatcherBuilder, Entity as EcsEntity, WorldExt,
+};
+use std::sync::Arc;
+use vek::*;
+
+/// How much faster should an in-game day be compared to a real day?
+// TODO: Don't hard-code this.
+const DAY_CYCLE_FACTOR: f64 = 24.0 * 2.0;
+
+/// At what point should we stop speeding up physics to compensate for lag? If
+/// we speed physics up too fast, we'd skip important physics events like
+/// collisions. This constant determines the upper limit. If delta time exceeds
+/// this value, the game's physics will begin to produce time lag. Ideally, we'd
+/// avoid such a situation.
+const MAX_DELTA_TIME: f32 = 1.0;
+
+/// NOTE: Please don't add `Deserialize` without checking to make sure we
+/// can guarantee the invariant that every entry in `area_names` points to a
+/// valid id in `areas`.
+#[derive(Default)]
+pub struct BuildAreas {
+    areas: Depot<Aabb<i32>>,
+    area_names: HashMap<String, Id<Aabb<i32>>>,
+}
+
+pub enum BuildAreaError {
+    /// This build area name is reserved by the system.
+    Reserved,
+    /// The build area name was not found.
+    NotFound,
+}
+
+/// Build area names that can only be inserted, not removed.
+const RESERVED_BUILD_AREA_NAMES: &[&str] = &["world"];
+
+impl BuildAreas {
+    pub fn areas(&self) -> &Depot<geom::Aabb<i32>> { &self.areas }
+
+    pub fn area_names(&self) -> &HashMap<String, Id<Aabb<i32>>> { &self.area_names }
+
+    /// If the area_name is already in the map, returns Err(area_name).
+    pub fn insert(&mut self, area_name: String, area: Aabb<i32>) -> Result<Id<Aabb<i32>>, String> {
+        let area_name_entry = match self.area_names.entry(area_name) {
+            hash_map::Entry::Occupied(o) => return Err(o.replace_key()),
+            hash_map::Entry::Vacant(v) => v,
+        };
+        let bb_id = self.areas.insert(area.made_valid());
+        area_name_entry.insert(bb_id);
+        Ok(bb_id)
+    }
+
+    pub fn remove(&mut self, area_name: &str) -> Result<Aabb<i32>, BuildAreaError> {
+        if RESERVED_BUILD_AREA_NAMES.contains(&area_name) {
+            return Err(BuildAreaError::Reserved);
+        }
+        let bb_id = self
+            .area_names
+            .remove(area_name)
+            .ok_or(BuildAreaError::NotFound)?;
+        let area = self.areas.remove(bb_id).expect(
+            "Entries in `areas` are added before entries in `area_names` in `insert`, and that is \
+             the only exposed way to add elements to `area_names`.",
+        );
+        Ok(area)
+    }
+}
+
+#[derive(Default)]
+pub struct BlockChange {
+    blocks: HashMap<Vec3<i32>, Block>,
+}
+
+impl BlockChange {
+    pub fn set(&mut self, pos: Vec3<i32>, block: Block) { self.blocks.insert(pos, block); }
+
+    pub fn try_set(&mut self, pos: Vec3<i32>, block: Block) -> Option<()> {
+        if !self.blocks.contains_key(&pos) {
+            self.blocks.insert(pos, block);
+            Some(())
+        } else {
+            None
+        }
+    }
+
+    pub fn clear(&mut self) { self.blocks.clear(); }
+}
+
+#[derive(Default)]
+pub struct TerrainChanges {
+    pub new_chunks: HashSet<Vec2<i32>>,
+    pub modified_chunks: HashSet<Vec2<i32>>,
+    pub removed_chunks: HashSet<Vec2<i32>>,
+    pub modified_blocks: HashMap<Vec3<i32>, Block>,
+}
+
+impl TerrainChanges {
+    pub fn clear(&mut self) {
+        self.new_chunks.clear();
+        self.modified_chunks.clear();
+        self.removed_chunks.clear();
+    }
+}
+
+#[derive(Copy, Clone)]
+pub enum ExecMode {
+    Server,
+    Client,
+    Singleplayer,
+}
+
+/// A type used to represent game state stored on both the client and the
+/// server. This includes things like entity components, terrain data, and
+/// global states like weather, time of day, etc.
+pub struct State {
+    ecs: specs::World,
+    // Avoid lifetime annotation by storing a thread pool instead of the whole dispatcher
+    thread_pool: Arc<ThreadPool>,
+}
+
+impl State {
+    /// Create a new `State` in client mode.
+    pub fn client() -> Self { Self::new(GameMode::Client) }
+
+    /// Create a new `State` in server mode.
+    pub fn server() -> Self { Self::new(GameMode::Server) }
+
+    pub fn new(game_mode: GameMode) -> Self {
+        let thread_name_infix = match game_mode {
+            GameMode::Server => "s",
+            GameMode::Client => "c",
+            GameMode::Singleplayer => "sp",
+        };
+
+        let thread_pool = Arc::new(
+            ThreadPoolBuilder::new()
+                .thread_name(move |i| format!("rayon-{}-{}", thread_name_infix, i))
+                .build()
+                .unwrap(),
+        );
+        Self {
+            ecs: Self::setup_ecs_world(game_mode, &thread_pool),
+            thread_pool,
+        }
+    }
+
+    /// Creates ecs world and registers all the common components and resources
+    // TODO: Split up registering into server and client (e.g. move
+    // EventBus<ServerEvent> to the server)
+    fn setup_ecs_world(game_mode: GameMode, thread_pool: &Arc<ThreadPool>) -> specs::World {
+        let mut ecs = specs::World::new();
+        // Uids for sync
+        ecs.register_sync_marker();
+        // Register server -> all clients synced components.
+        ecs.register::<comp::Body>();
+        ecs.register::<comp::Player>();
+        ecs.register::<comp::Stats>();
+        ecs.register::<comp::SkillSet>();
+        ecs.register::<comp::Buffs>();
+        ecs.register::<comp::Auras>();
+        ecs.register::<comp::Energy>();
+        ecs.register::<comp::Combo>();
+        ecs.register::<comp::Health>();
+        ecs.register::<comp::Poise>();
+        ecs.register::<comp::CanBuild>();
+        ecs.register::<comp::LightEmitter>();
+        ecs.register::<comp::Item>();
+        ecs.register::<comp::Scale>();
+        ecs.register::<comp::Mounting>();
+        ecs.register::<comp::MountState>();
+        ecs.register::<comp::Mass>();
+        ecs.register::<comp::Density>();
+        ecs.register::<comp::Collider>();
+        ecs.register::<comp::Sticky>();
+        ecs.register::<comp::CharacterState>();
+        ecs.register::<comp::Object>();
+        ecs.register::<comp::Group>();
+        ecs.register::<comp::Shockwave>();
+        ecs.register::<comp::ShockwaveHitEntities>();
+        ecs.register::<comp::BeamSegment>();
+
+        // Register components send from clients -> server
+        ecs.register::<comp::Controller>();
+
+        // Register components send directly from server -> all but one client
+        ecs.register::<comp::PhysicsState>();
+
+        // Register components synced from client -> server -> all other clients
+        ecs.register::<comp::Pos>();
+        ecs.register::<comp::Vel>();
+        ecs.register::<comp::Ori>();
+        ecs.register::<comp::Inventory>();
+
+        // Register common unsynced components
+        ecs.register::<comp::PreviousPhysCache>();
+        ecs.register::<comp::PosVelDefer>();
+
+        // Register client-local components
+        // TODO: only register on the client
+        ecs.register::<comp::LightAnimation>();
+        ecs.register::<sync_interp::InterpBuffer<comp::Pos>>();
+        ecs.register::<sync_interp::InterpBuffer<comp::Vel>>();
+        ecs.register::<sync_interp::InterpBuffer<comp::Ori>>();
+
+        // Register server-local components
+        // TODO: only register on the server
+        ecs.register::<comp::Last<comp::Pos>>();
+        ecs.register::<comp::Last<comp::Vel>>();
+        ecs.register::<comp::Last<comp::Ori>>();
+        ecs.register::<comp::Alignment>();
+        ecs.register::<comp::Agent>();
+        ecs.register::<comp::WaypointArea>();
+        ecs.register::<comp::ForceUpdate>();
+        ecs.register::<comp::InventoryUpdate>();
+        ecs.register::<comp::Admin>();
+        ecs.register::<comp::Waypoint>();
+        ecs.register::<comp::Projectile>();
+        ecs.register::<comp::Melee>();
+        ecs.register::<comp::ItemDrop>();
+        ecs.register::<comp::ChatMode>();
+        ecs.register::<comp::Faction>();
+        ecs.register::<comp::invite::Invite>();
+        ecs.register::<comp::invite::PendingInvites>();
+        ecs.register::<comp::Beam>();
+
+        // Register synced resources used by the ECS.
+        ecs.insert(TimeOfDay(0.0));
+
+        // Register unsynced resources used by the ECS.
+        ecs.insert(Time(0.0));
+        ecs.insert(DeltaTime(0.0));
+        ecs.insert(PlayerEntity(None));
+        ecs.insert(TerrainGrid::new().unwrap());
+        ecs.insert(BlockChange::default());
+        ecs.insert(BuildAreas::default());
+        ecs.insert(TerrainChanges::default());
+        ecs.insert(EventBus::<LocalEvent>::default());
+        ecs.insert(game_mode);
+        ecs.insert(Vec::<common::outcome::Outcome>::new());
+
+        let slow_limit = thread_pool.current_num_threads().max(2) as u64;
+        let slow_limit = slow_limit / 2 + slow_limit / 4;
+        tracing::trace!(?slow_limit, "Slow Thread limit");
+        ecs.insert(SlowJobPool::new(slow_limit, Arc::clone(&thread_pool)));
+
+        // TODO: only register on the server
+        ecs.insert(EventBus::<ServerEvent>::default());
+        ecs.insert(comp::group::GroupManager::default());
+        ecs.insert(RegionMap::new());
+        ecs.insert(SysMetrics::default());
+        ecs.insert(PhysicsMetrics::default());
+        ecs.insert(Trades::default());
+        ecs.insert(PlayerPhysicsSettings::default());
+
+        // Load plugins from asset directory
+        #[cfg(feature = "plugins")]
+        ecs.insert(match PluginMgr::from_assets() {
+            Ok(plugin_mgr) => {
+                let ecs_world = EcsWorld {
+                    entities: &ecs.entities(),
+                    health: ecs.read_component().into(),
+                    uid: ecs.read_component().into(),
+                    uid_allocator: &ecs.read_resource::<UidAllocator>().into(),
+                    player: ecs.read_component().into(),
+                };
+                if let Err(e) = plugin_mgr
+                    .execute_event(&ecs_world, &plugin_api::event::PluginLoadEvent {
+                        game_mode,
+                    })
+                {
+                    tracing::debug!(?e, "Failed to run plugin init");
+                    tracing::info!("Plugins disabled, enable debug logging for more information.");
+                    PluginMgr::default()
+                } else {
+                    plugin_mgr
+                }
+            },
+            Err(e) => {
+                tracing::debug!(?e, "Failed to read plugins from assets");
+                tracing::info!("Plugins disabled, enable debug logging for more information.");
+                PluginMgr::default()
+            },
+        });
+
+        ecs
+    }
+
+    /// Register a component with the state's ECS.
+    pub fn with_component<T: Component>(mut self) -> Self
+    where
+        <T as Component>::Storage: Default,
+    {
+        self.ecs.register::<T>();
+        self
+    }
+
+    /// Write a component attributed to a particular entity, ignoring errors.
+    ///
+    /// This should be used *only* when we can guarantee that the rest of the
+    /// code does not rely on the insert having succeeded (meaning the
+    /// entity is no longer alive!).
+    ///
+    /// Returns None if the entity was dead or there was no previous entry for
+    /// this component; otherwise, returns Some(old_component).
+    pub fn write_component_ignore_entity_dead<C: Component>(
+        &mut self,
+        entity: EcsEntity,
+        comp: C,
+    ) -> Option<C> {
+        self.ecs
+            .write_storage()
+            .insert(entity, comp)
+            .ok()
+            .and_then(identity)
+    }
+
+    /// Delete a component attributed to a particular entity.
+    pub fn delete_component<C: Component>(&mut self, entity: EcsEntity) -> Option<C> {
+        self.ecs.write_storage().remove(entity)
+    }
+
+    /// Read a component attributed to a particular entity.
+    pub fn read_component_cloned<C: Component + Clone>(&self, entity: EcsEntity) -> Option<C> {
+        self.ecs.read_storage().get(entity).cloned()
+    }
+
+    /// Read a component attributed to a particular entity.
+    pub fn read_component_copied<C: Component + Copy>(&self, entity: EcsEntity) -> Option<C> {
+        self.ecs.read_storage().get(entity).copied()
+    }
+
+    /// Given mutable access to the resource R, assuming the resource
+    /// component exists (this is already the behavior of functions like `fetch`
+    /// and `write_component_ignore_entity_dead`).  Since all of our resources
+    /// are generated up front, any failure here is definitely a code bug.
+    pub fn mut_resource<R: Resource>(&mut self) -> &mut R {
+        self.ecs.get_mut::<R>().expect(
+            "Tried to fetch an invalid resource even though all our resources should be known at \
+             compile time.",
+        )
+    }
+
+    /// Get a read-only reference to the storage of a particular component type.
+    pub fn read_storage<C: Component>(&self) -> EcsStorage<C, Fetch<EcsMaskedStorage<C>>> {
+        self.ecs.read_storage::<C>()
+    }
+
+    /// Get a reference to the internal ECS world.
+    pub fn ecs(&self) -> &specs::World { &self.ecs }
+
+    /// Get a mutable reference to the internal ECS world.
+    pub fn ecs_mut(&mut self) -> &mut specs::World { &mut self.ecs }
+
+    /// Get a reference to the `TerrainChanges` structure of the state. This
+    /// contains information about terrain state that has changed since the
+    /// last game tick.
+    pub fn terrain_changes(&self) -> Fetch<TerrainChanges> { self.ecs.read_resource() }
+
+    /// Get the current in-game time of day.
+    ///
+    /// Note that this should not be used for physics, animations or other such
+    /// localised timings.
+    pub fn get_time_of_day(&self) -> f64 { self.ecs.read_resource::<TimeOfDay>().0 }
+
+    /// Get the current in-game day period (period of the day/night cycle)
+    /// Get the current in-game day period (period of the day/night cycle)
+    pub fn get_day_period(&self) -> DayPeriod { self.get_time_of_day().into() }
+
+    /// Get the current in-game time.
+    ///
+    /// Note that this does not correspond to the time of day.
+    pub fn get_time(&self) -> f64 { self.ecs.read_resource::<Time>().0 }
+
+    /// Get the current delta time.
+    pub fn get_delta_time(&self) -> f32 { self.ecs.read_resource::<DeltaTime>().0 }
+
+    /// Get a reference to this state's terrain.
+    pub fn terrain(&self) -> Fetch<TerrainGrid> { self.ecs.read_resource() }
+
+    /// Get a reference to this state's terrain.
+    pub fn slow_job_pool(&self) -> Fetch<SlowJobPool> { self.ecs.read_resource() }
+
+    /// Get a writable reference to this state's terrain.
+    pub fn terrain_mut(&self) -> FetchMut<TerrainGrid> { self.ecs.write_resource() }
+
+    /// Get a block in this state's terrain.
+    pub fn get_block(&self, pos: Vec3<i32>) -> Option<Block> {
+        self.terrain().get(pos).ok().copied()
+    }
+
+    /// Set a block in this state's terrain.
+    pub fn set_block(&self, pos: Vec3<i32>, block: Block) {
+        self.ecs.write_resource::<BlockChange>().set(pos, block);
+    }
+
+    /// Check if the block at given position `pos` has already been modified
+    /// this tick.
+    pub fn can_set_block(&self, pos: Vec3<i32>) -> bool {
+        !self
+            .ecs
+            .read_resource::<BlockChange>()
+            .blocks
+            .contains_key(&pos)
+    }
+
+    /// Removes every chunk of the terrain.
+    pub fn clear_terrain(&mut self) {
+        let removed_chunks = &mut self.ecs.write_resource::<TerrainChanges>().removed_chunks;
+
+        self.terrain_mut().drain().for_each(|(key, _)| {
+            removed_chunks.insert(key);
+        });
+    }
+
+    /// Insert the provided chunk into this state's terrain.
+    pub fn insert_chunk(&mut self, key: Vec2<i32>, chunk: TerrainChunk) {
+        if self
+            .ecs
+            .write_resource::<TerrainGrid>()
+            .insert(key, Arc::new(chunk))
+            .is_some()
+        {
+            self.ecs
+                .write_resource::<TerrainChanges>()
+                .modified_chunks
+                .insert(key);
+        } else {
+            self.ecs
+                .write_resource::<TerrainChanges>()
+                .new_chunks
+                .insert(key);
+        }
+    }
+
+    /// Remove the chunk with the given key from this state's terrain, if it
+    /// exists.
+    pub fn remove_chunk(&mut self, key: Vec2<i32>) {
+        if self
+            .ecs
+            .write_resource::<TerrainGrid>()
+            .remove(key)
+            .is_some()
+        {
+            self.ecs
+                .write_resource::<TerrainChanges>()
+                .removed_chunks
+                .insert(key);
+        }
+    }
+
+    // Run RegionMap tick to update entity region occupancy
+    pub fn update_region_map(&self) {
+        span!(_guard, "update_region_map", "State::update_region_map");
+        self.ecs.write_resource::<RegionMap>().tick(
+            self.ecs.read_storage::<comp::Pos>(),
+            self.ecs.read_storage::<comp::Vel>(),
+            self.ecs.entities(),
+        );
+    }
+
+    // Apply terrain changes
+    pub fn apply_terrain_changes(&self) {
+        span!(
+            _guard,
+            "apply_terrain_changes",
+            "State::apply_terrain_changes"
+        );
+        let mut terrain = self.ecs.write_resource::<TerrainGrid>();
+        let mut modified_blocks =
+            std::mem::take(&mut self.ecs.write_resource::<BlockChange>().blocks);
+        // Apply block modifications
+        // Only include in `TerrainChanges` if successful
+        modified_blocks.retain(|pos, block| terrain.set(*pos, *block).is_ok());
+        self.ecs.write_resource::<TerrainChanges>().modified_blocks = modified_blocks;
+    }
+
+    /// Execute a single tick, simulating the game state by the given duration.
+    pub fn tick(
+        &mut self,
+        dt: Duration,
+        add_systems: impl Fn(&mut DispatcherBuilder),
+        update_terrain_and_regions: bool,
+    ) {
+        span!(_guard, "tick", "State::tick");
+        // Change the time accordingly.
+        self.ecs.write_resource::<TimeOfDay>().0 += dt.as_secs_f64() * DAY_CYCLE_FACTOR;
+        self.ecs.write_resource::<Time>().0 += dt.as_secs_f64();
+
+        // Update delta time.
+        // Beyond a delta time of MAX_DELTA_TIME, start lagging to avoid skipping
+        // important physics events.
+        self.ecs.write_resource::<DeltaTime>().0 = dt.as_secs_f32().min(MAX_DELTA_TIME);
+
+        if update_terrain_and_regions {
+            self.update_region_map();
+        }
+
+        span!(guard, "create dispatcher");
+        // Run systems to update the world.
+        // Create and run a dispatcher for ecs systems.
+        let mut dispatch_builder =
+            DispatcherBuilder::new().with_pool(Arc::clone(&self.thread_pool));
+        // TODO: Consider alternative ways to do this
+        add_systems(&mut dispatch_builder);
+        // This dispatches all the systems in parallel.
+        let mut dispatcher = dispatch_builder.build();
+        drop(guard);
+
+        span!(guard, "run systems");
+        dispatcher.dispatch(&self.ecs);
+        drop(guard);
+
+        span!(guard, "maintain ecs");
+        self.ecs.maintain();
+        drop(guard);
+
+        if update_terrain_and_regions {
+            self.apply_terrain_changes();
+        }
+
+        // Process local events
+        span!(guard, "process local events");
+        let events = self.ecs.read_resource::<EventBus<LocalEvent>>().recv_all();
+        for event in events {
+            let mut velocities = self.ecs.write_storage::<comp::Vel>();
+            let physics = self.ecs.read_storage::<comp::PhysicsState>();
+            match event {
+                LocalEvent::Jump(entity, impulse) => {
+                    if let Some(vel) = velocities.get_mut(entity) {
+                        vel.0.z = impulse + physics.get(entity).map_or(0.0, |ps| ps.ground_vel.z);
+                    }
+                },
+                LocalEvent::ApplyImpulse { entity, impulse } => {
+                    if let Some(vel) = velocities.get_mut(entity) {
+                        vel.0 = impulse;
+                    }
+                },
+                LocalEvent::Boost {
+                    entity,
+                    vel: extra_vel,
+                } => {
+                    if let Some(vel) = velocities.get_mut(entity) {
+                        vel.0 += extra_vel;
+                    }
+                },
+                LocalEvent::CreateOutcome(outcome) => {
+                    self.ecs.write_resource::<Vec<Outcome>>().push(outcome);
+                },
+            }
+        }
+        drop(guard);
+    }
+
+    /// Clean up the state after a tick.
+    pub fn cleanup(&mut self) {
+        span!(_guard, "cleanup", "State::cleanup");
+        // Clean up data structures from the last tick.
+        self.ecs.write_resource::<TerrainChanges>().clear();
+    }
+}
diff --git a/common/sys/Cargo.toml b/common/systems/Cargo.toml
similarity index 97%
rename from common/sys/Cargo.toml
rename to common/systems/Cargo.toml
index 33a746079d..f9bed018ce 100644
--- a/common/sys/Cargo.toml
+++ b/common/systems/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 authors = ["Marcel Märtens <marcel.cochem@googlemail.com>"]
 edition = "2018"
-name = "veloren-common-sys"
+name = "veloren-common-systems"
 version = "0.9.0"
 
 [features]
diff --git a/common/sys/src/aura.rs b/common/systems/src/aura.rs
similarity index 100%
rename from common/sys/src/aura.rs
rename to common/systems/src/aura.rs
diff --git a/common/sys/src/beam.rs b/common/systems/src/beam.rs
similarity index 100%
rename from common/sys/src/beam.rs
rename to common/systems/src/beam.rs
diff --git a/common/sys/src/buff.rs b/common/systems/src/buff.rs
similarity index 100%
rename from common/sys/src/buff.rs
rename to common/systems/src/buff.rs
diff --git a/common/sys/src/character_behavior.rs b/common/systems/src/character_behavior.rs
similarity index 100%
rename from common/sys/src/character_behavior.rs
rename to common/systems/src/character_behavior.rs
diff --git a/common/sys/src/controller.rs b/common/systems/src/controller.rs
similarity index 100%
rename from common/sys/src/controller.rs
rename to common/systems/src/controller.rs
diff --git a/common/sys/src/interpolation.rs b/common/systems/src/interpolation.rs
similarity index 100%
rename from common/sys/src/interpolation.rs
rename to common/systems/src/interpolation.rs
diff --git a/common/sys/src/lib.rs b/common/systems/src/lib.rs
similarity index 98%
rename from common/sys/src/lib.rs
rename to common/systems/src/lib.rs
index 4287507a5a..19596f16b5 100644
--- a/common/sys/src/lib.rs
+++ b/common/systems/src/lib.rs
@@ -6,7 +6,7 @@ mod beam;
 mod buff;
 pub mod character_behavior;
 pub mod controller;
-pub mod interpolation;
+mod interpolation;
 pub mod melee;
 mod mount;
 pub mod phys;
diff --git a/common/sys/src/melee.rs b/common/systems/src/melee.rs
similarity index 100%
rename from common/sys/src/melee.rs
rename to common/systems/src/melee.rs
diff --git a/common/sys/src/mount.rs b/common/systems/src/mount.rs
similarity index 100%
rename from common/sys/src/mount.rs
rename to common/systems/src/mount.rs
diff --git a/common/sys/src/phys.rs b/common/systems/src/phys.rs
similarity index 100%
rename from common/sys/src/phys.rs
rename to common/systems/src/phys.rs
diff --git a/common/sys/src/phys/spatial_grid.rs b/common/systems/src/phys/spatial_grid.rs
similarity index 100%
rename from common/sys/src/phys/spatial_grid.rs
rename to common/systems/src/phys/spatial_grid.rs
diff --git a/common/sys/src/projectile.rs b/common/systems/src/projectile.rs
similarity index 100%
rename from common/sys/src/projectile.rs
rename to common/systems/src/projectile.rs
diff --git a/common/sys/src/shockwave.rs b/common/systems/src/shockwave.rs
similarity index 100%
rename from common/sys/src/shockwave.rs
rename to common/systems/src/shockwave.rs
diff --git a/common/sys/src/stats.rs b/common/systems/src/stats.rs
similarity index 100%
rename from common/sys/src/stats.rs
rename to common/systems/src/stats.rs
diff --git a/server/Cargo.toml b/server/Cargo.toml
index 31dd0eb517..09009685d0 100644
--- a/server/Cargo.toml
+++ b/server/Cargo.toml
@@ -6,7 +6,7 @@ edition = "2018"
 
 [features]
 worldgen = []
-tracy = ["common/tracy", "common-base/tracy", "common-ecs/tracy", "common-sys/tracy", "common-net/tracy", "world/tracy"]
+tracy = ["common/tracy", "common-base/tracy", "common-ecs/tracy", "common-state/tracy", "common-net/tracy", "world/tracy"]
 simd = ["vek/platform_intrinsics"]
 plugins = ["common-state/plugins"]
 
@@ -17,7 +17,7 @@ common = { package = "veloren-common", path = "../common" }
 common-base = { package = "veloren-common-base", path = "../common/base" }
 common-ecs = { package = "veloren-common-ecs", path = "../common/ecs" }
 common-state = { package = "veloren-common-state", path = "../common/state" }
-common-sys = { package = "veloren-common-sys", path = "../common/sys" }
+common-systems = { package = "veloren-common-systems", path = "../common/systems" }
 common-net = { package = "veloren-common-net", path = "../common/net" }
 world = { package = "veloren-world", path = "../world" }
 network = { package = "veloren-network", path = "../network", features = ["metrics", "compression"], default-features = false }
diff --git a/server/src/lib.rs b/server/src/lib.rs
index 80689cce14..acc5d9c254 100644
--- a/server/src/lib.rs
+++ b/server/src/lib.rs
@@ -81,7 +81,7 @@ use common_state::plugin::memory_manager::EcsWorld;
 #[cfg(feature = "plugins")]
 use common_state::plugin::PluginMgr;
 use common_state::{BuildAreas, State};
-use common_sys::add_local_systems;
+use common_systems::add_local_systems;
 use metrics::{EcsSystemMetrics, PhysicsMetrics, TickMetrics};
 use network::{Network, Pid, ProtocolAddr};
 use persistence::{
diff --git a/server/src/sys/mod.rs b/server/src/sys/mod.rs
index 5f1463da08..9be00f150a 100644
--- a/server/src/sys/mod.rs
+++ b/server/src/sys/mod.rs
@@ -12,7 +12,7 @@ pub mod terrain_sync;
 pub mod waypoint;
 
 use common_ecs::{dispatch, run_now, System};
-use common_sys::{melee, projectile};
+use common_systems::{melee, projectile};
 use specs::DispatcherBuilder;
 use std::{
     marker::PhantomData,
diff --git a/voxygen/Cargo.toml b/voxygen/Cargo.toml
index 1f8ddbd08a..05703515f8 100644
--- a/voxygen/Cargo.toml
+++ b/voxygen/Cargo.toml
@@ -24,7 +24,7 @@ gl = ["gfx_device_gl", "gfx_gl"]
 hot-anim = ["anim/use-dyn-lib"]
 singleplayer = ["server"]
 simd = ["vek/platform_intrinsics"]
-tracy = ["common/tracy", "common-ecs/tracy", "common-frontend/tracy", "common-net/tracy", "common-state/tracy", "client/tracy"]
+tracy = ["common/tracy", "common-ecs/tracy", "common-frontend/tracy", "common-net/tracy", "common-systems/tracy", "common-state/tracy", "client/tracy"]
 plugins = ["client/plugins"]
 
 default = ["gl", "singleplayer", "native-dialog", "plugins", "simd"]
@@ -36,8 +36,8 @@ common-base = {package = "veloren-common-base", path = "../common/base"}
 common-ecs = {package = "veloren-common-ecs", path = "../common/ecs"}
 common-frontend = {package = "veloren-common-frontend", path = "../common/frontend"}
 common-net = {package = "veloren-common-net", path = "../common/net"}
+common-systems = {package = "veloren-common-systems", path = "../common/systems"}
 common-state = {package = "veloren-common-state", path = "../common/state"}
-common-sys = {package = "veloren-common-sys", path = "../common/sys"}
 
 anim = {package = "veloren-voxygen-anim", path = "anim"}
 
diff --git a/voxygen/src/ecs/sys.rs b/voxygen/src/ecs/sys.rs
index 4aedaa4c95..66d6565673 100644
--- a/voxygen/src/ecs/sys.rs
+++ b/voxygen/src/ecs/sys.rs
@@ -5,6 +5,6 @@ use common_ecs::{dispatch, System};
 use specs::DispatcherBuilder;
 
 pub fn add_local_systems(dispatch_builder: &mut DispatcherBuilder) {
-    dispatch::<interpolation::Sys>(dispatch_builder, &[&common_sys::phys::Sys::sys_name()]);
+    dispatch::<interpolation::Sys>(dispatch_builder, &[&common_systems::phys::Sys::sys_name()]);
     dispatch::<floater::Sys>(dispatch_builder, &[&interpolation::Sys::sys_name()]);
 }