Skip to content
This repository has been archived by the owner on Sep 7, 2021. It is now read-only.


Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?


Failed to load latest commit information.
Latest commit message
Commit time

This project is archived. It's neither maintained nor developed anymore.

Gainput Build Status MIT licensed

Gainput is the awesome C++ input library for your game:

  • handles your input needs from low-level device reading to high-level mapping of user-defined buttons
  • well-documented, clean, lightweight, and easy to use
  • a unified interface on all supported platforms: Android NDK, iOS/tvOS, Linux, macOS, Windows
  • supported devices: keyboard, mouse, gamepad, multi-touch, device built-in sensors
  • Open Source (MIT license)
  • complete list of features
  • API documentation


#include <gainput/gainput.h>

enum Button

gainput::InputManager manager;
manager.SetDisplaySize(displayWidth, displayHeight);
const gainput::DeviceId keyboardId = manager.CreateDevice<gainput::InputDeviceKeyboard>();
const gainput::DeviceId mouseId = manager.CreateDevice<gainput::InputDeviceMouse>();
const gainput::DeviceId padId = manager.CreateDevice<gainput::InputDevicePad>();
const gainput::DeviceId touchId = manager.CreateDevice<gainput::InputDeviceTouch>();

gainput::InputMap map(manager);
map.MapBool(ButtonConfirm, keyboardId, gainput::KeyReturn);
map.MapBool(ButtonConfirm, mouseId, gainput::MouseButtonLeft);
map.MapBool(ButtonConfirm, padId, gainput::PadButtonA);
map.MapBool(ButtonConfirm, touchId, gainput::Touch0Down);

while (running)

	// May need some platform-specific message handling here

	if (map.GetBoolWasDown(ButtonConfirm))
		// Confirmed!


  • Offers a unified interface on all supported platforms. (Some minor changes are necessary to setup the library.)
  • Provides a low-level and high-level interface: Query the state of input devices buttons directly or map device buttons to a user button. That way it's easy to support alternative inputs or change the input mappings around later.
  • Supports recording and playback of input sequences.
  • Features a network server to obtain information on devices and mappings from.
  • Two Gainput instances can sync device states over the network. It's also possible to receive multi-touch inputs from a smartphone's regular browser.
  • Completely written in portable C++.
  • No STL is used. No exceptions are thrown. No RTTI is used. No C++11, and no boost.
  • No weird external dependencies are used. Relies on the existing platform SDKs.
  • Easily set up and built using your favorite IDE/build tool.
  • Listeners can be installed both for devices buttons as well as user buttons. That way you are notified when a button state changes.
  • Gestures allow for more complex input patterns to be detected, for example double-clicking, pinch/rotation gestures, or holding several buttons simultaneously.
  • An external allocator can be supplied to the library so that all memory management is done the way you want it.
  • Supports raw input on Linux and Windows.
  • Gamepad rumbling is supported where available.
  • It's easy to check for all pressed buttons so that offering a way to the players to remap their buttons is easy to implement. Similarly it's easy to save and load mappings.
  • Possibly unnecessary features, like gestures or the network server, are easily disabled.
  • Dead zones can be set up for any float-value button.
  • State changes, i.e. if a button is newly down or just released, can be checked for.


By default, Gainput is built using CMake.

  1. Run mkdir build
  2. Run cmake ..
  3. Run make
  4. The library can be found in lib/, the executables in samples/.


Everyone is welcome to contribute to the library. If you find any problems, you can submit them using GitHub's issue system. If you want to contribute code, you should fork the project and then send a pull request.


Gainput has a minimal number of external dependencies to make it as self-contained as possible. It uses the platforms' default ways of getting inputs and doesn't use the STL.


Generally, testing should be done by building and running Gainput on all supported platforms. The samples in the samples/ folder should be used in order to determine if the library is functional.

The unit tests in the test/ folder are built by the normal CMake build. The executable can be found in the test/ folder. All build configurations and unit tests are built and run by Travis CI whenever something is pushed into the repository.