12 Input – Changelog

13 min read

What shipped in each Scylla Input release, from the initial surface that wrapped Unity’s Input System into a complete game-input layer down through every fix that follows.

This page collects the release notes for Scylla Input, the framework’s input layer over Unity’s Input System. Versions are listed newest at the top; each entry groups its bullets under Added, Removed, Changed, and Fixed. Input follows its own semver line, independent of Core and the other modules.

1.1.1

A maintenance release that moves Input onto Scylla Core 1.2.0.

Added

  • A New Input Actions from Template command, in Tools/Scylla/Input and as the Template button in the Input Actions Editor toolbar. It lists the Default actions asset and the twelve genre presets, asks where to save, and copies the chosen asset into the project together with its sidecar and its input contexts, then opens the copy in the editor. This is how to start from a preset when Scylla Input is installed as a package, because the asset picker does not list assets inside packages and those assets are read-only.

Removed

  • The ExcludeMousePosition and ExcludeMouseDelta rebind settings, from the Input configuration and its JSON config file. Neither had any effect: a rebind never captures the mouse position or mouse movement, whatever they were set to, and a binding that expects mouse movement is still captured when the player moves the mouse. A JSON config file that still contains the two keys loads without error and ignores them.
  • ScyllaInputMenuItems.CreateInputModuleContext and ValidateCreateInputModuleContext. The GameObject/Scylla entry now runs CreateInputModule directly.

Changed

  • Requires Scylla Core 1.2.0 or newer.
  • In the Editor, Play mode no longer changes the Input and Input Context configuration assets. Input now works on runtime copies of both, so values changed at runtime and JSON config overrides last for the Play session only. Builds are unaffected.
  • Pushing, popping, removing and clearing input contexts is now logged at Debug level instead of Info, so routine context changes no longer fill the console.
  • The Input setup wizard now opens centered on the Unity main window.
  • The Input setup wizard no longer requires a Scylla Bootstrap in the scene. When there is none, it creates one before adding the Input module, instead of disabling Next on the Game Profile page.
  • Input menu items are placed by the Scylla Core menu registry. Their paths and the Input Actions Editor shortcut are unchanged, and a divider now separates Export Bundle and Import Bundle from the other items. The Assets/Create/Scylla/Input entries are declared with [ScyllaCreateAsset] instead of [CreateAssetMenu].
  • Scylla Input declares itself a tier 1 module in its ScyllaModuleInfo.

Fixed

  • InputDeviceChangedEvent is now published, and registered IInputListener objects receive InputEventType.DeviceChanged, whenever the last-used device changes. This includes the fallback to another device after the last-used device is disconnected. Both were declared and documented before but never raised.
  • The rebind settings in the Input configuration now take effect. Timeout and DefaultCancelPath are the starting values of every rebind operation, and the operation’s fluent methods still override them per rebind. Without a configuration a rebind keeps the previous behavior of a 5 second timeout and Escape to cancel.
  • The rebind Timeout tooltip no longer offers 0 as “no timeout”. The configured timeout stays within 1 to 30 seconds, and a JSON override outside that range is clamped into it.
  • The Input Logging toggles now work. LogBindingChanges, LogContextChanges and LogSchemeChanges silence the binding, rebind, context stack and control scheme messages they describe. All three still default to on. Warnings and errors are always logged.
  • The built-in default contexts now match the shipped Scylla Input Contexts - Default asset and the Scylla Input Actions - Default actions asset. They were used when no context configuration was found, by Reset to Defaults and by Add Default Input Contexts, but they named the Action Game maps, so their Gameplay context enabled maps the default actions asset does not have and gameplay input did nothing. The set is now Gameplay, Menu, Console, Global and Rebinding. The Gameplay – Debug context remains in the Action Game context configuration.
  • Two descriptions in the Input Actions editor described the editor wrongly. The Layout tab now says that its exclusive sets name the layout’s row groups rather than binding groups, and a composite part now says that its binding groups are set on the composite rather than on each part.
  • The Input setup wizard now describes what it creates correctly. The simple action asset lists its actual Gameplay and Menu actions, and the Input Contexts step lists the default contexts with their real priorities.
  • The Input setup wizard now finds the factory action assets and context configurations when Scylla Input is installed as a package. It looked for them only at their location in the Scylla source project, so in an installed package it copied neither the genre preset nor the default actions asset, and created an empty context configuration. The wizard also reports a factory context configuration it cannot find, instead of creating the empty one without a word.
  • An action asset copied by the Input setup wizard now keeps its descriptions and its config-screen layout in the Input Actions Editor. The copied sidecar still pointed at the shipped asset it was copied from, so the editor did not find it for the copy.

