How to write a GUI application in Rust?

When developing GUI applications with Rust, you can choose several strategies and tools. Rust is a systems-level programming language focused on performance and safety, offering multiple GUI libraries and frameworks to help build stable and efficient applications. Here are several viable approaches:

1. Using Druid

Druid is a native Rust GUI toolkit designed to provide high performance and a user-friendly API. Its goal is to offer sufficient tools for building modern desktop applications, with an architecture based on reactive data streams.

Example: Create a simple counter application. The user interface includes a number and a button; clicking the button increments the number.

rust
use druid::widget::{Button, Flex, Label};
use druid::{AppLauncher, Data, Lens, Widget, WidgetExt, WindowDesc};

#[derive(Clone, Data, Lens)]
struct AppState {
    count: u32,
}

fn build_ui() -> impl Widget<AppState> {
    let label = Label::new(|data: &AppState, _env: &_| format!("Count: {}", data.count));
    let button = Button::new("Increment")
        .on_click(|_ctx, data: &mut AppState, _env| {
            data.count += 1;
        });

    Flex::column().with_child(label).with_child(button)
}

fn main() {
    let main_window = WindowDesc::new(build_ui())
        .title("Simple Counter");
    let initial_state = AppState { count: 0 };

    AppLauncher::with_window(main_window)
        .launch(initial_state)
        .expect("Failed to launch application");
}

2. Using gtk-rs

gtk-rs is a Rust binding for the GTK+ (GIMP Toolkit) library, suitable for building complex cross-platform GUI applications.

Example: Create a simple window

rust
use gtk::prelude::*;
use gtk::{Button, Window, WindowType};

fn main() {
    gtk::init().expect("Failed to initialize GTK.");

    let window = Window::new(WindowType::Toplevel);
    window.set_title("Hello, GTK!");
    window.set_default_size(350, 70);

    let button = Button::new_with_label("Click me!");
    button.connect_clicked(|_| {
        println!("Clicked!");
    });
    window.add(&button);

    window.show_all();
    window.connect_delete_event(|_, _| {
        gtk::main_quit();
        Inhibit(false)
    });

    gtk::main();
}

3. Using iced

iced is a cross-platform GUI library written in Rust, designed to build applications that can run on various devices, including desktop systems and web.

Example: Create a simple counter application, which also includes a button and a label.

rust
use iced::{button, Button, Column, Command, Element, Sandbox, Settings, Text};

struct Counter {
    value: i32,
    increment_button: button::State,
}

#[derive(Debug, Clone, Copy)]
enum Message {
    IncrementPressed,
}

impl Sandbox for Counter {
    type Message = Message;

    fn new() -> Self {
        Counter {
            value: 0,
            increment_button: button::State::new(),
        }
    }

    fn title(&self) -> String {
        String::from("Counter - Iced")
    }

    fn update(&mut self, message: Message) -> Command<Self::Message> {
        match message {
            Message::IncrementPressed => {
                self.value += 1;
            }
        }
        Command::none()
    }

    fn view(&self) -> Element<'_, Self::Message> {
        let text = Text::new(self.value.to_string()).size(50);
        let button = Button::new(&mut self.increment_button, Text::new("Increment"))
            .on_press(Message::IncrementPressed);

        Column::new().push(text).push(button).into()
    }
}

fn main() {
    Counter::run(Settings::default())
}

Conclusion

The choice of tool depends on the specific requirements of the project, the target platform, and the developer's familiarity with the libraries or frameworks. The examples above demonstrate several methods for creating GUIs in Rust, each with its unique advantages and use cases. The documentation and community support for these libraries are typically comprehensive, helping developers get started faster and resolve issues encountered.