diff --git a/crates/bevy_input/src/common_conditions.rs b/crates/bevy_input/src/common_conditions.rs
index 4a7e4dd7bed9f1..d4615c3f9b9f8b 100644
--- a/crates/bevy_input/src/common_conditions.rs
+++ b/crates/bevy_input/src/common_conditions.rs
@@ -7,12 +7,12 @@ use std::hash::Hash;
 /// ```no_run
 /// # use bevy_app::{App, NoopPluginGroup as DefaultPlugins, Update};
 /// # use bevy_ecs::prelude::IntoSystemConfigs;
-/// # use bevy_input::{common_conditions::input_toggle_active, prelude::KeyCode};
+/// # use bevy_input::{common_conditions::input_toggle_active, prelude::PhysicalKeyCode};
 ///
 /// fn main() {
 ///     App::new()
 ///         .add_plugins(DefaultPlugins)
-///         .add_systems(Update, pause_menu.run_if(input_toggle_active(false, KeyCode::Escape)))
+///         .add_systems(Update, pause_menu.run_if(input_toggle_active(false, PhysicalKeyCode::Escape)))
 ///         .run();
 /// }
 ///
@@ -26,7 +26,7 @@ use std::hash::Hash;
 /// ```no_run
 /// # use bevy_app::{App, NoopPluginGroup as DefaultPlugins, Update};
 /// # use bevy_ecs::prelude::{IntoSystemConfigs, Res, ResMut, Resource};
-/// # use bevy_input::{common_conditions::input_just_pressed, prelude::KeyCode};
+/// # use bevy_input::{common_conditions::input_just_pressed, prelude::PhysicalKeyCode};
 ///
 /// #[derive(Resource, Default)]
 /// struct Paused(bool);
@@ -35,7 +35,7 @@ use std::hash::Hash;
 ///     App::new()
 ///         .add_plugins(DefaultPlugins)
 ///         .init_resource::<Paused>()
-///         .add_systems(Update, toggle_pause_state.run_if(input_just_pressed(KeyCode::Escape)))
+///         .add_systems(Update, toggle_pause_state.run_if(input_just_pressed(PhysicalKeyCode::Escape)))
 ///         .add_systems(Update, pause_menu.run_if(|paused: Res<Paused>| paused.0))
 ///         .run();
 /// }
@@ -76,11 +76,11 @@ where
 /// ```no_run
 /// # use bevy_app::{App, NoopPluginGroup as DefaultPlugins, Update};
 /// # use bevy_ecs::prelude::IntoSystemConfigs;
-/// # use bevy_input::{common_conditions::input_just_pressed, prelude::KeyCode};
+/// # use bevy_input::{common_conditions::input_just_pressed, prelude::PhysicalKeyCode};
 /// fn main() {
 ///     App::new()
 ///         .add_plugins(DefaultPlugins)
-///         .add_systems(Update, jump.run_if(input_just_pressed(KeyCode::Space)))
+///         .add_systems(Update, jump.run_if(input_just_pressed(PhysicalKeyCode::Space)))
 ///         .run();
 /// }
 ///
@@ -104,7 +104,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::prelude::KeyCode;
+    use crate::prelude::PhysicalKeyCode;
     use bevy_ecs::schedule::{IntoSystemConfigs, Schedule};
 
     fn test_system() {}
@@ -114,10 +114,10 @@ mod tests {
     fn distributive_run_if_compiles() {
         Schedule::default().add_systems(
             (test_system, test_system)
-                .distributive_run_if(input_toggle_active(false, KeyCode::Escape))
-                .distributive_run_if(input_pressed(KeyCode::Escape))
-                .distributive_run_if(input_just_pressed(KeyCode::Escape))
-                .distributive_run_if(input_just_released(KeyCode::Escape)),
+                .distributive_run_if(input_toggle_active(false, PhysicalKeyCode::Escape))
+                .distributive_run_if(input_pressed(PhysicalKeyCode::Escape))
+                .distributive_run_if(input_just_pressed(PhysicalKeyCode::Escape))
+                .distributive_run_if(input_just_released(PhysicalKeyCode::Escape)),
         );
     }
 }
diff --git a/crates/bevy_input/src/keyboard.rs b/crates/bevy_input/src/keyboard.rs
index 3465403871f453..d469fd7eab32f0 100644
--- a/crates/bevy_input/src/keyboard.rs
+++ b/crates/bevy_input/src/keyboard.rs
@@ -1,19 +1,19 @@
 //! The keyboard input functionality.
 
 // This file contains a substantial portion of the UI Events Specification by the W3C. In
-// particular, the variant names within `KeyCode` and their documentation are modified
+// particular, the variant names within `PhysicalKeyCode` and their documentation are modified
 // versions of contents of the aforementioned specification.
 //
 // The original documents are:
 //
 //
-// ### For `KeyCode`
+// ### For `PhysicalKeyCode`
 // UI Events KeyboardEvent code Values
 // https://www.w3.org/TR/2017/CR-uievents-code-20170601/
 // Copyright © 2017 W3C® (MIT, ERCIM, Keio, Beihang).
 //
 // These documents were used under the terms of the following license. This W3C license as well as
-// the W3C short notice apply to the `KeyCode` enums and their variants and the
+// the W3C short notice apply to the `PhysicalKeyCode` enums and their variants and the
 // documentation attached to their variants.
 
 // --------- BEGGINING OF W3C LICENSE --------------------------------------------------------------
@@ -86,7 +86,7 @@ use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
 /// ## Usage
 ///
 /// The event is consumed inside of the [`keyboard_input_system`]
-/// to update the [`Input<KeyCode>`](ButtonInput<KeyCode>) resource.
+/// to update the [`Input<PhysicalKeyCode>`](ButtonInput<PhysicalKeyCode>) resource.
 #[derive(Event, Debug, Clone, PartialEq, Eq, Reflect)]
 #[reflect(Debug, PartialEq)]
 #[cfg_attr(