1.1.0

Adds Scylla’s own Input Actions editor and the authoring layer around it: a metadata sidecar, context-aware conflict detection, config layout authoring, constants generation, and a set of factory action assets to start a project from. The runtime layer keeps the shape it had in 1.0.0, with additions for per-action rebindability, multiple action assets, and interaction reporting.

Added

  • Input Actions editor. Scylla’s own window for .inputactions assets, at Tools/Scylla/Input/Input Actions Editor.... It edits the stock Unity file in place, so an asset authored here still works with PlayerInput and Unity’s generated wrapper, and an asset authored in Unity’s editor opens here unchanged. A tree of maps, actions and bindings sits beside nine panels covering the asset itself, control schemes, bindings, the conflict matrix, contexts, the config layout, validation, glyphs and code generation, in the order an asset is usually authored, with an undo stack of its own.
  • Metadata sidecar, MyGame.scyllainput.asset, carrying what the .inputactions format cannot: authoring notes, display name overrides, which actions are protected from rebinding, per-scheme icon sets, and the controls-screen layout. Keyed by the action asset’s GUID rather than its file name, so renaming or moving either file keeps annotations attached to the elements they describe.
  • Live conflict detection in the binding matrix, which reads the project’s input contexts and does not report two actions as conflicting when no context can enable both. Device classes and control aliases are resolved before comparison, so a keyboard binding never collides with a gamepad one and <Gamepad>/buttonSouth is recognized as the same control as <Gamepad>/a.
  • Config layout authoring. Controls-screen layout that previously had to be written in code can now be authored into the sidecar, including deriving exclusivity from the same tags the contexts already declare.
  • Constants generation. A generated C# file of constants for maps, actions, binding groups, control schemes, layout groups, contexts and exclusivity tags, so a renamed action breaks the build rather than failing silently at run time. The same file carries a CreateConfigLayout() factory that rebuilds the authored layout in code. Regenerating an unchanged asset writes nothing.
  • Bundle export and import. Tools/Scylla/Input/Export Bundle... packages an action asset and its sidecar into one portable file, and Import Bundle... writes it into another project, reproducing the action asset byte for byte. Import previews what the bundle holds and lets you choose which parts land. Nothing in the target project is overwritten.
  • Factory action assets. Twelve genre presets covering 2D Platformer, 2D Top-Down, 4X Strategy, Action Game, Adventure, Fighting, Flight Sim, Party Tactics, Puzzle, Racing, Shoot Em Up and Survival, plus a Base and a Default asset. Each ships with its sidecar and its own input contexts, so a project starts from a working setup for its genre instead of an empty asset, and the setup wizard offers them per game profile.
  • Control picker and press-to-bind capture. A searchable control catalog behind every binding path field, also reachable by double-clicking a matrix cell, and an Edit-mode capture that binds a control by pressing it. A captured modifier combination becomes a composite rather than a bare key, and capture reports what it could hear and what it had to drop.
  • Per-action rebindability, authored in the sidecar, shown in the matrix, and honored at run time through IInputRebindabilityProvider, so an action marked as protected cannot be rebound from a controls screen.
  • Multiple action assets. ScyllaInputConfiguration now holds an ordered list of InputActionAsset instead of a single one, where a later entry overrides a map name declared by an earlier one. Camera and Console ship their own assets and register alongside the game’s.
  • Interaction reporting on action events through Interaction and InteractionName, so a hold and a tap on the same action can be told apart without reaching into Unity’s callback context.
  • Matrix qualifier badges, which mark a binding carrying an interaction or a processor, so a row that looks like a duplicate reads as a qualified one instead. A hold gets a mark of its own, since holding is the one qualifier that changes how a control feels rather than only what value it produces, and a cell whose bindings disagree is marked as mixed.
  • Input playground demo, a scene for exercising one action against interaction and processor combinations and watching which interaction actually drove each fire.

Changed

  • Conflict detection now accounts for interactions and control schemes, attributes modifier depth per binding rather than per action, and matches a binding group as a whole entry rather than as a substring. A shared modifier on its own no longer counts as a shared shortcut.
  • Config group membership and action identity are keyed by map name and action name together, so two maps can each declare an action of the same name without colliding.
  • Shipped action and context assets follow one naming pattern, Scylla Input Actions - <Name> and Scylla Input Contexts - <Name>.
  • Generated constants use one fixed type name and no longer pin an output path.
  • Glyph resolution falls back to the base device layout, so a control a derived layout does not name still resolves. Shipped icon sets now cover the stick axes, the mouse cursor and both scroll halves.
  • Keyboard control scheme names are normalized across the shipped assets, and the PlayStation and DualShock brand names are spelled correctly in the icon sets.
  • Requires Input System 1.19.0 or newer.

