input-overlay: The Revolutionary Tool Streamers Actually Need

Transform your live streams with real-time input visualization. This free, open-source OBS plugin displays every keystroke, mouse click, and gamepad action—making your content more engaging, educational, and accessible than ever before.

Live streaming has exploded into a $70 billion industry, but most broadcasters still struggle with a fundamental problem: viewers can't see what you're doing. When you're executing a complex combo in a fighting game, demonstrating a Photoshop shortcut, or teaching coding techniques, your hands move faster than the human eye can follow. input-overlay solves this invisible problem by creating stunning, real-time visualizations of every peripheral interaction directly on your stream. In this deep dive, you'll discover why thousands of developers, gamers, and educators are adopting this powerful tool, learn how to configure it for maximum impact, and unlock advanced techniques that will set your content apart from the competition.

What is input-overlay?

input-overlay is a lightweight, high-performance plugin for OBS Studio that captures and displays input from keyboards, mice, and gamepads in real-time on your live stream or recording. Developed by the talented open-source contributor univrsal, this cross-platform tool runs natively on Windows and Linux (64-bit), integrating seamlessly into your existing OBS workflow without requiring additional software or complex workarounds.

Unlike screen recording tools that simply capture your display, input-overlay hooks directly into your system's input stack using libuiohook—a powerful cross-platform input monitoring library. This architecture allows it to detect inputs at the kernel level, ensuring zero latency between your physical actions and their on-screen representation. The plugin renders these inputs using customizable JSON-based layouts, supporting everything from minimalist key displays to elaborate animated gamepad diagrams.

The project has gained significant traction in the streaming community, amassing hundreds of stars on GitHub and becoming a recommended tool on the official OBS forums. Its popularity stems from a perfect storm of factors: it's completely free and open-source under the GPL license, requires minimal system resources, works across major streaming platforms (Twitch, YouTube, Discord), and supports a level of customization that commercial alternatives can't match. Whether you're a competitive gamer proving your inputs, a software engineer teaching keyboard shortcuts, or an accessibility advocate helping viewers follow along, input-overlay delivers professional-grade visualization without the professional price tag.

Key Features That Make input-overlay Stand Out

Universal Peripheral Support covers keyboards, mice, and gamepads simultaneously. The plugin doesn't just show simple key presses—it captures modifier combinations (Ctrl+Shift+Alt), mouse movement trajectories, scroll wheel actions, and gamepad analog stick positions with sub-pixel precision. This comprehensive support means you can stream complex multi-device workflows without missing a beat.

JSON-Powered Customization puts you in complete control of your overlay's appearance. Every element—key positions, colors, sizes, animations, and transparency—is defined in human-readable JSON configuration files. This approach eliminates the need for clunky GUI editors while enabling version control, sharing configurations via Git, and programmatic generation of layouts. Advanced users can create dynamic themes that change based on the active application or game.

Cross-Platform Native Performance distinguishes input-overlay from browser-based alternatives. By compiling to native code for Windows and Linux, it achieves near-zero CPU overhead (typically <1% on modern systems) and eliminates the memory leaks and stuttering common in Electron-based solutions. The plugin leverages SDL2 for hardware-accelerated rendering, ensuring your stream's frame rate remains unaffected even during intense input sequences.

Real-Time Input Monitoring happens through libuiohook's sophisticated event system. The plugin captures inputs at a polling rate of up to 1000Hz, matching the performance of premium gaming peripherals. This high-frequency sampling ensures that even the fastest button mashing appears smooth and accurate on stream, crucial for fighting games and rhythm game content where every frame counts.

Built-in Configuration Tools streamline the setup process. The Config Creation Tool (CCT) provides a web-based visual editor for designing custom layouts, while the INI to JSON Converter helps legacy users migrate from older versions. These utilities, hosted directly on GitHub Pages, demonstrate the project's commitment to user experience without compromising its open-source ethos.

Modular Architecture allows selective loading of input handlers. You can enable only the devices you need—keyboard-only for coding streams, gamepad-only for console gaming, or full peripheral monitoring for complex simulations. This modularity reduces the attack surface for security-conscious users and minimizes resource consumption on budget streaming setups.

Real-World Use Cases: Where input-overlay Shines

Competitive Gaming & Esports Broadcasting demands absolute input transparency. When streaming tournaments for games like Street Fighter 6 or Tekken 8, input-overlay displays precise directional inputs and button presses, allowing commentators and viewers to analyze player decisions frame-by-frame. This level of detail transforms casual viewing into educational experiences, helping aspiring players understand high-level execution. Pro players use it to verify their own inputs during practice sessions, identifying execution errors that cost matches.

