emilk/egui
Egui
This library is an immediate mode graphical user interface toolkit that reconstructs the entire interface every frame. By executing procedural code within a high-frequency loop that matches the display refresh rate, it allows developers to define interactive elements and state updates directly. The framework utilizes a multi-pass rendering approach to resolve layout dependencies, ensuring that widget sizes and positions are calculated accurately before final placement to prevent visual jitter.
The project functions as a cross-platform graphics toolkit, providing a portable rendering layer that abstracts hardware-accelerated drawing commands across various operating systems and web browsers. It remains backend-agnostic by delegating low-level draw calls to modular integration layers, while its CPU-based tessellation generates geometry for shapes and text before sending them to the graphics hardware. This architecture supports low-latency performance, making it suitable for resource-constrained environments and real-time applications.
Beyond its core rendering capabilities, the framework includes a coordinate-based hit-testing system for input-event dispatching and manages widget interaction priorities for overlapping elements. It provides tools for state-persistence serialization, performance profiling, and multi-viewport management. The system is designed to be configured during the build process, allowing for the inclusion of optional features such as parallel tessellation and interoperability with external math or color libraries.
Features
- Immediate Mode Frameworks - Rebuilds the interface procedurally every frame to reflect current application state.
- Immediate Mode GUI Toolkits - Reconstructs the entire user interface every frame based on current application state and input.
- Immediate Mode Rendering Engines - Render interactive user interfaces by defining elements and state updates within a high-frequency loop that executes at the display refresh rate.
- Rendering - Provides a portable rendering layer that abstracts hardware-accelerated drawing commands across different operating systems.
- Immediate Mode GUI Frameworks - Building interactive user interfaces by defining elements within a high-frequency render loop that updates at the display refresh rate.
- Rendering Engines - Perform multi-pass rendering to resolve layout dependencies, such as calculating widget sizes before final placement, to prevent visual jitters during interface updates.
- Retained State UI Frameworks - Manages widget layout and interaction logic through a persistent coordinate system and input handling loop.
- Input Handling Systems - Define widget sensitivity to user input and manage input priority for overlapping elements to ensure correct interaction handling across the entire interface.
- Rendering Backends - Provides modular integration layers to decouple core rendering logic from specific graphics APIs.
- Cross-Platform Frameworks - Enables the development of portable graphical applications for desktop and web environments.
- Frontend Frameworks - Immediate mode GUI library for simple and fast interfaces.
- UI Frameworks - Easy to use immediate mode gui.
- High-Performance Rendering - Minimizes memory overhead and maintains smooth frame rates for resource-constrained applications.
- Layout Engines - Resolves widget sizes and positions through multi-pass calculations before rendering.
- Input Dispatchers - Routes user interactions through coordinate-based hit-testing to target specific widgets.
- 3D Math and Geometry Toolkits - Generates geometry for shapes and text on the CPU before hardware submission.
- Embedded Visualization - Provides efficient graphical dashboards for hardware devices with minimal dependencies.
