diff --git a/crates/bevy_input/src/common_conditions.rs b/crates/bevy_input/src/common_conditions.rs
index 06043a0ae9f17..d5c46bece70db 100644
--- a/crates/bevy_input/src/common_conditions.rs
+++ b/crates/bevy_input/src/common_conditions.rs
@@ -1,5 +1,6 @@
 use crate::Input;
 use bevy_ecs::system::Res;
+use bevy_reflect::FromReflect;
 use std::hash::Hash;
 
 /// Stateful run condition that can be toggled via a input press using [`Input::just_pressed`].
@@ -49,7 +50,7 @@ use std::hash::Hash;
 /// ```
 pub fn input_toggle_active<T>(default: bool, input: T) -> impl FnMut(Res<Input<T>>) -> bool + Clone
 where
-    T: Copy + Eq + Hash + Send + Sync + 'static,
+    T: FromReflect + Copy + Eq + Hash + Send + Sync + 'static,
 {
     let mut active = default;
     move |inputs: Res<Input<T>>| {
@@ -61,7 +62,7 @@ where
 /// Run condition that is active if [`Input::pressed`] is true for the given input.
 pub fn input_pressed<T>(input: T) -> impl FnMut(Res<Input<T>>) -> bool + Clone
 where
-    T: Copy + Eq + Hash + Send + Sync + 'static,
+    T: FromReflect + Copy + Eq + Hash + Send + Sync + 'static,
 {
     move |inputs: Res<Input<T>>| inputs.pressed(input)
 }
@@ -82,15 +83,15 @@ where
 /// ```
 pub fn input_just_pressed<T>(input: T) -> impl FnMut(Res<Input<T>>) -> bool + Clone
 where
-    T: Copy + Eq + Hash + Send + Sync + 'static,
+    T: FromReflect + Clone + Eq + Hash + Send + Sync + 'static,
 {
-    move |inputs: Res<Input<T>>| inputs.just_pressed(input)
+    move |inputs: Res<Input<T>>| inputs.just_pressed(input.clone())
 }
 
 /// Run condition that is active if [`Input::just_released`] is true for the given input.
 pub fn input_just_released<T>(input: T) -> impl FnMut(Res<Input<T>>) -> bool + Clone
 where
-    T: Copy + Eq + Hash + Send + Sync + 'static,
+    T: FromReflect + Copy + Eq + Hash + Send + Sync + 'static,
 {
     move |inputs: Res<Input<T>>| inputs.just_released(input)
 }
diff --git a/crates/bevy_input/src/input.rs b/crates/bevy_input/src/input.rs
index b1ecd8c3ba79c..e731131e92bfb 100644
--- a/crates/bevy_input/src/input.rs
+++ b/crates/bevy_input/src/input.rs
@@ -1,8 +1,9 @@
 //! The generic input type.
 
 use bevy_ecs::system::Resource;
-use bevy_reflect::{std_traits::ReflectDefault, Reflect};
-use bevy_utils::HashSet;
+
+use bevy_reflect::{std_traits::ReflectDefault, FromReflect, Reflect};
+use bevy_utils::{HashMap, HashSet};
 use std::hash::Hash;
 
 // unused import, but needed for intra doc link to work
@@ -45,31 +46,49 @@ use bevy_ecs::schedule::State;
 ///[`DetectChangesMut::bypass_change_detection`]: bevy_ecs::change_detection::DetectChangesMut::bypass_change_detection
 #[derive(Debug, Clone, Resource, Reflect)]
 #[reflect(Default)]
-pub struct Input<T: Clone + Eq + Hash + Send + Sync + 'static> {
+pub struct Input<T: FromReflect + Clone + Eq + Hash + Send + Sync + 'static> {
     /// A collection of every button that is currently being pressed.
     pressed: HashSet<T>,
     /// A collection of every button that has just been pressed.
     just_pressed: HashSet<T>,
     /// A collection of every button that has just been released.
     just_released: HashSet<T>,
+    /// To map logical keys with their respecting physical keys for reliability.
+    dynamic_map_value: HashMap<T, T>,
 }
 
-impl<T: Clone + Eq + Hash + Send + Sync + 'static> Default for Input<T> {
+impl<T: FromReflect + Clone + Eq + Hash + Send + Sync + 'static> Default for Input<T> {
     fn default() -> Self {
         Self {
             pressed: Default::default(),
             just_pressed: Default::default(),
             just_released: Default::default(),
+            dynamic_map_value: HashMap::default(),
         }
     }
 }
 
 impl<T> Input<T>
 where