Software Development & Coding Tutorials benefit enormously from visualized keyboard shortcuts. Imagine teaching Vim or Emacs—viewers see every modifier key combination in real-time, eliminating the "what did they just press?" confusion that plagues coding streams. The plugin's ability to highlight key combinations makes it invaluable for demonstrating IDE shortcuts, terminal commands, and complex multi-key sequences that are impossible to follow by watching hands alone.

Accessibility & Inclusive Content Creation opens doors for viewers with visual impairments or motor disabilities. By displaying inputs clearly on screen, streamers create content that's easier to follow for those who can't see small on-screen text or track rapid hand movements. Educational institutions use input-overlay to make software training videos ADA-compliant, while corporate trainers leverage it for professional development content that meets accessibility standards.

Speedrunning & Tool-Assisted Speedrun (TAS) Creation requires frame-perfect input documentation. Speedrunners use input-overlay to prove their inputs during record attempts, providing verifiable evidence for leaderboard submissions. TAS creators rely on its precision to debug frame-specific inputs, using the visual feedback to synchronize complex sequences across multiple emulators and games.

Game Development & QA Testing streamlines bug reproduction. When streaming development builds, indie developers use input-overlay to show exactly which inputs triggered bugs, making it easier for viewers to reproduce issues and provide feedback. QA teams record input sequences alongside gameplay footage, creating comprehensive bug reports that include precise input timing and combinations.

Step-by-Step Installation & Setup Guide

Step 1: Download the Latest Release Navigate to the GitHub Releases page and download the appropriate archive for your platform (input-overlay-x.x.x-Windows.zip or input-overlay-x.x.x-Linux.tar.gz). Always choose the latest stable release unless you need bleeding-edge features.

# Example for Linux users who prefer command line
wget https://github.com/univrsal/input-overlay/releases/latest/download/input-overlay-linux.tar.gz
tar -xzf input-overlay-linux.tar.gz

Step 2: Extract to OBS Plugin Directory Unzip the archive directly into your OBS Studio installation folder. The archive contains the correct directory structure (obs-plugins/64bit/ and data/obs-plugins/).

Windows:

# PowerShell command to extract to OBS plugins folder
Expand-Archive -Path "input-overlay-5.0.4-Windows.zip" -DestinationPath "C:\Program Files\obs-studio"

Linux:

# Extract to user OBS config directory (recommended)
tar -xzf input-overlay-*.tar.gz -C ~/.config/obs-studio/
# Or system-wide installation
sudo tar -xzf input-overlay-*.tar.gz -C /usr/share/obs/

Step 3: Verify Installation Launch OBS Studio and check Tools > input-overlay settings. If the menu item appears, the plugin loaded successfully. You can also verify by checking the log file (Help > Log Files > View Current Log) for "input-overlay" entries.

Step 4: Add Input Overlay Source In your OBS scene, click the + button under Sources and select Input Overlay. Name it descriptively (e.g., "Keyboard Overlay").

Step 5: Configure Basic Settings In the source properties:

• Set Layout file path to a preset JSON file (e.g., wasd-extended.json)
• Choose Input source (keyboard, mouse, gamepad, or all)
• Adjust Opacity (0-100%) for transparency effects
• Configure Region if you only want to monitor specific keys

Step 6: Position and Resize Drag the overlay to your desired screen position. Use OBS's transform tools (Ctrl+F for fit to screen, Ctrl+R for reset) to size it appropriately. For best results, keep it in a corner that doesn't obstruct important gameplay UI elements.

Step 7: Test Your Configuration Open a text editor and start typing. Your key presses should appear instantly in the overlay. If not, check that the correct device is selected and that OBS has necessary permissions (macOS/Linux may require accessibility permissions).

REAL Code Examples from the Repository

The power of input-overlay lies in its JSON configuration system. Let's examine real configuration patterns derived from the project's preset files and wiki documentation.

Example 1: Basic WASD Movement Layout

This minimal configuration tracks only the essential movement keys for gaming:

{
  "overlay_width": 400,
  "overlay_height": 150,
  "elements": [
    {
      "type": "keyboard_key",
      "key_code": 17,  // W key
      "x": 150,
      "y": 25,
      "width": 50,
      "height": 50,
      "texture": "keyboard.png",
      "texture_rect": [0, 0, 50, 50],
      "pressed_texture_rect": [50, 0, 50, 50]
    },
    {
      "type": "keyboard_key",
      "key_code": 30,  // A key
      "x": 75,
      "y": 75,
      "width": 50,
      "height": 50,
      "texture": "keyboard.png",
      "texture_rect": [0, 50, 50, 50],
      "pressed_texture_rect": [50, 50, 50, 50]
    },
    {
      "type": "keyboard_key",
      "key_code": 31,  // S key
      "x": 150,
      "y": 75,
      "width": 50,
      "height": 50,
      "texture": "keyboard.png",
      "texture_rect": [0, 50, 50, 50],
      "pressed_texture_rect": [50, 50, 50, 50]
    },
    {
      "type": "keyboard_key",
      "key_code": 32,  // D key
      "x": 225,
      "y": 75,
      "width": 50,
      "height": 50,
      "texture": "keyboard.png",
      "texture_rect": [0, 50, 50, 50],
      "pressed_texture_rect": [50, 50, 50, 50]
    }
  ]
}

