diff --git a/Cargo.toml b/Cargo.toml
index 05e57f72..405f1b79 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -25,20 +25,33 @@ egui = ['dep:bevy_egui']
 
 [dependencies]
 leafwing_input_manager_macros = { path = "macros", version = "0.7" }
-
-bevy = {version = "0.9", default-features = false, features = ["serialize", "bevy_gilrs"]}
-bevy_egui = {version = "0.19", optional = true}
-
-petitset = {version = "0.2.1", features = ["serde_compat"]}
-derive_more = {version = "0.99", default-features = false, features = ["display", "error"]}
+bevy = { version = "0.10", default-features = false, features = [
+  "serialize",
+  "bevy_gilrs",
+] }
+bevy_egui = { version = "0.20", optional = true }
+
+petitset = { version = "0.2.1", features = ["serde_compat"] }
+derive_more = { version = "0.99", default-features = false, features = [
+  "display",
+  "error",
+] }
 itertools = "0.10"
-serde = {version = "1.0", features = ["derive"]}
-fixedbitset  = "0.4.2"
-once_cell = "1.17.0"
+serde = { version = "1.0", features = ["derive"] }
+fixedbitset = "0.4.2"
+once_cell = "1.17.1"
 
 [dev-dependencies]
-bevy = {version = "0.9", default-features = false, features = ["bevy_asset", "bevy_sprite", "bevy_text", "bevy_ui", "bevy_render", "bevy_core_pipeline", "x11"]}
-bevy_egui = {version = "0.19"}
+bevy_egui = { version = "0.20" }
+bevy = { version = "0.10", default-features = false, features = [
+  "bevy_asset",
+  "bevy_sprite",
+  "bevy_text",
+  "bevy_ui",
+  "bevy_render",
+  "bevy_core_pipeline",
+  "x11",
+] }
 serde_test = "1.0"
 
 [lib]
diff --git a/RELEASES.md b/RELEASES.md
index 16b5df65..2559e2d1 100644
--- a/RELEASES.md
+++ b/RELEASES.md
@@ -5,6 +5,8 @@
 ### Usability
 
 - Added `ActionState::consume_all()` to consume all actions.
+- `bevy_egui` dependency has been bumped from 0.19 to 0.20.
+- `bevy` dependency has been bumped from 0.9 to 0.10.
 
 ### Enhancements
 
