diff --git a/CHANGELOG.md b/CHANGELOG.md
index b369b19bf7..74995d905c 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -48,6 +48,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Gave weapons critical strike {chance, multiplier} stats
 - A system to add glow and reflection effects to figures (i.e: characters, armour, weapons, etc.)
 - Merchants will trade wares with players
+- Airships that can be mounted and flown, and also walked on (`/airship` admin command)
 
 ### Changed
 
diff --git a/Cargo.lock b/Cargo.lock
index 3e6de98ee3..c16404c034 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5619,6 +5619,7 @@ dependencies = [
  "hashbrown",
  "serde",
  "specs",
+ "specs-idvs",
  "sum_type",
  "tracing",
  "vek 0.14.1",
diff --git a/assets/common/npc_names.ron b/assets/common/npc_names.ron
index 49ceb5c023..aeefb77fee 100644
--- a/assets/common/npc_names.ron
+++ b/assets/common/npc_names.ron
@@ -969,6 +969,15 @@
         ),
         species: ()
     ),
+    ship: (
+        body: (
+            keyword: "ship",
+            names_0: [
+                "Boaty McBoatface",
+            ],
+        ),
+        species: (),
+    ),
     biped_small: (
         body: (
             keyword: "biped_small",
diff --git a/assets/server/manifests/ship_manifest.ron b/assets/server/manifests/ship_manifest.ron
new file mode 100644
index 0000000000..817d579120
--- /dev/null
+++ b/assets/server/manifests/ship_manifest.ron
@@ -0,0 +1,23 @@
+({
+    DefaultAirship: (
+        bone0: (
+            //offset: (3.0, 7.0, 1.0),
+            //offset: (-20.75, -34.75, 1.25),
+            //offset: (0.0, 0.0, 0.0),
+            offset: (-17.5, -35.0, 1.0),
+            //phys_offset: (0.25, 0.25, 0.25),
+            phys_offset: (0.0, 0.0, 0.0),
+            central: ("Human_Airship"),
+        ),
+        bone1: (
+            offset: (0.0, 40.0, -8.0),
+            phys_offset: (0.0, 0.0, 0.0),
+            central: ("propeller-l"),
+        ),
+        bone2: (
+            offset: (0.0, 0.0, -4.0),
+            phys_offset: (0.0, 0.0, 0.0),
+            central: ("propeller-r"),
+        ),
+    ),
+})
diff --git a/assets/server/voxel/Human_Airship.vox b/assets/server/voxel/Human_Airship.vox
new file mode 100644
index 0000000000..36e3758d03
--- /dev/null
+++ b/assets/server/voxel/Human_Airship.vox
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ba02746d73ebf853c0511b673510c09bd47e3ab0fff13d936feb181a8378ebd9
+size 78024
diff --git a/assets/server/voxel/airship.vox b/assets/server/voxel/airship.vox
new file mode 100644
index 0000000000..06bebaa938
--- /dev/null
+++ b/assets/server/voxel/airship.vox
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:86f317298900ea98f95c6a33192b25fbbcbd3ce5f105cad58ad3c595a7a7d9ee
+size 70176
diff --git a/assets/server/voxel/propeller-l.vox b/assets/server/voxel/propeller-l.vox
new file mode 100644
index 0000000000..a193fa89ee
--- /dev/null
+++ b/assets/server/voxel/propeller-l.vox
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:09ef4bad2557abcc5a2b938f21053babc7770ebe2333039aef9b98ba930b7ec7
+size 1584
diff --git a/assets/server/voxel/propeller-r.vox b/assets/server/voxel/propeller-r.vox
new file mode 100644
index 0000000000..5b940751e6
--- /dev/null
+++ b/assets/server/voxel/propeller-r.vox
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4947977524b88bc5adfa934d9061a3499e94b960abb3bcf0a3e2aca482096dc
+size 1584
diff --git a/client/src/lib.rs b/client/src/lib.rs
index 588ab0ae8b..27bf2f7c90 100644
--- a/client/src/lib.rs
+++ b/client/src/lib.rs
@@ -33,6 +33,7 @@ use common::{
     grid::Grid,
     outcome::Outcome,
     recipe::RecipeBook,
+    resources::PlayerEntity,
     terrain::{block::Block, neighbors, BiomeKind, SitesKind, TerrainChunk, TerrainChunkSize},
     trade::{PendingTrade, TradeAction, TradeId, TradeResult},
     uid::{Uid, UidAllocator},
@@ -281,6 +282,7 @@ impl Client {
 
                 let entity = state.ecs_mut().apply_entity_package(entity_package);
                 *state.ecs_mut().write_resource() = time_of_day;
+                *state.ecs_mut().write_resource() = PlayerEntity(Some(entity));
                 state.ecs_mut().insert(material_stats);
                 state.ecs_mut().insert(ability_map);
 
@@ -1458,6 +1460,7 @@ impl Client {
             ServerGeneral::SetPlayerEntity(uid) => {
                 if let Some(entity) = self.state.ecs().entity_from_uid(uid.0) {
                     self.entity = entity;
+                    *self.state.ecs_mut().write_resource() = PlayerEntity(Some(entity));
                 } else {
                     return Err(Error::Other("Failed to find entity from uid.".to_owned()));
                 }
diff --git a/common/Cargo.toml b/common/Cargo.toml
index 9001b753b1..ae126f3ed1 100644
--- a/common/Cargo.toml
+++ b/common/Cargo.toml
@@ -15,6 +15,7 @@ default = ["simd"]
 [dependencies]
 
 common-base = { package = "veloren-common-base", path = "base" }
+#inline_tweak = "1.0.2"
 
 # Serde
 serde = { version = "1.0.110", features = ["derive", "rc"] }
diff --git a/common/net/Cargo.toml b/common/net/Cargo.toml
index 227ae093f9..5d8773a164 100644
--- a/common/net/Cargo.toml
+++ b/common/net/Cargo.toml
@@ -12,6 +12,7 @@ default = ["simd"]
 
 [dependencies]
 common = {package = "veloren-common", path = "../../common"}
+#inline_tweak = "1.0.2"
 
 sum_type = "0.2.0"
 vek = { version = "=0.14.1", features = ["serde"] }
@@ -25,6 +26,7 @@ authc = { git = "https://gitlab.com/veloren/auth.git", rev = "fb3dcbc4962b367253
 
 # ECS
 specs = { git = "https://github.com/amethyst/specs.git", features = ["serde", "storage-event-control"], rev = "5a9b71035007be0e3574f35184acac1cd4530496" }
+specs-idvs = { git = "https://gitlab.com/veloren/specs-idvs.git", rev = "b65fb220e94f5d3c9bc30074a076149763795556" }
 
 # Serde
-serde = { version = "1.0.110", features = ["derive"] }
\ No newline at end of file
+serde = { version = "1.0.110", features = ["derive"] }
diff --git a/common/net/src/msg/ecs_packet.rs b/common/net/src/msg/ecs_packet.rs
index 1ee77e127d..86049f7103 100644
--- a/common/net/src/msg/ecs_packet.rs
+++ b/common/net/src/msg/ecs_packet.rs
@@ -100,9 +100,9 @@ impl sync::CompPacket for EcsCompPacket {
             EcsCompPacket::Gravity(comp) => sync::handle_insert(comp, entity, world),
             EcsCompPacket::Sticky(comp) => sync::handle_insert(comp, entity, world),
             EcsCompPacket::CharacterState(comp) => sync::handle_insert(comp, entity, world),
-            EcsCompPacket::Pos(comp) => sync::handle_insert(comp, entity, world),
-            EcsCompPacket::Vel(comp) => sync::handle_insert(comp, entity, world),
-            EcsCompPacket::Ori(comp) => sync::handle_insert(comp, entity, world),
+            EcsCompPacket::Pos(comp) => sync::handle_interp_insert(comp, entity, world),
+            EcsCompPacket::Vel(comp) => sync::handle_interp_insert(comp, entity, world),
+            EcsCompPacket::Ori(comp) => sync::handle_interp_insert(comp, entity, world),
             EcsCompPacket::Shockwave(comp) => sync::handle_insert(comp, entity, world),
             EcsCompPacket::BeamSegment(comp) => sync::handle_insert(comp, entity, world),
         }
@@ -132,9 +132,9 @@ impl sync::CompPacket for EcsCompPacket {
             EcsCompPacket::Gravity(comp) => sync::handle_modify(comp, entity, world),
             EcsCompPacket::Sticky(comp) => sync::handle_modify(comp, entity, world),
             EcsCompPacket::CharacterState(comp) => sync::handle_modify(comp, entity, world),
-            EcsCompPacket::Pos(comp) => sync::handle_modify(comp, entity, world),
-            EcsCompPacket::Vel(comp) => sync::handle_modify(comp, entity, world),
-            EcsCompPacket::Ori(comp) => sync::handle_modify(comp, entity, world),
+            EcsCompPacket::Pos(comp) => sync::handle_interp_modify(comp, entity, world),
+            EcsCompPacket::Vel(comp) => sync::handle_interp_modify(comp, entity, world),
+            EcsCompPacket::Ori(comp) => sync::handle_interp_modify(comp, entity, world),
             EcsCompPacket::Shockwave(comp) => sync::handle_modify(comp, entity, world),
             EcsCompPacket::BeamSegment(comp) => sync::handle_modify(comp, entity, world),
         }
@@ -168,9 +168,9 @@ impl sync::CompPacket for EcsCompPacket {
             EcsCompPhantom::CharacterState(_) => {
                 sync::handle_remove::<comp::CharacterState>(entity, world)
             },
-            EcsCompPhantom::Pos(_) => sync::handle_remove::<comp::Pos>(entity, world),
-            EcsCompPhantom::Vel(_) => sync::handle_remove::<comp::Vel>(entity, world),
-            EcsCompPhantom::Ori(_) => sync::handle_remove::<comp::Ori>(entity, world),
+            EcsCompPhantom::Pos(_) => sync::handle_interp_remove::<comp::Pos>(entity, world),
+            EcsCompPhantom::Vel(_) => sync::handle_interp_remove::<comp::Vel>(entity, world),
+            EcsCompPhantom::Ori(_) => sync::handle_interp_remove::<comp::Ori>(entity, world),
             EcsCompPhantom::Shockwave(_) => sync::handle_remove::<comp::Shockwave>(entity, world),
             EcsCompPhantom::BeamSegment(_) => sync::handle_remove::<comp::Ori>(entity, world),
         }
diff --git a/common/net/src/sync/interpolation.rs b/common/net/src/sync/interpolation.rs
new file mode 100644
index 0000000000..2b2207ad09
--- /dev/null
+++ b/common/net/src/sync/interpolation.rs
@@ -0,0 +1,155 @@
+// impls of `InterpolatableComponent` on things defined in `common`, since
+// `common_net` is downstream of `common`, and an `InterpolationSystem` that
+// applies them
+use super::InterpolatableComponent;
+use common::comp::{Ori, Pos, Vel};
+use specs::Component;
+use specs_idvs::IdvStorage;
+use tracing::warn;
+use vek::ops::{Lerp, Slerp};
+
+#[derive(Debug, Default)]
+pub struct InterpBuffer<T> {
+    pub buf: [(f64, T); 4],
+    pub i: usize,
+}
+
+impl<T> InterpBuffer<T> {
+    fn push(&mut self, time: f64, x: T) {
+        let InterpBuffer {
+            ref mut buf,
+            ref mut i,
+        } = self;
+        *i += 1;
+        *i %= buf.len();
+        buf[*i] = (time, x);
+    }
+}
+
+impl<T: 'static + Send + Sync> Component for InterpBuffer<T> {
+    type Storage = IdvStorage<Self>;
+}
+
+// 0 is pure physics, 1 is pure extrapolation
+const PHYSICS_VS_EXTRAPOLATION_FACTOR: f32 = 0.2;
+const POSITION_INTERP_SANITY: Option<f32> = None;
+const VELOCITY_INTERP_SANITY: Option<f32> = None;
+const ENABLE_POSITION_HERMITE: bool = false;
+
+impl InterpolatableComponent for Pos {
+    type InterpData = InterpBuffer<Pos>;
+    type ReadData = InterpBuffer<Vel>;
+
+    fn update_component(&self, interp_data: &mut Self::InterpData, time: f64) {
+        interp_data.push(time, *self);
+    }
+
+    fn interpolate(self, interp_data: &Self::InterpData, t2: f64, vel: &InterpBuffer<Vel>) -> Self {
+        // lerp to test interface, do hermite spline later
+        let InterpBuffer { ref buf, ref i } = interp_data;
+        let (t0, p0) = buf[(i + buf.len() - 1) % buf.len()];
+        let (t1, p1) = buf[i % buf.len()];
+        if (t1 - t0).abs() < f64::EPSILON {
+            return self;
+        }
+        if POSITION_INTERP_SANITY
+            .map_or(false, |limit| p0.0.distance_squared(p1.0) > limit.powf(2.0))
+        {
+            warn!("position delta exceeded sanity check, clamping");
+            return p1;
+        }
+        let (t0prime, m0) = vel.buf[(i + vel.buf.len() - 1) % vel.buf.len()];
+        let (t1prime, m1) = vel.buf[i % vel.buf.len()];
+        let mut out;
+        let t = (t2 - t0) / (t1 - t0);
+        if ENABLE_POSITION_HERMITE
+            && ((t0 - t0prime).abs() < f64::EPSILON && (t1 - t1prime).abs() < f64::EPSILON)
+        {
+            let h00 = |t: f64| (2.0 * t.powf(3.0) - 3.0 * t.powf(2.0) + 1.0) as f32;
+            let h10 = |t: f64| (t.powf(3.0) - 2.0 * t.powf(2.0) + t) as f32;
+            let h01 = |t: f64| (-2.0 * t.powf(3.0) + 3.0 * t.powf(2.0)) as f32;
+            let h11 = |t: f64| (t.powf(3.0) - t.powf(2.0)) as f32;
+            let dt = (t1 - t0) as f32;
+            out = h00(t) * p0.0 + h10(t) * dt * m0.0 + h01(t) * p1.0 + h11(t) * dt * m1.0;
+        } else {
+            if ENABLE_POSITION_HERMITE {
+                warn!(
+                    "timestamps for pos and vel don't match ({:?}, {:?}), falling back to lerp",
+                    interp_data, vel
+                );
+            }
+            out = Lerp::lerp_unclamped(p0.0, p1.0, t as f32);
+        }
+
+        if out.map(|x| x.is_nan()).reduce_or() {
+            warn!("interpolation output is nan: {}, {}, {:?}", t2, t, buf);
+            out = p1.0;
+        }
+
+        Pos(Lerp::lerp(self.0, out, PHYSICS_VS_EXTRAPOLATION_FACTOR))
+    }
+}
+
+impl InterpolatableComponent for Vel {
+    type InterpData = InterpBuffer<Vel>;
+    type ReadData = ();
+
+    fn update_component(&self, interp_data: &mut Self::InterpData, time: f64) {
+        interp_data.push(time, *self);
+    }
+
+    fn interpolate(self, interp_data: &Self::InterpData, t2: f64, _: &()) -> Self {
+        let InterpBuffer { ref buf, ref i } = interp_data;
+        let (t0, p0) = buf[(i + buf.len() - 1) % buf.len()];
+        let (t1, p1) = buf[i % buf.len()];
+        if (t1 - t0).abs() < f64::EPSILON {
+            return self;
+        }
+        if VELOCITY_INTERP_SANITY
+            .map_or(false, |limit| p0.0.distance_squared(p1.0) > limit.powf(2.0))
+        {
+            warn!("velocity delta exceeded sanity check, clamping");
+            return p1;
+        }
+        let lerp_factor = 1.0 + ((t2 - t1) / (t1 - t0)) as f32;
+        let mut out = Lerp::lerp_unclamped(p0.0, p1.0, lerp_factor);
+        if out.map(|x| x.is_nan()).reduce_or() {
+            warn!(
+                "interpolation output is nan: {}, {}, {:?}",
+                t2, lerp_factor, buf
+            );
+            out = p1.0;
+        }
+
+        Vel(Lerp::lerp(self.0, out, PHYSICS_VS_EXTRAPOLATION_FACTOR))
+    }
+}
+
+impl InterpolatableComponent for Ori {
+    type InterpData = InterpBuffer<Ori>;
+    type ReadData = ();
+
+    fn update_component(&self, interp_data: &mut Self::InterpData, time: f64) {
+        interp_data.push(time, *self);
+    }
+
+    fn interpolate(self, interp_data: &Self::InterpData, t2: f64, _: &()) -> Self {
+        let InterpBuffer { ref buf, ref i } = interp_data;
+        let (t0, p0) = buf[(i + buf.len() - 1) % buf.len()];
+        let (t1, p1) = buf[i % buf.len()];
+        if (t1 - t0).abs() < f64::EPSILON {
+            return self;
+        }
+        let lerp_factor = 1.0 + ((t2 - t1) / (t1 - t0)) as f32;
+        let mut out = Slerp::slerp_unclamped(p0.to_quat(), p1.to_quat(), lerp_factor);
+        if out.into_vec4().map(|x| x.is_nan()).reduce_or() {
+            warn!(
+                "interpolation output is nan: {}, {}, {:?}",
+                t2, lerp_factor, buf
+            );
+            out = p1.to_quat();
+        }
+
+        Ori::new(Slerp::slerp(self.to_quat(), out, PHYSICS_VS_EXTRAPOLATION_FACTOR).normalized())
+    }
+}
diff --git a/common/net/src/sync/mod.rs b/common/net/src/sync/mod.rs
index 2b25c0db43..7997437db5 100644
--- a/common/net/src/sync/mod.rs
+++ b/common/net/src/sync/mod.rs
@@ -1,5 +1,6 @@
 // Note: Currently only one-way sync is supported until a usecase for two-way
 // sync arises
+pub mod interpolation;
 mod packet;
 mod sync_ext;
 mod track;
@@ -7,8 +8,9 @@ mod track;
 // Reexports
 pub use common::uid::{Uid, UidAllocator};
 pub use packet::{
-    handle_insert, handle_modify, handle_remove, CompPacket, CompSyncPackage, EntityPackage,
-    EntitySyncPackage, StatePackage,
+    handle_insert, handle_interp_insert, handle_interp_modify, handle_interp_remove, handle_modify,
+    handle_remove, CompPacket, CompSyncPackage, EntityPackage, EntitySyncPackage,
+    InterpolatableComponent, StatePackage,
 };
 pub use sync_ext::WorldSyncExt;
 pub use track::UpdateTracker;
diff --git a/common/net/src/sync/packet.rs b/common/net/src/sync/packet.rs
index e86dfb30fa..152b7946d6 100644
--- a/common/net/src/sync/packet.rs
+++ b/common/net/src/sync/packet.rs
@@ -1,5 +1,5 @@
 use super::track::UpdateTracker;
-use common::uid::Uid;
+use common::{resources::Time, uid::Uid};
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use specs::{Component, Entity, Join, ReadStorage, World, WorldExt};
 use std::{
@@ -9,6 +9,10 @@ use std::{
 };
 use tracing::error;
 
+// TODO: apply_{insert,modify,remove} all take the entity and call
+// `write_storage` once per entity per component, instead of once per update
+// batch(e.g. in a system-like memory access pattern); if sync ends up being a
+// bottleneck, try optimizing this
 /// Implemented by type that carries component data for insertion and
 /// modification The assocatied `Phantom` type only carries information about
 /// which component type is of interest and is used to transmit deletion events
@@ -42,6 +46,44 @@ pub fn handle_remove<C: Component>(entity: Entity, world: &World) {
     world.write_storage::<C>().remove(entity);
 }
 
+pub trait InterpolatableComponent: Component {
+    type InterpData: Component + Default;
+    type ReadData;
+
+    fn update_component(&self, data: &mut Self::InterpData, time: f64);
+    fn interpolate(self, data: &Self::InterpData, time: f64, read_data: &Self::ReadData) -> Self;
+}
+
+pub fn handle_interp_insert<C: InterpolatableComponent>(comp: C, entity: Entity, world: &World) {
+    let mut interp_data = C::InterpData::default();
+    let time = world.read_resource::<Time>().0;
+    comp.update_component(&mut interp_data, time);
+    handle_insert(comp, entity, world);
+    handle_insert(interp_data, entity, world);
+}
+
+pub fn handle_interp_modify<C: InterpolatableComponent + Debug>(
+    comp: C,
+    entity: Entity,
+    world: &World,
+) {
+    if let Some(mut interp_data) = world.write_storage::<C::InterpData>().get_mut(entity) {
+        let time = world.read_resource::<Time>().0;
+        comp.update_component(&mut interp_data, time);
+        handle_modify(comp, entity, world);
+    } else {
+        error!(
+            ?comp,
+            "Error modifying interpolation data for synced component, it doesn't seem to exist"
+        );
+    }
+}
+
+pub fn handle_interp_remove<C: InterpolatableComponent>(entity: Entity, world: &World) {
+    handle_remove::<C>(entity, world);
+    handle_remove::<C::InterpData>(entity, world);
+}
+
 #[derive(Copy, Clone, Debug, Serialize, Deserialize)]
 pub enum CompUpdateKind<P: CompPacket> {
     Inserted(P),
diff --git a/common/src/cmd.rs b/common/src/cmd.rs
index f6771bdcd3..e53c82609e 100644
--- a/common/src/cmd.rs
+++ b/common/src/cmd.rs
@@ -36,6 +36,7 @@ impl ChatCommandData {
 #[derive(Copy, Clone)]
 pub enum ChatCommand {
     Adminify,
+    Airship,
     Alias,
     Ban,
     Build,
@@ -89,6 +90,7 @@ pub enum ChatCommand {
 // Thank you for keeping this sorted alphabetically :-)
 pub static CHAT_COMMANDS: &[ChatCommand] = &[
     ChatCommand::Adminify,
+    ChatCommand::Airship,
     ChatCommand::Alias,
     ChatCommand::Ban,
     ChatCommand::Build,
@@ -222,6 +224,11 @@ impl ChatCommand {
                 "Temporarily gives a player admin permissions or removes them",
                 Admin,
             ),
+            ChatCommand::Airship => cmd(
+                vec![Float("destination_degrees_ccw_of_east", 90.0, Optional)],
+                "Spawns an airship",
+                Admin,
+            ),
             ChatCommand::Alias => cmd(vec![Any("name", Required)], "Change your alias", NoAdmin),
             ChatCommand::Ban => cmd(
                 vec![Any("username", Required), Message(Optional)],
@@ -449,6 +456,7 @@ impl ChatCommand {
     pub fn keyword(&self) -> &'static str {
         match self {
             ChatCommand::Adminify => "adminify",
+            ChatCommand::Airship => "airship",
             ChatCommand::Alias => "alias",
             ChatCommand::Ban => "ban",
             ChatCommand::Build => "build",
diff --git a/common/src/comp/agent.rs b/common/src/comp/agent.rs
index 7d6c5a57df..2df698c1c8 100644
--- a/common/src/comp/agent.rs
+++ b/common/src/comp/agent.rs
@@ -168,6 +168,7 @@ impl<'a> From<&'a Body> for Psyche {
                 Body::Golem(_) => 1.0,
                 Body::Theropod(_) => 1.0,
                 Body::Dragon(_) => 1.0,
+                Body::Ship(_) => 1.0,
             },
         }
     }
@@ -221,6 +222,15 @@ impl Agent {
         self
     }
 
+    pub fn with_destination(pos: Vec3<f32>) -> Self {
+        Self {
+            can_speak: true,
+            psyche: Psyche { aggro: 1.0 },
+            rtsim_controller: RtSimController::with_destination(pos),
+            ..Default::default()
+        }
+    }
+
     pub fn new(
         patrol_origin: Option<Vec3<f32>>,
         can_speak: bool,
diff --git a/common/src/comp/body.rs b/common/src/comp/body.rs
index bb331f3a54..a56ea27528 100644
--- a/common/src/comp/body.rs
+++ b/common/src/comp/body.rs
@@ -11,6 +11,7 @@ pub mod object;
 pub mod quadruped_low;
 pub mod quadruped_medium;
 pub mod quadruped_small;
+pub mod ship;
 pub mod theropod;
 
 use crate::{
@@ -44,6 +45,7 @@ make_case_elim!(
         Golem(body: golem::Body) = 11,
         Theropod(body: theropod::Body) = 12,
         QuadrupedLow(body: quadruped_low::Body) = 13,
+        Ship(body: ship::Body) = 14,
     }
 );
 
@@ -78,6 +80,7 @@ pub struct AllBodies<BodyMeta, SpeciesMeta> {
     pub golem: BodyData<BodyMeta, golem::AllSpecies<SpeciesMeta>>,
     pub theropod: BodyData<BodyMeta, theropod::AllSpecies<SpeciesMeta>>,
     pub quadruped_low: BodyData<BodyMeta, quadruped_low::AllSpecies<SpeciesMeta>>,
+    pub ship: BodyData<BodyMeta, ()>,
 }
 
 /// Can only retrieve body metadata by direct index.
@@ -124,6 +127,7 @@ impl<'a, BodyMeta, SpeciesMeta> core::ops::Index<&'a Body> for AllBodies<BodyMet
             Body::Golem(_) => &self.golem.body,
             Body::Theropod(_) => &self.theropod.body,
             Body::QuadrupedLow(_) => &self.quadruped_low.body,
+            Body::Ship(_) => &self.ship.body,
         }
     }
 }
@@ -218,6 +222,7 @@ impl Body {
             Body::Golem(_) => 2.5,
             Body::BipedSmall(_) => 0.75,
             Body::Object(_) => 0.4,
+            Body::Ship(_) => 1.0,
         }
     }
 
@@ -294,6 +299,7 @@ impl Body {
                 object::Body::Crossbow => 1.7,
                 _ => 1.0,
             },
+            Body::Ship(_) => 1.0,
         }
     }
 
@@ -416,6 +422,7 @@ impl Body {
                 quadruped_low::Species::Deadwood => 600,
                 _ => 200,
             },
+            Body::Ship(_) => 10000,
         }
     }
 
@@ -508,12 +515,23 @@ impl Body {
                 quadruped_low::Species::Deadwood => 30,
                 _ => 20,
             },
+            Body::Ship(_) => 500,
+        }
+    }
+
+    pub fn flying_height(&self) -> f32 {
+        match self {
+            Body::BirdSmall(_) => 30.0,
+            Body::BirdMedium(_) => 40.0,
+            Body::Dragon(_) => 60.0,
+            Body::Ship(ship::Body::DefaultAirship) => 60.0,
+            _ => 0.0,
         }
     }
 
     pub fn immune_to(&self, buff: BuffKind) -> bool {
         match buff {
-            BuffKind::Bleeding => matches!(self, Body::Object(_) | Body::Golem(_)),
+            BuffKind::Bleeding => matches!(self, Body::Object(_) | Body::Golem(_) | Body::Ship(_)),
             _ => false,
         }
     }
@@ -521,7 +539,13 @@ impl Body {
     /// Returns a multiplier representing increased difficulty not accounted for
     /// due to AI or not using an actual weapon
     // TODO: Match on species
-    pub fn combat_multiplier(&self) -> f32 { if let Body::Object(_) = self { 0.0 } else { 1.0 } }
+    pub fn combat_multiplier(&self) -> f32 {
+        if let Body::Object(_) | Body::Ship(_) = self {
+            0.0
+        } else {
+            1.0
+        }
+    }
 
     pub fn base_poise(&self) -> u32 {
         match self {
@@ -549,6 +573,13 @@ impl Body {
             Body::Humanoid(_) | Body::BipedSmall(_) | Body::BipedLarge(_)
         )
     }
+
+    pub fn mounting_offset(&self) -> Vec3<f32> {
+        match self {
+            Body::Ship(ship::Body::DefaultAirship) => Vec3::from([0.0, 0.0, 10.0]),
+            _ => Vec3::unit_z(),
+        }
+    }
 }
 
 impl Component for Body {
diff --git a/common/src/comp/body/ship.rs b/common/src/comp/body/ship.rs
new file mode 100644
index 0000000000..a4a465ccf8
--- /dev/null
+++ b/common/src/comp/body/ship.rs
@@ -0,0 +1,126 @@
+use crate::make_case_elim;
+use serde::{Deserialize, Serialize};
+
+make_case_elim!(
+    body,
+    #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Serialize, Deserialize)]
+    #[repr(u32)]
+    pub enum Body {
+        DefaultAirship = 0,
+    }
+);
+
+impl From<Body> for super::Body {
+    fn from(body: Body) -> Self { super::Body::Ship(body) }
+}
+
+impl Body {
+    pub fn manifest_entry(&self) -> &'static str {
+        match self {
+            Body::DefaultAirship => "Human_Airship",
+        }
+    }
+}
+
+/// Terrain is 11.0 scale relative to small-scale voxels, and all figures get
+/// multiplied by 0.8 in rendering. For now, have a constant in `comp::Scale`
+/// that compensates for both of these, but there might be a more elegant way
+/// (e.g. using `Scale(0.8)` for everything else and not having a magic number
+/// in figure rendering, and multiplying terrain models by 11.0 in animation).
+pub const AIRSHIP_SCALE: f32 = 11.0 / 0.8;
+
+/// Duplicate of some of the things defined in `voxygen::scene::figure::load` to
+/// avoid having to refactor all of that to `common` for using voxels as
+/// collider geometry
+pub mod figuredata {
+    use crate::{
+        assets::{self, AssetExt, AssetHandle, DotVoxAsset, Ron},
+        figure::cell::Cell,
+        terrain::{
+            block::{Block, BlockKind},
+            sprite::SpriteKind,
+        },
+        volumes::dyna::{ColumnAccess, Dyna},
+    };
+    use hashbrown::HashMap;
+    use lazy_static::lazy_static;
+    use serde::Deserialize;
+    use vek::Vec3;
+
+    #[derive(Deserialize)]
+    pub struct VoxSimple(pub String);
+
+    #[derive(Deserialize)]
+    pub struct ShipCentralSpec(pub HashMap<super::Body, SidedShipCentralVoxSpec>);
+
+    #[derive(Deserialize)]
+    pub struct SidedShipCentralVoxSpec {
+        pub bone0: ShipCentralSubSpec,
+        pub bone1: ShipCentralSubSpec,
+        pub bone2: ShipCentralSubSpec,
+    }
+
+    #[derive(Deserialize)]
+    pub struct ShipCentralSubSpec {
+        pub offset: [f32; 3],
+        pub phys_offset: [f32; 3],
+        pub central: VoxSimple,
+    }
+
+    /// manual instead of through `make_vox_spec!` so that it can be in `common`
+    #[derive(Clone)]
+    pub struct ShipSpec {
+        pub central: AssetHandle<Ron<ShipCentralSpec>>,
+        pub colliders: HashMap<String, VoxelCollider>,
+    }
+
+    #[derive(Clone)]
+    pub struct VoxelCollider {
+        pub dyna: Dyna<Block, (), ColumnAccess>,
+        pub translation: Vec3<f32>,
+    }
+
+    impl assets::Compound for ShipSpec {
+        fn load<S: assets::source::Source>(
+            cache: &assets::AssetCache<S>,
+            _: &str,
+        ) -> Result<Self, assets::Error> {
+            let manifest: AssetHandle<Ron<ShipCentralSpec>> =
+                AssetExt::load("server.manifests.ship_manifest")?;
+            let mut colliders = HashMap::new();
+            for (_, spec) in (manifest.read().0).0.iter() {
+                for bone in [&spec.bone0, &spec.bone1, &spec.bone2].iter() {
+                    // TODO: Currently both client and server load models and manifests from
+                    // "server.voxel.". In order to support CSG procedural airships, we probably
+                    // need to load them in the server and sync them as an ECS resource.
+                    let vox =
+                        cache.load::<DotVoxAsset>(&["server.voxel.", &bone.central.0].concat())?;
+                    let dyna = Dyna::<Cell, (), ColumnAccess>::from_vox(&vox.read().0, false);
+                    let dyna = dyna.map_into(|cell| {
+                        if let Some(rgb) = cell.get_color() {
+                            Block::new(BlockKind::Misc, rgb)
+                        } else {
+                            Block::air(SpriteKind::Empty)
+                        }
+                    });
+                    let collider = VoxelCollider {
+                        dyna,
+                        translation: Vec3::from(bone.offset) + Vec3::from(bone.phys_offset),
+                    };
+                    colliders.insert(bone.central.0.clone(), collider);
+                }
+            }
+            Ok(ShipSpec {
+                central: manifest,
+                colliders,
+            })
+        }
+    }
+
+    lazy_static! {
+        // TODO: Load this from the ECS as a resource, and maybe make it more general than ships
+        // (although figuring out how to keep the figure bones in sync with the terrain offsets seems
+        // like a hard problem if they're not the same manifest)
+        pub static ref VOXEL_COLLIDER_MANIFEST: AssetHandle<ShipSpec> = AssetExt::load_expect("server.manifests.ship_manifest");
+    }
+}
diff --git a/common/src/comp/mod.rs b/common/src/comp/mod.rs
index e493a527c9..6f951b9704 100644
--- a/common/src/comp/mod.rs
+++ b/common/src/comp/mod.rs
@@ -48,8 +48,8 @@ pub use self::{
     beam::{Beam, BeamSegment},
     body::{
         biped_large, biped_small, bird_medium, bird_small, dragon, fish_medium, fish_small, golem,
-        humanoid, object, quadruped_low, quadruped_medium, quadruped_small, theropod, AllBodies,
-        Body, BodyData,
+        humanoid, object, quadruped_low, quadruped_medium, quadruped_small, ship, theropod,
+        AllBodies, Body, BodyData,
     },
     buff::{
         Buff, BuffCategory, BuffChange, BuffData, BuffEffect, BuffId, BuffKind, BuffSource, Buffs,
diff --git a/common/src/comp/phys.rs b/common/src/comp/phys.rs
index fdb8d10a05..cddf4832f8 100644
--- a/common/src/comp/phys.rs
+++ b/common/src/comp/phys.rs
@@ -33,6 +33,7 @@ pub struct PreviousPhysCache {
     pub collision_boundary: f32,
     pub scale: f32,
     pub scaled_radius: f32,
+    pub ori: Quaternion<f32>,
 }
 
 impl Component for PreviousPhysCache {
@@ -55,9 +56,12 @@ impl Component for Mass {
     type Storage = DerefFlaggedStorage<Self, IdvStorage<Self>>;
 }
 
-// Mass
-#[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize)]
+// Collider
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub enum Collider {
+    // TODO: pass the map from ids -> voxel data to get_radius and get_z_limits to compute a
+    // bounding cylinder
+    Voxel { id: String },
     Box { radius: f32, z_min: f32, z_max: f32 },
     Point,
 }
@@ -65,6 +69,7 @@ pub enum Collider {
 impl Collider {
     pub fn get_radius(&self) -> f32 {
         match self {
+            Collider::Voxel { .. } => 1.0,
             Collider::Box { radius, .. } => *radius,
             Collider::Point => 0.0,
         }
@@ -72,6 +77,7 @@ impl Collider {
 
     pub fn get_z_limits(&self, modifier: f32) -> (f32, f32) {
         match self {
+            Collider::Voxel { .. } => (0.0, 1.0),
             Collider::Box { z_min, z_max, .. } => (*z_min * modifier, *z_max * modifier),
             Collider::Point => (0.0, 0.0),
         }
@@ -104,6 +110,7 @@ pub struct PhysicsState {
     pub on_wall: Option<Vec3<f32>>,
     pub touch_entities: Vec<Uid>,
     pub in_liquid: Option<f32>, // Depth
+    pub ground_vel: Vec3<f32>,
 }
 
 impl PhysicsState {
@@ -113,6 +120,8 @@ impl PhysicsState {
         touch_entities.clear();
         *self = Self {
             touch_entities,
+            ground_vel: self.ground_vel, /* Preserved, since it's the velocity of the last
+                                          * contact point */
             ..Self::default()
         }
     }
diff --git a/common/src/event.rs b/common/src/event.rs
index 21c8bc33af..c74ec46931 100644
--- a/common/src/event.rs
+++ b/common/src/event.rs
@@ -20,17 +20,12 @@ pub type SiteId = u64;
 
 pub enum LocalEvent {
     /// Applies upward force to entity's `Vel`
-    Jump(EcsEntity),
+    Jump(EcsEntity, f32),
     /// Applies the `impulse` to `entity`'s `Vel`
     ApplyImpulse {
         entity: EcsEntity,
         impulse: Vec3<f32>,
     },
-    /// Applies leaping force to `entity`'s `Vel` away from `wall_dir` direction
-    WallLeap {
-        entity: EcsEntity,
-        wall_dir: Vec3<f32>,
-    },
     /// Applies `vel` velocity to `entity`
     Boost { entity: EcsEntity, vel: Vec3<f32> },
 }
diff --git a/common/src/resources.rs b/common/src/resources.rs
index 73810234c8..dccede903a 100644
--- a/common/src/resources.rs
+++ b/common/src/resources.rs
@@ -1,4 +1,5 @@
 use serde::{Deserialize, Serialize};
+use specs::Entity;
 
 /// A resource that stores the time of day.
 #[derive(Copy, Clone, Debug, Serialize, Deserialize, Default)]
@@ -26,3 +27,8 @@ pub enum GameMode {
     // To be used later when we no longer start up an entirely new server for singleplayer
     Singleplayer,
 }
+
+/// A resource that stores the player's entity (on the client), and None on the
+/// server
+#[derive(Copy, Clone, Default, Debug)]
+pub struct PlayerEntity(pub Option<Entity>);
diff --git a/common/src/rtsim.rs b/common/src/rtsim.rs
index e5c1268d2e..49a831e12d 100644
--- a/common/src/rtsim.rs
+++ b/common/src/rtsim.rs
@@ -46,4 +46,11 @@ impl Default for RtSimController {
 
 impl RtSimController {
     pub fn reset(&mut self) { *self = Self::default(); }
+
+    pub fn with_destination(pos: Vec3<f32>) -> Self {
+        Self {
+            travel_to: Some((pos, format!("{:0.1?}", pos))),
+            speed_factor: 0.25,
+        }
+    }
 }
diff --git a/common/src/states/climb.rs b/common/src/states/climb.rs
index 51a5a176d5..040c31ac20 100644
--- a/common/src/states/climb.rs
+++ b/common/src/states/climb.rs
@@ -9,12 +9,9 @@ use crate::{
     util::Dir,
 };
 use serde::{Deserialize, Serialize};
-use vek::{
-    vec::{Vec2, Vec3},
-    Lerp,
-};
+use vek::*;
 
-const HUMANOID_CLIMB_ACCEL: f32 = 5.0;
+const HUMANOID_CLIMB_ACCEL: f32 = 24.0;
 const CLIMB_SPEED: f32 = 5.0;
 
 #[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize, Eq, Hash)]
@@ -36,7 +33,7 @@ impl CharacterBehavior for Data {
                 // They've climbed atop something, give them a boost
                 update
                     .local_events
-                    .push_front(LocalEvent::Jump(data.entity));
+                    .push_front(LocalEvent::Jump(data.entity, BASE_JUMP_IMPULSE * 0.5));
             }
             update.character = CharacterState::Idle {};
             return update;
@@ -76,26 +73,10 @@ impl CharacterBehavior for Data {
         };
 
         // Apply Vertical Climbing Movement
-        if update.vel.0.z <= CLIMB_SPEED {
-            match climb {
-                Climb::Down => {
-                    update.vel.0 -=
-                        data.dt.0 * update.vel.0.map(|e| e.abs().powf(1.5) * e.signum() * 1.0);
-                },
-                Climb::Up => {
-                    update.vel.0.z = (update.vel.0.z + data.dt.0 * GRAVITY * 1.25).min(CLIMB_SPEED);
-                },
-                Climb::Hold => {
-                    // Antigrav
-                    update.vel.0.z =
-                        (update.vel.0.z + data.dt.0 * GRAVITY * 1.075).min(CLIMB_SPEED);
-                    update.vel.0 = Lerp::lerp(
-                        update.vel.0,
-                        Vec3::zero(),
-                        30.0 * data.dt.0 / (1.0 - update.vel.0.z.min(0.0) * 5.0),
-                    );
-                },
-            }
+        match climb {
+            Climb::Down => update.vel.0.z += data.dt.0 * (GRAVITY - HUMANOID_CLIMB_ACCEL),
+            Climb::Up => update.vel.0.z += data.dt.0 * (GRAVITY + HUMANOID_CLIMB_ACCEL),
+            Climb::Hold => update.vel.0.z += data.dt.0 * GRAVITY,
         }
 
         update
diff --git a/common/src/states/glide.rs b/common/src/states/glide.rs
index a54046e38e..04bfbb8fe6 100644
--- a/common/src/states/glide.rs
+++ b/common/src/states/glide.rs
@@ -9,8 +9,7 @@ use vek::Vec2;
 
 // Gravity is 9.81 * 4, so this makes gravity equal to .15
 const GLIDE_ANTIGRAV: f32 = crate::consts::GRAVITY * 0.90;
-const GLIDE_ACCEL: f32 = 12.0;
-const GLIDE_SPEED: f32 = 45.0;
+const GLIDE_ACCEL: f32 = 5.0;
 
 #[derive(Copy, Clone, Debug, PartialEq, Serialize, Deserialize, Eq, Hash)]
 pub struct Data;
@@ -40,13 +39,7 @@ impl CharacterBehavior for Data {
         handle_climb(&data, &mut update);
 
         // Move player according to movement direction vector
-        update.vel.0 += Vec2::broadcast(data.dt.0)
-            * data.inputs.move_dir
-            * if data.vel.0.magnitude_squared() < GLIDE_SPEED.powi(2) {
-                GLIDE_ACCEL
-            } else {
-                0.0
-            };
+        update.vel.0 += Vec2::broadcast(data.dt.0) * data.inputs.move_dir * GLIDE_ACCEL;
 
         // Determine orientation vector from movement direction vector
         let horiz_vel = Vec2::<f32>::from(update.vel.0);
@@ -56,7 +49,7 @@ impl CharacterBehavior for Data {
 
         // Apply Glide antigrav lift
         let horiz_speed_sq = horiz_vel.magnitude_squared();
-        if horiz_speed_sq < GLIDE_SPEED.powi(2) && update.vel.0.z < 0.0 {
+        if update.vel.0.z < 0.0 {
             let lift = (GLIDE_ANTIGRAV + update.vel.0.z.powi(2) * 0.15)
                 * (horiz_speed_sq * f32::powf(0.075, 2.0)).clamp(0.2, 1.0);
 
diff --git a/common/src/states/utils.rs b/common/src/states/utils.rs
index bc43bb7643..68d4e02b1b 100644
--- a/common/src/states/utils.rs
+++ b/common/src/states/utils.rs
@@ -3,7 +3,7 @@ use crate::{
         biped_large, biped_small,
         inventory::slot::EquipSlot,
         item::{Hands, ItemKind, Tool, ToolKind},
-        quadruped_low, quadruped_medium, quadruped_small,
+        quadruped_low, quadruped_medium, quadruped_small, ship,
         skills::Skill,
         theropod, Body, CharacterAbility, CharacterState, InputKind, InventoryAction, StateUpdate,
     },
@@ -17,10 +17,11 @@ use std::time::Duration;
 use vek::*;
 
 pub const MOVEMENT_THRESHOLD_VEL: f32 = 3.0;
-const BASE_HUMANOID_AIR_ACCEL: f32 = 8.0;
-const BASE_FLIGHT_ACCEL: f32 = 16.0;
+const BASE_HUMANOID_AIR_ACCEL: f32 = 2.0;
+const BASE_FLIGHT_ACCEL: f32 = 2.0;
 const BASE_HUMANOID_WATER_ACCEL: f32 = 150.0;
 const BASE_HUMANOID_WATER_SPEED: f32 = 180.0;
+pub const BASE_JUMP_IMPULSE: f32 = 16.0;
 // const BASE_HUMANOID_CLIMB_ACCEL: f32 = 10.0;
 // const ROLL_SPEED: f32 = 17.0;
 // const CHARGE_SPEED: f32 = 20.0;
@@ -117,6 +118,7 @@ impl Body {
                 quadruped_low::Species::Basilisk => 120.0,
                 quadruped_low::Species::Deadwood => 140.0,
             },
+            Body::Ship(_) => 30.0,
         }
     }
 
@@ -168,14 +170,24 @@ impl Body {
                 quadruped_low::Species::Lavadrake => 4.0,
                 _ => 6.0,
             },
+            Body::Ship(_) => 0.175,
         }
     }
 
-    pub fn can_fly(&self) -> bool {
-        matches!(
-            self,
-            Body::BirdMedium(_) | Body::Dragon(_) | Body::BirdSmall(_)
-        )
+    /// Returns flying speed if the body type can fly, otherwise None
+    pub fn can_fly(&self) -> Option<f32> {
+        match self {
+            Body::BirdMedium(_) | Body::Dragon(_) | Body::BirdSmall(_) => Some(1.0),
+            Body::Ship(ship::Body::DefaultAirship) => Some(1.0),
+            _ => None,
+        }
+    }
+
+    pub fn jump_impulse(&self) -> Option<f32> {
+        match self {
+            Body::Object(_) | Body::Ship(_) => None,
+            _ => Some(BASE_JUMP_IMPULSE),
+        }
     }
 
     pub fn can_climb(&self) -> bool { matches!(self, Body::Humanoid(_)) }
@@ -186,10 +198,18 @@ pub fn handle_move(data: &JoinData, update: &mut StateUpdate, efficiency: f32) {
     if let Some(depth) = data.physics.in_liquid {
         swim_move(data, update, efficiency, depth);
     } else if input_is_pressed(data, InputKind::Fly)
-        && !data.physics.on_ground
-        && data.body.can_fly()
+        && (!data.physics.on_ground || data.body.jump_impulse().is_none())
+        && data.body.can_fly().is_some()
     {
-        fly_move(data, update, efficiency);
+        fly_move(
+            data,
+            update,
+            efficiency
+                * data
+                    .body
+                    .can_fly()
+                    .expect("can_fly is_some right above this"),
+        );
     } else {
         basic_move(data, update, efficiency);
     }
@@ -289,7 +309,11 @@ fn swim_move(data: &JoinData, update: &mut StateUpdate, efficiency: f32, depth:
         }
         * efficiency;
 
-    handle_orientation(data, update, if data.physics.on_ground { 9.0 } else { 2.0 });
+    handle_orientation(
+        data,
+        update,
+        data.body.base_ori_rate() * if data.physics.on_ground { 0.5 } else { 0.1 },
+    );
 
     // Swim
     update.vel.0.z = (update.vel.0.z
@@ -306,7 +330,6 @@ fn swim_move(data: &JoinData, update: &mut StateUpdate, efficiency: f32, depth:
 /// Updates components to move entity as if it's flying
 fn fly_move(data: &JoinData, update: &mut StateUpdate, efficiency: f32) {
     // Update velocity (counteract gravity with lift)
-    // TODO: Do this better
     update.vel.0 += Vec3::unit_z() * data.dt.0 * GRAVITY
         + Vec3::new(
             data.inputs.move_dir.x,
@@ -316,7 +339,7 @@ fn fly_move(data: &JoinData, update: &mut StateUpdate, efficiency: f32) {
             * BASE_FLIGHT_ACCEL
             * efficiency;
 
-    handle_orientation(data, update, 1.0);
+    handle_orientation(data, update, data.body.base_ori_rate());
 }
 
 /// Checks if an input related to an attack is held. If one is, moves entity
@@ -429,10 +452,12 @@ pub fn handle_jump(data: &JoinData, update: &mut StateUpdate) {
             .in_liquid
             .map(|depth| depth > 1.0)
             .unwrap_or(false)
+        && data.body.jump_impulse().is_some()
     {
-        update
-            .local_events
-            .push_front(LocalEvent::Jump(data.entity));
+        update.local_events.push_front(LocalEvent::Jump(
+            data.entity,
+            data.body.jump_impulse().unwrap(),
+        ));
     }
 }
 
diff --git a/common/src/util/find_dist.rs b/common/src/util/find_dist.rs
index cb02c728fe..10399a2b63 100644
--- a/common/src/util/find_dist.rs
+++ b/common/src/util/find_dist.rs
@@ -35,11 +35,11 @@ impl Cylinder {
     pub fn from_components(
         pos: Vec3<f32>,
         scale: Option<crate::comp::Scale>,
-        collider: Option<crate::comp::Collider>,
+        collider: Option<&crate::comp::Collider>,
         char_state: Option<&crate::comp::CharacterState>,
     ) -> Self {
         let scale = scale.map_or(1.0, |s| s.0);
-        let radius = collider.map_or(0.5, |c| c.get_radius()) * scale;
+        let radius = collider.as_ref().map_or(0.5, |c| c.get_radius()) * scale;
         let z_limit_modifier = char_state
             .filter(|char_state| char_state.is_dodge())
             .map_or(1.0, |_| 0.5)
diff --git a/common/src/volumes/dyna.rs b/common/src/volumes/dyna.rs
index 3e736c5db1..b6cb3e6bdc 100644
--- a/common/src/volumes/dyna.rs
+++ b/common/src/volumes/dyna.rs
@@ -44,6 +44,21 @@ impl<V, M, A: Access> Dyna<V, M, A> {
             None
         }
     }
+
+    pub fn map_into<W, F: FnMut(V) -> W>(self, f: F) -> Dyna<W, M, A> {
+        let Dyna {
+            vox,
+            meta,
+            sz,
+            _phantom,
+        } = self;
+        Dyna {
+            vox: vox.into_iter().map(f).collect(),
+            meta,
+            sz,
+            _phantom,
+        }
+    }
 }
 
 impl<V, M, A: Access> BaseVol for Dyna<V, M, A> {
diff --git a/common/sys/src/character_behavior.rs b/common/sys/src/character_behavior.rs
index ac7d8a15be..3b6c4d2d46 100644
--- a/common/sys/src/character_behavior.rs
+++ b/common/sys/src/character_behavior.rs
@@ -153,15 +153,6 @@ impl<'a> System<'a> for Sys {
                 // Do nothing
                 continue;
             }
-            // If mounted, character state is controlled by mount
-            // TODO: Make mounting a state
-            if let Some(Mounting(_)) = read_data.mountings.get(entity) {
-                let sit_state = CharacterState::Sit {};
-                if char_state.get_unchecked() != &sit_state {
-                    *char_state.get_mut_unchecked() = sit_state;
-                }
-                continue;
-            }
 
             // Enter stunned state if poise damage is enough
             if let Some(mut poise) = poises.get_mut(entity) {
@@ -317,6 +308,17 @@ impl<'a> System<'a> for Sys {
                 incorporate_update(&mut join_struct, state_update);
             }
 
+            // Mounted occurs after control actions have been handled
+            // If mounted, character state is controlled by mount
+            // TODO: Make mounting a state
+            if let Some(Mounting(_)) = read_data.mountings.get(entity) {
+                let sit_state = CharacterState::Sit {};
+                if join_struct.char_state.get_unchecked() != &sit_state {
+                    *join_struct.char_state.get_mut_unchecked() = sit_state;
+                }
+                continue;
+            }
+
             let j = JoinData::new(
                 &join_struct,
                 &read_data.lazy_update,
diff --git a/common/sys/src/interpolation.rs b/common/sys/src/interpolation.rs
new file mode 100644
index 0000000000..3393b80944
--- /dev/null
+++ b/common/sys/src/interpolation.rs
@@ -0,0 +1,63 @@
+use common::{
+    comp::{Ori, Pos, Vel},
+    resources::{PlayerEntity, Time},
+};
+use common_ecs::{Job, Origin, Phase, System};
+use common_net::sync::InterpolatableComponent;
+use specs::{
+    prelude::ParallelIterator, shred::ResourceId, Entities, ParJoin, Read, ReadStorage, SystemData,
+    World, WriteStorage,
+};
+
+#[derive(SystemData)]
+pub struct InterpolationSystemData<'a> {
+    time: Read<'a, Time>,
+    player: Read<'a, PlayerEntity>,
+    entities: Entities<'a>,
+    pos: WriteStorage<'a, Pos>,
+    pos_interpdata: ReadStorage<'a, <Pos as InterpolatableComponent>::InterpData>,
+    vel: WriteStorage<'a, Vel>,
+    vel_interpdata: ReadStorage<'a, <Vel as InterpolatableComponent>::InterpData>,
+    ori: WriteStorage<'a, Ori>,
+    ori_interpdata: ReadStorage<'a, <Ori as InterpolatableComponent>::InterpData>,
+}
+
+#[derive(Default)]
+pub struct InterpolationSystem;
+
+impl<'a> System<'a> for InterpolationSystem {
+    type SystemData = InterpolationSystemData<'a>;
+
+    const NAME: &'static str = "interpolation";
+    const ORIGIN: Origin = Origin::Common;
+    const PHASE: Phase = Phase::Apply;
+
+    fn run(_job: &mut Job<Self>, mut data: InterpolationSystemData<'a>) {
+        let time = data.time.0;
+        let player = data.player.0;
+
+        (
+            &data.entities,
+            &mut data.pos,
+            &data.pos_interpdata,
+            &data.vel_interpdata,
+        )
+            .par_join()
+            .filter(|(e, _, _, _)| Some(e) != player.as_ref())
+            .for_each(|(_, pos, interp, vel)| {
+                *pos = pos.interpolate(interp, time, vel);
+            });
+        (&data.entities, &mut data.vel, &data.vel_interpdata)
+            .par_join()
+            .filter(|(e, _, _)| Some(e) != player.as_ref())
+            .for_each(|(_, vel, interp)| {
+                *vel = vel.interpolate(interp, time, &());
+            });
+        (&data.entities, &mut data.ori, &data.ori_interpdata)
+            .par_join()
+            .filter(|(e, _, _)| Some(e) != player.as_ref())
+            .for_each(|(_, ori, interp)| {
+                *ori = ori.interpolate(interp, time, &());
+            });
+    }
+}
diff --git a/common/sys/src/lib.rs b/common/sys/src/lib.rs
index 4077fd861b..6292b30311 100644
--- a/common/sys/src/lib.rs
+++ b/common/sys/src/lib.rs
@@ -5,6 +5,7 @@ mod beam;
 mod buff;
 pub mod character_behavior;
 pub mod controller;
+mod interpolation;
 pub mod melee;
 mod mount;
 pub mod phys;
diff --git a/common/sys/src/mount.rs b/common/sys/src/mount.rs
index db36b178e8..016fb9eb60 100644
--- a/common/sys/src/mount.rs
+++ b/common/sys/src/mount.rs
@@ -1,11 +1,11 @@
 use common::{
-    comp::{Controller, MountState, Mounting, Ori, Pos, Vel},
+    comp::{Body, Controller, MountState, Mounting, Ori, Pos, Vel},
     uid::UidAllocator,
 };
 use common_ecs::{Job, Origin, Phase, System};
 use specs::{
     saveload::{Marker, MarkerAllocator},
-    Entities, Join, Read, WriteStorage,
+    Entities, Join, Read, ReadStorage, WriteStorage,
 };
 use vek::*;
 
@@ -23,6 +23,7 @@ impl<'a> System<'a> for Sys {
         WriteStorage<'a, Pos>,
         WriteStorage<'a, Vel>,
         WriteStorage<'a, Ori>,
+        ReadStorage<'a, Body>,
     );
 
     const NAME: &'static str = "mount";
@@ -40,21 +41,24 @@ impl<'a> System<'a> for Sys {
             mut positions,
             mut velocities,
             mut orientations,
+            bodies,
         ): Self::SystemData,
     ) {
         // Mounted entities.
-        for (entity, mut mount_states) in (&entities, &mut mount_state.restrict_mut()).join() {
+        for (entity, mut mount_states, body) in
+            (&entities, &mut mount_state.restrict_mut(), bodies.maybe()).join()
+        {
             match mount_states.get_unchecked() {
                 MountState::Unmounted => {},
                 MountState::MountedBy(mounter_uid) => {
                     // Note: currently controller events are not passed through since none of them
                     // are currently relevant to controlling the mounted entity
-                    if let Some((inputs, mounter)) = uid_allocator
+                    if let Some((inputs, queued_inputs, mounter)) = uid_allocator
                         .retrieve_entity_internal(mounter_uid.id())
                         .and_then(|mounter| {
                             controllers
                                 .get(mounter)
-                                .map(|c| (c.inputs.clone(), mounter))
+                                .map(|c| (c.inputs.clone(), c.queued_inputs.clone(), mounter))
                         })
                     {
                         // TODO: consider joining on these? (remember we can use .maybe())
@@ -62,13 +66,16 @@ impl<'a> System<'a> for Sys {
                         let ori = orientations.get(entity).copied();
                         let vel = velocities.get(entity).copied();
                         if let (Some(pos), Some(ori), Some(vel)) = (pos, ori, vel) {
-                            let _ = positions.insert(mounter, Pos(pos.0 + Vec3::unit_z() * 1.0));
+                            let mounting_offset =
+                                body.map_or(Vec3::unit_z(), Body::mounting_offset);
+                            let _ = positions.insert(mounter, Pos(pos.0 + mounting_offset));
                             let _ = orientations.insert(mounter, ori);
                             let _ = velocities.insert(mounter, vel);
                         }
                         if let Some(controller) = controllers.get_mut(entity) {
                             *controller = Controller {
                                 inputs,
+                                queued_inputs,
                                 ..Default::default()
                             }
                         }
diff --git a/common/sys/src/phys.rs b/common/sys/src/phys.rs
index cb0ee3cd51..9a6dd22748 100644
--- a/common/sys/src/phys.rs
+++ b/common/sys/src/phys.rs
@@ -1,19 +1,25 @@
 use common::{
     comp::{
-        BeamSegment, CharacterState, Collider, Gravity, Mass, Mounting, Ori, PhysicsState, Pos,
-        PreviousPhysCache, Projectile, Scale, Shockwave, Sticky, Vel,
+        body::ship::figuredata::VOXEL_COLLIDER_MANIFEST, BeamSegment, Body, CharacterState,
+        Collider, Gravity, Mass, Mounting, Ori, PhysicsState, Pos, PreviousPhysCache, Projectile,
+        Scale, Shockwave, Sticky, Vel,
     },
     consts::{FRIC_GROUND, GRAVITY},
     event::{EventBus, ServerEvent},
     resources::DeltaTime,
     terrain::{Block, TerrainGrid},
     uid::Uid,
-    vol::ReadVol,
+    vol::{BaseVol, ReadVol},
 };
 use common_base::{prof_span, span};
 use common_ecs::{Job, Origin, ParMode, Phase, PhysicsMetrics, System};
+use hashbrown::HashMap;
 use rayon::iter::ParallelIterator;
-use specs::{Entities, Join, ParJoin, Read, ReadExpect, ReadStorage, WriteExpect, WriteStorage};
+use specs::{
+    shred::{ResourceId, World},
+    Entities, Entity, Join, ParJoin, Read, ReadExpect, ReadStorage, SystemData, WriteExpect,
+    WriteStorage,
+};
 use std::ops::Range;
 use vek::*;
 
@@ -24,7 +30,7 @@ pub const BOUYANCY: f32 = 1.0;
 // friction is 0.01, and the speed is 1.0, then after 1/60th of a second the
 // speed will be 0.99. after 1 second the speed will be 0.54, which is 0.99 ^
 // 60.
-pub const FRIC_AIR: f32 = 0.0125;
+pub const FRIC_AIR: f32 = 0.0025;
 pub const FRIC_FLUID: f32 = 0.4;
 
 // Integrates forces, calculates the new velocity based off of the old velocity
@@ -62,132 +68,105 @@ fn calc_z_limit(
 #[derive(Default)]
 pub struct Sys;
 
-impl<'a> System<'a> for Sys {
-    #[allow(clippy::type_complexity)]
-    type SystemData = (
-        Entities<'a>,
-        ReadStorage<'a, Uid>,
-        ReadExpect<'a, TerrainGrid>,
-        Read<'a, DeltaTime>,
-        WriteExpect<'a, PhysicsMetrics>,
-        Read<'a, EventBus<ServerEvent>>,
-        ReadStorage<'a, Scale>,
-        ReadStorage<'a, Sticky>,
-        ReadStorage<'a, Mass>,
-        ReadStorage<'a, Collider>,
-        ReadStorage<'a, Gravity>,
-        WriteStorage<'a, PhysicsState>,
-        WriteStorage<'a, Pos>,
-        WriteStorage<'a, Vel>,
-        WriteStorage<'a, Ori>,
-        WriteStorage<'a, PreviousPhysCache>,
-        ReadStorage<'a, Mounting>,
-        ReadStorage<'a, Projectile>,
-        ReadStorage<'a, BeamSegment>,
-        ReadStorage<'a, Shockwave>,
-        ReadStorage<'a, CharacterState>,
-    );
+#[derive(SystemData)]
+pub struct PhysicsRead<'a> {
+    entities: Entities<'a>,
+    uids: ReadStorage<'a, Uid>,
+    terrain: ReadExpect<'a, TerrainGrid>,
+    dt: Read<'a, DeltaTime>,
+    event_bus: Read<'a, EventBus<ServerEvent>>,
+    scales: ReadStorage<'a, Scale>,
+    stickies: ReadStorage<'a, Sticky>,
+    masses: ReadStorage<'a, Mass>,
+    colliders: ReadStorage<'a, Collider>,
+    gravities: ReadStorage<'a, Gravity>,
+    mountings: ReadStorage<'a, Mounting>,
+    projectiles: ReadStorage<'a, Projectile>,
+    beams: ReadStorage<'a, BeamSegment>,
+    shockwaves: ReadStorage<'a, Shockwave>,
+    char_states: ReadStorage<'a, CharacterState>,
+    bodies: ReadStorage<'a, Body>,
+    character_states: ReadStorage<'a, CharacterState>,
+}
 
-    const NAME: &'static str = "phys";
-    const ORIGIN: Origin = Origin::Common;
-    const PHASE: Phase = Phase::Create;
+#[derive(SystemData)]
+pub struct PhysicsWrite<'a> {
+    physics_metrics: WriteExpect<'a, PhysicsMetrics>,
+    physics_states: WriteStorage<'a, PhysicsState>,
+    positions: WriteStorage<'a, Pos>,
+    velocities: WriteStorage<'a, Vel>,
+    orientations: WriteStorage<'a, Ori>,
+    previous_phys_cache: WriteStorage<'a, PreviousPhysCache>,
+}
 
-    #[allow(clippy::or_fun_call)] // TODO: Pending review in #587
-    #[allow(clippy::blocks_in_if_conditions)] // TODO: Pending review in #587
-    fn run(
-        job: &mut Job<Self>,
-        (
-            entities,
-            uids,
-            terrain,
-            dt,
-            mut physics_metrics,
-            event_bus,
-            scales,
-            stickies,
-            masses,
-            colliders,
-            gravities,
-            mut physics_states,
-            mut positions,
-            mut velocities,
-            mut orientations,
-            mut previous_phys_cache,
-            mountings,
-            projectiles,
-            beams,
-            shockwaves,
-            char_states,
-        ): Self::SystemData,
-    ) {
-        let mut event_emitter = event_bus.emitter();
+#[derive(SystemData)]
+pub struct PhysicsData<'a> {
+    read: PhysicsRead<'a>,
+    write: PhysicsWrite<'a>,
+}
 
-        // Add/reset physics state components
-        span!(guard, "Add/reset physics state components");
+impl<'a> PhysicsData<'a> {
+    /// Add/reset physics state components
+    fn reset(&mut self) {
+        span!(_guard, "Add/reset physics state components");
         for (entity, _, _, _, _) in (
-            &entities,
-            &colliders,
-            &positions,
-            &velocities,
-            &orientations,
+            &self.read.entities,
+            &self.read.colliders,
+            &self.write.positions,
+            &self.write.velocities,
+            &self.write.orientations,
         )
             .join()
         {
-            let _ = physics_states
+            let _ = self
+                .write
+                .physics_states
                 .entry(entity)
                 .map(|e| e.or_insert_with(Default::default));
         }
-        drop(guard);
+    }
 
-        // Apply pushback
-        //
-        // Note: We now do this first because we project velocity ahead. This is slighty
-        // imperfect and implies that we might get edge-cases where entities
-        // standing right next to the edge of a wall may get hit by projectiles
-        // fired into the wall very close to them. However, this sort of thing is
-        // already possible with poorly-defined hitboxes anyway so it's not too
-        // much of a concern.
-        //
-        // If this situation becomes a problem, this code should be integrated with the
-        // terrain collision code below, although that's not trivial to do since
-        // it means the step needs to take into account the speeds of both
-        // entities.
-        span!(guard, "Maintain pushback cache");
+    fn maintain_pushback_cache(&mut self) {
+        span!(_guard, "Maintain pushback cache");
         //Add PreviousPhysCache for all relevant entities
         for entity in (
-            &entities,
-            &velocities,
-            &positions,
-            !&previous_phys_cache,
-            !&mountings,
-            !&beams,
-            !&shockwaves,
+            &self.read.entities,
+            &self.write.velocities,
+            &self.write.positions,
+            !&self.write.previous_phys_cache,
+            !&self.read.mountings,
+            !&self.read.beams,
+            !&self.read.shockwaves,
         )
             .join()
             .map(|(e, _, _, _, _, _, _)| e)
             .collect::<Vec<_>>()
         {
-            let _ = previous_phys_cache.insert(entity, PreviousPhysCache {
-                velocity_dt: Vec3::zero(),
-                center: Vec3::zero(),
-                collision_boundary: 0.0,
-                scale: 0.0,
-                scaled_radius: 0.0,
-            });
+            let _ = self
+                .write
+                .previous_phys_cache
+                .insert(entity, PreviousPhysCache {
+                    velocity_dt: Vec3::zero(),
+                    center: Vec3::zero(),
+                    collision_boundary: 0.0,
+                    scale: 0.0,
+                    scaled_radius: 0.0,
+                    ori: Quaternion::identity(),
+                });
         }
 
         //Update PreviousPhysCache
         for (_, vel, position, mut phys_cache, collider, scale, cs, _, _, _) in (
-            &entities,
-            &velocities,
-            &positions,
-            &mut previous_phys_cache,
-            colliders.maybe(),
-            scales.maybe(),
-            char_states.maybe(),
-            !&mountings,
-            !&beams,
-            !&shockwaves,
+            &self.read.entities,
+            &self.write.velocities,
+            &self.write.positions,
+            &mut self.write.previous_phys_cache,
+            self.read.colliders.maybe(),
+            self.read.scales.maybe(),
+            self.read.char_states.maybe(),
+            !&self.read.mountings,
+            !&self.read.beams,
+            !&self.read.shockwaves,
         )
             .join()
         {
@@ -196,7 +175,7 @@ impl<'a> System<'a> for Sys {
             let z_limits = (z_limits.0 * scale, z_limits.1 * scale);
             let half_height = (z_limits.1 - z_limits.0) / 2.0;
 
-            phys_cache.velocity_dt = vel.0 * dt.0;
+            phys_cache.velocity_dt = vel.0 * self.read.dt.0;
             let entity_center = position.0 + Vec3::new(0.0, z_limits.0 + half_height, 0.0);
             let flat_radius = collider.map(|c| c.get_radius()).unwrap_or(0.5) * scale;
             let radius = (flat_radius.powi(2) + half_height.powi(2)).sqrt();
@@ -208,24 +187,30 @@ impl<'a> System<'a> for Sys {
             phys_cache.scale = scale;
             phys_cache.scaled_radius = flat_radius;
         }
-        drop(guard);
+    }
 
-        span!(guard, "Apply pushback");
+    fn apply_pushback(&mut self, job: &mut Job<Sys>) {
+        span!(_guard, "Apply pushback");
         job.cpu_stats.measure(ParMode::Rayon);
+        let PhysicsData {
+            ref read,
+            ref mut write,
+        } = self;
+        let (positions, previous_phys_cache) = (&write.positions, &write.previous_phys_cache);
         let metrics = (
-            &entities,
-            &positions,
-            &mut velocities,
-            &previous_phys_cache,
-            masses.maybe(),
-            colliders.maybe(),
-            !&mountings,
-            stickies.maybe(),
-            &mut physics_states,
+            &read.entities,
+            positions,
+            &mut write.velocities,
+            previous_phys_cache,
+            read.masses.maybe(),
+            read.colliders.maybe(),
+            !&read.mountings,
+            read.stickies.maybe(),
+            &mut write.physics_states,
             // TODO: if we need to avoid collisions for other things consider moving whether it
             // should interact into the collider component or into a separate component
-            projectiles.maybe(),
-            char_states.maybe(),
+            read.projectiles.maybe(),
+            read.char_states.maybe(),
         )
             .par_join()
             .filter(|(_, _, _, _, _, _, _, sticky, physics, _, _)| {
@@ -275,17 +260,17 @@ impl<'a> System<'a> for Sys {
                         _,
                         char_state_other_maybe,
                     ) in (
-                        &entities,
-                        &uids,
-                        &positions,
-                        &previous_phys_cache,
-                        masses.maybe(),
-                        colliders.maybe(),
-                        !&projectiles,
-                        !&mountings,
-                        !&beams,
-                        !&shockwaves,
-                        char_states.maybe(),
+                        &read.entities,
+                        &read.uids,
+                        positions,
+                        previous_phys_cache,
+                        read.masses.maybe(),
+                        read.colliders.maybe(),
+                        !&read.projectiles,
+                        !&read.mountings,
+                        !&read.beams,
+                        !&read.shockwaves,
+                        read.char_states.maybe(),
                     )
                         .join()
                     {
@@ -343,8 +328,13 @@ impl<'a> System<'a> for Sys {
                                     entity_entity_collisions += 1;
                                 }
 
-                                // Don't apply repulsive force to projectiles
-                                if diff.magnitude_squared() > 0.0 && !is_projectile {
+                                // Don't apply repulsive force to projectiles or if we're colliding
+                                // with a terrain-like entity, or if we are a terrain-like entity
+                                if diff.magnitude_squared() > 0.0
+                                    && !is_projectile
+                                    && !matches!(collider_other, Some(Collider::Voxel { .. }))
+                                    && !matches!(collider, Some(Collider::Voxel { .. }))
+                                {
                                     let force =
                                         400.0 * (collision_dist - diff.magnitude()) * mass_other
                                             / (mass + mass_other);
@@ -358,7 +348,7 @@ impl<'a> System<'a> for Sys {
                     }
 
                     // Change velocity
-                    vel.0 += vel_delta * dt.0;
+                    vel.0 += vel_delta * read.dt.0;
 
                     // Metrics
                     PhysicsMetrics {
@@ -373,435 +363,797 @@ impl<'a> System<'a> for Sys {
                 entity_entity_collisions: old.entity_entity_collisions
                     + new.entity_entity_collisions,
             });
-        physics_metrics.entity_entity_collision_checks = metrics.entity_entity_collision_checks;
-        physics_metrics.entity_entity_collisions = metrics.entity_entity_collisions;
-        drop(guard);
+        write.physics_metrics.entity_entity_collision_checks =
+            metrics.entity_entity_collision_checks;
+        write.physics_metrics.entity_entity_collisions = metrics.entity_entity_collisions;
+    }
 
+    fn handle_movement_and_terrain(&mut self, job: &mut Job<Sys>) {
+        let PhysicsData {
+            ref read,
+            ref mut write,
+        } = self;
         // Apply movement inputs
         span!(guard, "Apply movement and terrain collision");
-        let land_on_grounds = (
-            &entities,
-            scales.maybe(),
-            stickies.maybe(),
-            &colliders,
-            &mut positions,
-            &mut velocities,
-            &mut orientations,
-            &mut physics_states,
-            !&mountings,
+        let (positions, velocities, previous_phys_cache, orientations) = (
+            &write.positions,
+            &mut write.velocities,
+            &write.previous_phys_cache,
+            &write.orientations,
+        );
+
+        // First pass: update velocity using air resistance and gravity for each entity.
+        // We do this in a first pass because it helps keep things more stable for
+        // entities that are anchored to other entities (such as airships).
+        (
+            &read.entities,
+            positions,
+            velocities,
+            &write.physics_states,
+            !&read.mountings,
         )
-        .par_join()
-        .map_init(
-            || {
-                prof_span!(guard, "physics e<>t rayon job");
-                guard
-            },
-            |_guard,
-            (entity, _scale, sticky, collider, mut pos, mut vel, _ori, mut physics_state, _),
-        | {
-            let mut landed_on_ground = None;
+            .par_join()
+            .for_each(|(entity, pos, vel, physics_state, _)| {
+                let in_loaded_chunk = read
+                    .terrain
+                    .get_key(read.terrain.pos_key(pos.0.map(|e| e.floor() as i32)))
+                    .is_some();
+                // Integrate forces
+                // Friction is assumed to be a constant dependent on location
+                let friction = if physics_state.on_ground { 0.0 } else { FRIC_AIR }
+                        // .max(if physics_state.on_ground {
+                        //     FRIC_GROUND
+                        // } else {
+                        //     0.0
+                        // })
+                        .max(if physics_state.in_liquid.is_some() {
+                            FRIC_FLUID
+                        } else {
+                            0.0
+                        });
+                let downward_force =
+                    if !in_loaded_chunk {
+                        0.0 // No gravity in unloaded chunks
+                    } else if physics_state
+                        .in_liquid
+                        .map(|depth| depth > 0.75)
+                        .unwrap_or(false)
+                    {
+                        (1.0 - BOUYANCY) * GRAVITY
+                    } else {
+                        GRAVITY
+                    } * read.gravities.get(entity).map(|g| g.0).unwrap_or_default();
 
-            if sticky.is_some() && physics_state.on_surface().is_some() {
-                vel.0 = Vec3::zero();
-                return landed_on_ground;
-            }
+                vel.0 = integrate_forces(read.dt.0, vel.0, downward_force, friction);
+            });
 
-            // TODO: Use this
-            //let scale = scale.map(|s| s.0).unwrap_or(1.0);
+        let velocities = &write.velocities;
 
-            let old_vel = *vel;
-            // Integrate forces
-            // Friction is assumed to be a constant dependent on location
-            let friction = FRIC_AIR
-                .max(if physics_state.on_ground {
-                    FRIC_GROUND
-                } else {
-                    0.0
-                })
-                .max(if physics_state.in_liquid.is_some() {
-                    FRIC_FLUID
-                } else {
-                    0.0
-                });
-            let in_loaded_chunk = terrain
-                .get_key(terrain.pos_key(pos.0.map(|e| e.floor() as i32)))
-                .is_some();
-            let downward_force = if !in_loaded_chunk {
-                0.0 // No gravity in unloaded chunks
-            } else if physics_state
-                .in_liquid
-                .map(|depth| depth > 0.75)
-                .unwrap_or(false)
-            {
-                (1.0 - BOUYANCY) * GRAVITY
-            } else {
-                GRAVITY
-            } * gravities.get(entity).map(|g| g.0).unwrap_or_default();
-            vel.0 = integrate_forces(dt.0, vel.0, downward_force, friction);
-
-            // Don't move if we're not in a loaded chunk
-            let mut pos_delta = if in_loaded_chunk {
-                // this is an approximation that allows most framerates to
-                // behave in a similar manner.
-                let dt_lerp = 0.2;
-                (vel.0 * dt_lerp + old_vel.0 * (1.0 - dt_lerp)) * dt.0
-            } else {
-                Vec3::zero()
-            };
-
-            match *collider {
-                Collider::Box {
-                    radius,
-                    z_min,
-                    z_max,
-                } => {
-                    // Scale collider
-                    // TODO: Use scale & actual proportions when pathfinding is good enough to manage irregular entity
-                    // sizes
-                    let radius = radius.min(0.45); // * scale;
-                    let z_min = z_min; // * scale;
-                    let z_max = z_max.clamped(1.2, 1.95); // * scale;
-
-                    // Probe distances
-                    let hdist = radius.ceil() as i32;
-                    // Neighbouring blocks iterator
-                    let near_iter = (-hdist..hdist + 1)
-                        .map(move |i| {
-                            (-hdist..hdist + 1).map(move |j| {
-                                (1 - Block::MAX_HEIGHT.ceil() as i32 + z_min.floor() as i32
-                                    ..z_max.ceil() as i32 + 1)
-                                    .map(move |k| (i, j, k))
-                            })
-                        })
-                        .flatten()
-                        .flatten();
-
-                    // Function for iterating over the blocks the player at a specific position
-                    // collides with
-                    fn collision_iter<'a>(
-                        pos: Vec3<f32>,
-                        terrain: &'a TerrainGrid,
-                        hit: &'a impl Fn(&Block) -> bool,
-                        height: &'a impl Fn(&Block) -> f32,
-                        near_iter: impl Iterator<Item = (i32, i32, i32)> + 'a,
-                        radius: f32,
-                        z_range: Range<f32>,
-                    ) -> impl Iterator<Item = Aabb<f32>> + 'a {
-                        near_iter.filter_map(move |(i, j, k)| {
-                            let block_pos = pos.map(|e| e.floor() as i32) + Vec3::new(i, j, k);
-
-                            if let Some(block) = terrain.get(block_pos).ok().copied().filter(hit) {
-                                let player_aabb = Aabb {
-                                    min: pos + Vec3::new(-radius, -radius, z_range.start),
-                                    max: pos + Vec3::new(radius, radius, z_range.end),
-                                };
-                                let block_aabb = Aabb {
-                                    min: block_pos.map(|e| e as f32),
-                                    max: block_pos.map(|e| e as f32)
-                                        + Vec3::new(1.0, 1.0, height(&block)),
-                                };
-
-                                if player_aabb.collides_with_aabb(block_aabb) {
-                                    return Some(block_aabb);
-                                }
-                            }
-
-                            None
-                        })
+        // Second pass: resolve collisions
+        let (pos_writes, vel_writes, land_on_grounds) = (
+            &read.entities,
+            read.scales.maybe(),
+            read.stickies.maybe(),
+            &read.colliders,
+            positions,
+            velocities,
+            orientations,
+            read.bodies.maybe(),
+            read.character_states.maybe(),
+            &mut write.physics_states,
+            previous_phys_cache,
+            !&read.mountings,
+        )
+            .par_join()
+            .fold(
+                || (Vec::new(), Vec::new(), Vec::new()),
+                |(mut pos_writes, mut vel_writes, mut land_on_grounds),
+                 (
+                    entity,
+                    scale,
+                    sticky,
+                    collider,
+                    pos,
+                    vel,
+                    _ori,
+                    body,
+                    character_state,
+                    mut physics_state,
+                    _previous_cache,
+                    _,
+                )| {
+                    // Defer the writes of positions and velocities to allow an inner loop over
+                    // terrain-like entities
+                    let mut vel = *vel;
+                    let old_vel = vel;
+                    if sticky.is_some() && physics_state.on_surface().is_some() {
+                        vel.0 = physics_state.ground_vel;
+                        return (pos_writes, vel_writes, land_on_grounds);
                     }
 
-                    let z_range = z_min..z_max;
-                    // Function for determining whether the player at a specific position collides
-                    // with blocks with the given criteria
-                    fn collision_with<'a>(
-                        pos: Vec3<f32>,
-                        terrain: &'a TerrainGrid,
-                        hit: impl Fn(&Block) -> bool,
-                        near_iter: impl Iterator<Item = (i32, i32, i32)> + 'a,
-                        radius: f32,
-                        z_range: Range<f32>,
-                    ) -> bool {
-                        collision_iter(pos, terrain, &|block| block.is_solid() && hit(block), &Block::solid_height, near_iter, radius, z_range).count()
-                            > 0
-                    }
+                    let scale = if let Collider::Voxel { .. } = collider {
+                        scale.map(|s| s.0).unwrap_or(1.0)
+                    } else {
+                        // TODO: Use scale & actual proportions when pathfinding is good
+                        // enough to manage irregular entity sizes
+                        1.0
+                    };
+
+                    let in_loaded_chunk = read
+                        .terrain
+                        .get_key(read.terrain.pos_key(pos.0.map(|e| e.floor() as i32)))
+                        .is_some();
+
+                    // Don't move if we're not in a loaded chunk
+                    let pos_delta = if in_loaded_chunk {
+                        vel.0 * read.dt.0
+                    } else {
+                        Vec3::zero()
+                    };
+
+                    // What's going on here? Because collisions need to be resolved against multiple
+                    // colliders, this code takes the current position and
+                    // propagates it forward according to velocity to find a
+                    // 'target' position. This is where we'd ideally end up at the end of the tick,
+                    // assuming no collisions. Then, we refine this target by
+                    // stepping from the original position to the target for
+                    // every obstacle, refining the target position as we go. It's not perfect, but
+                    // it works pretty well in practice. Oddities can occur on
+                    // the intersection between multiple colliders, but it's not
+                    // like any game physics system resolves these sort of things well anyway. At
+                    // the very least, we don't do things that result in glitchy
+                    // velocities or entirely broken position snapping.
+                    let mut tgt_pos = pos.0 + pos_delta;
 
                     let was_on_ground = physics_state.on_ground;
-                    physics_state.on_ground = false;
+                    let block_snap = body.map_or(false, |body| body.jump_impulse().is_some());
+                    let climbing =
+                        character_state.map_or(false, |cs| matches!(cs, CharacterState::Climb));
 
-                    let mut on_ground = false;
-                    let mut on_ceiling = false;
-                    let mut attempts = 0; // Don't loop infinitely here
+                    match &collider {
+                        Collider::Voxel { .. } => {
+                            // for now, treat entities with voxel colliders as their bounding
+                            // cylinders for the purposes of colliding them with terrain
 
-                    // Don't jump too far at once
-                    let increments = (pos_delta.map(|e| e.abs()).reduce_partial_max() / 0.3)
-                        .ceil()
-                        .max(1.0);
-                    let old_pos = pos.0;
-                    fn block_true(_: &Block) -> bool { true }
-                    for _ in 0..increments as usize {
-                        pos.0 += pos_delta / increments;
+                            // Additionally, multiply radius by 0.1 to make the cylinder smaller to
+                            // avoid lag
+                            let radius = collider.get_radius() * scale * 0.1;
+                            let (z_min, z_max) = collider.get_z_limits(scale);
 
-                        const MAX_ATTEMPTS: usize = 16;
-
-                        // While the player is colliding with the terrain...
-                        while collision_with(pos.0, &terrain, block_true, near_iter.clone(), radius, z_range.clone())
-                            && attempts < MAX_ATTEMPTS
-                        {
-                            // Calculate the player's AABB
-                            let player_aabb = Aabb {
-                                min: pos.0 + Vec3::new(-radius, -radius, z_min),
-                                max: pos.0 + Vec3::new(radius, radius, z_max),
-                            };
-
-                            // Determine the block that we are colliding with most (based on minimum
-                            // collision axis)
-                            let (_block_pos, block_aabb, block_height) = near_iter
-                                .clone()
-                                // Calculate the block's position in world space
-                                .map(|(i, j, k)| pos.0.map(|e| e.floor() as i32) + Vec3::new(i, j, k))
-                                // Make sure the block is actually solid
-                                .filter_map(|block_pos| {
-                                    if let Some(block) = terrain
-                                        .get(block_pos)
-                                        .ok()
-                                        .filter(|block| block.is_solid())
-                                    {
-                                        // Calculate block AABB
-                                        Some((
-                                            block_pos,
-                                            Aabb {
-                                                min: block_pos.map(|e| e as f32),
-                                                max: block_pos.map(|e| e as f32) + Vec3::new(1.0, 1.0, block.solid_height()),
-                                            },
-                                            block.solid_height(),
-                                        ))
-                                    } else {
-                                        None
-                                    }
-                                })
-                                // Determine whether the block's AABB collides with the player's AABB
-                                .filter(|(_, block_aabb, _)| block_aabb.collides_with_aabb(player_aabb))
-                                // Find the maximum of the minimum collision axes (this bit is weird, trust me that it works)
-                                .min_by_key(|(_, block_aabb, _)| {
-                                    ((block_aabb.center() - player_aabb.center() - Vec3::unit_z() * 0.5)
-                                        .map(|e| e.abs())
-                                        .sum()
-                                        * 1_000_000.0) as i32
-                                })
-                                .expect("Collision detected, but no colliding blocks found!");
-
-                            // Find the intrusion vector of the collision
-                            let dir = player_aabb.collision_vector_with_aabb(block_aabb);
-
-                            // Determine an appropriate resolution vector (i.e: the minimum distance
-                            // needed to push out of the block)
-                            let max_axis = dir.map(|e| e.abs()).reduce_partial_min();
-                            let resolve_dir = -dir.map(|e| {
-                                if e.abs().to_bits() == max_axis.to_bits() {
-                                    e
-                                } else {
-                                    0.0
-                                }
-                            });
-
-                            // When the resolution direction is pointing upwards, we must be on the
-                            // ground
-                            if resolve_dir.z > 0.0 && vel.0.z <= 0.0 {
-                                on_ground = true;
-
-                                if !was_on_ground {
-                                    landed_on_ground = Some((entity, *vel));
-                                }
-                            } else if resolve_dir.z < 0.0 && vel.0.z >= 0.0 {
-                                on_ceiling = true;
-                            }
-
-                            // When the resolution direction is non-vertical, we must be colliding
-                            // with a wall If the space above is free...
-                            if !collision_with(Vec3::new(pos.0.x, pos.0.y, (pos.0.z + 0.1).ceil()), &terrain, block_true, near_iter.clone(), radius, z_range.clone())
-                                // ...and we're being pushed out horizontally...
-                                && resolve_dir.z == 0.0
-                                // ...and the vertical resolution direction is sufficiently great...
-                                && -dir.z > 0.1
-                                // ...and we're falling/standing OR there is a block *directly* beneath our current origin (note: not hitbox)...
-                                && (vel.0.z <= 0.0 || terrain
-                                    .get((pos.0 - Vec3::unit_z() * 0.1).map(|e| e.floor() as i32))
-                                    .map(|block| block.is_solid())
-                                    .unwrap_or(false))
-                                // ...and there is a collision with a block beneath our current hitbox...
-                                && collision_with(
-                                    pos.0 + resolve_dir - Vec3::unit_z() * 1.05,
-                                    &terrain,
-                                    block_true,
-                                    near_iter.clone(),
-                                    radius,
-                                    z_range.clone(),
-                                )
-                            {
-                                // ...block-hop!
-                                pos.0.z = (pos.0.z + 0.1).floor() + block_height;
-                                vel.0.z = 0.0;
-                                on_ground = true;
-                                break;
-                            } else {
-                                // Correct the velocity
-                                vel.0 = vel.0.map2(resolve_dir, |e, d| {
-                                    if d * e.signum() < 0.0 { 0.0 } else { e }
-                                });
-                                pos_delta *= resolve_dir.map(|e| if e != 0.0 { 0.0 } else { 1.0 });
-                            }
-
-                            // Resolve the collision normally
-                            pos.0 += resolve_dir;
-
-                            attempts += 1;
-                        }
-
-                        if attempts == MAX_ATTEMPTS {
-                            vel.0 = Vec3::zero();
-                            pos.0 = old_pos;
-                            break;
-                        }
-                    }
-
-                    if on_ceiling {
-                        physics_state.on_ceiling = true;
-                    }
-
-                    if on_ground {
-                        physics_state.on_ground = true;
-                    // If the space below us is free, then "snap" to the ground
-                    } else if collision_with(
-                        pos.0 - Vec3::unit_z() * 1.05,
-                        &terrain,
-                        block_true,
-                        near_iter.clone(),
-                        radius,
-                        z_range.clone(),
-                    ) && vel.0.z < 0.0
-                        && vel.0.z > -1.5
-                        && was_on_ground
-                        && !collision_with(
-                            pos.0 - Vec3::unit_z() * 0.05,
-                            &terrain,
-                            |block| block.solid_height() >= (pos.0.z - 0.05).rem_euclid(1.0),
-                            near_iter.clone(),
+                            let mut cpos = *pos;
+                            let cylinder = (radius, z_min, z_max);
+                            box_voxel_collision(
+                                cylinder,
+                                &*read.terrain,
+                                entity,
+                                &mut cpos,
+                                tgt_pos,
+                                &mut vel,
+                                &mut physics_state,
+                                Vec3::zero(),
+                                &read.dt,
+                                was_on_ground,
+                                block_snap,
+                                climbing,
+                                |entity, vel| land_on_grounds.push((entity, vel)),
+                            );
+                            tgt_pos = cpos.0;
+                        },
+                        Collider::Box {
                             radius,
-                            z_range.clone(),
-                        )
-                    {
-                        let snap_height = terrain
-                            .get(
-                                Vec3::new(pos.0.x, pos.0.y, pos.0.z - 0.05)
-                                    .map(|e| e.floor() as i32),
-                            )
-                            .ok()
-                            .filter(|block| block.is_solid())
-                            .map(|block| block.solid_height())
-                            .unwrap_or(0.0);
-                        pos.0.z = (pos.0.z - 0.05).floor() + snap_height;
-                        physics_state.on_ground = true;
-                    }
+                            z_min,
+                            z_max,
+                        } => {
+                            // Scale collider
+                            let radius = radius.min(0.45) * scale;
+                            let z_min = *z_min * scale;
+                            let z_max = z_max.clamped(1.2, 1.95) * scale;
 
-                    let dirs = [
-                        Vec3::unit_x(),
-                        Vec3::unit_y(),
-                        -Vec3::unit_x(),
-                        -Vec3::unit_y(),
-                    ];
+                            let cylinder = (radius, z_min, z_max);
+                            let mut cpos = *pos;
+                            box_voxel_collision(
+                                cylinder,
+                                &*read.terrain,
+                                entity,
+                                &mut cpos,
+                                tgt_pos,
+                                &mut vel,
+                                &mut physics_state,
+                                Vec3::zero(),
+                                &read.dt,
+                                was_on_ground,
+                                block_snap,
+                                climbing,
+                                |entity, vel| land_on_grounds.push((entity, vel)),
+                            );
+                            tgt_pos = cpos.0;
+                        },
+                        Collider::Point => {
+                            let mut pos = *pos;
 
-                    if let (wall_dir, true) =
-                        dirs.iter().fold((Vec3::zero(), false), |(a, hit), dir| {
-                            if collision_with(
-                                pos.0 + *dir * 0.01,
-                                &terrain,
-                                block_true,
-                                near_iter.clone(),
-                                radius,
-                                z_range.clone(),
-                            ) {
-                                (a + dir, true)
-                            } else {
-                                (a, hit)
-                            }
-                        })
-                    {
-                        physics_state.on_wall = Some(wall_dir);
-                    } else {
-                        physics_state.on_wall = None;
-                    }
+                            let (dist, block) = read
+                                .terrain
+                                .ray(pos.0, pos.0 + pos_delta)
+                                .until(|block: &Block| block.is_filled())
+                                .ignore_error()
+                                .cast();
 
-                    // Figure out if we're in water
-                    physics_state.in_liquid = collision_iter(
-                        pos.0,
-                        &terrain,
-                        &|block| block.is_liquid(),
-                        // The liquid part of a liquid block always extends 1 block high.
-                        &|_block| 1.0,
-                        near_iter.clone(),
-                        radius,
-                        z_min..z_max,
-                    )
-                    .max_by_key(|block_aabb| (block_aabb.max.z * 100.0) as i32)
-                    .map(|block_aabb| block_aabb.max.z - pos.0.z);
-                },
-                Collider::Point => {
-                    let (dist, block) = terrain.ray(pos.0, pos.0 + pos_delta)
-                        .until(|block: &Block| block.is_filled())
-                        .ignore_error().cast();
+                            pos.0 += pos_delta.try_normalized().unwrap_or_else(Vec3::zero) * dist;
 
-                    pos.0 += pos_delta.try_normalized().unwrap_or(Vec3::zero()) * dist;
+                            // Can't fail since we do ignore_error above
+                            if block.unwrap().is_some() {
+                                let block_center = pos.0.map(|e| e.floor()) + 0.5;
+                                let block_rpos = (pos.0 - block_center)
+                                    .try_normalized()
+                                    .unwrap_or_else(Vec3::zero);
 
-                    // Can't fail since we do ignore_error above
-                    if block.unwrap().is_some() {
-                        let block_center = pos.0.map(|e| e.floor()) + 0.5;
-                        let block_rpos = (pos.0 - block_center)
-                            .try_normalized()
-                            .unwrap_or(Vec3::zero());
-
-                        // See whether we're on the top/bottom of a block, or the side
-                        if block_rpos.z.abs()
-                            > block_rpos.xy().map(|e| e.abs()).reduce_partial_max()
-                        {
-                            if block_rpos.z > 0.0 {
-                                physics_state.on_ground = true;
-                            } else {
-                                physics_state.on_ceiling = true;
-                            }
-                            vel.0.z = 0.0;
-                        } else {
-                            physics_state.on_wall =
-                                Some(if block_rpos.x.abs() > block_rpos.y.abs() {
-                                    vel.0.x = 0.0;
-                                    Vec3::unit_x() * -block_rpos.x.signum()
+                                // See whether we're on the top/bottom of a block, or the side
+                                if block_rpos.z.abs()
+                                    > block_rpos.xy().map(|e| e.abs()).reduce_partial_max()
+                                {
+                                    if block_rpos.z > 0.0 {
+                                        physics_state.on_ground = true;
+                                    } else {
+                                        physics_state.on_ceiling = true;
+                                    }
+                                    vel.0.z = 0.0;
                                 } else {
-                                    vel.0.y = 0.0;
-                                    Vec3::unit_y() * -block_rpos.y.signum()
-                                });
+                                    physics_state.on_wall =
+                                        Some(if block_rpos.x.abs() > block_rpos.y.abs() {
+                                            vel.0.x = 0.0;
+                                            Vec3::unit_x() * -block_rpos.x.signum()
+                                        } else {
+                                            vel.0.y = 0.0;
+                                            Vec3::unit_y() * -block_rpos.y.signum()
+                                        });
+                                }
+                            }
+
+                            physics_state.in_liquid = read
+                                .terrain
+                                .get(pos.0.map(|e| e.floor() as i32))
+                                .ok()
+                                .and_then(|vox| vox.is_liquid().then_some(1.0));
+
+                            tgt_pos = pos.0;
+                        },
+                    }
+
+                    // Collide with terrain-like entities
+                    for (
+                        entity_other,
+                        _other,
+                        pos_other,
+                        vel_other,
+                        previous_cache_other,
+                        _mass_other,
+                        collider_other,
+                        ori_other,
+                        _,
+                        _,
+                        _,
+                        _,
+                        _char_state_other_maybe,
+                    ) in (
+                        &read.entities,
+                        &read.uids,
+                        positions,
+                        velocities,
+                        previous_phys_cache,
+                        read.masses.maybe(),
+                        &read.colliders,
+                        orientations,
+                        !&read.projectiles,
+                        !&read.mountings,
+                        !&read.beams,
+                        !&read.shockwaves,
+                        read.char_states.maybe(),
+                    )
+                        .join()
+                    {
+                        // TODO: terrain-collider-size aware broadphase
+                        /*let collision_boundary = previous_cache.collision_boundary
+                            + previous_cache_other.collision_boundary;
+                        if previous_cache
+                            .center
+                            .distance_squared(previous_cache_other.center)
+                            > collision_boundary.powi(2)
+                        {
+                            continue;
+                        }*/
+                        if entity == entity_other {
+                            continue;
+                        }
+
+                        let voxel_id = if let Collider::Voxel { id } = collider_other {
+                            id
+                        } else {
+                            continue;
+                        };
+                        // use bounding cylinder regardless of our collider
+                        // TODO: extract point-terrain collision above to its own function
+                        let radius = collider.get_radius();
+                        let (z_min, z_max) = collider.get_z_limits(1.0);
+
+                        let radius = radius.min(0.45) * scale;
+                        let z_min = z_min * scale;
+                        let z_max = z_max.clamped(1.2, 1.95) * scale;
+
+                        if let Some(voxel_collider) =
+                            VOXEL_COLLIDER_MANIFEST.read().colliders.get(&*voxel_id)
+                        {
+                            let mut physics_state_delta = physics_state.clone();
+                            // deliberately don't use scale yet here, because the 11.0/0.8
+                            // thing is in the comp::Scale for visual reasons
+                            let mut cpos = *pos;
+                            let wpos = cpos.0;
+
+                            // TODO: Cache the matrices here to avoid recomputing
+
+                            let transform_from = Mat4::<f32>::translation_3d(pos_other.0 - wpos)
+                                * Mat4::from(ori_other.to_quat())
+                                * Mat4::<f32>::translation_3d(voxel_collider.translation);
+                            let transform_to = transform_from.inverted();
+                            let ori_from = Mat4::from(ori_other.to_quat());
+                            let ori_to = ori_from.inverted();
+
+                            // The velocity of the collider, taking into account orientation.
+                            let wpos_rel = (Mat4::<f32>::translation_3d(pos_other.0)
+                                * Mat4::from(ori_other.to_quat())
+                                * Mat4::<f32>::translation_3d(voxel_collider.translation))
+                            .inverted()
+                            .mul_point(wpos);
+                            let wpos_last = (Mat4::<f32>::translation_3d(pos_other.0)
+                                * Mat4::from(previous_cache_other.ori)
+                                * Mat4::<f32>::translation_3d(voxel_collider.translation))
+                            .mul_point(wpos_rel);
+                            let vel_other = vel_other.0 + (wpos - wpos_last) / read.dt.0;
+
+                            cpos.0 = transform_to.mul_point(Vec3::zero());
+                            vel.0 = ori_to.mul_direction(vel.0 - vel_other);
+                            let cylinder = (radius, z_min, z_max);
+                            box_voxel_collision(
+                                cylinder,
+                                &voxel_collider.dyna,
+                                entity,
+                                &mut cpos,
+                                transform_to.mul_point(tgt_pos - wpos),
+                                &mut vel,
+                                &mut physics_state_delta,
+                                ori_to.mul_direction(vel_other),
+                                &read.dt,
+                                was_on_ground,
+                                block_snap,
+                                climbing,
+                                |entity, vel| {
+                                    land_on_grounds
+                                        .push((entity, Vel(ori_from.mul_direction(vel.0))))
+                                },
+                            );
+
+                            cpos.0 = transform_from.mul_point(cpos.0) + wpos;
+                            vel.0 = ori_from.mul_direction(vel.0) + vel_other;
+                            tgt_pos = cpos.0;
+
+                            // union in the state updates, so that the state isn't just based on
+                            // the most recent terrain that collision was attempted with
+                            if physics_state_delta.on_ground {
+                                physics_state.ground_vel = vel_other;
+                            }
+                            physics_state.on_ground |= physics_state_delta.on_ground;
+                            physics_state.on_ceiling |= physics_state_delta.on_ceiling;
+                            physics_state.on_wall = physics_state.on_wall.or_else(|| {
+                                physics_state_delta
+                                    .on_wall
+                                    .map(|dir| ori_from.mul_direction(dir))
+                            });
+                            physics_state
+                                .touch_entities
+                                .append(&mut physics_state_delta.touch_entities);
+                            physics_state.in_liquid =
+                                match (physics_state.in_liquid, physics_state_delta.in_liquid) {
+                                    // this match computes `x <|> y <|> liftA2 max x y`
+                                    (Some(x), Some(y)) => Some(x.max(y)),
+                                    (x @ Some(_), _) => x,
+                                    (_, y @ Some(_)) => y,
+                                    _ => None,
+                                };
                         }
                     }
 
-                    physics_state.in_liquid = terrain.get(pos.0.map(|e| e.floor() as i32))
-                        .ok()
-                        .and_then(|vox| vox.is_liquid().then_some(1.0));
-                },
-            }
+                    if tgt_pos != pos.0 {
+                        pos_writes.push((entity, Pos(tgt_pos)));
+                    }
+                    if vel != old_vel {
+                        vel_writes.push((entity, vel));
+                    }
 
-            landed_on_ground
-        }).fold(Vec::new, |mut lands_on_grounds, landed_on_ground| {
-            if let Some(land_on_ground) = landed_on_ground {
-                lands_on_grounds.push(land_on_ground);
-            }
-            lands_on_grounds
-        }).reduce(Vec::new, |mut land_on_grounds_a, mut land_on_grounds_b| {
-            land_on_grounds_a.append(&mut land_on_grounds_b);
-            land_on_grounds_a
-        });
+                    (pos_writes, vel_writes, land_on_grounds)
+                },
+            )
+            .reduce(
+                || (Vec::new(), Vec::new(), Vec::new()),
+                |(mut pos_writes_a, mut vel_writes_a, mut land_on_grounds_a),
+                 (mut pos_writes_b, mut vel_writes_b, mut land_on_grounds_b)| {
+                    pos_writes_a.append(&mut pos_writes_b);
+                    vel_writes_a.append(&mut vel_writes_b);
+                    land_on_grounds_a.append(&mut land_on_grounds_b);
+                    (pos_writes_a, vel_writes_a, land_on_grounds_a)
+                },
+            );
         drop(guard);
         job.cpu_stats.measure(ParMode::Single);
 
+        let pos_writes: HashMap<Entity, Pos> = pos_writes.into_iter().collect();
+        let vel_writes: HashMap<Entity, Vel> = vel_writes.into_iter().collect();
+        for (entity, pos, vel) in
+            (&read.entities, &mut write.positions, &mut write.velocities).join()
+        {
+            if let Some(new_pos) = pos_writes.get(&entity) {
+                *pos = *new_pos;
+            }
+
+            if let Some(new_vel) = vel_writes.get(&entity) {
+                *vel = *new_vel;
+            }
+        }
+
+        for (ori, previous_phys_cache) in
+            (&write.orientations, &mut write.previous_phys_cache).join()
+        {
+            previous_phys_cache.ori = ori.to_quat();
+        }
+
+        let mut event_emitter = read.event_bus.emitter();
         land_on_grounds.into_iter().for_each(|(entity, vel)| {
             event_emitter.emit(ServerEvent::LandOnGround { entity, vel: vel.0 });
         });
     }
 }
+
+impl<'a> System<'a> for Sys {
+    type SystemData = PhysicsData<'a>;
+
+    const NAME: &'static str = "phys";
+    const ORIGIN: Origin = Origin::Common;
+    const PHASE: Phase = Phase::Create;
+
+    fn run(job: &mut Job<Self>, mut psd: Self::SystemData) {
+        psd.reset();
+
+        // Apply pushback
+        //
+        // Note: We now do this first because we project velocity ahead. This is slighty
+        // imperfect and implies that we might get edge-cases where entities
+        // standing right next to the edge of a wall may get hit by projectiles
+        // fired into the wall very close to them. However, this sort of thing is
+        // already possible with poorly-defined hitboxes anyway so it's not too
+        // much of a concern.
+        //
+        // If this situation becomes a problem, this code should be integrated with the
+        // terrain collision code below, although that's not trivial to do since
+        // it means the step needs to take into account the speeds of both
+        // entities.
+        psd.maintain_pushback_cache();
+        psd.apply_pushback(job);
+
+        psd.handle_movement_and_terrain(job);
+    }
+}
+
+#[allow(clippy::too_many_arguments)]
+fn box_voxel_collision<'a, T: BaseVol<Vox = Block> + ReadVol>(
+    cylinder: (f32, f32, f32),
+    terrain: &'a T,
+    entity: Entity,
+    pos: &mut Pos,
+    tgt_pos: Vec3<f32>,
+    vel: &mut Vel,
+    physics_state: &mut PhysicsState,
+    ground_vel: Vec3<f32>,
+    dt: &DeltaTime,
+    was_on_ground: bool,
+    block_snap: bool,
+    climbing: bool,
+    mut land_on_ground: impl FnMut(Entity, Vel),
+) {
+    let (radius, z_min, z_max) = cylinder;
+
+    // Probe distances
+    let hdist = radius.ceil() as i32;
+    // Neighbouring blocks iterator
+    let near_iter = (-hdist..hdist + 1)
+        .map(move |i| {
+            (-hdist..hdist + 1).map(move |j| {
+                (1 - Block::MAX_HEIGHT.ceil() as i32 + z_min.floor() as i32
+                    ..z_max.ceil() as i32 + 1)
+                    .map(move |k| (i, j, k))
+            })
+        })
+        .flatten()
+        .flatten();
+
+    // Function for iterating over the blocks the player at a specific position
+    // collides with
+    fn collision_iter<'a, T: BaseVol<Vox = Block> + ReadVol>(
+        pos: Vec3<f32>,
+        terrain: &'a T,
+        hit: &'a impl Fn(&Block) -> bool,
+        height: &'a impl Fn(&Block) -> f32,
+        near_iter: impl Iterator<Item = (i32, i32, i32)> + 'a,
+        radius: f32,
+        z_range: Range<f32>,
+    ) -> impl Iterator<Item = Aabb<f32>> + 'a {
+        near_iter.filter_map(move |(i, j, k)| {
+            let block_pos = pos.map(|e| e.floor() as i32) + Vec3::new(i, j, k);
+
+            if let Some(block) = terrain.get(block_pos).ok().copied().filter(hit) {
+                let player_aabb = Aabb {
+                    min: pos + Vec3::new(-radius, -radius, z_range.start),
+                    max: pos + Vec3::new(radius, radius, z_range.end),
+                };
+                let block_aabb = Aabb {
+                    min: block_pos.map(|e| e as f32),
+                    max: block_pos.map(|e| e as f32) + Vec3::new(1.0, 1.0, height(&block)),
+                };
+
+                if player_aabb.collides_with_aabb(block_aabb) {
+                    return Some(block_aabb);
+                }
+            }
+
+            None
+        })
+    }
+
+    let z_range = z_min..z_max;
+    // Function for determining whether the player at a specific position collides
+    // with blocks with the given criteria
+    fn collision_with<'a, T: BaseVol<Vox = Block> + ReadVol>(
+        pos: Vec3<f32>,
+        terrain: &'a T,
+        hit: impl Fn(&Block) -> bool,
+        near_iter: impl Iterator<Item = (i32, i32, i32)> + 'a,
+        radius: f32,
+        z_range: Range<f32>,
+    ) -> bool {
+        collision_iter(
+            pos,
+            terrain,
+            &|block| block.is_solid() && hit(block),
+            &Block::solid_height,
+            near_iter,
+            radius,
+            z_range,
+        )
+        .count()
+            > 0
+    }
+
+    physics_state.on_ground = false;
+
+    let mut on_ground = false;
+    let mut on_ceiling = false;
+    let mut attempts = 0; // Don't loop infinitely here
+
+    let mut pos_delta = tgt_pos - pos.0;
+
+    // Don't jump too far at once
+    let increments = (pos_delta.map(|e| e.abs()).reduce_partial_max() / 0.3)
+        .ceil()
+        .max(1.0);
+    let old_pos = pos.0;
+    fn block_true(_: &Block) -> bool { true }
+    for _ in 0..increments as usize {
+        pos.0 += pos_delta / increments;
+
+        const MAX_ATTEMPTS: usize = 16;
+
+        // While the player is colliding with the terrain...
+        while collision_with(
+            pos.0,
+            &terrain,
+            block_true,
+            near_iter.clone(),
+            radius,
+            z_range.clone(),
+        ) && attempts < MAX_ATTEMPTS
+        {
+            // Calculate the player's AABB
+            let player_aabb = Aabb {
+                min: pos.0 + Vec3::new(-radius, -radius, z_min),
+                max: pos.0 + Vec3::new(radius, radius, z_max),
+            };
+
+            // Determine the block that we are colliding with most (based on minimum
+            // collision axis)
+            let (_block_pos, block_aabb, block_height) = near_iter
+                .clone()
+                // Calculate the block's position in world space
+                .map(|(i, j, k)| pos.0.map(|e| e.floor() as i32) + Vec3::new(i, j, k))
+                // Make sure the block is actually solid
+                .filter_map(|block_pos| {
+                    if let Some(block) = terrain
+                        .get(block_pos)
+                        .ok()
+                        .filter(|block| block.is_solid())
+                    {
+                        // Calculate block AABB
+                        Some((
+                            block_pos,
+                            Aabb {
+                                min: block_pos.map(|e| e as f32),
+                                max: block_pos.map(|e| e as f32) + Vec3::new(1.0, 1.0, block.solid_height()),
+                            },
+                            block.solid_height(),
+                        ))
+                    } else {
+                        None
+                    }
+                })
+                // Determine whether the block's AABB collides with the player's AABB
+                .filter(|(_, block_aabb, _)| block_aabb.collides_with_aabb(player_aabb))
+                // Find the maximum of the minimum collision axes (this bit is weird, trust me that it works)
+                .min_by_key(|(_, block_aabb, _)| {
+                    ((block_aabb.center() - player_aabb.center() - Vec3::unit_z() * 0.5)
+                        .map(|e| e.abs())
+                        .sum()
+                        * 1_000_000.0) as i32
+                })
+                .expect("Collision detected, but no colliding blocks found!");
+
+            // Find the intrusion vector of the collision
+            let dir = player_aabb.collision_vector_with_aabb(block_aabb);
+
+            // Determine an appropriate resolution vector (i.e: the minimum distance
+            // needed to push out of the block)
+            let max_axis = dir.map(|e| e.abs()).reduce_partial_min();
+            let resolve_dir = -dir.map(|e| {
+                if e.abs().to_bits() == max_axis.to_bits() {
+                    e
+                } else {
+                    0.0
+                }
+            });
+
+            // When the resolution direction is pointing upwards, we must be on the
+            // ground
+            if resolve_dir.z > 0.0
+            /* && vel.0.z <= 0.0 */
+            {
+                on_ground = true;
+
+                if !was_on_ground {
+                    land_on_ground(entity, *vel);
+                }
+            } else if resolve_dir.z < 0.0 && vel.0.z >= 0.0 {
+                on_ceiling = true;
+            }
+
+            // When the resolution direction is non-vertical, we must be colliding
+            // with a wall If the space above is free...
+            if !collision_with(Vec3::new(pos.0.x, pos.0.y, (pos.0.z + 0.1).ceil()), &terrain, block_true, near_iter.clone(), radius, z_range.clone())
+                // ...and we're being pushed out horizontally...
+                && resolve_dir.z == 0.0
+                // ...and the vertical resolution direction is sufficiently great...
+                && dir.z < -0.1
+                // ...and we're falling/standing OR there is a block *directly* beneath our current origin (note: not hitbox)...
+                // && terrain
+                //     .get((pos.0 - Vec3::unit_z() * 0.1).map(|e| e.floor() as i32))
+                //     .map(|block| block.is_solid())
+                //     .unwrap_or(false)
+                // ...and there is a collision with a block beneath our current hitbox...
+                && collision_with(
+                    pos.0 + resolve_dir - Vec3::unit_z() * 1.25,
+                    &terrain,
+                    block_true,
+                    near_iter.clone(),
+                    radius,
+                    z_range.clone(),
+                )
+            {
+                // ...block-hop!
+                pos.0.z = (pos.0.z + 0.1).floor() + block_height;
+                vel.0.z = vel.0.z.max(0.0);
+                on_ground = true;
+                break;
+            } else {
+                // Correct the velocity
+                vel.0 = vel.0.map2(resolve_dir, |e, d| {
+                    if d * e.signum() < 0.0 {
+                        if d < 0.0 { d.min(0.0) } else { d.max(0.0) }
+                    } else {
+                        e
+                    }
+                });
+                pos_delta *= resolve_dir.map(|e| if e != 0.0 { 0.0 } else { 1.0 });
+            }
+
+            // Resolve the collision normally
+            pos.0 += resolve_dir;
+
+            attempts += 1;
+        }
+
+        if attempts == MAX_ATTEMPTS {
+            vel.0 = Vec3::zero();
+            pos.0 = old_pos;
+            break;
+        }
+    }
+
+    if on_ceiling {
+        physics_state.on_ceiling = true;
+    }
+
+    if on_ground {
+        physics_state.on_ground = true;
+    // If the space below us is free, then "snap" to the ground
+    } else if collision_with(
+        pos.0 - Vec3::unit_z() * 1.1,
+        &terrain,
+        block_true,
+        near_iter.clone(),
+        radius,
+        z_range.clone(),
+    ) && vel.0.z < 0.25
+        && vel.0.z > -1.5
+        && was_on_ground
+        && block_snap
+    {
+        let snap_height = terrain
+            .get(Vec3::new(pos.0.x, pos.0.y, pos.0.z - 0.1).map(|e| e.floor() as i32))
+            .ok()
+            .filter(|block| block.is_solid())
+            .map(|block| block.solid_height())
+            .unwrap_or(0.0);
+        vel.0.z = 0.0;
+        pos.0.z = (pos.0.z - 0.1).floor() + snap_height;
+        physics_state.on_ground = true;
+    }
+
+    let dirs = [
+        Vec3::unit_x(),
+        Vec3::unit_y(),
+        -Vec3::unit_x(),
+        -Vec3::unit_y(),
+    ];
+
+    if let (wall_dir, true) = dirs.iter().fold((Vec3::zero(), false), |(a, hit), dir| {
+        if collision_with(
+            pos.0 + *dir * 0.01,
+            &terrain,
+            block_true,
+            near_iter.clone(),
+            radius,
+            z_range.clone(),
+        ) {
+            (a + dir, true)
+        } else {
+            (a, hit)
+        }
+    }) {
+        physics_state.on_wall = Some(wall_dir);
+    } else {
+        physics_state.on_wall = None;
+    }
+
+    if physics_state.on_ground || (physics_state.on_wall.is_some() && climbing) {
+        vel.0 *= (1.0 - FRIC_GROUND.min(1.0)).powf(dt.0 * 60.0);
+        physics_state.ground_vel = ground_vel;
+    }
+
+    // Figure out if we're in water
+    physics_state.in_liquid = collision_iter(
+        pos.0,
+        &*terrain,
+        &|block| block.is_liquid(),
+        // The liquid part of a liquid block always extends 1 block high.
+        &|_block| 1.0,
+        near_iter,
+        radius,
+        z_min..z_max,
+    )
+    .max_by_key(|block_aabb| (block_aabb.max.z * 100.0) as i32)
+    .map(|block_aabb| block_aabb.max.z - pos.0.z);
+}
diff --git a/common/sys/src/state.rs b/common/sys/src/state.rs
index 3d15d4e3ff..f45ec3d18a 100644
--- a/common/sys/src/state.rs
+++ b/common/sys/src/state.rs
@@ -6,7 +6,7 @@ use common::{
     comp,
     event::{EventBus, LocalEvent, ServerEvent},
     region::RegionMap,
-    resources::{DeltaTime, GameMode, Time, TimeOfDay},
+    resources::{DeltaTime, GameMode, PlayerEntity, Time, TimeOfDay},
     terrain::{Block, TerrainChunk, TerrainGrid},
     time::DayPeriod,
     trade::Trades,
@@ -14,8 +14,8 @@ use common::{
     vol::{ReadVol, WriteVol},
 };
 use common_base::span;
-use common_ecs::{PhysicsMetrics, SysMetrics};
-use common_net::sync::WorldSyncExt;
+use common_ecs::{run_now, PhysicsMetrics, SysMetrics};
+use common_net::sync::{interpolation as sync_interp, WorldSyncExt};
 use hashbrown::{HashMap, HashSet};
 use rayon::{ThreadPool, ThreadPoolBuilder};
 use specs::{
@@ -36,7 +36,6 @@ const DAY_CYCLE_FACTOR: f64 = 24.0 * 2.0;
 /// 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;
-const HUMANOID_JUMP_ACCEL: f32 = 16.0;
 
 #[derive(Default)]
 pub struct BlockChange {
@@ -165,6 +164,9 @@ impl State {
         // 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
@@ -194,6 +196,7 @@ impl State {
         // 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(TerrainChanges::default());
@@ -438,6 +441,7 @@ impl State {
         let mut dispatcher = dispatch_builder.build();
         drop(guard);
         span!(guard, "run systems");
+        run_now::<crate::interpolation::InterpolationSystem>(&self.ecs);
         dispatcher.dispatch(&self.ecs);
         drop(guard);
 
@@ -454,11 +458,11 @@ impl State {
         let events = self.ecs.read_resource::<EventBus<LocalEvent>>().recv_all();
         for event in events {
             let mut velocities = self.ecs.write_storage::<comp::Vel>();
-            let mut controllers = self.ecs.write_storage::<comp::Controller>();
+            let physics = self.ecs.read_storage::<comp::PhysicsState>();
             match event {
-                LocalEvent::Jump(entity) => {
+                LocalEvent::Jump(entity, impulse) => {
                     if let Some(vel) = velocities.get_mut(entity) {
-                        vel.0.z = HUMANOID_JUMP_ACCEL;
+                        vel.0.z = impulse + physics.get(entity).map_or(0.0, |ps| ps.ground_vel.z);
                     }
                 },
                 LocalEvent::ApplyImpulse { entity, impulse } => {
@@ -466,21 +470,6 @@ impl State {
                         vel.0 = impulse;
                     }
                 },
-                LocalEvent::WallLeap { entity, wall_dir } => {
-                    if let (Some(vel), Some(_controller)) =
-                        (velocities.get_mut(entity), controllers.get_mut(entity))
-                    {
-                        let hspeed = Vec2::<f32>::from(vel.0).magnitude();
-                        if hspeed > 0.001 && hspeed < 0.5 {
-                            vel.0 += vel.0.normalized()
-                                * Vec3::new(1.0, 1.0, 0.0)
-                                * HUMANOID_JUMP_ACCEL
-                                * 1.5
-                                - wall_dir * 0.03;
-                            vel.0.z = HUMANOID_JUMP_ACCEL * 0.5;
-                        }
-                    }
-                },
                 LocalEvent::Boost {
                     entity,
                     vel: extra_vel,
diff --git a/server/src/cmd.rs b/server/src/cmd.rs
index 9043ef5fe5..8ca53368fb 100644
--- a/server/src/cmd.rs
+++ b/server/src/cmd.rs
@@ -77,6 +77,7 @@ type CommandHandler = fn(&mut Server, EcsEntity, EcsEntity, String, &ChatCommand
 fn get_handler(cmd: &ChatCommand) -> CommandHandler {
     match cmd {
         ChatCommand::Adminify => handle_adminify,
+        ChatCommand::Airship => handle_spawn_airship,
         ChatCommand::Alias => handle_alias,
         ChatCommand::Ban => handle_ban,
         ChatCommand::Build => handle_build,
@@ -984,6 +985,51 @@ fn handle_spawn_training_dummy(
     }
 }
 
+fn handle_spawn_airship(
+    server: &mut Server,
+    client: EcsEntity,
+    target: EcsEntity,
+    args: String,
+    action: &ChatCommand,
+) {
+    let angle = scan_fmt!(&args, &action.arg_fmt(), f32).ok();
+    match server.state.read_component_copied::<comp::Pos>(target) {
+        Some(mut pos) => {
+            pos.0.z += 50.0;
+            const DESTINATION_RADIUS: f32 = 2000.0;
+            let angle = angle.map(|a| a * std::f32::consts::PI / 180.0);
+            let destination = angle.map(|a| {
+                pos.0
+                    + Vec3::new(
+                        DESTINATION_RADIUS * a.cos(),
+                        DESTINATION_RADIUS * a.sin(),
+                        200.0,
+                    )
+            });
+            server
+                .state
+                .create_ship(pos, comp::ship::Body::DefaultAirship, 1, destination)
+                .with(comp::Scale(comp::ship::AIRSHIP_SCALE))
+                .with(LightEmitter {
+                    col: Rgb::new(1.0, 0.65, 0.2),
+                    strength: 2.0,
+                    flicker: 1.0,
+                    animated: true,
+                })
+                .build();
+
+            server.notify_client(
+                client,
+                ServerGeneral::server_msg(ChatType::CommandInfo, "Spawned an airship"),
+            );
+        },
+        None => server.notify_client(
+            client,
+            ServerGeneral::server_msg(ChatType::CommandError, "You have no position!"),
+        ),
+    }
+}
+
 fn handle_spawn_campfire(
     server: &mut Server,
     client: EcsEntity,
diff --git a/server/src/events/entity_creation.rs b/server/src/events/entity_creation.rs
index a10b60c9d9..e9868eae25 100644
--- a/server/src/events/entity_creation.rs
+++ b/server/src/events/entity_creation.rs
@@ -129,7 +129,12 @@ pub fn handle_shoot(
         return;
     };
 
-    let vel = *dir * speed;
+    let vel = *dir * speed
+        + state
+            .ecs()
+            .read_storage::<Vel>()
+            .get(entity)
+            .map_or(Vec3::zero(), |v| v.0);
 
     // Add an outcome
     state
diff --git a/server/src/events/inventory_manip.rs b/server/src/events/inventory_manip.rs
index c1c9f8f450..c03290d370 100644
--- a/server/src/events/inventory_manip.rs
+++ b/server/src/events/inventory_manip.rs
@@ -69,7 +69,7 @@ pub fn handle_inventory(server: &mut Server, entity: EcsEntity, manip: comp::Inv
             find_dist::Cylinder::from_components(
                 p.0,
                 scales.get(entity).copied(),
-                colliders.get(entity).copied(),
+                colliders.get(entity),
                 char_states.get(entity),
             )
         })
diff --git a/server/src/rtsim/entity.rs b/server/src/rtsim/entity.rs
index a65a555890..05b96fcbf2 100644
--- a/server/src/rtsim/entity.rs
+++ b/server/src/rtsim/entity.rs
@@ -27,7 +27,10 @@ impl Entity {
 
     pub fn get_body(&self) -> comp::Body {
         match self.rng(PERM_GENUS).gen::<f32>() {
-            //we want 50% birds, 50% humans for now
+            // we want 5% airships, 45% birds, 50% humans
+            // TODO: uncomment this to re-enable RtSim airships once physics is interpolated well
+            // in multiplayer.
+            //x if x < 0.05 => comp::Body::Ship(comp::ship::Body::DefaultAirship),
             x if x < 0.50 => {
                 let species = *(&comp::bird_medium::ALL_SPECIES)
                     .choose(&mut self.rng(PERM_SPECIES))
@@ -53,6 +56,7 @@ impl Entity {
             comp::Body::BirdSmall(_) => "Warbler".to_string(),
             comp::Body::Dragon(b) => get_npc_name(&npc_names.dragon, b.species).to_string(),
             comp::Body::Humanoid(b) => get_npc_name(&npc_names.humanoid, b.species).to_string(),
+            comp::Body::Ship(_) => "Veloren Air".to_string(),
             //TODO: finish match as necessary
             _ => unimplemented!(),
         }
@@ -131,6 +135,7 @@ impl Entity {
                 .iter()
                 .filter(|s| match self.get_body() {
                     comp::Body::Humanoid(_) => s.1.is_settlement() | s.1.is_castle(),
+                    comp::Body::Ship(_) => s.1.is_settlement(),
                     _ => s.1.is_dungeon(),
                 })
                 .filter(|_| thread_rng().gen_range(0i32..4) == 0)
diff --git a/server/src/rtsim/tick.rs b/server/src/rtsim/tick.rs
index 6faddda0c1..13ab05faaf 100644
--- a/server/src/rtsim/tick.rs
+++ b/server/src/rtsim/tick.rs
@@ -122,7 +122,10 @@ impl<'a> System<'a> for Sys {
                     comp::Body::Humanoid(_) => comp::Alignment::Npc,
                     _ => comp::Alignment::Wild,
                 },
-                scale: comp::Scale(1.0),
+                scale: match body {
+                    comp::Body::Ship(_) => comp::Scale(comp::ship::AIRSHIP_SCALE),
+                    _ => comp::Scale(1.0),
+                },
                 drop_item: None,
                 home_chunk: None,
                 rtsim_entity: Some(RtSimEntity(id)),
diff --git a/server/src/state_ext.rs b/server/src/state_ext.rs
index a596b31cbb..4e9369a939 100644
--- a/server/src/state_ext.rs
+++ b/server/src/state_ext.rs
@@ -41,6 +41,13 @@ pub trait StateExt {
     ) -> EcsEntityBuilder;
     /// Build a static object entity
     fn create_object(&mut self, pos: comp::Pos, object: comp::object::Body) -> EcsEntityBuilder;
+    fn create_ship(
+        &mut self,
+        pos: comp::Pos,
+        ship: comp::ship::Body,
+        level: u16,
+        destination: Option<Vec3<f32>>,
+    ) -> EcsEntityBuilder;
     /// Build a projectile
     fn create_projectile(
         &mut self,
@@ -172,10 +179,15 @@ impl StateExt for State {
                 ))
                 .unwrap_or_default(),
             )
-            .with(comp::Collider::Box {
-                radius: body.radius(),
-                z_min: 0.0,
-                z_max: body.height(),
+            .with(match body {
+                comp::Body::Ship(ship) => comp::Collider::Voxel {
+                    id: ship.manifest_entry().to_string(),
+                },
+                _ => comp::Collider::Box {
+                    radius: body.radius(),
+                    z_min: 0.0,
+                    z_max: body.height(),
+                },
             })
             .with(comp::Controller::default())
             .with(body)
@@ -215,6 +227,42 @@ impl StateExt for State {
             .with(comp::Gravity(1.0))
     }
 
+    fn create_ship(
+        &mut self,
+        pos: comp::Pos,
+        ship: comp::ship::Body,
+        level: u16,
+        destination: Option<Vec3<f32>>,
+    ) -> EcsEntityBuilder {
+        let mut builder = self
+            .ecs_mut()
+            .create_entity_synced()
+            .with(pos)
+            .with(comp::Vel(Vec3::zero()))
+            .with(comp::Ori::default())
+            .with(comp::Mass(50.0))
+            .with(comp::Collider::Voxel {
+                id: ship.manifest_entry().to_string(),
+            })
+            .with(comp::Body::Ship(ship))
+            .with(comp::Gravity(1.0))
+            .with(comp::Controller::default())
+            .with(comp::inventory::Inventory::new_empty())
+            .with(comp::CharacterState::default())
+            // TODO: some of these are required in order for the character_behavior system to
+            // recognize a possesed airship; that system should be refactored to use `.maybe()`
+            .with(comp::Energy::new(ship.into(), level))
+            .with(comp::Health::new(ship.into(), level))
+            .with(comp::Stats::new("Airship".to_string()))
+            .with(comp::Buffs::default())
+            .with(comp::MountState::Unmounted)
+            .with(comp::Combo::default());
+        if let Some(pos) = destination {
+            builder = builder.with(comp::Agent::with_destination(pos))
+        }
+        builder
+    }
+
     fn create_projectile(
         &mut self,
         pos: comp::Pos,
diff --git a/server/src/sys/agent.rs b/server/src/sys/agent.rs
index 74cc3aae94..4abf971136 100644
--- a/server/src/sys/agent.rs
+++ b/server/src/sys/agent.rs
@@ -34,7 +34,7 @@ use specs::{
     Entities, Entity as EcsEntity, Join, ParJoin, Read, ReadExpect, ReadStorage, SystemData, World,
     Write, WriteStorage,
 };
-use std::f32::consts::PI;
+use std::{f32::consts::PI, sync::Arc};
 use vek::*;
 
 struct AgentData<'a> {
@@ -82,6 +82,7 @@ pub struct ReadData<'a> {
     mount_states: ReadStorage<'a, MountState>,
     time_of_day: Read<'a, TimeOfDay>,
     light_emitter: ReadStorage<'a, LightEmitter>,
+    world: ReadExpect<'a, Arc<world::World>>,
 }
 
 // This is 3.1 to last longer than the last damage timer (3.0 seconds)
@@ -213,7 +214,7 @@ impl<'a> System<'a> for Sys {
                         in_liquid: physics_state.in_liquid.is_some(),
                         min_tgt_dist: 1.0,
                         can_climb: body.map(|b| b.can_climb()).unwrap_or(false),
-                        can_fly: body.map(|b| b.can_fly()).unwrap_or(false),
+                        can_fly: body.map(|b| b.can_fly().is_some()).unwrap_or(false),
                     };
 
                     let flees = alignment
@@ -619,19 +620,43 @@ impl<'a> AgentData<'a> {
 
                 controller.inputs.move_z = bearing.z
                     + if self.traversal_config.can_fly {
-                        if read_data
+                        let obstacle_ahead = read_data
                             .terrain
                             .ray(
                                 self.pos.0 + Vec3::unit_z(),
                                 self.pos.0
-                                    + bearing.try_normalized().unwrap_or_else(Vec3::unit_y) * 60.0
+                                    + bearing.try_normalized().unwrap_or_else(Vec3::unit_y) * 80.0
                                     + Vec3::unit_z(),
                             )
                             .until(Block::is_solid)
                             .cast()
                             .1
-                            .map_or(true, |b| b.is_some())
-                        {
+                            .map_or(true, |b| b.is_some());
+                        let ground_too_close = self
+                            .body
+                            .map(|body| {
+                                let height_approx = self.pos.0.y
+                                    - read_data
+                                        .world
+                                        .sim()
+                                        .get_alt_approx(self.pos.0.xy().map(|x: f32| x as i32))
+                                        .unwrap_or(0.0);
+
+                                height_approx < body.flying_height()
+                                    || read_data
+                                        .terrain
+                                        .ray(
+                                            self.pos.0,
+                                            self.pos.0 - body.flying_height() * Vec3::unit_z(),
+                                        )
+                                        .until(|b: &Block| b.is_solid() || b.is_liquid())
+                                        .cast()
+                                        .1
+                                        .map_or(false, |b| b.is_some())
+                            })
+                            .unwrap_or(false);
+
+                        if obstacle_ahead || ground_too_close {
                             1.0 //fly up when approaching obstacles
                         } else {
                             -0.1
diff --git a/server/src/sys/entity_sync.rs b/server/src/sys/entity_sync.rs
index 25fa256b45..600fea43fe 100644
--- a/server/src/sys/entity_sync.rs
+++ b/server/src/sys/entity_sync.rs
@@ -249,9 +249,18 @@ impl<'a> System<'a> for Sys {
             {
                 let mut comp_sync_package = CompSyncPackage::new();
                 let mut throttle = true;
+
+                // Extrapolation depends on receiving several frames indicating that something
+                // has stopped in order for the extrapolated value to have
+                // stopped
+                const SEND_UNCHANGED_PHYSICS_DATA: bool = true;
+
                 // TODO: An entity that stopped moving on a tick that it wasn't sent to the
                 // player will never have its position updated
-                match last_pos.get(entity).map(|&l| l.0 != pos) {
+                match last_pos
+                    .get(entity)
+                    .map(|&l| l.0 != pos || SEND_UNCHANGED_PHYSICS_DATA)
+                {
                     Some(false) => {},
                     Some(true) => {
                         let _ = last_pos.insert(entity, Last(pos));
@@ -265,7 +274,10 @@ impl<'a> System<'a> for Sys {
                 }
 
                 if let Some(&vel) = maybe_vel {
-                    match last_vel.get(entity).map(|&l| l.0 != vel) {
+                    match last_vel
+                        .get(entity)
+                        .map(|&l| l.0 != vel || SEND_UNCHANGED_PHYSICS_DATA)
+                    {
                         Some(false) => {},
                         Some(true) => {
                             let _ = last_vel.insert(entity, Last(vel));
@@ -286,7 +298,10 @@ impl<'a> System<'a> for Sys {
                 }
 
                 if let Some(&ori) = maybe_ori {
-                    match last_ori.get(entity).map(|&l| l.0 != ori) {
+                    match last_ori
+                        .get(entity)
+                        .map(|&l| l.0 != ori || SEND_UNCHANGED_PHYSICS_DATA)
+                    {
                         Some(false) => {},
                         Some(true) => {
                             let _ = last_ori.insert(entity, Last(ori));
diff --git a/server/src/sys/sentinel.rs b/server/src/sys/sentinel.rs
index 105b417a6c..778892724c 100644
--- a/server/src/sys/sentinel.rs
+++ b/server/src/sys/sentinel.rs
@@ -140,7 +140,7 @@ impl<'a> TrackedComps<'a> {
         self.mass.get(entity).copied().map(|c| comps.push(c.into()));
         self.collider
             .get(entity)
-            .copied()
+            .cloned()
             .map(|c| comps.push(c.into()));
         self.sticky
             .get(entity)
diff --git a/voxygen/anim/src/lib.rs b/voxygen/anim/src/lib.rs
index 4988954a6f..c424b4d869 100644
--- a/voxygen/anim/src/lib.rs
+++ b/voxygen/anim/src/lib.rs
@@ -54,6 +54,7 @@ pub mod object;
 pub mod quadruped_low;
 pub mod quadruped_medium;
 pub mod quadruped_small;
+pub mod ship;
 pub mod theropod;
 pub mod vek;
 
diff --git a/voxygen/anim/src/ship/idle.rs b/voxygen/anim/src/ship/idle.rs
new file mode 100644
index 0000000000..a8e59d5c56
--- /dev/null
+++ b/voxygen/anim/src/ship/idle.rs
@@ -0,0 +1,33 @@
+use super::{
+    super::{vek::*, Animation},
+    ShipSkeleton, SkeletonAttr,
+};
+use common::comp::item::ToolKind;
+
+pub struct IdleAnimation;
+
+impl Animation for IdleAnimation {
+    type Dependency = (Option<ToolKind>, Option<ToolKind>, f32);
+    type Skeleton = ShipSkeleton;
+
+    #[cfg(feature = "use-dyn-lib")]
+    const UPDATE_FN: &'static [u8] = b"ship_idle\0";
+
+    #[cfg_attr(feature = "be-dyn-lib", export_name = "ship_idle")]
+    #[allow(clippy::approx_constant)] // TODO: Pending review in #587
+    fn update_skeleton_inner(
+        skeleton: &Self::Skeleton,
+        (_active_tool_kind, _second_tool_kind, _global_time): Self::Dependency,
+        _anim_time: f32,
+        _rate: &mut f32,
+        s_a: &SkeletonAttr,
+    ) -> Self::Skeleton {
+        let mut next = (*skeleton).clone();
+
+        next.bone0.position = Vec3::new(s_a.bone0.0, s_a.bone0.1, s_a.bone0.2) / 11.0;
+
+        next.bone1.position = Vec3::new(s_a.bone1.0, s_a.bone1.1, s_a.bone1.2) / 11.0;
+
+        next
+    }
+}
diff --git a/voxygen/anim/src/ship/mod.rs b/voxygen/anim/src/ship/mod.rs
new file mode 100644
index 0000000000..14316d2ab3
--- /dev/null
+++ b/voxygen/anim/src/ship/mod.rs
@@ -0,0 +1,68 @@
+pub mod idle;
+
+// Reexports
+pub use self::idle::IdleAnimation;
+
+use super::{make_bone, vek::*, FigureBoneData, Skeleton};
+use common::comp::{self};
+use core::convert::TryFrom;
+
+pub type Body = comp::ship::Body;
+
+skeleton_impls!(struct ShipSkeleton {
+    + bone0,
+    + bone1,
+});
+
+impl Skeleton for ShipSkeleton {
+    type Attr = SkeletonAttr;
+    type Body = Body;
+
+    const BONE_COUNT: usize = 2;
+    #[cfg(feature = "use-dyn-lib")]
+    const COMPUTE_FN: &'static [u8] = b"ship_compute_mats\0";
+
+    #[cfg_attr(feature = "be-dyn-lib", export_name = "ship_compute_mats")]
+    fn compute_matrices_inner(
+        &self,
+        base_mat: Mat4<f32>,
+        buf: &mut [FigureBoneData; super::MAX_BONE_COUNT],
+    ) -> Vec3<f32> {
+        let bone0_mat = base_mat * Mat4::<f32>::from(self.bone0);
+
+        *(<&mut [_; Self::BONE_COUNT]>::try_from(&mut buf[0..Self::BONE_COUNT]).unwrap()) = [
+            make_bone(bone0_mat * Mat4::scaling_3d(1.0 / 11.0)),
+            make_bone(Mat4::<f32>::from(self.bone1) * Mat4::scaling_3d(1.0 / 11.0)), /* Decorellated from ori */
+        ];
+        Vec3::unit_z() * 0.5
+    }
+}
+
+pub struct SkeletonAttr {
+    bone0: (f32, f32, f32),
+    bone1: (f32, f32, f32),
+}
+
+impl<'a> std::convert::TryFrom<&'a comp::Body> for SkeletonAttr {
+    type Error = ();
+
+    fn try_from(body: &'a comp::Body) -> Result<Self, Self::Error> {
+        match body {
+            comp::Body::Ship(body) => Ok(SkeletonAttr::from(body)),
+            _ => Err(()),
+        }
+    }
+}
+
+impl Default for SkeletonAttr {
+    fn default() -> Self {
+        Self {
+            bone0: (0.0, 0.0, 0.0),
+            bone1: (0.0, 0.0, 0.0),
+        }
+    }
+}
+
+impl<'a> From<&'a Body> for SkeletonAttr {
+    fn from(_: &'a Body) -> Self { Self::default() }
+}
diff --git a/voxygen/src/scene/figure/load.rs b/voxygen/src/scene/figure/load.rs
index 6aca80bb7f..a04e9c5d16 100644
--- a/voxygen/src/scene/figure/load.rs
+++ b/voxygen/src/scene/figure/load.rs
@@ -16,13 +16,17 @@ use common::{
         quadruped_low::{self, BodyType as QLBodyType, Species as QLSpecies},
         quadruped_medium::{self, BodyType as QMBodyType, Species as QMSpecies},
         quadruped_small::{self, BodyType as QSBodyType, Species as QSSpecies},
+        ship::{
+            self,
+            figuredata::{ShipCentralSubSpec, ShipSpec},
+        },
         theropod::{self, BodyType as TBodyType, Species as TSpecies},
     },
     figure::{DynaUnionizer, MatSegment, Material, Segment},
 };
 use hashbrown::HashMap;
 use serde::Deserialize;
-use std::sync::Arc;
+use std::{fmt, hash::Hash, sync::Arc};
 use tracing::{error, warn};
 use vek::*;
 
@@ -34,6 +38,9 @@ fn load_segment(mesh_name: &str) -> Segment {
 }
 fn graceful_load_vox(mesh_name: &str) -> AssetHandle<DotVoxAsset> {
     let full_specifier: String = ["voxygen.voxel.", mesh_name].concat();
+    graceful_load_vox_fullspec(&full_specifier)
+}
+fn graceful_load_vox_fullspec(full_specifier: &str) -> AssetHandle<DotVoxAsset> {
     match DotVoxAsset::load(&full_specifier) {
         Ok(dot_vox) => dot_vox,
         Err(_) => {
@@ -45,6 +52,9 @@ fn graceful_load_vox(mesh_name: &str) -> AssetHandle<DotVoxAsset> {
 fn graceful_load_segment(mesh_name: &str) -> Segment {
     Segment::from(&graceful_load_vox(mesh_name).read().0)
 }
+fn graceful_load_segment_fullspec(full_specifier: &str) -> Segment {
+    Segment::from(&graceful_load_vox_fullspec(full_specifier).read().0)
+}
 fn graceful_load_segment_flipped(mesh_name: &str, flipped: bool) -> Segment {
     Segment::from_vox(&graceful_load_vox(mesh_name).read().0, flipped)
 }
@@ -4171,3 +4181,53 @@ impl ObjectCentralSpec {
         (central, Vec3::from(spec.bone1.offset))
     }
 }
+
+fn mesh_ship_bone<K: fmt::Debug + Eq + Hash, V, F: Fn(&V) -> &ShipCentralSubSpec>(
+    map: &HashMap<K, V>,
+    obj: &K,
+    f: F,
+) -> BoneMeshes {
+    let spec = match map.get(&obj) {
+        Some(spec) => spec,
+        None => {
+            error!("No specification exists for {:?}", obj);
+            return load_mesh("not_found", Vec3::new(-5.0, -5.0, -2.5));
+        },
+    };
+    let bone = f(spec);
+    let central = graceful_load_segment_fullspec(&["server.voxel.", &bone.central.0].concat());
+
+    (central, Vec3::from(bone.offset))
+}
+
+impl BodySpec for ship::Body {
+    type Spec = ShipSpec;
+
+    #[allow(unused_variables)]
+    fn load_spec() -> Result<AssetHandle<Self::Spec>, assets::Error> { Self::Spec::load("") }
+
+    fn bone_meshes(
+        FigureKey { body, .. }: &FigureKey<Self>,
+        spec: &Self::Spec,
+    ) -> [Option<BoneMeshes>; anim::MAX_BONE_COUNT] {
+        let map = &(spec.central.read().0).0;
+        [
+            Some(mesh_ship_bone(map, body, |spec| &spec.bone0)),
+            Some(mesh_ship_bone(map, body, |spec| &spec.bone1)),
+            Some(mesh_ship_bone(map, body, |spec| &spec.bone2)),
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+            None,
+        ]
+    }
+}
diff --git a/voxygen/src/scene/figure/mod.rs b/voxygen/src/scene/figure/mod.rs
index db5146c923..f2070d03cc 100644
--- a/voxygen/src/scene/figure/mod.rs
+++ b/voxygen/src/scene/figure/mod.rs
@@ -23,7 +23,7 @@ use anim::{
     dragon::DragonSkeleton, fish_medium::FishMediumSkeleton, fish_small::FishSmallSkeleton,
     golem::GolemSkeleton, object::ObjectSkeleton, quadruped_low::QuadrupedLowSkeleton,
     quadruped_medium::QuadrupedMediumSkeleton, quadruped_small::QuadrupedSmallSkeleton,
-    theropod::TheropodSkeleton, Animation, Skeleton,
+    ship::ShipSkeleton, theropod::TheropodSkeleton, Animation, Skeleton,
 };
 use common::{
     comp::{
@@ -101,6 +101,7 @@ struct FigureMgrStates {
     biped_small_states: HashMap<EcsEntity, FigureState<BipedSmallSkeleton>>,
     golem_states: HashMap<EcsEntity, FigureState<GolemSkeleton>>,
     object_states: HashMap<EcsEntity, FigureState<ObjectSkeleton>>,
+    ship_states: HashMap<EcsEntity, FigureState<ShipSkeleton>>,
 }
 
 impl FigureMgrStates {
@@ -120,6 +121,7 @@ impl FigureMgrStates {
             biped_small_states: HashMap::new(),
             golem_states: HashMap::new(),
             object_states: HashMap::new(),
+            ship_states: HashMap::new(),
         }
     }
 
@@ -180,6 +182,7 @@ impl FigureMgrStates {
                 .map(DerefMut::deref_mut),
             Body::Golem(_) => self.golem_states.get_mut(&entity).map(DerefMut::deref_mut),
             Body::Object(_) => self.object_states.get_mut(&entity).map(DerefMut::deref_mut),
+            Body::Ship(_) => self.ship_states.get_mut(&entity).map(DerefMut::deref_mut),
         }
     }
 
@@ -205,6 +208,7 @@ impl FigureMgrStates {
             Body::BipedSmall(_) => self.biped_small_states.remove(&entity).map(|e| e.meta),
             Body::Golem(_) => self.golem_states.remove(&entity).map(|e| e.meta),
             Body::Object(_) => self.object_states.remove(&entity).map(|e| e.meta),
+            Body::Ship(_) => self.ship_states.remove(&entity).map(|e| e.meta),
         }
     }
 
@@ -224,6 +228,7 @@ impl FigureMgrStates {
         self.biped_small_states.retain(|k, v| f(k, &mut *v));
         self.golem_states.retain(|k, v| f(k, &mut *v));
         self.object_states.retain(|k, v| f(k, &mut *v));
+        self.ship_states.retain(|k, v| f(k, &mut *v));
     }
 
     fn count(&self) -> usize {
@@ -242,6 +247,7 @@ impl FigureMgrStates {
             + self.biped_small_states.len()
             + self.golem_states.len()
             + self.object_states.len()
+            + self.ship_states.len()
     }
 
     fn count_visible(&self) -> usize {
@@ -314,6 +320,7 @@ impl FigureMgrStates {
                 .iter()
                 .filter(|(_, c)| c.visible())
                 .count()
+            + self.ship_states.iter().filter(|(_, c)| c.visible()).count()
     }
 }
 
@@ -332,6 +339,7 @@ pub struct FigureMgr {
     biped_large_model_cache: FigureModelCache<BipedLargeSkeleton>,
     biped_small_model_cache: FigureModelCache<BipedSmallSkeleton>,
     object_model_cache: FigureModelCache<ObjectSkeleton>,
+    ship_model_cache: FigureModelCache<ShipSkeleton>,
     golem_model_cache: FigureModelCache<GolemSkeleton>,
     states: FigureMgrStates,
 }
@@ -353,6 +361,7 @@ impl FigureMgr {
             biped_large_model_cache: FigureModelCache::new(),
             biped_small_model_cache: FigureModelCache::new(),
             object_model_cache: FigureModelCache::new(),
+            ship_model_cache: FigureModelCache::new(),
             golem_model_cache: FigureModelCache::new(),
             states: FigureMgrStates::default(),
         }
@@ -384,6 +393,7 @@ impl FigureMgr {
         self.biped_small_model_cache
             .clean(&mut self.col_lights, tick);
         self.object_model_cache.clean(&mut self.col_lights, tick);
+        self.ship_model_cache.clean(&mut self.col_lights, tick);
         self.golem_model_cache.clean(&mut self.col_lights, tick);
     }
 
@@ -673,6 +683,7 @@ impl FigureMgr {
             let (in_frustum, lpindex) = if let Some(mut meta) = state {
                 let (in_frustum, lpindex) = BoundingSphere::new(pos.0.into_array(), radius)
                     .coherent_test_against_frustum(frustum, meta.lpindex);
+                let in_frustum = in_frustum || matches!(body, Body::Ship(_));
                 meta.visible = in_frustum;
                 meta.lpindex = lpindex;
                 if in_frustum {
@@ -733,6 +744,9 @@ impl FigureMgr {
 
             let hands = (active_tool_hand, second_tool_hand);
 
+            // Velocity relative to the current ground
+            let rel_vel = vel.0 - physics.ground_vel;
+
             match body {
                 Body::Humanoid(body) => {
                     let (model, skeleton_attr) = self.model_cache.get_or_create_model(
@@ -753,6 +767,10 @@ impl FigureMgr {
                         .or_insert_with(|| {
                             FigureState::new(renderer, CharacterSkeleton::default())
                         });
+
+                    // Average velocity relative to the current ground
+                    let rel_avg_vel = state.avg_vel - physics.ground_vel;
+
                     let (character, last_character) = match (character, last_character) {
                         (Some(c), Some(l)) => (c, l),
                         _ => continue,
@@ -764,19 +782,13 @@ impl FigureMgr {
 
                     let target_base = match (
                         physics.on_ground,
-                        vel.0.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
-                        physics.in_liquid.is_some(),                      // In water
+                        rel_vel.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
+                        physics.in_liquid.is_some(),                        // In water
                     ) {
                         // Standing
                         (true, false, false) => anim::character::StandAnimation::update_skeleton(
                             &CharacterSkeleton::default(),
-                            (
-                                active_tool_kind,
-                                second_tool_kind,
-                                hands,
-                                time,
-                                state.avg_vel,
-                            ),
+                            (active_tool_kind, second_tool_kind, hands, time, rel_avg_vel),
                             state.state_time,
                             &mut state_animation_rate,
                             skeleton_attr,
@@ -788,12 +800,12 @@ impl FigureMgr {
                                 active_tool_kind,
                                 second_tool_kind,
                                 hands,
-                                vel.0,
+                                rel_vel,
                                 // TODO: Update to use the quaternion.
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                 time,
-                                state.avg_vel,
+                                rel_avg_vel,
                                 state.acc_vel,
                             ),
                             state.state_time,
@@ -807,7 +819,7 @@ impl FigureMgr {
                                 active_tool_kind,
                                 second_tool_kind,
                                 hands,
-                                vel.0,
+                                rel_vel,
                                 // TODO: Update to use the quaternion.
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
@@ -824,12 +836,12 @@ impl FigureMgr {
                                 active_tool_kind,
                                 second_tool_kind,
                                 hands,
-                                vel.0,
+                                rel_vel,
                                 // TODO: Update to use the quaternion.
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                 time,
-                                state.avg_vel,
+                                rel_avg_vel,
                             ),
                             state.state_time,
                             &mut state_animation_rate,
@@ -874,7 +886,7 @@ impl FigureMgr {
                                 (
                                     active_tool_kind,
                                     second_tool_kind,
-                                    vel.0.magnitude(),
+                                    rel_vel.magnitude(),
                                     time,
                                     None,
                                 ),
@@ -902,7 +914,7 @@ impl FigureMgr {
                                 (
                                     active_tool_kind,
                                     second_tool_kind,
-                                    vel.0.magnitude(),
+                                    rel_vel.magnitude(),
                                     // TODO: Update to use the quaternion.
                                     ori * anim::vek::Vec3::<f32>::unit_y(),
                                     state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
@@ -934,7 +946,7 @@ impl FigureMgr {
                                 (
                                     active_tool_kind,
                                     second_tool_kind,
-                                    vel.0.magnitude(),
+                                    rel_vel.magnitude(),
                                     // TODO: Update to use the quaternion.
                                     ori * anim::vek::Vec3::<f32>::unit_y(),
                                     state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
@@ -968,7 +980,7 @@ impl FigureMgr {
                                 (
                                     active_tool_kind,
                                     second_tool_kind,
-                                    vel.0,
+                                    rel_vel,
                                     time,
                                     Some(s.stage_section),
                                 ),
@@ -1001,7 +1013,7 @@ impl FigureMgr {
                                 (
                                     active_tool_kind,
                                     second_tool_kind,
-                                    vel.0,
+                                    rel_vel,
                                     time,
                                     Some(s.stage_section),
                                 ),
@@ -1015,7 +1027,7 @@ impl FigureMgr {
                                 &target_base,
                                 (
                                     active_tool_kind,
-                                    vel.0,
+                                    rel_vel,
                                     // TODO: Update to use the quaternion.
                                     ori * anim::vek::Vec3::<f32>::unit_y(),
                                     state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
@@ -1032,7 +1044,7 @@ impl FigureMgr {
                                 (
                                     active_tool_kind,
                                     second_tool_kind,
-                                    vel.0.magnitude(),
+                                    rel_vel.magnitude(),
                                     time,
                                     None,
                                 ),
@@ -1091,7 +1103,7 @@ impl FigureMgr {
                                     active_tool_kind,
                                     second_tool_kind,
                                     time,
-                                    vel.0.magnitude(),
+                                    rel_vel.magnitude(),
                                     Some(s.stage_section),
                                 ),
                                 stage_progress,
@@ -1158,7 +1170,7 @@ impl FigureMgr {
                                 (
                                     active_tool_kind,
                                     second_tool_kind,
-                                    vel.0,
+                                    rel_vel,
                                     time,
                                     Some(s.stage_section),
                                 ),
@@ -1194,7 +1206,7 @@ impl FigureMgr {
                                 (
                                     active_tool_kind,
                                     second_tool_kind,
-                                    vel.0,
+                                    rel_vel,
                                     time,
                                     Some(s.stage_section),
                                 ),
@@ -1224,7 +1236,7 @@ impl FigureMgr {
                                         (
                                             active_tool_kind,
                                             second_tool_kind,
-                                            vel.0.magnitude(),
+                                            rel_vel.magnitude(),
                                             time,
                                             Some(s.stage_section),
                                             state.state_time,
@@ -1241,7 +1253,7 @@ impl FigureMgr {
                                         (
                                             active_tool_kind,
                                             second_tool_kind,
-                                            vel.0.magnitude(),
+                                            rel_vel.magnitude(),
                                             time,
                                             Some(s.stage_section),
                                             state.state_time,
@@ -1272,7 +1284,7 @@ impl FigureMgr {
                                     active_tool_kind,
                                     second_tool_kind,
                                     time,
-                                    vel.0.magnitude(),
+                                    rel_vel.magnitude(),
                                     Some(s.stage_section),
                                 ),
                                 stage_progress,
@@ -1336,7 +1348,7 @@ impl FigureMgr {
                                     (
                                         active_tool_kind,
                                         second_tool_kind,
-                                        vel.0.magnitude(),
+                                        rel_vel.magnitude(),
                                         time,
                                         Some(s.stage_section),
                                     ),
@@ -1349,7 +1361,7 @@ impl FigureMgr {
                                     (
                                         active_tool_kind,
                                         second_tool_kind,
-                                        vel.0,
+                                        rel_vel,
                                         time,
                                         Some(s.stage_section),
                                     ),
@@ -1362,7 +1374,7 @@ impl FigureMgr {
                                     (
                                         active_tool_kind,
                                         second_tool_kind,
-                                        vel.0.magnitude(),
+                                        rel_vel.magnitude(),
                                         time,
                                         Some(s.stage_section),
                                     ),
@@ -1384,7 +1396,12 @@ impl FigureMgr {
                         CharacterState::Equipping { .. } => {
                             anim::character::EquipAnimation::update_skeleton(
                                 &target_base,
-                                (active_tool_kind, second_tool_kind, vel.0.magnitude(), time),
+                                (
+                                    active_tool_kind,
+                                    second_tool_kind,
+                                    rel_vel.magnitude(),
+                                    time,
+                                ),
                                 state.state_time,
                                 &mut state_animation_rate,
                                 skeleton_attr,
@@ -1395,7 +1412,7 @@ impl FigureMgr {
                             (
                                 active_tool_kind,
                                 second_tool_kind,
-                                vel.0.magnitude(),
+                                rel_vel.magnitude(),
                                 time,
                                 look_dir,
                             ),
@@ -1407,7 +1424,12 @@ impl FigureMgr {
                             if physics.in_liquid.is_some() {
                                 anim::character::SwimWieldAnimation::update_skeleton(
                                     &target_base,
-                                    (active_tool_kind, second_tool_kind, vel.0.magnitude(), time),
+                                    (
+                                        active_tool_kind,
+                                        second_tool_kind,
+                                        rel_vel.magnitude(),
+                                        time,
+                                    ),
                                     state.state_time,
                                     &mut state_animation_rate,
                                     skeleton_attr,
@@ -1422,7 +1444,7 @@ impl FigureMgr {
                                         ori * anim::vek::Vec3::<f32>::unit_y(),
                                         state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                         look_dir,
-                                        vel.0,
+                                        rel_vel,
                                         time,
                                     ),
                                     state.state_time,
@@ -1437,7 +1459,7 @@ impl FigureMgr {
                                 (
                                     active_tool_kind,
                                     second_tool_kind,
-                                    vel.0,
+                                    rel_vel,
                                     // TODO: Update to use the quaternion.
                                     ori * anim::vek::Vec3::<f32>::unit_y(),
                                     state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
@@ -1454,7 +1476,7 @@ impl FigureMgr {
                                 (
                                     active_tool_kind,
                                     second_tool_kind,
-                                    vel.0,
+                                    rel_vel,
                                     // TODO: Update to use the quaternion.
                                     ori * anim::vek::Vec3::<f32>::unit_y(),
                                     time,
@@ -1479,7 +1501,7 @@ impl FigureMgr {
                                 (
                                     active_tool_kind,
                                     second_tool_kind,
-                                    vel.0,
+                                    rel_vel,
                                     // TODO: Update to use the quaternion.
                                     ori * anim::vek::Vec3::<f32>::unit_y(),
                                     state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
@@ -1518,6 +1540,7 @@ impl FigureMgr {
                         camera,
                         &mut update_buf,
                         terrain,
+                        physics.ground_vel,
                     );
                 },
                 Body::QuadrupedSmall(body) => {
@@ -1541,6 +1564,9 @@ impl FigureMgr {
                             FigureState::new(renderer, QuadrupedSmallSkeleton::default())
                         });
 
+                    // Average velocity relative to the current ground
+                    let rel_avg_vel = state.avg_vel - physics.ground_vel;
+
                     let (character, last_character) = match (character, last_character) {
                         (Some(c), Some(l)) => (c, l),
                         _ => continue,
@@ -1552,8 +1578,8 @@ impl FigureMgr {
 
                     let target_base = match (
                         physics.on_ground,
-                        vel.0.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
-                        physics.in_liquid.is_some(),                      // In water
+                        rel_vel.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
+                        physics.in_liquid.is_some(),                        // In water
                     ) {
                         // Standing
                         (true, false, false) => {
@@ -1570,12 +1596,12 @@ impl FigureMgr {
                             anim::quadruped_small::RunAnimation::update_skeleton(
                                 &QuadrupedSmallSkeleton::default(),
                                 (
-                                    vel.0.magnitude(),
+                                    rel_vel.magnitude(),
                                     // TODO: Update to use the quaternion.
                                     ori * anim::vek::Vec3::<f32>::unit_y(),
                                     state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                     time,
-                                    state.avg_vel,
+                                    rel_avg_vel,
                                     state.acc_vel,
                                 ),
                                 state.state_time,
@@ -1587,12 +1613,12 @@ impl FigureMgr {
                         (false, _, true) => anim::quadruped_small::RunAnimation::update_skeleton(
                             &QuadrupedSmallSkeleton::default(),
                             (
-                                vel.0.magnitude(),
+                                rel_vel.magnitude(),
                                 // TODO: Update to use the quaternion.
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                 time,
-                                state.avg_vel,
+                                rel_avg_vel,
                                 state.acc_vel,
                             ),
                             state.state_time,
@@ -1602,7 +1628,7 @@ impl FigureMgr {
                         // In air
                         (false, _, false) => anim::quadruped_small::JumpAnimation::update_skeleton(
                             &QuadrupedSmallSkeleton::default(),
-                            (vel.0.magnitude(), time),
+                            (rel_vel.magnitude(), time),
                             state.state_time,
                             &mut state_animation_rate,
                             skeleton_attr,
@@ -1644,7 +1670,7 @@ impl FigureMgr {
                                 anim::quadruped_small::AlphaAnimation::update_skeleton(
                                     &target_base,
                                     (
-                                        vel.0.magnitude(),
+                                        rel_vel.magnitude(),
                                         time,
                                         Some(s.stage_section),
                                         state.state_time,
@@ -1675,7 +1701,7 @@ impl FigureMgr {
                                     anim::quadruped_small::StunnedAnimation::update_skeleton(
                                         &target_base,
                                         (
-                                            vel.0.magnitude(),
+                                            rel_vel.magnitude(),
                                             time,
                                             Some(s.stage_section),
                                             state.state_time,
@@ -1716,6 +1742,7 @@ impl FigureMgr {
                         camera,
                         &mut update_buf,
                         terrain,
+                        physics.ground_vel,
                     );
                 },
                 Body::QuadrupedMedium(body) => {
@@ -1739,6 +1766,9 @@ impl FigureMgr {
                             FigureState::new(renderer, QuadrupedMediumSkeleton::default())
                         });
 
+                    // Average velocity relative to the current ground
+                    let rel_avg_vel = state.avg_vel - physics.ground_vel;
+
                     let (character, last_character) = match (character, last_character) {
                         (Some(c), Some(l)) => (c, l),
                         _ => continue,
@@ -1750,8 +1780,8 @@ impl FigureMgr {
 
                     let target_base = match (
                         physics.on_ground,
-                        vel.0.magnitude_squared() > 0.25, // Moving
-                        physics.in_liquid.is_some(),      // In water
+                        rel_vel.magnitude_squared() > 0.25, // Moving
+                        physics.in_liquid.is_some(),        // In water
                     ) {
                         // Standing
                         (true, false, false) => {
@@ -1768,12 +1798,12 @@ impl FigureMgr {
                             anim::quadruped_medium::RunAnimation::update_skeleton(
                                 &QuadrupedMediumSkeleton::default(),
                                 (
-                                    vel.0.magnitude(),
+                                    rel_vel.magnitude(),
                                     // TODO: Update to use the quaternion.
                                     ori * anim::vek::Vec3::<f32>::unit_y(),
                                     state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                     time,
-                                    state.avg_vel,
+                                    rel_avg_vel,
                                     state.acc_vel,
                                 ),
                                 state.state_time,
@@ -1785,12 +1815,12 @@ impl FigureMgr {
                         (false, _, true) => anim::quadruped_medium::RunAnimation::update_skeleton(
                             &QuadrupedMediumSkeleton::default(),
                             (
-                                vel.0.magnitude(),
+                                rel_vel.magnitude(),
                                 // TODO: Update to use the quaternion.
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                 time,
-                                state.avg_vel,
+                                rel_avg_vel,
                                 state.acc_vel,
                             ),
                             state.state_time,
@@ -1835,7 +1865,7 @@ impl FigureMgr {
                             anim::quadruped_medium::HoofAnimation::update_skeleton(
                                 &target_base,
                                 (
-                                    vel.0.magnitude(),
+                                    rel_vel.magnitude(),
                                     time,
                                     Some(s.stage_section),
                                     state.state_time,
@@ -1863,7 +1893,7 @@ impl FigureMgr {
                             anim::quadruped_medium::DashAnimation::update_skeleton(
                                 &target_base,
                                 (
-                                    vel.0.magnitude(),
+                                    rel_vel.magnitude(),
                                     time,
                                     Some(s.stage_section),
                                     state.state_time,
@@ -1893,7 +1923,7 @@ impl FigureMgr {
                             anim::quadruped_medium::LeapMeleeAnimation::update_skeleton(
                                 &target_base,
                                 (
-                                    vel.0.magnitude(),
+                                    rel_vel.magnitude(),
                                     time,
                                     Some(s.stage_section),
                                     state.state_time,
@@ -1931,7 +1961,7 @@ impl FigureMgr {
                                 1 => anim::quadruped_medium::AlphaAnimation::update_skeleton(
                                     &target_base,
                                     (
-                                        vel.0.magnitude(),
+                                        rel_vel.magnitude(),
                                         time,
                                         Some(s.stage_section),
                                         state.state_time,
@@ -1943,7 +1973,7 @@ impl FigureMgr {
                                 2 => anim::quadruped_medium::BetaAnimation::update_skeleton(
                                     &target_base,
                                     (
-                                        vel.0.magnitude(),
+                                        rel_vel.magnitude(),
                                         time,
                                         Some(s.stage_section),
                                         state.state_time,
@@ -1955,7 +1985,7 @@ impl FigureMgr {
                                 _ => anim::quadruped_medium::AlphaAnimation::update_skeleton(
                                     &target_base,
                                     (
-                                        vel.0.magnitude(),
+                                        rel_vel.magnitude(),
                                         time,
                                         Some(s.stage_section),
                                         state.state_time,
@@ -1984,7 +2014,7 @@ impl FigureMgr {
                                     anim::quadruped_medium::StunnedAnimation::update_skeleton(
                                         &target_base,
                                         (
-                                            vel.0.magnitude(),
+                                            rel_vel.magnitude(),
                                             time,
                                             Some(s.stage_section),
                                             state.state_time,
@@ -1998,7 +2028,7 @@ impl FigureMgr {
                                     anim::quadruped_medium::StunnedAnimation::update_skeleton(
                                         &target_base,
                                         (
-                                            vel.0.magnitude(),
+                                            rel_vel.magnitude(),
                                             time,
                                             Some(s.stage_section),
                                             state.state_time,
@@ -2039,6 +2069,7 @@ impl FigureMgr {
                         camera,
                         &mut update_buf,
                         terrain,
+                        physics.ground_vel,
                     );
                 },
                 Body::QuadrupedLow(body) => {
@@ -2062,6 +2093,9 @@ impl FigureMgr {
                             FigureState::new(renderer, QuadrupedLowSkeleton::default())
                         });
 
+                    // Average velocity relative to the current ground
+                    let rel_avg_vel = state.avg_vel - physics.ground_vel;
+
                     let (character, last_character) = match (character, last_character) {
                         (Some(c), Some(l)) => (c, l),
                         _ => continue,
@@ -2073,8 +2107,8 @@ impl FigureMgr {
 
                     let target_base = match (
                         physics.on_ground,
-                        vel.0.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
-                        physics.in_liquid.is_some(),                      // In water
+                        rel_vel.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
+                        physics.in_liquid.is_some(),                        // In water
                     ) {
                         // Standing
                         (true, false, false) => {
@@ -2090,12 +2124,12 @@ impl FigureMgr {
                         (true, true, false) => anim::quadruped_low::RunAnimation::update_skeleton(
                             &QuadrupedLowSkeleton::default(),
                             (
-                                vel.0.magnitude(),
+                                rel_vel.magnitude(),
                                 // TODO: Update to use the quaternion.
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                 time,
-                                state.avg_vel,
+                                rel_avg_vel,
                                 state.acc_vel,
                             ),
                             state.state_time,
@@ -2106,12 +2140,12 @@ impl FigureMgr {
                         (false, _, true) => anim::quadruped_low::RunAnimation::update_skeleton(
                             &QuadrupedLowSkeleton::default(),
                             (
-                                vel.0.magnitude(),
+                                rel_vel.magnitude(),
                                 // TODO: Update to use the quaternion.
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                 time,
-                                state.avg_vel,
+                                rel_avg_vel,
                                 state.acc_vel,
                             ),
                             state.state_time,
@@ -2121,7 +2155,7 @@ impl FigureMgr {
                         // In air
                         (false, _, false) => anim::quadruped_low::JumpAnimation::update_skeleton(
                             &QuadrupedLowSkeleton::default(),
-                            (vel.0.magnitude(), time),
+                            (rel_vel.magnitude(), time),
                             state.state_time,
                             &mut state_animation_rate,
                             skeleton_attr,
@@ -2150,7 +2184,7 @@ impl FigureMgr {
                             };
                             anim::quadruped_low::ShootAnimation::update_skeleton(
                                 &target_base,
-                                (vel.0.magnitude(), time, Some(s.stage_section)),
+                                (rel_vel.magnitude(), time, Some(s.stage_section)),
                                 stage_progress,
                                 &mut state_animation_rate,
                                 skeleton_attr,
@@ -2175,7 +2209,7 @@ impl FigureMgr {
                             anim::quadruped_low::BetaAnimation::update_skeleton(
                                 &target_base,
                                 (
-                                    vel.0.magnitude(),
+                                    rel_vel.magnitude(),
                                     time,
                                     Some(s.stage_section),
                                     state.state_time,
@@ -2205,7 +2239,7 @@ impl FigureMgr {
                             anim::quadruped_low::TailwhipAnimation::update_skeleton(
                                 &target_base,
                                 (
-                                    vel.0.magnitude(),
+                                    rel_vel.magnitude(),
                                     time,
                                     Some(s.stage_section),
                                     state.state_time,
@@ -2233,7 +2267,7 @@ impl FigureMgr {
                                     anim::quadruped_low::StunnedAnimation::update_skeleton(
                                         &target_base,
                                         (
-                                            vel.0.magnitude(),
+                                            rel_vel.magnitude(),
                                             time,
                                             Some(s.stage_section),
                                             state.state_time,
@@ -2247,7 +2281,7 @@ impl FigureMgr {
                                     anim::quadruped_low::StunnedAnimation::update_skeleton(
                                         &target_base,
                                         (
-                                            vel.0.magnitude(),
+                                            rel_vel.magnitude(),
                                             time,
                                             Some(s.stage_section),
                                             state.state_time,
@@ -2287,7 +2321,7 @@ impl FigureMgr {
                                 1 => anim::quadruped_low::AlphaAnimation::update_skeleton(
                                     &target_base,
                                     (
-                                        vel.0.magnitude(),
+                                        rel_vel.magnitude(),
                                         time,
                                         Some(s.stage_section),
                                         state.state_time,
@@ -2299,7 +2333,7 @@ impl FigureMgr {
                                 2 => anim::quadruped_low::BetaAnimation::update_skeleton(
                                     &target_base,
                                     (
-                                        vel.0.magnitude(),
+                                        rel_vel.magnitude(),
                                         time,
                                         Some(s.stage_section),
                                         state.state_time,
@@ -2311,7 +2345,7 @@ impl FigureMgr {
                                 _ => anim::quadruped_low::AlphaAnimation::update_skeleton(
                                     &target_base,
                                     (
-                                        vel.0.magnitude(),
+                                        rel_vel.magnitude(),
                                         time,
                                         Some(s.stage_section),
                                         state.state_time,
@@ -2337,7 +2371,7 @@ impl FigureMgr {
                             anim::quadruped_low::BreatheAnimation::update_skeleton(
                                 &target_base,
                                 (
-                                    vel.0.magnitude(),
+                                    rel_vel.magnitude(),
                                     time,
                                     Some(s.stage_section),
                                     state.state_time,
@@ -2365,7 +2399,7 @@ impl FigureMgr {
                             anim::quadruped_low::DashAnimation::update_skeleton(
                                 &target_base,
                                 (
-                                    vel.0.magnitude(),
+                                    rel_vel.magnitude(),
                                     time,
                                     Some(s.stage_section),
                                     state.state_time,
@@ -2395,6 +2429,7 @@ impl FigureMgr {
                         camera,
                         &mut update_buf,
                         terrain,
+                        physics.ground_vel,
                     );
                 },
                 Body::BirdMedium(body) => {
@@ -2417,6 +2452,9 @@ impl FigureMgr {
                             FigureState::new(renderer, BirdMediumSkeleton::default())
                         });
 
+                    // Average velocity relative to the current ground
+                    let _rel_avg_vel = state.avg_vel - physics.ground_vel;
+
                     let (character, last_character) = match (character, last_character) {
                         (Some(c), Some(l)) => (c, l),
                         _ => continue,
@@ -2428,8 +2466,8 @@ impl FigureMgr {
 
                     let target_base = match (
                         physics.on_ground,
-                        vel.0.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
-                        physics.in_liquid.is_some(),                      // In water
+                        rel_vel.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
+                        physics.in_liquid.is_some(),                        // In water
                     ) {
                         // Standing
                         (true, false, false) => anim::bird_medium::IdleAnimation::update_skeleton(
@@ -2442,7 +2480,7 @@ impl FigureMgr {
                         // Running
                         (true, true, false) => anim::bird_medium::RunAnimation::update_skeleton(
                             &BirdMediumSkeleton::default(),
-                            (vel.0.magnitude(), time),
+                            (rel_vel.magnitude(), time),
                             state.state_time,
                             &mut state_animation_rate,
                             skeleton_attr,
@@ -2450,7 +2488,7 @@ impl FigureMgr {
                         // Running
                         (false, _, true) => anim::bird_medium::RunAnimation::update_skeleton(
                             &BirdMediumSkeleton::default(),
-                            (vel.0.magnitude(), time),
+                            (rel_vel.magnitude(), time),
                             state.state_time,
                             &mut state_animation_rate,
                             skeleton_attr,
@@ -2458,7 +2496,7 @@ impl FigureMgr {
                         // In air
                         (false, _, false) => anim::bird_medium::FlyAnimation::update_skeleton(
                             &BirdMediumSkeleton::default(),
-                            (vel.0.magnitude(), time),
+                            (rel_vel.magnitude(), time),
                             state.state_time,
                             &mut state_animation_rate,
                             skeleton_attr,
@@ -2501,6 +2539,7 @@ impl FigureMgr {
                         camera,
                         &mut update_buf,
                         terrain,
+                        physics.ground_vel,
                     );
                 },
                 Body::FishMedium(body) => {
@@ -2523,6 +2562,9 @@ impl FigureMgr {
                             FigureState::new(renderer, FishMediumSkeleton::default())
                         });
 
+                    // Average velocity relative to the current ground
+                    let rel_avg_vel = state.avg_vel - physics.ground_vel;
+
                     let (character, last_character) = match (character, last_character) {
                         (Some(c), Some(l)) => (c, l),
                         _ => continue,
@@ -2534,19 +2576,19 @@ impl FigureMgr {
 
                     let target_base = match (
                         physics.on_ground,
-                        vel.0.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
-                        physics.in_liquid.is_some(),                      // In water
+                        rel_vel.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
+                        physics.in_liquid.is_some(),                        // In water
                     ) {
                         // Idle
                         (_, false, _) => anim::fish_medium::IdleAnimation::update_skeleton(
                             &FishMediumSkeleton::default(),
                             (
-                                vel.0,
+                                rel_vel,
                                 // TODO: Update to use the quaternion.
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                 time,
-                                state.avg_vel,
+                                rel_avg_vel,
                             ),
                             state.state_time,
                             &mut state_animation_rate,
@@ -2556,12 +2598,12 @@ impl FigureMgr {
                         (_, true, _) => anim::fish_medium::SwimAnimation::update_skeleton(
                             &FishMediumSkeleton::default(),
                             (
-                                vel.0,
+                                rel_vel,
                                 // TODO: Update to use the quaternion.
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                 time,
-                                state.avg_vel,
+                                rel_avg_vel,
                                 state.acc_vel,
                             ),
                             state.state_time,
@@ -2586,6 +2628,7 @@ impl FigureMgr {
                         camera,
                         &mut update_buf,
                         terrain,
+                        physics.ground_vel,
                     );
                 },
                 Body::BipedSmall(body) => {
@@ -2608,6 +2651,9 @@ impl FigureMgr {
                             FigureState::new(renderer, BipedSmallSkeleton::default())
                         });
 
+                    // Average velocity relative to the current ground
+                    let rel_avg_vel = state.avg_vel - physics.ground_vel;
+
                     let (character, last_character) = match (character, last_character) {
                         (Some(c), Some(l)) => (c, l),
                         _ => continue,
@@ -2619,18 +2665,18 @@ impl FigureMgr {
 
                     let target_base = match (
                         physics.on_ground,
-                        vel.0.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
-                        physics.in_liquid.is_some(),                      // In water
+                        rel_vel.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
+                        physics.in_liquid.is_some(),                        // In water
                     ) {
                         // Idle
                         (true, false, false) => anim::biped_small::IdleAnimation::update_skeleton(
                             &BipedSmallSkeleton::default(),
                             (
-                                vel.0,
+                                rel_vel,
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                 time,
-                                state.avg_vel,
+                                rel_avg_vel,
                             ),
                             state.state_time,
                             &mut state_animation_rate,
@@ -2640,11 +2686,11 @@ impl FigureMgr {
                         (true, true, _) => anim::biped_small::RunAnimation::update_skeleton(
                             &BipedSmallSkeleton::default(),
                             (
-                                vel.0,
+                                rel_vel,
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                 time,
-                                state.avg_vel,
+                                rel_avg_vel,
                                 state.acc_vel,
                             ),
                             state.state_time,
@@ -2655,11 +2701,11 @@ impl FigureMgr {
                         (false, _, false) => anim::biped_small::RunAnimation::update_skeleton(
                             &BipedSmallSkeleton::default(),
                             (
-                                vel.0,
+                                rel_vel,
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                 time,
-                                state.avg_vel,
+                                rel_avg_vel,
                                 state.acc_vel,
                             ),
                             state.state_time,
@@ -2670,11 +2716,11 @@ impl FigureMgr {
                         (false, _, true) => anim::biped_small::RunAnimation::update_skeleton(
                             &BipedSmallSkeleton::default(),
                             (
-                                vel.0,
+                                rel_vel,
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                 time,
-                                state.avg_vel,
+                                rel_avg_vel,
                                 state.acc_vel,
                             ),
                             state.state_time,
@@ -2684,11 +2730,11 @@ impl FigureMgr {
                         _ => anim::biped_small::IdleAnimation::update_skeleton(
                             &BipedSmallSkeleton::default(),
                             (
-                                vel.0,
+                                rel_vel,
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                 time,
-                                state.avg_vel,
+                                rel_avg_vel,
                             ),
                             state.state_time,
                             &mut state_animation_rate,
@@ -2702,11 +2748,11 @@ impl FigureMgr {
                                 &target_base,
                                 (
                                     active_tool_kind,
-                                    vel.0,
+                                    rel_vel,
                                     ori * anim::vek::Vec3::<f32>::unit_y(),
                                     state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                     time,
-                                    state.avg_vel,
+                                    rel_avg_vel,
                                     state.acc_vel,
                                 ),
                                 state.state_time,
@@ -2734,11 +2780,11 @@ impl FigureMgr {
                             anim::biped_small::DashAnimation::update_skeleton(
                                 &target_base,
                                 (
-                                    vel.0,
+                                    rel_vel,
                                     ori * anim::vek::Vec3::<f32>::unit_y(),
                                     state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                     time,
-                                    state.avg_vel,
+                                    rel_avg_vel,
                                     state.acc_vel,
                                     Some(s.stage_section),
                                     state.state_time,
@@ -2804,11 +2850,11 @@ impl FigureMgr {
                                 &target_base,
                                 (
                                     active_tool_kind,
-                                    vel.0,
+                                    rel_vel,
                                     ori * anim::vek::Vec3::<f32>::unit_y(),
                                     state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                     time,
-                                    state.avg_vel,
+                                    rel_avg_vel,
                                     state.acc_vel,
                                     Some(s.stage_section),
                                     state.state_time,
@@ -2835,11 +2881,11 @@ impl FigureMgr {
                                 &target_base,
                                 (
                                     active_tool_kind,
-                                    vel.0,
+                                    rel_vel,
                                     ori * anim::vek::Vec3::<f32>::unit_y(),
                                     state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                     time,
-                                    state.avg_vel,
+                                    rel_avg_vel,
                                     state.acc_vel,
                                     Some(s.stage_section),
                                     state.state_time,
@@ -2877,11 +2923,11 @@ impl FigureMgr {
                                 1 => anim::biped_small::AlphaAnimation::update_skeleton(
                                     &target_base,
                                     (
-                                        vel.0,
+                                        rel_vel,
                                         ori * anim::vek::Vec3::<f32>::unit_y(),
                                         state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                         time,
-                                        state.avg_vel,
+                                        rel_avg_vel,
                                         state.acc_vel,
                                         Some(s.stage_section),
                                         state.state_time,
@@ -2893,11 +2939,11 @@ impl FigureMgr {
                                 _ => anim::biped_small::AlphaAnimation::update_skeleton(
                                     &target_base,
                                     (
-                                        vel.0,
+                                        rel_vel,
                                         ori * anim::vek::Vec3::<f32>::unit_y(),
                                         state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                         time,
-                                        state.avg_vel,
+                                        rel_avg_vel,
                                         state.acc_vel,
                                         Some(s.stage_section),
                                         state.state_time,
@@ -2928,6 +2974,7 @@ impl FigureMgr {
                         camera,
                         &mut update_buf,
                         terrain,
+                        physics.ground_vel,
                     );
                 },
                 Body::Dragon(body) => {
@@ -2947,6 +2994,9 @@ impl FigureMgr {
                             FigureState::new(renderer, DragonSkeleton::default())
                         });
 
+                    // Average velocity relative to the current ground
+                    let rel_avg_vel = state.avg_vel - physics.ground_vel;
+
                     let (character, last_character) = match (character, last_character) {
                         (Some(c), Some(l)) => (c, l),
                         _ => continue,
@@ -2958,8 +3008,8 @@ impl FigureMgr {
 
                     let target_base = match (
                         physics.on_ground,
-                        vel.0.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
-                        physics.in_liquid.is_some(),                      // In water
+                        rel_vel.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
+                        physics.in_liquid.is_some(),                        // In water
                     ) {
                         // Standing
                         (true, false, false) => anim::dragon::IdleAnimation::update_skeleton(
@@ -2973,12 +3023,12 @@ impl FigureMgr {
                         (true, true, false) => anim::dragon::RunAnimation::update_skeleton(
                             &DragonSkeleton::default(),
                             (
-                                vel.0.magnitude(),
+                                rel_vel.magnitude(),
                                 // TODO: Update to use the quaternion.
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                 time,
-                                state.avg_vel,
+                                rel_avg_vel,
                             ),
                             state.state_time,
                             &mut state_animation_rate,
@@ -2987,7 +3037,7 @@ impl FigureMgr {
                         // In air
                         (false, _, false) => anim::dragon::FlyAnimation::update_skeleton(
                             &DragonSkeleton::default(),
-                            (vel.0.magnitude(), time),
+                            (rel_vel.magnitude(), time),
                             state.state_time,
                             &mut state_animation_rate,
                             skeleton_attr,
@@ -3018,6 +3068,7 @@ impl FigureMgr {
                         camera,
                         &mut update_buf,
                         terrain,
+                        physics.ground_vel,
                     );
                 },
                 Body::Theropod(body) => {
@@ -3038,6 +3089,9 @@ impl FigureMgr {
                         .entry(entity)
                         .or_insert_with(|| FigureState::new(renderer, TheropodSkeleton::default()));
 
+                    // Average velocity relative to the current ground
+                    let rel_avg_vel = state.avg_vel - physics.ground_vel;
+
                     let (character, last_character) = match (character, last_character) {
                         (Some(c), Some(l)) => (c, l),
                         _ => continue,
@@ -3049,8 +3103,8 @@ impl FigureMgr {
 
                     let target_base = match (
                         physics.on_ground,
-                        vel.0.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
-                        physics.in_liquid.is_some(),                      // In water
+                        rel_vel.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
+                        physics.in_liquid.is_some(),                        // In water
                     ) {
                         // Standing
                         (true, false, false) => anim::theropod::IdleAnimation::update_skeleton(
@@ -3064,12 +3118,12 @@ impl FigureMgr {
                         (true, true, false) => anim::theropod::RunAnimation::update_skeleton(
                             &TheropodSkeleton::default(),
                             (
-                                vel.0,
+                                rel_vel,
                                 // TODO: Update to use the quaternion.
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                 time,
-                                state.avg_vel,
+                                rel_avg_vel,
                                 state.acc_vel,
                             ),
                             state.state_time,
@@ -3080,12 +3134,12 @@ impl FigureMgr {
                         (false, _, false) => anim::theropod::JumpAnimation::update_skeleton(
                             &TheropodSkeleton::default(),
                             (
-                                vel.0.magnitude(),
+                                rel_vel.magnitude(),
                                 // TODO: Update to use the quaternion.
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                 time,
-                                state.avg_vel,
+                                rel_avg_vel,
                             ),
                             state.state_time,
                             &mut state_animation_rate,
@@ -3128,7 +3182,7 @@ impl FigureMgr {
                                 1 => anim::theropod::AlphaAnimation::update_skeleton(
                                     &target_base,
                                     (
-                                        vel.0.magnitude(),
+                                        rel_vel.magnitude(),
                                         time,
                                         Some(s.stage_section),
                                         state.state_time,
@@ -3140,7 +3194,7 @@ impl FigureMgr {
                                 _ => anim::theropod::BetaAnimation::update_skeleton(
                                     &target_base,
                                     (
-                                        vel.0.magnitude(),
+                                        rel_vel.magnitude(),
                                         time,
                                         Some(s.stage_section),
                                         state.state_time,
@@ -3201,6 +3255,7 @@ impl FigureMgr {
                         camera,
                         &mut update_buf,
                         terrain,
+                        physics.ground_vel,
                     );
                 },
                 Body::BirdSmall(body) => {
@@ -3223,6 +3278,9 @@ impl FigureMgr {
                             FigureState::new(renderer, BirdSmallSkeleton::default())
                         });
 
+                    // Average velocity relative to the current ground
+                    let _rel_avg_vel = state.avg_vel - physics.ground_vel;
+
                     let (character, last_character) = match (character, last_character) {
                         (Some(c), Some(l)) => (c, l),
                         _ => continue,
@@ -3234,8 +3292,8 @@ impl FigureMgr {
 
                     let target_base = match (
                         physics.on_ground,
-                        vel.0.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
-                        physics.in_liquid.is_some(),                      // In water
+                        rel_vel.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
+                        physics.in_liquid.is_some(),                        // In water
                     ) {
                         // Standing
                         (true, false, false) => anim::bird_small::IdleAnimation::update_skeleton(
@@ -3248,7 +3306,7 @@ impl FigureMgr {
                         // Running
                         (true, true, false) => anim::bird_small::RunAnimation::update_skeleton(
                             &BirdSmallSkeleton::default(),
-                            (vel.0.magnitude(), time),
+                            (rel_vel.magnitude(), time),
                             state.state_time,
                             &mut state_animation_rate,
                             skeleton_attr,
@@ -3256,7 +3314,7 @@ impl FigureMgr {
                         // In air
                         (false, _, false) => anim::bird_small::JumpAnimation::update_skeleton(
                             &BirdSmallSkeleton::default(),
-                            (vel.0.magnitude(), time),
+                            (rel_vel.magnitude(), time),
                             state.state_time,
                             &mut state_animation_rate,
                             skeleton_attr,
@@ -3288,6 +3346,7 @@ impl FigureMgr {
                         camera,
                         &mut update_buf,
                         terrain,
+                        physics.ground_vel,
                     );
                 },
                 Body::FishSmall(body) => {
@@ -3310,6 +3369,9 @@ impl FigureMgr {
                             FigureState::new(renderer, FishSmallSkeleton::default())
                         });
 
+                    // Average velocity relative to the current ground
+                    let rel_avg_vel = state.avg_vel - physics.ground_vel;
+
                     let (character, last_character) = match (character, last_character) {
                         (Some(c), Some(l)) => (c, l),
                         _ => continue,
@@ -3321,19 +3383,19 @@ impl FigureMgr {
 
                     let target_base = match (
                         physics.on_ground,
-                        vel.0.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
-                        physics.in_liquid.is_some(),                      // In water
+                        rel_vel.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
+                        physics.in_liquid.is_some(),                        // In water
                     ) {
                         // Idle
                         (_, false, _) => anim::fish_small::IdleAnimation::update_skeleton(
                             &FishSmallSkeleton::default(),
                             (
-                                vel.0,
+                                rel_vel,
                                 // TODO: Update to use the quaternion.
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                 time,
-                                state.avg_vel,
+                                rel_avg_vel,
                             ),
                             state.state_time,
                             &mut state_animation_rate,
@@ -3343,12 +3405,12 @@ impl FigureMgr {
                         (_, true, _) => anim::fish_small::SwimAnimation::update_skeleton(
                             &FishSmallSkeleton::default(),
                             (
-                                vel.0,
+                                rel_vel,
                                 // TODO: Update to use the quaternion.
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                 time,
-                                state.avg_vel,
+                                rel_avg_vel,
                                 state.acc_vel,
                             ),
                             state.state_time,
@@ -3373,6 +3435,7 @@ impl FigureMgr {
                         camera,
                         &mut update_buf,
                         terrain,
+                        physics.ground_vel,
                     );
                 },
                 Body::BipedLarge(body) => {
@@ -3395,6 +3458,9 @@ impl FigureMgr {
                             FigureState::new(renderer, BipedLargeSkeleton::default())
                         });
 
+                    // Average velocity relative to the current ground
+                    let rel_avg_vel = state.avg_vel - physics.ground_vel;
+
                     let (character, last_character) = match (character, last_character) {
                         (Some(c), Some(l)) => (c, l),
                         _ => continue,
@@ -3406,8 +3472,8 @@ impl FigureMgr {
 
                     let target_base = match (
                         physics.on_ground,
-                        vel.0.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
-                        physics.in_liquid.is_some(),                      // In water
+                        rel_vel.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
+                        physics.in_liquid.is_some(),                        // In water
                     ) {
                         // Running
                         (true, true, false) => anim::biped_large::RunAnimation::update_skeleton(
@@ -3415,12 +3481,12 @@ impl FigureMgr {
                             (
                                 active_tool_kind,
                                 second_tool_kind,
-                                vel.0,
+                                rel_vel,
                                 // TODO: Update to use the quaternion.
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                 time,
-                                state.avg_vel,
+                                rel_avg_vel,
                                 state.acc_vel,
                             ),
                             state.state_time,
@@ -3447,7 +3513,12 @@ impl FigureMgr {
                         CharacterState::Equipping { .. } => {
                             anim::biped_large::EquipAnimation::update_skeleton(
                                 &target_base,
-                                (active_tool_kind, second_tool_kind, vel.0.magnitude(), time),
+                                (
+                                    active_tool_kind,
+                                    second_tool_kind,
+                                    rel_vel.magnitude(),
+                                    time,
+                                ),
                                 state.state_time,
                                 &mut state_animation_rate,
                                 skeleton_attr,
@@ -3459,7 +3530,7 @@ impl FigureMgr {
                                 (
                                     active_tool_kind,
                                     second_tool_kind,
-                                    vel.0,
+                                    rel_vel,
                                     time,
                                     state.acc_vel,
                                 ),
@@ -3474,7 +3545,7 @@ impl FigureMgr {
                                 (
                                     active_tool_kind,
                                     second_tool_kind,
-                                    vel.0,
+                                    rel_vel,
                                     time,
                                     None,
                                     state.acc_vel,
@@ -3503,7 +3574,7 @@ impl FigureMgr {
                                 (
                                     active_tool_kind,
                                     second_tool_kind,
-                                    vel.0,
+                                    rel_vel,
                                     // TODO: Update to use the quaternion.
                                     ori * anim::vek::Vec3::<f32>::unit_y(),
                                     state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
@@ -3535,7 +3606,7 @@ impl FigureMgr {
                                 (
                                     active_tool_kind,
                                     second_tool_kind,
-                                    vel.0,
+                                    rel_vel,
                                     // TODO: Update to use the quaternion.
                                     ori * anim::vek::Vec3::<f32>::unit_y(),
                                     state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
@@ -3570,7 +3641,7 @@ impl FigureMgr {
                                 (
                                     active_tool_kind,
                                     second_tool_kind,
-                                    vel.0,
+                                    rel_vel,
                                     time,
                                     Some(s.stage_section),
                                     state.acc_vel,
@@ -3610,7 +3681,7 @@ impl FigureMgr {
                                     (
                                         active_tool_kind,
                                         second_tool_kind,
-                                        vel.0,
+                                        rel_vel,
                                         time,
                                         Some(s.stage_section),
                                         state.acc_vel,
@@ -3624,7 +3695,7 @@ impl FigureMgr {
                                     (
                                         active_tool_kind,
                                         second_tool_kind,
-                                        vel.0,
+                                        rel_vel,
                                         time,
                                         Some(s.stage_section),
                                         state.acc_vel,
@@ -3638,7 +3709,7 @@ impl FigureMgr {
                                     (
                                         active_tool_kind,
                                         second_tool_kind,
-                                        vel.0,
+                                        rel_vel,
                                         time,
                                         Some(s.stage_section),
                                         state.acc_vel,
@@ -3676,7 +3747,7 @@ impl FigureMgr {
                                 (
                                     active_tool_kind,
                                     second_tool_kind,
-                                    vel.0,
+                                    rel_vel,
                                     time,
                                     Some(s.stage_section),
                                 ),
@@ -3716,7 +3787,7 @@ impl FigureMgr {
                                 (
                                     active_tool_kind,
                                     second_tool_kind,
-                                    vel.0,
+                                    rel_vel,
                                     time,
                                     Some(s.stage_section),
                                 ),
@@ -3745,7 +3816,7 @@ impl FigureMgr {
                                     active_tool_kind,
                                     second_tool_kind,
                                     time,
-                                    vel.0.magnitude(),
+                                    rel_vel.magnitude(),
                                     Some(s.stage_section),
                                 ),
                                 stage_progress,
@@ -3771,7 +3842,7 @@ impl FigureMgr {
                                     active_tool_kind,
                                     second_tool_kind,
                                     time,
-                                    vel.0,
+                                    rel_vel,
                                     Some(s.stage_section),
                                     state.acc_vel,
                                 ),
@@ -3800,6 +3871,7 @@ impl FigureMgr {
                         camera,
                         &mut update_buf,
                         terrain,
+                        physics.ground_vel,
                     );
                 },
                 Body::Golem(body) => {
@@ -3819,6 +3891,9 @@ impl FigureMgr {
                             FigureState::new(renderer, GolemSkeleton::default())
                         });
 
+                    // Average velocity relative to the current ground
+                    let _rel_avg_vel = state.avg_vel - physics.ground_vel;
+
                     let (character, last_character) = match (character, last_character) {
                         (Some(c), Some(l)) => (c, l),
                         _ => continue,
@@ -3830,8 +3905,8 @@ impl FigureMgr {
 
                     let target_base = match (
                         physics.on_ground,
-                        vel.0.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
-                        physics.in_liquid.is_some(),                      // In water
+                        rel_vel.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
+                        physics.in_liquid.is_some(),                        // In water
                     ) {
                         // Standing
                         (true, false, false) => anim::golem::IdleAnimation::update_skeleton(
@@ -3845,7 +3920,7 @@ impl FigureMgr {
                         (true, true, false) => anim::golem::RunAnimation::update_skeleton(
                             &GolemSkeleton::default(),
                             (
-                                vel.0,
+                                rel_vel,
                                 // TODO: Update to use the quaternion.
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
@@ -3860,7 +3935,7 @@ impl FigureMgr {
                         (false, _, false) => anim::golem::RunAnimation::update_skeleton(
                             &GolemSkeleton::default(),
                             (
-                                vel.0,
+                                rel_vel,
                                 ori * anim::vek::Vec3::<f32>::unit_y(),
                                 state.last_ori * anim::vek::Vec3::<f32>::unit_y(),
                                 time,
@@ -3929,7 +4004,7 @@ impl FigureMgr {
                             };
                             anim::golem::ShockwaveAnimation::update_skeleton(
                                 &target_base,
-                                (Some(s.stage_section), vel.0.magnitude(), time),
+                                (Some(s.stage_section), rel_vel.magnitude(), time),
                                 stage_progress,
                                 &mut state_animation_rate,
                                 skeleton_attr,
@@ -3980,6 +4055,7 @@ impl FigureMgr {
                         camera,
                         &mut update_buf,
                         terrain,
+                        physics.ground_vel,
                     );
                 },
                 Body::Object(body) => {
@@ -3999,6 +4075,9 @@ impl FigureMgr {
                             FigureState::new(renderer, ObjectSkeleton::default())
                         });
 
+                    // Average velocity relative to the current ground
+                    let _rel_avg_vel = state.avg_vel - physics.ground_vel;
+
                     let (character, last_character) = match (character, last_character) {
                         (Some(c), Some(l)) => (c, l),
                         _ => (&CharacterState::Idle, &Last {
@@ -4012,8 +4091,8 @@ impl FigureMgr {
 
                     let target_base = match (
                         physics.on_ground,
-                        vel.0.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
-                        physics.in_liquid.is_some(),                      // In water
+                        rel_vel.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
+                        physics.in_liquid.is_some(),                        // In water
                     ) {
                         // Standing
                         (true, false, false) => anim::object::IdleAnimation::update_skeleton(
@@ -4104,6 +4183,86 @@ impl FigureMgr {
                         camera,
                         &mut update_buf,
                         terrain,
+                        physics.ground_vel,
+                    );
+                },
+                Body::Ship(body) => {
+                    let (model, skeleton_attr) = self.ship_model_cache.get_or_create_model(
+                        renderer,
+                        &mut self.col_lights,
+                        *body,
+                        inventory,
+                        tick,
+                        player_camera_mode,
+                        player_character_state,
+                        scene_data.runtime,
+                    );
+
+                    let state = self
+                        .states
+                        .ship_states
+                        .entry(entity)
+                        .or_insert_with(|| FigureState::new(renderer, ShipSkeleton::default()));
+
+                    // Average velocity relative to the current ground
+                    let _rel_avg_vel = state.avg_vel - physics.ground_vel;
+
+                    let (character, last_character) = match (character, last_character) {
+                        (Some(c), Some(l)) => (c, l),
+                        _ => (&CharacterState::Idle, &Last {
+                            0: CharacterState::Idle,
+                        }),
+                    };
+
+                    if !character.same_variant(&last_character.0) {
+                        state.state_time = 0.0;
+                    }
+
+                    let target_base = match (
+                        physics.on_ground,
+                        rel_vel.magnitude_squared() > MOVING_THRESHOLD_SQR, // Moving
+                        physics.in_liquid.is_some(),                        // In water
+                    ) {
+                        // Standing
+                        (true, false, false) => anim::ship::IdleAnimation::update_skeleton(
+                            &ShipSkeleton::default(),
+                            (active_tool_kind, second_tool_kind, time),
+                            state.state_time,
+                            &mut state_animation_rate,
+                            skeleton_attr,
+                        ),
+                        _ => anim::ship::IdleAnimation::update_skeleton(
+                            &ShipSkeleton::default(),
+                            (active_tool_kind, second_tool_kind, time),
+                            state.state_time,
+                            &mut state_animation_rate,
+                            skeleton_attr,
+                        ),
+                    };
+
+                    #[allow(clippy::match_single_binding)]
+                    let target_bones = match &character {
+                        // TODO!
+                        _ => target_base,
+                    };
+
+                    state.skeleton = anim::vek::Lerp::lerp(&state.skeleton, &target_bones, dt_lerp);
+                    state.update(
+                        renderer,
+                        pos.0,
+                        ori,
+                        scale,
+                        col,
+                        dt,
+                        state_animation_rate,
+                        model,
+                        lpindex,
+                        true,
+                        is_player,
+                        camera,
+                        &mut update_buf,
+                        terrain,
+                        physics.ground_vel,
                     );
                 },
             }
@@ -4144,7 +4303,7 @@ impl FigureMgr {
             .join()
             // Don't render dead entities
             .filter(|(_, _, _, _, health, _, _)| health.map_or(true, |h| !h.is_dead))
-            .for_each(|(entity, pos, _, body, _, inventory, _)| {
+            .for_each(|(entity, pos, _, body, _, inventory, scale)| {
                 if let Some((locals, bone_consts, model, _)) = self.get_model_for_render(
                     tick,
                     camera,
@@ -4154,7 +4313,7 @@ impl FigureMgr {
                     inventory,
                     false,
                     pos.0,
-                    figure_lod_render_distance,
+                    figure_lod_render_distance * scale.map_or(1.0, |s| s.0),
                     |state| state.can_shadow_sun(),
                 ) {
                     renderer.render_figure_shadow_directed(
@@ -4186,7 +4345,7 @@ impl FigureMgr {
         let character_state_storage = state.read_storage::<common::comp::CharacterState>();
         let character_state = character_state_storage.get(player_entity);
 
-        for (entity, pos, _, body, _, inventory, _) in (
+        for (entity, pos, _, body, _, inventory, scale) in (
             &ecs.entities(),
             &ecs.read_storage::<Pos>(),
             ecs.read_storage::<Ori>().maybe(),
@@ -4211,7 +4370,7 @@ impl FigureMgr {
                     inventory,
                     false,
                     pos.0,
-                    figure_lod_render_distance,
+                    figure_lod_render_distance * scale.map_or(1.0, |s| s.0),
                     |state| state.visible(),
                 ) {
                     renderer.render_figure(model, &col_lights, global, locals, bone_consts, lod);
@@ -4313,6 +4472,7 @@ impl FigureMgr {
             biped_large_model_cache,
             biped_small_model_cache,
             object_model_cache,
+            ship_model_cache,
             golem_model_cache,
             states:
                 FigureMgrStates {
@@ -4330,6 +4490,7 @@ impl FigureMgr {
                     biped_small_states,
                     golem_states,
                     object_states,
+                    ship_states,
                 },
         } = self;
         let col_lights = &*col_lights_;
@@ -4572,6 +4733,23 @@ impl FigureMgr {
                         ),
                     )
                 }),
+            Body::Ship(body) => ship_states
+                .get(&entity)
+                .filter(|state| filter_state(&*state))
+                .map(move |state| {
+                    (
+                        state.locals(),
+                        state.bone_consts(),
+                        ship_model_cache.get_model(
+                            col_lights,
+                            *body,
+                            inventory,
+                            tick,
+                            player_camera_mode,
+                            character_state,
+                        ),
+                    )
+                }),
         } {
             let model_entry = model_entry?;
 
@@ -4784,6 +4962,7 @@ impl<S: Skeleton> FigureState<S> {
         _camera: &Camera,
         buf: &mut [anim::FigureBoneData; anim::MAX_BONE_COUNT],
         terrain: Option<&Terrain>,
+        ground_vel: Vec3<f32>,
     ) {
         // NOTE: As long as update() always gets called after get_or_create_model(), and
         // visibility is not set again until after the model is rendered, we
@@ -4895,7 +5074,7 @@ impl<S: Skeleton> FigureState<S> {
 
         // Can potentially overflow
         if self.avg_vel.magnitude_squared() != 0.0 {
-            self.acc_vel += self.avg_vel.magnitude() * dt;
+            self.acc_vel += (self.avg_vel - ground_vel).magnitude() * dt;
         } else {
             self.acc_vel = 0.0;
         }
diff --git a/voxygen/src/scene/simple.rs b/voxygen/src/scene/simple.rs
index 2502c6c176..bc735af9e1 100644
--- a/voxygen/src/scene/simple.rs
+++ b/voxygen/src/scene/simple.rs
@@ -199,6 +199,7 @@ impl Scene {
                     &camera,
                     &mut buf,
                     None,
+                    Vec3::zero(),
                 );
                 (model, state)
             }),
@@ -378,6 +379,7 @@ impl Scene {
                 &self.camera,
                 &mut buf,
                 None,
+                Vec3::zero(),
             );
         }
     }
diff --git a/voxygen/src/session.rs b/voxygen/src/session.rs
index 822b3d6156..791db45343 100644
--- a/voxygen/src/session.rs
+++ b/voxygen/src/session.rs
@@ -1562,7 +1562,7 @@ fn under_cursor(
     let player_cylinder = Cylinder::from_components(
         player_pos,
         scales.get(player_entity).copied(),
-        colliders.get(player_entity).copied(),
+        colliders.get(player_entity),
         char_states.get(player_entity),
     );
     let terrain = client.state().terrain();
@@ -1643,7 +1643,7 @@ fn under_cursor(
             let target_cylinder = Cylinder::from_components(
                 p,
                 scales.get(*e).copied(),
-                colliders.get(*e).copied(),
+                colliders.get(*e),
                 char_states.get(*e),
             );
 
@@ -1706,7 +1706,7 @@ fn select_interactable(
             let player_cylinder = Cylinder::from_components(
                 player_pos,
                 scales.get(player_entity).copied(),
-                colliders.get(player_entity).copied(),
+                colliders.get(player_entity),
                 char_states.get(player_entity),
             );
 
@@ -1720,7 +1720,7 @@ fn select_interactable(
                 .join()
                 .filter(|(e, _, _, _, _)| *e != player_entity)
                 .map(|(e, p, s, c, cs)| {
-                    let cylinder = Cylinder::from_components(p.0, s.copied(), c.copied(), cs);
+                    let cylinder = Cylinder::from_components(p.0, s.copied(), c, cs);
                     (e, cylinder)
                 })
                 // Roughly filter out entities farther than interaction distance