Skip to main content
Iced is a cross-platform GUI library for Rust focused on simplicity and type-safety. Inspired by Elm, it provides a batteries-included API for building responsive user interfaces.

​
What is Iced?

Iced is a modern GUI framework that brings functional, reactive programming patterns to Rust. It emphasizes:

Type-Safe

Leverage Rust’s type system to catch errors at compile time

Cross-Platform

Build once, run everywhere: Windows, macOS, Linux, and the Web

Reactive

State-driven UI with automatic updates and efficient rendering

Batteries-Included

Rich set of built-in widgets and styling options out of the box

​
Key Features

  • Simple, easy-to-use API - Get started quickly with minimal boilerplate
  • Type-safe, reactive programming model - Inspired by The Elm Architecture
  • Cross-platform support - Windows, macOS, Linux, and the Web
  • Responsive layout - Flexible layout system with rows, columns, and containers
  • Built-in widgets - Text inputs, scrollables, buttons, and more
  • Custom widget support - Create your own widgets when needed
  • Debug tooling - Performance metrics and time traveling debugger
  • First-class async support - Use futures and streams naturally
  • Modular ecosystem - Choose between GPU-accelerated (wgpu) or software rendering (tiny-skia)
Iced is currently experimental software. While it’s production-ready for many use cases, the API may evolve as the library matures.

​
The Elm Architecture

Iced follows The Elm Architecture, which splits user interfaces into four distinct concepts:
1

State

The data that represents your application’s current state
#[derive(Default)]
struct Counter {
    value: i32,
}
2

Messages

User interactions or events that you care about
#[derive(Debug, Clone, Copy)]
pub enum Message {
    Increment,
    Decrement,
}
3

View Logic

Display your state as widgets that produce messages
fn view(&self) -> Column<Message> {
    column![
        button("+").on_press(Message::Increment),
        text(self.value).size(50),
        button("-").on_press(Message::Decrement),
    ]
}
4

Update Logic

React to messages and update your state
fn update(&mut self, message: Message) {
    match message {
        Message::Increment => self.value += 1,
        Message::Decrement => self.value -= 1,
    }
}
This architecture provides a clear separation of concerns and makes it easy to reason about your application’s behavior.

​
Philosophy

Iced leverages Rust to its full extent: ownership, borrowing, lifetimes, futures, streams, first-class functions, trait bounds, closures, and more. The library is designed for advanced Rust programmers who want to build type-safe, performant GUIs.
Iced is unforgiving and will not let you cut corners. The type signatures are your guide - everything is connected through the type system. If you’re new to Rust or prefer a more gentle learning curve, consider waiting for the official book to be completed.

​
Who Should Use Iced?

Iced is ideal for:
  • Rust developers building desktop or web applications
  • Systems programmers who need native GUI applications
  • Teams wanting type-safe UI code with compile-time guarantees
  • Cross-platform projects targeting multiple operating systems
  • Performance-critical applications requiring efficient rendering

​
Next Steps

Ready to get started? Follow our installation guide to set up Iced in your project.

Installation

Learn how to add Iced to your Rust project

Build docs developers (and LLMs) love

Get started for freeTalk to us