Fixed

  • Binding collisions in the shipped factory assets that the context exclusivity work uncovered.
  • Constants generation produced invalid C# type names for asset names that are not valid identifiers.
  • Press-to-bind capture recorded the control the pad reported rather than the control the binding is for.
  • ConfigScreen demo rendered nothing at all, and its table now scrolls both ways and reads its columns from the authored config layout.
  • Input demo sample failed to compile after import from the UPM package. Packaging stripped the demo editor assembly’s reference to the sample’s own runtime assembly, which surfaced as unresolved namespace and type errors in the consumer’s project.

1.0.0

The initial release of Scylla Input wraps Unity’s Input System into a complete game-input layer with action management, context stacking, buffering, runtime rebinding, scheme detection, and prompt resolution.

Added

  • ScyllaInput module facade as a Tier 1 module under Core, owning a fixed roster of sub-managers and exposing a single entry point for game code.
  • Action API: ScyllaInputAction wrappers around Unity’s InputAction with value-reading helpers (ReadFloat, ReadVector2, ReadValue<T>), routed performed / started / canceled callbacks, and a modifier-key disambiguation pass so an action bound to Ctrl+1 does not also fire on a bare 1.
  • Context stack via IInputContextManager, a LIFO of named InputContext objects with priority and a blocking flag, so pushing a pause menu disables gameplay action maps without unregistering them and popping restores them exactly as they were.
  • Conflict-exclusive tags on contexts, authored in the context configuration asset. Contexts sharing a tag are never active together, so an in-game controls screen never reports the keys they have in common as conflicts. A context can carry several tags, and an always-on map keeps reporting its overlaps without any special case. ConfigLayout.WithExclusiveGroupsFromContexts lets a controls screen read the tags instead of restating the same relationships in code.
  • Input buffering via IInputBufferManager, per-action timed queues that hold recent triggers for the few frames between a press and the moment the action becomes legal, the canonical implementation of fighting-game combo windows and platformer coyote-time.
  • Runtime rebinding via IInputBindingManager (low-level StartRebind, save and load) and the higher-level InputRebindManager (interactive state machine, conflict detection), with pluggable storage backends: JSONFileBindingStorage for human-editable profiles on disk and PlayerPrefsBindingStorage for the path of least resistance.
  • Control-scheme detection via IControlSchemeManager, which watches recent device activity and publishes a ControlSchemeChangedEvent when the player swaps between keyboard / mouse and gamepad.
  • Button-prompt resolution via IInputHintsManager, which resolves an action plus the active scheme into a sprite and label through registered InputIconSet assets, so per-platform icon sets keep prompts honest across the player’s hardware.
  • Gamepad brand detection feeding prompt resolution. The hints manager matches the detected controller against each registered icon set’s GamepadType, so a DualSense draws PlayStation glyphs and an Xbox pad draws A/B/X/Y with no game code in between. SetIconSetForScheme still pins a scheme to one set when a project wants to override the choice, and ResolveIconSetForScheme reports which set the prompts actually resolve against, as opposed to GetIconSetForScheme, which reports the configured mapping.
  • Event-driven notifications on every meaningful Input transition (device connected, action performed, context pushed, binding loaded, rebind completed, scheme changed, hint changed) published as typed events on Scylla Event eXchange.
  • ScyllaInputConfiguration ScriptableObject with binding-storage, rebind, and logging setting groups, plus the matching JSON config file and the separate ScyllaInputContextConfiguration that ships the default context set.
  • ConfigScreen demo, a complete rebinding UX with per-action rows, per-control-scheme columns (Keyboard / Mouse, WASD, Gamepad), click-to-rebind, red highlight on conflict, and instant save on accept.
  • Input Demo Game, a small playable third-person game that runs every Input feature at once instead of isolating them: three locomotion action maps that swap when the player boards a car or a helicopter, a six-entry context stack with a live on-screen readout of the context ID and depth, buffered melee combos with a toggle that turns buffering off so the same mashing drops the chain, an in-game controls screen with conflict detection and JSON persistence, and a prompt bar whose glyphs follow the device, the controller brand and the current bindings. Built on Core and Input alone, so nothing in it needs another module. Its seven contexts are authored in a context configuration asset rather than built in code, so the whole setup can be read and copied from the Inspector, and its conflict column is driven by the tags on those contexts: clear one and the collisions the demo hides appear.
Updated on October 7, 2026