How to Migrate from Unity's Old Input Manager to the Input System Without Breaking Controls
In a nutshell
Migrate a Unity 6 project from the old Input Manager to the Input System without breaking player controls, UI, or leftover Input calls.
You install the Input System, press Play, and Unity throws an error: you are trying to read input with the UnityEngine.Input class, but Active Input Handling already points at the Input System package. Or Play Mode starts, and the pause menu no longer receives a single click.
This article shows a safe order for migrating an existing Unity 6 project from the old Input Manager to the new Input System without breaking controls or UI. Keep both backends on, replace your Input calls, fix the EventSystem, then turn the old manager off only when everything still works. The steps follow the official Input System documentation as of November 20, 2026. Install the current Input System package from the Package Manager. Do not pin a package version from this article, because newer releases will follow.
Why migrate in Unity 6
Unity's manual now treats the built-in Input Manager as a legacy feature. It is deprecated, it is not recommended for new projects, and Unity says it will be removed in a future version of the editor. The old manager remains available so existing projects can keep running. A planned switch is still better than waiting until a future upgrade removes the old backend for you.
Keep both backends on while you migrate
If your project does not include the Input System, open Window > Package Manager, switch to the Unity Registry, and install the Input System package. From Unity 6.1 on, some project templates already add it. Empty projects often do not.
During installation, Unity asks whether to enable the Input System backends and disable the Input Manager backends. If you choose Yes, the Editor restarts with only the new system active. Every leftover Input.GetAxis or Input.GetButton call then fails, and uGUI menus that still use the old input module fail with them.
Set the backend yourself instead. Go to Edit > Project Settings > Player, open Other Settings, and set Active Input Handling to Both. The Editor will restart. In that mode, Unity defines both ENABLE_LEGACY_INPUT_MANAGER and ENABLE_INPUT_SYSTEM, so old and new code can run side by side.
#if ENABLE_INPUT_SYSTEM
// New Input System backends are enabled.
#endif
#if ENABLE_LEGACY_INPUT_MANAGER
// Old Input Manager backends are enabled.
#endif
Treat Both as a bridge. Leave it on until your own scripts, the EventSystem and any third-party assets have moved over. Switch to Input System Package (New) only after Play Mode and a build work without the exception and with a working UI.
Replace GetAxis and GetButton with Actions
The recommended workflow is to read named actions, not raw device buttons. Unless you need more than one action asset, assign a single asset as the project-wide actions.
Open Edit > Project Settings > Input System Package and create or assign the default project-wide actions if none are set. The defaults include a Player map and a UI map, with actions such as Move (a Vector2 value) and Jump, already bound for keyboard, mouse, gamepad, touch and XR. You reach them through InputSystem.actions. They are enabled by default and are preloaded at startup, and in the Editor each time you enter Play Mode.
Find each action once, then read it every frame. Looking the action up by name every time, as Input.GetAxis("Horizontal") did, is the slow path in the new API.
using UnityEngine;
using UnityEngine.InputSystem;
public class PlayerMovement : MonoBehaviour
{
InputAction moveAction;
InputAction jumpAction;
void Start()
{
moveAction = InputSystem.actions.FindAction("Move");
jumpAction = InputSystem.actions.FindAction("Jump");
}
void Update()
{
Vector2 move = moveAction.ReadValue<Vector2>();
if (jumpAction.WasPressedThisFrame())
{
// jump
}
}
}
The names in the UnityEngine.InputSystem namespace map to the old calls like this:
Input.GetAxis("Horizontal")andInput.GetAxis("Vertical")becomemoveAction.ReadValue<Vector2>()Input.GetButton("Jump")becomesjumpAction.IsPressed()Input.GetButtonDownbecomesWasPressedThisFrame()Input.GetButtonUpbecomesWasReleasedThisFrame()Input.GetKey(KeyCode.Space)becomesKeyboard.current.spaceKey.isPressedInput.GetMouseButton(0)becomesMouse.current.leftButton.isPressedInput.mousePositionbecomesMouse.current.position.ReadValue()
Two details matter if you want the controls to feel the same. The default Move action is a 2D value, so the old Horizontal and Vertical axes become one vector, not two floats. And ReadValue does not apply the old Gravity and Sensitivity smoothing, so a key or button reaches its full value immediately. If your movement relied on that ramp, you will need to recreate it on purpose. Input.GetAxisRaw has no direct equivalent. ReadUnprocessedValue() only differs from ReadValue when processors are attached to the action.
Direct device reads such as Keyboard.current are a quick stand-in, not the long-term workflow, and the current device can be null when that hardware is missing.
A few older Input Manager features still depend on your Unity version. From Unity 6.4 on, MonoBehaviour mouse event functions such as OnMouseDown work with the Input System. On earlier Unity 6 releases they may do nothing once only the new backend is active. If your project uses location, compass or device orientation, check the Input System documentation for your editor before you turn the old manager off. IMGUI (OnGUI) is not compatible with the Input System, so a debug menu built that way may need to stay on Both.
Keep the UI working
If you use Unity UI (uGUI), you always need an input module on the EventSystem to feed the Input System into the UI. The older StandaloneInputModule still talks to the legacy Input Manager. When Active Input Handling is set to the new package only, that module is a frequent source of the UnityEngine.Input exception.
Select the EventSystem in the scene. If the Input System package is installed, the Inspector offers a button that replaces StandaloneInputModule with InputSystemUIInputModule. The new module comes pre-configured with default UI actions. When Active Input Handling is already set to the new package or to Both, Unity also adds the new module automatically if you place a fresh uGUI element in the scene.
UI Toolkit is different. From Unity 2023.2 on, which includes Unity 6, UI Toolkit can read the UI actions from your project-wide actions without an extra module. You do need InputSystemUIInputModule plus an EventSystem when UI Toolkit and uGUI share the same scene.
If you also use the PlayerInput component, assign the same action asset to PlayerInput and to InputSystemUIInputModule, and set the UI Input Module field on PlayerInput. Then the same device assignment drives both the player and the UI. If your scripts read actions while PlayerInput is in use, read PlayerInput.actions, not InputSystem.actions, because PlayerInput keeps a filtered copy for each player's device.
The exception and leftover Input calls
The runtime error usually reads: InvalidOperationException: You are trying to read Input using the UnityEngine.Input class, but you have switched active Input handling to Input System package in Player Settings. It appears when Active Input Handling is set to Input System Package (New) and something still calls UnityEngine.Input.
Read the stack trace before you change random scripts. It often starts in StandaloneInputModule or BaseInput.GetButtonDown, not in your movement class. After you fix the EventSystem, search your own code for Input.GetAxis, Input.GetButton, Input.GetKey, Input.GetMouseButton and Input.mousePosition. Then check third-party assets and plugins. Setting Active Input Handling back to Both is a valid temporary step. The lasting fix is to migrate the caller or update the plugin.
When PlayerInput is worth it
The PlayerInput component is optional. Add it when you want Send Messages (OnJump, OnMove(InputValue value)), Invoke Unity Events, or a PlayerInputManager for local multiplayer. A single-player game that already polls in Update can stay with FindAction and ReadValue.
A short migration checklist
- Install the current Input System package from the Package Manager, then set Active Input Handling to Both.
- Create or assign the default project-wide actions.
- Replace your own
Inputcalls. Find each action once, then read it every frame. - If you use uGUI, replace
StandaloneInputModulewithInputSystemUIInputModuleand click through the menus with a keyboard and a gamepad. - Check
OnMouseevents, touch, location, compass and IMGUI against your Unity version. - Update plugins that still call
UnityEngine.Input, or leave Both on until a fix exists. - When Play Mode and a build run without the exception and with a working UI, set Active Input Handling to Input System Package (New).
Before you flip that last switch, play through movement, menus and on-screen buttons. Input is a client-side engine topic. horizOn is a game backend with a Unity SDK for accounts, cloud save, leaderboards and in-game news. Migrating the Input System does not change how you use that SDK, and it does not replace or wrap Unity's input stack.