diff --git a/crates/asset_game/src/weapon_catalog.rs b/crates/asset_game/src/weapon_catalog.rs
index d6ea6a8..78bcc4c 100644
--- a/crates/asset_game/src/weapon_catalog.rs
+++ b/crates/asset_game/src/weapon_catalog.rs
@@ -217,6 +217,12 @@ pub struct WeaponBodyFacts {
     pub sprint_drop_time_ms: i32,
     pub fuse_time_ms: i32,
 
+    pub auto_aim_range: f32,
+
+    pub aim_assist_range: f32,
+
+    pub aim_assist_range_ads: f32,
+
     pub cook_off_hold: bool,
 
     pub clip_only: bool,
@@ -1729,6 +1735,9 @@ impl WeaponCatalog {
                 sprint_loop_time_ms: geometry.sprint_loop_time_ms,
                 sprint_drop_time_ms: geometry.sprint_drop_time_ms,
                 fuse_time_ms: geometry.fuse_time_ms,
+                auto_aim_range: geometry.auto_aim_range,
+                aim_assist_range: geometry.aim_assist_range,
+                aim_assist_range_ads: geometry.aim_assist_range_ads,
                 cook_off_hold: geometry.cook_off_hold,
                 clip_only: geometry.clip_only,
                 timed_detonation: geometry.timed_detonation,
@@ -4691,6 +4700,11 @@ fn merge_body_facts(dst: &mut WeaponBodyFacts, src: WeaponBodyFacts) {
     if dst.fuse_time_ms == 0 {
         dst.fuse_time_ms = src.fuse_time_ms;
     }
+    if dst.aim_assist_range == 0.0 {
+        dst.auto_aim_range = src.auto_aim_range;
+        dst.aim_assist_range = src.aim_assist_range;
+        dst.aim_assist_range_ads = src.aim_assist_range_ads;
+    }
     if dst.sprint_raise_time_ms == 0 {
         dst.sprint_raise_time_ms = src.sprint_raise_time_ms;
     }
diff --git a/crates/audio/src/rumble.rs b/crates/audio/src/rumble.rs
index 09888b5..1ef441b 100644
--- a/crates/audio/src/rumble.rs
+++ b/crates/audio/src/rumble.rs
@@ -151,8 +151,18 @@ fn update(
     gamepads: Query<Entity, With<Gamepad>>,
     mut state: Local<RumblePlayback>,
     mut output: MessageWriter<GamepadRumbleRequest>,
+    settings: Res<frame::GameSettings>,
+    active: Option<Res<frame::ActivePad>>,
 ) {
     let now = clock.time();
+    if !settings.pad_vibration {
+        for _ in requests.read() {}
+        state.active.clear();
+        if let Some((gamepad, _)) = state.output.take() {
+            output.write(GamepadRumbleRequest::Stop { gamepad });
+        }
+        return;
+    }
     let owner = bank.as_ref().and_then(|bank| {
         let meta = presented.snapshot()?.meta.for_client(local.0)?;
         (meta.lifecycle == sim::ClientLifecycle::Alive).then_some((
@@ -198,7 +208,10 @@ fn update(
         intensity.strong_motor = intensity.strong_motor.max(current.strong_motor);
         intensity.weak_motor = intensity.weak_motor.max(current.weak_motor);
     }
-    let selected = gamepads.iter().min_by_key(|entity| entity.to_bits());
+    let selected = active
+        .and_then(|active| active.0)
+        .filter(|entity| gamepads.contains(*entity))
+        .or_else(|| gamepads.iter().min_by_key(|entity| entity.to_bits()));
     if state
         .output
         .is_some_and(|(entity, _)| Some(entity) != selected)
diff --git a/crates/console/src/binds.rs b/crates/console/src/binds.rs
index 855d183..1542fe2 100644
--- a/crates/console/src/binds.rs
+++ b/crates/console/src/binds.rs
@@ -3,6 +3,7 @@ use input_iw4::{ClientInput, command_id_lookup, command_name, key_event};
 use std::collections::HashMap;
 
 use bevy::input::ButtonInput;
+use bevy::input::gamepad::{Gamepad, GamepadButton};
 use bevy::input::keyboard::KeyCode;
 use bevy::input::mouse::{MouseButton, MouseScrollUnit};
 use bevy::prelude::Resource;
@@ -21,6 +22,174 @@ pub enum BindButton {
     Mouse(MouseButton),
     WheelUp,
     WheelDown,
+    Pad(PadButton),
+}
+
+impl BindButton {
+    pub fn is_pad(self) -> bool {
+        matches!(self, Self::Pad(_))
+    }
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub enum PadButton {
+    A,
+    B,
+    X,
+    Y,
+    LeftBumper,
+    RightBumper,
+    LeftTrigger,
+    RightTrigger,
+    LeftStick,
+    RightStick,
+    DpadUp,
+    DpadDown,
+    DpadLeft,
+    DpadRight,
+    Back,
+    Start,
+}
+
+impl PadButton {
+    pub const ALL: [Self; 16] = [
+        Self::A,
+        Self::B,
+        Self::X,
+        Self::Y,
+        Self::LeftBumper,
+        Self::RightBumper,
+        Self::LeftTrigger,
+        Self::RightTrigger,
+        Self::LeftStick,
+        Self::RightStick,
+        Self::DpadUp,
+        Self::DpadDown,
+        Self::DpadLeft,
+        Self::DpadRight,
+        Self::Back,
+        Self::Start,
+    ];
+
+    pub const fn gamepad_button(self) -> GamepadButton {
+        match self {
+            Self::A => GamepadButton::South,
+            Self::B => GamepadButton::East,
+            Self::X => GamepadButton::West,
+            Self::Y => GamepadButton::North,
+            Self::LeftBumper => GamepadButton::LeftTrigger,
+            Self::RightBumper => GamepadButton::RightTrigger,
+            Self::LeftTrigger => GamepadButton::LeftTrigger2,
+            Self::RightTrigger => GamepadButton::RightTrigger2,
+            Self::LeftStick => GamepadButton::LeftThumb,
+            Self::RightStick => GamepadButton::RightThumb,
+            Self::DpadUp => GamepadButton::DPadUp,
+            Self::DpadDown => GamepadButton::DPadDown,
+            Self::DpadLeft => GamepadButton::DPadLeft,
+            Self::DpadRight => GamepadButton::DPadRight,
+            Self::Back => GamepadButton::Select,
+            Self::Start => GamepadButton::Start,
+        }
+    }
+
+    pub fn from_gamepad_button(button: GamepadButton) -> Option<Self> {
+        Self::ALL
+            .into_iter()
+            .find(|pad| pad.gamepad_button() == button)
+    }
+
+    pub const fn console_name(self) -> &'static str {
+        match self {
+            Self::A => "BUTTON_A",
+            Self::B => "BUTTON_B",
+            Self::X => "BUTTON_X",
+            Self::Y => "BUTTON_Y",
+            Self::LeftBumper => "BUTTON_LSHLDR",
+            Self::RightBumper => "BUTTON_RSHLDR",
+            Self::LeftTrigger => "BUTTON_LTRIG",
+            Self::RightTrigger => "BUTTON_RTRIG",
+            Self::LeftStick => "BUTTON_LSTICK",
+            Self::RightStick => "BUTTON_RSTICK",
+            Self::DpadUp => "DPAD_UP",
+            Self::DpadDown => "DPAD_DOWN",
+            Self::DpadLeft => "DPAD_LEFT",
+            Self::DpadRight => "DPAD_RIGHT",
+            Self::Back => "BUTTON_BACK",
+            Self::Start => "BUTTON_START",
+        }
+    }
+
+    pub const fn label(self) -> &'static str {
+        match self {
+            Self::A => "A",
+            Self::B => "B",
+            Self::X => "X",
+            Self::Y => "Y",
+            Self::LeftBumper => "LB",
+            Self::RightBumper => "RB",
+            Self::LeftTrigger => "LT",
+            Self::RightTrigger => "RT",
+            Self::LeftStick => "LS",
+            Self::RightStick => "RS",
+            Self::DpadUp => "D-UP",
+            Self::DpadDown => "D-DOWN",
+            Self::DpadLeft => "D-LEFT",
+            Self::DpadRight => "D-RIGHT",
+            Self::Back => "BACK",
+            Self::Start => "START",
+        }
+    }
+
+    const fn keynum(self) -> usize {
+        190 + self as usize
+    }
+}
+
+pub fn pad_layout(layout: usize) -> Vec<(PadButton, &'static str)> {
+    use PadButton::*;
+    let mut binds = vec![
+        (RightTrigger, "+attack"),
+        (LeftTrigger, "+speed_throw"),
+        (RightBumper, "+frag"),
+        (LeftBumper, "+smoke"),
+        (A, "+gostand"),
+        (B, "+stance"),
+        (X, "+usereload"),
+        (Y, "weapnext"),
+        (LeftStick, "+breath_sprint"),
+        (RightStick, "+melee"),
+        (DpadUp, "+actionslot 1"),
+        (DpadDown, "+actionslot 2"),
+        (DpadLeft, "+actionslot 3"),
+        (DpadRight, "+actionslot 4"),
+        (Back, "+scores"),
+    ];
+    let mut set = |button: PadButton, command: &'static str| {
+        binds.retain(|(b, _)| *b != button);
+        binds.push((button, command));
+    };
+    let tactical = |set: &mut dyn FnMut(PadButton, &'static str)| {
+        set(B, "+melee");
+        set(RightStick, "+stance");
+    };
+    match layout {
+        1 => tactical(&mut set),
+        2 => {
+            set(LeftTrigger, "+attack");
+            set(RightTrigger, "+speed_throw");
+            set(LeftBumper, "+frag");
+            set(RightBumper, "+smoke");
+        }
+        3 | 4 => {
+            set(LeftBumper, "+gostand");
+            set(A, "+smoke");
+            if layout == 4 {
+                tactical(&mut set);
+            }
+        }
+        _ => {}
+    }
+    binds
 }
 
 pub(crate) fn wheel_button(y: f32) -> Option<BindButton> {
@@ -50,11 +219,21 @@ pub(crate) fn wheel_detents(unit: MouseScrollUnit, y: f32, carry: &mut f32) -> i
 pub struct BindInputs<'a> {
     pub keys: &'a ButtonInput<KeyCode>,
     pub mouse: &'a ButtonInput<MouseButton>,
+    pub pad: Option<&'a Gamepad>,
 }
 
 impl<'a> BindInputs<'a> {
     pub fn new(keys: &'a ButtonInput<KeyCode>, mouse: &'a ButtonInput<MouseButton>) -> Self {
-        Self { keys, mouse }
+        Self {
+            keys,
+            mouse,
+            pad: None,
+        }
+    }
+
+    pub fn with_pad(mut self, pad: Option<&'a Gamepad>) -> Self {
+        self.pad = pad;
+        self
     }
 
     pub fn pressed(&self, button: BindButton) -> bool {
@@ -62,6 +241,9 @@ impl<'a> BindInputs<'a> {
             BindButton::Key(key) => self.keys.pressed(key),
             BindButton::Mouse(btn) => self.mouse.pressed(btn),
             BindButton::WheelUp | BindButton::WheelDown => false,
+            BindButton::Pad(btn) => self
+                .pad
+                .is_some_and(|pad| pad.pressed(btn.gamepad_button())),
         }
     }
 
@@ -70,6 +252,9 @@ impl<'a> BindInputs<'a> {
             BindButton::Key(key) => self.keys.just_pressed(key),
             BindButton::Mouse(btn) => self.mouse.just_pressed(btn),
             BindButton::WheelUp | BindButton::WheelDown => false,
+            BindButton::Pad(btn) => self
+                .pad
+                .is_some_and(|pad| pad.just_pressed(btn.gamepad_button())),
         }
     }
 
@@ -78,6 +263,9 @@ impl<'a> BindInputs<'a> {
             BindButton::Key(key) => self.keys.just_released(key),
             BindButton::Mouse(btn) => self.mouse.just_released(btn),
             BindButton::WheelUp | BindButton::WheelDown => false,
+            BindButton::Pad(btn) => self
+                .pad
+                .is_some_and(|pad| pad.just_released(btn.gamepad_button())),
         }
     }
 }
@@ -91,6 +279,7 @@ impl KeyBinds {
     pub fn apply_defaults(&mut self) {
         self.map.clear();
         let _ = self.apply_script(DEFAULT_CONTROLS);
+        self.apply_pad_layout(0);
     }
 
     pub fn apply_script(&mut self, script: &str) -> Vec<String> {
@@ -154,6 +343,26 @@ impl KeyBinds {
         self.map.clear();
     }
 
+    pub fn clear_command_on(&mut self, id: u32, pad: bool) -> bool {
+        let before = self.map.len();
+        self.map
+            .retain(|button, bound| *bound != id || button.is_pad() != pad);
+        self.map.len() != before
+    }
+
+    pub fn apply_pad_layout(&mut self, layout: usize) {
+        self.map.retain(|button, _| !button.is_pad());
+        for (button, command) in pad_layout(layout) {
+            if let Some(id) = command_id_lookup(command) {
+                self.set(BindButton::Pad(button), id);
+            }
+        }
+    }
+
+    pub fn has_pad_binds(&self) -> bool {
+        self.map.keys().any(|button| button.is_pad())
+    }
+
     pub fn get(&self, button: BindButton) -> Option<u32> {
         self.map.get(&button).copied()
     }
diff --git a/crates/console/src/binds/key_names.rs b/crates/console/src/binds/key_names.rs
index 0deb946..0f930bc 100644
--- a/crates/console/src/binds/key_names.rs
+++ b/crates/console/src/binds/key_names.rs
@@ -33,6 +33,21 @@ macro_rules! key_catalog {
             $( $($m_hint,)? )*
             "mwheelup",
             "mwheeldown",
+            "BUTTON_A",
+            "BUTTON_B",
+            "BUTTON_X",
+            "BUTTON_Y",
+            "BUTTON_LSHLDR",
+            "BUTTON_RSHLDR",
+            "BUTTON_LTRIG",
+            "BUTTON_RTRIG",
+            "BUTTON_LSTICK",
+            "BUTTON_RSTICK",
+            "DPAD_UP",
+            "DPAD_DOWN",
+            "DPAD_LEFT",
+            "DPAD_RIGHT",
+            "BUTTON_BACK",
         ];
 
         pub fn host_keynum(button: BindButton) -> usize {
@@ -43,6 +58,7 @@ macro_rules! key_catalog {
                 },
                 BindButton::WheelUp => 186,
                 BindButton::WheelDown => 187,
+                BindButton::Pad(pad) => pad.keynum(),
                 BindButton::Key(key) => match key {
                     $(KeyCode::$k_button => $k_code,)*
                     _ => 62,
@@ -65,7 +81,13 @@ macro_rules! key_catalog {
                 )*
                 "mwheelup" | "wheelup" => Some(vec![BindButton::WheelUp]),
                 "mwheeldown" | "wheeldown" => Some(vec![BindButton::WheelDown]),
-                _ => None,
+                other => {
+                    let upper = other.to_ascii_uppercase();
+                    super::PadButton::ALL
+                        .into_iter()
+                        .find(|pad| pad.console_name() == upper || pad.label() == upper)
+                        .map(|pad| vec![BindButton::Pad(pad)])
+                }
             }
         }
 
@@ -82,6 +104,7 @@ macro_rules! key_catalog {
                 },
                 BindButton::WheelUp => "MWHEELUP".into(),
                 BindButton::WheelDown => "MWHEELDOWN".into(),
+                BindButton::Pad(pad) => pad.console_name().into(),
             }
         }
 
diff --git a/crates/console/src/gamepad.rs b/crates/console/src/gamepad.rs
new file mode 100644
index 0000000..5538b7b
--- /dev/null
+++ b/crates/console/src/gamepad.rs
@@ -0,0 +1,167 @@
+use bevy::input::gamepad::{Gamepad, GamepadButton, GamepadConnection, GamepadConnectionEvent};
+use bevy::prelude::*;
+use frame::{UiMenuKey, UiMenuRequest};
+
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub(crate) struct Sticks {
+    /// Forward and right.
+    pub movement: Vec2,
+    /// Right and up.
+    pub look: Vec2,
+}
+
+fn radial(stick: Vec2, deadzone: f32) -> Vec2 {
+    let length = stick.length();
+    if length <= deadzone || length <= f32::EPSILON {
+        return Vec2::ZERO;
+    }
+    let scaled = ((length - deadzone) / (1.0 - deadzone).max(0.01)).min(1.0);
+    stick / length * scaled
+}
+
+pub(crate) fn sticks(pad: &Gamepad, settings: &frame::GameSettings) -> Sticks {
+    let left = radial(pad.left_stick(), settings.pad_deadzone_left);
+    let right = radial(pad.right_stick(), settings.pad_deadzone_right);
+    match settings.pad_stick_layout {
+        1 => Sticks {
+            movement: Vec2::new(right.y, right.x),
+            look: left,
+        },
+        2 => Sticks {
+            movement: Vec2::new(left.y, right.x),
+            look: Vec2::new(left.x, right.y),
+        },
+        3 => Sticks {
+            movement: Vec2::new(right.y, left.x),
+            look: Vec2::new(right.x, left.y),
+        },
+        _ => Sticks {
+            movement: Vec2::new(left.y, left.x),
+            look: right,
+        },
+    }
+}
+
+fn curve(deflection: f32, kind: u8) -> f32 {
+    let d = deflection.clamp(0.0, 1.0);
+    match kind {
+        1 => d,
+        2 => 1.0 - (1.0 - d) * (1.0 - d),
+        _ => 0.35 * d + 0.65 * d * d * d,
+    }
+}
+
+pub(crate) fn shaped_look(look: Vec2, settings: &frame::GameSettings) -> Vec2 {
+    let deflection = look.length();
+    if deflection <= f32::EPSILON {
+        return Vec2::ZERO;
+    }
+    let shaped = look / deflection * curve(deflection, settings.pad_curve);
+    Vec2::new(
+        shaped.x,
+        if settings.pad_invert {
+            -shaped.y
+        } else {
+            shaped.y
+        },
+    )
+}
+
+pub(crate) fn track_active_pad(
+    gamepads: Query<(Entity, &Gamepad, Option<&Name>)>,
+    mut connections: MessageReader<GamepadConnectionEvent>,
+    mut active: ResMut<frame::ActivePad>,
+) {
+    for event in connections.read() {
+        match &event.connection {
+            GamepadConnection::Connected { name, .. } => {
+                diag::info!(Ui, "controller connected: {name}");
+            }
+            GamepadConnection::Disconnected => {
+                diag::info!(Ui, "controller disconnected");
+            }
+        }
+    }
+    if active.0.is_some_and(|entity| gamepads.get(entity).is_err()) {
+        active.0 = None;
+    }
+    for (entity, pad, name) in &gamepads {
+        let moved = pad.left_stick().length() > 0.5 || pad.right_stick().length() > 0.5;
+        if (pad.get_just_pressed().next().is_some() || moved) && active.0 != Some(entity) {
+            diag::info!(
+                Ui,
+                "controller in use: {}",
+                name.map_or("unnamed", |n| n.as_str())
+            );
+            active.0 = Some(entity);
+        }
+    }
+}
+
+const REPEAT_DELAY: f32 = 0.4;
+const REPEAT_EVERY: f32 = 0.12;
+
+pub(crate) fn drive_menus_with_pad(
+    gamepads: Query<&Gamepad>,
+    active: Res<frame::ActivePad>,
+    script_menus: Option<Res<hud::ScriptMenus>>,
+    capture: Res<frame::UiBindingCapture>,
+    time: Res<Time>,
+    mut requests: MessageWriter<UiMenuRequest>,
+    mut repeat: Local<Option<(UiMenuKey, f32)>>,
+) {
+    // A binding being listened for takes the controller's buttons itself.
+    let pad = active
+        .0
+        .and_then(|entity| gamepads.get(entity).ok())
+        .filter(|_| capture.command.is_none());
+    let Some(pad) = pad else {
+        *repeat = None;
+        return;
+    };
+    if pad.just_pressed(GamepadButton::Start) {
+        requests.write(UiMenuRequest::Key(UiMenuKey::Escape));
+    }
+    if !script_menus.is_some_and(|menus| menus.captures_input()) {
+        *repeat = None;
+        return;
+    }
+    if pad.just_pressed(GamepadButton::South) {
+        requests.write(UiMenuRequest::Key(UiMenuKey::Enter));
+    }
+    if pad.just_pressed(GamepadButton::East) {
+        requests.write(UiMenuRequest::Key(UiMenuKey::Escape));
+    }
+    let stick = pad.left_stick();
+    let direction = if pad.pressed(GamepadButton::DPadUp) || stick.y > 0.6 {
+        Some(UiMenuKey::Up)
+    } else if pad.pressed(GamepadButton::DPadDown) || stick.y < -0.6 {
+        Some(UiMenuKey::Down)
+    } else if pad.pressed(GamepadButton::DPadLeft) || stick.x < -0.6 {
+        Some(UiMenuKey::Left)
+    } else if pad.pressed(GamepadButton::DPadRight) || stick.x > 0.6 {
+        Some(UiMenuKey::Right)
+    } else {
+        None
+    };
+    let now = time.elapsed_secs();
+    let fire = match (direction, *repeat) {
+        (Some(key), Some((held, next))) if key == held => {
+            if now >= next {
+                *repeat = Some((key, now + REPEAT_EVERY));
+            }
+            now >= next
+        }
+        (Some(key), _) => {
+            *repeat = Some((key, now + REPEAT_DELAY));
+            true
+        }
+        (None, _) => {
+            *repeat = None;
+            false
+        }
+    };
+    if fire && let Some(key) = direction {
+        requests.write(UiMenuRequest::Key(key));
+    }
+}
diff --git a/crates/console/src/lib.rs b/crates/console/src/lib.rs
index dd472eb..31ff273 100644
--- a/crates/console/src/lib.rs
+++ b/crates/console/src/lib.rs
@@ -23,6 +23,7 @@ mod diagnostics;
 pub mod editor;
 mod feature_dispatch;
 mod frontend;
+mod gamepad;
 pub mod input;
 pub mod plugin;
 pub mod registry;
@@ -33,8 +34,8 @@ mod user_settings;
 mod weapon_dispatch;
 
 pub use binds::{
-    BINDABLE_KEYS, BindButton, BindInputs, DEFAULT_CONTROLS, KeyBinds, display_button, host_keynum,
-    parse_button_name, parse_key_name,
+    BINDABLE_KEYS, BindButton, BindInputs, DEFAULT_CONTROLS, KeyBinds, PadButton, display_button,
+    host_keynum, parse_button_name, parse_key_name,
 };
 pub use class_dispatch::class_completions;
 pub use command::{ConsoleCommand, ConsoleQueue, SubmittedCommand};
diff --git a/crates/console/src/plugin/mod.rs b/crates/console/src/plugin/mod.rs
index 4aebe97..fd41898 100644
--- a/crates/console/src/plugin/mod.rs
+++ b/crates/console/src/plugin/mod.rs
@@ -99,6 +99,23 @@ impl Plugin for ConsolePlugin {
                 (setup_console, crate::user_settings::load_user_settings).chain(),
             )
             .add_systems(PreUpdate, feed_console_keyboard.before(InputSystems))
+            .init_resource::<frame::ActivePad>()
+            .add_systems(
+                PreUpdate,
+                (
+                    crate::gamepad::track_active_pad,
+                    crate::gamepad::drive_menus_with_pad,
+                )
+                    .chain()
+                    .after(InputSystems)
+                    .before(publish_client_action_input),
+            )
+            .add_systems(
+                Update,
+                crate::user_settings::apply_pad_layout_setting
+                    .after(crate::user_settings::consume_menu_binding)
+                    .before(crate::user_settings::sync_binding_view),
+            )
             .add_systems(
                 PreUpdate,
                 (
@@ -265,7 +282,21 @@ fn publish_client_action_input(
     mut hud_input: ResMut<frame::HudInputView>,
     settings: Res<frame::GameSettings>,
     mut out: ResMut<ClientActionInput>,
+    (gamepads, active, mut aiming_with_pad): (
+        Query<&bevy::input::gamepad::Gamepad>,
+        Res<frame::ActivePad>,
+        Local<bool>,
+    ),
 ) {
+    let pad = active.0.and_then(|entity| gamepads.get(entity).ok());
+    out.pad_aim_assist = if *aiming_with_pad && pad.is_some() {
+        settings.pad_aim_assist
+    } else {
+        0
+    };
+    out.pad_move = [0.0; 2];
+    out.pad_look = [0.0; 2];
+    out.pad_deflection = 0.0;
     hud_input.console_open = console.open;
     if binds.is_changed() || hud_input.binding_keys.is_empty() {
         hud_input.binding_keys.clear();
@@ -337,7 +368,22 @@ fn publish_client_action_input(
         return;
     }
 
-    let inputs = BindInputs::new(&keys, &mouse_buttons);
+    out.pad_sensitivity = settings.pad_sensitivity / frame::GameSettings::PAD_SENSITIVITY_DEFAULT;
+    out.pad_ads_sensitivity = settings.pad_ads_sensitivity;
+    if let Some(pad) = pad {
+        let sticks = crate::gamepad::sticks(pad, &settings);
+        let look = crate::gamepad::shaped_look(sticks.look, &settings);
+        out.pad_move = [sticks.movement.x, sticks.movement.y];
+        out.pad_look = [look.x, look.y];
+        out.pad_deflection = sticks.movement.x.abs().max(sticks.look.length());
+        if sticks.look.length() > 0.0
+            || sticks.movement.length() > 0.0
+            || pad.get_just_pressed().next().is_some()
+        {
+            *aiming_with_pad = true;
+        }
+    }
+    let inputs = BindInputs::new(&keys, &mouse_buttons).with_pad(pad);
     for (button, id) in binds.iter() {
         let key_num = host_keynum(button);
         if key_num >= input_iw4::KEY_COUNT {
@@ -392,9 +438,14 @@ fn publish_client_action_input(
     let (rx, ry) = scripted.mouse_rate().unwrap_or((0.0, 0.0));
     out.mouse_x += sx + rx;
     out.mouse_y += sy + ry;
+    let mut moved = 0.0;
     for ev in motion.read() {
         out.mouse_x += ev.delta.x;
         out.mouse_y += ev.delta.y;
+        moved += ev.delta.x.abs() + ev.delta.y.abs();
+    }
+    if moved > 2.0 || mouse_buttons.get_just_pressed().next().is_some() {
+        *aiming_with_pad = false;
     }
 }
 
diff --git a/crates/console/src/user_settings.rs b/crates/console/src/user_settings.rs
index 8b588f9..15f661b 100644
--- a/crates/console/src/user_settings.rs
+++ b/crates/console/src/user_settings.rs
@@ -52,6 +52,11 @@ pub(crate) fn consume_menu_binding(
     keys: Res<ButtonInput<KeyCode>>,
     mouse: Res<ButtonInput<MouseButton>>,
     mut wheel: MessageReader<MouseWheel>,
+    (gamepads, active, mut settings): (
+        Query<&bevy::input::gamepad::Gamepad>,
+        Res<frame::ActivePad>,
+        ResMut<frame::GameSettings>,
+    ),
     mut pending: ResMut<PendingMenuBinding>,
     mut capture: ResMut<frame::UiBindingCapture>,
     mut binds: ResMut<KeyBinds>,
@@ -85,7 +90,32 @@ pub(crate) fn consume_menu_binding(
         pending.armed = true;
         return;
     }
-    if keys.just_pressed(KeyCode::Escape) {
+    let pad = active.0.and_then(|entity| gamepads.get(entity).ok());
+    let pad_start =
+        pad.is_some_and(|pad| pad.just_pressed(bevy::input::gamepad::GamepadButton::Start));
+    let pad_button = pad.and_then(|pad| {
+        pad.get_just_pressed()
+            .copied()
+            .filter_map(crate::PadButton::from_gamepad_button)
+            .find(|button| *button != crate::PadButton::Start)
+    });
+    if let Some(button) = pad_button.filter(|_| !pad_start) {
+        capture.command = None;
+        capture.consumed_input = true;
+        binds.clear_command_on(id, true);
+        binds.set(BindButton::Pad(button), id);
+        if settings.pad_layout != frame::GameSettings::PAD_LAYOUT_CUSTOM {
+            settings.pad_layout = frame::GameSettings::PAD_LAYOUT_CUSTOM;
+            settings.touch();
+        }
+        pending.id = None;
+        pending.armed = false;
+        view.listening = None;
+        view.revision = view.revision.wrapping_add(1);
+        return;
+    }
+    // Start cancels, as Escape does, rather than binding.
+    if keys.just_pressed(KeyCode::Escape) || pad_start {
         capture.command = None;
         capture.consumed_input = true;
         pending.id = None;
@@ -110,7 +140,7 @@ pub(crate) fn consume_menu_binding(
     let Some(button) = button else { return };
     capture.command = None;
     capture.consumed_input = true;
-    binds.clear_command(id);
+    binds.clear_command_on(id, false);
     binds.set(button, id);
     pending.id = None;
     pending.armed = false;
@@ -126,15 +156,27 @@ pub(crate) fn sync_binding_view(
     if !binds.is_changed() {
         return;
     }
-    let mut chords = std::collections::BTreeMap::<u32, Vec<String>>::new();
+    let mut chords = std::collections::BTreeMap::<u32, (Vec<String>, Vec<String>)>::new();
     for (button, id) in binds.iter() {
-        chords.entry(id).or_default().push(display_button(button));
+        let (keys, buttons) = chords.entry(id).or_default();
+        match button {
+            BindButton::Pad(pad) => buttons.push(pad.label().to_owned()),
+            _ => keys.push(display_button(button)),
+        }
     }
     view.chords.clear();
-    for (id, mut names) in chords {
-        names.sort();
-        names.dedup();
-        view.chords.insert(id, names.join(" OR "));
+    for (id, (mut keys, mut buttons)) in chords {
+        keys.sort();
+        keys.dedup();
+        buttons.sort();
+        buttons.dedup();
+        let text = match (keys.is_empty(), buttons.is_empty()) {
+            (false, false) => format!("{} | {}", keys.join(" OR "), buttons.join(" OR ")),
+            (false, true) => keys.join(" OR "),
+            (true, false) => buttons.join(" OR "),
+            (true, true) => continue,
+        };
+        view.chords.insert(id, text);
     }
     // Publish every command so removing its last binding clears the old label.
     for (id, command) in input_iw4::INPUT_COMMAND_NAMES.iter().enumerate().skip(1) {
@@ -267,6 +309,28 @@ fn settings_path(artifacts: &std::path::Path) -> Option<PathBuf> {
         .map(|path| path.join("iw4l/settings.cfg"))
 }
 
+pub(crate) fn apply_pad_layout_setting(
+    settings: Res<frame::GameSettings>,
+    mut binds: ResMut<KeyBinds>,
+    mut seen: Local<Option<u8>>,
+) {
+    let layout = settings.pad_layout;
+    let previous = seen.replace(layout);
+    if previous.is_none()
+        || previous == Some(layout)
+        || layout == frame::GameSettings::PAD_LAYOUT_CUSTOM
+    {
+        return;
+    }
+    binds.apply_pad_layout(usize::from(layout));
+}
+
+fn parse_into<T: std::str::FromStr>(value: &str, slot: &mut T) {
+    if let Ok(value) = value.parse() {
+        *slot = value;
+    }
+}
+
 fn serialize_settings(settings: &frame::GameSettings, binds: &KeyBinds) -> String {
     let safe_name = settings.player_name.replace(['\n', '\r', '='], " ");
     let mut lines = vec![
@@ -286,6 +350,16 @@ fn serialize_settings(settings: &frame::GameSettings, binds: &KeyBinds) -> Strin
         format!("sensitivity={:.3}", settings.sensitivity),
         format!("invert_mouse={}", settings.invert_mouse),
         format!("player_name={safe_name}"),
+        format!("pad_layout={}", settings.pad_layout),
+        format!("pad_stick_layout={}", settings.pad_stick_layout),
+        format!("pad_sensitivity={:.2}", settings.pad_sensitivity),
+        format!("pad_ads_sensitivity={:.2}", settings.pad_ads_sensitivity),
+        format!("pad_invert={}", settings.pad_invert),
+        format!("pad_curve={}", settings.pad_curve),
+        format!("pad_aim_assist={}", settings.pad_aim_assist),
+        format!("pad_vibration={}", settings.pad_vibration),
+        format!("pad_deadzone_left={:.2}", settings.pad_deadzone_left),
+        format!("pad_deadzone_right={:.2}", settings.pad_deadzone_right),
         "unbindall".to_owned(),
     ];
     lines.extend(binds.list_lines());
@@ -368,6 +442,16 @@ fn parse_settings(source: &str, settings: &mut frame::GameSettings, binds: &mut
                 }
             }
             "player_name" => settings.player_name = value.to_owned(),
+            "pad_layout" => parse_into(value, &mut settings.pad_layout),
+            "pad_stick_layout" => parse_into(value, &mut settings.pad_stick_layout),
+            "pad_sensitivity" => parse_into(value, &mut settings.pad_sensitivity),
+            "pad_ads_sensitivity" => parse_into(value, &mut settings.pad_ads_sensitivity),
+            "pad_invert" => parse_into(value, &mut settings.pad_invert),
+            "pad_curve" => parse_into(value, &mut settings.pad_curve),
+            "pad_aim_assist" => parse_into(value, &mut settings.pad_aim_assist),
+            "pad_vibration" => parse_into(value, &mut settings.pad_vibration),
+            "pad_deadzone_left" => parse_into(value, &mut settings.pad_deadzone_left),
+            "pad_deadzone_right" => parse_into(value, &mut settings.pad_deadzone_right),
             _ => warn!("ignored unknown setting `{key}`"),
         }
     }
@@ -377,6 +461,10 @@ fn parse_settings(source: &str, settings: &mut frame::GameSettings, binds: &mut
             warn!("settings bind: {warning}");
         }
     }
+    // Settings saved before controller support carry no controller binds.
+    if !binds.has_pad_binds() {
+        binds.apply_pad_layout(usize::from(settings.pad_layout.min(4)));
+    }
     if source
         .lines()
         .next()
@@ -436,6 +524,16 @@ pub(crate) fn native_menu_settings(
             "ui_shadows" => settings.shadows = value == "1",
             "ui_dof" => settings.depth_of_field = value == "1",
             "ui_bloom" => settings.bloom = value == "1",
+            "ui_pad_layout" => parse_into(value, &mut settings.pad_layout),
+            "ui_pad_stick_layout" => parse_into(value, &mut settings.pad_stick_layout),
+            "ui_pad_sensitivity" => parse_into(value, &mut settings.pad_sensitivity),
+            "ui_pad_ads_sensitivity" => parse_into(value, &mut settings.pad_ads_sensitivity),
+            "ui_pad_invert" => settings.pad_invert = value == "1",
+            "ui_pad_curve" => parse_into(value, &mut settings.pad_curve),
+            "ui_pad_aim_assist" => parse_into(value, &mut settings.pad_aim_assist),
+            "ui_pad_vibration" => settings.pad_vibration = value == "1",
+            "ui_pad_deadzone_left" => parse_into(value, &mut settings.pad_deadzone_left),
+            "ui_pad_deadzone_right" => parse_into(value, &mut settings.pad_deadzone_right),
             _ => continue,
         }
         settings.sanitize();
@@ -459,4 +557,26 @@ pub(crate) fn native_menu_settings(
         if settings.fullscreen { "1" } else { "0" },
     );
     dvars.set("ui_r_vsync", if settings.vsync { "1" } else { "0" });
+    dvars.set("ui_pad_layout", settings.pad_layout.to_string());
+    dvars.set("ui_pad_stick_layout", settings.pad_stick_layout.to_string());
+    dvars.set("ui_pad_sensitivity", settings.pad_sensitivity.to_string());
+    dvars.set(
+        "ui_pad_ads_sensitivity",
+        settings.pad_ads_sensitivity.to_string(),
+    );
+    dvars.set("ui_pad_invert", if settings.pad_invert { "1" } else { "0" });
+    dvars.set("ui_pad_curve", settings.pad_curve.to_string());
+    dvars.set("ui_pad_aim_assist", settings.pad_aim_assist.to_string());
+    dvars.set(
+        "ui_pad_vibration",
+        if settings.pad_vibration { "1" } else { "0" },
+    );
+    dvars.set(
+        "ui_pad_deadzone_left",
+        settings.pad_deadzone_left.to_string(),
+    );
+    dvars.set(
+        "ui_pad_deadzone_right",
+        settings.pad_deadzone_right.to_string(),
+    );
 }
diff --git a/crates/fastfile_iw4/src/load/weapon.rs b/crates/fastfile_iw4/src/load/weapon.rs
index fd2ef95..1b7ddcc 100644
--- a/crates/fastfile_iw4/src/load/weapon.rs
+++ b/crates/fastfile_iw4/src/load/weapon.rs
@@ -250,6 +250,9 @@ pub(super) fn load_weapon(s: &mut ZoneStream<'_>, links: &mut dyn AssetLinkSink)
             sprint_loop_time_ms: s.i32_at(body, s.layout(0x2ac, 1012))?,
             sprint_drop_time_ms: s.i32_at(body, s.layout(0x2b0, 1016))?,
             fuse_time_ms: s.i32_at(body, s.layout(0x2d8, 1056))?,
+            auto_aim_range: s.f32_at(body, s.layout(0x2e0, 1064))?,
+            aim_assist_range: s.f32_at(body, s.layout(0x2e4, 1068))?,
+            aim_assist_range_ads: s.f32_at(body, s.layout(0x2e8, 1072))?,
             explosion_radius: s.i32_at(body, s.layout(0x3e8, 1348))?,
             explosion_radius_min: s.i32_at(body, s.layout(0x3ec, 1352))?,
             explosion_inner_damage: s.i32_at(body, s.layout(0x3f0, 1356))?,
@@ -528,6 +531,9 @@ pub(super) fn load_weapon(s: &mut ZoneStream<'_>, links: &mut dyn AssetLinkSink)
         sprint_loop_time_ms: body_facts.sprint_loop_time_ms,
         sprint_drop_time_ms: body_facts.sprint_drop_time_ms,
         fuse_time_ms: body_facts.fuse_time_ms,
+        auto_aim_range: body_facts.auto_aim_range,
+        aim_assist_range: body_facts.aim_assist_range,
+        aim_assist_range_ads: body_facts.aim_assist_range_ads,
         cook_off_hold: body_facts.cook_off_hold,
         clip_only: body_facts.clip_only,
         timed_detonation: body_facts.timed_detonation,
@@ -665,6 +671,9 @@ struct WeapDefScalars {
     sprint_loop_time_ms: i32,
     sprint_drop_time_ms: i32,
     fuse_time_ms: i32,
+    auto_aim_range: f32,
+    aim_assist_range: f32,
+    aim_assist_range_ads: f32,
 
     cook_off_hold: bool,
 
diff --git a/crates/fastfile_iw4/src/zone.rs b/crates/fastfile_iw4/src/zone.rs
index 18ab666..3c3ec99 100644
--- a/crates/fastfile_iw4/src/zone.rs
+++ b/crates/fastfile_iw4/src/zone.rs
@@ -1253,6 +1253,9 @@ pub struct WeaponGeometry {
     pub sprint_drop_time_ms: i32,
 
     pub fuse_time_ms: i32,
+    pub auto_aim_range: f32,
+    pub aim_assist_range: f32,
+    pub aim_assist_range_ads: f32,
 
     pub cook_off_hold: bool,
 
diff --git a/crates/frame/src/lib.rs b/crates/frame/src/lib.rs
index f4a7867..cdbc433 100644
--- a/crates/frame/src/lib.rs
+++ b/crates/frame/src/lib.rs
@@ -1,4 +1,5 @@
 pub mod class_presets;
+pub mod pad;
 pub mod retire;
 pub mod schedule;
 pub mod script_entity_notify;
@@ -8,6 +9,7 @@ pub mod settings;
 pub mod ui;
 
 pub use class_presets::{ClassPreset, pick_showcase, showcase_classes};
+pub use pad::ActivePad;
 pub use retire::Retiring;
 pub use schedule::{
     AUTHORITY_TOC, AuthorityBookkeeping, AuthorityEdge, AuthoritySet, CLIENT_TOC,
diff --git a/crates/frame/src/pad.rs b/crates/frame/src/pad.rs
new file mode 100644
index 0000000..ce55522
--- /dev/null
+++ b/crates/frame/src/pad.rs
@@ -0,0 +1,6 @@
+use bevy::prelude::{Entity, Resource};
+
+/// The last controller pressed or moved, so a virtual joystick or an idle
+/// second pad can stay connected without taking over.
+#[derive(Resource, Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct ActivePad(pub Option<Entity>);
diff --git a/crates/frame/src/settings.rs b/crates/frame/src/settings.rs
index 6c3dcf8..a4f7824 100644
--- a/crates/frame/src/settings.rs
+++ b/crates/frame/src/settings.rs
@@ -38,6 +38,22 @@ pub struct GameSettings {
     pub invert_mouse: bool,
     pub player_name: String,
 
+    /// 0 default, 1 tactical, 2 lefty, 3 bumper jumper, 4 bumper jumper
+    /// tactical, or `PAD_LAYOUT_CUSTOM` once rebound.
+    pub pad_layout: u8,
+    /// 0 default, 1 southpaw, 2 legacy, 3 legacy southpaw.
+    pub pad_stick_layout: u8,
+    pub pad_sensitivity: f32,
+    pub pad_ads_sensitivity: f32,
+    pub pad_invert: bool,
+    /// 0 standard, 1 linear, 2 dynamic.
+    pub pad_curve: u8,
+    /// 0 off, 1 slowdown and lock-on, 2 also auto aim.
+    pub pad_aim_assist: u8,
+    pub pad_vibration: bool,
+    pub pad_deadzone_left: f32,
+    pub pad_deadzone_right: f32,
+
     pub revision: u64,
 }
 
@@ -56,6 +72,16 @@ impl Default for GameSettings {
             sensitivity: 5.0,
             invert_mouse: false,
             player_name: "Player".to_owned(),
+            pad_layout: 0,
+            pad_stick_layout: 0,
+            pad_sensitivity: Self::PAD_SENSITIVITY_DEFAULT,
+            pad_ads_sensitivity: 1.0,
+            pad_invert: false,
+            pad_curve: 0,
+            pad_aim_assist: 1,
+            pad_vibration: true,
+            pad_deadzone_left: 0.12,
+            pad_deadzone_right: 0.12,
             revision: 0,
         }
     }
@@ -65,6 +91,8 @@ impl GameSettings {
     pub const FOV_DEFAULT: f32 = 65.0;
     pub const FOV_MIN: f32 = 65.0;
     pub const FOV_MAX: f32 = 120.0;
+    pub const PAD_SENSITIVITY_DEFAULT: f32 = 3.0;
+    pub const PAD_LAYOUT_CUSTOM: u8 = 255;
 
     pub fn touch(&mut self) {
         self.revision = self.revision.wrapping_add(1);
@@ -85,6 +113,28 @@ impl GameSettings {
         };
         self.master_volume = self.master_volume.clamp(0.0, 1.0);
         self.sensitivity = self.sensitivity.clamp(0.1, 30.0);
+        if self.pad_layout != Self::PAD_LAYOUT_CUSTOM {
+            self.pad_layout = self.pad_layout.min(4);
+        }
+        self.pad_stick_layout = self.pad_stick_layout.min(3);
+        self.pad_curve = self.pad_curve.min(2);
+        self.pad_aim_assist = self.pad_aim_assist.min(2);
+        let finite = |v: f32, lo: f32, hi: f32, default: f32| {
+            if v.is_finite() {
+                v.clamp(lo, hi)
+            } else {
+                default
+            }
+        };
+        self.pad_sensitivity = finite(
+            self.pad_sensitivity,
+            1.0,
+            10.0,
+            Self::PAD_SENSITIVITY_DEFAULT,
+        );
+        self.pad_ads_sensitivity = finite(self.pad_ads_sensitivity, 0.5, 1.5, 1.0);
+        self.pad_deadzone_left = finite(self.pad_deadzone_left, 0.0, 0.4, 0.12);
+        self.pad_deadzone_right = finite(self.pad_deadzone_right, 0.0, 0.4, 0.12);
         self.player_name = self.player_name.trim().chars().take(16).collect();
         if self.player_name.is_empty() {
             self.player_name = "Player".to_owned();
diff --git a/crates/hud/src/menus/mod.rs b/crates/hud/src/menus/mod.rs
index 6cb07af..7b6037e 100644
--- a/crates/hud/src/menus/mod.rs
+++ b/crates/hud/src/menus/mod.rs
@@ -661,15 +661,17 @@ fn handle_input(
     };
 
     if pressed.down {
-        runner.focus_step(&top, 1, false);
+        runner.focus_nav(&top, 0, 1);
     }
     if pressed.up {
-        runner.focus_step(&top, -1, false);
+        runner.focus_nav(&top, 0, -1);
     }
-    if (pressed.left || pressed.right)
-        && let Some(focus) = runner.menus.stack.last().and_then(|m| m.focus)
-    {
-        runner.adjust(&top, focus, if pressed.left { -1 } else { 1 });
+    if pressed.left || pressed.right {
+        let step = if pressed.left { -1 } else { 1 };
+        let focus = runner.menus.stack.last().and_then(|m| m.focus);
+        if !focus.is_some_and(|focus| runner.adjust(&top, focus, step)) {
+            runner.focus_nav(&top, step, 0);
+        }
         return;
     }
     if pressed.enter {
diff --git a/crates/hud/src/menus/runtime.rs b/crates/hud/src/menus/runtime.rs
index 7a9b034..4360900 100644
--- a/crates/hud/src/menus/runtime.rs
+++ b/crates/hud/src/menus/runtime.rs
@@ -491,6 +491,77 @@ impl Runner<'_, '_> {
         self.set_focus(menu, next);
     }
 
+    /// Menu files list items in no particular screen order, so focus moves
+    /// by position: within a column vertically, across columns sideways.
+    pub(crate) fn focus_nav(&mut self, menu: &str, dx: i32, dy: i32) -> bool {
+        let catalog = self.catalog;
+        let Some(def) = catalog.get(menu) else {
+            return false;
+        };
+        let current = self.menus.get_mut(menu).and_then(|m| m.focus);
+        let visible = self.visible_items(menu);
+        let candidates: Vec<(usize, [f32; 4])> = (0..def.items.len())
+            .filter(|&i| is_focusable(&def.items[i]) && visible.contains(&i))
+            .map(|i| (i, nav_rect(&def.items[i])))
+            .collect();
+        let Some(&(at, here)) = current.and_then(|c| candidates.iter().find(|(i, _)| *i == c))
+        else {
+            if dx != 0 {
+                return false;
+            }
+            self.focus_step(menu, dy, true);
+            return true;
+        };
+        let centre = |r: [f32; 4]| [(r[0] + r[2]) * 0.5, (r[1] + r[3]) * 0.5];
+        let c = centre(here);
+        let same_column = |r: [f32; 4]| {
+            let o = centre(r);
+            (r[0] <= c[0] && c[0] <= r[2]) || (here[0] <= o[0] && o[0] <= here[2])
+        };
+        let others = candidates.iter().filter(|(i, _)| *i != at);
+        let next = if dy != 0 {
+            let dir = dy.signum() as f32;
+            let column: Vec<_> = others.filter(|(_, r)| same_column(*r)).collect();
+            let ahead = column
+                .iter()
+                .filter(|(_, r)| (centre(*r)[1] - c[1]) * dir > 0.5)
+                .min_by(|a, b| {
+                    let da = (centre(a.1)[1] - c[1]).abs();
+                    let db = (centre(b.1)[1] - c[1]).abs();
+                    da.total_cmp(&db)
+                });
+            let wrapped = || {
+                column
+                    .iter()
+                    .min_by(|a, b| (centre(a.1)[1] * dir).total_cmp(&(centre(b.1)[1] * dir)))
+            };
+            match ahead.or_else(wrapped) {
+                Some((index, _)) => *index,
+                None => {
+                    self.focus_step(menu, dy, false);
+                    return true;
+                }
+            }
+        } else {
+            let dir = dx.signum() as f32;
+            let Some((index, _)) = others
+                .filter(|(_, r)| !same_column(*r) && (centre(*r)[0] - c[0]) * dir > 0.0)
+                .min_by(|a, b| {
+                    let score = |r: [f32; 4]| {
+                        let o = centre(r);
+                        (o[1] - c[1]).abs() * 4.0 + (o[0] - c[0]).abs()
+                    };
+                    score(a.1).total_cmp(&score(b.1))
+                })
+            else {
+                return false;
+            };
+            *index
+        };
+        self.set_focus(menu, next);
+        true
+    }
+
     pub(crate) fn visible_items(&mut self, menu: &str) -> Vec<usize> {
         let Some(def) = self.catalog.get(menu) else {
             return Vec::new();
@@ -626,3 +697,21 @@ impl Runner<'_, '_> {
         self.run_events(menu, Some(index), events);
     }
 }
+
+/// Left, top, right, bottom on the 640 by 480 virtual screen.
+fn nav_rect(item: &asset_game::MenuItem) -> [f32; 4] {
+    let r = &item.rect;
+    let ox = match r.horz_align {
+        2 => 320.0,
+        3 => 640.0,
+        _ => 0.0,
+    };
+    let oy = match r.vert_align {
+        2 => 240.0,
+        3 => 480.0,
+        _ => 0.0,
+    };
+    let (x0, x1) = (r.x + ox, r.x + ox + r.w);
+    let (y0, y1) = (r.y + oy, r.y + oy + r.h);
+    [x0.min(x1), y0.min(y1), x0.max(x1), y0.max(y1)]
+}
diff --git a/crates/net/src/client/input.rs b/crates/net/src/client/input.rs
index 0cbff75..f0733b4 100644
--- a/crates/net/src/client/input.rs
+++ b/crates/net/src/client/input.rs
@@ -48,6 +48,21 @@ pub struct ClientActionInput {
     pub cl_yawspeed: f32,
     pub now_msec: i32,
     pub frame_msec: u32,
+
+    /// Forward and right.
+    pub pad_move: [f32; 2],
+    /// Right and up.
+    pub pad_look: [f32; 2],
+    pub pad_deflection: f32,
+    pub pad_sensitivity: f32,
+    pub pad_ads_sensitivity: f32,
+    pub pad_turn_rate: [f32; 2],
+    /// Pitch and yaw, degrees.
+    pub pad_look_delta: [f32; 2],
+    pub pad_aim_assist: u8,
+    pub pad_lockon: Option<u64>,
+    pub pad_autoaim: Option<(u64, f32)>,
+    pub pad_was_ads: bool,
 }
 
 impl Default for ClientActionInput {
@@ -70,6 +85,17 @@ impl Default for ClientActionInput {
             cl_yawspeed: CL_YAWSPEED_DEFAULT,
             now_msec: 16,
             frame_msec: 16,
+            pad_move: [0.0; 2],
+            pad_look: [0.0; 2],
+            pad_deflection: 0.0,
+            pad_sensitivity: 1.0,
+            pad_ads_sensitivity: 1.0,
+            pad_turn_rate: [0.0; 2],
+            pad_look_delta: [0.0; 2],
+            pad_aim_assist: 0,
+            pad_lockon: None,
+            pad_autoaim: None,
+            pad_was_ads: false,
         }
     }
 }
@@ -140,15 +166,19 @@ pub fn build_usercmd(input: &mut ClientActionInput, look: &LookState, server_tim
         input.fov_scale,
     );
     let (mouse_pitch, mouse_yaw) = mouse_move_angles(mx, my, input.m_yaw, input.m_pitch);
+    let pad_pitch = (input.pad_look_delta[0] * ANGLE2SHORT) as i32;
+    let pad_yaw = (input.pad_look_delta[1] * ANGLE2SHORT) as i32;
+    let forward = (axes.forward + input.pad_move[0]).clamp(-1.0, 1.0);
+    let right = (axes.right + input.pad_move[1]).clamp(-1.0, 1.0);
 
     create_cmd(&CreateCmdInput {
         server_time,
         angles: look.angles,
         buttons: bits,
-        forwardmove: axis_to_move(axes.forward),
-        rightmove: axis_to_move(axes.right),
-        mouse_pitch_delta: mouse_pitch,
-        mouse_yaw_delta: mouse_yaw,
+        forwardmove: axis_to_move(forward),
+        rightmove: axis_to_move(right),
+        mouse_pitch_delta: mouse_pitch + pad_pitch,
+        mouse_yaw_delta: mouse_yaw + pad_yaw,
         key_pitch_delta: 0,
         key_yaw_delta: 0,
         frozen: false,
diff --git a/crates/net/src/client/mod.rs b/crates/net/src/client/mod.rs
index 52d4637..49dc965 100644
--- a/crates/net/src/client/mod.rs
+++ b/crates/net/src/client/mod.rs
@@ -1,6 +1,7 @@
 pub mod frame_census;
 pub mod frame_clock;
 pub mod input;
+pub mod pad_aim;
 pub mod predict;
 pub mod predicted_error;
 pub mod presentation;
diff --git a/crates/net/src/client/pad_aim.rs b/crates/net/src/client/pad_aim.rs
new file mode 100644
index 0000000..0a65c3d
--- /dev/null
+++ b/crates/net/src/client/pad_aim.rs
@@ -0,0 +1,272 @@
+use super::input::ClientActionInput;
+
+/// Degrees a second at full deflection.
+const TURN_YAW: f32 = 260.0;
+const TURN_PITCH: f32 = 90.0;
+const TURN_YAW_ADS: f32 = 90.0;
+const TURN_PITCH_ADS: f32 = 55.0;
+/// Degrees a second squared.
+const TURN_ACCEL: f32 = 1200.0;
+
+const SLOWDOWN_HIP: f32 = 0.4;
+const SLOWDOWN_ADS: f32 = 0.5;
+/// Full width and height on the 640 by 480 virtual screen.
+const SLOWDOWN_REGION: [f32; 2] = [90.0, 90.0];
+const LOCKON_REGION: [f32; 2] = [90.0, 90.0];
+const AUTOAIM_REGION: [f32; 2] = [160.0, 120.0];
+const LOCKON_STRENGTH: f32 = 0.6;
+const LOCKON_DEFLECTION: f32 = 0.05;
+/// Degrees a second, for at most `AUTOAIM_TIME` seconds.
+const AUTOAIM_LERP: f32 = 40.0;
+const AUTOAIM_TIME: f32 = 0.5;
+
+const FALLBACK_RANGE: f32 = 1500.0;
+
+#[derive(Clone, Copy, Debug)]
+pub struct AimTarget {
+    pub key: u64,
+    pub mins: [f32; 3],
+    pub maxs: [f32; 3],
+    pub aim: [f32; 3],
+    pub velocity: [f32; 3],
+}
+
+#[derive(Clone, Copy, Debug)]
+pub struct AimView {
+    pub eye: [f32; 3],
+    /// Pitch and yaw, degrees.
+    pub angles: [f32; 2],
+    pub velocity: [f32; 3],
+    pub ads_lerp: f32,
+    /// Against a 65 degree field of view.
+    pub fov_scale: f32,
+    pub ranges: weapon_iw4::AimAssistRanges,
+    pub dt: f32,
+}
+
+struct OnScreen {
+    target: AimTarget,
+    min: [f32; 2],
+    max: [f32; 2],
+    dist_sqr: f32,
+    crosshair_sqr: f32,
+}
+
+fn axes(angles: [f32; 2]) -> ([f32; 3], [f32; 3], [f32; 3]) {
+    let (sp, cp) = angles[0].to_radians().sin_cos();
+    let (sy, cy) = angles[1].to_radians().sin_cos();
+    let forward = [cp * cy, cp * sy, -sp];
+    let right = [sy, -cy, 0.0];
+    let up = [sp * cy, sp * sy, cp];
+    (forward, right, up)
+}
+
+fn dot(a: [f32; 3], b: [f32; 3]) -> f32 {
+    a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
+}
+
+fn angles_to(eye: [f32; 3], point: [f32; 3]) -> [f32; 2] {
+    let d = [point[0] - eye[0], point[1] - eye[1], point[2] - eye[2]];
+    let flat = (d[0] * d[0] + d[1] * d[1]).sqrt();
+    [
+        -d[2].atan2(flat).to_degrees(),
+        d[1].atan2(d[0]).to_degrees(),
+    ]
+}
+
+fn angle_delta(to: f32, from: f32) -> f32 {
+    (to - from + 540.0).rem_euclid(360.0) - 180.0
+}
+
+fn lerp(a: f32, b: f32, t: f32) -> f32 {
+    a + (b - a) * t
+}
+
+fn project(view: &AimView, targets: &[AimTarget]) -> Vec<OnScreen> {
+    let (forward, right, up) = axes(view.angles);
+    let tan_x = (32.5f32.to_radians().tan() * view.fov_scale).max(1e-3);
+    let tan_y = tan_x * 9.0 / 16.0;
+    let mut out: Vec<OnScreen> = targets
+        .iter()
+        .filter_map(|target| {
+            let mut min = [f32::MAX; 2];
+            let mut max = [f32::MIN; 2];
+            for corner in 0..8 {
+                let p = [
+                    if corner & 1 == 0 {
+                        target.mins[0]
+                    } else {
+                        target.maxs[0]
+                    },
+                    if corner & 2 == 0 {
+                        target.mins[1]
+                    } else {
+                        target.maxs[1]
+                    },
+                    if corner & 4 == 0 {
+                        target.mins[2]
+                    } else {
+                        target.maxs[2]
+                    },
+                ];
+                let d = [p[0] - view.eye[0], p[1] - view.eye[1], p[2] - view.eye[2]];
+                let depth = dot(d, forward);
+                if depth <= 0.0 {
+                    continue;
+                }
+                let x = dot(d, right) / (depth * tan_x);
+                let y = -dot(d, up) / (depth * tan_y);
+                min = [min[0].min(x), min[1].min(y)];
+                max = [max[0].max(x), max[1].max(y)];
+            }
+            if max[0] <= min[0]
+                || max[1] <= min[1]
+                || min[0] > 1.0
+                || min[1] > 1.0
+                || max[0] < -1.0
+                || max[1] < -1.0
+            {
+                return None;
+            }
+            let min = [min[0].clamp(-1.0, 1.0), min[1].clamp(-1.0, 1.0)];
+            let max = [max[0].clamp(-1.0, 1.0), max[1].clamp(-1.0, 1.0)];
+            let centre = [(min[0] + max[0]) * 0.5, (min[1] + max[1]) * 0.5];
+            let d = [
+                target.aim[0] - view.eye[0],
+                target.aim[1] - view.eye[1],
+                target.aim[2] - view.eye[2],
+            ];
+            Some(OnScreen {
+                target: *target,
+                min,
+                max,
+                dist_sqr: dot(d, d),
+                crosshair_sqr: centre[0] * centre[0] + centre[1] * centre[1],
+            })
+        })
+        .collect();
+    out.sort_by(|a, b| a.crosshair_sqr.total_cmp(&b.crosshair_sqr));
+    out
+}
+
+fn best(screen: &[OnScreen], range: f32, region: [f32; 2], scale: f32) -> Option<&OnScreen> {
+    let half = [region[0] / 640.0 * scale, region[1] / 480.0 * scale];
+    screen.iter().find(|s| {
+        s.dist_sqr <= range * range
+            && s.min[0] <= half[0]
+            && s.max[0] >= -half[0]
+            && s.min[1] <= half[1]
+            && s.max[1] >= -half[1]
+    })
+}
+
+pub fn pad_look_frame(
+    input: &mut ClientActionInput,
+    view: &AimView,
+    targets: &[AimTarget],
+    ads: bool,
+) {
+    let dt = view.dt;
+    let ads_lerp = view.ads_lerp.clamp(0.0, 1.0);
+    let sensitivity = input.pad_sensitivity * lerp(1.0, input.pad_ads_sensitivity, ads_lerp);
+    let zoom = view.fov_scale.clamp(0.02, 2.0);
+    let max_yaw = lerp(TURN_YAW, TURN_YAW_ADS, ads_lerp) * zoom * sensitivity;
+    let max_pitch = lerp(TURN_PITCH, TURN_PITCH_ADS, ads_lerp) * zoom * sensitivity;
+    let wanted = [-input.pad_look[1] * max_pitch, -input.pad_look[0] * max_yaw];
+
+    for (rate, goal) in input.pad_turn_rate.iter_mut().zip(wanted) {
+        if (goal.abs() > rate.abs() && goal.signum() == rate.signum())
+            || (*rate == 0.0 && goal != 0.0)
+        {
+            let step = TURN_ACCEL * zoom * dt;
+            *rate = if goal > *rate {
+                (*rate + step).min(goal)
+            } else {
+                (*rate - step).max(goal)
+            };
+        } else {
+            *rate = goal;
+        }
+    }
+    let mut delta = [input.pad_turn_rate[0] * dt, input.pad_turn_rate[1] * dt];
+
+    let mode = input.pad_aim_assist;
+    if mode == 0 {
+        input.pad_lockon = None;
+        input.pad_autoaim = None;
+        input.pad_was_ads = ads;
+        input.pad_look_delta = delta;
+        return;
+    }
+    let screen = project(view, targets);
+    let range = |hip: f32, ads: f32| {
+        let hip = if hip > 0.0 { hip } else { FALLBACK_RANGE };
+        let ads = if ads > 0.0 { ads } else { hip };
+        lerp(hip, ads, ads_lerp)
+    };
+    let assist_range = range(view.ranges.hip, view.ranges.ads);
+
+    if best(&screen, assist_range, SLOWDOWN_REGION, 1.0).is_some() {
+        let slow = lerp(SLOWDOWN_HIP, SLOWDOWN_ADS, ads_lerp);
+        delta[0] *= slow;
+        delta[1] *= slow;
+    }
+
+    let kept = input
+        .pad_lockon
+        .and_then(|key| screen.iter().find(|s| s.target.key == key))
+        .filter(|s| best(std::slice::from_ref(*s), assist_range, LOCKON_REGION, 1.0).is_some());
+    let lock = kept.or_else(|| best(&screen, assist_range, LOCKON_REGION, 1.0));
+    input.pad_lockon = lock.map(|s| s.target.key);
+    if let Some(lock) = lock
+        && input.pad_autoaim.is_none()
+        && input.pad_deflection > LOCKON_DEFLECTION
+    {
+        let t = lock.target;
+        let moved = [
+            t.aim[0] + (t.velocity[0] - view.velocity[0]) * dt,
+            t.aim[1] + (t.velocity[1] - view.velocity[1]) * dt,
+            t.aim[2] + (t.velocity[2] - view.velocity[2]) * dt,
+        ];
+        let now = angles_to(view.eye, t.aim);
+        let next = angles_to(view.eye, moved);
+        delta[0] += LOCKON_STRENGTH * angle_delta(next[0], now[0]);
+        delta[1] += LOCKON_STRENGTH * angle_delta(next[1], now[1]);
+    }
+
+    if mode == 2 && ads && !input.pad_was_ads {
+        let auto_range = if view.ranges.auto_aim > 0.0 {
+            view.ranges.auto_aim
+        } else {
+            FALLBACK_RANGE
+        };
+        input.pad_autoaim = best(&screen, auto_range, AUTOAIM_REGION, (1.0 / zoom).max(1.0))
+            .map(|s| (s.target.key, AUTOAIM_TIME));
+    }
+    if !ads {
+        input.pad_autoaim = None;
+    }
+    if let Some((key, left)) = input.pad_autoaim {
+        match screen
+            .iter()
+            .find(|s| s.target.key == key)
+            .filter(|_| left > 0.0)
+        {
+            Some(s) => {
+                let goal = angles_to(view.eye, s.target.aim);
+                let pitch = angle_delta(goal[0], view.angles[0]);
+                let yaw = angle_delta(goal[1], view.angles[1]);
+                let length = pitch.hypot(yaw);
+                let step = (AUTOAIM_LERP * dt).min(length);
+                if length > 1e-4 {
+                    delta[0] += pitch / length * step;
+                    delta[1] += yaw / length * step;
+                }
+                input.pad_autoaim = (length > 0.25).then_some((key, left - dt));
+            }
+            None => input.pad_autoaim = None,
+        }
+    }
+    input.pad_was_ads = ads;
+    input.pad_look_delta = delta;
+}
diff --git a/crates/net/src/client/runtime.rs b/crates/net/src/client/runtime.rs
index bcadefb..01d16ce 100644
--- a/crates/net/src/client/runtime.rs
+++ b/crates/net/src/client/runtime.rs
@@ -801,6 +801,91 @@ pub fn sample_client_input(
     if frozen {
         actions.mouse_x = 0.0;
         actions.mouse_y = 0.0;
+        actions.pad_move = [0.0; 2];
+        actions.pad_look = [0.0; 2];
+    }
+    if let Some(ps) = ps {
+        let world = prediction.0.world();
+        let eye = [
+            ps.origin[0],
+            ps.origin[1],
+            ps.origin[2] + ps.view_height_current,
+        ];
+        let visible = |point: [f32; 3]| {
+            let hit =
+                world.trace_world(eye, point, [0.0; 3], [0.0; 3], hud_iw4::OVERHEAD_TRACE_MASK);
+            hit.fraction >= 1.0 && hit.startsolid == 0
+        };
+        let angles = [
+            look.angles[0] as f32 / input_iw4::ANGLE2SHORT,
+            look.angles[1] as f32 / input_iw4::ANGLE2SHORT,
+        ];
+        let (sp, cp) = angles[0].to_radians().sin_cos();
+        let (sy, cy) = angles[1].to_radians().sin_cos();
+        let forward = [cp * cy, cp * sy, -sp];
+        let in_front = |origin: [f32; 3], radius: f32| {
+            let d = [
+                origin[0] - ps.origin[0],
+                origin[1] - ps.origin[1],
+                origin[2] - ps.origin[2],
+            ];
+            d[0] * forward[0] + d[1] * forward[1] + d[2] * forward[2] + radius >= 0.0
+        };
+        let mut targets: Vec<crate::client::pad_aim::AimTarget> = Vec::new();
+        if actions.pad_aim_assist > 0 {
+            const RADIUS: f32 = 10.0;
+            let snapshot = presented.snapshot();
+            let team = |id: sim::ClientId| {
+                snapshot
+                    .and_then(|s| s.meta.for_client(id))
+                    .map(|m| m.client_state_team)
+            };
+            let teams = snapshot.is_some_and(|s| s.meta.kind.is_team());
+            let mine = team(local.0);
+            for id in snapshot
+                .into_iter()
+                .flat_map(|s| s.players.iter().map(|(id, _)| *id))
+            {
+                if id == local.0 || (teams && team(id) == mine) {
+                    continue;
+                }
+                let Some(other) = presented.player(id).filter(|o| o.pm_type == 0) else {
+                    continue;
+                };
+                let o = other.origin;
+                let head = [o[0], o[1], o[2] + other.view_height_current];
+                if !in_front(o, RADIUS) || !visible(head) {
+                    continue;
+                }
+                let top = other.view_height_current + 8.0;
+                targets.push(crate::client::pad_aim::AimTarget {
+                    key: u64::from(id.0),
+                    mins: [o[0] - RADIUS, o[1] - RADIUS, o[2]],
+                    maxs: [o[0] + RADIUS, o[1] + RADIUS, o[2] + top],
+                    aim: [o[0], o[1], o[2] + top * 0.75],
+                    velocity: other.velocity,
+                });
+            }
+        }
+        let ranges = world
+            .weapon_combat_row(playerstate_iw4::get_viewmodel_weapon_index(ps))
+            .map_or(weapon_iw4::AimAssistRanges::NONE, |facts| facts.aim_assist);
+        let view = crate::client::pad_aim::AimView {
+            eye,
+            angles,
+            velocity: ps.velocity,
+            ads_lerp: ps.f_weapon_pos_frac,
+            fov_scale: actions.fov_scale.max(0.01),
+            ranges,
+            dt: cls.frametime_secs(),
+        };
+        let ads = actions.client.using_ads || actions.client.kb.speed.active;
+        crate::client::pad_aim::pad_look_frame(&mut actions, &view, &targets, ads);
+    } else {
+        actions.pad_look_delta = [0.0; 2];
+    }
+    if frozen {
+        actions.pad_look_delta = [0.0; 2];
     }
     let choose_direction = presented
         .snapshot()
@@ -983,6 +1068,11 @@ pub fn sample_client_input(
         }
     }
     let mut cmd = build_usercmd(&mut actions, &look, 0);
+    if cmd.buttons & playerstate_iw4::buttons::USE_RELOAD != 0
+        && ps.is_some_and(|ps| ps.cursor_hint == 0)
+    {
+        cmd.buttons |= playerstate_iw4::buttons::RELOAD;
+    }
     look.angles = cmd.angles;
     if let Some((mouse_x, mouse_y)) = remote_mouse {
         cmd.remote_control = remote_control_axes(&actions, mouse_x, mouse_y);
diff --git a/crates/session/src/combat_table.rs b/crates/session/src/combat_table.rs
index b18164e..d4ccf59 100644
--- a/crates/session/src/combat_table.rs
+++ b/crates/session/src/combat_table.rs
@@ -163,6 +163,11 @@ pub fn from_registry(
                     WeaponCombatFacts::none()
                 });
             facts.alternate_weapon = weapons.alternate_of(i as u32);
+            facts.aim_assist = weapon_iw4::AimAssistRanges {
+                auto_aim: f.auto_aim_range,
+                hip: f.aim_assist_range,
+                ads: f.aim_assist_range_ads,
+            };
             facts
         })
         .collect();
diff --git a/crates/ui/menus/controller.json b/crates/ui/menus/controller.json
new file mode 100644
index 0000000..4fdfa84
--- /dev/null
+++ b/crates/ui/menus/controller.json
@@ -0,0 +1,866 @@
+[
+ {
+  "name": "options_controller",
+  "base": "pc_options_video",
+  "fields": {
+   "handlers": {
+    "open": [
+     {
+      "Script": "focusFirst;"
+     }
+    ],
+    "close": [],
+    "esc": [
+     {
+      "Script": "close self;"
+     }
+    ]
+   }
+  },
+  "item_overrides": [
+   {
+    "index": 22,
+    "fields": {
+     "vis_exp": "0"
+    }
+   },
+   {
+    "index": 23,
+    "fields": {
+     "vis_exp": "0"
+    }
+   },
+   {
+    "index": 24,
+    "fields": {
+     "vis_exp": "0"
+    }
+   },
+   {
+    "index": 25,
+    "fields": {
+     "vis_exp": "0"
+    }
+   },
+   {
+    "index": 26,
+    "fields": {
+     "vis_exp": "0"
+    }
+   },
+   {
+    "index": 27,
+    "fields": {
+     "vis_exp": "0"
+    }
+   },
+   {
+    "index": 28,
+    "fields": {
+     "vis_exp": "0"
+    }
+   },
+   {
+    "index": 29,
+    "fields": {
+     "vis_exp": "0"
+    }
+   },
+   {
+    "index": 30,
+    "fields": {
+     "vis_exp": "0"
+    }
+   },
+   {
+    "index": 31,
+    "fields": {
+     "vis_exp": "0"
+    }
+   },
+   {
+    "index": 32,
+    "fields": {
+     "vis_exp": "0"
+    }
+   },
+   {
+    "index": 33,
+    "fields": {
+     "vis_exp": "0"
+    }
+   },
+   {
+    "index": 34,
+    "fields": {
+     "vis_exp": "0"
+    }
+   },
+   {
+    "index": 21,
+    "fields": {
+     "text_key": "Controller"
+    }
+   }
+  ],
+  "item_copies": [
+   {
+    "index": 27,
+    "fields": {
+     "item_type": 12,
+     "static_flags": 0,
+     "dvar": "ui_pad_layout",
+     "choices": [
+      [
+       "Default",
+       "0"
+      ],
+      [
+       "Tactical",
+       "1"
+      ],
+      [
+       "Lefty",
+       "2"
+      ],
+      [
+       "Bumper Jumper",
+       "3"
+      ],
+      [
+       "Bumper Jumper Tactical",
+       "4"
+      ],
+      [
+       "Custom",
+       "255"
+      ]
+     ],
+     "vis_exp": "1",
+     "disabled_exp": "0",
+     "text_key": "",
+     "text_exp": "",
+     "text_align_mode": 10,
+     "text_align_x": -8,
+     "text_align_y": 0,
+     "fore_color": [
+      1,
+      1,
+      1,
+      1
+     ],
+     "rect": {
+      "x": 232,
+      "y": 28,
+      "w": 344,
+      "h": 20
+     },
+     "handlers": {
+      "action": [
+       {
+        "Script": "play mouse_click;"
+       }
+      ],
+      "focus": [
+       {
+        "Script": "play mouse_over; setItemColor self backcolor 0 0 0 1;"
+       }
+      ],
+      "leave_focus": [
+       {
+        "Script": "setItemColor self backcolor 0 0 0 0;"
+       }
+      ]
+     },
+     "text_scale": 0.375,
+     "style": 1,
+     "background": "menu_button_selection_bar",
+     "back_color": [
+      0,
+      0,
+      0,
+      0
+     ]
+    }
+   },
+   {
+    "index": 28,
+    "fields": {
+     "vis_exp": "1",
+     "text_key": "Button Layout",
+     "rect": {
+      "x": 232,
+      "y": 28,
+      "w": 344,
+      "h": 20
+     },
+     "text_scale": 0.32
+    }
+   },
+   {
+    "index": 27,
+    "fields": {
+     "item_type": 12,
+     "static_flags": 0,
+     "dvar": "ui_pad_stick_layout",
+     "choices": [
+      [
+       "Default",
+       "0"
+      ],
+      [
+       "Southpaw",
+       "1"
+      ],
+      [
+       "Legacy",
+       "2"
+      ],
+      [
+       "Legacy Southpaw",
+       "3"
+      ]
+     ],
+     "vis_exp": "1",
+     "disabled_exp": "0",
+     "text_key": "",
+     "text_exp": "",
+     "text_align_mode": 10,
+     "text_align_x": -8,
+     "text_align_y": 0,
+     "fore_color": [
+      1,
+      1,
+      1,
+      1
+     ],
+     "rect": {
+      "x": 232,
+      "y": 48,
+      "w": 344,
+      "h": 20
+     },
+     "handlers": {
+      "action": [
+       {
+        "Script": "play mouse_click;"
+       }
+      ],
+      "focus": [
+       {
+        "Script": "play mouse_over; setItemColor self backcolor 0 0 0 1;"
+       }
+      ],
+      "leave_focus": [
+       {
+        "Script": "setItemColor self backcolor 0 0 0 0;"
+       }
+      ]
+     },
+     "text_scale": 0.375,
+     "style": 1,
+     "background": "menu_button_selection_bar",
+     "back_color": [
+      0,
+      0,
+      0,
+      0
+     ]
+    }
+   },
+   {
+    "index": 28,
+    "fields": {
+     "vis_exp": "1",
+     "text_key": "Stick Layout",
+     "rect": {
+      "x": 232,
+      "y": 48,
+      "w": 344,
+      "h": 20
+     },
+     "text_scale": 0.32
+    }
+   },
+   {
+    "index": 24,
+    "fields": {
+     "item_type": 10,
+     "static_flags": 0,
+     "dvar": "ui_pad_sensitivity",
+     "choices": [],
+     "vis_exp": "1",
+     "disabled_exp": "0",
+     "text_key": "",
+     "text_exp": "",
+     "text_align_mode": 10,
+     "text_align_x": -8,
+     "text_align_y": 0,
+     "fore_color": [
+      1,
+      1,
+      1,
+      1
+     ],
+     "rect": {
+      "x": 420,
+      "y": 68,
+      "w": 112,
+      "h": 20
+     },
+     "handlers": {
+      "focus": [
+       {
+        "Script": "play mouse_over;"
+       }
+      ]
+     },
+     "text_scale": 0.375,
+     "style": 1,
+     "background": "",
+     "back_color": [
+      0,
+      0,
+      0,
+      0
+     ],
+     "slider": {
+      "min": 1,
+      "max": 10,
+      "step": 0.5
+     }
+    }
+   },
+   {
+    "index": 29,
+    "fields": {
+     "text_key": "Look Sensitivity",
+     "vis_exp": "1",
+     "rect": {
+      "x": 232,
+      "y": 68,
+      "w": 344,
+      "h": 20
+     }
+    }
+   },
+   {
+    "index": 24,
+    "fields": {
+     "item_type": 10,
+     "static_flags": 0,
+     "dvar": "ui_pad_ads_sensitivity",
+     "choices": [],
+     "vis_exp": "1",
+     "disabled_exp": "0",
+     "text_key": "",
+     "text_exp": "",
+     "text_align_mode": 10,
+     "text_align_x": -8,
+     "text_align_y": 0,
+     "fore_color": [
+      1,
+      1,
+      1,
+      1
+     ],
+     "rect": {
+      "x": 420,
+      "y": 88,
+      "w": 112,
+      "h": 20
+     },
+     "handlers": {
+      "focus": [
+       {
+        "Script": "play mouse_over;"
+       }
+      ]
+     },
+     "text_scale": 0.375,
+     "style": 1,
+     "background": "",
+     "back_color": [
+      0,
+      0,
+      0,
+      0
+     ],
+     "slider": {
+      "min": 0.5,
+      "max": 1.5,
+      "step": 0.05,
+      "display_range": [
+       50,
+       150
+      ],
+      "suffix": "%"
+     }
+    }
+   },
+   {
+    "index": 29,
+    "fields": {
+     "text_key": "ADS Sensitivity",
+     "vis_exp": "1",
+     "rect": {
+      "x": 232,
+      "y": 88,
+      "w": 344,
+      "h": 20
+     }
+    }
+   },
+   {
+    "index": 27,
+    "fields": {
+     "item_type": 12,
+     "static_flags": 0,
+     "dvar": "ui_pad_invert",
+     "choices": [
+      [
+       "@MENU_DISABLED",
+       "0"
+      ],
+      [
+       "@MENU_ENABLED",
+       "1"
+      ]
+     ],
+     "vis_exp": "1",
+     "disabled_exp": "0",
+     "text_key": "",
+     "text_exp": "",
+     "text_align_mode": 10,
+     "text_align_x": -8,
+     "text_align_y": 0,
+     "fore_color": [
+      1,
+      1,
+      1,
+      1
+     ],
+     "rect": {
+      "x": 232,
+      "y": 108,
+      "w": 344,
+      "h": 20
+     },
+     "handlers": {
+      "action": [
+       {
+        "Script": "play mouse_click;"
+       }
+      ],
+      "focus": [
+       {
+        "Script": "play mouse_over; setItemColor self backcolor 0 0 0 1;"
+       }
+      ],
+      "leave_focus": [
+       {
+        "Script": "setItemColor self backcolor 0 0 0 0;"
+       }
+      ]
+     },
+     "text_scale": 0.375,
+     "style": 1,
+     "background": "menu_button_selection_bar",
+     "back_color": [
+      0,
+      0,
+      0,
+      0
+     ]
+    }
+   },
+   {
+    "index": 28,
+    "fields": {
+     "vis_exp": "1",
+     "text_key": "Look Inversion",
+     "rect": {
+      "x": 232,
+      "y": 108,
+      "w": 344,
+      "h": 20
+     },
+     "text_scale": 0.32
+    }
+   },
+   {
+    "index": 27,
+    "fields": {
+     "item_type": 12,
+     "static_flags": 0,
+     "dvar": "ui_pad_curve",
+     "choices": [
+      [
+       "Standard",
+       "0"
+      ],
+      [
+       "Linear",
+       "1"
+      ],
+      [
+       "Dynamic",
+       "2"
+      ]
+     ],
+     "vis_exp": "1",
+     "disabled_exp": "0",
+     "text_key": "",
+     "text_exp": "",
+     "text_align_mode": 10,
+     "text_align_x": -8,
+     "text_align_y": 0,
+     "fore_color": [
+      1,
+      1,
+      1,
+      1
+     ],
+     "rect": {
+      "x": 232,
+      "y": 128,
+      "w": 344,
+      "h": 20
+     },
+     "handlers": {
+      "action": [
+       {
+        "Script": "play mouse_click;"
+       }
+      ],
+      "focus": [
+       {
+        "Script": "play mouse_over; setItemColor self backcolor 0 0 0 1;"
+       }
+      ],
+      "leave_focus": [
+       {
+        "Script": "setItemColor self backcolor 0 0 0 0;"
+       }
+      ]
+     },
+     "text_scale": 0.375,
+     "style": 1,
+     "background": "menu_button_selection_bar",
+     "back_color": [
+      0,
+      0,
+      0,
+      0
+     ]
+    }
+   },
+   {
+    "index": 28,
+    "fields": {
+     "vis_exp": "1",
+     "text_key": "Response Curve",
+     "rect": {
+      "x": 232,
+      "y": 128,
+      "w": 344,
+      "h": 20
+     },
+     "text_scale": 0.32
+    }
+   },
+   {
+    "index": 27,
+    "fields": {
+     "item_type": 12,
+     "static_flags": 0,
+     "dvar": "ui_pad_aim_assist",
+     "choices": [
+      [
+       "Off",
+       "0"
+      ],
+      [
+       "Standard",
+       "1"
+      ],
+      [
+       "Full",
+       "2"
+      ]
+     ],
+     "vis_exp": "1",
+     "disabled_exp": "0",
+     "text_key": "",
+     "text_exp": "",
+     "text_align_mode": 10,
+     "text_align_x": -8,
+     "text_align_y": 0,
+     "fore_color": [
+      1,
+      1,
+      1,
+      1
+     ],
+     "rect": {
+      "x": 232,
+      "y": 148,
+      "w": 344,
+      "h": 20
+     },
+     "handlers": {
+      "action": [
+       {
+        "Script": "play mouse_click;"
+       }
+      ],
+      "focus": [
+       {
+        "Script": "play mouse_over; setItemColor self backcolor 0 0 0 1;"
+       }
+      ],
+      "leave_focus": [
+       {
+        "Script": "setItemColor self backcolor 0 0 0 0;"
+       }
+      ]
+     },
+     "text_scale": 0.375,
+     "style": 1,
+     "background": "menu_button_selection_bar",
+     "back_color": [
+      0,
+      0,
+      0,
+      0
+     ]
+    }
+   },
+   {
+    "index": 28,
+    "fields": {
+     "vis_exp": "1",
+     "text_key": "Aim Assist",
+     "rect": {
+      "x": 232,
+      "y": 148,
+      "w": 344,
+      "h": 20
+     },
+     "text_scale": 0.32
+    }
+   },
+   {
+    "index": 27,
+    "fields": {
+     "item_type": 12,
+     "static_flags": 0,
+     "dvar": "ui_pad_vibration",
+     "choices": [
+      [
+       "@MENU_DISABLED",
+       "0"
+      ],
+      [
+       "@MENU_ENABLED",
+       "1"
+      ]
+     ],
+     "vis_exp": "1",
+     "disabled_exp": "0",
+     "text_key": "",
+     "text_exp": "",
+     "text_align_mode": 10,
+     "text_align_x": -8,
+     "text_align_y": 0,
+     "fore_color": [
+      1,
+      1,
+      1,
+      1
+     ],
+     "rect": {
+      "x": 232,
+      "y": 168,
+      "w": 344,
+      "h": 20
+     },
+     "handlers": {
+      "action": [
+       {
+        "Script": "play mouse_click;"
+       }
+      ],
+      "focus": [
+       {
+        "Script": "play mouse_over; setItemColor self backcolor 0 0 0 1;"
+       }
+      ],
+      "leave_focus": [
+       {
+        "Script": "setItemColor self backcolor 0 0 0 0;"
+       }
+      ]
+     },
+     "text_scale": 0.375,
+     "style": 1,
+     "background": "menu_button_selection_bar",
+     "back_color": [
+      0,
+      0,
+      0,
+      0
+     ]
+    }
+   },
+   {
+    "index": 28,
+    "fields": {
+     "vis_exp": "1",
+     "text_key": "Vibration",
+     "rect": {
+      "x": 232,
+      "y": 168,
+      "w": 344,
+      "h": 20
+     },
+     "text_scale": 0.32
+    }
+   },
+   {
+    "index": 24,
+    "fields": {
+     "item_type": 10,
+     "static_flags": 0,
+     "dvar": "ui_pad_deadzone_left",
+     "choices": [],
+     "vis_exp": "1",
+     "disabled_exp": "0",
+     "text_key": "",
+     "text_exp": "",
+     "text_align_mode": 10,
+     "text_align_x": -8,
+     "text_align_y": 0,
+     "fore_color": [
+      1,
+      1,
+      1,
+      1
+     ],
+     "rect": {
+      "x": 420,
+      "y": 188,
+      "w": 112,
+      "h": 20
+     },
+     "handlers": {
+      "focus": [
+       {
+        "Script": "play mouse_over;"
+       }
+      ]
+     },
+     "text_scale": 0.375,
+     "style": 1,
+     "background": "",
+     "back_color": [
+      0,
+      0,
+      0,
+      0
+     ],
+     "slider": {
+      "min": 0,
+      "max": 0.4,
+      "step": 0.01,
+      "display_range": [
+       0,
+       40
+      ],
+      "suffix": "%"
+     }
+    }
+   },
+   {
+    "index": 29,
+    "fields": {
+     "text_key": "Left Stick Deadzone",
+     "vis_exp": "1",
+     "rect": {
+      "x": 232,
+      "y": 188,
+      "w": 344,
+      "h": 20
+     }
+    }
+   },
+   {
+    "index": 24,
+    "fields": {
+     "item_type": 10,
+     "static_flags": 0,
+     "dvar": "ui_pad_deadzone_right",
+     "choices": [],
+     "vis_exp": "1",
+     "disabled_exp": "0",
+     "text_key": "",
+     "text_exp": "",
+     "text_align_mode": 10,
+     "text_align_x": -8,
+     "text_align_y": 0,
+     "fore_color": [
+      1,
+      1,
+      1,
+      1
+     ],
+     "rect": {
+      "x": 420,
+      "y": 208,
+      "w": 112,
+      "h": 20
+     },
+     "handlers": {
+      "focus": [
+       {
+        "Script": "play mouse_over;"
+       }
+      ]
+     },
+     "text_scale": 0.375,
+     "style": 1,
+     "background": "",
+     "back_color": [
+      0,
+      0,
+      0,
+      0
+     ],
+     "slider": {
+      "min": 0,
+      "max": 0.4,
+      "step": 0.01,
+      "display_range": [
+       0,
+       40
+      ],
+      "suffix": "%"
+     }
+    }
+   },
+   {
+    "index": 29,
+    "fields": {
+     "text_key": "Right Stick Deadzone",
+     "vis_exp": "1",
+     "rect": {
+      "x": 232,
+      "y": 208,
+      "w": 344,
+      "h": 20
+     }
+    }
+   }
+  ]
+ }
+]
\ No newline at end of file
diff --git a/crates/ui/menus/settings.json b/crates/ui/menus/settings.json
index 5b073d5..ee9f94c 100644
--- a/crates/ui/menus/settings.json
+++ b/crates/ui/menus/settings.json
@@ -87,6 +87,8 @@
       {"index": 30, "fields": {"vis_exp": "0"}},
       {"index": 31, "fields": {"vis_exp": "0"}},
       {"index": 32, "fields": {"vis_exp": "0"}},
+      {"index": 33, "fields": {"vis_exp": "0"}},
+      {"index": 34, "fields": {"vis_exp": "0"}},
       {"index": 21, "fields": {"text_key": "@MENU_ADVANCED_VIDEO"}}
     ],
     "item_copies": [
diff --git a/crates/ui/src/menu.rs b/crates/ui/src/menu.rs
index 3807199..6a66c3b 100644
--- a/crates/ui/src/menu.rs
+++ b/crates/ui/src/menu.rs
@@ -56,6 +56,7 @@ pub fn install_frontend_menus(catalog: &mut asset_game::MenuCatalog) -> Result<(
     catalog.load_definitions(include_str!("../menus/connection_error.json"))?;
     catalog.load_definitions(include_str!("../menus/classes.json"))?;
     catalog.load_definitions(include_str!("../menus/settings.json"))?;
+    catalog.load_definitions(include_str!("../menus/controller.json"))?;
     for (name, menu) in &mut catalog.menus {
         if let Some(chat) = menu
             .items
@@ -76,7 +77,15 @@ pub fn install_frontend_menus(catalog: &mut asset_game::MenuCatalog) -> Result<(
             multiplayer.handlers.action = vec![asset_game::MenuEvent::Script(
                 "play mouse_click; close self; open options_multi;".into(),
             )];
+            let mut controller = multiplayer.clone();
             menu.items.push(multiplayer);
+            controller.name = "controller_settings".into();
+            controller.text_key = "Controller".into();
+            controller.rect.y = 108.0;
+            controller.handlers.action = vec![asset_game::MenuEvent::Script(
+                "play mouse_click; close self; open options_controller;".into(),
+            )];
+            menu.items.push(controller);
         }
 
         let removed_rows: Vec<_> = menu
@@ -93,7 +102,10 @@ pub fn install_frontend_menus(catalog: &mut asset_game::MenuCatalog) -> Result<(
             .collect();
         menu.items.retain(|item| {
             !removed_rows.iter().any(|&(x, y)| {
-                item.rect.x == x && item.rect.y == y && item.name != "multiplayer_settings"
+                item.rect.x == x
+                    && item.rect.y == y
+                    && item.name != "multiplayer_settings"
+                    && item.name != "controller_settings"
             })
         });
         if name == "pc_options_controls" {
diff --git a/crates/weapon_iw4/src/lib.rs b/crates/weapon_iw4/src/lib.rs
index 6125a7b..9dc0adc 100644
--- a/crates/weapon_iw4/src/lib.rs
+++ b/crates/weapon_iw4/src/lib.rs
@@ -127,7 +127,7 @@ pub use sway::{
     lerp_sway_params, sway_contribution, sway_shellshock_landing_scale, track, track_a,
 };
 pub use tick::{
-    BURST_COOLDOWN_DEFAULT_MS, BUTTON_ATTACK, BUTTON_RELOAD, BUTTON_THROW,
+    AimAssistRanges, BURST_COOLDOWN_DEFAULT_MS, BUTTON_ATTACK, BUTTON_RELOAD, BUTTON_THROW,
     CHECK_FIRING_AMMO_DRY_FIRE_MS, CapturedCombatInput, MissingCombatFacts, PERK_FASTRELOAD,
     PERK_WEAP_RELOAD_MULTIPLIER_DEFAULT, WeaponCmd, WeaponCombatFacts, WeaponHandState,
     WeaponTickEvent, get_weapon_fire_button, perk_fastreload_eligible, spawn_clip_stock,
diff --git a/crates/weapon_iw4/src/tick.rs b/crates/weapon_iw4/src/tick.rs
index 33c08af..c977916 100644
--- a/crates/weapon_iw4/src/tick.rs
+++ b/crates/weapon_iw4/src/tick.rs
@@ -138,8 +138,25 @@ pub struct CapturedCombatInput {
     pub dual_mag: Option<crate::reload::DualMagTimes>,
 }
 
+/// Map units; zero where the weapon sets none.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct AimAssistRanges {
+    pub auto_aim: f32,
+    pub hip: f32,
+    pub ads: f32,
+}
+
+impl AimAssistRanges {
+    pub const NONE: Self = Self {
+        auto_aim: 0.0,
+        hip: 0.0,
+        ads: 0.0,
+    };
+}
+
 #[derive(Clone, Copy, Debug, PartialEq)]
 pub struct WeaponCombatFacts {
+    pub aim_assist: AimAssistRanges,
     pub fire_time_ms: i32,
     pub fire_delay_ms: i32,
     pub raise_time_ms: i32,
@@ -273,6 +290,7 @@ impl Default for WeaponCombatFacts {
 impl WeaponCombatFacts {
     pub const fn none() -> Self {
         Self {
+            aim_assist: AimAssistRanges::NONE,
             fire_time_ms: 0,
             fire_delay_ms: 0,
             raise_time_ms: 0,
@@ -380,6 +398,7 @@ impl WeaponCombatFacts {
             return Err(MissingCombatFacts::LocationDamage);
         }
         Ok(Self {
+            aim_assist: AimAssistRanges::NONE,
             fire_time_ms: input.fire_time_ms,
             fire_delay_ms: input.fire_delay_ms,
             raise_time_ms: input.raise_time_ms,