Universal-Dear-ImGui-Hook

A Dear ImGui overlay that draws your interface inside another application, whatever graphics API it uses, and lets an AI assistant such as Claude Code see and play the game through MCP over a local named pipe or Unix socket. The API is detected at runtime: build once, inject anywhere.

Windows games running under Wine or Proton use the Windows DLL.

Contents

• Features
• Quick start
• Usage: Windows, Linux, settings, your menu, as a library
• Remote control by an AI assistant
• API
• How it works
• Building
• Tests
• Contributing
• Limitations
• Support

Sections marked with ▶ unfold on click.

Features

• One library for every API: the backend is picked from the first API that presents a frame. Inject before or after the game initializes its graphics.
• Remote control by an AI assistant: through MCP and a local named pipe (Windows) or Unix socket (Linux), an assistant such as Claude Code sees the game, writes to the player over it and presses its keys.
• Menu input: INSERT, or L3 + R3 on a controller, opens the menu; F11 removes the overlay and unloads the DLL. The keys are settings in example/config.cpp. While the menu is open the game sees no keyboard, mouse or controller input (Windows), and an XInput controller navigates the menu.
• No crash from the overlay (Windows, MSVC builds): an exception in the overlay, from a renderer backend or the menu code, removes it instead of taking the game down; the menu key brings it back.
• Images and frame capture: uih::CreateTexture() turns RGBA pixels into an image for ImGui::Image(), and uih::CaptureFrame() copies what the game draws, without the overlay, on every backend.
• Several windows: when the game presents to more than one window or swap chain, the overlay stays on one of them and follows the focus.
• Readable on any display: the interface follows the DPI of the game window, or a fixed scale, with correct colors on sRGB and floating-point back buffers.
• No injector needed: the DLL can be loaded as dinput8.dll, and the Linux library with LD_PRELOAD.
• No dependencies: Dear ImGui, MinHook and the Vulkan headers are vendored; the C and C++ runtimes are linked statically.

Quick start

1. Get the library. Prebuilt libraries are attached to each release, and every commit’s builds are kept as workflow artifacts. Pick the one that matches the game, not your machine:

2. Or build it. On Windows, open Universal-ImGui-Hook.sln in Visual Studio 2022 or newer and build Release|x64: the DLL is build/vs/x64/Release/Universal-ImGui-Hook.dll. On Linux:

sudo apt install cmake ninja-build g++ pkg-config libxcb1-dev
cmake --preset linux && cmake --build --preset linux
LD_PRELOAD=$PWD/build/linux/Universal-ImGui-Hook.so ./game

3. Make it yours. You only edit the example; the hook itself, in src/, needs no change:

Usage

Windows

Inject Universal-ImGui-Hook.dll with any injector or LoadLibrary. An injected DLL is unloaded by F11; inject it again to bring the overlay back.

To load it without an injector, rename it to dinput8.dll and put it next to the game’s executable: it exports DirectInput8Create and forwards it to the system library, so any game that imports DirectInput 8 loads it. Under Wine or Proton, add WINEDLLOVERRIDES="dinput8=n,b" %command% to the launch options. Loaded this way the DLL stays in the game, which references it: F11 removes the overlay and INSERT brings it back.

Logs (config.debugLog) go to OutputDebugString: read them with DebugView. The example DLL writes them when the game runs with the environment variable UIH_DEBUG=1.

Linux

LD_PRELOAD=/path/to/Universal-ImGui-Hook.so ./game

For a Steam game, set the launch options to LD_PRELOAD=/path/to/Universal-ImGui-Hook.so %command%. UIH_DEBUG=1 prints the log on stderr. A preloaded library cannot leave the process: F11 removes the overlay and its hooks, and INSERT brings them back.

Settings

The settings of the example library are compiled into it: edit example/config.cpp, next to dllmain.cpp, and rebuild.

void ApplySettings(uih::Config& config) {
    config.menuKey = VK_INSERT;                              // opens and closes the menu
    config.unloadKey = VK_F11;                               // removes the overlay, unloads the DLL
    config.menuButtons = uih::GamepadL3 | uih::GamepadR3;    // controller buttons held together, 0 to disable
    config.backend = uih::Backend::None;                     // graphics API to hook, None detects it
    config.scale = 0.0f;                                     // interface size, 0 follows the DPI
    config.remoteControl = false;                            // remote control by an AI assistant
    config.remotePipe = "universal-imgui-hook";              // name of its pipe (Windows) or socket (Linux)
}

Writing your menu

The interface lives in example/menu.cpp. DrawMenu() is called every frame between ImGui::NewFrame() and ImGui::Render(), so any Dear ImGui code works there. The entry points, example/dllmain.cpp on Windows and example/preload.cpp on Linux, apply the settings and start the hook:

uih::Config config;
ApplySettings(config);         // example/config.cpp
config.render = DrawMenu;      // every frame
config.setup = LoadFonts;      // when the ImGui context is created: fonts, style
config.module = module;        // Windows: DLL unloaded by unloadKey
uih::Start(config);

Images are created once from RGBA pixels and drawn like any ImGui texture:

static ImTextureData* logo = uih::CreateTexture(pixels, 64, 64);
ImGui::Image(logo->GetTexRef(), ImVec2(64, 64));

The example menu is a tour of the common widgets (buttons, combo and list boxes, inputs, sliders, colors, tabs, trees, tables, plots, popups, draw lists) with imgui.png shown under the slider, and its Menu bar opens Dear ImGui’s own demo window, which covers every function. example/image.cpp embeds the picture in the library and decodes it with stb_image.

Using the hook as a library