diff --git a/examples/arpg_indirection.rs b/examples/arpg_indirection.rs
index b09f0528..eacb5377 100644
--- a/examples/arpg_indirection.rs
+++ b/examples/arpg_indirection.rs
@@ -19,9 +19,10 @@ fn main() {
         .add_plugin(InputManagerPlugin::<Ability>::default())
         .add_startup_system(spawn_player)
         // This system coordinates the state of our two actions
-        .add_system_to_stage(
-            CoreStage::PreUpdate,
-            copy_action_state.after(InputManagerSystem::ManualControl),
+        .add_system(
+            copy_action_state
+                .in_base_set(CoreSet::PreUpdate)
+                .after(InputManagerSystem::ManualControl),
         )
         // Try it out, using QWER / left click / right click!
         .add_system(report_abilities_used)
diff --git a/examples/binding_menu.rs b/examples/binding_menu.rs
index 843b88e6..95d478d7 100644
--- a/examples/binding_menu.rs
+++ b/examples/binding_menu.rs
@@ -1,11 +1,17 @@
 use bevy::{
     ecs::system::SystemParam,
-    input::{keyboard::KeyboardInput, mouse::MouseButtonInput, ButtonState},
+    input::{
+        gamepad::{GamepadButtonChangedEvent, GamepadEvent},
+        keyboard::KeyboardInput,
+        mouse::MouseButtonInput,
+        ButtonState,
+    },
     prelude::*,
+    window::PrimaryWindow,
 };
 use bevy_egui::{
     egui::{Align2, Area, Grid, Window},
-    EguiContext, EguiPlugin,
+    EguiContexts, EguiPlugin,
 };
 use derive_more::Display;
 use leafwing_input_manager::{prelude::*, user_input::InputKind};
@@ -37,12 +43,12 @@ fn spawn_player_system(mut commands: Commands, control_settings: Res<ControlSett
 
 fn controls_window_system(
     mut commands: Commands,
-    mut egui: ResMut<EguiContext>,
-    windows: Res<Windows>,
+    mut egui: EguiContexts,
+    windows: Query<&bevy::window::Window, With<PrimaryWindow>>,
     control_settings: ResMut<ControlSettings>,
 ) {
     // The window may not exist when the application closes
-    let Some(main_window) = windows.get_primary() else {
+    let Ok(main_window) = windows.get_single() else {
         return;
     };
     let window_width_margin = egui.ctx_mut().style().spacing.window_margin.left * 2.0;
@@ -89,7 +95,7 @@ fn controls_window_system(
 }
 
 fn buttons_system(
-    mut egui: ResMut<EguiContext>,
+    mut egui: EguiContexts,
     mut control_settings: ResMut<ControlSettings>,
     mut player_mappings: Query<&mut InputMap<ControlAction>>,
 ) {
@@ -109,7 +115,7 @@ fn buttons_system(
 
 fn binding_window_system(
     mut commands: Commands,
-    mut egui: ResMut<EguiContext>,
+    mut egui: EguiContexts,
     mut input_events: InputEvents,
     active_binding: Option<ResMut<ActiveBinding>>,
     mut control_settings: ResMut<ControlSettings>,
@@ -265,15 +271,14 @@ impl InputEvents<'_, '_> {
                 return Some(mouse_input.button.into());
             }
         }
-        if let Some(GamepadEvent {
+        if let Some(GamepadEvent::Button(GamepadButtonChangedEvent {
             gamepad: _,
-            event_type,
-        }) = self.gamepad_events.iter().next()
+            button_type,
+            value: strength,
+        })) = self.gamepad_events.iter().next()
         {
-            if let GamepadEventType::ButtonChanged(button, strength) = event_type.to_owned() {
-                if strength <= 0.5 {
-                    return Some(button.into());
-                }
+            if *strength <= 0.5 {
+                return Some((*button_type).into());
             }
         }
         None
diff --git a/examples/press_duration.rs b/examples/press_duration.rs
index 0cdc926d..44efa706 100644
--- a/examples/press_duration.rs
+++ b/examples/press_duration.rs
@@ -3,7 +3,7 @@
 //!
 //! Press Left / Right or A / D to move your character to the left and right!
 
-use bevy::prelude::*;
+use bevy::{prelude::*, window::PrimaryWindow};
 use leafwing_input_manager::prelude::*;
 
 fn main() {
@@ -115,8 +115,11 @@ fn drag(mut query: Query<&mut Velocity>, time: Res<Time>) {
     }
 }
 
-fn wall_collisions(mut query: Query<(&Transform, &mut Velocity)>, windows: Res<Windows>) {
-    let window_width = windows.get_primary().unwrap().width();
+fn wall_collisions(
+    mut query: Query<(&Transform, &mut Velocity)>,
+    windows: Query<&Window, With<PrimaryWindow>>,
+) {
+    let window_width = windows.single().width();
     let left_side = 0.0 - window_width / 2.0;
     let right_side = 0.0 + window_width / 2.0;
 
diff --git a/examples/send_actions_over_network.rs b/examples/send_actions_over_network.rs
index b16e853e..800a3f06 100644
--- a/examples/send_actions_over_network.rs
+++ b/examples/send_actions_over_network.rs
@@ -36,10 +36,7 @@ fn main() {
         .add_plugin(InputPlugin)
         .add_plugin(InputManagerPlugin::<FpsAction>::default())
         // Creates an event stream of `ActionDiffs` to send to the server
-        .add_system_to_stage(
-            CoreStage::PostUpdate,
-            generate_action_diffs::<FpsAction, StableId>,
-        )
+        .add_system(generate_action_diffs::<FpsAction, StableId>.in_base_set(CoreSet::PostUpdate))
         .add_event::<ActionDiff<FpsAction, StableId>>()
         .add_startup_system(spawn_player);
 
@@ -49,10 +46,7 @@ fn main() {
         .add_plugin(InputManagerPlugin::<FpsAction>::server())
         .add_event::<ActionDiff<FpsAction, StableId>>()
         // Reads in the event stream of `ActionDiffs` to update the `ActionState`
-        .add_system_to_stage(
-            CoreStage::PreUpdate,
-            process_action_diffs::<FpsAction, StableId>,
-        )
+        .add_system(process_action_diffs::<FpsAction, StableId>.in_base_set(CoreSet::PreUpdate))
         // Typically, the rest of this information would synchronized as well
         .add_startup_system(spawn_player);
 
diff --git a/examples/ui_driven_actions.rs b/examples/ui_driven_actions.rs
index c5c09601..5600e836 100644
--- a/examples/ui_driven_actions.rs
+++ b/examples/ui_driven_actions.rs
@@ -9,7 +9,7 @@ fn main() {
         .add_plugin(InputManagerPlugin::<Action>::default())
         .add_startup_system(spawn_player)
         .add_startup_system(spawn_cameras)
-        .add_startup_system_to_stage(StartupStage::PostStartup, spawn_ui)
+        .add_startup_system(spawn_ui.in_base_set(StartupSet::PostStartup))
         .add_system(move_player)
         .run();
 }
diff --git a/src/input_mocking.rs b/src/input_mocking.rs
index 5429e559..8fe16fc0 100644
--- a/src/input_mocking.rs
+++ b/src/input_mocking.rs
@@ -18,11 +18,11 @@ use bevy::ecs::system::{ResMut, SystemState};
 use bevy::ecs::world::World;
 #[cfg(feature = "ui")]
 use bevy::ecs::{component::Component, query::With, system::Query};
-use bevy::input::gamepad::GamepadEventRaw;
+use bevy::input::gamepad::{GamepadAxisChangedEvent, GamepadButtonChangedEvent};
 use bevy::input::mouse::MouseScrollUnit;
 use bevy::input::ButtonState;
 use bevy::input::{
-    gamepad::{Gamepad, GamepadButton, GamepadEvent, GamepadEventType},
+    gamepad::{Gamepad, GamepadButton, GamepadEvent},
     keyboard::{KeyCode, KeyboardInput},
     mouse::{MouseButton, MouseButtonInput, MouseMotion, MouseWheel},
     touch::{TouchInput, Touches},
@@ -216,10 +216,12 @@ impl MockInput for MutableInputStreams<'_> {
         // Gamepad buttons
         for button_type in raw_inputs.gamepad_buttons {
             if let Some(gamepad) = gamepad {
-                self.gamepad_events.send(GamepadEventRaw {
-                    gamepad,
-                    event_type: GamepadEventType::ButtonChanged(button_type, 1.0),
-                });
+                self.gamepad_events
+                    .send(GamepadEvent::Button(GamepadButtonChangedEvent {
+                        gamepad,
+                        button_type,
+                        value: 1.0,
+                    }));
             }
         }
 
@@ -229,10 +231,12 @@ impl MockInput for MutableInputStreams<'_> {
                 match outer_axis_type {
                     AxisType::Gamepad(axis_type) => {
                         if let Some(gamepad) = gamepad {
-                            self.gamepad_events.send(GamepadEventRaw {
-                                gamepad,
-                                event_type: GamepadEventType::AxisChanged(axis_type, position_data),
-                            });
+                            self.gamepad_events
+                                .send(GamepadEvent::Axis(GamepadAxisChangedEvent {
+                                    gamepad,
+                                    axis_type,
+                                    value: position_data,
+                                }));
                         }
                     }
                     AxisType::MouseWheel(axis_type) => {
@@ -281,10 +285,12 @@ impl MockInput for MutableInputStreams<'_> {
 
         for button_type in raw_inputs.gamepad_buttons {
             if let Some(gamepad) = gamepad {
-                self.gamepad_events.send(GamepadEventRaw {
-                    gamepad,
-                    event_type: GamepadEventType::ButtonChanged(button_type, 1.0),
-                });
+                self.gamepad_events
+                    .send(GamepadEvent::Button(GamepadButtonChangedEvent {
+                        gamepad,
+                        button_type,
+                        value: 1.0,
+                    }));
             }
         }
 
@@ -481,7 +487,10 @@ impl MockInput for App {
 mod test {
     use crate::input_mocking::MockInput;
     use bevy::{
-        input::{gamepad::GamepadInfo, InputPlugin},
+        input::{
+            gamepad::{GamepadConnection, GamepadConnectionEvent, GamepadEvent, GamepadInfo},
+            InputPlugin,
+        },
         prelude::*,
     };
 
@@ -522,12 +531,12 @@ mod test {
 
         let gamepad = Gamepad { id: 0 };
         let mut gamepad_events = app.world.resource_mut::<Events<GamepadEvent>>();
-        gamepad_events.send(GamepadEvent {
+        gamepad_events.send(GamepadEvent::Connection(GamepadConnectionEvent {
             gamepad,
-            event_type: GamepadEventType::Connected(GamepadInfo {
+            connection: GamepadConnection::Connected(GamepadInfo {
                 name: "TestController".into(),
             }),
-        });
+        }));
         app.update();
 
         // Test that buttons are unpressed by default
@@ -562,12 +571,12 @@ mod test {
 
         let gamepad = Gamepad { id: 0 };
         let mut gamepad_events = app.world.resource_mut::<Events<GamepadEvent>>();
-        gamepad_events.send(GamepadEvent {
+        gamepad_events.send(GamepadEvent::Connection(GamepadConnectionEvent {
             gamepad,
-            event_type: GamepadEventType::Connected(GamepadInfo {
+            connection: GamepadConnection::Connected(GamepadInfo {
                 name: "TestController".into(),
             }),
-        });
+        }));
         app.update();
 
         // Test that buttons are unpressed by default
diff --git a/src/input_streams.rs b/src/input_streams.rs
index 00ee6aca..2ea5b838 100644
--- a/src/input_streams.rs
+++ b/src/input_streams.rs
@@ -1,13 +1,10 @@
 //! Unified input streams for working with [`bevy::input`] data.
 
-use bevy::{
-    input::{
-        gamepad::{Gamepad, GamepadAxis, GamepadButton, GamepadEventRaw, Gamepads},
-        keyboard::{KeyCode, KeyboardInput},
-        mouse::{MouseButton, MouseButtonInput, MouseMotion, MouseWheel},
-        Axis, Input,
-    },
-    prelude::ScanCode,
+use bevy::input::{
+    gamepad::{Gamepad, GamepadAxis, GamepadButton, GamepadEvent, Gamepads},
+    keyboard::{KeyCode, KeyboardInput, ScanCode},
+    mouse::{MouseButton, MouseButtonInput, MouseMotion, MouseWheel},
+    Axis, Input,
 };
 use petitset::PetitSet;
 
@@ -403,7 +400,7 @@ pub struct MutableInputStreams<'a> {
     /// A list of registered [`Gamepads`]
     pub gamepads: &'a mut Gamepads,
     /// Events used for mocking gamepad-related inputs
-    pub gamepad_events: &'a mut Events<GamepadEventRaw>,
+    pub gamepad_events: &'a mut Events<GamepadEvent>,
 
     /// A [`KeyCode`] [`Input`] stream
     pub keycodes: &'a mut Input<KeyCode>,
@@ -433,7 +430,7 @@ impl<'a> MutableInputStreams<'a> {
             ResMut<Axis<GamepadButton>>,
             ResMut<Axis<GamepadAxis>>,
             ResMut<Gamepads>,
-            ResMut<Events<GamepadEventRaw>>,
+            ResMut<Events<GamepadEvent>>,
             ResMut<Input<KeyCode>>,
             ResMut<Input<ScanCode>>,
             ResMut<Events<KeyboardInput>>,
diff --git a/src/plugin.rs b/src/plugin.rs
index 89b13c8a..6db2c24f 100644
--- a/src/plugin.rs
+++ b/src/plugin.rs
@@ -7,9 +7,10 @@ use core::hash::Hash;
 use core::marker::PhantomData;
 use std::fmt::Debug;
 
-use bevy::app::{App, CoreStage, Plugin};
+use bevy::app::{App, Plugin};
 use bevy::ecs::prelude::*;
 use bevy::input::InputSystem;
+use bevy::prelude::CoreSet;
 #[cfg(feature = "ui")]
 use bevy::ui::UiSystem;
 
@@ -33,17 +34,17 @@ use bevy::ui::UiSystem;
 /// **WARNING:** Theses systems run during [`CoreStage::PreUpdate`].
 /// If you have systems that care about inputs and actions that also run during this stage,
 /// you must define an ordering between your systems or behavior will be very erratic.
-/// The stable labels for these systems are available under [`InputManagerSystem`] enum.
+/// The stable system sets for these systems are available under [`InputManagerSystem`] enum.
 ///
 /// Complete list:
 ///
 /// - [`tick_action_state`](crate::systems::tick_action_state), which resets the `pressed` and `just_pressed` fields of the [`ActionState`](crate::action_state::ActionState) each frame
-///     - labeled [`InputManagerSystem::Reset`]
+///     - in set [`InputManagerSystem::Reset`]
 /// - [`update_action_state`](crate::systems::update_action_state), which collects [`Input`](bevy::input::Input) resources to update the [`ActionState`](crate::action_state::ActionState)
-///     - labeled [`InputManagerSystem::Update`]
+///     - in set [`InputManagerSystem::Update`]
 /// - [`update_action_state_from_interaction`](crate::systems::update_action_state_from_interaction), for triggering actions from buttons
 ///    - powers the [`ActionStateDriver`](crate::action_state::ActionStateDriver) component baseod on an [`Interaction`](bevy::ui::Interaction) component
-///    - labeled [`InputManagerSystem::Update`]
+///    - in set [`InputManagerSystem::Update`]
 /// - [`release_on_disable`](crate::systems::release_on_disable), which resets action states when [`ToggleActions`] is flipped, to avoid persistent presses.
 pub struct InputManagerPlugin<A: Actionlike> {
     _phantom: PhantomData<A>,
@@ -87,45 +88,45 @@ impl<A: Actionlike> Plugin for InputManagerPlugin<A> {
 
         match self.machine {
             Machine::Client => {
-                app.add_system_to_stage(
-                    CoreStage::PreUpdate,
+                app.add_system(
                     tick_action_state::<A>
-                        .with_run_criteria(run_if_enabled::<A>)
-                        .label(InputManagerSystem::Tick)
+                        .run_if(run_if_enabled::<A>)
+                        .in_base_set(CoreSet::PreUpdate)
+                        .in_set(InputManagerSystem::Tick)
                         .before(InputManagerSystem::Update),
                 )
-                .add_system_to_stage(
-                    CoreStage::PreUpdate,
+                .add_system(
                     release_on_disable::<A>
-                        .label(InputManagerSystem::ReleaseOnDisable)
+                        .in_base_set(CoreSet::PreUpdate)
+                        .in_set(InputManagerSystem::ReleaseOnDisable)
                         .after(InputManagerSystem::Update),
                 )
-                .add_system_to_stage(CoreStage::PostUpdate, release_on_input_map_removed::<A>);
+                .add_system(release_on_input_map_removed::<A>.in_base_set(CoreSet::PostUpdate));
 
                 #[cfg(feature = "egui")]
-                app.add_system_to_stage(
-                    CoreStage::PreUpdate,
+                app.add_system(
                     update_action_state::<A>
-                        .with_run_criteria(run_if_enabled::<A>)
-                        .label(InputManagerSystem::Update)
+                        .run_if(run_if_enabled::<A>)
+                        .in_base_set(CoreSet::PreUpdate)
+                        .in_set(InputManagerSystem::Update)
                         .after(InputSystem)
-                        .after(bevy_egui::EguiSystem::ProcessInput),
+                        .after(bevy_egui::EguiSet::ProcessInput),
                 );
                 #[cfg(not(feature = "egui"))]
-                app.add_system_to_stage(
-                    CoreStage::PreUpdate,
+                app.add_system(
                     update_action_state::<A>
-                        .with_run_criteria(run_if_enabled::<A>)
-                        .label(InputManagerSystem::Update)
+                        .run_if(run_if_enabled::<A>)
+                        .in_base_set(CoreSet::PreUpdate)
+                        .in_set(InputManagerSystem::Update)
                         .after(InputSystem),
                 );
 
                 #[cfg(feature = "ui")]
-                app.add_system_to_stage(
-                    CoreStage::PreUpdate,
+                app.add_system(
                     update_action_state_from_interaction::<A>
-                        .with_run_criteria(run_if_enabled::<A>)
-                        .label(InputManagerSystem::ManualControl)
+                        .run_if(run_if_enabled::<A>)
+                        .in_base_set(CoreSet::PreUpdate)
+                        .in_set(InputManagerSystem::ManualControl)
                         .before(InputManagerSystem::ReleaseOnDisable)
                         .after(InputManagerSystem::Tick)
                         // Must run after the system is updated from inputs, or it will be forcibly released due to the inputs
@@ -136,11 +137,11 @@ impl<A: Actionlike> Plugin for InputManagerPlugin<A> {
                 );
             }
             Machine::Server => {
-                app.add_system_to_stage(
-                    CoreStage::PreUpdate,
+                app.add_system(
                     tick_action_state::<A>
-                        .with_run_criteria(run_if_enabled::<A>)
-                        .label(InputManagerSystem::Tick),
+                        .run_if(run_if_enabled::<A>)
+                        .in_base_set(CoreSet::PreUpdate)
+                        .in_set(InputManagerSystem::Tick),
                 );
             }
         };
@@ -188,10 +189,10 @@ impl<A: Actionlike> Default for ToggleActions<A> {
     }
 }
 
-/// [`SystemLabel`]s for the [`crate::systems`] used by this crate
+/// [`SystemSet`]s for the [`crate::systems`] used by this crate
 ///
 /// `Reset` must occur before `Update`
-#[derive(SystemLabel, Clone, Hash, Debug, PartialEq, Eq)]
+#[derive(SystemSet, Clone, Hash, Debug, PartialEq, Eq)]
 pub enum InputManagerSystem {
     /// Advances action timers.
     ///
diff --git a/src/systems.rs b/src/systems.rs
index fabc384a..7909038c 100644
--- a/src/systems.rs
+++ b/src/systems.rs
@@ -20,15 +20,12 @@ use bevy::input::{
 };
 use bevy::time::Time;
 use bevy::utils::Instant;
-use bevy::{
-    ecs::{prelude::*, schedule::ShouldRun},
-    prelude::ScanCode,
-};
+use bevy::{ecs::prelude::*, prelude::ScanCode};
 
 #[cfg(feature = "ui")]
 use bevy::ui::Interaction;
 #[cfg(feature = "egui")]
-use bevy_egui::EguiContext;
+use bevy_egui::EguiContexts;
 
 /// Advances actions timer.
 ///
@@ -75,7 +72,7 @@ pub fn update_action_state<A: Actionlike>(
     mouse_wheel: Option<Res<Events<MouseWheel>>>,
     mouse_motion: Res<Events<MouseMotion>>,
     clash_strategy: Res<ClashStrategy>,
-    #[cfg(feature = "egui")] maybe_egui: Option<ResMut<EguiContext>>,
+    #[cfg(feature = "egui")] mut maybe_egui: EguiContexts,
     action_state: Option<ResMut<ActionState<A>>>,
     input_map: Option<Res<InputMap<A>>>,
     press_scheduler: Option<ResMut<PressScheduler<A>>>,
@@ -96,23 +93,23 @@ pub fn update_action_state<A: Actionlike>(
     let mouse_motion = mouse_motion.into_inner();
 
     #[cfg(feature = "egui")]
-    let (keycodes, scan_codes, mouse_buttons, mouse_wheel) = if let Some(mut egui) = maybe_egui {
-        let ctx = egui.ctx_mut();
-        // If egui wants to own inputs, don't also apply them to the game state
-        let keycodes = keycodes.filter(|_| !ctx.wants_keyboard_input());
-        let scan_codes = scan_codes.filter(|_| !ctx.wants_keyboard_input());
+    let ctx = maybe_egui.ctx_mut();
+
+    // If egui wants to own inputs, don't also apply them to the game state
+    #[cfg(feature = "egui")]
+    let (keycodes, scan_codes) = if ctx.wants_keyboard_input() {
+        (None, None)
+    } else {
+        (keycodes, scan_codes)
+    };
 
-        // `wants_pointer_input` sometimes returns `false` after clicking or holding a button over a widget,
-        // so `is_pointer_over_area` is also needed.
-        let mouse_buttons =
-            mouse_buttons.filter(|_| !ctx.is_pointer_over_area() && !ctx.wants_pointer_input());
-        let mouse_wheel =
-            mouse_wheel.filter(|_| !ctx.is_pointer_over_area() && !ctx.wants_pointer_input());
-        (keycodes, scan_codes, mouse_buttons, mouse_wheel)
+    // `wants_pointer_input` sometimes returns `false` after clicking or holding a button over a widget,
+    // so `is_pointer_over_area` is also needed.
+    #[cfg(feature = "egui")]
+    let (mouse_buttons, mouse_wheel) = if ctx.is_pointer_over_area() || ctx.wants_pointer_input() {
+        (None, None)
     } else {
-        // We don't just want to make these variables mutable
-        // because then we'll have unused mut when the feature is not enabled
-        (keycodes, scan_codes, mouse_buttons, mouse_wheel)
+        (mouse_buttons, mouse_wheel)
     };
 
     let resources = input_map
@@ -250,7 +247,7 @@ pub fn release_on_disable<A: Actionlike>(
 /// For components you must remove the [`InputMap<A>`] before [`CoreStage::PostUpdate`](bevy::prelude::CoreStage::PostUpdate)
 /// or this will not run.
 pub fn release_on_input_map_removed<A: Actionlike>(
-    removed_components: RemovedComponents<InputMap<A>>,
+    mut removed_components: RemovedComponents<InputMap<A>>,
     input_map_resource: Option<ResMut<InputMap<A>>>,
     action_state_resource: Option<ResMut<ActionState<A>>>,
     mut input_map_resource_existed: Local<bool>,
@@ -278,10 +275,6 @@ pub fn release_on_input_map_removed<A: Actionlike>(
 }
 
 /// Returns [`ShouldRun::No`] if [`DisableInput`] exists and [`ShouldRun::Yes`] otherwise
-pub(super) fn run_if_enabled<A: Actionlike>(toggle_actions: Res<ToggleActions<A>>) -> ShouldRun {
-    if toggle_actions.enabled {
-        ShouldRun::Yes
-    } else {
-        ShouldRun::No
-    }
+pub(super) fn run_if_enabled<A: Actionlike>(toggle_actions: Res<ToggleActions<A>>) -> bool {
+    toggle_actions.enabled
 }
diff --git a/tests/gamepad_axis.rs b/tests/gamepad_axis.rs
index 235b6a6f..76c5f46c 100644
--- a/tests/gamepad_axis.rs
+++ b/tests/gamepad_axis.rs
@@ -1,4 +1,6 @@
-use bevy::input::gamepad::{GamepadEventRaw, GamepadInfo};
+use bevy::input::gamepad::{
+    GamepadAxisChangedEvent, GamepadConnection, GamepadConnectionEvent, GamepadEvent, GamepadInfo,
+};
 use bevy::input::InputPlugin;
 use bevy::prelude::*;
 use leafwing_input_manager::axislike::{AxisType, DualAxisData};
@@ -29,14 +31,14 @@ fn test_app() -> App {
         .init_resource::<ActionState<AxislikeTestAction>>();
 
     // WARNING: you MUST register your gamepad during tests, or all gamepad input mocking will fail
-    let mut gamepad_events = app.world.resource_mut::<Events<GamepadEventRaw>>();
-    gamepad_events.send(GamepadEventRaw {
+    let mut gamepad_events = app.world.resource_mut::<Events<GamepadEvent>>();
+    gamepad_events.send(GamepadEvent::Connection(GamepadConnectionEvent {
         // This MUST be consistent with any other mocked events
         gamepad: Gamepad { id: 1 },
-        event_type: GamepadEventType::Connected(GamepadInfo {
+        connection: GamepadConnection::Connected(GamepadInfo {
             name: "TestController".into(),
         }),
-    });
+    }));
 
     // Ensure that the gamepad is picked up by the appropriate system
     app.update();
@@ -54,11 +56,12 @@ fn raw_gamepad_axis_events() {
         ButtonlikeTestAction::Up,
     )]));
 
-    let mut events = app.world.resource_mut::<Events<GamepadEventRaw>>();
-    events.send(GamepadEventRaw {
+    let mut events = app.world.resource_mut::<Events<GamepadEvent>>();
+    events.send(GamepadEvent::Axis(GamepadAxisChangedEvent {
         gamepad: Gamepad { id: 1 },
-        event_type: GamepadEventType::AxisChanged(GamepadAxisType::RightStickX, 1.0),
-    });
+        axis_type: GamepadAxisType::RightStickX,
+        value: 1.0,
+    }));
 
     app.update();
     let action_state = app.world.resource::<ActionState<ButtonlikeTestAction>>();
@@ -68,7 +71,7 @@ fn raw_gamepad_axis_events() {
 #[test]
 fn game_pad_single_axis_mocking() {
     let mut app = test_app();
-    let mut events = app.world.resource_mut::<Events<GamepadEventRaw>>();
+    let mut events = app.world.resource_mut::<Events<GamepadEvent>>();
     assert_eq!(events.drain().count(), 0);
 
     let input = SingleAxis {
@@ -79,14 +82,14 @@ fn game_pad_single_axis_mocking() {
     };
 
     app.send_input(input);
-    let mut events = app.world.resource_mut::<Events<GamepadEventRaw>>();
+    let mut events = app.world.resource_mut::<Events<GamepadEvent>>();
     assert_eq!(events.drain().count(), 1);
 }
 
 #[test]
 fn game_pad_dual_axis_mocking() {
     let mut app = test_app();
-    let mut events = app.world.resource_mut::<Events<GamepadEventRaw>>();
+    let mut events = app.world.resource_mut::<Events<GamepadEvent>>();
     assert_eq!(events.drain().count(), 0);
 
     let input = DualAxis {
@@ -104,7 +107,7 @@ fn game_pad_dual_axis_mocking() {
         },
     };
     app.send_input(input);
-    let mut events = app.world.resource_mut::<Events<GamepadEventRaw>>();
+    let mut events = app.world.resource_mut::<Events<GamepadEvent>>();
     // Dual axis events are split out
     assert_eq!(events.drain().count(), 2);
 }
diff --git a/tests/integration.rs b/tests/integration.rs
index 9eea171b..741ccfdd 100644
--- a/tests/integration.rs
+++ b/tests/integration.rs
@@ -1,5 +1,3 @@
-#![cfg(test)]
-use bevy::ecs::query::ChangeTrackers;
 use bevy::prelude::*;
 use leafwing_input_manager::prelude::*;
 use leafwing_input_manager::press_scheduler::PressScheduler;
@@ -94,40 +92,6 @@ fn do_nothing() {
     }
 }
 
-#[test]
-fn action_state_change_detection() {
-    use bevy::input::InputPlugin;
-
-    let mut app = App::new();
-
-    app.add_plugins(MinimalPlugins)
-        .add_plugin(InputPlugin)
-        .add_plugin(InputManagerPlugin::<Action>::default())
-        .add_startup_system(spawn_player)
-        .add_system(action_state_changed_iff_input_changed);
-
-    for i in 0..10 {
-        if i % 2 == 0 {
-            app.send_input(KeyCode::F);
-        }
-
-        app.update();
-    }
-
-    fn action_state_changed_iff_input_changed(
-        query: Query<ChangeTrackers<ActionState<Action>>>,
-        input: Res<Input<KeyCode>>,
-    ) {
-        let action_state_tracker = query.single();
-
-        if input.is_changed() {
-            assert!(action_state_tracker.is_changed());
-        } else {
-            assert!(!action_state_tracker.is_changed());
-        }
-    }
-}
-
 #[test]
 fn disable_input() {
     use bevy::input::InputPlugin;
@@ -144,7 +108,7 @@ fn disable_input() {
         .insert_resource(InputMap::<Action>::new([(KeyCode::F, Action::PayRespects)]))
         .init_resource::<Respect>()
         .add_system(pay_respects)
-        .add_system_to_stage(CoreStage::PreUpdate, respect_fades);
+        .add_system(respect_fades.in_base_set(CoreSet::PreUpdate));
 
     // Press F to pay respects
     app.send_input(KeyCode::F);
@@ -184,7 +148,7 @@ fn release_when_input_map_removed() {
         .init_resource::<Respect>()
         .add_system(pay_respects)
         .add_system(remove_input_map)
-        .add_system_to_stage(CoreStage::PreUpdate, respect_fades);
+        .add_system(respect_fades.in_base_set(CoreSet::PreUpdate));
 
     // Press F to pay respects
     app.send_input(KeyCode::F);
@@ -244,7 +208,7 @@ fn action_state_driver() {
         .add_plugin(InputPlugin)
         .add_startup_system(setup)
         .add_system(pay_respects)
-        .add_system_to_stage(CoreStage::PreUpdate, respect_fades)
+        .add_system(respect_fades.in_base_set(CoreSet::PreUpdate))
         .init_resource::<Respect>();
 
     app.update();