Fix: Unity New Input System UI Not Working

Here is how to fix Unity new input system UI not working. You upgraded to Unity’s new Input System, your gameplay controls work beautifully, but every button, slider, and dropdown in your UI is completely dead. Clicks do nothing, hover states never trigger, and navigation with a gamepad is non-existent. The problem is almost always a mismatch between your EventSystem configuration and the input backend the project is actually using. Let us fix it step by step.

The Symptom

After installing the com.unity.inputsystem package and migrating your player controls to the new Input System, you notice that your canvas-based UI has stopped responding entirely. Buttons do not fire their OnClick events. Scrollviews cannot be scrolled. Toggle groups and input fields ignore mouse and keyboard interaction. If you are using a gamepad, navigation between UI elements does not work at all.

The confusing part is that everything looks correct in the scene hierarchy. Your Canvas has a GraphicRaycaster, your EventSystem is present, and your buttons have properly assigned OnClick listeners. There are no errors in the Console. The UI just silently refuses to acknowledge any input.

If you switch back to the old Input Manager in Player Settings, the UI starts working again immediately. This confirms the issue is specific to how the new Input System interacts with Unity’s EventSystem, not a problem with your UI layout or button configuration.

What Causes This

1. Wrong input module on the EventSystem. This is the root cause in the vast majority of cases. When Unity creates an EventSystem via GameObject > UI > EventSystem, it attaches a StandaloneInputModule component by default. This module communicates exclusively with the legacy Input Manager. When you switch the project to the new Input System, this module silently stops receiving input events. It does not throw an error — it simply has nothing to read from.

The new Input System provides its own replacement: InputSystemUIInputModule. This component speaks the new Input System’s language and routes pointer, click, scroll, and navigation events to the EventSystem. Without it, the entire UI event pipeline is disconnected.

2. Missing or misconfigured action asset reference. The InputSystemUIInputModule relies on an Input Action Asset to know which actions correspond to UI operations like pointing, clicking, and scrolling. If the Actions Asset field on the module is empty, or if it references an asset that has been deleted or renamed, the module cannot map physical input to UI events. Unity provides a default UI actions map, but if you have overridden it with a custom asset, every binding must be present.

3. Active Input Handling set incorrectly. In Edit > Project Settings > Player > Other Settings, there is an Active Input Handling dropdown. If this is set to Input Manager (Old), the new Input System package is installed but not actually active at runtime. The InputSystemUIInputModule will be present in your scene but will receive no input data because the backend is not running. This setting requires an editor restart to take effect, which catches many developers off guard.

4. Multiple input modules on the same EventSystem. If both StandaloneInputModule and InputSystemUIInputModule are attached to the same EventSystem GameObject, they conflict. The EventSystem only processes input from one module at a time, and the selection order is not always predictable. In some Unity versions this results in the old module taking priority, effectively blocking the new one.

The Fix

Step 1: Replace the input module. Select your EventSystem in the hierarchy. In the Inspector, find the StandaloneInputModule component and remove it. Then click Add Component and search for InputSystemUIInputModule. Add it to the EventSystem.

// Verify the EventSystem has the correct module at runtime
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.InputSystem.UI;

public class EventSystemValidator : MonoBehaviour
{
    void Awake()
    {
        var eventSystem = EventSystem.current;
        if (eventSystem == null)
        {
            Debug.LogError("No EventSystem found in scene.");
            return;
        }

        var newModule = eventSystem.GetComponent<InputSystemUIInputModule>();
        var oldModule = eventSystem.GetComponent<StandaloneInputModule>();

        if (newModule == null)
            Debug.LogError("InputSystemUIInputModule is missing on EventSystem.");

        if (oldModule != null)
            Debug.LogWarning("StandaloneInputModule is still attached. Remove it to avoid conflicts.");
    }
}

If you have multiple scenes, each with their own EventSystem, you must update every single one. A common mistake is fixing the main menu scene but forgetting the in-game UI scene or the pause menu scene. Use a script like the one above during development to catch these misses early.

Step 2: Configure the action asset and bindings. On the InputSystemUIInputModule, check the Actions Asset field. If you have a custom Input Action Asset for your project, assign it here. Then verify that each UI action slot — Point, Left Click, Middle Click, Right Click, Scroll Wheel, Move, Submit, Cancel, and Tracked Device Position/Orientation — is mapped to the correct action.

// Programmatically assign a UI action asset at runtime
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.UI;

public class UIInputSetup : MonoBehaviour
{
    [SerializeField] private InputActionAsset uiActions;

    void Start()
    {
        var module = FindObjectOfType<InputSystemUIInputModule>();
        if (module == null)
        {
            Debug.LogError("No InputSystemUIInputModule found.");
            return;
        }

        module.actionsAsset = uiActions;

        // Verify critical action references are bound
        Debug.Log($"Point action: {module.point?.action?.name ?? "MISSING"}");
        Debug.Log($"Click action: {module.leftClick?.action?.name ?? "MISSING"}");
        Debug.Log($"Submit action: {module.submit?.action?.name ?? "MISSING"}");
        Debug.Log($"Cancel action: {module.cancel?.action?.name ?? "MISSING"}");
    }
}

If you do not have a custom action asset and want to use the defaults, you can leave the field empty and click the Set Default Actions button that appears on the component. This generates a built-in UI action map with sensible defaults for mouse, keyboard, and gamepad.

Step 3: Verify Active Input Handling. Go to Edit > Project Settings > Player > Other Settings and find the Active Input Handling dropdown. Set it to Input System Package (New) if you have fully migrated, or Both if you still need the old Input Manager for some systems. Unity will prompt you to restart the editor — you must do this for the change to take effect.

// Runtime check for active input backend
using UnityEngine;

public class InputBackendCheck : MonoBehaviour
{
    void Start()
    {
#if ENABLE_INPUT_SYSTEM
        Debug.Log("New Input System is ACTIVE.");
#else
        Debug.LogWarning("New Input System is NOT active. Check Player Settings.");
#endif

#if ENABLE_LEGACY_INPUT_MANAGER
        Debug.Log("Legacy Input Manager is ACTIVE.");
#endif
    }
}

The preprocessor defines ENABLE_INPUT_SYSTEM and ENABLE_LEGACY_INPUT_MANAGER are set automatically by Unity based on this Player Setting. They are the most reliable way to check which backends are available at compile time.

Related Issues

If your UI is working with mouse but not with gamepad, the issue is likely in the navigation setup on your Selectable components. Each Button, Toggle, and Slider has a Navigation property that must be set to Automatic or explicitly configured for directional navigation. Without this, the EventSystem does not know which element to select when you press a direction on the stick or d-pad.

For projects that use both world-space canvases and screen-space overlays, make sure each canvas has its own GraphicRaycaster component. A world-space canvas also requires a Physics Raycaster on the camera and the canvas must be on a layer included in the camera’s event mask. Missing raycasters are a separate but related cause of unresponsive UI that is often confused with the Input System issue.

If you are experiencing input lag or delayed UI response after the fix, check whether your action bindings have interactions like Hold or SlowTap applied to click or submit actions. These interactions add intentional delay before the action triggers, which feels like broken UI when applied to button clicks.

Swap the module. It is always the module.