linebender/druid
Druid
Druid is a native user interface toolkit and 2D graphics engine for the Rust programming language. It functions as a retained-mode, data-driven framework for building graphical user interfaces that run across Linux, macOS, and web browsers via WebAssembly.
The toolkit distinguishes itself through a data-first approach to UI design, utilizing lenses to isolate subsets of global application state and synchronize them with specific widgets. This allows the visual layout to update automatically when the underlying data model changes.
Its capability surface includes a constraint-based box layout system for component positioning, a platform-abstraction layer for native event handling, and a vector graphics engine for drawing shapes and text. The framework also covers desktop window management, including multi-window coordination, system file dialogs, and hierarchical application menu systems.
Features
- Cross-Platform GUI Toolkits - Functions as a comprehensive framework for building graphical user interfaces across Linux, macOS, and web browsers.
- Cross-Platform UI Toolkits - Provides a complete toolkit for building native-like GUIs from a single codebase for Linux, macOS, and the web.
- Data-Driven UI Libraries - Functions as a data-driven framework that synchronizes global application state with the visual layout using lenses.
- Custom Shape Rendering - Provides a 2D graphics engine for rendering vector shapes and lines directly onto the window using a paint context.
- 2D Rendering Engines - Ships a rendering engine for drawing vector paths, shapes, and text layouts across multiple backends.
- Data-View Synchronizers - Automatically synchronizes user interface elements when the underlying data model changes.
- State Mapping - Uses functional lenses to map specific subsets of global application state to individual widgets.
- Cross-Platform Abstractions - A common interface for interacting with different application frameworks while hiding backend-specific implementation details.
- Custom Widget Definitions - Allows developers to define bespoke UI components by implementing standard traits for event handling, layout, and painting.
- Custom Widget Implementation - Allows for the design of specialized interface components by implementing custom logic for layout, events, and rendering.
- State-Synchronized Bindings - Automatically synchronizes UI elements with application state changes through reactive bindings.
- Desktop Applications - Provides a framework specifically for building cross-platform desktop GUI applications.
- Event-Driven UI Frameworks - Utilizes an architectural pattern where UI state and interactions are managed through a system of commands and messages.
- DOM Event Listeners - Provides mechanisms to attach listeners to interface elements that execute logic upon user interaction.
- Rust Native Toolkits - Provides a data-first native UI framework implemented specifically for the Rust programming language.
- Retained State UI Frameworks - Maintains a persistent tree of widgets that automatically updates the view when state changes.
- Constraint Based Layouts - Implements a constraint-based box layout system where components negotiate dimensions based on parent-provided constraints.
- Widget Data Bindings - Connects application data sources directly to interface elements to isolate state updates.
- Native Windowing - Manages the lifecycle of native application windows, including system menus and file dialogs.
- Linux UI Rendering - Renders user interfaces on Linux distributions using X11 or Wayland windowing protocols.
- Abstraction-Layer Rendering Backends - Implements an abstraction layer that decouples 2D scene logic from specific native graphics APIs.
- Main Axis Alignment - Positions child components along primary layout axes using configurable distribution and alignment rules.
- Input Event Loops - Implements a non-blocking event loop to handle window and input interactions across platforms.
- Widget Composition Traits - Defines UI components by implementing standard traits for event handling, layout, and rendering.
- Asynchronous Event Dispatchers - Implements systems to offload event handler execution to managed thread pools to prevent blocking the UI.
- Platform Abstraction Layers - Decouples application logic from native operating system windowing and input event lifecycles.
- Dynamic List Rendering - Supports efficient rendering of data collections that automatically update the view when items are modified.
- Event Routing Systems - Provides a mechanism for routing targeted commands to specific widgets within the UI element tree.
- Layout Composition Frameworks - Enables the construction of complex interfaces by nesting widgets, flex containers, and custom painters.
- Content State Toggling - Provides the ability to toggle between different UI components based on boolean state values to handle various application statuses.
- Native Event Streams - Bridges native OS event streams into a standard representation for the UI framework.
- macOS Renderers - Utilizes native macOS graphics tools for hardware-accelerated user interface rendering.
- Targeted Widget Messaging - Enables sending targeted instructions to specific widgets using unique identity identifiers.
- Vector Graphics Rendering - Provides high-fidelity rendering of scalable vector graphics as native widgets within the UI.
- Multi-Window Controllers - Supports the creation and coordination of multiple independent native windows within a single application session.
- Window Lifecycle Controllers - Provides APIs for managing the lifecycle of native windows, including their creation, focus, and termination.
- Web-Based UI Deployment - Enables compilation and execution of native user interface applications within web browsers.
- UI Rendering Engines - Employs a WebAssembly-based engine to render consistent user interfaces across browsers.
- UI Frameworks - Data-first gui design toolkit.
