Expand description
Iced is a cross-platform GUI library focused on simplicity and type-safety. Inspired by Elm.
§Features
- Simple, easy-to-use, batteries-included API
- Type-safe, reactive programming model
- Cross-platform support (Windows, macOS, Linux, and the Web)
- Responsive layout
- Built-in widgets (including text inputs, scrollables, and more!)
- Custom widget support (create your own!)
- Debug overlay with performance metrics
- First-class support for async actions (use futures!)
- Modular ecosystem split into reusable parts:
- A renderer-agnostic native runtime enabling integration with existing systems
- A built-in renderer supporting Vulkan, Metal, DX11, and DX12
- A windowing shell
- A web runtime leveraging the DOM
Check out the repository and the examples for more details!
§Overview
Inspired by The Elm Architecture, Iced expects you to split user interfaces into four different concepts:
- State — the state of your application
- Messages — user interactions or meaningful events that you care about
- View logic — a way to display your state as widgets that may produce messages on user interaction
- Update logic — a way to react to messages and update your state
We can build something to see how this works! Let’s say we want a simple counter that can be incremented and decremented using two buttons.
We start by modelling the state of our application:
struct Counter {
// The counter value
value: i32,
}
Next, we need to define the possible user interactions of our counter: the button presses. These interactions are our messages:
#[derive(Debug, Clone, Copy)]
pub enum Message {
IncrementPressed,
DecrementPressed,
}
Now, let’s show the actual counter by putting it all together in our view logic:
use iced::widget::{button, column, text, Column};
impl Counter {
pub fn view(&self) -> Column<Message> {
// We use a column: a simple vertical layout
column![
// The increment button. We tell it to produce an
// `IncrementPressed` message when pressed
button("+").on_press(Message::IncrementPressed),
// We show the value of the counter here
text(self.value).size(50),
// The decrement button. We tell it to produce a
// `DecrementPressed` message when pressed
button("-").on_press(Message::DecrementPressed),
]
}
}
Finally, we need to be able to react to any produced messages and change our state accordingly in our update logic:
impl Counter {
// ...
pub fn update(&mut self, message: Message) {
match message {
Message::IncrementPressed => {
self.value += 1;
}
Message::DecrementPressed => {
self.value -= 1;
}
}
}
}
And that’s everything! We just wrote a whole user interface. Iced is now able to:
- Take the result of our view logic and layout its widgets.
- Process events from our system and produce messages for our update logic.
- Draw the resulting user interface.
§Usage
The Application
trait should get you started quickly,
streamlining all the process described above!
Modules§
- Leverage advanced concepts like custom widgets.
- Build interactive cross-platform applications.
- Access the clipboard.
- Run asynchronous actions.
- Handle events of a user interface.
- Choose your preferred executor to power your application.
- Load and use fonts.
- Listen and react to keyboard events.
- Listen and react to mouse events.
- Display interactive elements on top of other widgets.
- Configure your application
- Listen to external events in your application.
- Listen and react to time.
- Listen and react to touch events.
- Use the built-in widgets or create your own.
- Configure the window of your application in native platforms.
Macros§
- Creates a
Color
with shorter and cleaner syntax.
Structs§
- A border.
- A color in the
sRGB
color space. - A set of asynchronous actions to be performed by some runtime.
- Degrees
- A font.
- A set of size constraints for layouting.
- An amount of space to pad for each side of a box
- An amount of logical pixels.
- A 2D point.
- Radians
- The border radii for the corners of a graphics primitive in the order: top-left, top-right, bottom-right, bottom-left.
- A rectangle.
- The settings of an application.
- An amount of space in 2 dimensions.
- A request to listen to external events.
- A 2D vector.
Enums§
- Alignment on the axis of a container.
- The background of some element.
- The strategy used to fit the contents of a widget to its bounding box.
- An error that occurred while running an application.
- A user interface event.
- A fill which transitions colors progressively along a direction, either linearly, radially (TBD), or conically (TBD).
- The strategy used to fill space in a specific dimension.
- The default graphics renderer for
iced
. - A built-in theme.
Traits§
- An interactive cross-platform application.
- A type that can run futures.
- A sandboxed
Application
.
Type Aliases§
- A generic widget.
- The result of running an application.