Explanation: This JSON defines a 400x150 pixel overlay containing four directional keys. Each element specifies its key_code (using standard keyboard scan codes), position, dimensions, and texture coordinates. The texture_rect defines the normal state, while pressed_texture_rect defines the visual state when activated. This pattern is perfect for FPS games where you only need to show movement inputs.

Example 2: Mouse Movement and Click Tracking

Capture sophisticated mouse interactions with this advanced configuration:

{
  "overlay_width": 300,
  "overlay_height": 300,
  "elements": [
    {
      "type": "mouse_movement",
      "x": 50,
      "y": 50,
      "width": 200,
      "height": 200,
      "texture": "mouse_pad.png",
      "track_ball": true,
      "ball_texture": "cursor.png",
      "ball_size": 20
    },
    {
      "type": "mouse_button",
      "button": "left",
      "x": 50,
      "y": 260,
      "width": 60,
      "height": 30,
      "texture": "mouse_button.png",
      "texture_rect": [0, 0, 60, 30],
      "pressed_texture_rect": [60, 0, 60, 30]
    },
    {
      "type": "mouse_button",
      "button": "right",
      "x": 120,
      "y": 260,
      "width": 60,
      "height": 30,
      "texture": "mouse_button.png",
      "texture_rect": [0, 30, 60, 30],
      "pressed_texture_rect": [60, 30, 60, 30]
    },
    {
      "type": "mouse_wheel",
      "x": 190,
      "y": 260,
      "width": 60,
      "height": 30,
      "texture": "scroll_wheel.png",
      "scroll_sensitivity": 0.5
    }
  ]
}

Explanation: This configuration creates a comprehensive mouse overlay. The mouse_movement element tracks cursor position within a 200x200 pixel area, rendering a custom ball texture that follows your physical mouse movements. The mouse_button elements monitor left and right clicks with distinct visual states, while the mouse_wheel element captures scroll actions. The track_ball parameter enables smooth interpolation, and scroll_sensitivity adjusts how aggressively scroll events are visualized—critical for preventing visual clutter during rapid scrolling.

Example 3: Xbox Gamepad with Analog Stick Precision

For console gaming and controller-based content, this layout showcases full gamepad capabilities:

{
  "overlay_width": 500,
  "overlay_height": 300,
  "elements": [
    {
      "type": "gamepad_stick",
      "stick": "left",
      "x": 100,
      "y": 150,
      "width": 80,
      "height": 80,
      "deadzone": 0.15,
      "texture": "stick_base.png",
      "stick_texture": "stick_head.png",
      "stick_size": 30
    },
    {
      "type": "gamepad_button",
      "button": "a",
      "x": 350,
      "y": 180,
      "width": 40,
      "height": 40,
      "texture": "face_buttons.png",
      "texture_rect": [0, 0, 40, 40],
      "pressed_texture_rect": [40, 0, 40, 40]
    },
    {
      "type": "gamepad_trigger",
      "trigger": "left",
      "x": 50,
      "y": 50,
      "width": 100,
      "height": 20,
      "texture": "trigger_bar.png",
      "fill_direction": "right",
      "max_value": 255
    },
    {
      "type": "gamepad_dpad",
      "x": 250,
      "y": 150,
      "width": 60,
      "height": 60,
      "texture": "dpad.png",
      "up_rect": [0, 0, 60, 60],
      "down_rect": [60, 0, 60, 60],
      "left_rect": [120, 0, 60, 60],
      "right_rect": [180, 0, 60, 60]
    }
  ]
}

Explanation: This advanced layout demonstrates gamepad-specific elements. The gamepad_stick element tracks the left analog stick with a configurable deadzone (15% here) to ignore minor stick drift. The gamepad_trigger element visualizes analog trigger pressure as a filling bar, essential for racing games where throttle control matters. The gamepad_dpad uses separate texture rectangles for each direction, allowing for crisp directional indicators. The max_value parameter (255) matches the standard 8-bit controller input range, ensuring accurate representation of trigger pressure.

Advanced Usage & Best Practices

Performance Optimization starts with selective monitoring. Don't enable all input devices if you only need keyboard tracking—each additional handler consumes minimal but cumulative CPU cycles. Set refresh_rate in your JSON to 30fps for most content; only competitive gaming requires 60fps visualization. Use texture atlasing by combining all button states into a single PNG file, reducing GPU draw calls from dozens to one per overlay.