@@ -96,7 +96,7 @@ use bevy_reflect::{ReflectDeserialize, ReflectSerialize};
 )]
 pub struct KeyboardInput {
     /// The physical key code of the key.
-    pub key_code: KeyCode,
+    pub key_code: PhysicalKeyCode,
     /// The logical key of the input
     pub logical_key: Key,
     /// The press state of the key.
@@ -105,14 +105,14 @@ pub struct KeyboardInput {
     pub window: Entity,
 }
 
-/// Updates the [`ButtonInput<KeyCode>`] resource with the latest [`KeyboardInput`] events.
+/// Updates the [`ButtonInput<PhysicalKeyCode>`] resource with the latest [`KeyboardInput`] events.
 ///
 /// ## Differences
 ///
-/// The main difference between the [`KeyboardInput`] event and the [`ButtonInput<KeyCode>`] resources is that
+/// The main difference between the [`KeyboardInput`] event and the [`ButtonInput<PhysicalKeyCode>`] resources is that
 /// the latter have convenient functions such as [`ButtonInput::pressed`], [`ButtonInput::just_pressed`] and [`ButtonInput::just_released`].
 pub fn keyboard_input_system(
-    mut key_input: ResMut<ButtonInput<KeyCode>>,
+    mut key_input: ResMut<ButtonInput<PhysicalKeyCode>>,
     mut keyboard_input_events: EventReader<KeyboardInput>,
 ) {
     // Avoid clearing if it's not empty to ensure change detection is not triggered.
@@ -134,8 +134,8 @@ pub fn keyboard_input_system(
 /// enum), but the values are primarily tied to the key's physical location on the keyboard.
 ///
 /// This enum is primarily used to store raw keycodes when Winit doesn't map a given native
-/// physical key identifier to a meaningful [`KeyCode`] variant. In the presence of identifiers we
-/// haven't mapped for you yet, this lets you use use [`KeyCode`] to:
+/// physical key identifier to a meaningful [`PhysicalKeyCode`] variant. In the presence of identifiers we
+/// haven't mapped for you yet, this lets you use use [`PhysicalKeyCode`] to:
 ///
 /// - Correctly match key press and release events.
 /// - On non-web platforms, support assigning keybinds to virtually any key through a UI.
@@ -162,7 +162,7 @@ pub enum NativeKeyCode {
 ///
 /// ## Usage
 ///
-/// It is used as the generic `T` value of an [`ButtonInput`] to create a `Res<Input<KeyCode>>`.
+/// It is used as the generic `T` value of an [`ButtonInput`] to create a `Res<ButtonInput<PhysicalKeyCode>>`.
 ///
 /// Code representing the location of a physical key
 /// This mostly conforms to the UI Events Specification's [`KeyboardEvent.code`] with a few
@@ -184,11 +184,11 @@ pub enum NativeKeyCode {
     reflect(Serialize, Deserialize)
 )]
 #[repr(u32)]
-pub enum KeyCode {
+pub enum PhysicalKeyCode {
     /// This variant is used when the key cannot be translated to any other variant.
     ///
     /// The native keycode is provided (if available) so you're able to more reliably match
-    /// key-press and key-release events by hashing the [`KeyCode`]. It is also possible to use
+    /// key-press and key-release events by hashing the [`PhysicalKeyCode`]. It is also possible to use
     /// this for keybinds for non-standard keys, but such keybinds are tied to a given platform.
     Unidentified(NativeKeyCode),
     /// <kbd>`</kbd> on a US keyboard. This is also called a backtick or grave.
diff --git a/crates/bevy_input/src/lib.rs b/crates/bevy_input/src/lib.rs
index e6841ace816368..b536eada067c50 100644
--- a/crates/bevy_input/src/lib.rs
+++ b/crates/bevy_input/src/lib.rs
@@ -24,7 +24,7 @@ pub mod prelude {
         gamepad::{
             Gamepad, GamepadAxis, GamepadAxisType, GamepadButton, GamepadButtonType, Gamepads,
         },
-        keyboard::KeyCode,
+        keyboard::PhysicalKeyCode,
         mouse::MouseButton,
         touch::{TouchInput, Touches},
         Axis, ButtonInput,
@@ -34,7 +34,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, NativeKeyCode};
+use keyboard::{
+    keyboard_input_system, Key, KeyboardInput, NativeKey, NativeKeyCode, PhysicalKeyCode,
+};
 use mouse::{
     mouse_button_input_system, MouseButton, MouseButtonInput, MouseMotion, MouseScrollUnit,
     MouseWheel,
@@ -66,7 +68,7 @@ impl Plugin for InputPlugin {
         app
             // keyboard
             .add_event::<KeyboardInput>()
-            .init_resource::<ButtonInput<KeyCode>>()
+            .init_resource::<ButtonInput<PhysicalKeyCode>>()
             .add_systems(PreUpdate, keyboard_input_system.in_set(InputSystem))
             // mouse
             .add_event::<MouseButtonInput>()
@@ -112,7 +114,7 @@ impl Plugin for InputPlugin {
 
         // Register keyboard types
         app.register_type::<KeyboardInput>()
-            .register_type::<KeyCode>()
+            .register_type::<PhysicalKeyCode>()
             .register_type::<NativeKeyCode>()
             .register_type::<Key>()
             .register_type::<NativeKey>();
diff --git a/crates/bevy_window/src/system.rs b/crates/bevy_window/src/system.rs
index 96db42c96c2527..3596b6cdcf74eb 100644
--- a/crates/bevy_window/src/system.rs
+++ b/crates/bevy_window/src/system.rs
@@ -2,7 +2,7 @@ use crate::{PrimaryWindow, Window, WindowCloseRequested};
 
 use bevy_app::AppExit;
 use bevy_ecs::prelude::*;
-use bevy_input::{keyboard::KeyCode, ButtonInput};
+use bevy_input::{keyboard::PhysicalKeyCode, ButtonInput};
 
 /// Exit the application when there are no open windows.
 ///
@@ -52,14 +52,14 @@ 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<ButtonInput<KeyCode>>,
+    input: Res<ButtonInput<PhysicalKeyCode>>,
 ) {
     for (window, focus) in focused_windows.iter() {
         if !focus.focused {
             continue;
         }
 
-        if input.just_pressed(KeyCode::Escape) {
+        if input.just_pressed(PhysicalKeyCode::Escape) {
             commands.entity(window).despawn();
         }
     }
diff --git a/crates/bevy_winit/src/converters.rs b/crates/bevy_winit/src/converters.rs
index 5cc2c034755286..f777705fc7d6e6 100644
--- a/crates/bevy_winit/src/converters.rs
+++ b/crates/bevy_winit/src/converters.rs
@@ -1,6 +1,6 @@
 use bevy_ecs::entity::Entity;
 use bevy_input::{
-    keyboard::{KeyCode, KeyboardInput, NativeKeyCode},
+    keyboard::{KeyboardInput, NativeKeyCode, PhysicalKeyCode},
     mouse::MouseButton,
     touch::{ForceTouch, TouchInput, TouchPhase},
     ButtonState,
@@ -80,207 +80,209 @@ pub fn convert_physical_native_key_code(
         winit::keyboard::NativeKeyCode::Xkb(key_code) => NativeKeyCode::Xkb(key_code),
     }
 }
-pub fn convert_physical_key_code(virtual_key_code: winit::keyboard::PhysicalKey) -> KeyCode {
+pub fn convert_physical_key_code(
+    virtual_key_code: winit::keyboard::PhysicalKey,
+) -> PhysicalKeyCode {
     match virtual_key_code {
         winit::keyboard::PhysicalKey::Unidentified(native_key_code) => {
-            KeyCode::Unidentified(convert_physical_native_key_code(native_key_code))
+            PhysicalKeyCode::Unidentified(convert_physical_native_key_code(native_key_code))
         }
         winit::keyboard::PhysicalKey::Code(code) => match code {
-            winit::keyboard::KeyCode::Backquote => KeyCode::Backquote,
-            winit::keyboard::KeyCode::Backslash => KeyCode::Backslash,
-            winit::keyboard::KeyCode::BracketLeft => KeyCode::BracketLeft,
-            winit::keyboard::KeyCode::BracketRight => KeyCode::BracketRight,
-            winit::keyboard::KeyCode::Comma => KeyCode::Comma,
-            winit::keyboard::KeyCode::Digit0 => KeyCode::Digit0,
-            winit::keyboard::KeyCode::Digit1 => KeyCode::Digit1,
-            winit::keyboard::KeyCode::Digit2 => KeyCode::Digit2,
-            winit::keyboard::KeyCode::Digit3 => KeyCode::Digit3,
-            winit::keyboard::KeyCode::Digit4 => KeyCode::Digit4,
-            winit::keyboard::KeyCode::Digit5 => KeyCode::Digit5,
-            winit::keyboard::KeyCode::Digit6 => KeyCode::Digit6,
-            winit::keyboard::KeyCode::Digit7 => KeyCode::Digit7,
-            winit::keyboard::KeyCode::Digit8 => KeyCode::Digit8,
-            winit::keyboard::KeyCode::Digit9 => KeyCode::Digit9,
-            winit::keyboard::KeyCode::Equal => KeyCode::Equal,
-            winit::keyboard::KeyCode::IntlBackslash => KeyCode::IntlBackslash,
-            winit::keyboard::KeyCode::IntlRo => KeyCode::IntlRo,
-            winit::keyboard::KeyCode::IntlYen => KeyCode::IntlYen,
-            winit::keyboard::KeyCode::KeyA => KeyCode::KeyA,
-            winit::keyboard::KeyCode::KeyB => KeyCode::KeyB,
-            winit::keyboard::KeyCode::KeyC => KeyCode::KeyC,
-            winit::keyboard::KeyCode::KeyD => KeyCode::KeyD,
-            winit::keyboard::KeyCode::KeyE => KeyCode::KeyE,
-            winit::keyboard::KeyCode::KeyF => KeyCode::KeyF,
-            winit::keyboard::KeyCode::KeyG => KeyCode::KeyG,
-            winit::keyboard::KeyCode::KeyH => KeyCode::KeyH,
-            winit::keyboard::KeyCode::KeyI => KeyCode::KeyI,
-            winit::keyboard::KeyCode::KeyJ => KeyCode::KeyJ,
-            winit::keyboard::KeyCode::KeyK => KeyCode::KeyK,
-            winit::keyboard::KeyCode::KeyL => KeyCode::KeyL,
-            winit::keyboard::KeyCode::KeyM => KeyCode::KeyM,
-            winit::keyboard::KeyCode::KeyN => KeyCode::KeyN,
-            winit::keyboard::KeyCode::KeyO => KeyCode::KeyO,
-            winit::keyboard::KeyCode::KeyP => KeyCode::KeyP,
-            winit::keyboard::KeyCode::KeyQ => KeyCode::KeyQ,
-            winit::keyboard::KeyCode::KeyR => KeyCode::KeyR,
-            winit::keyboard::KeyCode::KeyS => KeyCode::KeyS,
-            winit::keyboard::KeyCode::KeyT => KeyCode::KeyT,
-            winit::keyboard::KeyCode::KeyU => KeyCode::KeyU,
-            winit::keyboard::KeyCode::KeyV => KeyCode::KeyV,
-            winit::keyboard::KeyCode::KeyW => KeyCode::KeyW,
-            winit::keyboard::KeyCode::KeyX => KeyCode::KeyX,
-            winit::keyboard::KeyCode::KeyY => KeyCode::KeyY,
-            winit::keyboard::KeyCode::KeyZ => KeyCode::KeyZ,
-            winit::keyboard::KeyCode::Minus => KeyCode::Minus,
-            winit::keyboard::KeyCode::Period => KeyCode::Period,
-            winit::keyboard::KeyCode::Quote => KeyCode::Quote,
-            winit::keyboard::KeyCode::Semicolon => KeyCode::Semicolon,
-            winit::keyboard::KeyCode::Slash => KeyCode::Slash,
-            winit::keyboard::KeyCode::AltLeft => KeyCode::AltLeft,
-            winit::keyboard::KeyCode::AltRight => KeyCode::AltRight,
-            winit::keyboard::KeyCode::Backspace => KeyCode::Backspace,
-            winit::keyboard::KeyCode::CapsLock => KeyCode::CapsLock,
-            winit::keyboard::KeyCode::ContextMenu => KeyCode::ContextMenu,
-            winit::keyboard::KeyCode::ControlLeft => KeyCode::ControlLeft,
-            winit::keyboard::KeyCode::ControlRight => KeyCode::ControlRight,
-            winit::keyboard::KeyCode::Enter => KeyCode::Enter,
-            winit::keyboard::KeyCode::SuperLeft => KeyCode::SuperLeft,
-            winit::keyboard::KeyCode::SuperRight => KeyCode::SuperRight,
-            winit::keyboard::KeyCode::ShiftLeft => KeyCode::ShiftLeft,
-            winit::keyboard::KeyCode::ShiftRight => KeyCode::ShiftRight,
-            winit::keyboard::KeyCode::Space => KeyCode::Space,
-            winit::keyboard::KeyCode::Tab => KeyCode::Tab,
-            winit::keyboard::KeyCode::Convert => KeyCode::Convert,
-            winit::keyboard::KeyCode::KanaMode => KeyCode::KanaMode,
-            winit::keyboard::KeyCode::Lang1 => KeyCode::Lang1,
-            winit::keyboard::KeyCode::Lang2 => KeyCode::Lang2,
-            winit::keyboard::KeyCode::Lang3 => KeyCode::Lang3,
-            winit::keyboard::KeyCode::Lang4 => KeyCode::Lang4,
-            winit::keyboard::KeyCode::Lang5 => KeyCode::Lang5,
-            winit::keyboard::KeyCode::NonConvert => KeyCode::NonConvert,
-            winit::keyboard::KeyCode::Delete => KeyCode::Delete,
-            winit::keyboard::KeyCode::End => KeyCode::End,
-            winit::keyboard::KeyCode::Help => KeyCode::Help,
-            winit::keyboard::KeyCode::Home => KeyCode::Home,
-            winit::keyboard::KeyCode::Insert => KeyCode::Insert,
-            winit::keyboard::KeyCode::PageDown => KeyCode::PageDown,
-            winit::keyboard::KeyCode::PageUp => KeyCode::PageUp,
-            winit::keyboard::KeyCode::ArrowDown => KeyCode::ArrowDown,
-            winit::keyboard::KeyCode::ArrowLeft => KeyCode::ArrowLeft,
-            winit::keyboard::KeyCode::ArrowRight => KeyCode::ArrowRight,
-            winit::keyboard::KeyCode::ArrowUp => KeyCode::ArrowUp,
-            winit::keyboard::KeyCode::NumLock => KeyCode::NumLock,
-            winit::keyboard::KeyCode::Numpad0 => KeyCode::Numpad0,
-            winit::keyboard::KeyCode::Numpad1 => KeyCode::Numpad1,
-            winit::keyboard::KeyCode::Numpad2 => KeyCode::Numpad2,
-            winit::keyboard::KeyCode::Numpad3 => KeyCode::Numpad3,
-            winit::keyboard::KeyCode::Numpad4 => KeyCode::Numpad4,
-            winit::keyboard::KeyCode::Numpad5 => KeyCode::Numpad5,
-            winit::keyboard::KeyCode::Numpad6 => KeyCode::Numpad6,
-            winit::keyboard::KeyCode::Numpad7 => KeyCode::Numpad7,
-            winit::keyboard::KeyCode::Numpad8 => KeyCode::Numpad8,
-            winit::keyboard::KeyCode::Numpad9 => KeyCode::Numpad9,
-            winit::keyboard::KeyCode::NumpadAdd => KeyCode::NumpadAdd,
-            winit::keyboard::KeyCode::NumpadBackspace => KeyCode::NumpadBackspace,
-            winit::keyboard::KeyCode::NumpadClear => KeyCode::NumpadClear,
-            winit::keyboard::KeyCode::NumpadClearEntry => KeyCode::NumpadClearEntry,
-            winit::keyboard::KeyCode::NumpadComma => KeyCode::NumpadComma,
-            winit::keyboard::KeyCode::NumpadDecimal => KeyCode::NumpadDecimal,
-            winit::keyboard::KeyCode::NumpadDivide => KeyCode::NumpadDivide,
-            winit::keyboard::KeyCode::NumpadEnter => KeyCode::NumpadEnter,
-            winit::keyboard::KeyCode::NumpadEqual => KeyCode::NumpadEqual,
-            winit::keyboard::KeyCode::NumpadHash => KeyCode::NumpadHash,
-            winit::keyboard::KeyCode::NumpadMemoryAdd => KeyCode::NumpadMemoryAdd,
-            winit::keyboard::KeyCode::NumpadMemoryClear => KeyCode::NumpadMemoryClear,
-            winit::keyboard::KeyCode::NumpadMemoryRecall => KeyCode::NumpadMemoryRecall,
-            winit::keyboard::KeyCode::NumpadMemoryStore => KeyCode::NumpadMemoryStore,
-            winit::keyboard::KeyCode::NumpadMemorySubtract => KeyCode::NumpadMemorySubtract,
-            winit::keyboard::KeyCode::NumpadMultiply => KeyCode::NumpadMultiply,
-            winit::keyboard::KeyCode::NumpadParenLeft => KeyCode::NumpadParenLeft,
-            winit::keyboard::KeyCode::NumpadParenRight => KeyCode::NumpadParenRight,
-            winit::keyboard::KeyCode::NumpadStar => KeyCode::NumpadStar,
-            winit::keyboard::KeyCode::NumpadSubtract => KeyCode::NumpadSubtract,
-            winit::keyboard::KeyCode::Escape => KeyCode::Escape,
-            winit::keyboard::KeyCode::Fn => KeyCode::Fn,
-            winit::keyboard::KeyCode::FnLock => KeyCode::FnLock,
-            winit::keyboard::KeyCode::PrintScreen => KeyCode::PrintScreen,
-            winit::keyboard::KeyCode::ScrollLock => KeyCode::ScrollLock,
-            winit::keyboard::KeyCode::Pause => KeyCode::Pause,
-            winit::keyboard::KeyCode::BrowserBack => KeyCode::BrowserBack,
-            winit::keyboard::KeyCode::BrowserFavorites => KeyCode::BrowserFavorites,
-            winit::keyboard::KeyCode::BrowserForward => KeyCode::BrowserForward,
-            winit::keyboard::KeyCode::BrowserHome => KeyCode::BrowserHome,
-            winit::keyboard::KeyCode::BrowserRefresh => KeyCode::BrowserRefresh,
-            winit::keyboard::KeyCode::BrowserSearch => KeyCode::BrowserSearch,
-            winit::keyboard::KeyCode::BrowserStop => KeyCode::BrowserStop,
-            winit::keyboard::KeyCode::Eject => KeyCode::Eject,
-            winit::keyboard::KeyCode::LaunchApp1 => KeyCode::LaunchApp1,
-            winit::keyboard::KeyCode::LaunchApp2 => KeyCode::LaunchApp2,
-            winit::keyboard::KeyCode::LaunchMail => KeyCode::LaunchMail,
-            winit::keyboard::KeyCode::MediaPlayPause => KeyCode::MediaPlayPause,
-            winit::keyboard::KeyCode::MediaSelect => KeyCode::MediaSelect,
-            winit::keyboard::KeyCode::MediaStop => KeyCode::MediaStop,
-            winit::keyboard::KeyCode::MediaTrackNext => KeyCode::MediaTrackNext,
-            winit::keyboard::KeyCode::MediaTrackPrevious => KeyCode::MediaTrackPrevious,
-            winit::keyboard::KeyCode::Power => KeyCode::Power,
-            winit::keyboard::KeyCode::Sleep => KeyCode::Sleep,
-            winit::keyboard::KeyCode::AudioVolumeDown => KeyCode::AudioVolumeDown,
-            winit::keyboard::KeyCode::AudioVolumeMute => KeyCode::AudioVolumeMute,
-            winit::keyboard::KeyCode::AudioVolumeUp => KeyCode::AudioVolumeUp,
-            winit::keyboard::KeyCode::WakeUp => KeyCode::WakeUp,
-            winit::keyboard::KeyCode::Meta => KeyCode::Meta,
-            winit::keyboard::KeyCode::Hyper => KeyCode::Hyper,
-            winit::keyboard::KeyCode::Turbo => KeyCode::Turbo,
-            winit::keyboard::KeyCode::Abort => KeyCode::Abort,
-            winit::keyboard::KeyCode::Resume => KeyCode::Resume,
-            winit::keyboard::KeyCode::Suspend => KeyCode::Suspend,
-            winit::keyboard::KeyCode::Again => KeyCode::Again,
-            winit::keyboard::KeyCode::Copy => KeyCode::Copy,
-            winit::keyboard::KeyCode::Cut => KeyCode::Cut,
-            winit::keyboard::KeyCode::Find => KeyCode::Find,
-            winit::keyboard::KeyCode::Open => KeyCode::Open,
-            winit::keyboard::KeyCode::Paste => KeyCode::Paste,
-            winit::keyboard::KeyCode::Props => KeyCode::Props,
-            winit::keyboard::KeyCode::Select => KeyCode::Select,
-            winit::keyboard::KeyCode::Undo => KeyCode::Undo,
-            winit::keyboard::KeyCode::Hiragana => KeyCode::Hiragana,
-            winit::keyboard::KeyCode::Katakana => KeyCode::Katakana,
-            winit::keyboard::KeyCode::F1 => KeyCode::F1,
-            winit::keyboard::KeyCode::F2 => KeyCode::F2,
-            winit::keyboard::KeyCode::F3 => KeyCode::F3,
-            winit::keyboard::KeyCode::F4 => KeyCode::F4,
-            winit::keyboard::KeyCode::F5 => KeyCode::F5,
-            winit::keyboard::KeyCode::F6 => KeyCode::F6,
-            winit::keyboard::KeyCode::F7 => KeyCode::F7,
-            winit::keyboard::KeyCode::F8 => KeyCode::F8,
-            winit::keyboard::KeyCode::F9 => KeyCode::F9,
-            winit::keyboard::KeyCode::F10 => KeyCode::F10,
-            winit::keyboard::KeyCode::F11 => KeyCode::F11,
-            winit::keyboard::KeyCode::F12 => KeyCode::F12,
-            winit::keyboard::KeyCode::F13 => KeyCode::F13,
-            winit::keyboard::KeyCode::F14 => KeyCode::F14,
-            winit::keyboard::KeyCode::F15 => KeyCode::F15,
-            winit::keyboard::KeyCode::F16 => KeyCode::F16,
-            winit::keyboard::KeyCode::F17 => KeyCode::F17,
-            winit::keyboard::KeyCode::F18 => KeyCode::F18,
-            winit::keyboard::KeyCode::F19 => KeyCode::F19,
-            winit::keyboard::KeyCode::F20 => KeyCode::F20,
-            winit::keyboard::KeyCode::F21 => KeyCode::F21,
-            winit::keyboard::KeyCode::F22 => KeyCode::F22,
-            winit::keyboard::KeyCode::F23 => KeyCode::F23,
-            winit::keyboard::KeyCode::F24 => KeyCode::F24,
-            winit::keyboard::KeyCode::F25 => KeyCode::F25,
-            winit::keyboard::KeyCode::F26 => KeyCode::F26,
-            winit::keyboard::KeyCode::F27 => KeyCode::F27,
-            winit::keyboard::KeyCode::F28 => KeyCode::F28,
-            winit::keyboard::KeyCode::F29 => KeyCode::F29,
-            winit::keyboard::KeyCode::F30 => KeyCode::F30,
-            winit::keyboard::KeyCode::F31 => KeyCode::F31,
-            winit::keyboard::KeyCode::F32 => KeyCode::F32,
-            winit::keyboard::KeyCode::F33 => KeyCode::F33,
-            winit::keyboard::KeyCode::F34 => KeyCode::F34,
-            winit::keyboard::KeyCode::F35 => KeyCode::F35,
-            _ => KeyCode::Unidentified(NativeKeyCode::Unidentified),
+            winit::keyboard::KeyCode::Backquote => PhysicalKeyCode::Backquote,
+            winit::keyboard::KeyCode::Backslash => PhysicalKeyCode::Backslash,
+            winit::keyboard::KeyCode::BracketLeft => PhysicalKeyCode::BracketLeft,
+            winit::keyboard::KeyCode::BracketRight => PhysicalKeyCode::BracketRight,
+            winit::keyboard::KeyCode::Comma => PhysicalKeyCode::Comma,
+            winit::keyboard::KeyCode::Digit0 => PhysicalKeyCode::Digit0,
+            winit::keyboard::KeyCode::Digit1 => PhysicalKeyCode::Digit1,
+            winit::keyboard::KeyCode::Digit2 => PhysicalKeyCode::Digit2,
+            winit::keyboard::KeyCode::Digit3 => PhysicalKeyCode::Digit3,
+            winit::keyboard::KeyCode::Digit4 => PhysicalKeyCode::Digit4,
+            winit::keyboard::KeyCode::Digit5 => PhysicalKeyCode::Digit5,
+            winit::keyboard::KeyCode::Digit6 => PhysicalKeyCode::Digit6,
+            winit::keyboard::KeyCode::Digit7 => PhysicalKeyCode::Digit7,
+            winit::keyboard::KeyCode::Digit8 => PhysicalKeyCode::Digit8,
+            winit::keyboard::KeyCode::Digit9 => PhysicalKeyCode::Digit9,
+            winit::keyboard::KeyCode::Equal => PhysicalKeyCode::Equal,
+            winit::keyboard::KeyCode::IntlBackslash => PhysicalKeyCode::IntlBackslash,
+            winit::keyboard::KeyCode::IntlRo => PhysicalKeyCode::IntlRo,
+            winit::keyboard::KeyCode::IntlYen => PhysicalKeyCode::IntlYen,
+            winit::keyboard::KeyCode::KeyA => PhysicalKeyCode::KeyA,
+            winit::keyboard::KeyCode::KeyB => PhysicalKeyCode::KeyB,
+            winit::keyboard::KeyCode::KeyC => PhysicalKeyCode::KeyC,
+            winit::keyboard::KeyCode::KeyD => PhysicalKeyCode::KeyD,
+            winit::keyboard::KeyCode::KeyE => PhysicalKeyCode::KeyE,
+            winit::keyboard::KeyCode::KeyF => PhysicalKeyCode::KeyF,
+            winit::keyboard::KeyCode::KeyG => PhysicalKeyCode::KeyG,
+            winit::keyboard::KeyCode::KeyH => PhysicalKeyCode::KeyH,
+            winit::keyboard::KeyCode::KeyI => PhysicalKeyCode::KeyI,
+            winit::keyboard::KeyCode::KeyJ => PhysicalKeyCode::KeyJ,
+            winit::keyboard::KeyCode::KeyK => PhysicalKeyCode::KeyK,
+            winit::keyboard::KeyCode::KeyL => PhysicalKeyCode::KeyL,
+            winit::keyboard::KeyCode::KeyM => PhysicalKeyCode::KeyM,
+            winit::keyboard::KeyCode::KeyN => PhysicalKeyCode::KeyN,
+            winit::keyboard::KeyCode::KeyO => PhysicalKeyCode::KeyO,
+            winit::keyboard::KeyCode::KeyP => PhysicalKeyCode::KeyP,
+            winit::keyboard::KeyCode::KeyQ => PhysicalKeyCode::KeyQ,
+            winit::keyboard::KeyCode::KeyR => PhysicalKeyCode::KeyR,
+            winit::keyboard::KeyCode::KeyS => PhysicalKeyCode::KeyS,
+            winit::keyboard::KeyCode::KeyT => PhysicalKeyCode::KeyT,
+            winit::keyboard::KeyCode::KeyU => PhysicalKeyCode::KeyU,
+            winit::keyboard::KeyCode::KeyV => PhysicalKeyCode::KeyV,
+            winit::keyboard::KeyCode::KeyW => PhysicalKeyCode::KeyW,
+            winit::keyboard::KeyCode::KeyX => PhysicalKeyCode::KeyX,
+            winit::keyboard::KeyCode::KeyY => PhysicalKeyCode::KeyY,
+            winit::keyboard::KeyCode::KeyZ => PhysicalKeyCode::KeyZ,
+            winit::keyboard::KeyCode::Minus => PhysicalKeyCode::Minus,
+            winit::keyboard::KeyCode::Period => PhysicalKeyCode::Period,
+            winit::keyboard::KeyCode::Quote => PhysicalKeyCode::Quote,
+            winit::keyboard::KeyCode::Semicolon => PhysicalKeyCode::Semicolon,
+            winit::keyboard::KeyCode::Slash => PhysicalKeyCode::Slash,
+            winit::keyboard::KeyCode::AltLeft => PhysicalKeyCode::AltLeft,
+            winit::keyboard::KeyCode::AltRight => PhysicalKeyCode::AltRight,
+            winit::keyboard::KeyCode::Backspace => PhysicalKeyCode::Backspace,
+            winit::keyboard::KeyCode::CapsLock => PhysicalKeyCode::CapsLock,
+            winit::keyboard::KeyCode::ContextMenu => PhysicalKeyCode::ContextMenu,
+            winit::keyboard::KeyCode::ControlLeft => PhysicalKeyCode::ControlLeft,
+            winit::keyboard::KeyCode::ControlRight => PhysicalKeyCode::ControlRight,
+            winit::keyboard::KeyCode::Enter => PhysicalKeyCode::Enter,
+            winit::keyboard::KeyCode::SuperLeft => PhysicalKeyCode::SuperLeft,
+            winit::keyboard::KeyCode::SuperRight => PhysicalKeyCode::SuperRight,
+            winit::keyboard::KeyCode::ShiftLeft => PhysicalKeyCode::ShiftLeft,
+            winit::keyboard::KeyCode::ShiftRight => PhysicalKeyCode::ShiftRight,
+            winit::keyboard::KeyCode::Space => PhysicalKeyCode::Space,
+            winit::keyboard::KeyCode::Tab => PhysicalKeyCode::Tab,
+            winit::keyboard::KeyCode::Convert => PhysicalKeyCode::Convert,
+            winit::keyboard::KeyCode::KanaMode => PhysicalKeyCode::KanaMode,
+            winit::keyboard::KeyCode::Lang1 => PhysicalKeyCode::Lang1,
+            winit::keyboard::KeyCode::Lang2 => PhysicalKeyCode::Lang2,
+            winit::keyboard::KeyCode::Lang3 => PhysicalKeyCode::Lang3,
+            winit::keyboard::KeyCode::Lang4 => PhysicalKeyCode::Lang4,
+            winit::keyboard::KeyCode::Lang5 => PhysicalKeyCode::Lang5,
+            winit::keyboard::KeyCode::NonConvert => PhysicalKeyCode::NonConvert,
+            winit::keyboard::KeyCode::Delete => PhysicalKeyCode::Delete,
+            winit::keyboard::KeyCode::End => PhysicalKeyCode::End,
+            winit::keyboard::KeyCode::Help => PhysicalKeyCode::Help,
+            winit::keyboard::KeyCode::Home => PhysicalKeyCode::Home,
+            winit::keyboard::KeyCode::Insert => PhysicalKeyCode::Insert,
+            winit::keyboard::KeyCode::PageDown => PhysicalKeyCode::PageDown,
+            winit::keyboard::KeyCode::PageUp => PhysicalKeyCode::PageUp,
+            winit::keyboard::KeyCode::ArrowDown => PhysicalKeyCode::ArrowDown,
+            winit::keyboard::KeyCode::ArrowLeft => PhysicalKeyCode::ArrowLeft,
+            winit::keyboard::KeyCode::ArrowRight => PhysicalKeyCode::ArrowRight,
+            winit::keyboard::KeyCode::ArrowUp => PhysicalKeyCode::ArrowUp,
+            winit::keyboard::KeyCode::NumLock => PhysicalKeyCode::NumLock,
+            winit::keyboard::KeyCode::Numpad0 => PhysicalKeyCode::Numpad0,
+            winit::keyboard::KeyCode::Numpad1 => PhysicalKeyCode::Numpad1,
+            winit::keyboard::KeyCode::Numpad2 => PhysicalKeyCode::Numpad2,
+            winit::keyboard::KeyCode::Numpad3 => PhysicalKeyCode::Numpad3,
+            winit::keyboard::KeyCode::Numpad4 => PhysicalKeyCode::Numpad4,
+            winit::keyboard::KeyCode::Numpad5 => PhysicalKeyCode::Numpad5,
+            winit::keyboard::KeyCode::Numpad6 => PhysicalKeyCode::Numpad6,
+            winit::keyboard::KeyCode::Numpad7 => PhysicalKeyCode::Numpad7,
+            winit::keyboard::KeyCode::Numpad8 => PhysicalKeyCode::Numpad8,
+            winit::keyboard::KeyCode::Numpad9 => PhysicalKeyCode::Numpad9,
+            winit::keyboard::KeyCode::NumpadAdd => PhysicalKeyCode::NumpadAdd,
+            winit::keyboard::KeyCode::NumpadBackspace => PhysicalKeyCode::NumpadBackspace,
+            winit::keyboard::KeyCode::NumpadClear => PhysicalKeyCode::NumpadClear,
+            winit::keyboard::KeyCode::NumpadClearEntry => PhysicalKeyCode::NumpadClearEntry,
+            winit::keyboard::KeyCode::NumpadComma => PhysicalKeyCode::NumpadComma,
+            winit::keyboard::KeyCode::NumpadDecimal => PhysicalKeyCode::NumpadDecimal,
+            winit::keyboard::KeyCode::NumpadDivide => PhysicalKeyCode::NumpadDivide,
+            winit::keyboard::KeyCode::NumpadEnter => PhysicalKeyCode::NumpadEnter,
+            winit::keyboard::KeyCode::NumpadEqual => PhysicalKeyCode::NumpadEqual,
+            winit::keyboard::KeyCode::NumpadHash => PhysicalKeyCode::NumpadHash,
+            winit::keyboard::KeyCode::NumpadMemoryAdd => PhysicalKeyCode::NumpadMemoryAdd,
+            winit::keyboard::KeyCode::NumpadMemoryClear => PhysicalKeyCode::NumpadMemoryClear,
+            winit::keyboard::KeyCode::NumpadMemoryRecall => PhysicalKeyCode::NumpadMemoryRecall,
+            winit::keyboard::KeyCode::NumpadMemoryStore => PhysicalKeyCode::NumpadMemoryStore,
+            winit::keyboard::KeyCode::NumpadMemorySubtract => PhysicalKeyCode::NumpadMemorySubtract,
+            winit::keyboard::KeyCode::NumpadMultiply => PhysicalKeyCode::NumpadMultiply,
+            winit::keyboard::KeyCode::NumpadParenLeft => PhysicalKeyCode::NumpadParenLeft,
+            winit::keyboard::KeyCode::NumpadParenRight => PhysicalKeyCode::NumpadParenRight,
+            winit::keyboard::KeyCode::NumpadStar => PhysicalKeyCode::NumpadStar,
+            winit::keyboard::KeyCode::NumpadSubtract => PhysicalKeyCode::NumpadSubtract,
+            winit::keyboard::KeyCode::Escape => PhysicalKeyCode::Escape,
+            winit::keyboard::KeyCode::Fn => PhysicalKeyCode::Fn,
+            winit::keyboard::KeyCode::FnLock => PhysicalKeyCode::FnLock,
+            winit::keyboard::KeyCode::PrintScreen => PhysicalKeyCode::PrintScreen,
+            winit::keyboard::KeyCode::ScrollLock => PhysicalKeyCode::ScrollLock,
+            winit::keyboard::KeyCode::Pause => PhysicalKeyCode::Pause,
+            winit::keyboard::KeyCode::BrowserBack => PhysicalKeyCode::BrowserBack,
+            winit::keyboard::KeyCode::BrowserFavorites => PhysicalKeyCode::BrowserFavorites,
+            winit::keyboard::KeyCode::BrowserForward => PhysicalKeyCode::BrowserForward,
+            winit::keyboard::KeyCode::BrowserHome => PhysicalKeyCode::BrowserHome,
+            winit::keyboard::KeyCode::BrowserRefresh => PhysicalKeyCode::BrowserRefresh,
+            winit::keyboard::KeyCode::BrowserSearch => PhysicalKeyCode::BrowserSearch,
+            winit::keyboard::KeyCode::BrowserStop => PhysicalKeyCode::BrowserStop,
+            winit::keyboard::KeyCode::Eject => PhysicalKeyCode::Eject,
+            winit::keyboard::KeyCode::LaunchApp1 => PhysicalKeyCode::LaunchApp1,
+            winit::keyboard::KeyCode::LaunchApp2 => PhysicalKeyCode::LaunchApp2,
+            winit::keyboard::KeyCode::LaunchMail => PhysicalKeyCode::LaunchMail,
+            winit::keyboard::KeyCode::MediaPlayPause => PhysicalKeyCode::MediaPlayPause,
+            winit::keyboard::KeyCode::MediaSelect => PhysicalKeyCode::MediaSelect,
+            winit::keyboard::KeyCode::MediaStop => PhysicalKeyCode::MediaStop,
+            winit::keyboard::KeyCode::MediaTrackNext => PhysicalKeyCode::MediaTrackNext,
+            winit::keyboard::KeyCode::MediaTrackPrevious => PhysicalKeyCode::MediaTrackPrevious,
+            winit::keyboard::KeyCode::Power => PhysicalKeyCode::Power,
+            winit::keyboard::KeyCode::Sleep => PhysicalKeyCode::Sleep,
+            winit::keyboard::KeyCode::AudioVolumeDown => PhysicalKeyCode::AudioVolumeDown,
+            winit::keyboard::KeyCode::AudioVolumeMute => PhysicalKeyCode::AudioVolumeMute,
+            winit::keyboard::KeyCode::AudioVolumeUp => PhysicalKeyCode::AudioVolumeUp,
+            winit::keyboard::KeyCode::WakeUp => PhysicalKeyCode::WakeUp,
+            winit::keyboard::KeyCode::Meta => PhysicalKeyCode::Meta,
+            winit::keyboard::KeyCode::Hyper => PhysicalKeyCode::Hyper,
+            winit::keyboard::KeyCode::Turbo => PhysicalKeyCode::Turbo,
+            winit::keyboard::KeyCode::Abort => PhysicalKeyCode::Abort,
+            winit::keyboard::KeyCode::Resume => PhysicalKeyCode::Resume,
+            winit::keyboard::KeyCode::Suspend => PhysicalKeyCode::Suspend,
+            winit::keyboard::KeyCode::Again => PhysicalKeyCode::Again,
+            winit::keyboard::KeyCode::Copy => PhysicalKeyCode::Copy,
+            winit::keyboard::KeyCode::Cut => PhysicalKeyCode::Cut,
+            winit::keyboard::KeyCode::Find => PhysicalKeyCode::Find,
+            winit::keyboard::KeyCode::Open => PhysicalKeyCode::Open,
+            winit::keyboard::KeyCode::Paste => PhysicalKeyCode::Paste,
+            winit::keyboard::KeyCode::Props => PhysicalKeyCode::Props,
+            winit::keyboard::KeyCode::Select => PhysicalKeyCode::Select,
+            winit::keyboard::KeyCode::Undo => PhysicalKeyCode::Undo,
+            winit::keyboard::KeyCode::Hiragana => PhysicalKeyCode::Hiragana,
+            winit::keyboard::KeyCode::Katakana => PhysicalKeyCode::Katakana,
+            winit::keyboard::KeyCode::F1 => PhysicalKeyCode::F1,
+            winit::keyboard::KeyCode::F2 => PhysicalKeyCode::F2,
+            winit::keyboard::KeyCode::F3 => PhysicalKeyCode::F3,
+            winit::keyboard::KeyCode::F4 => PhysicalKeyCode::F4,
+            winit::keyboard::KeyCode::F5 => PhysicalKeyCode::F5,
+            winit::keyboard::KeyCode::F6 => PhysicalKeyCode::F6,
+            winit::keyboard::KeyCode::F7 => PhysicalKeyCode::F7,
+            winit::keyboard::KeyCode::F8 => PhysicalKeyCode::F8,
+            winit::keyboard::KeyCode::F9 => PhysicalKeyCode::F9,
+            winit::keyboard::KeyCode::F10 => PhysicalKeyCode::F10,
+            winit::keyboard::KeyCode::F11 => PhysicalKeyCode::F11,
+            winit::keyboard::KeyCode::F12 => PhysicalKeyCode::F12,
+            winit::keyboard::KeyCode::F13 => PhysicalKeyCode::F13,
+            winit::keyboard::KeyCode::F14 => PhysicalKeyCode::F14,
+            winit::keyboard::KeyCode::F15 => PhysicalKeyCode::F15,
+            winit::keyboard::KeyCode::F16 => PhysicalKeyCode::F16,
+            winit::keyboard::KeyCode::F17 => PhysicalKeyCode::F17,
+            winit::keyboard::KeyCode::F18 => PhysicalKeyCode::F18,
+            winit::keyboard::KeyCode::F19 => PhysicalKeyCode::F19,
+            winit::keyboard::KeyCode::F20 => PhysicalKeyCode::F20,
+            winit::keyboard::KeyCode::F21 => PhysicalKeyCode::F21,
+            winit::keyboard::KeyCode::F22 => PhysicalKeyCode::F22,
+            winit::keyboard::KeyCode::F23 => PhysicalKeyCode::F23,
+            winit::keyboard::KeyCode::F24 => PhysicalKeyCode::F24,
+            winit::keyboard::KeyCode::F25 => PhysicalKeyCode::F25,
+            winit::keyboard::KeyCode::F26 => PhysicalKeyCode::F26,
+            winit::keyboard::KeyCode::F27 => PhysicalKeyCode::F27,
+            winit::keyboard::KeyCode::F28 => PhysicalKeyCode::F28,
+            winit::keyboard::KeyCode::F29 => PhysicalKeyCode::F29,
+            winit::keyboard::KeyCode::F30 => PhysicalKeyCode::F30,
+            winit::keyboard::KeyCode::F31 => PhysicalKeyCode::F31,
+            winit::keyboard::KeyCode::F32 => PhysicalKeyCode::F32,
+            winit::keyboard::KeyCode::F33 => PhysicalKeyCode::F33,
+            winit::keyboard::KeyCode::F34 => PhysicalKeyCode::F34,
+            winit::keyboard::KeyCode::F35 => PhysicalKeyCode::F35,
+            _ => PhysicalKeyCode::Unidentified(NativeKeyCode::Unidentified),
         },
     }
 }
diff --git a/examples/2d/2d_gizmos.rs b/examples/2d/2d_gizmos.rs
index 1e7129f51949f7..2674a4b7971573 100644
--- a/examples/2d/2d_gizmos.rs
+++ b/examples/2d/2d_gizmos.rs
@@ -218,45 +218,45 @@ fn draw_primitives(
 
 fn update_config(
     mut config_store: ResMut<GizmoConfigStore>,
-    keyboard: Res<ButtonInput<KeyCode>>,
+    keyboard: Res<ButtonInput<PhysicalKeyCode>>,
     time: Res<Time>,
 ) {
     let (config, _) = config_store.config_mut::<DefaultGizmoConfigGroup>();
-    if keyboard.pressed(KeyCode::ArrowRight) {
+    if keyboard.pressed(PhysicalKeyCode::ArrowRight) {
         config.line_width += 5. * time.delta_seconds();
         config.line_width = config.line_width.clamp(0., 50.);
     }
-    if keyboard.pressed(KeyCode::ArrowLeft) {
+    if keyboard.pressed(PhysicalKeyCode::ArrowLeft) {
         config.line_width -= 5. * time.delta_seconds();
         config.line_width = config.line_width.clamp(0., 50.);
     }
-    if keyboard.just_pressed(KeyCode::Digit1) {
+    if keyboard.just_pressed(PhysicalKeyCode::Digit1) {
         config.enabled ^= true;
     }
 
     let (my_config, _) = config_store.config_mut::<MyRoundGizmos>();
-    if keyboard.pressed(KeyCode::ArrowUp) {
+    if keyboard.pressed(PhysicalKeyCode::ArrowUp) {
         my_config.line_width += 5. * time.delta_seconds();
         my_config.line_width = my_config.line_width.clamp(0., 50.);
     }
-    if keyboard.pressed(KeyCode::ArrowDown) {
+    if keyboard.pressed(PhysicalKeyCode::ArrowDown) {
         my_config.line_width -= 5. * time.delta_seconds();
         my_config.line_width = my_config.line_width.clamp(0., 50.);
     }
-    if keyboard.just_pressed(KeyCode::Digit2) {
+    if keyboard.just_pressed(PhysicalKeyCode::Digit2) {
         my_config.enabled ^= true;
     }
 }
 
 fn update_primitives(
-    keyboard: Res<ButtonInput<KeyCode>>,
+    keyboard: Res<ButtonInput<PhysicalKeyCode>>,
     mut next_primitive_state: ResMut<NextState<PrimitiveState>>,
     primitive_state: Res<State<PrimitiveState>>,
 ) {
-    if keyboard.just_pressed(KeyCode::KeyJ) {
+    if keyboard.just_pressed(PhysicalKeyCode::KeyJ) {
         next_primitive_state.set(primitive_state.get().last());
     }
-    if keyboard.just_pressed(KeyCode::KeyK) {
+    if keyboard.just_pressed(PhysicalKeyCode::KeyK) {
         next_primitive_state.set(primitive_state.get().next());
     }
 }
diff --git a/examples/2d/bloom_2d.rs b/examples/2d/bloom_2d.rs
index de1292efdd8547..43e48d6f52067e 100644
--- a/examples/2d/bloom_2d.rs
+++ b/examples/2d/bloom_2d.rs
@@ -89,7 +89,7 @@ fn update_bloom_settings(
     mut camera: Query<(Entity, Option<&mut BloomSettings>), With<Camera>>,
     mut text: Query<&mut Text>,
     mut commands: Commands,
-    keycode: Res<ButtonInput<KeyCode>>,
+    keycode: Res<ButtonInput<PhysicalKeyCode>>,
     time: Res<Time>,
 ) {
     let bloom_settings = camera.single_mut();
@@ -128,65 +128,65 @@ fn update_bloom_settings(
                 bloom_settings.prefilter_settings.threshold_softness
             ));
 
-            if keycode.just_pressed(KeyCode::Space) {
+            if keycode.just_pressed(PhysicalKeyCode::Space) {
                 commands.entity(entity).remove::<BloomSettings>();
             }
 
             let dt = time.delta_seconds();
 
-            if keycode.pressed(KeyCode::KeyA) {
+            if keycode.pressed(PhysicalKeyCode::KeyA) {
                 bloom_settings.intensity -= dt / 10.0;
             }
-            if keycode.pressed(KeyCode::KeyQ) {
+            if keycode.pressed(PhysicalKeyCode::KeyQ) {
                 bloom_settings.intensity += dt / 10.0;
             }
             bloom_settings.intensity = bloom_settings.intensity.clamp(0.0, 1.0);
 
-            if keycode.pressed(KeyCode::KeyS) {
+            if keycode.pressed(PhysicalKeyCode::KeyS) {
                 bloom_settings.low_frequency_boost -= dt / 10.0;
             }
-            if keycode.pressed(KeyCode::KeyW) {
+            if keycode.pressed(PhysicalKeyCode::KeyW) {
                 bloom_settings.low_frequency_boost += dt / 10.0;
             }
             bloom_settings.low_frequency_boost = bloom_settings.low_frequency_boost.clamp(0.0, 1.0);
 
-            if keycode.pressed(KeyCode::KeyD) {
+            if keycode.pressed(PhysicalKeyCode::KeyD) {
                 bloom_settings.low_frequency_boost_curvature -= dt / 10.0;
             }
-            if keycode.pressed(KeyCode::KeyE) {
+            if keycode.pressed(PhysicalKeyCode::KeyE) {
                 bloom_settings.low_frequency_boost_curvature += dt / 10.0;
             }
             bloom_settings.low_frequency_boost_curvature =
                 bloom_settings.low_frequency_boost_curvature.clamp(0.0, 1.0);
 
-            if keycode.pressed(KeyCode::KeyF) {
+            if keycode.pressed(PhysicalKeyCode::KeyF) {
                 bloom_settings.high_pass_frequency -= dt / 10.0;
             }
-            if keycode.pressed(KeyCode::KeyR) {
+            if keycode.pressed(PhysicalKeyCode::KeyR) {
                 bloom_settings.high_pass_frequency += dt / 10.0;
             }
             bloom_settings.high_pass_frequency = bloom_settings.high_pass_frequency.clamp(0.0, 1.0);
 
-            if keycode.pressed(KeyCode::KeyG) {
+            if keycode.pressed(PhysicalKeyCode::KeyG) {
                 bloom_settings.composite_mode = BloomCompositeMode::Additive;
             }
-            if keycode.pressed(KeyCode::KeyT) {
+            if keycode.pressed(PhysicalKeyCode::KeyT) {
                 bloom_settings.composite_mode = BloomCompositeMode::EnergyConserving;
             }
 
-            if keycode.pressed(KeyCode::KeyH) {
+            if keycode.pressed(PhysicalKeyCode::KeyH) {
                 bloom_settings.prefilter_settings.threshold -= dt;
             }
-            if keycode.pressed(KeyCode::KeyY) {
+            if keycode.pressed(PhysicalKeyCode::KeyY) {
                 bloom_settings.prefilter_settings.threshold += dt;
             }
             bloom_settings.prefilter_settings.threshold =
                 bloom_settings.prefilter_settings.threshold.max(0.0);
 
-            if keycode.pressed(KeyCode::KeyJ) {
+            if keycode.pressed(PhysicalKeyCode::KeyJ) {
                 bloom_settings.prefilter_settings.threshold_softness -= dt / 10.0;
             }
-            if keycode.pressed(KeyCode::KeyU) {
+            if keycode.pressed(PhysicalKeyCode::KeyU) {
                 bloom_settings.prefilter_settings.threshold_softness += dt / 10.0;
             }
             bloom_settings.prefilter_settings.threshold_softness = bloom_settings
@@ -198,7 +198,7 @@ fn update_bloom_settings(
         (entity, None) => {
             *text = "Bloom: Off (Toggle: Space)".to_string();
 
-            if keycode.just_pressed(KeyCode::Space) {
+            if keycode.just_pressed(PhysicalKeyCode::Space) {
                 commands.entity(entity).insert(BloomSettings::default());
             }
         }
diff --git a/examples/2d/bounding_2d.rs b/examples/2d/bounding_2d.rs
index ff121d7d8c2585..91894d49bf980e 100644
--- a/examples/2d/bounding_2d.rs
+++ b/examples/2d/bounding_2d.rs
@@ -49,11 +49,11 @@ enum Test {
 }
 
 fn update_test_state(
-    keycode: Res<ButtonInput<KeyCode>>,
+    keycode: Res<ButtonInput<PhysicalKeyCode>>,
     cur_state: Res<State<Test>>,
     mut state: ResMut<NextState<Test>>,
 ) {
-    if !keycode.just_pressed(KeyCode::Space) {
+    if !keycode.just_pressed(PhysicalKeyCode::Space) {
         return;
     }
 
diff --git a/examples/2d/rotation.rs b/examples/2d/rotation.rs
index 75e80548c7c750..68bed06d453259 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<ButtonInput<KeyCode>>,
+    keyboard_input: Res<ButtonInput<PhysicalKeyCode>>,
     mut query: Query<(&Player, &mut Transform)>,
 ) {
     let (ship, mut transform) = query.single_mut();
@@ -125,15 +125,15 @@ fn player_movement_system(
     let mut rotation_factor = 0.0;
     let mut movement_factor = 0.0;
 
-    if keyboard_input.pressed(KeyCode::ArrowLeft) {
+    if keyboard_input.pressed(PhysicalKeyCode::ArrowLeft) {
         rotation_factor += 1.0;
     }
 
-    if keyboard_input.pressed(KeyCode::ArrowRight) {
+    if keyboard_input.pressed(PhysicalKeyCode::ArrowRight) {
         rotation_factor -= 1.0;
     }
 
-    if keyboard_input.pressed(KeyCode::ArrowUp) {
+    if keyboard_input.pressed(PhysicalKeyCode::ArrowUp) {
         movement_factor += 1.0;
     }
 
diff --git a/examples/3d/3d_gizmos.rs b/examples/3d/3d_gizmos.rs
index c54c20c2617585..aec0c6c38264d6 100644
--- a/examples/3d/3d_gizmos.rs
+++ b/examples/3d/3d_gizmos.rs
@@ -334,15 +334,15 @@ fn draw_primitives(
 
 fn update_config(
     mut config_store: ResMut<GizmoConfigStore>,
-    keyboard: Res<ButtonInput<KeyCode>>,
+    keyboard: Res<ButtonInput<PhysicalKeyCode>>,
     time: Res<Time>,
 ) {
-    if keyboard.just_pressed(KeyCode::KeyD) {
+    if keyboard.just_pressed(PhysicalKeyCode::KeyD) {
         for (_, config, _) in config_store.iter_mut() {
             config.depth_bias = if config.depth_bias == 0. { -1. } else { 0. };
         }
     }
-    if keyboard.just_pressed(KeyCode::KeyP) {
+    if keyboard.just_pressed(PhysicalKeyCode::KeyP) {
         for (_, config, _) in config_store.iter_mut() {
             // Toggle line_perspective
             config.line_perspective ^= true;
@@ -352,32 +352,32 @@ fn update_config(
     }
 
     let (config, _) = config_store.config_mut::<DefaultGizmoConfigGroup>();
-    if keyboard.pressed(KeyCode::ArrowRight) {
+    if keyboard.pressed(PhysicalKeyCode::ArrowRight) {
         config.line_width += 5. * time.delta_seconds();
         config.line_width = config.line_width.clamp(0., 50.);
     }
-    if keyboard.pressed(KeyCode::ArrowLeft) {
+    if keyboard.pressed(PhysicalKeyCode::ArrowLeft) {
         config.line_width -= 5. * time.delta_seconds();
         config.line_width = config.line_width.clamp(0., 50.);
     }
-    if keyboard.just_pressed(KeyCode::Digit1) {
+    if keyboard.just_pressed(PhysicalKeyCode::Digit1) {
         config.enabled ^= true;
     }
 
     let (my_config, _) = config_store.config_mut::<MyRoundGizmos>();
-    if keyboard.pressed(KeyCode::ArrowUp) {
+    if keyboard.pressed(PhysicalKeyCode::ArrowUp) {
         my_config.line_width += 5. * time.delta_seconds();
         my_config.line_width = my_config.line_width.clamp(0., 50.);
     }
-    if keyboard.pressed(KeyCode::ArrowDown) {
+    if keyboard.pressed(PhysicalKeyCode::ArrowDown) {
         my_config.line_width -= 5. * time.delta_seconds();
         my_config.line_width = my_config.line_width.clamp(0., 50.);
     }
-    if keyboard.just_pressed(KeyCode::Digit2) {
+    if keyboard.just_pressed(PhysicalKeyCode::Digit2) {
         my_config.enabled ^= true;
     }
 
-    if keyboard.just_pressed(KeyCode::KeyA) {
+    if keyboard.just_pressed(PhysicalKeyCode::KeyA) {
         // AABB gizmos are normally only drawn on entities with a ShowAabbGizmo component
         // We can change this behaviour in the configuration of AabbGizmoGroup
         config_store.config_mut::<AabbGizmoConfigGroup>().1.draw_all ^= true;
@@ -385,23 +385,23 @@ fn update_config(
 }
 
 fn update_primitives(
-    keyboard: Res<ButtonInput<KeyCode>>,
+    keyboard: Res<ButtonInput<PhysicalKeyCode>>,
     primitive_state: Res<State<PrimitiveState>>,
     mut next_primitive_state: ResMut<NextState<PrimitiveState>>,
     mut segments: ResMut<PrimitiveSegments>,
     mut segments_f: Local<f32>,
 ) {
-    if keyboard.just_pressed(KeyCode::KeyK) {
+    if keyboard.just_pressed(PhysicalKeyCode::KeyK) {
         next_primitive_state.set(primitive_state.get().next());
     }
-    if keyboard.just_pressed(KeyCode::KeyJ) {
+    if keyboard.just_pressed(PhysicalKeyCode::KeyJ) {
         next_primitive_state.set(primitive_state.get().last());
     }
-    if keyboard.pressed(KeyCode::KeyL) {
+    if keyboard.pressed(PhysicalKeyCode::KeyL) {
         *segments_f = (*segments_f + 0.05).max(2.0);
         segments.0 = segments_f.floor() as usize;
     }
-    if keyboard.pressed(KeyCode::KeyH) {
+    if keyboard.pressed(PhysicalKeyCode::KeyH) {
         *segments_f = (*segments_f - 0.05).max(2.0);
         segments.0 = segments_f.floor() as usize;
     }
diff --git a/examples/3d/anti_aliasing.rs b/examples/3d/anti_aliasing.rs
index aadaa256ac36a0..18f07263a85ca7 100644
--- a/examples/3d/anti_aliasing.rs
+++ b/examples/3d/anti_aliasing.rs
@@ -29,7 +29,7 @@ fn main() {
 }
 
 fn modify_aa(
-    keys: Res<ButtonInput<KeyCode>>,
+    keys: Res<ButtonInput<PhysicalKeyCode>>,
     mut camera: Query<
         (
             Entity,
@@ -45,14 +45,14 @@ fn modify_aa(
     let mut camera = commands.entity(camera_entity);
 
     // No AA
-    if keys.just_pressed(KeyCode::Digit1) {
+    if keys.just_pressed(PhysicalKeyCode::Digit1) {
         *msaa = Msaa::Off;
         camera.remove::<Fxaa>();
         camera.remove::<TemporalAntiAliasBundle>();
     }
 
     // MSAA
-    if keys.just_pressed(KeyCode::Digit2) && *msaa == Msaa::Off {
+    if keys.just_pressed(PhysicalKeyCode::Digit2) && *msaa == Msaa::Off {
         camera.remove::<Fxaa>();
         camera.remove::<TemporalAntiAliasBundle>();
 
@@ -61,19 +61,19 @@ fn modify_aa(
 
     // MSAA Sample Count
     if *msaa != Msaa::Off {
-        if keys.just_pressed(KeyCode::KeyQ) {
+        if keys.just_pressed(PhysicalKeyCode::KeyQ) {
             *msaa = Msaa::Sample2;
         }
-        if keys.just_pressed(KeyCode::KeyW) {
+        if keys.just_pressed(PhysicalKeyCode::KeyW) {
             *msaa = Msaa::Sample4;
         }
-        if keys.just_pressed(KeyCode::KeyE) {
+        if keys.just_pressed(PhysicalKeyCode::KeyE) {
             *msaa = Msaa::Sample8;
         }
     }
 
     // FXAA
-    if keys.just_pressed(KeyCode::Digit3) && fxaa.is_none() {
+    if keys.just_pressed(PhysicalKeyCode::Digit3) && fxaa.is_none() {
         *msaa = Msaa::Off;
         camera.remove::<TemporalAntiAliasBundle>();
 
@@ -82,30 +82,30 @@ fn modify_aa(
 
     // FXAA Settings
     if let Some(mut fxaa) = fxaa {
-        if keys.just_pressed(KeyCode::KeyQ) {
+        if keys.just_pressed(PhysicalKeyCode::KeyQ) {
             fxaa.edge_threshold = Sensitivity::Low;
             fxaa.edge_threshold_min = Sensitivity::Low;
         }
-        if keys.just_pressed(KeyCode::KeyW) {
+        if keys.just_pressed(PhysicalKeyCode::KeyW) {
             fxaa.edge_threshold = Sensitivity::Medium;
             fxaa.edge_threshold_min = Sensitivity::Medium;
         }
-        if keys.just_pressed(KeyCode::KeyE) {
+        if keys.just_pressed(PhysicalKeyCode::KeyE) {
             fxaa.edge_threshold = Sensitivity::High;
             fxaa.edge_threshold_min = Sensitivity::High;
         }
-        if keys.just_pressed(KeyCode::KeyR) {
+        if keys.just_pressed(PhysicalKeyCode::KeyR) {
             fxaa.edge_threshold = Sensitivity::Ultra;
             fxaa.edge_threshold_min = Sensitivity::Ultra;
         }
-        if keys.just_pressed(KeyCode::KeyT) {
+        if keys.just_pressed(PhysicalKeyCode::KeyT) {
             fxaa.edge_threshold = Sensitivity::Extreme;
             fxaa.edge_threshold_min = Sensitivity::Extreme;
         }
     }
 
     // TAA
-    if keys.just_pressed(KeyCode::Digit4) && taa.is_none() {
+    if keys.just_pressed(PhysicalKeyCode::Digit4) && taa.is_none() {
         *msaa = Msaa::Off;
         camera.remove::<Fxaa>();
 
@@ -114,23 +114,23 @@ fn modify_aa(
 }
 
 fn modify_sharpening(
-    keys: Res<ButtonInput<KeyCode>>,
+    keys: Res<ButtonInput<PhysicalKeyCode>>,
     mut query: Query<&mut ContrastAdaptiveSharpeningSettings>,
 ) {
     for mut cas in &mut query {
-        if keys.just_pressed(KeyCode::Digit0) {
+        if keys.just_pressed(PhysicalKeyCode::Digit0) {
             cas.enabled = !cas.enabled;
         }
         if cas.enabled {
-            if keys.just_pressed(KeyCode::Minus) {
+            if keys.just_pressed(PhysicalKeyCode::Minus) {
                 cas.sharpening_strength -= 0.1;
                 cas.sharpening_strength = cas.sharpening_strength.clamp(0.0, 1.0);
             }
-            if keys.just_pressed(KeyCode::Equal) {
+            if keys.just_pressed(PhysicalKeyCode::Equal) {
                 cas.sharpening_strength += 0.1;
                 cas.sharpening_strength = cas.sharpening_strength.clamp(0.0, 1.0);
             }
-            if keys.just_pressed(KeyCode::KeyD) {
+            if keys.just_pressed(PhysicalKeyCode::KeyD) {
                 cas.denoise = !cas.denoise;
             }
         }
diff --git a/examples/3d/atmospheric_fog.rs b/examples/3d/atmospheric_fog.rs
index 052b31784bc9d9..e9f23ed13c13e5 100644
--- a/examples/3d/atmospheric_fog.rs
+++ b/examples/3d/atmospheric_fog.rs
@@ -112,15 +112,15 @@ fn setup_instructions(mut commands: Commands) {
     );
 }
 
-fn toggle_system(keycode: Res<ButtonInput<KeyCode>>, mut fog: Query<&mut FogSettings>) {
+fn toggle_system(keycode: Res<ButtonInput<PhysicalKeyCode>>, mut fog: Query<&mut FogSettings>) {
     let mut fog_settings = fog.single_mut();
 
-    if keycode.just_pressed(KeyCode::Space) {
+    if keycode.just_pressed(PhysicalKeyCode::Space) {
         let a = fog_settings.color.a();
         fog_settings.color.set_a(1.0 - a);
     }
 
-    if keycode.just_pressed(KeyCode::KeyS) {
+    if keycode.just_pressed(PhysicalKeyCode::KeyS) {
         let a = fog_settings.directional_light_color.a();
         fog_settings.directional_light_color.set_a(0.5 - a);
     }
diff --git a/examples/3d/blend_modes.rs b/examples/3d/blend_modes.rs
index c97a8ee14c22ec..657af7aafea30d 100644
--- a/examples/3d/blend_modes.rs
+++ b/examples/3d/blend_modes.rs
@@ -294,19 +294,19 @@ fn example_control_system(
     labelled: Query<&GlobalTransform>,
     mut state: Local<ExampleState>,
     time: Res<Time>,
-    input: Res<ButtonInput<KeyCode>>,
+    input: Res<ButtonInput<PhysicalKeyCode>>,
 ) {
-    if input.pressed(KeyCode::ArrowUp) {
+    if input.pressed(PhysicalKeyCode::ArrowUp) {
         state.alpha = (state.alpha + time.delta_seconds()).min(1.0);
-    } else if input.pressed(KeyCode::ArrowDown) {
+    } else if input.pressed(PhysicalKeyCode::ArrowDown) {
         state.alpha = (state.alpha - time.delta_seconds()).max(0.0);
     }
 
-    if input.just_pressed(KeyCode::Space) {
+    if input.just_pressed(PhysicalKeyCode::Space) {
         state.unlit = !state.unlit;
     }
 
-    let randomize_colors = input.just_pressed(KeyCode::KeyC);
+    let randomize_colors = input.just_pressed(PhysicalKeyCode::KeyC);
 
     for (material_handle, controls) in &controllable {
         let material = materials.get_mut(material_handle).unwrap();
@@ -324,13 +324,13 @@ fn example_control_system(
 
     let (mut camera, mut camera_transform, camera_global_transform) = camera.single_mut();
 
-    if input.just_pressed(KeyCode::KeyH) {
+    if input.just_pressed(PhysicalKeyCode::KeyH) {
         camera.hdr = !camera.hdr;
     }
 
-    let rotation = if input.pressed(KeyCode::ArrowLeft) {
+    let rotation = if input.pressed(PhysicalKeyCode::ArrowLeft) {
         time.delta_seconds()
-    } else if input.pressed(KeyCode::ArrowRight) {
+    } else if input.pressed(PhysicalKeyCode::ArrowRight) {
         -time.delta_seconds()
     } else {
         0.0
diff --git a/examples/3d/bloom_3d.rs b/examples/3d/bloom_3d.rs
index 3f23736b0bb580..8ea2915359ae0a 100644
--- a/examples/3d/bloom_3d.rs
+++ b/examples/3d/bloom_3d.rs
@@ -114,7 +114,7 @@ fn update_bloom_settings(
     mut camera: Query<(Entity, Option<&mut BloomSettings>), With<Camera>>,
     mut text: Query<&mut Text>,
     mut commands: Commands,
-    keycode: Res<ButtonInput<KeyCode>>,
+    keycode: Res<ButtonInput<PhysicalKeyCode>>,
     time: Res<Time>,
 ) {
     let bloom_settings = camera.single_mut();
@@ -153,65 +153,65 @@ fn update_bloom_settings(
                 bloom_settings.prefilter_settings.threshold_softness
             ));
 
-            if keycode.just_pressed(KeyCode::Space) {
+            if keycode.just_pressed(PhysicalKeyCode::Space) {
                 commands.entity(entity).remove::<BloomSettings>();
             }
 
             let dt = time.delta_seconds();
 
-            if keycode.pressed(KeyCode::KeyA) {
+            if keycode.pressed(PhysicalKeyCode::KeyA) {
                 bloom_settings.intensity -= dt / 10.0;
             }
-            if keycode.pressed(KeyCode::KeyQ) {
+            if keycode.pressed(PhysicalKeyCode::KeyQ) {
                 bloom_settings.intensity += dt / 10.0;
             }
             bloom_settings.intensity = bloom_settings.intensity.clamp(0.0, 1.0);
 
-            if keycode.pressed(KeyCode::KeyS) {
+            if keycode.pressed(PhysicalKeyCode::KeyS) {
                 bloom_settings.low_frequency_boost -= dt / 10.0;
             }
-            if keycode.pressed(KeyCode::KeyW) {
+            if keycode.pressed(PhysicalKeyCode::KeyW) {
                 bloom_settings.low_frequency_boost += dt / 10.0;
             }
             bloom_settings.low_frequency_boost = bloom_settings.low_frequency_boost.clamp(0.0, 1.0);
 
-            if keycode.pressed(KeyCode::KeyD) {
+            if keycode.pressed(PhysicalKeyCode::KeyD) {
                 bloom_settings.low_frequency_boost_curvature -= dt / 10.0;
             }
-            if keycode.pressed(KeyCode::KeyE) {
+            if keycode.pressed(PhysicalKeyCode::KeyE) {
                 bloom_settings.low_frequency_boost_curvature += dt / 10.0;
             }
             bloom_settings.low_frequency_boost_curvature =
                 bloom_settings.low_frequency_boost_curvature.clamp(0.0, 1.0);
 
-            if keycode.pressed(KeyCode::KeyF) {
+            if keycode.pressed(PhysicalKeyCode::KeyF) {
                 bloom_settings.high_pass_frequency -= dt / 10.0;
             }
-            if keycode.pressed(KeyCode::KeyR) {
+            if keycode.pressed(PhysicalKeyCode::KeyR) {
                 bloom_settings.high_pass_frequency += dt / 10.0;
             }
             bloom_settings.high_pass_frequency = bloom_settings.high_pass_frequency.clamp(0.0, 1.0);
 
-            if keycode.pressed(KeyCode::KeyG) {
+            if keycode.pressed(PhysicalKeyCode::KeyG) {
                 bloom_settings.composite_mode = BloomCompositeMode::Additive;
             }
-            if keycode.pressed(KeyCode::KeyT) {
+            if keycode.pressed(PhysicalKeyCode::KeyT) {
                 bloom_settings.composite_mode = BloomCompositeMode::EnergyConserving;
             }
 
-            if keycode.pressed(KeyCode::KeyH) {
+            if keycode.pressed(PhysicalKeyCode::KeyH) {
                 bloom_settings.prefilter_settings.threshold -= dt;
             }
-            if keycode.pressed(KeyCode::KeyY) {
+            if keycode.pressed(PhysicalKeyCode::KeyY) {
                 bloom_settings.prefilter_settings.threshold += dt;
             }
             bloom_settings.prefilter_settings.threshold =
                 bloom_settings.prefilter_settings.threshold.max(0.0);
 
-            if keycode.pressed(KeyCode::KeyJ) {
+            if keycode.pressed(PhysicalKeyCode::KeyJ) {
                 bloom_settings.prefilter_settings.threshold_softness -= dt / 10.0;
             }
-            if keycode.pressed(KeyCode::KeyU) {
+            if keycode.pressed(PhysicalKeyCode::KeyU) {
                 bloom_settings.prefilter_settings.threshold_softness += dt / 10.0;
             }
             bloom_settings.prefilter_settings.threshold_softness = bloom_settings
@@ -223,7 +223,7 @@ fn update_bloom_settings(
         (entity, None) => {
             *text = "Bloom: Off (Toggle: Space)".to_string();
 
-            if keycode.just_pressed(KeyCode::Space) {
+            if keycode.just_pressed(PhysicalKeyCode::Space) {
                 commands.entity(entity).insert(BloomSettings::default());
             }
         }
diff --git a/examples/3d/deferred_rendering.rs b/examples/3d/deferred_rendering.rs
index 01adab5676cf6d..6ab731abb54885 100644
--- a/examples/3d/deferred_rendering.rs
+++ b/examples/3d/deferred_rendering.rs
@@ -337,7 +337,7 @@ enum DefaultRenderMode {
 fn switch_mode(
     mut text: Query<&mut Text>,
     mut commands: Commands,
-    keys: Res<ButtonInput<KeyCode>>,
+    keys: Res<ButtonInput<PhysicalKeyCode>>,
     mut default_opaque_renderer_method: ResMut<DefaultOpaqueRendererMethod>,
     mut materials: ResMut<Assets<StandardMaterial>>,
     cameras: Query<Entity, With<Camera>>,
@@ -350,11 +350,11 @@ fn switch_mode(
 
     text.clear();
 
-    if keys.just_pressed(KeyCode::Space) {
+    if keys.just_pressed(PhysicalKeyCode::Space) {
         pause.0 = !pause.0;
     }
 
-    if keys.just_pressed(KeyCode::Digit1) {
+    if keys.just_pressed(PhysicalKeyCode::Digit1) {
         *mode = DefaultRenderMode::Deferred;
         default_opaque_renderer_method.set_to_deferred();
         println!("DefaultOpaqueRendererMethod: Deferred");
@@ -366,7 +366,7 @@ fn switch_mode(
             commands.entity(camera).insert(DeferredPrepass);
         }
     }
-    if keys.just_pressed(KeyCode::Digit2) {
+    if keys.just_pressed(PhysicalKeyCode::Digit2) {
         *mode = DefaultRenderMode::Forward;
         default_opaque_renderer_method.set_to_forward();
         println!("DefaultOpaqueRendererMethod: Forward");
@@ -378,7 +378,7 @@ fn switch_mode(
             commands.entity(camera).remove::<DeferredPrepass>();
         }
     }
-    if keys.just_pressed(KeyCode::Digit3) {
+    if keys.just_pressed(PhysicalKeyCode::Digit3) {
         *mode = DefaultRenderMode::ForwardPrepass;
         default_opaque_renderer_method.set_to_forward();
         println!("DefaultOpaqueRendererMethod: Forward + Prepass");
@@ -391,7 +391,7 @@ fn switch_mode(
         }
     }
 
-    if keys.just_pressed(KeyCode::KeyH) {
+    if keys.just_pressed(PhysicalKeyCode::KeyH) {
         *hide_ui = !*hide_ui;
     }
 
diff --git a/examples/3d/deterministic.rs b/examples/3d/deterministic.rs
index addd28c197fd96..7f698cff5f08fe 100644
--- a/examples/3d/deterministic.rs
+++ b/examples/3d/deterministic.rs
@@ -60,9 +60,9 @@ fn setup(
 
 fn keys(
     mut deterministic_rendering_config: ResMut<DeterministicRenderingConfig>,
-    keyboard_input: Res<ButtonInput<KeyCode>>,
+    keyboard_input: Res<ButtonInput<PhysicalKeyCode>>,
 ) {
-    if keyboard_input.just_pressed(KeyCode::KeyD) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::KeyD) {
         deterministic_rendering_config.stable_sort_z_fighting ^= true;
     }
 }
diff --git a/examples/3d/fog.rs b/examples/3d/fog.rs
index 677aa95a326eb0..348620ce4fad83 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<ButtonInput<KeyCode>>,
+    keycode: Res<ButtonInput<PhysicalKeyCode>>,
 ) {
     let now = time.elapsed_seconds();
     let delta = time.delta_seconds();
@@ -184,7 +184,7 @@ fn update_system(
         .value
         .push_str("\n\n1 / 2 / 3 - Fog Falloff Mode");
 
-    if keycode.pressed(KeyCode::Digit1) {
+    if keycode.pressed(PhysicalKeyCode::Digit1) {
         if let FogFalloff::Linear { .. } = fog.falloff {
             // No change
         } else {
@@ -195,7 +195,7 @@ fn update_system(
         };
     }
 
-    if keycode.pressed(KeyCode::Digit2) {
+    if keycode.pressed(PhysicalKeyCode::Digit2) {
         if let FogFalloff::Exponential { .. } = fog.falloff {
             // No change
         } else if let FogFalloff::ExponentialSquared { density } = fog.falloff {
@@ -205,7 +205,7 @@ fn update_system(
         };
     }
 
-    if keycode.pressed(KeyCode::Digit3) {
+    if keycode.pressed(PhysicalKeyCode::Digit3) {
         if let FogFalloff::Exponential { density } = fog.falloff {
             fog.falloff = FogFalloff::ExponentialSquared { density };
         } else if let FogFalloff::ExponentialSquared { .. } = fog.falloff {
@@ -225,16 +225,16 @@ fn update_system(
             .value
             .push_str("\nA / S - Move Start Distance\nZ / X - Move End Distance");
 
-        if keycode.pressed(KeyCode::KeyA) {
+        if keycode.pressed(PhysicalKeyCode::KeyA) {
             *start -= delta * 3.0;
         }
-        if keycode.pressed(KeyCode::KeyS) {
+        if keycode.pressed(PhysicalKeyCode::KeyS) {
             *start += delta * 3.0;
         }
-        if keycode.pressed(KeyCode::KeyZ) {
+        if keycode.pressed(PhysicalKeyCode::KeyZ) {
             *end -= delta * 3.0;
         }
-        if keycode.pressed(KeyCode::KeyX) {
+        if keycode.pressed(PhysicalKeyCode::KeyX) {
             *end += delta * 3.0;
         }
     }
@@ -243,13 +243,13 @@ fn update_system(
     if let FogFalloff::Exponential { ref mut density } = &mut fog.falloff {
         text.sections[0].value.push_str("\nA / S - Change Density");
 
-        if keycode.pressed(KeyCode::KeyA) {
+        if keycode.pressed(PhysicalKeyCode::KeyA) {
             *density -= delta * 0.5 * *density;
             if *density < 0.0 {
                 *density = 0.0;
             }
         }
-        if keycode.pressed(KeyCode::KeyS) {
+        if keycode.pressed(PhysicalKeyCode::KeyS) {
             *density += delta * 0.5 * *density;
         }
     }
@@ -258,13 +258,13 @@ fn update_system(
     if let FogFalloff::ExponentialSquared { ref mut density } = &mut fog.falloff {
         text.sections[0].value.push_str("\nA / S - Change Density");
 
-        if keycode.pressed(KeyCode::KeyA) {
+        if keycode.pressed(PhysicalKeyCode::KeyA) {
             *density -= delta * 0.5 * *density;
             if *density < 0.0 {
                 *density = 0.0;
             }
         }
-        if keycode.pressed(KeyCode::KeyS) {
+        if keycode.pressed(PhysicalKeyCode::KeyS) {
             *density += delta * 0.5 * *density;
         }
     }
@@ -274,42 +274,42 @@ fn update_system(
         .value
         .push_str("\n\n- / = - Red\n[ / ] - Green\n; / ' - Blue\n. / ? - Alpha");
 
-    if keycode.pressed(KeyCode::Minus) {
+    if keycode.pressed(PhysicalKeyCode::Minus) {
         let r = (fog.color.r() - 0.1 * delta).max(0.0);
         fog.color.set_r(r);
     }
 
-    if keycode.any_pressed([KeyCode::Equal, KeyCode::NumpadEqual]) {
+    if keycode.any_pressed([PhysicalKeyCode::Equal, PhysicalKeyCode::NumpadEqual]) {
         let r = (fog.color.r() + 0.1 * delta).min(1.0);
         fog.color.set_r(r);
     }
 
-    if keycode.pressed(KeyCode::BracketLeft) {
+    if keycode.pressed(PhysicalKeyCode::BracketLeft) {
         let g = (fog.color.g() - 0.1 * delta).max(0.0);
         fog.color.set_g(g);
     }
 
-    if keycode.pressed(KeyCode::BracketRight) {
+    if keycode.pressed(PhysicalKeyCode::BracketRight) {
         let g = (fog.color.g() + 0.1 * delta).min(1.0);
         fog.color.set_g(g);
     }
 
-    if keycode.pressed(KeyCode::Semicolon) {
+    if keycode.pressed(PhysicalKeyCode::Semicolon) {
         let b = (fog.color.b() - 0.1 * delta).max(0.0);
         fog.color.set_b(b);
     }
 
-    if keycode.pressed(KeyCode::Quote) {
+    if keycode.pressed(PhysicalKeyCode::Quote) {
         let b = (fog.color.b() + 0.1 * delta).min(1.0);
         fog.color.set_b(b);
     }
 
-    if keycode.pressed(KeyCode::Period) {
+    if keycode.pressed(PhysicalKeyCode::Period) {
         let a = (fog.color.a() - 0.1 * delta).max(0.0);
         fog.color.set_a(a);
     }
 
-    if keycode.pressed(KeyCode::Slash) {
+    if keycode.pressed(PhysicalKeyCode::Slash) {
         let a = (fog.color.a() + 0.1 * delta).min(1.0);
         fog.color.set_a(a);
     }
diff --git a/examples/3d/generate_custom_mesh.rs b/examples/3d/generate_custom_mesh.rs
index 1c9cf0d067e908..2373158a411346 100644
--- a/examples/3d/generate_custom_mesh.rs
+++ b/examples/3d/generate_custom_mesh.rs
@@ -88,33 +88,33 @@ 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<ButtonInput<KeyCode>>,
+    keyboard_input: Res<ButtonInput<PhysicalKeyCode>>,
     mesh_query: Query<&Handle<Mesh>, With<CustomUV>>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut query: Query<&mut Transform, With<CustomUV>>,
     time: Res<Time>,
 ) {
-    if keyboard_input.just_pressed(KeyCode::Space) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::Space) {
         let mesh_handle = mesh_query.get_single().expect("Query not successful");
         let mesh = meshes.get_mut(mesh_handle).unwrap();
         toggle_texture(mesh);
     }
-    if keyboard_input.pressed(KeyCode::KeyX) {
+    if keyboard_input.pressed(PhysicalKeyCode::KeyX) {
         for mut transform in &mut query {
             transform.rotate_x(time.delta_seconds() / 1.2);
         }
     }
-    if keyboard_input.pressed(KeyCode::KeyY) {
+    if keyboard_input.pressed(PhysicalKeyCode::KeyY) {
         for mut transform in &mut query {
             transform.rotate_y(time.delta_seconds() / 1.2);
         }
     }
-    if keyboard_input.pressed(KeyCode::KeyZ) {
+    if keyboard_input.pressed(PhysicalKeyCode::KeyZ) {
         for mut transform in &mut query {
             transform.rotate_z(time.delta_seconds() / 1.2);
         }
     }
-    if keyboard_input.pressed(KeyCode::KeyR) {
+    if keyboard_input.pressed(PhysicalKeyCode::KeyR) {
         for mut transform in &mut query {
             transform.look_to(Vec3::NEG_Z, Vec3::Y);
         }
diff --git a/examples/3d/lighting.rs b/examples/3d/lighting.rs
index 9e68a4012c0d22..6334cdc2be0daa 100644
--- a/examples/3d/lighting.rs
+++ b/examples/3d/lighting.rs
@@ -291,29 +291,29 @@ fn setup(
 }
 
 fn update_exposure(
-    key_input: Res<ButtonInput<KeyCode>>,
+    key_input: Res<ButtonInput<PhysicalKeyCode>>,
     mut parameters: ResMut<Parameters>,
     mut query: Query<&mut ExposureSettings>,
     mut text: Query<&mut Text>,
 ) {
     // TODO: Clamp values to a reasonable range
     let mut text = text.single_mut();
-    if key_input.just_pressed(KeyCode::Digit2) {
+    if key_input.just_pressed(PhysicalKeyCode::Digit2) {
         parameters.aperture_f_stops *= 2.0;
-    } else if key_input.just_pressed(KeyCode::Digit1) {
+    } else if key_input.just_pressed(PhysicalKeyCode::Digit1) {
         parameters.aperture_f_stops *= 0.5;
     }
-    if key_input.just_pressed(KeyCode::Digit4) {
+    if key_input.just_pressed(PhysicalKeyCode::Digit4) {
         parameters.shutter_speed_s *= 2.0;
-    } else if key_input.just_pressed(KeyCode::Digit3) {
+    } else if key_input.just_pressed(PhysicalKeyCode::Digit3) {
         parameters.shutter_speed_s *= 0.5;
     }
-    if key_input.just_pressed(KeyCode::Digit6) {
+    if key_input.just_pressed(PhysicalKeyCode::Digit6) {
         parameters.sensitivity_iso += 100.0;
-    } else if key_input.just_pressed(KeyCode::Digit5) {
+    } else if key_input.just_pressed(PhysicalKeyCode::Digit5) {
         parameters.sensitivity_iso -= 100.0;
     }
-    if key_input.just_pressed(KeyCode::KeyR) {
+    if key_input.just_pressed(PhysicalKeyCode::KeyR) {
         *parameters = Parameters::default();
     }
 
@@ -337,22 +337,22 @@ fn animate_light_direction(
 }
 
 fn movement(
-    input: Res<ButtonInput<KeyCode>>,
+    input: Res<ButtonInput<PhysicalKeyCode>>,
     time: Res<Time>,
     mut query: Query<&mut Transform, With<Movable>>,
 ) {
     for mut transform in &mut query {
         let mut direction = Vec3::ZERO;
-        if input.pressed(KeyCode::ArrowUp) {
+        if input.pressed(PhysicalKeyCode::ArrowUp) {
             direction.y += 1.0;
         }
-        if input.pressed(KeyCode::ArrowDown) {
+        if input.pressed(PhysicalKeyCode::ArrowDown) {
             direction.y -= 1.0;
         }
-        if input.pressed(KeyCode::ArrowLeft) {
+        if input.pressed(PhysicalKeyCode::ArrowLeft) {
             direction.x -= 1.0;
         }
-        if input.pressed(KeyCode::ArrowRight) {
+        if input.pressed(PhysicalKeyCode::ArrowRight) {
             direction.x += 1.0;
         }
 
diff --git a/examples/3d/parallax_mapping.rs b/examples/3d/parallax_mapping.rs
index 159c37039f737c..8d617860cb9b0d 100644
--- a/examples/3d/parallax_mapping.rs
+++ b/examples/3d/parallax_mapping.rs
@@ -79,18 +79,18 @@ impl CurrentMethod {
 }
 
 fn update_parallax_depth_scale(
-    input: Res<ButtonInput<KeyCode>>,
+    input: Res<ButtonInput<PhysicalKeyCode>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
     mut target_depth: Local<TargetDepth>,
     mut depth_update: Local<bool>,
     mut text: Query<&mut Text>,
 ) {
-    if input.just_pressed(KeyCode::Digit1) {
+    if input.just_pressed(PhysicalKeyCode::Digit1) {
         target_depth.0 -= DEPTH_UPDATE_STEP;
         target_depth.0 = target_depth.0.max(0.0);
         *depth_update = true;
     }
-    if input.just_pressed(KeyCode::Digit2) {
+    if input.just_pressed(PhysicalKeyCode::Digit2) {
         target_depth.0 += DEPTH_UPDATE_STEP;
         target_depth.0 = target_depth.0.min(MAX_DEPTH);
         *depth_update = true;
@@ -110,12 +110,12 @@ fn update_parallax_depth_scale(
 }
 
 fn switch_method(
-    input: Res<ButtonInput<KeyCode>>,
+    input: Res<ButtonInput<PhysicalKeyCode>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
     mut text: Query<&mut Text>,
     mut current: Local<CurrentMethod>,
 ) {
-    if input.just_pressed(KeyCode::Space) {
+    if input.just_pressed(PhysicalKeyCode::Space) {
         current.next_method();
     } else {
         return;
@@ -129,15 +129,15 @@ fn switch_method(
 }
 
 fn update_parallax_layers(
-    input: Res<ButtonInput<KeyCode>>,
+    input: Res<ButtonInput<PhysicalKeyCode>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
     mut target_layers: Local<TargetLayers>,
     mut text: Query<&mut Text>,
 ) {
-    if input.just_pressed(KeyCode::Digit3) {
+    if input.just_pressed(PhysicalKeyCode::Digit3) {
         target_layers.0 -= 1.0;
         target_layers.0 = target_layers.0.max(0.0);
-    } else if input.just_pressed(KeyCode::Digit4) {
+    } else if input.just_pressed(PhysicalKeyCode::Digit4) {
         target_layers.0 += 1.0;
     } else {
         return;
diff --git a/examples/3d/reflection_probes.rs b/examples/3d/reflection_probes.rs
index cdb45ff80e9ce6..18a5c2aac561e0 100644
--- a/examples/3d/reflection_probes.rs
+++ b/examples/3d/reflection_probes.rs
@@ -202,12 +202,12 @@ fn change_reflection_type(
     mut commands: Commands,
     light_probe_query: Query<Entity, With<LightProbe>>,
     camera_query: Query<Entity, With<Camera3d>>,
-    keyboard: Res<ButtonInput<KeyCode>>,
+    keyboard: Res<ButtonInput<PhysicalKeyCode>>,
     mut app_status: ResMut<AppStatus>,
     cubemaps: Res<Cubemaps>,
 ) {
     // Only do anything if space was pressed.
-    if !keyboard.just_pressed(KeyCode::Space) {
+    if !keyboard.just_pressed(PhysicalKeyCode::Space) {
         return;
     }
 
@@ -240,8 +240,8 @@ fn change_reflection_type(
 }
 
 // A system that handles enabling and disabling rotation.
-fn toggle_rotation(keyboard: Res<ButtonInput<KeyCode>>, mut app_status: ResMut<AppStatus>) {
-    if keyboard.just_pressed(KeyCode::Enter) {
+fn toggle_rotation(keyboard: Res<ButtonInput<PhysicalKeyCode>>, mut app_status: ResMut<AppStatus>) {
+    if keyboard.just_pressed(PhysicalKeyCode::Enter) {
         app_status.rotating = !app_status.rotating;
     }
 }
diff --git a/examples/3d/shadow_biases.rs b/examples/3d/shadow_biases.rs
index bf9c4edb2bb4ba..673ccd57cf309e 100644
--- a/examples/3d/shadow_biases.rs
+++ b/examples/3d/shadow_biases.rs
@@ -187,12 +187,12 @@ fn setup(
 }
 
 fn toggle_light(
-    input: Res<ButtonInput<KeyCode>>,
+    input: Res<ButtonInput<PhysicalKeyCode>>,
     mut point_lights: Query<&mut PointLight>,
     mut directional_lights: Query<&mut DirectionalLight>,
     mut example_text: Query<&mut Text>,
 ) {
-    if input.just_pressed(KeyCode::KeyL) {
+    if input.just_pressed(PhysicalKeyCode::KeyL) {
         for mut light in &mut point_lights {
             light.intensity = if light.intensity == 0.0 {
                 example_text.single_mut().sections[3].value = "PointLight".to_string();
@@ -213,27 +213,27 @@ fn toggle_light(
 }
 
 fn adjust_light_position(
-    input: Res<ButtonInput<KeyCode>>,
+    input: Res<ButtonInput<PhysicalKeyCode>>,
     mut lights: Query<&mut Transform, With<Lights>>,
     mut example_text: Query<&mut Text>,
 ) {
     let mut offset = Vec3::ZERO;
-    if input.just_pressed(KeyCode::ArrowLeft) {
+    if input.just_pressed(PhysicalKeyCode::ArrowLeft) {
         offset.x -= 1.0;
     }
-    if input.just_pressed(KeyCode::ArrowRight) {
+    if input.just_pressed(PhysicalKeyCode::ArrowRight) {
         offset.x += 1.0;
     }
-    if input.just_pressed(KeyCode::ArrowUp) {
+    if input.just_pressed(PhysicalKeyCode::ArrowUp) {
         offset.z -= 1.0;
     }
-    if input.just_pressed(KeyCode::ArrowDown) {
+    if input.just_pressed(PhysicalKeyCode::ArrowDown) {
         offset.z += 1.0;
     }
-    if input.just_pressed(KeyCode::PageDown) {
+    if input.just_pressed(PhysicalKeyCode::PageDown) {
         offset.y -= 1.0;
     }
-    if input.just_pressed(KeyCode::PageUp) {
+    if input.just_pressed(PhysicalKeyCode::PageUp) {
         offset.y += 1.0;
     }
     if offset != Vec3::ZERO {
@@ -249,11 +249,11 @@ fn adjust_light_position(
 }
 
 fn cycle_filter_methods(
-    input: Res<ButtonInput<KeyCode>>,
+    input: Res<ButtonInput<PhysicalKeyCode>>,
     mut filter_methods: Query<&mut ShadowFilteringMethod>,
     mut example_text: Query<&mut Text>,
 ) {
-    if input.just_pressed(KeyCode::KeyF) {
+    if input.just_pressed(PhysicalKeyCode::KeyF) {
         for mut filter_method in &mut filter_methods {
             let filter_method_string;
             *filter_method = match *filter_method {
@@ -276,30 +276,30 @@ fn cycle_filter_methods(
 }
 
 fn adjust_point_light_biases(
-    input: Res<ButtonInput<KeyCode>>,
+    input: Res<ButtonInput<PhysicalKeyCode>>,
     mut query: Query<&mut PointLight>,
     mut example_text: Query<&mut Text>,
 ) {
     let depth_bias_step_size = 0.01;
     let normal_bias_step_size = 0.1;
     for mut light in &mut query {
-        if input.just_pressed(KeyCode::Digit1) {
+        if input.just_pressed(PhysicalKeyCode::Digit1) {
             light.shadow_depth_bias -= depth_bias_step_size;
         }
-        if input.just_pressed(KeyCode::Digit2) {
+        if input.just_pressed(PhysicalKeyCode::Digit2) {
             light.shadow_depth_bias += depth_bias_step_size;
         }
-        if input.just_pressed(KeyCode::Digit3) {
+        if input.just_pressed(PhysicalKeyCode::Digit3) {
             light.shadow_normal_bias -= normal_bias_step_size;
         }
-        if input.just_pressed(KeyCode::Digit4) {
+        if input.just_pressed(PhysicalKeyCode::Digit4) {
             light.shadow_normal_bias += normal_bias_step_size;
         }
-        if input.just_pressed(KeyCode::KeyR) {
+        if input.just_pressed(PhysicalKeyCode::KeyR) {
             light.shadow_depth_bias = PointLight::DEFAULT_SHADOW_DEPTH_BIAS;
             light.shadow_normal_bias = PointLight::DEFAULT_SHADOW_NORMAL_BIAS;
         }
-        if input.just_pressed(KeyCode::KeyZ) {
+        if input.just_pressed(PhysicalKeyCode::KeyZ) {
             light.shadow_depth_bias = 0.0;
             light.shadow_normal_bias = 0.0;
         }
@@ -310,30 +310,30 @@ fn adjust_point_light_biases(
 }
 
 fn adjust_directional_light_biases(
-    input: Res<ButtonInput<KeyCode>>,
+    input: Res<ButtonInput<PhysicalKeyCode>>,
     mut query: Query<&mut DirectionalLight>,
     mut example_text: Query<&mut Text>,
 ) {
     let depth_bias_step_size = 0.01;
     let normal_bias_step_size = 0.1;
     for mut light in &mut query {
-        if input.just_pressed(KeyCode::Digit5) {
+        if input.just_pressed(PhysicalKeyCode::Digit5) {
             light.shadow_depth_bias -= depth_bias_step_size;
         }
-        if input.just_pressed(KeyCode::Digit6) {
+        if input.just_pressed(PhysicalKeyCode::Digit6) {
             light.shadow_depth_bias += depth_bias_step_size;
         }
-        if input.just_pressed(KeyCode::Digit7) {
+        if input.just_pressed(PhysicalKeyCode::Digit7) {
             light.shadow_normal_bias -= normal_bias_step_size;
         }
-        if input.just_pressed(KeyCode::Digit8) {
+        if input.just_pressed(PhysicalKeyCode::Digit8) {
             light.shadow_normal_bias += normal_bias_step_size;
         }
-        if input.just_pressed(KeyCode::KeyR) {
+        if input.just_pressed(PhysicalKeyCode::KeyR) {
             light.shadow_depth_bias = DirectionalLight::DEFAULT_SHADOW_DEPTH_BIAS;
             light.shadow_normal_bias = DirectionalLight::DEFAULT_SHADOW_NORMAL_BIAS;
         }
-        if input.just_pressed(KeyCode::KeyZ) {
+        if input.just_pressed(PhysicalKeyCode::KeyZ) {
             light.shadow_depth_bias = 0.0;
             light.shadow_normal_bias = 0.0;
         }
diff --git a/examples/3d/shadow_caster_receiver.rs b/examples/3d/shadow_caster_receiver.rs
index 1928ca9897b571..5175d78241fae1 100644
--- a/examples/3d/shadow_caster_receiver.rs
+++ b/examples/3d/shadow_caster_receiver.rs
@@ -126,11 +126,11 @@ fn setup(
 }
 
 fn toggle_light(
-    input: Res<ButtonInput<KeyCode>>,
+    input: Res<ButtonInput<PhysicalKeyCode>>,
     mut point_lights: Query<&mut PointLight>,
     mut directional_lights: Query<&mut DirectionalLight>,
 ) {
-    if input.just_pressed(KeyCode::KeyL) {
+    if input.just_pressed(PhysicalKeyCode::KeyL) {
         for mut light in &mut point_lights {
             light.intensity = if light.intensity == 0.0 {
                 println!("Using PointLight");
@@ -152,7 +152,7 @@ fn toggle_light(
 
 fn toggle_shadows(
     mut commands: Commands,
-    input: Res<ButtonInput<KeyCode>>,
+    input: Res<ButtonInput<PhysicalKeyCode>>,
     mut queries: ParamSet<(
         Query<Entity, (With<Handle<Mesh>>, With<NotShadowCaster>)>,
         Query<Entity, (With<Handle<Mesh>>, With<NotShadowReceiver>)>,
@@ -160,7 +160,7 @@ fn toggle_shadows(
         Query<Entity, (With<Handle<Mesh>>, Without<NotShadowReceiver>)>,
     )>,
 ) {
-    if input.just_pressed(KeyCode::KeyC) {
+    if input.just_pressed(PhysicalKeyCode::KeyC) {
         println!("Toggling casters");
         for entity in queries.p0().iter() {
             commands.entity(entity).remove::<NotShadowCaster>();
@@ -169,7 +169,7 @@ fn toggle_shadows(
             commands.entity(entity).insert(NotShadowCaster);
         }
     }
-    if input.just_pressed(KeyCode::KeyR) {
+    if input.just_pressed(PhysicalKeyCode::KeyR) {
         println!("Toggling receivers");
         for entity in queries.p1().iter() {
             commands.entity(entity).remove::<NotShadowReceiver>();
diff --git a/examples/3d/spotlight.rs b/examples/3d/spotlight.rs
index 93cdd3ea6668f8..417a88bbc9ea92 100644
--- a/examples/3d/spotlight.rs
+++ b/examples/3d/spotlight.rs
@@ -142,28 +142,28 @@ fn light_sway(time: Res<Time>, mut query: Query<(&mut Transform, &mut SpotLight)
 }
 
 fn movement(
-    input: Res<ButtonInput<KeyCode>>,
+    input: Res<ButtonInput<PhysicalKeyCode>>,
     time: Res<Time>,
     mut query: Query<&mut Transform, With<Movable>>,
 ) {
     for mut transform in &mut query {
         let mut direction = Vec3::ZERO;
-        if input.pressed(KeyCode::ArrowUp) {
+        if input.pressed(PhysicalKeyCode::ArrowUp) {
             direction.z -= 1.0;
         }
-        if input.pressed(KeyCode::ArrowDown) {
+        if input.pressed(PhysicalKeyCode::ArrowDown) {
             direction.z += 1.0;
         }
-        if input.pressed(KeyCode::ArrowLeft) {
+        if input.pressed(PhysicalKeyCode::ArrowLeft) {
             direction.x -= 1.0;
         }
-        if input.pressed(KeyCode::ArrowRight) {
+        if input.pressed(PhysicalKeyCode::ArrowRight) {
             direction.x += 1.0;
         }
-        if input.pressed(KeyCode::PageUp) {
+        if input.pressed(PhysicalKeyCode::PageUp) {
             direction.y += 1.0;
         }
-        if input.pressed(KeyCode::PageDown) {
+        if input.pressed(PhysicalKeyCode::PageDown) {
             direction.y -= 1.0;
         }
 
diff --git a/examples/3d/ssao.rs b/examples/3d/ssao.rs
index 97d82b94f183aa..e11dd0e1d733a5 100644
--- a/examples/3d/ssao.rs
+++ b/examples/3d/ssao.rs
@@ -128,7 +128,7 @@ fn update(
     mut text: Query<&mut Text>,
     mut sphere: Query<&mut Transform, With<SphereMarker>>,
     mut commands: Commands,
-    keycode: Res<ButtonInput<KeyCode>>,
+    keycode: Res<ButtonInput<PhysicalKeyCode>>,
     time: Res<Time>,
 ) {
     let mut sphere = sphere.single_mut();
@@ -137,30 +137,30 @@ fn update(
     let (camera_entity, ssao_settings, temporal_jitter) = camera.single();
 
     let mut commands = commands.entity(camera_entity);
-    if keycode.just_pressed(KeyCode::Digit1) {
+    if keycode.just_pressed(PhysicalKeyCode::Digit1) {
         commands.remove::<ScreenSpaceAmbientOcclusionSettings>();
     }
-    if keycode.just_pressed(KeyCode::Digit2) {
+    if keycode.just_pressed(PhysicalKeyCode::Digit2) {
         commands.insert(ScreenSpaceAmbientOcclusionSettings {
             quality_level: ScreenSpaceAmbientOcclusionQualityLevel::Low,
         });
     }
-    if keycode.just_pressed(KeyCode::Digit3) {
+    if keycode.just_pressed(PhysicalKeyCode::Digit3) {
         commands.insert(ScreenSpaceAmbientOcclusionSettings {
             quality_level: ScreenSpaceAmbientOcclusionQualityLevel::Medium,
         });
     }
-    if keycode.just_pressed(KeyCode::Digit4) {
+    if keycode.just_pressed(PhysicalKeyCode::Digit4) {
         commands.insert(ScreenSpaceAmbientOcclusionSettings {
             quality_level: ScreenSpaceAmbientOcclusionQualityLevel::High,
         });
     }
-    if keycode.just_pressed(KeyCode::Digit5) {
+    if keycode.just_pressed(PhysicalKeyCode::Digit5) {
         commands.insert(ScreenSpaceAmbientOcclusionSettings {
             quality_level: ScreenSpaceAmbientOcclusionQualityLevel::Ultra,
         });
     }
-    if keycode.just_pressed(KeyCode::Space) {
+    if keycode.just_pressed(PhysicalKeyCode::Space) {
         if temporal_jitter.is_some() {
             commands.remove::<TemporalJitter>();
         } else {
diff --git a/examples/3d/tonemapping.rs b/examples/3d/tonemapping.rs
index 9c168415b8de67..41c025de786faf 100644
--- a/examples/3d/tonemapping.rs
+++ b/examples/3d/tonemapping.rs
@@ -360,16 +360,16 @@ fn resize_image(
 }
 
 fn toggle_scene(
-    keys: Res<ButtonInput<KeyCode>>,
+    keys: Res<ButtonInput<PhysicalKeyCode>>,
     mut query: Query<(&mut Visibility, &SceneNumber)>,
     mut current_scene: ResMut<CurrentScene>,
 ) {
     let mut pressed = None;
-    if keys.just_pressed(KeyCode::KeyQ) {
+    if keys.just_pressed(PhysicalKeyCode::KeyQ) {
         pressed = Some(1);
-    } else if keys.just_pressed(KeyCode::KeyW) {
+    } else if keys.just_pressed(PhysicalKeyCode::KeyW) {
         pressed = Some(2);
-    } else if keys.just_pressed(KeyCode::KeyE) {
+    } else if keys.just_pressed(PhysicalKeyCode::KeyE) {
         pressed = Some(3);
     }
 
@@ -387,7 +387,7 @@ fn toggle_scene(
 }
 
 fn toggle_tonemapping_method(
-    keys: Res<ButtonInput<KeyCode>>,
+    keys: Res<ButtonInput<PhysicalKeyCode>>,
     mut tonemapping: Query<&mut Tonemapping>,
     mut color_grading: Query<&mut ColorGrading>,
     per_method_settings: Res<PerMethodSettings>,
@@ -395,21 +395,21 @@ fn toggle_tonemapping_method(
     let mut method = tonemapping.single_mut();
     let mut color_grading = color_grading.single_mut();
 
-    if keys.just_pressed(KeyCode::Digit1) {
+    if keys.just_pressed(PhysicalKeyCode::Digit1) {
         *method = Tonemapping::None;
-    } else if keys.just_pressed(KeyCode::Digit2) {
+    } else if keys.just_pressed(PhysicalKeyCode::Digit2) {
         *method = Tonemapping::Reinhard;
-    } else if keys.just_pressed(KeyCode::Digit3) {
+    } else if keys.just_pressed(PhysicalKeyCode::Digit3) {
         *method = Tonemapping::ReinhardLuminance;
-    } else if keys.just_pressed(KeyCode::Digit4) {
+    } else if keys.just_pressed(PhysicalKeyCode::Digit4) {
         *method = Tonemapping::AcesFitted;
-    } else if keys.just_pressed(KeyCode::Digit5) {
+    } else if keys.just_pressed(PhysicalKeyCode::Digit5) {
         *method = Tonemapping::AgX;
-    } else if keys.just_pressed(KeyCode::Digit6) {
+    } else if keys.just_pressed(PhysicalKeyCode::Digit6) {
         *method = Tonemapping::SomewhatBoringDisplayTransform;
-    } else if keys.just_pressed(KeyCode::Digit7) {
+    } else if keys.just_pressed(PhysicalKeyCode::Digit7) {
         *method = Tonemapping::TonyMcMapface;
-    } else if keys.just_pressed(KeyCode::Digit8) {
+    } else if keys.just_pressed(PhysicalKeyCode::Digit8) {
         *method = Tonemapping::BlenderFilmic;
     }
 
@@ -435,7 +435,7 @@ impl SelectedParameter {
 }
 
 fn update_color_grading_settings(
-    keys: Res<ButtonInput<KeyCode>>,
+    keys: Res<ButtonInput<PhysicalKeyCode>>,
     time: Res<Time>,
     mut per_method_settings: ResMut<PerMethodSettings>,
     tonemapping: Query<&Tonemapping>,
@@ -445,17 +445,17 @@ fn update_color_grading_settings(
     let method = tonemapping.single();
     let color_grading = per_method_settings.settings.get_mut(method).unwrap();
     let mut dt = time.delta_seconds() * 0.25;
-    if keys.pressed(KeyCode::ArrowLeft) {
+    if keys.pressed(PhysicalKeyCode::ArrowLeft) {
         dt = -dt;
     }
 
-    if keys.just_pressed(KeyCode::ArrowDown) {
+    if keys.just_pressed(PhysicalKeyCode::ArrowDown) {
         selected_parameter.next();
     }
-    if keys.just_pressed(KeyCode::ArrowUp) {
+    if keys.just_pressed(PhysicalKeyCode::ArrowUp) {
         selected_parameter.prev();
     }
-    if keys.pressed(KeyCode::ArrowLeft) || keys.pressed(KeyCode::ArrowRight) {
+    if keys.pressed(PhysicalKeyCode::ArrowLeft) || keys.pressed(PhysicalKeyCode::ArrowRight) {
         match selected_parameter.value {
             0 => {
                 color_grading.exposure += dt;
@@ -473,13 +473,13 @@ fn update_color_grading_settings(
         }
     }
 
-    if keys.just_pressed(KeyCode::Space) {
+    if keys.just_pressed(PhysicalKeyCode::Space) {
         for (_, grading) in per_method_settings.settings.iter_mut() {
             *grading = ColorGrading::default();
         }
     }
 
-    if keys.just_pressed(KeyCode::Enter) && current_scene.0 == 1 {
+    if keys.just_pressed(PhysicalKeyCode::Enter) && current_scene.0 == 1 {
         for (mapper, grading) in per_method_settings.settings.iter_mut() {
             *grading = PerMethodSettings::basic_scene_recommendation(*mapper);
         }
@@ -492,7 +492,7 @@ fn update_ui(
     current_scene: Res<CurrentScene>,
     selected_parameter: Res<SelectedParameter>,
     mut hide_ui: Local<bool>,
-    keys: Res<ButtonInput<KeyCode>>,
+    keys: Res<ButtonInput<PhysicalKeyCode>>,
 ) {
     let (method, color_grading) = settings.single();
     let method = *method;
@@ -500,7 +500,7 @@ fn update_ui(
     let mut text = text.single_mut();
     let text = &mut text.sections[0].value;
 
-    if keys.just_pressed(KeyCode::KeyH) {
+    if keys.just_pressed(PhysicalKeyCode::KeyH) {
         *hide_ui = !*hide_ui;
     }
     text.clear();
diff --git a/examples/3d/transmission.rs b/examples/3d/transmission.rs
index 156d51f2359f28..023ec69bdcbff4 100644
--- a/examples/3d/transmission.rs
+++ b/examples/3d/transmission.rs
@@ -435,45 +435,45 @@ fn example_control_system(
     mut display: Query<&mut Text, With<ExampleDisplay>>,
     mut state: Local<ExampleState>,
     time: Res<Time>,
-    input: Res<ButtonInput<KeyCode>>,
+    input: Res<ButtonInput<PhysicalKeyCode>>,
 ) {
-    if input.pressed(KeyCode::Digit2) {
+    if input.pressed(PhysicalKeyCode::Digit2) {
         state.diffuse_transmission = (state.diffuse_transmission + time.delta_seconds()).min(1.0);
-    } else if input.pressed(KeyCode::Digit1) {
+    } else if input.pressed(PhysicalKeyCode::Digit1) {
         state.diffuse_transmission = (state.diffuse_transmission - time.delta_seconds()).max(0.0);
     }
 
-    if input.pressed(KeyCode::KeyW) {
+    if input.pressed(PhysicalKeyCode::KeyW) {
         state.specular_transmission = (state.specular_transmission + time.delta_seconds()).min(1.0);
-    } else if input.pressed(KeyCode::KeyQ) {
+    } else if input.pressed(PhysicalKeyCode::KeyQ) {
         state.specular_transmission = (state.specular_transmission - time.delta_seconds()).max(0.0);
     }
 
-    if input.pressed(KeyCode::KeyS) {
+    if input.pressed(PhysicalKeyCode::KeyS) {
         state.thickness = (state.thickness + time.delta_seconds()).min(5.0);
-    } else if input.pressed(KeyCode::KeyA) {
+    } else if input.pressed(PhysicalKeyCode::KeyA) {
         state.thickness = (state.thickness - time.delta_seconds()).max(0.0);
     }
 
-    if input.pressed(KeyCode::KeyX) {
+    if input.pressed(PhysicalKeyCode::KeyX) {
         state.ior = (state.ior + time.delta_seconds()).min(3.0);
-    } else if input.pressed(KeyCode::KeyZ) {
+    } else if input.pressed(PhysicalKeyCode::KeyZ) {
         state.ior = (state.ior - time.delta_seconds()).max(1.0);
     }
 
-    if input.pressed(KeyCode::KeyI) {
+    if input.pressed(PhysicalKeyCode::KeyI) {
         state.reflectance = (state.reflectance + time.delta_seconds()).min(1.0);
-    } else if input.pressed(KeyCode::KeyU) {
+    } else if input.pressed(PhysicalKeyCode::KeyU) {
         state.reflectance = (state.reflectance - time.delta_seconds()).max(0.0);
     }
 
-    if input.pressed(KeyCode::KeyR) {
+    if input.pressed(PhysicalKeyCode::KeyR) {
         state.perceptual_roughness = (state.perceptual_roughness + time.delta_seconds()).min(1.0);
-    } else if input.pressed(KeyCode::KeyE) {
+    } else if input.pressed(PhysicalKeyCode::KeyE) {
         state.perceptual_roughness = (state.perceptual_roughness - time.delta_seconds()).max(0.0);
     }
 
-    let randomize_colors = input.just_pressed(KeyCode::KeyC);
+    let randomize_colors = input.just_pressed(PhysicalKeyCode::KeyC);
 
     for (material_handle, controls) in &controllable {
         let material = materials.get_mut(material_handle).unwrap();
@@ -505,12 +505,12 @@ fn example_control_system(
         temporal_jitter,
     ) = camera.single_mut();
 
-    if input.just_pressed(KeyCode::KeyH) {
+    if input.just_pressed(PhysicalKeyCode::KeyH) {
         camera.hdr = !camera.hdr;
     }
 
     #[cfg(not(all(feature = "webgl2", target_arch = "wasm32")))]
-    if input.just_pressed(KeyCode::KeyD) {
+    if input.just_pressed(PhysicalKeyCode::KeyD) {
         if depth_prepass.is_none() {
             commands.entity(camera_entity).insert(DepthPrepass);
         } else {
@@ -519,7 +519,7 @@ fn example_control_system(
     }
 
     #[cfg(not(all(feature = "webgl2", target_arch = "wasm32")))]
-    if input.just_pressed(KeyCode::KeyT) {
+    if input.just_pressed(PhysicalKeyCode::KeyT) {
         if temporal_jitter.is_none() {
             commands.entity(camera_entity).insert((
                 TemporalJitter::default(),
@@ -532,36 +532,40 @@ fn example_control_system(
         }
     }
 
-    if input.just_pressed(KeyCode::KeyO) && camera_3d.screen_space_specular_transmission_steps > 0 {
+    if input.just_pressed(PhysicalKeyCode::KeyO)
+        && camera_3d.screen_space_specular_transmission_steps > 0
+    {
         camera_3d.screen_space_specular_transmission_steps -= 1;
     }
 
-    if input.just_pressed(KeyCode::KeyP) && camera_3d.screen_space_specular_transmission_steps < 4 {
+    if input.just_pressed(PhysicalKeyCode::KeyP)
+        && camera_3d.screen_space_specular_transmission_steps < 4
+    {
         camera_3d.screen_space_specular_transmission_steps += 1;
     }
 
-    if input.just_pressed(KeyCode::KeyJ) {
+    if input.just_pressed(PhysicalKeyCode::KeyJ) {
         camera_3d.screen_space_specular_transmission_quality = ScreenSpaceTransmissionQuality::Low;
     }
 
-    if input.just_pressed(KeyCode::KeyK) {
+    if input.just_pressed(PhysicalKeyCode::KeyK) {
         camera_3d.screen_space_specular_transmission_quality =
             ScreenSpaceTransmissionQuality::Medium;
     }
 
-    if input.just_pressed(KeyCode::KeyL) {
+    if input.just_pressed(PhysicalKeyCode::KeyL) {
         camera_3d.screen_space_specular_transmission_quality = ScreenSpaceTransmissionQuality::High;
     }
 
-    if input.just_pressed(KeyCode::Semicolon) {
+    if input.just_pressed(PhysicalKeyCode::Semicolon) {
         camera_3d.screen_space_specular_transmission_quality =
             ScreenSpaceTransmissionQuality::Ultra;
     }
 
-    let rotation = if input.pressed(KeyCode::ArrowRight) {
+    let rotation = if input.pressed(PhysicalKeyCode::ArrowRight) {
         state.auto_camera = false;
         time.delta_seconds()
-    } else if input.pressed(KeyCode::ArrowLeft) {
+    } else if input.pressed(PhysicalKeyCode::ArrowLeft) {
         state.auto_camera = false;
         -time.delta_seconds()
     } else if state.auto_camera {
@@ -570,14 +574,16 @@ fn example_control_system(
         0.0
     };
 
-    let distance_change =
-        if input.pressed(KeyCode::ArrowDown) && camera_transform.translation.length() < 25.0 {
-            time.delta_seconds()
-        } else if input.pressed(KeyCode::ArrowUp) && camera_transform.translation.length() > 2.0 {
-            -time.delta_seconds()
-        } else {
-            0.0
-        };
+    let distance_change = if input.pressed(PhysicalKeyCode::ArrowDown)
+        && camera_transform.translation.length() < 25.0
+    {
+        time.delta_seconds()
+    } else if input.pressed(PhysicalKeyCode::ArrowUp) && camera_transform.translation.length() > 2.0
+    {
+        -time.delta_seconds()
+    } else {
+        0.0
+    };
 
     camera_transform.translation *= distance_change.exp();
 
diff --git a/examples/3d/wireframe.rs b/examples/3d/wireframe.rs
index f21d74fe44966a..57dddadff478d2 100644
--- a/examples/3d/wireframe.rs
+++ b/examples/3d/wireframe.rs
@@ -121,7 +121,7 @@ fn setup(
 
 /// This system let's you toggle various wireframe settings
 fn update_colors(
-    keyboard_input: Res<ButtonInput<KeyCode>>,
+    keyboard_input: Res<ButtonInput<PhysicalKeyCode>>,
     mut config: ResMut<WireframeConfig>,
     mut wireframe_colors: Query<&mut WireframeColor>,
     mut text: Query<&mut Text>,
@@ -143,12 +143,12 @@ Color: {:?}
     );
 
     // Toggle showing a wireframe on all meshes
-    if keyboard_input.just_pressed(KeyCode::KeyZ) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::KeyZ) {
         config.global = !config.global;
     }
 
     // Toggle the global wireframe color
-    if keyboard_input.just_pressed(KeyCode::KeyX) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::KeyX) {
         config.default_color = if config.default_color == Color::WHITE {
             Color::PINK
         } else {
@@ -157,7 +157,7 @@ Color: {:?}
     }
 
     // Toggle the color of a wireframe using WireframeColor and not the global color
-    if keyboard_input.just_pressed(KeyCode::KeyC) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::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 64c07149c87a4e..0a8959f8c93440 100644
--- a/examples/animation/animated_fox.rs
+++ b/examples/animation/animated_fox.rs
@@ -93,13 +93,13 @@ fn setup_scene_once_loaded(
 }
 
 fn keyboard_animation_control(
-    keyboard_input: Res<ButtonInput<KeyCode>>,
+    keyboard_input: Res<ButtonInput<PhysicalKeyCode>>,
     mut animation_players: Query<&mut AnimationPlayer>,
     animations: Res<Animations>,
     mut current_animation: Local<usize>,
 ) {
     for mut player in &mut animation_players {
-        if keyboard_input.just_pressed(KeyCode::Space) {
+        if keyboard_input.just_pressed(PhysicalKeyCode::Space) {
             if player.is_paused() {
                 player.resume();
             } else {
@@ -107,27 +107,27 @@ fn keyboard_animation_control(
             }
         }
 
-        if keyboard_input.just_pressed(KeyCode::ArrowUp) {
+        if keyboard_input.just_pressed(PhysicalKeyCode::ArrowUp) {
             let speed = player.speed();
             player.set_speed(speed * 1.2);
         }
 
-        if keyboard_input.just_pressed(KeyCode::ArrowDown) {
+        if keyboard_input.just_pressed(PhysicalKeyCode::ArrowDown) {
             let speed = player.speed();
             player.set_speed(speed * 0.8);
         }
 
-        if keyboard_input.just_pressed(KeyCode::ArrowLeft) {
+        if keyboard_input.just_pressed(PhysicalKeyCode::ArrowLeft) {
             let elapsed = player.seek_time();
             player.seek_to(elapsed - 0.1);
         }
 
-        if keyboard_input.just_pressed(KeyCode::ArrowRight) {
+        if keyboard_input.just_pressed(PhysicalKeyCode::ArrowRight) {
             let elapsed = player.seek_time();
             player.seek_to(elapsed + 0.1);
         }
 
-        if keyboard_input.just_pressed(KeyCode::Enter) {
+        if keyboard_input.just_pressed(PhysicalKeyCode::Enter) {
             *current_animation = (*current_animation + 1) % animations.0.len();
             player
                 .play_with_transition(
@@ -137,22 +137,22 @@ fn keyboard_animation_control(
                 .repeat();
         }
 
-        if keyboard_input.just_pressed(KeyCode::Digit1) {
+        if keyboard_input.just_pressed(PhysicalKeyCode::Digit1) {
             player.set_repeat(RepeatAnimation::Count(1));
             player.replay();
         }
 
-        if keyboard_input.just_pressed(KeyCode::Digit3) {
+        if keyboard_input.just_pressed(PhysicalKeyCode::Digit3) {
             player.set_repeat(RepeatAnimation::Count(3));
             player.replay();
         }
 
-        if keyboard_input.just_pressed(KeyCode::Digit5) {
+        if keyboard_input.just_pressed(PhysicalKeyCode::Digit5) {
             player.set_repeat(RepeatAnimation::Count(5));
             player.replay();
         }
 
-        if keyboard_input.just_pressed(KeyCode::KeyL) {
+        if keyboard_input.just_pressed(PhysicalKeyCode::KeyL) {
             player.set_repeat(RepeatAnimation::Forever);
         }
     }
diff --git a/examples/app/logs.rs b/examples/app/logs.rs
index 851d55a2ab6873..8ff80d8c8ab3a2 100644
--- a/examples/app/logs.rs
+++ b/examples/app/logs.rs
@@ -32,8 +32,8 @@ fn setup(mut commands: Commands) {
     });
 }
 
-fn panic_on_p(keys: Res<ButtonInput<KeyCode>>) {
-    if keys.just_pressed(KeyCode::KeyP) {
+fn panic_on_p(keys: Res<ButtonInput<PhysicalKeyCode>>) {
+    if keys.just_pressed(PhysicalKeyCode::KeyP) {
         panic!("P pressed, panicking");
     }
 }
diff --git a/examples/audio/audio_control.rs b/examples/audio/audio_control.rs
index 9e882cc012a2ec..c58bcaa22beb1e 100644
--- a/examples/audio/audio_control.rs
+++ b/examples/audio/audio_control.rs
@@ -30,10 +30,10 @@ fn update_speed(music_controller: Query<&AudioSink, With<MyMusic>>, time: Res<Ti
 }
 
 fn pause(
-    keyboard_input: Res<ButtonInput<KeyCode>>,
+    keyboard_input: Res<ButtonInput<PhysicalKeyCode>>,
     music_controller: Query<&AudioSink, With<MyMusic>>,
 ) {
-    if keyboard_input.just_pressed(KeyCode::Space) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::Space) {
         if let Ok(sink) = music_controller.get_single() {
             sink.toggle();
         }
@@ -41,13 +41,13 @@ fn pause(
 }
 
 fn volume(
-    keyboard_input: Res<ButtonInput<KeyCode>>,
+    keyboard_input: Res<ButtonInput<PhysicalKeyCode>>,
     music_controller: Query<&AudioSink, With<MyMusic>>,
 ) {
     if let Ok(sink) = music_controller.get_single() {
-        if keyboard_input.just_pressed(KeyCode::Equal) {
+        if keyboard_input.just_pressed(PhysicalKeyCode::Equal) {
             sink.set_volume(sink.volume() + 0.1);
-        } else if keyboard_input.just_pressed(KeyCode::Minus) {
+        } else if keyboard_input.just_pressed(PhysicalKeyCode::Minus) {
             sink.set_volume(sink.volume() - 0.1);
         }
     }
diff --git a/examples/audio/pitch.rs b/examples/audio/pitch.rs
index dafe30a3b98dd1..cefc93b484d76e 100644
--- a/examples/audio/pitch.rs
+++ b/examples/audio/pitch.rs
@@ -39,17 +39,17 @@ fn play_pitch(
 }
 
 fn keyboard_input_system(
-    keyboard_input: Res<ButtonInput<KeyCode>>,
+    keyboard_input: Res<ButtonInput<PhysicalKeyCode>>,
     mut frequency: ResMut<PitchFrequency>,
     mut events: EventWriter<PlayPitch>,
 ) {
-    if keyboard_input.just_pressed(KeyCode::ArrowUp) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::ArrowUp) {
         frequency.0 *= 2.0f32.powf(1.0 / 12.0);
     }
-    if keyboard_input.just_pressed(KeyCode::ArrowDown) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::ArrowDown) {
         frequency.0 /= 2.0f32.powf(1.0 / 12.0);
     }
-    if keyboard_input.just_pressed(KeyCode::Space) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::Space) {
         events.send(PlayPitch);
     }
 }
diff --git a/examples/audio/spatial_audio_2d.rs b/examples/audio/spatial_audio_2d.rs
index 79018311eb5674..0492256dcc6448 100644
--- a/examples/audio/spatial_audio_2d.rs
+++ b/examples/audio/spatial_audio_2d.rs
@@ -102,10 +102,10 @@ struct Emitter {
 fn update_emitters(
     time: Res<Time>,
     mut emitters: Query<(&mut Transform, &mut Emitter), With<Emitter>>,
-    keyboard: Res<ButtonInput<KeyCode>>,
+    keyboard: Res<ButtonInput<PhysicalKeyCode>>,
 ) {
     for (mut emitter_transform, mut emitter) in emitters.iter_mut() {
-        if keyboard.just_pressed(KeyCode::Space) {
+        if keyboard.just_pressed(PhysicalKeyCode::Space) {
             emitter.stopped = !emitter.stopped;
         }
 
@@ -116,7 +116,7 @@ fn update_emitters(
 }
 
 fn update_listener(
-    keyboard: Res<ButtonInput<KeyCode>>,
+    keyboard: Res<ButtonInput<PhysicalKeyCode>>,
     time: Res<Time>,
     mut listeners: Query<&mut Transform, With<SpatialListener>>,
 ) {
@@ -124,16 +124,16 @@ fn update_listener(
 
     let speed = 200.;
 
-    if keyboard.pressed(KeyCode::ArrowRight) {
+    if keyboard.pressed(PhysicalKeyCode::ArrowRight) {
         transform.translation.x += speed * time.delta_seconds();
     }
-    if keyboard.pressed(KeyCode::ArrowLeft) {
+    if keyboard.pressed(PhysicalKeyCode::ArrowLeft) {
         transform.translation.x -= speed * time.delta_seconds();
     }
-    if keyboard.pressed(KeyCode::ArrowUp) {
+    if keyboard.pressed(PhysicalKeyCode::ArrowUp) {
         transform.translation.y += speed * time.delta_seconds();
     }
-    if keyboard.pressed(KeyCode::ArrowDown) {
+    if keyboard.pressed(PhysicalKeyCode::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 6c1e6c829e4355..176549bea4f318 100644
--- a/examples/audio/spatial_audio_3d.rs
+++ b/examples/audio/spatial_audio_3d.rs
@@ -101,10 +101,10 @@ struct Emitter {
 fn update_positions(
     time: Res<Time>,
     mut emitters: Query<(&mut Transform, &mut Emitter), With<Emitter>>,
-    keyboard: Res<ButtonInput<KeyCode>>,
+    keyboard: Res<ButtonInput<PhysicalKeyCode>>,
 ) {
     for (mut emitter_transform, mut emitter) in emitters.iter_mut() {
-        if keyboard.just_pressed(KeyCode::Space) {
+        if keyboard.just_pressed(PhysicalKeyCode::Space) {
             emitter.stopped = !emitter.stopped;
         }
 
@@ -116,7 +116,7 @@ fn update_positions(
 }
 
 fn update_listener(
-    keyboard: Res<ButtonInput<KeyCode>>,
+    keyboard: Res<ButtonInput<PhysicalKeyCode>>,
     time: Res<Time>,
     mut listeners: Query<&mut Transform, With<SpatialListener>>,
 ) {
@@ -124,16 +124,16 @@ fn update_listener(
 
     let speed = 2.;
 
-    if keyboard.pressed(KeyCode::ArrowRight) {
+    if keyboard.pressed(PhysicalKeyCode::ArrowRight) {
         transform.translation.x += speed * time.delta_seconds();
     }
-    if keyboard.pressed(KeyCode::ArrowLeft) {
+    if keyboard.pressed(PhysicalKeyCode::ArrowLeft) {
         transform.translation.x -= speed * time.delta_seconds();
     }
-    if keyboard.pressed(KeyCode::ArrowDown) {
+    if keyboard.pressed(PhysicalKeyCode::ArrowDown) {
         transform.translation.z += speed * time.delta_seconds();
     }
-    if keyboard.pressed(KeyCode::ArrowUp) {
+    if keyboard.pressed(PhysicalKeyCode::ArrowUp) {
         transform.translation.z -= speed * time.delta_seconds();
     }
 }
diff --git a/examples/ecs/generic_system.rs b/examples/ecs/generic_system.rs
index dbd5b63432b3a0..bce06dafa480a6 100644
--- a/examples/ecs/generic_system.rs
+++ b/examples/ecs/generic_system.rs
@@ -73,9 +73,9 @@ 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<ButtonInput<KeyCode>>,
+    keyboard_input: Res<ButtonInput<PhysicalKeyCode>>,
 ) {
-    if keyboard_input.pressed(KeyCode::Space) {
+    if keyboard_input.pressed(PhysicalKeyCode::Space) {
         next_state.set(AppState::InGame);
     }
 }
diff --git a/examples/ecs/run_conditions.rs b/examples/ecs/run_conditions.rs
index b2fbea9176ea58..fac125eed2fb7c 100644
--- a/examples/ecs/run_conditions.rs
+++ b/examples/ecs/run_conditions.rs
@@ -64,12 +64,12 @@ 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<ButtonInput<KeyCode>>,
+    keyboard_input: Res<ButtonInput<PhysicalKeyCode>>,
     mouse_button_input: Res<ButtonInput<MouseButton>>,
     touch_input: Res<Touches>,
 ) -> bool {
-    keyboard_input.just_pressed(KeyCode::Space)
-        || keyboard_input.just_pressed(KeyCode::Enter)
+    keyboard_input.just_pressed(PhysicalKeyCode::Space)
+        || keyboard_input.just_pressed(PhysicalKeyCode::Enter)
         || mouse_button_input.just_pressed(MouseButton::Left)
         || mouse_button_input.just_pressed(MouseButton::Right)
         || touch_input.any_just_pressed()
diff --git a/examples/ecs/state.rs b/examples/ecs/state.rs
index a1632c4c3352da..4730041423b38d 100644
--- a/examples/ecs/state.rs
+++ b/examples/ecs/state.rs
@@ -129,21 +129,21 @@ fn setup_game(mut commands: Commands, asset_server: Res<AssetServer>) {
 const SPEED: f32 = 100.0;
 fn movement(
     time: Res<Time>,
-    input: Res<ButtonInput<KeyCode>>,
+    input: Res<ButtonInput<PhysicalKeyCode>>,
     mut query: Query<&mut Transform, With<Sprite>>,
 ) {
     for mut transform in &mut query {
         let mut direction = Vec3::ZERO;
-        if input.pressed(KeyCode::ArrowLeft) {
+        if input.pressed(PhysicalKeyCode::ArrowLeft) {
             direction.x -= 1.0;
         }
-        if input.pressed(KeyCode::ArrowRight) {
+        if input.pressed(PhysicalKeyCode::ArrowRight) {
             direction.x += 1.0;
         }
-        if input.pressed(KeyCode::ArrowUp) {
+        if input.pressed(PhysicalKeyCode::ArrowUp) {
             direction.y += 1.0;
         }
-        if input.pressed(KeyCode::ArrowDown) {
+        if input.pressed(PhysicalKeyCode::ArrowDown) {
             direction.y -= 1.0;
         }
 
diff --git a/examples/games/alien_cake_addict.rs b/examples/games/alien_cake_addict.rs
index b771380c2f80ea..8d8ed6f12d8c17 100644
--- a/examples/games/alien_cake_addict.rs
+++ b/examples/games/alien_cake_addict.rs
@@ -192,7 +192,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<ButtonInput<KeyCode>>,
+    keyboard_input: Res<ButtonInput<PhysicalKeyCode>>,
     mut game: ResMut<Game>,
     mut transforms: Query<&mut Transform>,
     time: Res<Time>,
@@ -201,28 +201,28 @@ fn move_player(
         let mut moved = false;
         let mut rotation = 0.0;
 
-        if keyboard_input.pressed(KeyCode::ArrowUp) {
+        if keyboard_input.pressed(PhysicalKeyCode::ArrowUp) {
             if game.player.i < BOARD_SIZE_I - 1 {
                 game.player.i += 1;
             }
             rotation = -PI / 2.;
             moved = true;
         }
-        if keyboard_input.pressed(KeyCode::ArrowDown) {
+        if keyboard_input.pressed(PhysicalKeyCode::ArrowDown) {
             if game.player.i > 0 {
                 game.player.i -= 1;
             }
             rotation = PI / 2.;
             moved = true;
         }
-        if keyboard_input.pressed(KeyCode::ArrowRight) {
+        if keyboard_input.pressed(PhysicalKeyCode::ArrowRight) {
             if game.player.j < BOARD_SIZE_J - 1 {
                 game.player.j += 1;
             }
             rotation = PI;
             moved = true;
         }
-        if keyboard_input.pressed(KeyCode::ArrowLeft) {
+        if keyboard_input.pressed(PhysicalKeyCode::ArrowLeft) {
             if game.player.j > 0 {
                 game.player.j -= 1;
             }
@@ -376,9 +376,9 @@ 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<ButtonInput<KeyCode>>,
+    keyboard_input: Res<ButtonInput<PhysicalKeyCode>>,
 ) {
-    if keyboard_input.just_pressed(KeyCode::Space) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::Space) {
         next_state.set(GameState::Playing);
     }
 }
diff --git a/examples/games/breakout.rs b/examples/games/breakout.rs
index bcc2ff8b2d72ac..de77e591696e4f 100644
--- a/examples/games/breakout.rs
+++ b/examples/games/breakout.rs
@@ -316,18 +316,18 @@ fn setup(
 }
 
 fn move_paddle(
-    keyboard_input: Res<ButtonInput<KeyCode>>,
+    keyboard_input: Res<ButtonInput<PhysicalKeyCode>>,
     mut query: Query<&mut Transform, With<Paddle>>,
     time: Res<Time>,
 ) {
     let mut paddle_transform = query.single_mut();
     let mut direction = 0.0;
 
-    if keyboard_input.pressed(KeyCode::ArrowLeft) {
+    if keyboard_input.pressed(PhysicalKeyCode::ArrowLeft) {
         direction -= 1.0;
     }
 
-    if keyboard_input.pressed(KeyCode::ArrowRight) {
+    if keyboard_input.pressed(PhysicalKeyCode::ArrowRight) {
         direction += 1.0;
     }
 
diff --git a/examples/games/stepping.rs b/examples/games/stepping.rs
index 7ebe5faf6f275c..697e8f03997f13 100644
--- a/examples/games/stepping.rs
+++ b/examples/games/stepping.rs
@@ -200,12 +200,12 @@ fn build_help(mut commands: Commands, asset_server: Res<AssetServer>) {
     }),));
 }
 
-fn handle_input(keyboard_input: Res<ButtonInput<KeyCode>>, mut stepping: ResMut<Stepping>) {
-    if keyboard_input.just_pressed(KeyCode::Slash) {
+fn handle_input(keyboard_input: Res<ButtonInput<PhysicalKeyCode>>, mut stepping: ResMut<Stepping>) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::Slash) {
         info!("{:#?}", stepping);
     }
     // grave key to toggle stepping mode for the FixedUpdate schedule
-    if keyboard_input.just_pressed(KeyCode::Backquote) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::Backquote) {
         if stepping.is_enabled() {
             stepping.disable();
             debug!("disabled stepping");
@@ -220,10 +220,10 @@ fn handle_input(keyboard_input: Res<ButtonInput<KeyCode>>, mut stepping: ResMut<
     }
 
     // space key will step the remainder of this frame
-    if keyboard_input.just_pressed(KeyCode::Space) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::Space) {
         debug!("continue");
         stepping.continue_frame();
-    } else if keyboard_input.just_pressed(KeyCode::KeyS) {
+    } else if keyboard_input.just_pressed(PhysicalKeyCode::KeyS) {
         debug!("stepping frame");
         stepping.step_frame();
     }
diff --git a/examples/helpers/camera_controller.rs b/examples/helpers/camera_controller.rs
index 43ea5424747617..265e2caf9e6f32 100644
--- a/examples/helpers/camera_controller.rs
+++ b/examples/helpers/camera_controller.rs
@@ -26,15 +26,15 @@ pub struct CameraController {
     pub enabled: bool,
     pub initialized: bool,
     pub sensitivity: f32,
-    pub key_forward: KeyCode,
-    pub key_back: KeyCode,
-    pub key_left: KeyCode,
-    pub key_right: KeyCode,
-    pub key_up: KeyCode,
-    pub key_down: KeyCode,
-    pub key_run: KeyCode,
+    pub key_forward: PhysicalKeyCode,
+    pub key_back: PhysicalKeyCode,
+    pub key_left: PhysicalKeyCode,
+    pub key_right: PhysicalKeyCode,
+    pub key_up: PhysicalKeyCode,
+    pub key_down: PhysicalKeyCode,
+    pub key_run: PhysicalKeyCode,
     pub mouse_key_cursor_grab: MouseButton,
-    pub keyboard_key_toggle_cursor_grab: KeyCode,
+    pub keyboard_key_toggle_cursor_grab: PhysicalKeyCode,
     pub walk_speed: f32,
     pub run_speed: f32,
     pub friction: f32,
@@ -49,15 +49,15 @@ impl Default for CameraController {
             enabled: true,
             initialized: false,
             sensitivity: 1.0,
-            key_forward: KeyCode::KeyW,
-            key_back: KeyCode::KeyS,
-            key_left: KeyCode::KeyA,
-            key_right: KeyCode::KeyD,
-            key_up: KeyCode::KeyE,
-            key_down: KeyCode::KeyQ,
-            key_run: KeyCode::ShiftLeft,
+            key_forward: PhysicalKeyCode::KeyW,
+            key_back: PhysicalKeyCode::KeyS,
+            key_left: PhysicalKeyCode::KeyA,
+            key_right: PhysicalKeyCode::KeyD,
+            key_up: PhysicalKeyCode::KeyE,
+            key_down: PhysicalKeyCode::KeyQ,
+            key_run: PhysicalKeyCode::ShiftLeft,
             mouse_key_cursor_grab: MouseButton::Left,
-            keyboard_key_toggle_cursor_grab: KeyCode::KeyM,
+            keyboard_key_toggle_cursor_grab: PhysicalKeyCode::KeyM,
             walk_speed: 5.0,
             run_speed: 15.0,
             friction: 0.5,
@@ -100,7 +100,7 @@ fn run_camera_controller(
     mut windows: Query<&mut Window>,
     mut mouse_events: EventReader<MouseMotion>,
     mouse_button_input: Res<ButtonInput<MouseButton>>,
-    key_input: Res<ButtonInput<KeyCode>>,
+    key_input: Res<ButtonInput<PhysicalKeyCode>>,
     mut toggle_cursor_grab: Local<bool>,
     mut mouse_cursor_grab: Local<bool>,
     mut query: Query<(&mut Transform, &mut CameraController), With<Camera>>,
diff --git a/examples/input/keyboard_input.rs b/examples/input/keyboard_input.rs
index ec9b97973eede7..bab2568f73aea3 100644
--- a/examples/input/keyboard_input.rs
+++ b/examples/input/keyboard_input.rs
@@ -10,15 +10,15 @@ fn main() {
 }
 
 /// This system prints 'A' key state
-fn keyboard_input_system(keyboard_input: Res<ButtonInput<KeyCode>>) {
-    if keyboard_input.pressed(KeyCode::KeyA) {
+fn keyboard_input_system(keyboard_input: Res<ButtonInput<PhysicalKeyCode>>) {
+    if keyboard_input.pressed(PhysicalKeyCode::KeyA) {
         info!("'A' currently pressed");
     }
 
-    if keyboard_input.just_pressed(KeyCode::KeyA) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::KeyA) {
         info!("'A' just pressed");
     }
-    if keyboard_input.just_released(KeyCode::KeyA) {
+    if keyboard_input.just_released(PhysicalKeyCode::KeyA) {
         info!("'A' just released");
     }
 }
diff --git a/examples/input/keyboard_modifiers.rs b/examples/input/keyboard_modifiers.rs
index 1f7d3bb0188760..784d5ab0b52026 100644
--- a/examples/input/keyboard_modifiers.rs
+++ b/examples/input/keyboard_modifiers.rs
@@ -10,11 +10,11 @@ fn main() {
 }
 
 /// This system prints when `Ctrl + Shift + A` is pressed
-fn keyboard_input_system(input: Res<ButtonInput<KeyCode>>) {
-    let shift = input.any_pressed([KeyCode::ShiftLeft, KeyCode::ShiftRight]);
-    let ctrl = input.any_pressed([KeyCode::ControlLeft, KeyCode::ControlRight]);
+fn keyboard_input_system(input: Res<ButtonInput<PhysicalKeyCode>>) {
+    let shift = input.any_pressed([PhysicalKeyCode::ShiftLeft, PhysicalKeyCode::ShiftRight]);
+    let ctrl = input.any_pressed([PhysicalKeyCode::ControlLeft, PhysicalKeyCode::ControlRight]);
 
-    if ctrl && shift && input.just_pressed(KeyCode::KeyA) {
+    if ctrl && shift && input.just_pressed(PhysicalKeyCode::KeyA) {
         info!("Just pressed Ctrl + Shift + A!");
     }
 }
diff --git a/examples/input/mouse_grab.rs b/examples/input/mouse_grab.rs
index a812f37f67755f..e52a81e30111ec 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<ButtonInput<MouseButton>>,
-    key: Res<ButtonInput<KeyCode>>,
+    key: Res<ButtonInput<PhysicalKeyCode>>,
 ) {
     let mut window = windows.single_mut();
 
@@ -23,7 +23,7 @@ fn grab_mouse(
         window.cursor.grab_mode = CursorGrabMode::Locked;
     }
 
-    if key.just_pressed(KeyCode::Escape) {
+    if key.just_pressed(PhysicalKeyCode::Escape) {
         window.cursor.visible = true;
         window.cursor.grab_mode = CursorGrabMode::None;
     }
diff --git a/examples/input/text_input.rs b/examples/input/text_input.rs
index a8e86726dccb5b..0e096707ee9fce 100644
--- a/examples/input/text_input.rs
+++ b/examples/input/text_input.rs
@@ -182,7 +182,7 @@ fn listen_keyboard_input_events(
 ) {
     for event in events.read() {
         match event.key_code {
-            KeyCode::Enter => {
+            PhysicalKeyCode::Enter => {
                 let (entity, text) = edit_text.single();
                 commands.entity(entity).insert(Bubble {
                     timer: Timer::from_seconds(5.0, TimerMode::Once),
@@ -193,7 +193,7 @@ fn listen_keyboard_input_events(
                     ..default()
                 });
             }
-            KeyCode::Backspace => {
+            PhysicalKeyCode::Backspace => {
                 edit_text.single_mut().1.sections[0].value.pop();
             }
             _ => continue,
diff --git a/examples/shader/shader_prepass.rs b/examples/shader/shader_prepass.rs
index 5234dfe3ca3b0b..c76754cba7c095 100644
--- a/examples/shader/shader_prepass.rs
+++ b/examples/shader/shader_prepass.rs
@@ -224,12 +224,12 @@ 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<ButtonInput<KeyCode>>,
+    keycode: Res<ButtonInput<PhysicalKeyCode>>,
     material_handle: Query<&Handle<PrepassOutputMaterial>>,
     mut materials: ResMut<Assets<PrepassOutputMaterial>>,
     mut text: Query<&mut Text>,
 ) {
-    if keycode.just_pressed(KeyCode::Space) {
+    if keycode.just_pressed(PhysicalKeyCode::Space) {
         *prepass_view = (*prepass_view + 1) % 4;
 
         let label = match *prepass_view {
diff --git a/examples/stress_tests/many_foxes.rs b/examples/stress_tests/many_foxes.rs
index c0e1856d68b806..516119b7cb22d3 100644
--- a/examples/stress_tests/many_foxes.rs
+++ b/examples/stress_tests/many_foxes.rs
@@ -258,30 +258,30 @@ fn update_fox_rings(
 }
 
 fn keyboard_animation_control(
-    keyboard_input: Res<ButtonInput<KeyCode>>,
+    keyboard_input: Res<ButtonInput<PhysicalKeyCode>>,
     mut animation_player: Query<&mut AnimationPlayer>,
     animations: Res<Animations>,
     mut current_animation: Local<usize>,
     mut foxes: ResMut<Foxes>,
 ) {
-    if keyboard_input.just_pressed(KeyCode::Space) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::Space) {
         foxes.moving = !foxes.moving;
     }
 
-    if keyboard_input.just_pressed(KeyCode::ArrowUp) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::ArrowUp) {
         foxes.speed *= 1.25;
     }
 
-    if keyboard_input.just_pressed(KeyCode::ArrowDown) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::ArrowDown) {
         foxes.speed *= 0.8;
     }
 
-    if keyboard_input.just_pressed(KeyCode::Enter) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::Enter) {
         *current_animation = (*current_animation + 1) % animations.0.len();
     }
 
     for mut player in &mut animation_player {
-        if keyboard_input.just_pressed(KeyCode::Space) {
+        if keyboard_input.just_pressed(PhysicalKeyCode::Space) {
             if player.is_paused() {
                 player.resume();
             } else {
@@ -289,27 +289,27 @@ fn keyboard_animation_control(
             }
         }
 
-        if keyboard_input.just_pressed(KeyCode::ArrowUp) {
+        if keyboard_input.just_pressed(PhysicalKeyCode::ArrowUp) {
             let speed = player.speed();
             player.set_speed(speed * 1.25);
         }
 
-        if keyboard_input.just_pressed(KeyCode::ArrowDown) {
+        if keyboard_input.just_pressed(PhysicalKeyCode::ArrowDown) {
             let speed = player.speed();
             player.set_speed(speed * 0.8);
         }
 
-        if keyboard_input.just_pressed(KeyCode::ArrowLeft) {
+        if keyboard_input.just_pressed(PhysicalKeyCode::ArrowLeft) {
             let elapsed = player.seek_time();
             player.seek_to(elapsed - 0.1);
         }
 
-        if keyboard_input.just_pressed(KeyCode::ArrowRight) {
+        if keyboard_input.just_pressed(PhysicalKeyCode::ArrowRight) {
             let elapsed = player.seek_time();
             player.seek_to(elapsed + 0.1);
         }
 
-        if keyboard_input.just_pressed(KeyCode::Enter) {
+        if keyboard_input.just_pressed(PhysicalKeyCode::Enter) {
             player
                 .play_with_transition(
                     animations.0[*current_animation].clone_weak(),
diff --git a/examples/stress_tests/many_gizmos.rs b/examples/stress_tests/many_gizmos.rs
index 88ba0aeaa5fed6..bad01543b9a1bf 100644
--- a/examples/stress_tests/many_gizmos.rs
+++ b/examples/stress_tests/many_gizmos.rs
@@ -49,14 +49,14 @@ struct Config {
     fancy: bool,
 }
 
-fn input(mut config: ResMut<Config>, input: Res<ButtonInput<KeyCode>>) {
-    if input.just_pressed(KeyCode::ArrowUp) {
+fn input(mut config: ResMut<Config>, input: Res<ButtonInput<PhysicalKeyCode>>) {
+    if input.just_pressed(PhysicalKeyCode::ArrowUp) {
         config.line_count += 10_000;
     }
-    if input.just_pressed(KeyCode::ArrowDown) {
+    if input.just_pressed(PhysicalKeyCode::ArrowDown) {
         config.line_count = config.line_count.saturating_sub(10_000);
     }
-    if input.just_pressed(KeyCode::Space) {
+    if input.just_pressed(PhysicalKeyCode::Space) {
         config.fancy = !config.fancy;
     }
 }
diff --git a/examples/time/virtual_time.rs b/examples/time/virtual_time.rs
index 30c46cff8f43ab..a8cd9b940c90c1 100644
--- a/examples/time/virtual_time.rs
+++ b/examples/time/virtual_time.rs
@@ -17,9 +17,9 @@ 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::ArrowUp)),
-                change_time_speed::<-1>.run_if(input_just_pressed(KeyCode::ArrowDown)),
+                toggle_pause.run_if(input_just_pressed(PhysicalKeyCode::Space)),
+                change_time_speed::<1>.run_if(input_just_pressed(PhysicalKeyCode::ArrowUp)),
+                change_time_speed::<-1>.run_if(input_just_pressed(PhysicalKeyCode::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 ac5c2fdbaee92f..aff60be026c0be 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<ButtonInput<KeyCode>>,
+    keyboard_input: Res<ButtonInput<PhysicalKeyCode>>,
     mut animation_player: Query<(&mut AnimationPlayer, &mut Clips, Entity, Option<&Name>)>,
 ) {
     for (mut player, mut clips, entity, name) in &mut animation_player {
@@ -74,7 +74,7 @@ fn handle_inputs(
             Some(name) => name.to_string(),
             None => format!("entity {entity:?}"),
         };
-        if keyboard_input.just_pressed(KeyCode::Space) {
+        if keyboard_input.just_pressed(PhysicalKeyCode::Space) {
             if player.is_paused() {
                 info!("resuming animation for {display_entity_name}");
                 player.resume();
@@ -87,7 +87,7 @@ fn handle_inputs(
             continue;
         }
 
-        if keyboard_input.just_pressed(KeyCode::Enter) {
+        if keyboard_input.just_pressed(PhysicalKeyCode::Enter) {
             info!("switching to new animation for {display_entity_name}");
 
             let resume = !player.is_paused();
diff --git a/examples/tools/scene_viewer/morph_viewer_plugin.rs b/examples/tools/scene_viewer/morph_viewer_plugin.rs
index 0608a049f8a447..4ec2213c4c2eb4 100644
--- a/examples/tools/scene_viewer/morph_viewer_plugin.rs
+++ b/examples/tools/scene_viewer/morph_viewer_plugin.rs
@@ -13,64 +13,180 @@ use bevy::prelude::*;
 use std::fmt;
 
 const WEIGHT_PER_SECOND: f32 = 0.8;
-const ALL_MODIFIERS: &[KeyCode] = &[KeyCode::ShiftLeft, KeyCode::ControlLeft, KeyCode::AltLeft];
+const ALL_MODIFIERS: &[PhysicalKeyCode] = &[
+    PhysicalKeyCode::ShiftLeft,
+    PhysicalKeyCode::ControlLeft,
+    PhysicalKeyCode::AltLeft,
+];
 const AVAILABLE_KEYS: [MorphKey; 56] = [
-    MorphKey::new("r", &[], KeyCode::KeyR),
-    MorphKey::new("t", &[], KeyCode::KeyT),
-    MorphKey::new("z", &[], KeyCode::KeyZ),
-    MorphKey::new("i", &[], KeyCode::KeyI),
-    MorphKey::new("o", &[], KeyCode::KeyO),
-    MorphKey::new("p", &[], KeyCode::KeyP),
-    MorphKey::new("f", &[], KeyCode::KeyF),
-    MorphKey::new("g", &[], KeyCode::KeyG),
-    MorphKey::new("h", &[], KeyCode::KeyH),
-    MorphKey::new("j", &[], KeyCode::KeyJ),
-    MorphKey::new("k", &[], KeyCode::KeyK),
-    MorphKey::new("y", &[], KeyCode::KeyY),
-    MorphKey::new("x", &[], KeyCode::KeyX),
-    MorphKey::new("c", &[], KeyCode::KeyC),
-    MorphKey::new("v", &[], KeyCode::KeyV),
-    MorphKey::new("b", &[], KeyCode::KeyB),
-    MorphKey::new("n", &[], KeyCode::KeyN),
-    MorphKey::new("m", &[], KeyCode::KeyM),
-    MorphKey::new("0", &[], KeyCode::Digit0),
-    MorphKey::new("1", &[], KeyCode::Digit1),
-    MorphKey::new("2", &[], KeyCode::Digit2),
-    MorphKey::new("3", &[], KeyCode::Digit3),
-    MorphKey::new("4", &[], KeyCode::Digit4),
-    MorphKey::new("5", &[], KeyCode::Digit5),
-    MorphKey::new("6", &[], KeyCode::Digit6),
-    MorphKey::new("7", &[], KeyCode::Digit7),
-    MorphKey::new("8", &[], KeyCode::Digit8),
-    MorphKey::new("9", &[], KeyCode::Digit9),
-    MorphKey::new("lshift-R", &[KeyCode::ShiftLeft], KeyCode::KeyR),
-    MorphKey::new("lshift-T", &[KeyCode::ShiftLeft], KeyCode::KeyT),
-    MorphKey::new("lshift-Z", &[KeyCode::ShiftLeft], KeyCode::KeyZ),
-    MorphKey::new("lshift-I", &[KeyCode::ShiftLeft], KeyCode::KeyI),
-    MorphKey::new("lshift-O", &[KeyCode::ShiftLeft], KeyCode::KeyO),
-    MorphKey::new("lshift-P", &[KeyCode::ShiftLeft], KeyCode::KeyP),
-    MorphKey::new("lshift-F", &[KeyCode::ShiftLeft], KeyCode::KeyF),
-    MorphKey::new("lshift-G", &[KeyCode::ShiftLeft], KeyCode::KeyG),
-    MorphKey::new("lshift-H", &[KeyCode::ShiftLeft], KeyCode::KeyH),
-    MorphKey::new("lshift-J", &[KeyCode::ShiftLeft], KeyCode::KeyJ),
-    MorphKey::new("lshift-K", &[KeyCode::ShiftLeft], KeyCode::KeyK),
-    MorphKey::new("lshift-Y", &[KeyCode::ShiftLeft], KeyCode::KeyY),
-    MorphKey::new("lshift-X", &[KeyCode::ShiftLeft], KeyCode::KeyX),
-    MorphKey::new("lshift-C", &[KeyCode::ShiftLeft], KeyCode::KeyC),
-    MorphKey::new("lshift-V", &[KeyCode::ShiftLeft], KeyCode::KeyV),
-    MorphKey::new("lshift-B", &[KeyCode::ShiftLeft], KeyCode::KeyB),
-    MorphKey::new("lshift-N", &[KeyCode::ShiftLeft], KeyCode::KeyN),
-    MorphKey::new("lshift-M", &[KeyCode::ShiftLeft], KeyCode::KeyM),
-    MorphKey::new("lshift-0", &[KeyCode::ShiftLeft], KeyCode::Digit0),
-    MorphKey::new("lshift-1", &[KeyCode::ShiftLeft], KeyCode::Digit1),
-    MorphKey::new("lshift-2", &[KeyCode::ShiftLeft], KeyCode::Digit2),
-    MorphKey::new("lshift-3", &[KeyCode::ShiftLeft], KeyCode::Digit3),
-    MorphKey::new("lshift-4", &[KeyCode::ShiftLeft], KeyCode::Digit4),
-    MorphKey::new("lshift-5", &[KeyCode::ShiftLeft], KeyCode::Digit5),
-    MorphKey::new("lshift-6", &[KeyCode::ShiftLeft], KeyCode::Digit6),
-    MorphKey::new("lshift-7", &[KeyCode::ShiftLeft], KeyCode::Digit7),
-    MorphKey::new("lshift-8", &[KeyCode::ShiftLeft], KeyCode::Digit8),
-    MorphKey::new("lshift-9", &[KeyCode::ShiftLeft], KeyCode::Digit9),
+    MorphKey::new("r", &[], PhysicalKeyCode::KeyR),
+    MorphKey::new("t", &[], PhysicalKeyCode::KeyT),
+    MorphKey::new("z", &[], PhysicalKeyCode::KeyZ),
+    MorphKey::new("i", &[], PhysicalKeyCode::KeyI),
+    MorphKey::new("o", &[], PhysicalKeyCode::KeyO),
+    MorphKey::new("p", &[], PhysicalKeyCode::KeyP),
+    MorphKey::new("f", &[], PhysicalKeyCode::KeyF),
+    MorphKey::new("g", &[], PhysicalKeyCode::KeyG),
+    MorphKey::new("h", &[], PhysicalKeyCode::KeyH),
+    MorphKey::new("j", &[], PhysicalKeyCode::KeyJ),
+    MorphKey::new("k", &[], PhysicalKeyCode::KeyK),
+    MorphKey::new("y", &[], PhysicalKeyCode::KeyY),
+    MorphKey::new("x", &[], PhysicalKeyCode::KeyX),
+    MorphKey::new("c", &[], PhysicalKeyCode::KeyC),
+    MorphKey::new("v", &[], PhysicalKeyCode::KeyV),
+    MorphKey::new("b", &[], PhysicalKeyCode::KeyB),
+    MorphKey::new("n", &[], PhysicalKeyCode::KeyN),
+    MorphKey::new("m", &[], PhysicalKeyCode::KeyM),
+    MorphKey::new("0", &[], PhysicalKeyCode::Digit0),
+    MorphKey::new("1", &[], PhysicalKeyCode::Digit1),
+    MorphKey::new("2", &[], PhysicalKeyCode::Digit2),
+    MorphKey::new("3", &[], PhysicalKeyCode::Digit3),
+    MorphKey::new("4", &[], PhysicalKeyCode::Digit4),
+    MorphKey::new("5", &[], PhysicalKeyCode::Digit5),
+    MorphKey::new("6", &[], PhysicalKeyCode::Digit6),
+    MorphKey::new("7", &[], PhysicalKeyCode::Digit7),
+    MorphKey::new("8", &[], PhysicalKeyCode::Digit8),
+    MorphKey::new("9", &[], PhysicalKeyCode::Digit9),
+    MorphKey::new(
+        "lshift-R",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::KeyR,
+    ),
+    MorphKey::new(
+        "lshift-T",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::KeyT,
+    ),
+    MorphKey::new(
+        "lshift-Z",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::KeyZ,
+    ),
+    MorphKey::new(
+        "lshift-I",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::KeyI,
+    ),
+    MorphKey::new(
+        "lshift-O",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::KeyO,
+    ),
+    MorphKey::new(
+        "lshift-P",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::KeyP,
+    ),
+    MorphKey::new(
+        "lshift-F",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::KeyF,
+    ),
+    MorphKey::new(
+        "lshift-G",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::KeyG,
+    ),
+    MorphKey::new(
+        "lshift-H",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::KeyH,
+    ),
+    MorphKey::new(
+        "lshift-J",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::KeyJ,
+    ),
+    MorphKey::new(
+        "lshift-K",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::KeyK,
+    ),
+    MorphKey::new(
+        "lshift-Y",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::KeyY,
+    ),
+    MorphKey::new(
+        "lshift-X",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::KeyX,
+    ),
+    MorphKey::new(
+        "lshift-C",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::KeyC,
+    ),
+    MorphKey::new(
+        "lshift-V",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::KeyV,
+    ),
+    MorphKey::new(
+        "lshift-B",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::KeyB,
+    ),
+    MorphKey::new(
+        "lshift-N",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::KeyN,
+    ),
+    MorphKey::new(
+        "lshift-M",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::KeyM,
+    ),
+    MorphKey::new(
+        "lshift-0",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::Digit0,
+    ),
+    MorphKey::new(
+        "lshift-1",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::Digit1,
+    ),
+    MorphKey::new(
+        "lshift-2",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::Digit2,
+    ),
+    MorphKey::new(
+        "lshift-3",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::Digit3,
+    ),
+    MorphKey::new(
+        "lshift-4",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::Digit4,
+    ),
+    MorphKey::new(
+        "lshift-5",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::Digit5,
+    ),
+    MorphKey::new(
+        "lshift-6",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::Digit6,
+    ),
+    MorphKey::new(
+        "lshift-7",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::Digit7,
+    ),
+    MorphKey::new(
+        "lshift-8",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::Digit8,
+    ),
+    MorphKey::new(
+        "lshift-9",
+        &[PhysicalKeyCode::ShiftLeft],
+        PhysicalKeyCode::Digit9,
+    ),
 ];
 
 #[derive(Clone, Copy)]
@@ -155,18 +271,22 @@ struct WeightsControl {
 
 struct MorphKey {
     name: &'static str,
-    modifiers: &'static [KeyCode],
-    key: KeyCode,
+    modifiers: &'static [PhysicalKeyCode],
+    key: PhysicalKeyCode,
 }
 impl MorphKey {
-    const fn new(name: &'static str, modifiers: &'static [KeyCode], key: KeyCode) -> Self {
+    const fn new(
+        name: &'static str,
+        modifiers: &'static [PhysicalKeyCode],
+        key: PhysicalKeyCode,
+    ) -> Self {
         MorphKey {
             name,
             modifiers,
             key,
         }
     }
-    fn active(&self, inputs: &ButtonInput<KeyCode>) -> bool {
+    fn active(&self, inputs: &ButtonInput<PhysicalKeyCode>) -> bool {
         let mut modifier = self.modifiers.iter();
         let mut non_modifier = ALL_MODIFIERS.iter().filter(|m| !self.modifiers.contains(m));
 
@@ -202,7 +322,7 @@ fn update_text(
 fn update_morphs(
     controls: Option<ResMut<WeightsControl>>,
     mut morphs: Query<&mut MorphWeights>,
-    input: Res<ButtonInput<KeyCode>>,
+    input: Res<ButtonInput<PhysicalKeyCode>>,
     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 2ff6af49489282..c20f156895aa40 100644
--- a/examples/tools/scene_viewer/scene_viewer_plugin.rs
+++ b/examples/tools/scene_viewer/scene_viewer_plugin.rs
@@ -73,7 +73,7 @@ impl Plugin for SceneViewerPlugin {
                 (
                     update_lights,
                     camera_tracker,
-                    toggle_bounding_boxes.run_if(input_just_pressed(KeyCode::KeyB)),
+                    toggle_bounding_boxes.run_if(input_just_pressed(PhysicalKeyCode::KeyB)),
                 ),
             );
     }
@@ -141,18 +141,18 @@ fn scene_load_check(
 }
 
 fn update_lights(
-    key_input: Res<ButtonInput<KeyCode>>,
+    key_input: Res<ButtonInput<PhysicalKeyCode>>,
     time: Res<Time>,
     mut query: Query<(&mut Transform, &mut DirectionalLight)>,
     mut animate_directional_light: Local<bool>,
 ) {
     for (_, mut light) in &mut query {
-        if key_input.just_pressed(KeyCode::KeyU) {
+        if key_input.just_pressed(PhysicalKeyCode::KeyU) {
             light.shadows_enabled = !light.shadows_enabled;
         }
     }
 
-    if key_input.just_pressed(KeyCode::KeyL) {
+    if key_input.just_pressed(PhysicalKeyCode::KeyL) {
         *animate_directional_light = !*animate_directional_light;
     }
     if *animate_directional_light {
@@ -198,7 +198,7 @@ impl CameraTracker {
 
 fn camera_tracker(
     mut camera_tracker: ResMut<CameraTracker>,
-    keyboard_input: Res<ButtonInput<KeyCode>>,
+    keyboard_input: Res<ButtonInput<PhysicalKeyCode>>,
     mut queries: ParamSet<(
         Query<(Entity, &mut Camera), (Added<Camera>, Without<CameraController>)>,
         Query<(Entity, &mut Camera), (Added<Camera>, With<CameraController>)>,
@@ -216,7 +216,7 @@ fn camera_tracker(
         camera.is_active = camera_tracker.track_camera(entity);
     }
 
-    if keyboard_input.just_pressed(KeyCode::KeyC) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::KeyC) {
         // disable currently active camera
         if let Some(e) = camera_tracker.active_camera() {
             if let Ok(mut camera) = queries.p2().get_mut(e) {
diff --git a/examples/ui/overflow_debug.rs b/examples/ui/overflow_debug.rs
index d40a085cf72b67..da2ec79676b667 100644
--- a/examples/ui/overflow_debug.rs
+++ b/examples/ui/overflow_debug.rs
@@ -239,11 +239,11 @@ fn spawn_container(
 fn update_animation(
     mut animation: ResMut<AnimationState>,
     time: Res<Time>,
-    keys: Res<ButtonInput<KeyCode>>,
+    keys: Res<ButtonInput<PhysicalKeyCode>>,
 ) {
     let time = time.elapsed_seconds();
 
-    if keys.just_pressed(KeyCode::Space) {
+    if keys.just_pressed(PhysicalKeyCode::Space) {
         animation.playing = !animation.playing;
 
         if !animation.playing {
@@ -271,10 +271,10 @@ fn update_transform<T: UpdateTransform + Component>(
 }
 
 fn toggle_overflow(
-    keys: Res<ButtonInput<KeyCode>>,
+    keys: Res<ButtonInput<PhysicalKeyCode>>,
     mut containers: Query<&mut Style, With<Container>>,
 ) {
-    if keys.just_pressed(KeyCode::KeyO) {
+    if keys.just_pressed(PhysicalKeyCode::KeyO) {
         for mut style in &mut containers {
             style.overflow = match style.overflow {
                 Overflow {
@@ -296,10 +296,10 @@ fn toggle_overflow(
 }
 
 fn next_container_size(
-    keys: Res<ButtonInput<KeyCode>>,
+    keys: Res<ButtonInput<PhysicalKeyCode>>,
     mut containers: Query<(&mut Style, &mut Container)>,
 ) {
-    if keys.just_pressed(KeyCode::KeyS) {
+    if keys.just_pressed(PhysicalKeyCode::KeyS) {
         for (mut style, mut container) in &mut containers {
             container.0 = (container.0 + 1) % 3;
 
diff --git a/examples/ui/ui_scaling.rs b/examples/ui/ui_scaling.rs
index 9c1beccbcd76a8..67c4f6b3d74314 100644
--- a/examples/ui/ui_scaling.rs
+++ b/examples/ui/ui_scaling.rs
@@ -84,13 +84,13 @@ fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
 }
 
 /// System that changes the scale of the ui when pressing up or down on the keyboard.
-fn change_scaling(input: Res<ButtonInput<KeyCode>>, mut ui_scale: ResMut<TargetScale>) {
-    if input.just_pressed(KeyCode::ArrowUp) {
+fn change_scaling(input: Res<ButtonInput<PhysicalKeyCode>>, mut ui_scale: ResMut<TargetScale>) {
+    if input.just_pressed(PhysicalKeyCode::ArrowUp) {
         let scale = (ui_scale.target_scale * 2.0).min(8.);
         ui_scale.set_scale(scale);
         info!("Scaling up! Scale: {}", ui_scale.target_scale);
     }
-    if input.just_pressed(KeyCode::ArrowDown) {
+    if input.just_pressed(PhysicalKeyCode::ArrowDown) {
         let scale = (ui_scale.target_scale / 2.0).max(1. / 8.);
         ui_scale.set_scale(scale);
         info!("Scaling down! Scale: {}", ui_scale.target_scale);
diff --git a/examples/ui/ui_texture_atlas.rs b/examples/ui/ui_texture_atlas.rs
index 70af3e9743a409..cc1a049f712f02 100644
--- a/examples/ui/ui_texture_atlas.rs
+++ b/examples/ui/ui_texture_atlas.rs
@@ -75,9 +75,9 @@ fn setup(
 
 fn increment_atlas_index(
     mut atlas_images: Query<&mut TextureAtlas>,
-    keyboard: Res<ButtonInput<KeyCode>>,
+    keyboard: Res<ButtonInput<PhysicalKeyCode>>,
 ) {
-    if keyboard.just_pressed(KeyCode::Space) {
+    if keyboard.just_pressed(PhysicalKeyCode::Space) {
         for mut atlas_image in &mut atlas_images {
             atlas_image.index = (atlas_image.index + 1) % 6;
         }
diff --git a/examples/ui/window_fallthrough.rs b/examples/ui/window_fallthrough.rs
index bfe3c6df0c1a43..6c50e029190ba4 100644
--- a/examples/ui/window_fallthrough.rs
+++ b/examples/ui/window_fallthrough.rs
@@ -48,10 +48,10 @@ 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<ButtonInput<KeyCode>>,
+    keyboard_input: Res<ButtonInput<PhysicalKeyCode>>,
     mut windows: Query<&mut Window>,
 ) {
-    if keyboard_input.just_pressed(KeyCode::KeyP) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::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 be75c2bf859001..18892ad18ecca9 100644
--- a/examples/window/clear_color.rs
+++ b/examples/window/clear_color.rs
@@ -17,8 +17,11 @@ fn setup(mut commands: Commands) {
     commands.spawn(Camera2dBundle::default());
 }
 
-fn change_clear_color(input: Res<ButtonInput<KeyCode>>, mut clear_color: ResMut<ClearColor>) {
-    if input.just_pressed(KeyCode::Space) {
+fn change_clear_color(
+    input: Res<ButtonInput<PhysicalKeyCode>>,
+    mut clear_color: ResMut<ClearColor>,
+) {
+    if input.just_pressed(PhysicalKeyCode::Space) {
         clear_color.0 = Color::PURPLE;
     }
 }
diff --git a/examples/window/low_power.rs b/examples/window/low_power.rs
index a496b0170d1597..ba918ecd0793e1 100644
--- a/examples/window/low_power.rs
+++ b/examples/window/low_power.rs
@@ -97,9 +97,9 @@ 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<ButtonInput<KeyCode>>,
+        mouse_button_input: Res<ButtonInput<PhysicalKeyCode>>,
     ) {
-        if mouse_button_input.just_pressed(KeyCode::Space) {
+        if mouse_button_input.just_pressed(PhysicalKeyCode::Space) {
             *mode = match *mode {
                 ExampleMode::Game => ExampleMode::Application,
                 ExampleMode::Application => ExampleMode::ApplicationWithRedraw,
diff --git a/examples/window/scale_factor_override.rs b/examples/window/scale_factor_override.rs
index 78d82a8aa36320..8465674abafbcf 100644
--- a/examples/window/scale_factor_override.rs
+++ b/examples/window/scale_factor_override.rs
@@ -76,10 +76,10 @@ fn display_override(mut windows: Query<&mut Window>) {
 }
 
 /// This system toggles scale factor overrides when enter is pressed
-fn toggle_override(input: Res<ButtonInput<KeyCode>>, mut windows: Query<&mut Window>) {
+fn toggle_override(input: Res<ButtonInput<PhysicalKeyCode>>, mut windows: Query<&mut Window>) {
     let mut window = windows.single_mut();
 
-    if input.just_pressed(KeyCode::Enter) {
+    if input.just_pressed(PhysicalKeyCode::Enter) {
         let scale_factor_override = window.resolution.scale_factor_override();
         window
             .resolution
@@ -88,14 +88,14 @@ fn toggle_override(input: Res<ButtonInput<KeyCode>>, mut windows: Query<&mut Win
 }
 
 /// This system changes the scale factor override when up or down is pressed
-fn change_scale_factor(input: Res<ButtonInput<KeyCode>>, mut windows: Query<&mut Window>) {
+fn change_scale_factor(input: Res<ButtonInput<PhysicalKeyCode>>, 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) {
+    if input.just_pressed(PhysicalKeyCode::ArrowUp) {
         window
             .resolution
             .set_scale_factor_override(scale_factor_override.map(|n| n + 1.0));
-    } else if input.just_pressed(KeyCode::ArrowDown) {
+    } else if input.just_pressed(PhysicalKeyCode::ArrowDown) {
         window
             .resolution
             .set_scale_factor_override(scale_factor_override.map(|n| (n - 1.0).max(1.0)));
diff --git a/examples/window/screenshot.rs b/examples/window/screenshot.rs
index 2647d083374c3c..376a8f9d9eb9e6 100644
--- a/examples/window/screenshot.rs
+++ b/examples/window/screenshot.rs
@@ -13,12 +13,12 @@ fn main() {
 }
 
 fn screenshot_on_spacebar(
-    input: Res<ButtonInput<KeyCode>>,
+    input: Res<ButtonInput<PhysicalKeyCode>>,
     main_window: Query<Entity, With<PrimaryWindow>>,
     mut screenshot_manager: ResMut<ScreenshotManager>,
     mut counter: Local<u32>,
 ) {
-    if input.just_pressed(KeyCode::Space) {
+    if input.just_pressed(PhysicalKeyCode::Space) {
         let path = format!("./screenshot-{}.png", *counter);
         *counter += 1;
         screenshot_manager
diff --git a/examples/window/window_resizing.rs b/examples/window/window_resizing.rs
index 9272ec9f87ecd7..ac678323864ac5 100644
--- a/examples/window/window_resizing.rs
+++ b/examples/window/window_resizing.rs
@@ -58,21 +58,21 @@ fn setup_ui(mut cmd: Commands) {
 
 /// This system shows how to request the window to a new resolution
 fn toggle_resolution(
-    keys: Res<ButtonInput<KeyCode>>,
+    keys: Res<ButtonInput<PhysicalKeyCode>>,
     mut windows: Query<&mut Window>,
     resolution: Res<ResolutionSettings>,
 ) {
     let mut window = windows.single_mut();
 
-    if keys.just_pressed(KeyCode::Digit1) {
+    if keys.just_pressed(PhysicalKeyCode::Digit1) {
         let res = resolution.small;
         window.resolution.set(res.x, res.y);
     }
-    if keys.just_pressed(KeyCode::Digit2) {
+    if keys.just_pressed(PhysicalKeyCode::Digit2) {
         let res = resolution.medium;
         window.resolution.set(res.x, res.y);
     }
-    if keys.just_pressed(KeyCode::Digit3) {
+    if keys.just_pressed(PhysicalKeyCode::Digit3) {
         let res = resolution.large;
         window.resolution.set(res.x, res.y);
     }
diff --git a/examples/window/window_settings.rs b/examples/window/window_settings.rs
index 77e24cef1f7042..8b33e1ae1f6888 100644
--- a/examples/window/window_settings.rs
+++ b/examples/window/window_settings.rs
@@ -62,8 +62,8 @@ 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<ButtonInput<KeyCode>>, mut windows: Query<&mut Window>) {
-    if input.just_pressed(KeyCode::KeyV) {
+fn toggle_vsync(input: Res<ButtonInput<PhysicalKeyCode>>, mut windows: Query<&mut Window>) {
+    if input.just_pressed(PhysicalKeyCode::KeyV) {
         let mut window = windows.single_mut();
 
         window.present_mode = if matches!(window.present_mode, PresentMode::AutoVsync) {
@@ -83,8 +83,8 @@ fn toggle_vsync(input: Res<ButtonInput<KeyCode>>, mut windows: Query<&mut Window
 /// [documentation](https://docs.rs/bevy/latest/bevy/prelude/struct.Window.html#structfield.window_level)
 /// for more details.
 
-fn switch_level(input: Res<ButtonInput<KeyCode>>, mut windows: Query<&mut Window>) {
-    if input.just_pressed(KeyCode::KeyT) {
+fn switch_level(input: Res<ButtonInput<PhysicalKeyCode>>, mut windows: Query<&mut Window>) {
+    if input.just_pressed(PhysicalKeyCode::KeyT) {
         let mut window = windows.single_mut();
 
         window.window_level = match window.window_level {
@@ -101,10 +101,13 @@ fn switch_level(input: Res<ButtonInput<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<ButtonInput<KeyCode>>, 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);
+fn toggle_window_controls(
+    input: Res<ButtonInput<PhysicalKeyCode>>,
+    mut windows: Query<&mut Window>,
+) {
+    let toggle_minimize = input.just_pressed(PhysicalKeyCode::Digit1);
+    let toggle_maximize = input.just_pressed(PhysicalKeyCode::Digit2);
+    let toggle_close = input.just_pressed(PhysicalKeyCode::Digit3);
 
     if toggle_minimize || toggle_maximize || toggle_close {
         let mut window = windows.single_mut();
@@ -130,8 +133,8 @@ fn change_title(mut windows: Query<&mut Window>, time: Res<Time>) {
     );
 }
 
-fn toggle_cursor(mut windows: Query<&mut Window>, input: Res<ButtonInput<KeyCode>>) {
-    if input.just_pressed(KeyCode::Space) {
+fn toggle_cursor(mut windows: Query<&mut Window>, input: Res<ButtonInput<PhysicalKeyCode>>) {
+    if input.just_pressed(PhysicalKeyCode::Space) {
         let mut window = windows.single_mut();
 
         window.cursor.visible = !window.cursor.visible;
@@ -143,8 +146,8 @@ fn toggle_cursor(mut windows: Query<&mut Window>, input: Res<ButtonInput<KeyCode
 }
 
 // This system will toggle the color theme used by the window
-fn toggle_theme(mut windows: Query<&mut Window>, input: Res<ButtonInput<KeyCode>>) {
-    if input.just_pressed(KeyCode::KeyF) {
+fn toggle_theme(mut windows: Query<&mut Window>, input: Res<ButtonInput<PhysicalKeyCode>>) {
+    if input.just_pressed(PhysicalKeyCode::KeyF) {
         let mut window = windows.single_mut();
 
         if let Some(current_theme) = window.window_theme {
diff --git a/tests/how_to_test_systems.rs b/tests/how_to_test_systems.rs
index b71e5471bd1e16..b5c1086c3ff824 100644
--- a/tests/how_to_test_systems.rs
+++ b/tests/how_to_test_systems.rs
@@ -37,8 +37,8 @@ fn hurt_enemies(mut enemies: Query<&mut Enemy>) {
     }
 }
 
-fn spawn_enemy(mut commands: Commands, keyboard_input: Res<ButtonInput<KeyCode>>) {
-    if keyboard_input.just_pressed(KeyCode::Space) {
+fn spawn_enemy(mut commands: Commands, keyboard_input: Res<ButtonInput<PhysicalKeyCode>>) {
+    if keyboard_input.just_pressed(PhysicalKeyCode::Space) {
         commands.spawn(Enemy {
             hit_points: 5,
             score_value: 3,
@@ -124,8 +124,8 @@ fn spawn_enemy_using_input_resource() {
     app.add_systems(Update, spawn_enemy);
 
     // Setup test resource
-    let mut input = ButtonInput::<KeyCode>::default();
-    input.press(KeyCode::Space);
+    let mut input = ButtonInput::<PhysicalKeyCode>::default();
+    input.press(PhysicalKeyCode::Space);
     app.insert_resource(input);
 
     // Run systems
@@ -134,8 +134,10 @@ 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::<ButtonInput<KeyCode>>().clear();
+    // Clear the `just_pressed` status for all `PhysicalKeyCode`s
+    app.world
+        .resource_mut::<ButtonInput<PhysicalKeyCode>>()
+        .clear();
 
     // Run systems
     app.update();