egui is a mature, cross-platform immediate-mode GUI library for Rust. Application code describes the UI every frame rather than retaining a widget tree; egui processes pointer, keyboard, and touch input, runs layout, paints built-in and custom widgets, and outputs a triangle mesh plus platform output such as clipboard changes, cursor updates, and an accessibility tree. The repository is organized as a Cargo workspace: `emath` and `ecolor` provide math and color primitives, `epaint` handles tessellation, text layout, and texture management, `egui` is the core UI layer, and `eframe` packages native (winit + glow/wgpu) and web (WASM/WebGL/WebGPU) backends. Extension crates add tables, image loaders, syntax highlighting, a testing harness (`egui_kittest`), and a large demo application with dozens of examples. This is purely an application/framework repository, not a data or research project. The architecture is cleanly layered: foundational math/graphics crates are decoupled from the immediate-mode UI state and from platform integrations. The codebase shows exceptionally high craftsmanship in areas such as scroll physics with kinetic coasting and rubber-banding, CPU-side tessellation with anti-aliased feathering, dynamic glyph texture atlases, and a robust accessibility integration via AccessKit. It has extensive snapshot and accessibility tests, per-crate changelogs, and CI workflows for linting, typo checks, link checking, and web preview deploys. The main maintenance risks are feature-flag complexity and the ongoing burden of keeping multiple rendering backends (glow, wgpu, web) behaviorally in sync, but the code is actively maintained and dependency pins are deliberate and documented.
Dear ImGui is a production-grade, immediate-mode graphical user interface library for C++. It provides a self-contained core engine (rendering, widgets, tables, fonts, input handling) and a large ecosystem of platform and renderer backends (GLFW, SDL2/3, Win32, Vulkan, DirectX, Metal, OpenGL, WebGPU, etc.) that enable integration into any application with minimal overhead. The architecture is a library with pluggable backends: user code calls ImGui::NewFrame() to build UI, then ImGui::Render() produces draw data consumed by the chosen renderer backend. The repository includes dozens of example applications demonstrating integration with various windowing systems and graphics APIs, as well as utilities like font embedding tools, FreeType rasterizer integration, and a headless backend for testing. It is not a data research project; it is a software library for building tools, debug UIs, and in-game overlays.
shadPS4 is a PlayStation 4 emulator for Windows, Linux, and macOS, written in C++20. It emulates the PS4's AMD GCN GPU via a custom shader recompiler that translates GCN instructions to SPIR-V, and implements high-level emulation (HLE) of PS4 system libraries (kernel, libc, networking, audio, video, input, etc.). The architecture is monolithic with modular subsystems: a Vulkan renderer with texture/buffer caches, a shader recompiler with IR optimization passes, a file system abstraction supporting host files and ZArchive, and an ImGui-based debug UI. While many library functions are stubbed or partially implemented, the core GPU and CPU emulation is functional enough to run several commercial games. The codebase demonstrates strong engineering practices with reusable common utilities (bitfields, slot containers, thread-safe queues) and a well-structured shader compilation pipeline. It is a hybrid project, combining software application development with significant reverse-engineering and data analysis of PS4 firmware and GPU architecture.
MangoHud is a Linux-first, in-process performance monitoring overlay for Vulkan and OpenGL games. It injects a HUD that shows FPS, frame times, CPU/GPU load, temperatures, clocks, power, VRAM/RAM usage, I/O, network, battery, and media player metadata. The code implements this through multiple low-level integration paths: a Vulkan implicit layer, OpenGL/EGL/GLX swapchain hooks, LD_PRELOAD shims, a gamescope companion app (mangoapp), and a Windows DLL path that uses kiero to hook D3D11/D3D12 and DXGI. Hardware metrics are collected from Linux sysfs/proc interfaces, vendor libraries like NVML and XNVCtrl, and vendor-specific DRM/hwmon backends for AMD, Intel, NVIDIA, Panfrost/Panthor, and Qualcomm GPUs.
This repository contains raygui, an immediate-mode GUI library for the raylib game programming library. It is written entirely in C as a single header file (src/raygui.h). The library provides over 25 controls (buttons, sliders, text boxes, list views, color pickers, etc.) designed specifically for building development tools, debug overlays, and editors. The architecture follows an immediate-mode pattern where controls are drawn and return their state every frame, with no retained state managed by the library, making it highly predictable and easy to integrate into existing game loops. A powerful styling system allows complete customization of colors, fonts, and metrics, with over 20 pre-built themes provided in the styles/ directory. The library also includes a built-in icon system with 256+ 16x16 icons. While tightly coupled to raylib by default, a standalone mode (RAYGUI_STANDALONE) allows it to be adapted to any graphics library by implementing a small set of backend functions. The examples directory contains several high-quality, reusable custom widgets (curve editor, property list, file dialog) that demonstrate how to extend the library. The codebase is mature, well-documented, and actively maintained, representing a high standard of C library craftsmanship within its domain.
REPENTOGON is a comprehensive modding framework for the game The Binding of Isaac: Repentance. It extends the game's Lua API with hundreds of new functions, provides low-level hooking and assembly patching capabilities, integrates ImGui for developer tools, and adds features like custom item pools, save syncing, virtual room management, and achievement tracking. The architecture is a hybrid of a C++ DLL that injects into the game process and a set of Lua scripts that run in the game's Lua environment. Key entry points include the DLL main (dllmain.cpp) which initializes hooks and patches, and the Lua registration system (LuaInit.cpp) which exposes new classes and callbacks. The framework relies on reverse-engineered game structures, signature scanning, and runtime code modification to achieve deep integration. External dependencies include the game itself, Lua 5.4, ImGui, and several bundled libraries (glad, rapidxml, rapidjson, mINI). The codebase is large and actively maintained, with a strong focus on modder extensibility and bug fixing.
UImGui is a Unity package that integrates Dear ImGui (immediate-mode GUI library) with the Unity game engine. It provides a complete solution for creating debug UIs, internal tools, runtime overlays, and editor-like workflows within Unity applications. The architecture centers around a UImGui MonoBehaviour that manages the Dear ImGui frame loop, with abstractions for rendering (Mesh vs Procedural), input (Input Manager vs Input System), and optional plugin integrations (ImPlot, ImNodes, ImGuizmo, etc.). The package supports all three Unity render pipelines (Built-in, URP, HDRP) and both Unity input systems, with proper texture handling, font management via FreeType, and docking support.
This is a Unity Editor extension package that injects custom GUI into Unity's toolbar via reflection. The core library (ToolbarExtender.cs) exposes two static lists of Action delegates (LeftToolbarGUI and RightToolbarGUI) that users populate in InitializeOnLoad static constructors. The companion ToolbarCallback.cs handles the low-level reflection hooking, with version-specific code paths for Unity 2018 through Unity 6.3 (which uses UI Toolkit docks instead of IMGUI). Two example implementations demonstrate usage: a scene switcher with numbered buttons and a scene view focuser toggle that persists state via EditorPrefs. The architecture is minimal but effective; the library has no external dependencies beyond the Unity Editor API and is distributed as a UPM package. The code is well-structured for its niche, though it remains inherently fragile due to its reliance on Unity's internal API reflection.
Cyber Engine Tweaks (CET) is a Windows DLL plugin (ASI) for Cyberpunk 2077 that provides a Lua scripting environment, an in-game Dear ImGui overlay, and a suite of developer tools for modding. It hooks into the game's DirectX 12 renderer and RED4ext runtime to expose internal game systems (RTTI, TweakDB, singletons, functions) to Lua scripts. The architecture is a singleton orchestrator (CET) that owns subsystems: a Lua VM (sol2 + LuaJIT), an ImGui overlay with dockable widgets (Console, TweakDB Editor, Settings, Bindings, Game Log), a raw input binding system, a persistent state manager, and a set of memory patches (disable vignette, boundary teleport, etc.). Mods are placed in a designated folder and can register callbacks for game events, create UI, manipulate game data, and override game functions via a hooking chain.
Razix is a multi-platform 3D game engine built in C++ with a focus on modern graphics APIs (Vulkan, DirectX 12, OpenGL). It features a custom rendering hardware interface (RHI), a frame graph system for efficient render pass scheduling, an entity-component system (ECS) for scene management, and a built-in editor with ImGui integration. The engine includes a Lua scripting system, physics integration via Jolt Physics, and a comprehensive memory management layer with custom allocators. Despite its ambitious scope and active development, the codebase exhibits a mix of well-engineered subsystems and areas of legacy code (e.g., LIMBO_STATE). The project provides testing frameworks for both engine core and graphics pipelines, and maintains a dedicated game project ('Tanu') as a showcase.
cimgui is a C language binding generator and wrapper library for Dear ImGui, a popular C++ immediate-mode GUI library. It provides a programmatically generated C API (cimgui.h/cpp) that exposes both public and internal ImGui functions, structs, and enums, along with backend-specific wrappers for GLFW, SDL2/3, Vulkan, OpenGL, and DirectX11. The core of the project is a Lua-based code generator (generator.lua, cpp2ffi.lua) that parses ImGui C++ headers and emits C bindings, metadata files (JSON/Lua), and backend implementations. The repository includes example applications demonstrating usage with various graphics backends and a CMake-based build system for easy integration. While not a standalone application, it serves as a foundational library for embedding Dear ImGui in C projects or for generating FFI bindings to other languages (e.g., Python, Rust, C#). The generator is designed to be extensible, supporting custom configurations and inherited types, making it suitable for binding other ImGui-based libraries like cimplot or cimnodes.
This repository provides a reusable, interactive node editor library built on top of Dear ImGui. It is a pure C++ library with a public API that enables embedding a visual node/graph editor into any ImGui-based application. The core implementation handles node and link creation, dragging, selection, zoom/pan, context menus, cut/copy/paste, flow animations, and state serialization via a bundled JSON library. It is not a standalone application but ships with several examples and an application framework (Win32/DirectX11, GLFW/OpenGL) to demonstrate usage. The architecture is modular, with separate components for canvas rendering, bezier math, and JSON serialization, making individual parts reusable in other projects. The repository is well-maintained with active issue triage and recent commits, though it has medium technical drift due to heavy version-conditional code for Dear ImGui compatibility and reliance on some outdated dependencies (DirectX SDK, older stb versions).
SysDVR is a Nintendo Switch homebrew streaming tool that captures the console's video and audio output and streams it to external clients via USB, TCP, or RTSP. The system comprises three main components: a sysmodule (C code) running on the Switch that interfaces with the grc:d service to capture frames and audio, a cross-platform client (C# .NET 9) that receives the stream, decodes it with FFmpeg, and renders/records using SDL2 and ImGui, and a configuration app (C++ ImGui) that runs on the Switch to manage streaming modes and patches. The architecture is modular with clear separation between capture, transport, and playback layers. The client uses a custom binary protocol with handshake, packet headers, and NAL replay for efficient streaming. External dependencies include libnx (Switch), FFmpeg, SDL2, libusb, ImGui, and .NET 9. The codebase demonstrates solid engineering with reusable patterns like buffer pools, pipeline chains, and platform abstraction, though it carries some technical debt from outdated third-party bindings and platform-specific workarounds.
ImNodeFlow is a C++ library that provides node-based editor functionality for Dear ImGui applications. It enables developers to create visual programming interfaces with customizable nodes, input/output pins, and bezier curve connections. The library handles all aspects of the node editor including grid management, node rendering, link rendering, user interactions (dragging, clicking, popup menus), and connection logic. The architecture centers around the ImNodeFlow class which manages the infinite grid, nodes, and links. Custom nodes are created by deriving from BaseNode and implementing the draw() method for node content. The system uses a retained-mode approach for nodes and links while leveraging ImGui's immediate-mode rendering for the UI. Key features include zoom/pan support, connection filtering, customizable styling, and popup events for right-click and dropped links. While primarily a UI component library, the repository includes specialized mathematical utilities that could be reused independently. The bezier math implementation for connection rendering and the context wrapper for zoom/pan functionality demonstrate particularly strong encapsulation and could be extracted for use in other projects.
This repository implements the Elden Ring Practice Tool, a Windows application that provides an in-game overlay with cheats, debugging utilities, and speedrun practice features for Elden Ring. The system works by injecting a DLL into the game process, hooking DirectX 12 to render an ImGui overlay, and reading/writing game memory via pointer chains. The architecture is a Cargo workspace with multiple crates: `practice-tool` (main DLL with overlay UI), `lib/libeldenring` (core memory editing and parameter access library), `lib/param-tinkerer` (standalone parameter editor), `lib/no-logo` (intro screen removal DLL), `lib/scripts` (injector), and `xtask` (build and code generation orchestration). Key entry points include `practice-tool/src/lib.rs` (DLL main), `practice-tool/src/practice_tool.rs` (ImGui render loop), and `xtask/src/main.rs` (build tasks). Data flows involve reading game memory via pointer chains, parsing game parameters from community-maintained Paramdex XML, and generating Rust structs and base addresses via AOB scanning. External dependencies include `hudhook` for injection, `imgui` for UI, `windows` crate for Win32 APIs, and `Paramdex` for game data definitions. The tool is heavily version-dependent, supporting 28 game versions with hardcoded base addresses.
FunGen is a desktop application for generating funscripts (motion scripts for interactive haptic devices) from video content using AI-based computer vision. It provides a full GUI built with Dear ImGui, supporting video playback via mpv, real-time and offline object detection (YOLO), optical flow analysis, and a plugin system for funscript transformations. The application integrates device control for hardware like The Handy, OSR, and Buttplug.io, and includes batch processing, watched folders, and a WebSocket API. The codebase is large and well-structured with many reusable components (plugin architecture, async YOLO worker, undo/redo system, checkpointing, theme management), but the project is explicitly deprecated in favor of a native binary rewrite (FunGen 2). The repository is kept for reference and no longer actively developed, leading to high technical drift and potential compatibility issues with current dependencies.
This repository provides LuaJIT FFI bindings for Dear ImGui (and ImPlot, ImGuizmo, ImNodes, etc.) via the cimgui C wrapper. It includes a high-level Lua module (`imgui`) that adds convenience functions, backends for GLFW, SDL2, SDL3, and LÖVE2D, as well as numerous example applications (code editor, node editors, file browser, plotter, etc.). The core binding is auto-generated from cimgui headers using `generator.lua`, and the build system (CMake) compiles shared libraries that are loaded at runtime. The repository serves as both a binding library and a showcase of Dear ImGui capabilities in Lua—it is not a data research project. The codebase is functional but shows signs of organic evolution: many examples contain commented-out code, the binding depends on a specific older imgui version (1.92.9b docking), and there are no formal tests. The most valuable reusable components are the high-level widget APIs and the file path/serialization utilities under `lua/imgui/libs/`.