kmonad/kmonad

Features

• Keyboard Key Mappings - Remaps physical keyboard keys to different characters or modifiers to customize the input layout.
• Keyboard Layout Layers - Kanata defines alternative keyboard layouts that activate to change key functions temporarily or permanently.
• Keyboard Layout Managers - Provides a system-level tool for defining custom key mappings, layers, and modifier behaviors to redefine keyboard functionality.
• Layered Keymaps - Provides sets of key mappings that can be toggled to dynamically change the active keyboard operational mode.
• Stateful Event Buffering - Sequences key events to implement advanced functionality such as sticky modifiers, leader keys, and macro execution.
• Custom Key Behavior Definitions - Implements advanced key event interception to provide tap-hold, leader keys, and sticky modifiers.
• Advanced Mapping Engines - Implements a sophisticated logic engine for tap-hold, leader keys, and macros to expand keyboard capabilities.
• Dynamic Layering - Defines sets of keymaps that toggle to change the function of the entire keyboard dynamically.
• Dynamic Layout Layering - Manages multiple key mapping sets that can be toggled to change keyboard functionality dynamically.
• Tap-Hold Key Behaviors - Assigns different actions to a key depending on whether it is tapped quickly or held down.
• Input Timing Logic - Evaluates key press and release durations to distinguish between taps, holds, and multi-tap sequences.
• Advanced Input Behaviors - Implements advanced input behaviors such as tap-mod, multi-tap, leader-key sequences, and macros.
• Cross-Platform Input Consistency - Standardizes custom keyboard shortcut patterns and behaviors across different operating systems.
• Input Interaction Patterns - Kanata creates interaction patterns such as sticky keys, circular sequences, and timed tap-hold transitions.
• Input Remappers - Intercepts and redirects hardware input events to trigger customized virtual output events system-wide.
• Multi-Use Key Configurations - Kanata assigns different actions to a single key based on whether it is tapped, held, or pressed multiple times.
• Programmable Input Wrappers - Implements a service that routes physical hardware inputs to virtual devices to enable custom key aliases and shell command execution.
• Keyboard Event Mappings - Implements a configuration-driven system to translate raw keyboard keycodes into customized actions and aliases.
• Input Device Emulators - Emulates physical input devices to inject transformed events into the system stream via virtual devices.
• Input Device Mapping - Links physical hardware device identifiers to virtual output ports for consistent keystroke processing.
• Keyboard Input Mapping - Captures keystrokes and transforms them into different outputs based on a configurable mapping.
• Automation Shortcuts - Provides shortcuts that automatically trigger system shell commands or complex macro sequences.
• Shell Command Execution - Enables the execution of operating system shell commands triggered by specific keyboard events.
• Event-Driven Execution - Automatically triggers system shell commands based on detected keyboard input events.
• Input Sequence Macros - Executes a series of keys in a specific order as a macro with optional delays between events.
• Key Aliasing - Assigns custom names to complex key sequences to allow for their reuse across different keyboard layers.
• Modifier-Aware Key Mappings - Binds multiple keys into single actions while preserving the order and timing of modifier keys.
• Action Cycling - Kanata rotates through a sequence of different key actions each time a button is pressed.
• Input Event Timing Control - Kanata enforces minimum delays between key events or sets specific timeouts for hold and press actions.
• Sticky Modifier Modalities - Holds a modifier key active temporarily for a set duration after a single press.

Star history