input-system-new

Generate C# input reader classes from .inputactions assets for Unity 6+.

71|11|Updated Jan 23, 2026
One-click install
npx skills add https://github.com/nlelouche/Unity-SkillForge --skill input-system-new
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: input-system-new
Source: https://github.com/nlelouche/Unity-SkillForge/tree/main/.agent/skills/05-ui-ux/input-system-new
Command: npx skills add https://github.com/nlelouche/Unity-SkillForge --skill input-system-new

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and templates (resource) components.

What problem does it solve?

This Skill simplifies handling multi-device input in Unity by abstracting away the complexities of the New Input System, enabling decoupled event-driven input management.

Core Features & Use Cases

  • ScriptableObject-based Input Reader: Centralizes input logic and exposes events for various actions (move, jump, attack, etc.).
  • Multi-Device Support: Seamlessly handles input from keyboard, gamepad, touch, and other devices.
  • Decoupled Architecture: Prevents direct polling of input, promoting cleaner code and easier maintenance.
  • Use Case: Implement player movement and actions in a game where controls need to be rebindable and work across different input devices.

Quick Start

Generate an InputReader ScriptableObject for your project.

Frequently Asked Questions about input-system-new

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I decouple input handling in Unity using ScriptableObject events?

Decoupled input handling in Unity is achieved by using a ScriptableObject-based Input Reader that exposes events for actions like move or jump, preventing direct polling and centralizing logic. This wrapper abstracts multi-device input into event-driven C# classes.

What's the best way to support gamepad, keyboard, and touchscreen input in Unity 6?

Multi-device input in Unity 6 is handled through a wrapper that processes keyboard, gamepad, and touch events simultaneously. It generates C# classes from .inputactions assets, allowing seamless event-driven consumption across different input devices.

How do I generate C# classes from .inputactions assets for event-driven input?

Generating C# classes from .inputactions assets involves using a ScriptableObject wrapper that processes the input actions file. This creates event-driven structures, allowing developers to subscribe to specific input events like attack or movement without direct polling.

Does this Unity New Input System wrapper require Unity 6?

Yes, the Unity New Input System wrapper requires Unity 6 or higher to function properly. It leverages the engine's latest input management features to generate C# classes and facilitate decoupled, event-driven input across multiple devices.

Why use ScriptableObject events for Unity input management instead of direct polling?

Using ScriptableObject events for Unity input management prevents direct polling, promoting a decoupled architecture. This approach centralizes input logic, resulting in cleaner code, easier maintenance, and seamless multi-device support for rebindable controls.

Can I implement rebindable controls across different input devices using this approach?

Implementing rebindable controls across different input devices is supported by centralizing input logic in a ScriptableObject. This decoupled architecture exposes events for various actions, allowing player movement and controls to adapt seamlessly across keyboards, gamepads, and touchscreens.