The repository is a CMake package; link uih::uih to get include/uih.h and Dear ImGui’s headers:

include(FetchContent)
FetchContent_Declare(uih GIT_REPOSITORY https://github.com/Sh0ckFR/Universal-Dear-ImGui-Hook.git GIT_TAG master)
FetchContent_MakeAvailable(uih)
target_link_libraries(my_overlay PRIVATE uih::uih)

tests/consumer/ is a complete example, built by the CI. On Linux, linking uih::uih into a shared library applies src/linux/exports.map, which only exports the hooked functions.

Remote control by an AI assistant

The library can let an AI assistant, such as Claude Code, see the game, write to the player over it and press its keys, through the Model Context Protocol (MCP) and a local named pipe on Windows, or a Unix socket on Linux. Every graphics API; on Linux, X11 and XWayland games.

flowchart LR
    A["Assistant, such as Claude Code"] -- "MCP on stdin and stdout" --> B["remote/uih_mcp.py"]
    B -- "local named pipe or Unix socket" --> C["The library in the game"]

1. Turn it on in example/config.cpp, then build the DLL or the .so:

config.remoteControl = true;
config.remotePipe = "universal-imgui-hook";   // \\.\pipe\universal-imgui-hook, or $XDG_RUNTIME_DIR/universal-imgui-hook on Linux

2. Load it into the game, with any injector, as dinput8.dll, or with the script, which needs Python 3.8 or newer and nothing else:

python remote/uih_mcp.py inject game.exe build/vs/x64/Release/Universal-ImGui-Hook.dll

On Linux, preload it: LD_PRELOAD=/path/to/Universal-ImGui-Hook.so ./game. The socket opens with the first frame of the overlay, in the process that draws it, not in the launch scripts that preload the library too.

3. Give the assistant the MCP server, once. With Claude Code:

claude mcp add game -- python C:/path/to/Universal-Dear-ImGui-Hook/remote/uih_mcp.py

On Linux, the same with python3 /path/to/Universal-Dear-ImGui-Hook/remote/uih_mcp.py. With another remotePipe, add --pipe after the script. Other MCP clients, such as Claude Desktop, take the same command in their configuration:

{
  "mcpServers": {
    "game": { "command": "python", "args": ["C:/path/to/Universal-Dear-ImGui-Hook/remote/uih_mcp.py"] }
  }
}

4. Ask. Start a new session of the assistant, or run /mcp in Claude Code, and talk about the game:

• Look at the game and tell me what you see.
• Write “Well done!” in the game for 5 seconds.
• Walk right to the edge of the platform, then jump.
• Open the overlay menu and describe it.

The assistant gets these tools:

API

Everything is in include/uih.h, namespace uih.

How it works

Building

Each preset builds into build/.

Visual Studio 2022 or newer, with the “Desktop development with C++” workload. Pick one:

• Universal-ImGui-Hook.sln builds the DLL and uih_host without CMake, into build/vs///.
• Open the folder: Visual Studio reads CMakePresets.json.
• Command line: cmake --preset msvc-x64, then cmake --build --preset msvc-x64.

Tests

-DUIH_BUILD_TESTS=ON builds uih_host, which renders a solid color with one API and checks the overlay, and registers the scenarios with CTest:

cmake --preset msvc-x64 -DUIH_BUILD_TESTS=ON && cmake --build --preset msvc-x64
ctest --test-dir build/msvc-x64 -C Release

Some tests press real keys and move the mouse. They are skipped when the host window does not have the focus: leave the machine alone while they run. A test whose screen check fails saves the capture as build/tests/capture-*.bmp.

Contributing

• A new source file goes into CMakeLists.txt and the matching project in vs/.
• A fix comes with a uih_host scenario that fails without it.
• Run the CTest suite on Windows; the CI covers Linux.

Limitations

Windows

• HDR10 swap chains (PQ color space) show the overlay with wrong colors, and CaptureFrame() only copies 8-bit and 10-bit back buffers: the floating-point ones of HDR output are not captured.
• A Vulkan swap chain created before the hook has no overlay until the game recreates it: its presents report VK_SUBOPTIMAL_KHR, which games answer by recreating it.
• When the game, or another overlay, subclasses the window after the hook, the hook’s window procedure stays in its chain: the unload key leaves the DLL loaded, and injecting it again does not start it.
• Native ARM64 Windows games are not supported: MinHook only handles x86 and x64.
• Only Windows builds made with MSVC, the released ones, survive an exception in the overlay: MinGW-w64 has no structured exception handling, and Linux builds are not protected either.
• D3D9: after an exception in a draw callback (ImDrawList::AddCallback), the state block of the Dear ImGui backend is never released, and the game cannot reset its device.

Linux

• Input is read from the X server: native Wayland windows get no menu input (run SDL games with SDL_VIDEODRIVER=x11), and the game still receives the keyboard and the mouse while the menu is open. The mouse wheel and input methods are not handled.
• 32-bit games, OpenGL ES, and games that link their GL or Vulkan loader statically are not supported.
• The remote control sends no keys to native Wayland games.

Credits

Built with Dear ImGui, MinHook, Vulkan-Headers and stb_image (the example’s picture).

Support

This project is free and MIT-licensed. Building it from scratch represents roughly 83 days of senior C++ work, about €54,000 at French freelance rates: six graphics backends on two operating systems, input blocking, crash protection, frame capture and the remote control by an AI assistant, and about 130 test scenarios run on every commit, real games included. If it saved you time, consider sponsoring or starring the repository.

License

This project is licensed under the MIT License - see the LICENSE file for details.