-    T: Clone + Eq + Hash + Send + Sync + 'static,
+    T: FromReflect + Clone + Eq + Hash + Send + Sync + 'static,
 {
+    /// When user adds modifiers to a keypress, the underlying Logical key might change.<br />
+    /// Use this to store a reference to the original `LogicalKey`.
+    pub fn add_dynamic_mapping<V: Into<T>, S: Into<T>>(&mut self, user_visible: V, stored: S) {
+        self.dynamic_map_value
+            .insert(user_visible.into(), stored.into());
+    }
+
+    /// To call when a dynamic key mapping is not longer needed.
+    pub fn release_dynamic_mapping<I: Into<T>>(&mut self, key: I) {
+        let to_remove = key.into();
+        self.dynamic_map_value
+            .retain(|k, v| k != &to_remove && v != &to_remove);
+    }
+
     /// Registers a press for the given `input`.
-    pub fn press(&mut self, input: T) {
+    pub fn press<I: Into<T>>(&mut self, input: I) {
+        let input = input.into();
         // Returns `true` if the `input` wasn't pressed.
         if self.pressed.insert(input.clone()) {
             self.just_pressed.insert(input);
@@ -77,20 +96,24 @@ where
     }
 
     /// Returns `true` if the `input` has been pressed.
-    pub fn pressed(&self, input: T) -> bool {
+    pub fn pressed<I: Into<T>>(&self, input: I) -> bool {
+        let input = input.into();
+        let input = self.dynamic_map_value.get(&input).unwrap_or(&input).clone();
         self.pressed.contains(&input)
     }
 
     /// Returns `true` if any item in `inputs` has been pressed.
-    pub fn any_pressed(&self, inputs: impl IntoIterator<Item = T>) -> bool {
+    pub fn any_pressed<I: Into<T>>(&self, inputs: impl IntoIterator<Item = I>) -> bool {
         inputs.into_iter().any(|it| self.pressed(it))
     }
 
     /// Registers a release for the given `input`.
-    pub fn release(&mut self, input: T) {
+    pub fn release<I: Into<T>>(&mut self, input: I) {
+        let input = input.into();
+        let input = self.dynamic_map_value.get(&input).unwrap_or(&input).clone();
         // Returns `true` if the `input` was pressed.
         if self.pressed.remove(&input) {
-            self.just_released.insert(input);
+            self.just_released.insert(input.clone());
         }
     }
 
@@ -101,44 +124,53 @@ where
     }
 
     /// Returns `true` if the `input` has just been pressed.
-    pub fn just_pressed(&self, input: T) -> bool {
+    pub fn just_pressed<I: Into<T>>(&self, input: I) -> bool {
+        let input = input.into();
+        let input = self.dynamic_map_value.get(&input).unwrap_or(&input).clone();
         self.just_pressed.contains(&input)
     }
 
     /// Returns `true` if any item in `inputs` has just been pressed.
-    pub fn any_just_pressed(&self, inputs: impl IntoIterator<Item = T>) -> bool {
+    pub fn any_just_pressed<I: Into<T>>(&self, inputs: impl IntoIterator<Item = I>) -> bool {
         inputs.into_iter().any(|it| self.just_pressed(it))
     }
 
     /// Clears the `just_pressed` state of the `input` and returns `true` if the `input` has just been pressed.
     ///
     /// Future calls to [`Input::just_pressed`] for the given input will return false until a new press event occurs.
-    pub fn clear_just_pressed(&mut self, input: T) -> bool {
-        self.just_pressed.remove(&input)
+    pub fn clear_just_pressed<I: Into<T>>(&mut self, input: I) -> bool {
+        self.just_pressed.remove(&input.into())
     }
 
     /// Returns `true` if the `input` has just been released.
-    pub fn just_released(&self, input: T) -> bool {
+    pub fn just_released<I: Into<T>>(&self, input: I) -> bool {
+        let input = input.into();
+        let input = self.dynamic_map_value.get(&input).unwrap_or(&input).clone();
         self.just_released.contains(&input)
     }
 
     /// Returns `true` if any item in `inputs` has just been released.
-    pub fn any_just_released(&self, inputs: impl IntoIterator<Item = T>) -> bool {
+    pub fn any_just_released<I: Into<T>>(&self, inputs: impl IntoIterator<Item = I>) -> bool {
         inputs.into_iter().any(|it| self.just_released(it))
     }
 
     /// Clears the `just_released` state of the `input` and returns `true` if the `input` has just been released.
     ///
     /// Future calls to [`Input::just_released`] for the given input will return false until a new release event occurs.
-    pub fn clear_just_released(&mut self, input: T) -> bool {
+    pub fn clear_just_released<I: Into<T>>(&mut self, input: I) -> bool {
+        let input = input.into();
+        let input = self.dynamic_map_value.get(&input).unwrap_or(&input).clone();
+        self.release_dynamic_mapping(input.clone());
         self.just_released.remove(&input)
     }
 
     /// Clears the `pressed`, `just_pressed` and `just_released` data of the `input`.
-    pub fn reset(&mut self, input: T) {
+    pub fn reset<I: Into<T>>(&mut self, input: I) {
+        let input = input.into();
         self.pressed.remove(&input);
         self.just_pressed.remove(&input);
         self.just_released.remove(&input);
+        self.dynamic_map_value.clear();
     }
 
     /// Clears the `pressed`, `just_pressed`, and `just_released` data for every input.
@@ -148,6 +180,7 @@ where
         self.pressed.clear();
         self.just_pressed.clear();
         self.just_released.clear();
+        self.dynamic_map_value.clear();
     }
 
     /// Clears the `just pressed` and `just released` data for every input.
@@ -155,7 +188,10 @@ where
     /// See also [`Input::reset_all`] for a full reset.
     pub fn clear(&mut self) {
         self.just_pressed.clear();
-        self.just_released.clear();
+        let inputs_to_release = self.just_released.drain().collect::<Vec<_>>();
+        for r in inputs_to_release {
+            self.release_dynamic_mapping(r);
+        }
     }
 
     /// An iterator visiting every pressed input in arbitrary order.
@@ -176,12 +212,13 @@ where
 
 #[cfg(test)]
 mod test {
-    use bevy_reflect::TypePath;
+    use bevy_reflect::Reflect;
 
     use crate::Input;
 
     /// Used for testing the functionality of [`Input`].
-    #[derive(TypePath, Copy, Clone, Eq, PartialEq, Hash)]
+    #[derive(Copy, Clone, Eq, PartialEq, Hash, Reflect)]
+    #[reflect_value]
     enum DummyInput {
         Input1,
         Input2,
@@ -189,7 +226,7 @@ mod test {
 
     #[test]
     fn test_press() {
-        let mut input = Input::default();
+        let mut input = Input::<DummyInput>::default();
         assert!(!input.pressed.contains(&DummyInput::Input1));
         assert!(!input.just_pressed.contains(&DummyInput::Input1));
         input.press(DummyInput::Input1);
@@ -199,7 +236,7 @@ mod test {
 
     #[test]
     fn test_pressed() {
-        let mut input = Input::default();
+        let mut input = Input::<DummyInput>::default();
         assert!(!input.pressed(DummyInput::Input1));
         input.press(DummyInput::Input1);
         assert!(input.pressed(DummyInput::Input1));
@@ -207,7 +244,7 @@ mod test {
 
     #[test]
     fn test_any_pressed() {
-        let mut input = Input::default();
+        let mut input = Input::<DummyInput>::default();
         assert!(!input.any_pressed([DummyInput::Input1]));
         assert!(!input.any_pressed([DummyInput::Input2]));
         assert!(!input.any_pressed([DummyInput::Input1, DummyInput::Input2]));
@@ -219,7 +256,7 @@ mod test {
 
     #[test]
     fn test_release() {
-        let mut input = Input::default();
+        let mut input = Input::<DummyInput>::default();
         input.press(DummyInput::Input1);
         assert!(input.pressed.contains(&DummyInput::Input1));
         assert!(!input.just_released.contains(&DummyInput::Input1));
@@ -230,7 +267,7 @@ mod test {
 
     #[test]
     fn test_release_all() {
-        let mut input = Input::default();
+        let mut input = Input::<DummyInput>::default();
         input.press(DummyInput::Input1);
         input.press(DummyInput::Input2);
         input.release_all();
@@ -241,7 +278,7 @@ mod test {
 
     #[test]
     fn test_just_pressed() {
-        let mut input = Input::default();
+        let mut input = Input::<DummyInput>::default();
         assert!(!input.just_pressed(DummyInput::Input1));
         input.press(DummyInput::Input1);
         assert!(input.just_pressed(DummyInput::Input1));
@@ -249,7 +286,7 @@ mod test {
 
     #[test]
     fn test_any_just_pressed() {
-        let mut input = Input::default();
+        let mut input = Input::<DummyInput>::default();
         assert!(!input.any_just_pressed([DummyInput::Input1]));
         assert!(!input.any_just_pressed([DummyInput::Input2]));
         assert!(!input.any_just_pressed([DummyInput::Input1, DummyInput::Input2]));
@@ -261,7 +298,7 @@ mod test {
 
     #[test]
     fn test_clear_just_pressed() {
-        let mut input = Input::default();
+        let mut input = Input::<DummyInput>::default();
         input.press(DummyInput::Input1);
         assert!(input.just_pressed(DummyInput::Input1));
         input.clear_just_pressed(DummyInput::Input1);
@@ -270,7 +307,7 @@ mod test {
 
     #[test]
     fn test_just_released() {
-        let mut input = Input::default();
+        let mut input = Input::<DummyInput>::default();
         input.press(DummyInput::Input1);
         assert!(!input.just_released(DummyInput::Input1));
         input.release(DummyInput::Input1);
@@ -279,7 +316,7 @@ mod test {
 
     #[test]
     fn test_any_just_released() {
-        let mut input = Input::default();
+        let mut input = Input::<DummyInput>::default();
         input.press(DummyInput::Input1);
         assert!(!input.any_just_released([DummyInput::Input1]));
         assert!(!input.any_just_released([DummyInput::Input2]));
@@ -292,7 +329,7 @@ mod test {
 
     #[test]
     fn test_clear_just_released() {
-        let mut input = Input::default();
+        let mut input = Input::<DummyInput>::default();
         input.press(DummyInput::Input1);
         input.release(DummyInput::Input1);
         assert!(input.just_released(DummyInput::Input1));
@@ -302,7 +339,7 @@ mod test {
 
     #[test]
     fn test_reset() {
-        let mut input = Input::default();
+        let mut input = Input::<DummyInput>::default();
 
         // Pressed
         input.press(DummyInput::Input1);
@@ -328,7 +365,7 @@ mod test {
 
     #[test]
     fn test_reset_all() {
-        let mut input = Input::default();
+        let mut input = Input::<DummyInput>::default();
 
         input.press(DummyInput::Input1);
         input.press(DummyInput::Input2);
@@ -344,7 +381,7 @@ mod test {
 
     #[test]
     fn test_clear() {
-        let mut input = Input::default();
+        let mut input = Input::<DummyInput>::default();
 
         // Pressed
         input.press(DummyInput::Input1);
@@ -370,7 +407,7 @@ mod test {
 
     #[test]
     fn test_get_pressed() {
-        let mut input = Input::default();
+        let mut input = Input::<DummyInput>::default();
         input.press(DummyInput::Input1);
         input.press(DummyInput::Input2);
         let pressed = input.get_pressed();
@@ -382,7 +419,7 @@ mod test {
 
     #[test]
     fn test_get_just_pressed() {
-        let mut input = Input::default();
+        let mut input = Input::<DummyInput>::default();
         input.press(DummyInput::Input1);
         input.press(DummyInput::Input2);
         let just_pressed = input.get_just_pressed();
@@ -394,7 +431,7 @@ mod test {
 
     #[test]
     fn test_get_just_released() {
-        let mut input = Input::default();
+        let mut input = Input::<DummyInput>::default();
         input.press(DummyInput::Input1);
         input.press(DummyInput::Input2);
         input.release(DummyInput::Input1);
@@ -408,7 +445,7 @@ mod test {
 
     #[test]
     fn test_general_input_handling() {
-        let mut input = Input::default();
+        let mut input = Input::<DummyInput>::default();
 
         // Test pressing
         input.press(DummyInput::Input1);
@@ -453,7 +490,7 @@ mod test {
         assert!(!input.just_released(DummyInput::Input2));
 
         // Set up an `Input` to test resetting
-        let mut input = Input::default();
+        let mut input = Input::<DummyInput>::default();
 
         input.press(DummyInput::Input1);
         input.release(DummyInput::Input2);
diff --git a/crates/bevy_input/src/keyboard.rs b/crates/bevy_input/src/keyboard.rs
index 73330617e0965..24e893cfd4057 100644
--- a/crates/bevy_input/src/keyboard.rs
+++ b/crates/bevy_input/src/keyboard.rs
@@ -23,7 +23,7 @@ use serde::{Deserialize, Serialize};
 /// ## Usage
 ///
 /// The event is consumed inside of the [`keyboard_input_system`]
-/// to update the [`Input<KeyCode>`](crate::Input<KeyCode>) resource.
+/// to update the [`Input<KeyLogic>`] resource.
 #[derive(Event, Debug, Clone, PartialEq, Eq, Reflect)]
 #[reflect(Debug, PartialEq)]
 #[cfg_attr(
@@ -43,19 +43,61 @@ pub struct KeyboardInput {
     pub window: Entity,
 }
 
-/// Updates the [`Input<KeyCode>`] resource with the latest [`KeyboardInput`] events.
+/// The stored logical key code for `Res<Input<KeyLogic>>`
+///
+/// We need to store the corresponding `KeyCode` because when modifiers are applied,
+/// the released logical key might be different from the pressed.
+/// For example, the sequence of physical keys:
+/// - Press shift
+/// - Press 'a'
+/// - Release shift
+/// - Release 'a',
+///
+/// Leads to the following underlying logical events:
+/// - Press shift
+/// - Press logic character key 'A'
+/// - Release shift
+/// - Release logic character key 'a'
+/// Note the different capitalization.
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Reflect)]
+#[cfg_attr(
+    feature = "serialize",
+    derive(serde::Serialize, serde::Deserialize),
+    reflect(Serialize, Deserialize)
+)]
+pub enum KeyLogic {
+    /// Represents the logical key, typically what's visible on the keyboard.
+    Logic(Key),
+    /// Represents the ScanCode
+    Physical(KeyCode),
+}
+
+impl<I> From<I> for KeyLogic
+where
+    I: Into<Key>,
+{
+    fn from(value: I) -> Self {
+        KeyLogic::Logic(value.into())
+    }
+}
+
+impl From<KeyCode> for KeyLogic {
+    fn from(value: KeyCode) -> Self {
+        KeyLogic::Physical(value)
+    }
+}
+
+/// Updates the [`Input<KeyLogic>`] resource with the latest [`KeyboardInput`] events.
 ///
 /// ## Differences
 ///
-/// The main difference between the [`KeyboardInput`] event and the [`Input<KeyCode>`] or [`Input<Key>`] resources is that
+/// The main difference between the [`KeyboardInput`] event and the [`Input<KeyLogic>`] resources is that
 /// the latter have convenient functions such as [`Input::pressed`], [`Input::just_pressed`] and [`Input::just_released`].
 pub fn keyboard_input_system(
-    mut logical_key_input: ResMut<Input<Key>>,
-    mut key_input: ResMut<Input<KeyCode>>,
+    mut key_input: ResMut<Input<KeyLogic>>,
     mut keyboard_input_events: EventReader<KeyboardInput>,
 ) {
     // Avoid clearing if it's not empty to ensure change detection is not triggered.
-    logical_key_input.bypass_change_detection().clear();
     key_input.bypass_change_detection().clear();
     for event in keyboard_input_events.read() {
         let KeyboardInput {
@@ -65,13 +107,12 @@ pub fn keyboard_input_system(
             ..
         } = event;
         match state {
-            ButtonState::Pressed => key_input.press(*key_code),
+            ButtonState::Pressed => {
+                key_input.add_dynamic_mapping(logical_key.clone(), *key_code);
+                key_input.press(*key_code);
+            }
             ButtonState::Released => key_input.release(*key_code),
         }
-        match state {
-            ButtonState::Pressed => logical_key_input.press(logical_key.clone()),
-            ButtonState::Released => logical_key_input.release(logical_key.clone()),
-        }
     }
 }
 
@@ -109,7 +150,7 @@ pub enum NativeKeyCode {
 ///
 /// ## Usage
 ///
-/// It is used as the generic `T` value of an [`Input`] to create a `Res<Input<KeyCode>>`.
+/// It is used as the generic `T` value of an [`Input`] to create a `Res<Input<KeyLogic>>`.
 /// The resource values are mapped to the current layout of the keyboard and correlate to a [`NativeKeyCode`].
 ///
 /// ## Updating
@@ -626,7 +667,9 @@ pub enum NativeKey {
 ///
 /// ## Usage
 ///
-/// It is used as the generic `T` value of an [`Input`] to create a `Res<Input<Key>>`.
+/// It is used as the generic `T` value of an [`Input`] to create a `Res<Input<KeyLogic>>`,
+/// storing a `Key` and its corresponding `KeyCode`.
+///
 /// The resource values are mapped to the current layout of the keyboard and correlate to a [`KeyCode`].
 ///
 /// ## Updating
@@ -1385,3 +1428,9 @@ pub enum Key {
     /// General-purpose function key.
     F35,
 }
+
+impl From<&str> for Key {
+    fn from(value: &str) -> Self {
+        Key::Character(value.into())
+    }
+}
diff --git a/crates/bevy_input/src/lib.rs b/crates/bevy_input/src/lib.rs
index 1539e02c36aa4..181f5b0214809 100644
--- a/crates/bevy_input/src/lib.rs
+++ b/crates/bevy_input/src/lib.rs
@@ -27,7 +27,7 @@ pub mod prelude {
         gamepad::{
             Gamepad, GamepadAxis, GamepadAxisType, GamepadButton, GamepadButtonType, Gamepads,
         },
-        keyboard::{Key, KeyCode},
+        keyboard::{Key, KeyCode, KeyLogic},
         mouse::MouseButton,
         touch::{TouchInput, Touches},
         Axis, Input,
@@ -36,8 +36,9 @@ pub mod prelude {
 
 use bevy_app::prelude::*;
 use bevy_ecs::prelude::*;
+
 use bevy_reflect::Reflect;
-use keyboard::{keyboard_input_system, Key, KeyCode, KeyboardInput, NativeKey};
+use keyboard::{keyboard_input_system, Key, KeyCode, KeyLogic, KeyboardInput, NativeKey};
 use mouse::{
     mouse_button_input_system, MouseButton, MouseButtonInput, MouseMotion, MouseScrollUnit,
     MouseWheel,
@@ -69,8 +70,7 @@ impl Plugin for InputPlugin {
         app
             // keyboard
             .add_event::<KeyboardInput>()
-            .init_resource::<Input<KeyCode>>()
-            .init_resource::<Input<Key>>()
+            .init_resource::<Input<KeyLogic>>()
             .add_systems(PreUpdate, keyboard_input_system.in_set(InputSystem))
             // mouse
             .add_event::<MouseButtonInput>()
@@ -116,6 +116,7 @@ impl Plugin for InputPlugin {
 
         // Register keyboard types
         app.register_type::<KeyboardInput>()
+            .register_type::<KeyLogic>()
             .register_type::<KeyCode>()
             .register_type::<Key>()
             .register_type::<NativeKey>();
diff --git a/crates/bevy_window/src/system.rs b/crates/bevy_window/src/system.rs
index b7dec35a102eb..9d4351643e0d9 100644
--- a/crates/bevy_window/src/system.rs
+++ b/crates/bevy_window/src/system.rs
@@ -2,7 +2,10 @@ use crate::{PrimaryWindow, Window, WindowCloseRequested};
 
 use bevy_app::AppExit;
 use bevy_ecs::prelude::*;
-use bevy_input::{keyboard::KeyCode, Input};
+use bevy_input::{
+    keyboard::{KeyCode, KeyLogic},
+    Input,
+};
 
 /// Exit the application when there are no open windows.
 ///
@@ -52,7 +55,7 @@ pub fn close_when_requested(mut commands: Commands, mut closed: EventReader<Wind
 pub fn close_on_esc(
     mut commands: Commands,
     focused_windows: Query<(Entity, &Window)>,
-    input: Res<Input<KeyCode>>,
+    input: Res<Input<KeyLogic>>,
 ) {
     for (window, focus) in focused_windows.iter() {
         if !focus.focused {
diff --git a/examples/2d/2d_gizmos.rs b/examples/2d/2d_gizmos.rs
index a70cd250a2976..624b130232291 100644
--- a/examples/2d/2d_gizmos.rs
+++ b/examples/2d/2d_gizmos.rs
@@ -55,7 +55,7 @@ fn system(mut gizmos: Gizmos, time: Res<Time>) {
     gizmos.arc_2d(Vec2::ZERO, sin / 10., PI / 2., 350., Color::ORANGE_RED);
 }
 
-fn update_config(mut config: ResMut<GizmoConfig>, keyboard: Res<Input<KeyCode>>, time: Res<Time>) {
+fn update_config(mut config: ResMut<GizmoConfig>, keyboard: Res<Input<KeyLogic>>, time: Res<Time>) {
     if keyboard.pressed(KeyCode::ArrowRight) {
         config.line_width += 5. * time.delta_seconds();
     }
diff --git a/examples/2d/bloom_2d.rs b/examples/2d/bloom_2d.rs
index 8b0f7ce48c3cd..8574757c8b7d4 100644
--- a/examples/2d/bloom_2d.rs
+++ b/examples/2d/bloom_2d.rs
@@ -91,7 +91,7 @@ fn update_bloom_settings(
     mut camera: Query<(Entity, Option<&mut BloomSettings>), With<Camera>>,
     mut text: Query<&mut Text>,
     mut commands: Commands,
-    keycode: Res<Input<KeyCode>>,
+    keycode: Res<Input<KeyLogic>>,
     time: Res<Time>,
 ) {
     let bloom_settings = camera.single_mut();
diff --git a/examples/2d/rotation.rs b/examples/2d/rotation.rs
index f791b5749ed33..2c4a49cf90f4a 100644
--- a/examples/2d/rotation.rs
+++ b/examples/2d/rotation.rs
@@ -117,7 +117,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
 /// Demonstrates applying rotation and movement based on keyboard input.
 fn player_movement_system(
     time: Res<Time>,
-    keyboard_input: Res<Input<KeyCode>>,
+    keyboard_input: Res<Input<KeyLogic>>,
     mut query: Query<(&Player, &mut Transform)>,
 ) {
     let (ship, mut transform) = query.single_mut();
diff --git a/examples/3d/3d_gizmos.rs b/examples/3d/3d_gizmos.rs
index 8e3c380640372..d797245341afb 100644
--- a/examples/3d/3d_gizmos.rs
+++ b/examples/3d/3d_gizmos.rs
@@ -104,7 +104,7 @@ fn rotate_camera(mut query: Query<&mut Transform, With<Camera>>, time: Res<Time>
     transform.rotate_around(Vec3::ZERO, Quat::from_rotation_y(time.delta_seconds() / 2.));
 }
 
-fn update_config(mut config: ResMut<GizmoConfig>, keyboard: Res<Input<KeyCode>>, time: Res<Time>) {
+fn update_config(mut config: ResMut<GizmoConfig>, keyboard: Res<Input<KeyLogic>>, time: Res<Time>) {
     if keyboard.just_pressed(KeyCode::KeyD) {
         config.depth_bias = if config.depth_bias == 0. { -1. } else { 0. };
     }
diff --git a/examples/3d/anti_aliasing.rs b/examples/3d/anti_aliasing.rs
index cfb761c71f574..e5df088581617 100644
--- a/examples/3d/anti_aliasing.rs
+++ b/examples/3d/anti_aliasing.rs
@@ -32,7 +32,7 @@ fn main() {
 }
 
 fn modify_aa(
-    keys: Res<Input<KeyCode>>,
+    keys: Res<Input<KeyLogic>>,
     mut camera: Query<
         (
             Entity,
@@ -117,7 +117,7 @@ fn modify_aa(
 }
 
 fn modify_sharpening(
-    keys: Res<Input<KeyCode>>,
+    keys: Res<Input<KeyLogic>>,
     mut query: Query<&mut ContrastAdaptiveSharpeningSettings>,
 ) {
     for mut cas in &mut query {
diff --git a/examples/3d/atmospheric_fog.rs b/examples/3d/atmospheric_fog.rs
index ada5c383e8fa3..06eb1575a6859 100644
--- a/examples/3d/atmospheric_fog.rs
+++ b/examples/3d/atmospheric_fog.rs
@@ -111,7 +111,7 @@ fn setup_instructions(mut commands: Commands) {
     );
 }
 
-fn toggle_system(keycode: Res<Input<KeyCode>>, mut fog: Query<&mut FogSettings>) {
+fn toggle_system(keycode: Res<Input<KeyLogic>>, mut fog: Query<&mut FogSettings>) {
     let mut fog_settings = fog.single_mut();
 
     if keycode.just_pressed(KeyCode::Space) {
diff --git a/examples/3d/blend_modes.rs b/examples/3d/blend_modes.rs
index d5f866830212b..56b7456d210d5 100644
--- a/examples/3d/blend_modes.rs
+++ b/examples/3d/blend_modes.rs
@@ -290,7 +290,7 @@ fn example_control_system(
     labelled: Query<&GlobalTransform>,
     mut state: Local<ExampleState>,
     time: Res<Time>,
-    input: Res<Input<KeyCode>>,
+    input: Res<Input<KeyLogic>>,
 ) {
     if input.pressed(KeyCode::ArrowUp) {
         state.alpha = (state.alpha + time.delta_seconds()).min(1.0);
diff --git a/examples/3d/bloom_3d.rs b/examples/3d/bloom_3d.rs
index ff150b8bd4424..a6053d902e616 100644
--- a/examples/3d/bloom_3d.rs
+++ b/examples/3d/bloom_3d.rs
@@ -115,7 +115,7 @@ fn update_bloom_settings(
     mut camera: Query<(Entity, Option<&mut BloomSettings>), With<Camera>>,
     mut text: Query<&mut Text>,
     mut commands: Commands,
-    keycode: Res<Input<KeyCode>>,
+    keycode: Res<Input<KeyLogic>>,
     time: Res<Time>,
 ) {
     let bloom_settings = camera.single_mut();
diff --git a/examples/3d/deferred_rendering.rs b/examples/3d/deferred_rendering.rs
index 63a51f995ad99..89d43d33adb3d 100644
--- a/examples/3d/deferred_rendering.rs
+++ b/examples/3d/deferred_rendering.rs
@@ -335,7 +335,7 @@ enum DefaultRenderMode {
 fn switch_mode(
     mut text: Query<&mut Text>,
     mut commands: Commands,
-    keys: Res<Input<KeyCode>>,
+    keys: Res<Input<KeyLogic>>,
     mut default_opaque_renderer_method: ResMut<DefaultOpaqueRendererMethod>,
     mut materials: ResMut<Assets<StandardMaterial>>,
     cameras: Query<Entity, With<Camera>>,
@@ -352,7 +352,7 @@ fn switch_mode(
         pause.0 = !pause.0;
     }
 
-    if keys.just_pressed(KeyCode::Key1) {
+    if keys.just_pressed(KeyCode::Digit1) {
         *mode = DefaultRenderMode::Deferred;
         default_opaque_renderer_method.set_to_deferred();
         println!("DefaultOpaqueRendererMethod: Deferred");
@@ -364,7 +364,7 @@ fn switch_mode(
             commands.entity(camera).insert(DeferredPrepass);
         }
     }
-    if keys.just_pressed(KeyCode::Key2) {
+    if keys.just_pressed(KeyCode::Digit2) {
         *mode = DefaultRenderMode::Forward;
         default_opaque_renderer_method.set_to_forward();
         println!("DefaultOpaqueRendererMethod: Forward");
@@ -376,7 +376,7 @@ fn switch_mode(
             commands.entity(camera).remove::<DeferredPrepass>();
         }
     }
-    if keys.just_pressed(KeyCode::Key3) {
+    if keys.just_pressed(KeyCode::Digit3) {
         *mode = DefaultRenderMode::ForwardPrepass;
         default_opaque_renderer_method.set_to_forward();
         println!("DefaultOpaqueRendererMethod: Forward + Prepass");
@@ -389,7 +389,7 @@ fn switch_mode(
         }
     }
 
-    if keys.just_pressed(KeyCode::H) {
+    if keys.just_pressed(KeyCode::KeyH) {
         *hide_ui = !*hide_ui;
     }
 
diff --git a/examples/3d/fog.rs b/examples/3d/fog.rs
index 14f184a9558b5..3b43329a6cae8 100644
--- a/examples/3d/fog.rs
+++ b/examples/3d/fog.rs
@@ -159,7 +159,7 @@ fn update_system(
     mut camera: Query<(&mut FogSettings, &mut Transform)>,
     mut text: Query<&mut Text>,
     time: Res<Time>,
-    keycode: Res<Input<KeyCode>>,
+    keycode: Res<Input<KeyLogic>>,
 ) {
     let now = time.elapsed_seconds();
     let delta = time.delta_seconds();
diff --git a/examples/3d/generate_custom_mesh.rs b/examples/3d/generate_custom_mesh.rs
index 761375fdc4810..0f27112604307 100644
--- a/examples/3d/generate_custom_mesh.rs
+++ b/examples/3d/generate_custom_mesh.rs
@@ -85,7 +85,7 @@ fn setup(
 // System to receive input from the user,
 // check out examples/input/ for more examples about user input.
 fn input_handler(
-    keyboard_input: Res<Input<KeyCode>>,
+    keyboard_input: Res<Input<KeyLogic>>,
     mesh_query: Query<&Handle<Mesh>, With<CustomUV>>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut query: Query<&mut Transform, With<CustomUV>>,
diff --git a/examples/3d/lighting.rs b/examples/3d/lighting.rs
index bc23c040e705f..35869fd8d6f47 100644
--- a/examples/3d/lighting.rs
+++ b/examples/3d/lighting.rs
@@ -261,7 +261,7 @@ fn animate_light_direction(
 }
 
 fn movement(
-    input: Res<Input<KeyCode>>,
+    input: Res<Input<KeyLogic>>,
     time: Res<Time>,
     mut query: Query<&mut Transform, With<Movable>>,
 ) {
diff --git a/examples/3d/parallax_mapping.rs b/examples/3d/parallax_mapping.rs
index 04e3d46c4ea18..770c406380ad3 100644
--- a/examples/3d/parallax_mapping.rs
+++ b/examples/3d/parallax_mapping.rs
@@ -79,7 +79,7 @@ impl CurrentMethod {
 }
 
 fn update_parallax_depth_scale(
-    input: Res<Input<KeyCode>>,
+    input: Res<Input<KeyLogic>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
     mut target_depth: Local<TargetDepth>,
     mut depth_update: Local<bool>,
@@ -111,7 +111,7 @@ fn update_parallax_depth_scale(
 }
 
 fn switch_method(
-    input: Res<Input<KeyCode>>,
+    input: Res<Input<KeyLogic>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
     mut text: Query<&mut Text>,
     mut current: Local<CurrentMethod>,
@@ -130,7 +130,7 @@ fn switch_method(
 }
 
 fn update_parallax_layers(
-    input: Res<Input<KeyCode>>,
+    input: Res<Input<KeyLogic>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
     mut target_layers: Local<TargetLayers>,
     mut text: Query<&mut Text>,
diff --git a/examples/3d/shadow_biases.rs b/examples/3d/shadow_biases.rs
index 7606e63ea5f40..292a5f265822d 100644
--- a/examples/3d/shadow_biases.rs
+++ b/examples/3d/shadow_biases.rs
@@ -187,7 +187,7 @@ fn setup(
 }
 
 fn toggle_light(
-    input: Res<Input<KeyCode>>,
+    input: Res<Input<KeyLogic>>,
     mut point_lights: Query<&mut PointLight>,
     mut directional_lights: Query<&mut DirectionalLight>,
     mut example_text: Query<&mut Text>,
@@ -213,21 +213,21 @@ fn toggle_light(
 }
 
 fn adjust_light_position(
-    input: Res<Input<KeyCode>>,
+    input: Res<Input<KeyLogic>>,
     mut lights: Query<&mut Transform, With<Lights>>,
     mut example_text: Query<&mut Text>,
 ) {
     let mut offset = Vec3::ZERO;
-    if input.just_pressed(KeyCode::Left) {
+    if input.just_pressed(KeyCode::ArrowLeft) {
         offset.x -= 1.0;
     }
-    if input.just_pressed(KeyCode::Right) {
+    if input.just_pressed(KeyCode::ArrowRight) {
         offset.x += 1.0;
     }
-    if input.just_pressed(KeyCode::Up) {
+    if input.just_pressed(KeyCode::ArrowUp) {
         offset.z -= 1.0;
     }
-    if input.just_pressed(KeyCode::Down) {
+    if input.just_pressed(KeyCode::ArrowDown) {
         offset.z += 1.0;
     }
     if input.just_pressed(KeyCode::PageDown) {
@@ -249,11 +249,11 @@ fn adjust_light_position(
 }
 
 fn cycle_filter_methods(
-    input: Res<Input<KeyCode>>,
+    input: Res<Input<KeyLogic>>,
     mut filter_methods: Query<&mut ShadowFilteringMethod>,
     mut example_text: Query<&mut Text>,
 ) {
-    if input.just_pressed(KeyCode::F) {
+    if input.just_pressed(KeyCode::KeyF) {
         for mut filter_method in &mut filter_methods {
             let filter_method_string;
             *filter_method = match *filter_method {
@@ -276,7 +276,7 @@ fn cycle_filter_methods(
 }
 
 fn adjust_point_light_biases(
-    input: Res<Input<KeyCode>>,
+    input: Res<Input<KeyLogic>>,
     mut query: Query<&mut PointLight>,
     mut example_text: Query<&mut Text>,
 ) {
@@ -295,11 +295,11 @@ fn adjust_point_light_biases(
         if input.just_pressed(KeyCode::Digit4) {
             light.shadow_normal_bias += normal_bias_step_size;
         }
-        if input.just_pressed(KeyCode::R) {
+        if input.just_pressed(KeyCode::KeyR) {
             light.shadow_depth_bias = PointLight::DEFAULT_SHADOW_DEPTH_BIAS;
             light.shadow_normal_bias = PointLight::DEFAULT_SHADOW_NORMAL_BIAS;
         }
-        if input.just_pressed(KeyCode::Z) {
+        if input.just_pressed(KeyCode::KeyZ) {
             light.shadow_depth_bias = 0.0;
             light.shadow_normal_bias = 0.0;
         }
@@ -310,7 +310,7 @@ fn adjust_point_light_biases(
 }
 
 fn adjust_directional_light_biases(
-    input: Res<Input<KeyCode>>,
+    input: Res<Input<KeyLogic>>,
     mut query: Query<&mut DirectionalLight>,
     mut example_text: Query<&mut Text>,
 ) {
@@ -329,11 +329,11 @@ fn adjust_directional_light_biases(
         if input.just_pressed(KeyCode::Digit8) {
             light.shadow_normal_bias += normal_bias_step_size;
         }
-        if input.just_pressed(KeyCode::R) {
+        if input.just_pressed(KeyCode::KeyR) {
             light.shadow_depth_bias = DirectionalLight::DEFAULT_SHADOW_DEPTH_BIAS;
             light.shadow_normal_bias = DirectionalLight::DEFAULT_SHADOW_NORMAL_BIAS;
         }
-        if input.just_pressed(KeyCode::Z) {
+        if input.just_pressed(KeyCode::KeyZ) {
             light.shadow_depth_bias = 0.0;
             light.shadow_normal_bias = 0.0;
         }
@@ -387,7 +387,7 @@ impl Default for CameraController {
 fn camera_controller(
     time: Res<Time>,
     mut mouse_events: EventReader<MouseMotion>,
-    key_input: Res<Input<KeyCode>>,
+    key_input: Res<Input<KeyLogic>>,
     mut query: Query<(&mut Transform, &mut CameraController), With<Camera>>,
 ) {
     let dt = time.delta_seconds();
diff --git a/examples/3d/shadow_caster_receiver.rs b/examples/3d/shadow_caster_receiver.rs
index acb87e1a05f6f..899cf6022a761 100644
--- a/examples/3d/shadow_caster_receiver.rs
+++ b/examples/3d/shadow_caster_receiver.rs
@@ -130,7 +130,7 @@ fn setup(
 }
 
 fn toggle_light(
-    input: Res<Input<KeyCode>>,
+    input: Res<Input<KeyLogic>>,
     mut point_lights: Query<&mut PointLight>,
     mut directional_lights: Query<&mut DirectionalLight>,
 ) {
@@ -156,7 +156,7 @@ fn toggle_light(
 
 fn toggle_shadows(
     mut commands: Commands,
-    input: Res<Input<KeyCode>>,
+    input: Res<Input<KeyLogic>>,
     mut queries: ParamSet<(
         Query<Entity, (With<Handle<Mesh>>, With<NotShadowCaster>)>,
         Query<Entity, (With<Handle<Mesh>>, With<NotShadowReceiver>)>,
diff --git a/examples/3d/skybox.rs b/examples/3d/skybox.rs
index d06bd81bafc66..5269dbb513971 100644
--- a/examples/3d/skybox.rs
+++ b/examples/3d/skybox.rs
@@ -221,7 +221,7 @@ pub fn camera_controller(
     time: Res<Time>,
     mut mouse_events: EventReader<MouseMotion>,
     mouse_button_input: Res<Input<MouseButton>>,
-    key_input: Res<Input<KeyCode>>,
+    key_input: Res<Input<KeyLogic>>,
     mut move_toggled: Local<bool>,
     mut query: Query<(&mut Transform, &mut CameraController), With<Camera>>,
 ) {
diff --git a/examples/3d/spotlight.rs b/examples/3d/spotlight.rs
index 6ea74b4c1b7b6..46ccbcc6f4fac 100644
--- a/examples/3d/spotlight.rs
+++ b/examples/3d/spotlight.rs
@@ -141,7 +141,7 @@ fn light_sway(time: Res<Time>, mut query: Query<(&mut Transform, &mut SpotLight)
 }
 
 fn movement(
-    input: Res<Input<KeyCode>>,
+    input: Res<Input<KeyLogic>>,
     time: Res<Time>,
     mut query: Query<&mut Transform, With<Movable>>,
 ) {
diff --git a/examples/3d/ssao.rs b/examples/3d/ssao.rs
index 43cd22c0959c8..c0b53ad710c90 100644
--- a/examples/3d/ssao.rs
+++ b/examples/3d/ssao.rs
@@ -131,7 +131,7 @@ fn update(
     mut text: Query<&mut Text>,
     mut sphere: Query<&mut Transform, With<SphereMarker>>,
     mut commands: Commands,
-    keycode: Res<Input<KeyCode>>,
+    keycode: Res<Input<KeyLogic>>,
     time: Res<Time>,
 ) {
     let mut sphere = sphere.single_mut();
diff --git a/examples/3d/tonemapping.rs b/examples/3d/tonemapping.rs
index f15789d489244..297b2b1af7258 100644
--- a/examples/3d/tonemapping.rs
+++ b/examples/3d/tonemapping.rs
@@ -347,7 +347,7 @@ fn update_image_viewer(
 }
 
 fn toggle_scene(
-    keys: Res<Input<KeyCode>>,
+    keys: Res<Input<KeyLogic>>,
     mut query: Query<(&mut Visibility, &SceneNumber)>,
     mut current_scene: ResMut<CurrentScene>,
 ) {
@@ -374,7 +374,7 @@ fn toggle_scene(
 }
 
 fn toggle_tonemapping_method(
-    keys: Res<Input<KeyCode>>,
+    keys: Res<Input<KeyLogic>>,
     mut tonemapping: Query<&mut Tonemapping>,
     mut color_grading: Query<&mut ColorGrading>,
     per_method_settings: Res<PerMethodSettings>,
@@ -422,7 +422,7 @@ impl SelectedParameter {
 }
 
 fn update_color_grading_settings(
-    keys: Res<Input<KeyCode>>,
+    keys: Res<Input<KeyLogic>>,
     time: Res<Time>,
     mut per_method_settings: ResMut<PerMethodSettings>,
     tonemapping: Query<&Tonemapping>,
@@ -479,7 +479,7 @@ fn update_ui(
     current_scene: Res<CurrentScene>,
     selected_parameter: Res<SelectedParameter>,
     mut hide_ui: Local<bool>,
-    keys: Res<Input<KeyCode>>,
+    keys: Res<Input<KeyLogic>>,
 ) {
     let (method, color_grading) = settings.single();
     let method = *method;
diff --git a/examples/3d/transmission.rs b/examples/3d/transmission.rs
index 80400e662936f..5ffc5af24516a 100644
--- a/examples/3d/transmission.rs
+++ b/examples/3d/transmission.rs
@@ -442,45 +442,45 @@ fn example_control_system(
     mut display: Query<&mut Text, With<ExampleDisplay>>,
     mut state: Local<ExampleState>,
     time: Res<Time>,
-    input: Res<Input<KeyCode>>,
+    input: Res<Input<KeyLogic>>,
 ) {
-    if input.pressed(KeyCode::Key2) {
+    if input.pressed(KeyCode::Digit2) {
         state.diffuse_transmission = (state.diffuse_transmission + time.delta_seconds()).min(1.0);
-    } else if input.pressed(KeyCode::Key1) {
+    } else if input.pressed(KeyCode::Digit1) {
         state.diffuse_transmission = (state.diffuse_transmission - time.delta_seconds()).max(0.0);
     }
 
-    if input.pressed(KeyCode::W) {
+    if input.pressed(KeyCode::KeyW) {
         state.specular_transmission = (state.specular_transmission + time.delta_seconds()).min(1.0);
-    } else if input.pressed(KeyCode::Q) {
+    } else if input.pressed(KeyCode::KeyQ) {
         state.specular_transmission = (state.specular_transmission - time.delta_seconds()).max(0.0);
     }
 
-    if input.pressed(KeyCode::S) {
+    if input.pressed(KeyCode::KeyS) {
         state.thickness = (state.thickness + time.delta_seconds()).min(5.0);
-    } else if input.pressed(KeyCode::A) {
+    } else if input.pressed(KeyCode::KeyA) {
         state.thickness = (state.thickness - time.delta_seconds()).max(0.0);
     }
 
-    if input.pressed(KeyCode::X) {
+    if input.pressed(KeyCode::KeyX) {
         state.ior = (state.ior + time.delta_seconds()).min(3.0);
-    } else if input.pressed(KeyCode::Z) {
+    } else if input.pressed(KeyCode::KeyZ) {
         state.ior = (state.ior - time.delta_seconds()).max(1.0);
     }
 
-    if input.pressed(KeyCode::I) {
+    if input.pressed(KeyCode::KeyI) {
         state.reflectance = (state.reflectance + time.delta_seconds()).min(1.0);
-    } else if input.pressed(KeyCode::U) {
+    } else if input.pressed(KeyCode::KeyU) {
         state.reflectance = (state.reflectance - time.delta_seconds()).max(0.0);
     }
 
-    if input.pressed(KeyCode::R) {
+    if input.pressed(KeyCode::KeyR) {
         state.perceptual_roughness = (state.perceptual_roughness + time.delta_seconds()).min(1.0);
-    } else if input.pressed(KeyCode::E) {
+    } else if input.pressed(KeyCode::KeyE) {
         state.perceptual_roughness = (state.perceptual_roughness - time.delta_seconds()).max(0.0);
     }
 
-    let randomize_colors = input.just_pressed(KeyCode::C);
+    let randomize_colors = input.just_pressed(KeyCode::KeyC);
 
     for (material_handle, controls) in &controllable {
         let material = materials.get_mut(material_handle).unwrap();
@@ -512,12 +512,12 @@ fn example_control_system(
         temporal_jitter,
     ) = camera.single_mut();
 
-    if input.just_pressed(KeyCode::H) {
+    if input.just_pressed(KeyCode::KeyH) {
         camera.hdr = !camera.hdr;
     }
 
     #[cfg(not(all(feature = "webgl2", target_arch = "wasm32")))]
-    if input.just_pressed(KeyCode::D) {
+    if input.just_pressed(KeyCode::KeyD) {
         if depth_prepass.is_none() {
             commands.entity(camera_entity).insert(DepthPrepass);
         } else {
@@ -526,7 +526,7 @@ fn example_control_system(
     }
 
     #[cfg(not(all(feature = "webgl2", target_arch = "wasm32")))]
-    if input.just_pressed(KeyCode::T) {
+    if input.just_pressed(KeyCode::KeyT) {
         if temporal_jitter.is_none() {
             commands.entity(camera_entity).insert((
                 TemporalJitter::default(),
@@ -539,24 +539,24 @@ fn example_control_system(
         }
     }
 
-    if input.just_pressed(KeyCode::O) && camera_3d.screen_space_specular_transmission_steps > 0 {
+    if input.just_pressed(KeyCode::KeyO) && camera_3d.screen_space_specular_transmission_steps > 0 {
         camera_3d.screen_space_specular_transmission_steps -= 1;
     }
 
-    if input.just_pressed(KeyCode::P) && camera_3d.screen_space_specular_transmission_steps < 4 {
+    if input.just_pressed(KeyCode::KeyP) && camera_3d.screen_space_specular_transmission_steps < 4 {
         camera_3d.screen_space_specular_transmission_steps += 1;
     }
 
-    if input.just_pressed(KeyCode::J) {
+    if input.just_pressed(KeyCode::KeyJ) {
         camera_3d.screen_space_specular_transmission_quality = ScreenSpaceTransmissionQuality::Low;
     }
 
-    if input.just_pressed(KeyCode::K) {
+    if input.just_pressed(KeyCode::KeyK) {
         camera_3d.screen_space_specular_transmission_quality =
             ScreenSpaceTransmissionQuality::Medium;
     }
 
-    if input.just_pressed(KeyCode::L) {
+    if input.just_pressed(KeyCode::KeyL) {
         camera_3d.screen_space_specular_transmission_quality = ScreenSpaceTransmissionQuality::High;
     }
 
@@ -565,10 +565,10 @@ fn example_control_system(
             ScreenSpaceTransmissionQuality::Ultra;
     }
 
-    let rotation = if input.pressed(KeyCode::Right) {
+    let rotation = if input.pressed(KeyCode::ArrowRight) {
         state.auto_camera = false;
         time.delta_seconds()
-    } else if input.pressed(KeyCode::Left) {
+    } else if input.pressed(KeyCode::ArrowLeft) {
         state.auto_camera = false;
         -time.delta_seconds()
     } else if state.auto_camera {
@@ -578,9 +578,9 @@ fn example_control_system(
     };
 
     let distance_change =
-        if input.pressed(KeyCode::Down) && camera_transform.translation.length() < 25.0 {
+        if input.pressed(KeyCode::ArrowDown) && camera_transform.translation.length() < 25.0 {
             time.delta_seconds()
-        } else if input.pressed(KeyCode::Up) && camera_transform.translation.length() > 2.0 {
+        } else if input.pressed(KeyCode::ArrowUp) && camera_transform.translation.length() > 2.0 {
             -time.delta_seconds()
         } else {
             0.0
diff --git a/examples/3d/wireframe.rs b/examples/3d/wireframe.rs
index 8f845409b6800..6a97b2ef5d440 100644
--- a/examples/3d/wireframe.rs
+++ b/examples/3d/wireframe.rs
@@ -117,7 +117,7 @@ fn setup(
 
 /// This system let's you toggle various wireframe settings
 fn update_colors(
-    keyboard_input: Res<Input<KeyCode>>,
+    keyboard_input: Res<Input<KeyLogic>>,
     mut config: ResMut<WireframeConfig>,
     mut wireframe_colors: Query<&mut WireframeColor>,
     mut text: Query<&mut Text>,
@@ -139,12 +139,12 @@ Color: {:?}
     );
 
     // Toggle showing a wireframe on all meshes
-    if keyboard_input.just_pressed(KeyCode::Z) {
+    if keyboard_input.just_pressed(KeyCode::KeyZ) {
         config.global = !config.global;
     }
 
     // Toggle the global wireframe color
-    if keyboard_input.just_pressed(KeyCode::X) {
+    if keyboard_input.just_pressed(KeyCode::KeyX) {
         config.default_color = if config.default_color == Color::WHITE {
             Color::PINK
         } else {
@@ -153,7 +153,7 @@ Color: {:?}
     }
 
     // Toggle the color of a wireframe using WireframeColor and not the global color
-    if keyboard_input.just_pressed(KeyCode::C) {
+    if keyboard_input.just_pressed(KeyCode::KeyC) {
         for mut color in &mut wireframe_colors {
             color.color = if color.color == Color::GREEN {
                 Color::RED
diff --git a/examples/animation/animated_fox.rs b/examples/animation/animated_fox.rs
index 9a57eb99bde9b..0302b89e2fb6e 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -92,7 +92,7 @@ fn setup_scene_once_loaded(
 }
 
 fn keyboard_animation_control(
-    keyboard_input: Res<Input<KeyCode>>,
+    keyboard_input: Res<Input<KeyLogic>>,
     mut animation_players: Query<&mut AnimationPlayer>,
     animations: Res<Animations>,
     mut current_animation: Local<usize>,
@@ -136,22 +136,22 @@ fn keyboard_animation_control(
                 .repeat();
         }
 
-        if keyboard_input.just_pressed(KeyCode::Key1) {
+        if keyboard_input.just_pressed(KeyCode::Digit1) {
             player.set_repeat(RepeatAnimation::Count(1));
             player.replay();
         }
 
-        if keyboard_input.just_pressed(KeyCode::Key3) {
+        if keyboard_input.just_pressed(KeyCode::Digit3) {
             player.set_repeat(RepeatAnimation::Count(3));
             player.replay();
         }
 
-        if keyboard_input.just_pressed(KeyCode::Key5) {
+        if keyboard_input.just_pressed(KeyCode::Digit5) {
             player.set_repeat(RepeatAnimation::Count(5));
             player.replay();
         }
 
-        if keyboard_input.just_pressed(KeyCode::L) {
+        if keyboard_input.just_pressed(KeyCode::KeyL) {
             player.set_repeat(RepeatAnimation::Forever);
         }
     }
diff --git a/examples/app/return_after_run.rs b/examples/app/return_after_run.rs
index 0f1f80a82cff8..eb5bae6d3caa5 100644
--- a/examples/app/return_after_run.rs
+++ b/examples/app/return_after_run.rs
@@ -6,7 +6,6 @@
 //! - It is not possible to recreate a window afer the event loop has been terminated.
 
 use bevy::{prelude::*, window::WindowPlugin};
-use bevy_internal::log::LogPlugin;
 
 fn main() {
     println!("Running Bevy App");
diff --git a/examples/audio/audio_control.rs b/examples/audio/audio_control.rs
index 1d9e6c294bf4d..2fe8fa8416e3d 100644
--- a/examples/audio/audio_control.rs
+++ b/examples/audio/audio_control.rs
@@ -29,7 +29,7 @@ fn update_speed(music_controller: Query<&AudioSink, With<MyMusic>>, time: Res<Ti
     }
 }
 
-fn pause(keyboard_input: Res<Input<KeyCode>>, music_controller: Query<&AudioSink, With<MyMusic>>) {
+fn pause(keyboard_input: Res<Input<KeyLogic>>, music_controller: Query<&AudioSink, With<MyMusic>>) {
     if keyboard_input.just_pressed(KeyCode::Space) {
         if let Ok(sink) = music_controller.get_single() {
             sink.toggle();
@@ -37,7 +37,10 @@ fn pause(keyboard_input: Res<Input<KeyCode>>, music_controller: Query<&AudioSink
     }
 }
 
-fn volume(keyboard_input: Res<Input<KeyCode>>, music_controller: Query<&AudioSink, With<MyMusic>>) {
+fn volume(
+    keyboard_input: Res<Input<KeyLogic>>,
+    music_controller: Query<&AudioSink, With<MyMusic>>,
+) {
     if let Ok(sink) = music_controller.get_single() {
         if keyboard_input.just_pressed(KeyCode::Equal) {
             sink.set_volume(sink.volume() + 0.1);
diff --git a/examples/audio/pitch.rs b/examples/audio/pitch.rs
index 218ae5500f602..c75c08f8275bf 100644
--- a/examples/audio/pitch.rs
+++ b/examples/audio/pitch.rs
@@ -39,14 +39,14 @@ fn play_pitch(
 }
 
 fn keyboard_input_system(
-    keyboard_input: Res<Input<KeyCode>>,
+    keyboard_input: Res<Input<KeyLogic>>,
     mut frequency: ResMut<PitchFrequency>,
     mut events: EventWriter<PlayPitch>,
 ) {
-    if keyboard_input.just_pressed(KeyCode::Up) {
+    if keyboard_input.just_pressed(KeyCode::ArrowUp) {
         frequency.0 *= 2.0f32.powf(1.0 / 12.0);
     }
-    if keyboard_input.just_pressed(KeyCode::Down) {
+    if keyboard_input.just_pressed(KeyCode::ArrowDown) {
         frequency.0 /= 2.0f32.powf(1.0 / 12.0);
     }
     if keyboard_input.just_pressed(KeyCode::Space) {
diff --git a/examples/audio/spatial_audio_2d.rs b/examples/audio/spatial_audio_2d.rs
index 96534fcfb6532..d822e753ba930 100644
--- a/examples/audio/spatial_audio_2d.rs
+++ b/examples/audio/spatial_audio_2d.rs
@@ -102,7 +102,7 @@ struct Emitter {
 fn update_emitters(
     time: Res<Time>,
     mut emitters: Query<(&mut Transform, &mut Emitter), With<Emitter>>,
-    keyboard: Res<Input<KeyCode>>,
+    keyboard: Res<Input<KeyLogic>>,
 ) {
     for (mut emitter_transform, mut emitter) in emitters.iter_mut() {
         if keyboard.just_pressed(KeyCode::Space) {
@@ -116,7 +116,7 @@ fn update_emitters(
 }
 
 fn update_listener(
-    keyboard: Res<Input<KeyCode>>,
+    keyboard: Res<Input<KeyLogic>>,
     time: Res<Time>,
     mut listeners: Query<&mut Transform, With<SpatialListener>>,
 ) {
@@ -124,16 +124,16 @@ fn update_listener(
 
     let speed = 200.;
 
-    if keyboard.pressed(KeyCode::Right) {
+    if keyboard.pressed(KeyCode::ArrowRight) {
         transform.translation.x += speed * time.delta_seconds();
     }
-    if keyboard.pressed(KeyCode::Left) {
+    if keyboard.pressed(KeyCode::ArrowLeft) {
         transform.translation.x -= speed * time.delta_seconds();
     }
-    if keyboard.pressed(KeyCode::Up) {
+    if keyboard.pressed(KeyCode::ArrowUp) {
         transform.translation.y += speed * time.delta_seconds();
     }
-    if keyboard.pressed(KeyCode::Down) {
+    if keyboard.pressed(KeyCode::ArrowDown) {
         transform.translation.y -= speed * time.delta_seconds();
     }
 }
diff --git a/examples/audio/spatial_audio_3d.rs b/examples/audio/spatial_audio_3d.rs
index 7dbb512f385fa..50d68ebf54fdd 100644
--- a/examples/audio/spatial_audio_3d.rs
+++ b/examples/audio/spatial_audio_3d.rs
@@ -101,7 +101,7 @@ struct Emitter {
 fn update_positions(
     time: Res<Time>,
     mut emitters: Query<(&mut Transform, &mut Emitter), With<Emitter>>,
-    keyboard: Res<Input<KeyCode>>,
+    keyboard: Res<Input<KeyLogic>>,
 ) {
     for (mut emitter_transform, mut emitter) in emitters.iter_mut() {
         if keyboard.just_pressed(KeyCode::Space) {
@@ -116,7 +116,7 @@ fn update_positions(
 }
 
 fn update_listener(
-    keyboard: Res<Input<KeyCode>>,
+    keyboard: Res<Input<KeyLogic>>,
     time: Res<Time>,
     mut listeners: Query<&mut Transform, With<SpatialListener>>,
 ) {
@@ -124,16 +124,16 @@ fn update_listener(
 
     let speed = 2.;
 
-    if keyboard.pressed(KeyCode::Right) {
+    if keyboard.pressed(KeyCode::ArrowRight) {
         transform.translation.x += speed * time.delta_seconds();
     }
-    if keyboard.pressed(KeyCode::Left) {
+    if keyboard.pressed(KeyCode::ArrowLeft) {
         transform.translation.x -= speed * time.delta_seconds();
     }
-    if keyboard.pressed(KeyCode::Down) {
+    if keyboard.pressed(KeyCode::ArrowDown) {
         transform.translation.z += speed * time.delta_seconds();
     }
-    if keyboard.pressed(KeyCode::Up) {
+    if keyboard.pressed(KeyCode::ArrowUp) {
         transform.translation.z -= speed * time.delta_seconds();
     }
 }
diff --git a/examples/ecs/generic_system.rs b/examples/ecs/generic_system.rs
index aac3444855f25..2e0c64fa1e444 100644
--- a/examples/ecs/generic_system.rs
+++ b/examples/ecs/generic_system.rs
@@ -73,7 +73,7 @@ fn print_text_system(time: Res<Time>, mut query: Query<(&mut PrinterTick, &TextT
 
 fn transition_to_in_game_system(
     mut next_state: ResMut<NextState<AppState>>,
-    keyboard_input: Res<Input<KeyCode>>,
+    keyboard_input: Res<Input<KeyLogic>>,
 ) {
     if keyboard_input.pressed(KeyCode::Space) {
         next_state.set(AppState::InGame);
diff --git a/examples/ecs/run_conditions.rs b/examples/ecs/run_conditions.rs
index 9e816c7efe0d3..6a77ab9b1c5ee 100644
--- a/examples/ecs/run_conditions.rs
+++ b/examples/ecs/run_conditions.rs
@@ -64,7 +64,7 @@ struct Unused;
 /// they are read only (except for local parameters which can be mutable).
 /// It returns a bool which determines if the system should run.
 fn has_user_input(
-    keyboard_input: Res<Input<KeyCode>>,
+    keyboard_input: Res<Input<KeyLogic>>,
     mouse_button_input: Res<Input<MouseButton>>,
     touch_input: Res<Touches>,
 ) -> bool {
diff --git a/examples/ecs/state.rs b/examples/ecs/state.rs
index 0d55e4c290880..27a0cf70e1ba7 100644
--- a/examples/ecs/state.rs
+++ b/examples/ecs/state.rs
@@ -132,7 +132,7 @@ fn setup_game(mut commands: Commands, asset_server: Res<AssetServer>) {
 const SPEED: f32 = 100.0;
 fn movement(
     time: Res<Time>,
-    input: Res<Input<KeyCode>>,
+    input: Res<Input<KeyLogic>>,
     mut query: Query<&mut Transform, With<Sprite>>,
 ) {
     for mut transform in &mut query {
diff --git a/examples/games/alien_cake_addict.rs b/examples/games/alien_cake_addict.rs
index 9ba902a8abde3..769710bea2d72 100644
--- a/examples/games/alien_cake_addict.rs
+++ b/examples/games/alien_cake_addict.rs
@@ -196,7 +196,7 @@ fn teardown(mut commands: Commands, entities: Query<Entity, (Without<Camera>, Wi
 // control the game character
 fn move_player(
     mut commands: Commands,
-    keyboard_input: Res<Input<KeyCode>>,
+    keyboard_input: Res<Input<KeyLogic>>,
     mut game: ResMut<Game>,
     mut transforms: Query<&mut Transform>,
     time: Res<Time>,
@@ -380,7 +380,7 @@ fn scoreboard_system(game: Res<Game>, mut query: Query<&mut Text>) {
 // restart the game when pressing spacebar
 fn gameover_keyboard(
     mut next_state: ResMut<NextState<GameState>>,
-    keyboard_input: Res<Input<KeyCode>>,
+    keyboard_input: Res<Input<KeyLogic>>,
 ) {
     if keyboard_input.just_pressed(KeyCode::Space) {
         next_state.set(GameState::Playing);
diff --git a/examples/games/breakout.rs b/examples/games/breakout.rs
index 57a811b1a641b..f403d3bf875c1 100644
--- a/examples/games/breakout.rs
+++ b/examples/games/breakout.rs
@@ -303,7 +303,7 @@ fn setup(
 }
 
 fn move_paddle(
-    keyboard_input: Res<Input<KeyCode>>,
+    keyboard_input: Res<Input<KeyLogic>>,
     mut query: Query<&mut Transform, With<Paddle>>,
     time: Res<Time>,
 ) {
diff --git a/examples/input/keyboard_input.rs b/examples/input/keyboard_input.rs
index 07bc59b49b5c9..8f8933ea93d82 100644
--- a/examples/input/keyboard_input.rs
+++ b/examples/input/keyboard_input.rs
@@ -9,17 +9,27 @@ fn main() {
         .run();
 }
 
-/// This system prints 'A' key state
-fn keyboard_input_system(keyboard_input: Res<Input<Key>>) {
-    if keyboard_input.pressed(Key::Character("a".into())) {
-        info!("'A' currently pressed");
+/// This system prints 'A' character key state
+fn keyboard_input_system(keyboard_input: Res<Input<KeyLogic>>) {
+    if keyboard_input.pressed("a") {
+        info!("Character lowercase 'a' currently pressed");
     }
 
-    if keyboard_input.just_pressed(Key::Character("a".into())) {
-        info!("'A' just pressed");
+    if keyboard_input.just_pressed("a") {
+        info!("Character lowercase 'a' just pressed");
     }
 
-    if keyboard_input.just_released(Key::Character("a".into())) {
-        info!("'A' just released");
+    if keyboard_input.just_released("a") {
+        info!("Character lowercase 'a' just released");
+    }
+
+    if keyboard_input.pressed("A") {
+        info!("Character uppercase 'A' currently pressed");
+    }
+    if keyboard_input.just_pressed("A") {
+        info!("Character uppercase 'A' just pressed");
+    }
+    if keyboard_input.just_released("A") {
+        info!("Character uppercase 'A' just released");
     }
 }
diff --git a/examples/input/keyboard_modifiers.rs b/examples/input/keyboard_modifiers.rs
index 64df72676f43c..536a80390b44d 100644
--- a/examples/input/keyboard_modifiers.rs
+++ b/examples/input/keyboard_modifiers.rs
@@ -10,7 +10,7 @@ fn main() {
 }
 
 /// This system prints when `Ctrl + Shift + A` is pressed
-fn keyboard_input_system(input: Res<Input<KeyCode>>) {
+fn keyboard_input_system(input: Res<Input<KeyLogic>>) {
     let shift = input.any_pressed([KeyCode::ShiftLeft, KeyCode::ShiftRight]);
     let ctrl = input.any_pressed([KeyCode::ControlLeft, KeyCode::ControlRight]);
 
diff --git a/examples/input/mouse_grab.rs b/examples/input/mouse_grab.rs
index 33e2574180e5e..103f822316ba1 100644
--- a/examples/input/mouse_grab.rs
+++ b/examples/input/mouse_grab.rs
@@ -14,7 +14,7 @@ fn main() {
 fn grab_mouse(
     mut windows: Query<&mut Window>,
     mouse: Res<Input<MouseButton>>,
-    key: Res<Input<KeyCode>>,
+    key: Res<Input<KeyLogic>>,
 ) {
     let mut window = windows.single_mut();
 
diff --git a/examples/shader/shader_prepass.rs b/examples/shader/shader_prepass.rs
index d3faa9f9fe457..b1a1e2cb7551a 100644
--- a/examples/shader/shader_prepass.rs
+++ b/examples/shader/shader_prepass.rs
@@ -224,7 +224,7 @@ impl Material for PrepassOutputMaterial {
 /// Every time you press space, it will cycle between transparent, depth and normals view
 fn toggle_prepass_view(
     mut prepass_view: Local<u32>,
-    keycode: Res<Input<KeyCode>>,
+    keycode: Res<Input<KeyLogic>>,
     material_handle: Query<&Handle<PrepassOutputMaterial>>,
     mut materials: ResMut<Assets<PrepassOutputMaterial>>,
     mut text: Query<&mut Text>,
diff --git a/examples/stress_tests/many_foxes.rs b/examples/stress_tests/many_foxes.rs
index 2988b344dbe3f..c1a30e1237c65 100644
--- a/examples/stress_tests/many_foxes.rs
+++ b/examples/stress_tests/many_foxes.rs
@@ -246,7 +246,7 @@ fn update_fox_rings(
 }
 
 fn keyboard_animation_control(
-    keyboard_input: Res<Input<KeyCode>>,
+    keyboard_input: Res<Input<KeyLogic>>,
     mut animation_player: Query<&mut AnimationPlayer>,
     animations: Res<Animations>,
     mut current_animation: Local<usize>,
diff --git a/examples/stress_tests/many_gizmos.rs b/examples/stress_tests/many_gizmos.rs
index 956ad95c6e687..1d572c6a92426 100644
--- a/examples/stress_tests/many_gizmos.rs
+++ b/examples/stress_tests/many_gizmos.rs
@@ -41,7 +41,7 @@ struct Config {
     fancy: bool,
 }
 
-fn input(mut config: ResMut<Config>, input: Res<Input<KeyCode>>) {
+fn input(mut config: ResMut<Config>, input: Res<Input<KeyLogic>>) {
     if input.just_pressed(KeyCode::ArrowUp) {
         config.line_count += 10_000;
     }
diff --git a/examples/time/virtual_time.rs b/examples/time/virtual_time.rs
index bcc41507ec18a..823468027f462 100644
--- a/examples/time/virtual_time.rs
+++ b/examples/time/virtual_time.rs
@@ -18,8 +18,7 @@ fn main() {
                 move_virtual_time_sprites,
                 move_real_time_sprites,
                 toggle_pause.run_if(input_just_pressed(KeyCode::Space)),
-                change_time_speed::<1>.run_if(input_just_pressed(KeyCode::Up)),
-                change_time_speed::<-1>.run_if(input_just_pressed(KeyCode::Down)),
+                change_time_speed::<1>.run_if(input_just_pressed(KeyCode::ArrowDown)),
                 (update_virtual_time_info_text, update_real_time_info_text)
                     // update the texts on a timer to make them more readable
                     // `on_timer` run condition uses `Virtual` time meaning it's scaled
diff --git a/examples/tools/scene_viewer/animation_plugin.rs b/examples/tools/scene_viewer/animation_plugin.rs
index c6483c00d6b7e..fec2af2a69e20 100644
--- a/examples/tools/scene_viewer/animation_plugin.rs
+++ b/examples/tools/scene_viewer/animation_plugin.rs
@@ -66,7 +66,7 @@ fn assign_clips(
 }
 
 fn handle_inputs(
-    keyboard_input: Res<Input<KeyCode>>,
+    keyboard_input: Res<Input<KeyLogic>>,
     mut animation_player: Query<(&mut AnimationPlayer, &mut Clips, Entity, Option<&Name>)>,
 ) {
     for (mut player, mut clips, entity, name) in &mut animation_player {
diff --git a/examples/tools/scene_viewer/camera_controller_plugin.rs b/examples/tools/scene_viewer/camera_controller_plugin.rs
index ebd7979563927..76112a10b7e47 100644
--- a/examples/tools/scene_viewer/camera_controller_plugin.rs
+++ b/examples/tools/scene_viewer/camera_controller_plugin.rs
@@ -100,7 +100,7 @@ fn camera_controller(
     mut windows: Query<&mut Window>,
     mut mouse_events: EventReader<MouseMotion>,
     mouse_button_input: Res<Input<MouseButton>>,
-    key_input: Res<Input<KeyCode>>,
+    key_input: Res<Input<KeyLogic>>,
     mut move_toggled: Local<bool>,
     mut query: Query<(&mut Transform, &mut CameraController), With<Camera>>,
 ) {
diff --git a/examples/tools/scene_viewer/morph_viewer_plugin.rs b/examples/tools/scene_viewer/morph_viewer_plugin.rs
index 2c8a305adfbef..cc794ebb43fc9 100644
--- a/examples/tools/scene_viewer/morph_viewer_plugin.rs
+++ b/examples/tools/scene_viewer/morph_viewer_plugin.rs
@@ -166,7 +166,7 @@ impl MorphKey {
             key,
         }
     }
-    fn active(&self, inputs: &Input<KeyCode>) -> bool {
+    fn active(&self, inputs: &Input<KeyLogic>) -> bool {
         let mut modifier = self.modifiers.iter();
         let mut non_modifier = ALL_MODIFIERS.iter().filter(|m| !self.modifiers.contains(m));
 
@@ -202,7 +202,7 @@ fn update_text(
 fn update_morphs(
     controls: Option<ResMut<WeightsControl>>,
     mut morphs: Query<&mut MorphWeights>,
-    input: Res<Input<KeyCode>>,
+    input: Res<Input<KeyLogic>>,
     time: Res<Time>,
 ) {
     let Some(mut controls) = controls else {
diff --git a/examples/tools/scene_viewer/scene_viewer_plugin.rs b/examples/tools/scene_viewer/scene_viewer_plugin.rs
index c6c9c983e49ac..0d4e507353238 100644
--- a/examples/tools/scene_viewer/scene_viewer_plugin.rs
+++ b/examples/tools/scene_viewer/scene_viewer_plugin.rs
@@ -145,7 +145,7 @@ fn scene_load_check(
 }
 
 fn update_lights(
-    key_input: Res<Input<KeyCode>>,
+    key_input: Res<Input<KeyLogic>>,
     time: Res<Time>,
     mut query: Query<(&mut Transform, &mut DirectionalLight)>,
     mut animate_directional_light: Local<bool>,
@@ -202,7 +202,7 @@ impl CameraTracker {
 
 fn camera_tracker(
     mut camera_tracker: ResMut<CameraTracker>,
-    keyboard_input: Res<Input<KeyCode>>,
+    keyboard_input: Res<Input<KeyLogic>>,
     mut queries: ParamSet<(
         Query<(Entity, &mut Camera), (Added<Camera>, Without<CameraController>)>,
         Query<(Entity, &mut Camera), (Added<Camera>, With<CameraController>)>,
diff --git a/examples/ui/overflow_debug.rs b/examples/ui/overflow_debug.rs
index 94354f57072f2..094895a150841 100644
--- a/examples/ui/overflow_debug.rs
+++ b/examples/ui/overflow_debug.rs
@@ -239,7 +239,7 @@ fn spawn_container(
 fn update_animation(
     mut animation: ResMut<AnimationState>,
     time: Res<Time>,
-    keys: Res<Input<KeyCode>>,
+    keys: Res<Input<KeyLogic>>,
 ) {
     let time = time.elapsed_seconds();
 
@@ -270,7 +270,7 @@ fn update_transform<T: UpdateTransform + Component>(
     }
 }
 
-fn toggle_overflow(keys: Res<Input<KeyCode>>, mut containers: Query<&mut Style, With<Container>>) {
+fn toggle_overflow(keys: Res<Input<KeyLogic>>, mut containers: Query<&mut Style, With<Container>>) {
     if keys.just_pressed(KeyCode::KeyO) {
         for mut style in &mut containers {
             style.overflow = match style.overflow {
@@ -293,7 +293,7 @@ fn toggle_overflow(keys: Res<Input<KeyCode>>, mut containers: Query<&mut Style,
 }
 
 fn next_container_size(
-    keys: Res<Input<KeyCode>>,
+    keys: Res<Input<KeyLogic>>,
     mut containers: Query<(&mut Style, &mut Container)>,
 ) {
     if keys.just_pressed(KeyCode::KeyS) {
diff --git a/examples/ui/ui_scaling.rs b/examples/ui/ui_scaling.rs
index f87a301832131..9bb67d13e6564 100644
--- a/examples/ui/ui_scaling.rs
+++ b/examples/ui/ui_scaling.rs
@@ -84,7 +84,7 @@ fn setup(mut commands: Commands, asset_server: ResMut<AssetServer>) {
 }
 
 /// System that changes the scale of the ui when pressing up or down on the keyboard.
-fn change_scaling(input: Res<Input<KeyCode>>, mut ui_scale: ResMut<TargetScale>) {
+fn change_scaling(input: Res<Input<KeyLogic>>, mut ui_scale: ResMut<TargetScale>) {
     if input.just_pressed(KeyCode::ArrowUp) {
         let scale = (ui_scale.target_scale * 2.0).min(8.);
         ui_scale.set_scale(scale);
diff --git a/examples/ui/ui_texture_atlas.rs b/examples/ui/ui_texture_atlas.rs
index dbab05c02d6f6..3ab7aeedac6d2 100644
--- a/examples/ui/ui_texture_atlas.rs
+++ b/examples/ui/ui_texture_atlas.rs
@@ -76,7 +76,7 @@ fn setup(
 
 fn increment_atlas_index(
     mut atlas_images: Query<&mut UiTextureAtlasImage>,
-    keyboard: Res<Input<KeyCode>>,
+    keyboard: Res<Input<KeyLogic>>,
 ) {
     if keyboard.just_pressed(KeyCode::Space) {
         for mut atlas_image in &mut atlas_images {
diff --git a/examples/ui/window_fallthrough.rs b/examples/ui/window_fallthrough.rs
index 83c6d20684417..10ea211f8ab00 100644
--- a/examples/ui/window_fallthrough.rs
+++ b/examples/ui/window_fallthrough.rs
@@ -47,7 +47,7 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     ));
 }
 // A simple system to handle some keyboard input and toggle on/off the hittest.
-fn toggle_mouse_passthrough(keyboard_input: Res<Input<KeyCode>>, mut windows: Query<&mut Window>) {
+fn toggle_mouse_passthrough(keyboard_input: Res<Input<KeyLogic>>, mut windows: Query<&mut Window>) {
     if keyboard_input.just_pressed(KeyCode::KeyP) {
         let mut window = windows.single_mut();
         window.cursor.hit_test = !window.cursor.hit_test;
diff --git a/examples/window/clear_color.rs b/examples/window/clear_color.rs
index dc136e3a3b28d..8a6b007c2f90c 100644
--- a/examples/window/clear_color.rs
+++ b/examples/window/clear_color.rs
@@ -17,7 +17,7 @@ fn setup(mut commands: Commands) {
     commands.spawn(Camera2dBundle::default());
 }
 
-fn change_clear_color(input: Res<Input<KeyCode>>, mut clear_color: ResMut<ClearColor>) {
+fn change_clear_color(input: Res<Input<KeyLogic>>, mut clear_color: ResMut<ClearColor>) {
     if input.just_pressed(KeyCode::Space) {
         clear_color.0 = Color::PURPLE;
     }
diff --git a/examples/window/low_power.rs b/examples/window/low_power.rs
index e3715a9eb8ac8..37895e6df9e58 100644
--- a/examples/window/low_power.rs
+++ b/examples/window/low_power.rs
@@ -97,7 +97,7 @@ pub(crate) mod test_setup {
     /// Switch between update modes when the mouse is clicked.
     pub(crate) fn cycle_modes(
         mut mode: ResMut<ExampleMode>,
-        mouse_button_input: Res<Input<KeyCode>>,
+        mouse_button_input: Res<Input<KeyLogic>>,
     ) {
         if mouse_button_input.just_pressed(KeyCode::Space) {
             *mode = match *mode {
diff --git a/examples/window/scale_factor_override.rs b/examples/window/scale_factor_override.rs
index 30b7660a12276..29c200d6543ff 100644
--- a/examples/window/scale_factor_override.rs
+++ b/examples/window/scale_factor_override.rs
@@ -76,7 +76,7 @@ fn display_override(mut windows: Query<&mut Window>) {
 }
 
 /// This system toggles scale factor overrides when enter is pressed
-fn toggle_override(input: Res<Input<KeyCode>>, mut windows: Query<&mut Window>) {
+fn toggle_override(input: Res<Input<KeyLogic>>, mut windows: Query<&mut Window>) {
     let mut window = windows.single_mut();
 
     if input.just_pressed(KeyCode::Enter) {
@@ -88,7 +88,7 @@ fn toggle_override(input: Res<Input<KeyCode>>, mut windows: Query<&mut Window>)
 }
 
 /// This system changes the scale factor override when up or down is pressed
-fn change_scale_factor(input: Res<Input<KeyCode>>, mut windows: Query<&mut Window>) {
+fn change_scale_factor(input: Res<Input<KeyLogic>>, mut windows: Query<&mut Window>) {
     let mut window = windows.single_mut();
     let scale_factor_override = window.resolution.scale_factor_override();
     if input.just_pressed(KeyCode::ArrowUp) {
diff --git a/examples/window/screenshot.rs b/examples/window/screenshot.rs
index 340dadd72b022..ba29c75e3bc95 100644
--- a/examples/window/screenshot.rs
+++ b/examples/window/screenshot.rs
@@ -13,7 +13,7 @@ fn main() {
 }
 
 fn screenshot_on_spacebar(
-    input: Res<Input<KeyCode>>,
+    input: Res<Input<KeyLogic>>,
     main_window: Query<Entity, With<PrimaryWindow>>,
     mut screenshot_manager: ResMut<ScreenshotManager>,
     mut counter: Local<u32>,
diff --git a/examples/window/window_resizing.rs b/examples/window/window_resizing.rs
index 67142a36fa528..5b7e8f88707ad 100644
--- a/examples/window/window_resizing.rs
+++ b/examples/window/window_resizing.rs
@@ -58,7 +58,7 @@ fn setup_ui(mut cmd: Commands) {
 
 /// This system shows how to request the window to a new resolution
 fn toggle_resolution(
-    keys: Res<Input<KeyCode>>,
+    keys: Res<Input<KeyLogic>>,
     mut windows: Query<&mut Window>,
     resolution: Res<ResolutionSettings>,
 ) {
diff --git a/examples/window/window_settings.rs b/examples/window/window_settings.rs
index 2c28807f5003a..bbcb701d5b9e8 100644
--- a/examples/window/window_settings.rs
+++ b/examples/window/window_settings.rs
@@ -64,7 +64,7 @@ fn make_visible(mut window: Query<&mut Window>, frames: Res<FrameCount>) {
 
 /// This system toggles the vsync mode when pressing the button V.
 /// You'll see fps increase displayed in the console.
-fn toggle_vsync(input: Res<Input<KeyCode>>, mut windows: Query<&mut Window>) {
+fn toggle_vsync(input: Res<Input<KeyLogic>>, mut windows: Query<&mut Window>) {
     if input.just_pressed(KeyCode::KeyV) {
         let mut window = windows.single_mut();
 
@@ -84,7 +84,7 @@ fn toggle_vsync(input: Res<Input<KeyCode>>, mut windows: Query<&mut Window>) {
 /// This feature only works on some platforms. Please check the
 /// [documentation](https://docs.rs/bevy/latest/bevy/prelude/struct.Window.html#structfield.window_level)
 /// for more details.
-fn switch_level(input: Res<Input<KeyCode>>, mut windows: Query<&mut Window>) {
+fn switch_level(input: Res<Input<KeyLogic>>, mut windows: Query<&mut Window>) {
     if input.just_pressed(KeyCode::KeyT) {
         let mut window = windows.single_mut();
 
@@ -102,10 +102,10 @@ fn switch_level(input: Res<Input<KeyCode>>, mut windows: Query<&mut Window>) {
 /// This feature only works on some platforms. Please check the
 /// [documentation](https://docs.rs/bevy/latest/bevy/prelude/struct.Window.html#structfield.enabled_buttons)
 /// for more details.
-fn toggle_window_controls(input: Res<Input<KeyCode>>, mut windows: Query<&mut Window>) {
-    let toggle_minimize = input.just_pressed(KeyCode::Key1);
-    let toggle_maximize = input.just_pressed(KeyCode::Key2);
-    let toggle_close = input.just_pressed(KeyCode::Key3);
+fn toggle_window_controls(input: Res<Input<KeyLogic>>, mut windows: Query<&mut Window>) {
+    let toggle_minimize = input.just_pressed(KeyCode::Digit1);
+    let toggle_maximize = input.just_pressed(KeyCode::Digit2);
+    let toggle_close = input.just_pressed(KeyCode::Digit3);
 
     if toggle_minimize || toggle_maximize || toggle_close {
         let mut window = windows.single_mut();
@@ -131,7 +131,7 @@ fn change_title(mut windows: Query<&mut Window>, time: Res<Time>) {
     );
 }
 
-fn toggle_cursor(mut windows: Query<&mut Window>, input: Res<Input<KeyCode>>) {
+fn toggle_cursor(mut windows: Query<&mut Window>, input: Res<Input<KeyLogic>>) {
     if input.just_pressed(KeyCode::Space) {
         let mut window = windows.single_mut();
 
@@ -144,7 +144,7 @@ fn toggle_cursor(mut windows: Query<&mut Window>, input: Res<Input<KeyCode>>) {
 }
 
 // This system will toggle the color theme used by the window
-fn toggle_theme(mut windows: Query<&mut Window>, input: Res<Input<KeyCode>>) {
+fn toggle_theme(mut windows: Query<&mut Window>, input: Res<Input<KeyLogic>>) {
     if input.just_pressed(KeyCode::KeyF) {
         let mut window = windows.single_mut();
 
diff --git a/tests/how_to_test_systems.rs b/tests/how_to_test_systems.rs
index 23b29bd550c2b..cf29f8dfe613d 100644
--- a/tests/how_to_test_systems.rs
+++ b/tests/how_to_test_systems.rs
@@ -37,7 +37,7 @@ fn hurt_enemies(mut enemies: Query<&mut Enemy>) {
     }
 }
 
-fn spawn_enemy(mut commands: Commands, keyboard_input: Res<Input<KeyCode>>) {
+fn spawn_enemy(mut commands: Commands, keyboard_input: Res<Input<KeyLogic>>) {
     if keyboard_input.just_pressed(KeyCode::Space) {
         commands.spawn(Enemy {
             hit_points: 5,
@@ -124,7 +124,7 @@ fn spawn_enemy_using_input_resource() {
     app.add_systems(Update, spawn_enemy);
 
     // Setup test resource
-    let mut input = Input::<KeyCode>::default();
+    let mut input = Input::<KeyLogic>::default();
     input.press(KeyCode::Space);
     app.insert_resource(input);
 
@@ -134,8 +134,8 @@ fn spawn_enemy_using_input_resource() {
     // Check resulting changes, one entity has been spawned with `Enemy` component
     assert_eq!(app.world.query::<&Enemy>().iter(&app.world).len(), 1);
 
-    // Clear the `just_pressed` status for all `KeyCode`s
-    app.world.resource_mut::<Input<KeyCode>>().clear();
+    // Clear the `just_pressed` status for all `KeyLogic`s
+    app.world.resource_mut::<Input<KeyLogic>>().clear();
 
     // Run systems
     app.update();