Start Building

Unity gives you two ways to read player input: the Legacy Input Manager (built in for years) and the new Input System (package-based, flexible, and the direction Unity recommends for new projects). Both can handle keyboard, mouse, and gamepad; the new system adds better rebinding, composite bindings, and multi-device support. This post explains the differences and when to use which so you can choose and implement input without fighting the engine.

1. What Each System Is

Legacy Input Manager

  • Uses Input.GetKey, Input.GetAxis, Input.GetButton and the Input Manager (Edit > Project Settings > Input).
  • Axis and button names are defined in the Input Manager (e.g. "Horizontal", "Jump", "Fire1").
  • No package to install; it is always available.
  • Simple for keyboard and one gamepad; rebinding and complex setups are mostly up to you in code.

New Input System

  • Installed via Package Manager (Input System).
  • You define Input Actions (e.g. "Move", "Jump", "Shoot") and bind keys, buttons, or sticks to them.
  • Supports rebinding, composites (WASD as one "Move" vector), multiple devices, and touch.
  • Can run in polling mode (check state in Update) or event mode (callbacks when actions trigger).
  • Replaces or works alongside the legacy system depending on Active Input Handling (Edit > Project Settings > Player > Other Settings).

Active Input Handling

  • Input Manager (Old) – Only legacy.
  • Input System Package (New) – Only new system.
  • Both – Both APIs work; use one consistently per project to avoid confusion.

2. When to Use Legacy vs New

Use Legacy when:

  • You are in a small or existing project and do not need rebinding or touch.
  • You want the least setup and are fine with hard-coded key names and axes.
  • You are following an old tutorial or maintaining an old codebase.

Use the new Input System when:

  • You want rebinding, multiple control schemes (keyboard+mouse, gamepad, touch), or composite bindings (WASD = one 2D axis).
  • You are starting a new project and are okay adding the package and creating Input Action assets.
  • You target mobile or cross-platform and want a single API for touch and gamepad.
  • You prefer event-driven input (e.g. OnJump, OnShoot) instead of polling in Update.

Pro tip: New projects that will grow (menus, rebinding, multiple platforms) are usually better off with the new system from the start. Migrating later is possible but takes time.

3. Quick Comparison in Code

Legacy – polling in Update:

  • Input.GetAxis("Horizontal") / Input.GetAxis("Vertical") for movement.
  • Input.GetButtonDown("Jump") for one-shot actions.
  • Axis and button names must match the Input Manager.
  • Rebinding means changing the Input Manager or your own saved key mapping and using Input.GetKey(KeyCode.SomeKey) instead of button names.

New Input System – polling:

  • Add the Input System package and set Active Input Handling to Input System Package (New) or Both.
  • Create an Input Actions asset (e.g. "Gameplay"), define actions like "Move" (Value, Vector2) and "Jump" (Button).
  • In code: use PlayerInput component and OnAction callbacks, or get the InputAction from your asset and call ReadValue\<Vector2>() / WasPressedThisFrame() in Update.
  • Rebinding is built in: use InputActionRebindingExtensions.ApplyBindingOverrides or the UI Rebinding API.

New Input System – events:

  • Subscribe to action.performed or action.canceled so you do not poll.
  • Good for one-shot actions (jump, shoot) and for keeping input logic out of Update.

4. Setting Up the New Input System (Minimal)

  1. Install: Window > Package Manager > Input System > Install.
  2. Active Input Handling: Edit > Project Settings > Player > Other Settings > Active Input Handling > set to Input System Package (New) or Both.
  3. Create an Input Actions asset: Right-click in Project > Create > Input Actions. Name it (e.g. "Gameplay").
  4. Define actions: Open the asset, add an Action Map (e.g. "Player"), add actions:
    • "Move" – Value, Control Type Vector 2. Add composite "2D Vector", bind W/S and A/D (or Left Stick).
    • "Jump" – Button. Bind Space and South button (gamepad).
  5. Generate C# class: In the asset Inspector, check Generate C# Class and apply. That gives you a generated class to reference actions in code.
  6. Use in a script: Instantiate the generated class, call Enable(), then read Move.ReadValue\<Vector2>() or subscribe to Jump.performed.

Pro tip: Use Player Input component with Invoke Unity Events or Send Messages if you prefer not to generate C#; for full control and cleaner architecture, the generated class or manual InputActionAsset is better.

5. Common Pitfalls

Legacy:

  • Input Manager axis names are case-sensitive and must match exactly.
  • GetAxis returns -1 to 1; GetAxisRaw returns -1, 0, or 1. Use Raw for snappy movement if you do not want smoothing.
  • Multiple gamepads: you use "Joystick 1" vs "Joystick 2" and axis names like "Horizontal" (first joystick). Legacy does not abstract "player 1" vs "player 2" as cleanly as the new system.

New system:

  • If Active Input Handling is Input Manager (Old) only, the new Input System APIs will not work.
  • InputAction must be enabled (e.g. action.Enable() or asset.Enable()) before reading or receiving events.
  • Rebinding at runtime changes bindings; save and load ApplyBindingOverrides / GetBindingOverrides so they persist.

6. Migrating From Legacy to New

  • Identify all Input.GetKey, GetAxis, GetButton (and variants) in your project.
  • Map each to an Input Action (e.g. "Jump" button, "Move" 2D vector).
  • Replace polling with ReadValue or WasPressedThisFrame, or with performed/ canceled events.
  • Switch Active Input Handling to the new system (or Both) and test on keyboard and gamepad.
  • Optionally add a rebinding UI and save/load overrides so players can customize.

For step-by-step fixes when input does not work, see our Unity Input System Not Working - New Input System Fix help article.

Summary

Unity’s Legacy Input Manager is simple and built in; the new Input System is a package that gives you rebinding, composites, multiple devices, and events. Use legacy for tiny or legacy projects; use the new system for new projects, rebinding, or cross-platform input. Set Active Input Handling correctly and enable your actions before reading them. Once you choose one approach, stick to it per project so input stays consistent and maintainable.

Bookmark this post when you start a new Unity project or plan to add rebinding. For more Unity scripting, see our Unity Game Development Course. Share it with your dev friends if it helped.