Unity New Input System Left Click Not Working? Troubleshooting Guide

Few things are more frustrating than clicking your mouse in a Unity project and getting absolutely nothing in return. If you’ve recently switched to the Unity New Input System and your left click suddenly stopped working, you’re not alone. The new system is powerful, flexible, and modern—but it also introduces a different workflow that can easily cause confusion, especially if you’re transitioning from the old Input Manager.

TLDR: If your left click isn’t working in Unity’s New Input System, the issue usually comes down to incorrect input bindings, missing Player Input setup, wrong control schemes, UI input misconfiguration, or event system conflicts. Double-check that your Input Action is enabled, properly bound to Mouse → Left Button, and correctly referenced in your script. Also verify that your Event System and Input System UI Input Module are configured properly. Most left-click problems are configuration-based—not code-breaking bugs.

Understanding Why Left Click Stops Working

The Unity New Input System differs significantly from the legacy system. Instead of calling Input.GetMouseButtonDown(0), you now define Input Actions inside an Input Actions asset and bind those actions to devices such as Mouse, Keyboard, or Gamepad.

If left click is not working, the problem often falls into one of these categories:

• Action not enabled
• Binding configured incorrectly
• Player Input component errors
• UI Input Module misconfigured
• Conflicting Input Handling settings
• Raycasting or physics issues

Let’s break down each one.

1. Check Your Input Actions Binding

The most common cause is a missing or incorrect binding.

Open your Input Actions asset and verify:

• A new Action exists (e.g., “Click”)
• The Action Type is set correctly (usually Button)
• The Binding path is set to Mouse → Left Button

If your binding is empty or pointing to the wrong device, Unity won’t detect the click.

Common mistake: Binding to <Pointer>/press but forgetting to support Mouse as an active device.

Make sure the binding path looks something like:

<Mouse>/leftButton

If it doesn’t, that’s likely your issue.

2. Make Sure the Action Is Being Enabled

Unlike the old Input system, actions must be enabled before they can detect input.

If you’re enabling manually in code, make sure you call:

clickAction.Enable();

If you’re using a Player Input component, ensure:

• The correct Input Actions asset is assigned
• Default Action Map is selected
• Behavior is set properly (Send Messages, Unity Events, or C# Events)

If you forget to enable the Action Map, nothing will trigger—even if bindings are correct.

3. Verify Your Project Input Handling Setting

Go to:

Edit → Project Settings → Player → Active Input Handling

You’ll see options like:

• Input Manager (Old)
• Input System Package (New)
• Both

If you’re using the New Input System, this must be set to either:

• Input System Package (New)
• Both

If it’s set only to the old Input Manager, your new bindings won’t work.

4. UI Click Not Working? Check Your Event System

If your issue is specifically that UI buttons are not responding to left click, the problem is rarely your script—it’s usually your Event System configuration.

In the Hierarchy, look for:

• An EventSystem GameObject
• An Input System UI Input Module component

If you instead see Standalone Input Module, that module belongs to the old Input Manager and won’t correctly read new Input System actions.

Replace it with:

• Input System UI Input Module

Then ensure:

• Point, Click, and Submit actions are assigned
• Those actions are from the correct Input Actions asset

This step alone fixes a huge percentage of left-click problems.

5. Control Scheme Issues

If you’re using control schemes (e.g., Keyboard & Mouse, Gamepad), your Mouse might not be part of the active scheme.

Open your Input Actions asset:

• Check under Control Schemes
• Ensure Mouse is included in the scheme
• Confirm your Player Input is using the correct scheme

If the scheme excludes Mouse, your clicks won’t register—even though the binding looks correct.

6. Raycast and Physics Problems

If clicks are being detected but objects aren’t responding, the issue may not be the Input System at all.

Check:

• Is there a collider attached?
• Is a Physics Raycaster on your Camera (for 3D)?
• Is a Graphic Raycaster on your Canvas (for UI)?
• Is another UI element blocking the click?

Use Debug.Log inside your click callback to see whether input is registered. If it logs but nothing happens visually, you’re dealing with a raycast or interaction issue—not input detection.

7. Script Listening Incorrectly

You may have bound the action correctly but are reading it improperly in code.

Example of a working callback with C# events:

public void OnClick(InputAction.CallbackContext context)
{
    if (context.performed)
    {
        Debug.Log("Left Click detected");
    }
}

Common mistakes include:

• Checking context.started instead of performed
• Forgetting to subscribe to the action
• Using the wrong Action Map
• Disabling the GameObject containing Player Input

Make sure your method signature matches Unity’s expectations if you’re using Send Messages.

8. Mixing Old and New Systems

If you’re using both systems, conflicts can happen.

For example:

• UI running on old Standalone Input Module
• Gameplay using New Input System
• Duplicate Event Systems in scene

Unity allows using “Both” systems, but it increases the chance of conflicts. If possible, stick fully to the new system to avoid unexpected behavior.

9. Platform-Specific Issues

Sometimes the click works in Editor but not in build. Potential reasons:

• Different control scheme selected at runtime
• Device lost or not recognized
• Cursor lock state interfering

If you’re locking the cursor:

Cursor.lockState = CursorLockMode.Locked;

This can prevent normal UI interaction.

Quick Diagnostic Checklist

If you want to troubleshoot rapidly, follow this sequence:

1. Confirm Active Input Handling is set correctly.
2. Verify binding is <Mouse>/leftButton.
3. Ensure Action Map is enabled.
4. Check Player Input component assignment.
5. Validate Event System uses Input System UI Input Module.
6. Confirm raycasters and colliders exist.
7. Add Debug.Log inside callback.

Going through this list solves nearly every reported case.

Why the New Input System Feels Harder

The old Input system was simple but limited. The new one is event-driven, device-agnostic, and scalable across platforms. That flexibility introduces layers of abstraction that can feel overwhelming.

However, once properly configured, it provides:

• Better cross-platform support
• Rebinding at runtime
• Cleaner event-based logic
• Separation between input and gameplay logic

Most issues happen during setup—not during runtime execution.

Final Thoughts

If your Unity New Input System left click isn’t working, don’t panic. In the overwhelming majority of cases, it’s a configuration issue: a disabled Action Map, an incorrect binding, or a misconfigured Event System. The system is precise—if every piece isn’t connected properly, it simply won’t trigger.

Take a systematic approach. Verify bindings. Confirm modules. Log your callbacks. And always check your Event System when UI is involved.

Once everything is aligned, you’ll have a flexible and powerful input framework that handles mouse, keyboard, controller, and even touch seamlessly.

And the next time left click stops working, you’ll know exactly where to look.