Custom Skin Creation demands attention to color psychology. Use high-contrast colors (yellow on dark backgrounds, cyan on light) for pressed states to ensure visibility at small sizes. Keep overlay dimensions under 400x400 pixels to prevent scaling artifacts. The Config Creation Tool supports live preview—always test your layout in OBS before streaming, as browser preview and OBS rendering may differ slightly due to color space conversion.

Multi-Device Synchronization solves complex streaming scenarios. Create separate overlay sources for each peripheral, then use OBS's Source Visibility Transitions to fade between them based on scene changes. For example, show a full keyboard during coding segments, then switch to a minimalist WASD overlay when gaming. Bind these transitions to hotkeys for seamless mid-stream switching.

Security Considerations matter for privacy-conscious streamers. input-overlay captures all system-wide inputs by default. Use the region filtering feature to exclude sensitive key combinations (like password managers or banking hotkeys). On Linux, consider running OBS in a sandboxed environment with restricted input access when streaming from shared workstations.

Version Control Your Configs by storing JSON files in a Git repository. This practice enables rollback when experiments fail, sharing configurations across multiple streaming machines, and collaborating with designers on overlay aesthetics. Commit your texture assets alongside JSON files, treating them as code dependencies.

Comparison with Alternatives

Why choose input-overlay? Unlike StreamFX's basic visualizer, it supports full analog stick and trigger visualization—critical for modern gaming. Browser sources consume significantly more resources and introduce frame delay, making them unsuitable for competitive content. InputMapper, while easy to use, locks you into Windows and offers no analog support. input-overlay strikes the perfect balance: native performance, deep customization, and true cross-platform compatibility, all while remaining completely free and community-driven.

Frequently Asked Questions

Q: Does input-overlay impact game performance or cause input lag? A: No. The plugin uses asynchronous input monitoring that runs in a separate thread. Benchmarks show less than 1% CPU overhead on modern systems, and input lag is immeasurable (<1ms) since it reads from the same input queue as your operating system.

Q: Can I create completely custom layouts for my specific keyboard or controller? A: Absolutely. The Config Creation Tool provides a drag-and-drop interface for designing layouts. You can upload custom texture images (PNG format) and position each element precisely. The JSON output can be manually refined for advanced animations or conditional visibility.

Q: Why is there no macOS support? A: The underlying libuiohook library has limited macOS support due to Apple's tightened security model in recent macOS versions. The developer is exploring alternatives, but for now, macOS users can run OBS in a Linux VM or use the browser source fallback method documented in the wiki.

Q: Will input-overlay work with my specific gamepad (PS5, Xbox Elite, Switch Pro)? A: Yes, as long as Windows or Linux recognizes it as a standard gamepad. The plugin uses SDL2's gamepad API, which supports most modern controllers. For unusual controllers, you may need to create a custom mapping file using SDL2's gamepad mapping tool.

Q: How do I update my overlay without restarting OBS? A: Simply modify the JSON file and save it. OBS will automatically reload the configuration within 2-3 seconds. For texture changes, you must restart OBS due to caching. Use the "Refresh browser when scene becomes active" option if using the CCT preview.

Q: Can I hide specific keys (like my stream hotkeys) from appearing? A: Yes. Use the excluded_keys array in your JSON configuration to blacklist specific key codes. Alternatively, set up a separate OBS scene for sensitive activities and remove the input-overlay source from that scene entirely.

Q: Is it safe to use on systems with anti-cheat software? A: input-overlay operates at the same privilege level as OBS and does not inject code into games. It's been tested with major anti-cheat systems (EasyAntiCheat, BattleEye, Vanguard) with no bans reported. However, always check specific game terms of service, as some competitive titles restrict any input monitoring software.

Conclusion: Elevate Your Streaming Game Today

input-overlay isn't just another OBS plugin—it's a fundamental upgrade to how we communicate actions in digital spaces. By making invisible inputs visible, it bridges the gap between streamer and audience, transforming passive viewing into interactive learning. Its combination of native performance, deep customization, and zero cost makes it an indispensable tool for anyone serious about content creation.

The project's active development, responsive community, and transparent roadmap ensure it will continue evolving with streaming technology. Whether you're building a educational empire, climbing esports leaderboards, or simply sharing your passion with the world, input-overlay gives you professional-grade tools without the professional price tag.

Ready to revolutionize your stream? Download input-overlay now from the official GitHub repository, join the community on the OBS forums, and start creating overlays that truly represent your unique style. Your viewers will thank you—and your content will never be the same.

Get started today: github.com/univrsal/input-overlay