A cross-platform GUI library for Rust, inspired by Elm

Last update: Jun 26, 2022

Iced

Test Status Documentation Crates.io License project chat

A cross-platform GUI library for Rust focused on simplicity and type-safety. Inspired by Elm.

Features

Iced is currently experimental software. Take a look at the roadmap, check out the issues, and feel free to contribute!

Installation

Add iced as a dependency in your Cargo.toml:

iced = "0.2"

Iced moves fast and the master branch can contain breaking changes! If you want to learn about a specific release, check out the release list.

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:

use iced::button;

struct Counter {
    // The counter value
    value: i32,

    // The local state of the two buttons
    increment_button: button::State,
    decrement_button: button::State,
}

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::{Button, Column, Text};

impl Counter {
    pub fn view(&mut self) -> Column<Message> {
        // We use a column: a simple vertical layout
        Column::new()
            .push(
                // The increment button. We tell it to produce an
                // `IncrementPressed` message when pressed
                Button::new(&mut self.increment_button, Text::new("+"))
                    .on_press(Message::IncrementPressed),
            )
            .push(
                // We show the value of the counter here
                Text::new(&self.value.to_string()).size(50),
            )
            .push(
                // The decrement button. We tell it to produce a
                // `DecrementPressed` message when pressed
                Button::new(&mut self.decrement_button, Text::new("-"))
                    .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:

  1. Take the result of our view logic and layout its widgets.
  2. Process events from our system and produce messages for our update logic.
  3. Draw the resulting user interface.

Browse the documentation and the examples to learn more!

Implementation details

Iced was originally born as an attempt at bringing the simplicity of Elm and The Elm Architecture into Coffee, a 2D game engine I am working on.

The core of the library was implemented during May 2019 in this pull request. The first alpha version was eventually released as a renderer-agnostic GUI library. The library did not provide a renderer and implemented the current tour example on top of ggez, a game library.

Since then, the focus has shifted towards providing a batteries-included, end-user-oriented GUI library, while keeping the ecosystem modular:

Iced Ecosystem

Contributing / Feedback

Contributions are greatly appreciated! If you want to contribute, please read our contributing guidelines for more details.

Feedback is also welcome! You can open an issue or, if you want to talk, come chat to our Zulip server. Moreover, you can find me (and a bunch of awesome folks) over the #games-and-graphics and #gui-and-ui channels in the Rust Community Discord. I go by lone_scientist#9554 there.

Sponsors

The development of Iced is sponsored by the Cryptowatch team at Kraken.com

GitHub

https://github.com/hecrj/iced
Comments
  • 1. Iced branding

    Hey everyone !

    In order for the new website to happen, we need to define some sort of branding for Iced. Since this should be a community effort, here are my first thoughts / mind map of how I reasoned about the logo and color scheme.

    Logo

    What is Iced ?

    • GUI Framework
    • Platform-agnostic
    • Written in Rust
    • Elm Architecture

    What does iced mean ?

    • Ice

      • Ice Cubes
      • Snowflakes
      • Mountains / Glacier
      • Icebergs
      • Sharp edges
      • Mostly light-blue colors
    • Iced Coffee

      • Ice cubes
      • Brown / Orange colors
    • Modern GUI / Elm

      • Font has to be sans-serif. Having serif makes everything look automatically older.
      • Flat
      • Square-ish shape
      • Draft / Prototyping
    • Rust

      • Light-Orange color (Github) and black color
      • "Jagged R" Rust Logo : maybe we can have a slight reminder of Rust in the shape of the logo ?

    Possible inspiration

    This whole article on the amethyst.rs website Logo of Flutter Logo of Electron Logo of Elm Logo of OrbTX Logo of Amethyst image

    Colors

    We need to define :

    • One main color - 3 shades
    • One "accent" color - 3 shades
    • One shade of light color
    • One shade of dark color

    In my opinion, it is obvious that Iced's main color should be light-blue. White could also largely be used as a reminder of snow. I'm thinking a slightly brown dark color could be used for texts.

    I'm undecided for the accent : I like light-green together with light-blue, though I think an orange accent would make for a better result because they are often used as opposite colors in video games. Take Rocket League for example. I also tried brown/orange as an alternative.

    My suggestions

    So here are my 2 cents. I'm terrible at graphic design (I'm just an engineer) and this is of course a draft that I hope someone will take further.

    For the color scheme, I took images of a glacier and extracted some colors. This would be my "main color" suggestion. I took another image of an emerald glacier and extracted shades of green - I think it's called teal. Finally, I got an image of an iced coffee and exrtacted shades of orange / brown.

    image

    As per the logo, I think I'm on to something. These are the result of my first iteration. I'm willing to add some sort of gradient to the ice cubes when I can figure out how to do that in Inkscape.

    image

    I think it's simple enough. A cool logo should never be complex as evidenced by the "possible inspirations" part, and should work in a monochrome context (both black and white), which I think is kind of the case here.

    What are your thoughts ? Any help welcome! :pray:

    Reviewed by AlisCode at 2020-01-05 22:11
  • 2. Scrolling programmatically

    The scroll_to method on the State in Scrollable is useful for scrolling programmatically but it requires knowledge of the layout bounds which isn't public.

    Either this information should be exposed, probably for all widgets, or the State should contain the bounds of the Scrollable so that scroll_to can be used as public api without needing to create a custom widget.

    What do you think?

    EDIT: zulip links https://iced.zulipchat.com/#narrow/stream/213316-general/topic/infinite.20list https://iced.zulipchat.com/#narrow/stream/213445-help/topic/Scrollable.3A.3Apush_back https://iced.zulipchat.com/#narrow/stream/213445-help/topic/how.20to.20scroll.20programmatically.3F https://iced.zulipchat.com/#narrow/stream/213445-help/topic/scroll_to

    Reviewed by krooq at 2020-04-19 11:27
  • 3. Another run example error: `cargo run --example tour`

    I'm trying to run the example on my Windows 10, but I come across this:

    iced> $Env:RUST_BACKTRACE="full"
    iced> cargo run --example tour  
        Finished dev [unoptimized + debuginfo] target(s) in 0.63s
         Running `target\debug\examples\tour.exe`
    [2019-12-01T05:21:46Z INFO  winit::platform_impl::platform::window] Guessed window DPI factor: 1
    error: process didn't exit successfully: `target\debug\examples\tour.exe` (exit code: 0xc0000005, STATUS_ACCESS_VIOLATION)
    

    I tried to backtrace the log, But it seems to only print a line of log about DPI factor. How could I log more to locate this issue?

    Reviewed by huangjj27 at 2019-12-01 06:13
  • 4. Iced on Raspberry PI 4 (almost working)

    Hi,

    I'm trying to use iced on my Raspberry 4. So far I managed to make it compile. It even runs and the window is shown, but no frame is rendered. Eventually it exits with the following error:

    thread 'main' panicked at 'Next frame: TimeOut', /home/pi/work/iced/wgpu/src/window/compositor.rs:110:21
    

    Before I patched the iced dependencies it failed to compile:

    error[E0308]: mismatched types
       --> /home/pi/.cargo/registry/src/github.com-1ecc6299db9ec823/font-kit-0.6.0/src/loaders/freetype.rs:804:20
        |
    804 |                 x: vector.x() as i64,
        |                    ^^^^^^^^^^^^^^^^^ expected `i32`, found `i64`
    
    error[E0308]: mismatched types
       --> /home/pi/.cargo/registry/src/github.com-1ecc6299db9ec823/font-kit-0.6.0/src/loaders/freetype.rs:805:20
        |
    805 |                 y: -vector.y() as i64,
        |                    ^^^^^^^^^^^^^^^^^^ expected `i32`, found `i64`
    
    error[E0308]: mismatched types
       --> /home/pi/.cargo/registry/src/github.com-1ecc6299db9ec823/font-kit-0.6.0/src/loaders/freetype.rs:808:21
        |
    808 |                 xx: matrix.x() as i64,
        |                     ^^^^^^^^^^^^^^^^^ expected `i32`, found `i64`
    
    error[E0308]: mismatched types
       --> /home/pi/.cargo/registry/src/github.com-1ecc6299db9ec823/font-kit-0.6.0/src/loaders/freetype.rs:809:21
        |
    809 |                 xy: matrix.y() as i64,
        |                     ^^^^^^^^^^^^^^^^^ expected `i32`, found `i64`
    
    error[E0308]: mismatched types
       --> /home/pi/.cargo/registry/src/github.com-1ecc6299db9ec823/font-kit-0.6.0/src/loaders/freetype.rs:810:21
        |
    810 |                 yx: matrix.z() as i64,
        |                     ^^^^^^^^^^^^^^^^^ expected `i32`, found `i64`
    
    error[E0308]: mismatched types
       --> /home/pi/.cargo/registry/src/github.com-1ecc6299db9ec823/font-kit-0.6.0/src/loaders/freetype.rs:811:21
        |
    811 |                 yy: matrix.w() as i64,
        |                     ^^^^^^^^^^^^^^^^^ expected `i32`, found `i64`
    
    error: aborting due to 6 previous errors
    
    For more information about this error, try `rustc --explain E0308`.
    error: could not compile `font-kit`.
    

    I updated iced_graphics' font-kit dependency to 0.9 and the error disappeared. I was able to build and execute examples, but rendering fails for some reason. Here's the typical output: https://gist.github.com/0x7CFE/3f29f6d7fccd67bd8804ad47c97daaa5 Also, please notice a ton of font errors.

    Currently Raspberry Pi 4 has only experimental but working Vulkan support. Yet I thought that for 2D stuff it should probably be enough.

    I will be happy to hear any suggestions.

    P.S.: Since iced is render agnostc, is it possible to build it on top of OpenGL? Maybe that would be easier than trying to debug alpha version of the Vulkan driver.

    Reviewed by 0x7CFE at 2020-06-27 09:14
  • 5. Panic when running any of the examples under Linux Intel GPU

    Environment:

    openSUSE Tumbleweed, kernel 5.3.11. KDE Plasma 5.17.3 System font: Noto Sans Mesa DRI Intel(R) HD Graphics 620 (Kaby Lake GT2) Mesa 19.2.4 Vulkan Instance Version: 1.1.127

    Running cargo run --example tour causes panic with the following stack trace (snipped):

      15: core::result::Result<T,E>::unwrap
                 at /rustc/4560ea788cb760f0a34127156c78e2552949f734/src/libcore/result.rs:933
      16: wgpu_glyph::builder::GlyphBrushBuilder<()>::using_fonts_bytes::{{closure}}
                 at /home/dmitry/.cargo/registry/src/github.com-1ecc6299db9ec823/wgpu_glyph-0.6.0/src/builder.rs:44
      17: core::iter::adapters::map_fold::{{closure}}
                 at /rustc/4560ea788cb760f0a34127156c78e2552949f734/src/libcore/iter/adapters/mod.rs:694
      18: core::iter::traits::iterator::Iterator::fold::ok::{{closure}}
                 at /rustc/4560ea788cb760f0a34127156c78e2552949f734/src/libcore/iter/traits/iterator.rs:1813
      19: core::iter::traits::iterator::Iterator::try_fold
                 at /rustc/4560ea788cb760f0a34127156c78e2552949f734/src/libcore/iter/traits/iterator.rs:1694
      20: core::iter::traits::iterator::Iterator::fold
                 at /rustc/4560ea788cb760f0a34127156c78e2552949f734/src/libcore/iter/traits/iterator.rs:1816
      21: <core::iter::adapters::Map<I,F> as core::iter::traits::iterator::Iterator>::fold
                 at /rustc/4560ea788cb760f0a34127156c78e2552949f734/src/libcore/iter/adapters/mod.rs:727
      22: core::iter::traits::iterator::Iterator::for_each
                 at /rustc/4560ea788cb760f0a34127156c78e2552949f734/src/libcore/iter/traits/iterator.rs:616
      23: <alloc::vec::Vec<T> as alloc::vec::SpecExtend<T,I>>::spec_extend
                 at /rustc/4560ea788cb760f0a34127156c78e2552949f734/src/liballoc/vec.rs:1966
      24: <alloc::vec::Vec<T> as alloc::vec::SpecExtend<T,I>>::from_iter
                 at /rustc/4560ea788cb760f0a34127156c78e2552949f734/src/liballoc/vec.rs:1949
      25: <alloc::vec::Vec<T> as core::iter::traits::collect::FromIterator<T>>::from_iter
                 at /rustc/4560ea788cb760f0a34127156c78e2552949f734/src/liballoc/vec.rs:1836
      26: core::iter::traits::iterator::Iterator::collect
                 at /rustc/4560ea788cb760f0a34127156c78e2552949f734/src/libcore/iter/traits/iterator.rs:1478
      27: wgpu_glyph::builder::GlyphBrushBuilder<()>::using_fonts_bytes
                 at /home/dmitry/.cargo/registry/src/github.com-1ecc6299db9ec823/wgpu_glyph-0.6.0/src/builder.rs:41
      28: iced_wgpu::text::Pipeline::new
                 at wgpu/src/text.rs:36
      29: iced_wgpu::renderer::Renderer::new
                 at wgpu/src/renderer.rs:64
      30: <iced_wgpu::renderer::Renderer as iced_native::renderer::windowed::Windowed>::new
                 at wgpu/src/renderer.rs:417
      31: iced_winit::application::Application::run
                 at ./winit/src/application.rs:115
      32: iced::application::Application::run
                 at ./src/application.rs:140
      33: iced::sandbox::Sandbox::run
                 at ./src/sandbox.rs:128
      34: tour::main
                 at examples/tour.rs:10
    
    Reviewed by ancwrd1 at 2019-11-25 20:27
  • 6. Experimental WebGL wgpu backend support

    Made changes to allow the use of WebGL wgpu backend. The basic functionality works, but text rendering is still buggy - Somehow, if the initial value of the text control was changed, some parts of the text start to disappear/show artifacts.

    UPD: Strange issue with text rendering is only reproducing in Firefox (v93). It is not directly related to the iced, I created an issue in wgpu_glyph here: https://github.com/hecrj/wgpu_glyph/issues/78

    The current implementation provides neither Application nor Sandbox implementations for this backend, and does not implement proper Clipboard in iced_winit, however, this should be at least some starting point.

    Changes list:

    • Added new integration_wgpu_webgl example, based on integration_wgpu and wgpu's hello-triangle example (can't use integration_wgpu example directly because it fails with its spirv shaders on WebGL)
    • Lifted Sync requirement for Runtime and Tracker in iced_futures
    • Aded webgl feature to iced_wgpu which enables wgpu/webgl
    • Created stub implementation for Clipboard in iced_winit
    Images

    iced running inside WebGL canvas: image

    Text issues after changing text value: image

    Same example running on desktop backend: image

    Reviewed by pacmancoder at 2021-10-23 09:44
  • 7. Implement dynamic linking feature

    The Bevy game engine has a nice dynamic linking features which, coupled with the lld linker, significantly improves compile times. I have added this to iced for faster compiling iterations (down to about 2.3 from 3.8 for a personal project) . What do you think? Relevant issue: #849

    Reviewed by zyansheep at 2021-05-04 19:36
  • 8. Application closes immediately after launched on Linux

    I am trying to run my application compiled in Ubuntu and I can't get it working. If launched by double clicking the application it just says mentions something like:

    there's no application installed for "shared library" files

    Event though the file already has execution permission with chmod +x app. If I run it through the console, it appears to work but closes immediately. No GUI interface is shown at all.

    I installed a panic hook but there's no panic going on, it closes without explanation.

    When compiling and running on Windows it works fine.

    Is there any mechanism in Iced to debug this kind of error?

    Reviewed by sum-elier at 2020-10-30 04:35
  • 9. Canvas examples on MacOS don't work

    0.1.1 seems to have broken the Canvas widget on Mac OS. When trying to run the clock, solar_system, bezier_tool examples on MacOS 10.14.6 get a blank, white, screen where I believe the Canvas is supposed to be. Running game_of_life presents a gray screen, and all the surrounding menu components but does not show any of the white "cell" pieces.

    Manually switching to the 0.1 branch and testing the ones that exist there seems to work fine.

    Reviewed by andrewmh20 at 2020-05-13 03:39
  • 10. Text Selection for text_input widget

    TL;DR Based on Finnerales fork, still WIP but looking for tips and/or wishes.

    First of all, this is based on work done by @Finnerale (#184). It's the biggest and imo most difficult part of what has been done in this pull request (as of now). My problem was, that I wasn't patient enough to wait any longer and i wanted this functionality for my side project. So although I'm an absolute beginner regarding Rust/GUI/Collab Work, I thought I'd give it a go.

    What's implemented:

    • Selection via Mouse dragging (by Finnerale)
    • Ctrl + A or 3 clicks to select everything
    • double click to select a word

    What's left afaik:

    • Shift + Left/Right = Expand selection by one character
    • Ctrl + Shift + Left/Right = Expand selection by one "word"
    • Shift + Home/End = Expand selection to Start/End (* I really need to work on Comments/Documention huh -> should be added tomorrow)

    So most importantly I'd like to know if i did something wrong or inappropriate (regarding the code(style)) and if there is something i forgot to add. Oh and also tell me if this is a waste of time for you (or me).

    I'm gonna post this as a draft pull request, because it's obviously still WIP :)

    P.S. Yea, i noticed the failing builds :P

    Reviewed by FabianLars at 2020-02-23 01:15
  • 11. Unable to use nfd with iced

    Hey, I was looking to use nfd or native file dialog, with iced. But it can only be accessed from the main thread, but when I access it from the main thread, the whole application freezes. Any alternatives, or ways to prevent it?

    Reviewed by emmanuelantony2000 at 2020-04-23 06:17
  • 12. Add linear gradient to canvas API

    Adds a canvas API similar to the HTML API for creating a linear gradient: https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-createlineargradient. This can be extended in the future to add radial & conic gradients.

    I've currently only implemented the rendering in wgpu. I wanted to hold off on tackling opengl until I get feedback on the data structures, module organization, and to see if there's any blockers.

    Reviewed by tarkah at 2022-06-20 16:18
  • 13. Theming

    This PR completely overhauls styling by implementing first-class support for themes, as described in the recently merged RFC: https://github.com/iced-rs/rfcs/pull/6.

    The default built-in themes and their corresponding color palettes are mostly placeholders and will most likely change as we fine-tune and iterate on the default looks of iced.

    Reviewed by hecrj at 2022-06-08 23:13
  • 14. Prevent pane grid title bar content and controls from overlapping

    This fixes the content/controls becoming unreadable when they overlap in narrow panes.

    Should this be configurable? For example:

    enum Overlap {
        Allow, // existing behavior
        HideContent, // proposed behavior
        HideControls,
    }
    

    Before

    https://user-images.githubusercontent.com/4934192/172265902-715c0a3f-bab7-41d9-8ad5-1fcbd6dc214a.mp4

    After

    https://user-images.githubusercontent.com/4934192/172265908-66f7ec7e-2121-4c82-9f4a-fa12f663cb7a.mp4

    Reviewed by mtkennerly at 2022-06-06 23:47
  • 15. `arc_to` does not act like `CanvasRenderingContext2D.arcTo`

    Is there an existing issue for this?

    • [X] I have searched the existing issues.

    Is this issue related to iced?

    • [X] My hardware is compatible and my graphics drivers are up-to-date.

    What happened?

    The native implementation of path::Builder::arc_to simply draws one straight line to the first point provided and then draws an arc to the endpoint.

    Any usage of arc_to will reproduce this behavior.

    What is the expected behavior?

    I expected iced_graphics's arc_to to act like CanvasRenderingContext2D.arcTo, which takes a control point and draws two straight lines between the starting point and the ending point connected by an arc,

    Version

    0.4

    Operative System

    Windows

    Do you have any log output?

    No response

    Reviewed by ThatsNoMoon at 2022-06-03 16:25
  • 16. Add profile release

    This PR adds a profile.release to reduce binaries size, but at the same time enables some optimizations. Using this profile, I was able to reduce the bezier_tool binary from 15.6 MB to 7.1MB, I haven't checked the other binaries though.

    I hope this is appreciated, thanks in advance for your review!

    Reviewed by Luni-4 at 2022-05-20 08:41
Idiomatic, GTK+-based, GUI library, inspired by Elm, written in Rust
Idiomatic, GTK+-based, GUI library, inspired by Elm, written in Rust

Relm Asynchronous, GTK+-based, GUI library, inspired by Elm, written in Rust. This library is in beta stage: it has not been thoroughly tested and its

Jun 18, 2022
An idiomatic GUI library inspired by Elm and based on gtk4-rs
An idiomatic GUI library inspired by Elm and based on gtk4-rs

An idiomatic GUI library inspired by Elm and based on gtk4-rs. Relm4 is a new version of relm that's built from scratch and is compatible with GTK4 an

Jun 21, 2022
Simple and portable (but not inflexible) GUI library in C that uses the native GUI technologies of each platform it supports.
Simple and portable (but not inflexible) GUI library in C that uses the native GUI technologies of each platform it supports.

libui: a portable GUI library for C This README is being written. Status It has come to my attention that I have not been particularly clear about how

Jun 18, 2022
A cross-platform GUI library for Rust focused on simplicity and type-safety
A cross-platform GUI library for Rust focused on simplicity and type-safety

A cross-platform GUI library for Rust, inspired by Elm

Jun 23, 2022
A single-header ANSI C immediate mode cross-platform GUI library
A single-header ANSI C immediate mode cross-platform GUI library

Nuklear This is a minimal-state, immediate-mode graphical user interface toolkit written in ANSI C and licensed under public domain. It was designed a

Jun 17, 2022
A simple, cross-platform GUI automation module for Rust.

AutoPilot AutoPilot is a Rust port of the Python C extension AutoPy, a simple, cross-platform GUI automation library for Python. For more information,

Jun 23, 2022
Truly cross platform, truly native. multiple backend GUI for rust
Truly cross platform, truly native. multiple backend GUI for rust

WIP: Sauron-native a rust UI library that conquers all platforms ranging from desktop to mobile devices. An attempt to create a truly native, truly cr

May 28, 2022
Cross-platform GUI toolkit written in Rust
Cross-platform GUI toolkit written in Rust

Tuix is a cross-platform GUI toolkit written in Rust. The driving principle behind tuix is to be a self-contained, small-as-possible, but still fast,

May 6, 2022
A cross-platform GUI toolkit in Rust

NXUI - Native X UI A cross-platform GUI toolkit in Rust NXUI is a GUI toolkit that calls OS native APIs as much as possible to achieve fast operation.

Jun 3, 2022
A lightweight cross-platform system-monitoring fltk gui application based on sysinfo
A lightweight cross-platform system-monitoring fltk gui application based on sysinfo

Sysinfo-gui A lightweight cross-platform system-monitoring fltk gui application based on sysinfo. The UI design is inspired by stacer. The svg icons a

Jun 8, 2022
Cross-platform native Rust menu library

A cross-platform Rust library for managing the native operating system menus.

Jan 13, 2022
Rust bindings to the minimalist, native, cross-platform UI toolkit `libui`
Rust bindings to the minimalist, native, cross-platform UI toolkit `libui`

Improved User Interface A cross-platform UI toolkit for Rust based on libui iui: ui-sys: iui is a simple (about 4 kLOC of Rust), small (about 800kb, i

Jun 23, 2022
A Rust binding of the wxWidgets cross platform toolkit.

wxRust master: / mac(0.10): This is a Rust binding for the wxWidgets cross platform toolkit. API wxRust API documentation How it works The wxRust libr

Jun 8, 2022
A cross-platform Mod Manager for RimWorld intended to work with macOS, linux and Windows

TODOs are available here. Discussions, PRs and Issues are open for anyone who is willing to contribute. rrm Inspired by Spoons rmm. This is a cross-pl

Feb 6, 2022
An easy-to-use, 2D GUI library written entirely in Rust.

Conrod An easy-to-use, 2D GUI library written entirely in Rust. Guide What is Conrod? A Brief Summary Screenshots and Videos Feature Overview Availabl

Jun 24, 2022
Rust bindings for the FLTK GUI library.
Rust bindings for the FLTK GUI library.

fltk-rs Rust bindings for the FLTK Graphical User Interface library. The FLTK crate is a crossplatform lightweight gui library which can be statically

Jun 25, 2022
Clear Coat is a Rust wrapper for the IUP GUI library.

Clear Coat Clear Coat is a Rust wrapper for the IUP GUI library. IUP uses native controls and has Windows and GTK backends. A macOS backend has been o

Feb 13, 2021
Rust bindings for the FLTK GUI library.
Rust bindings for the FLTK GUI library.

fltk-rs Rust bindings for the FLTK Graphical User Interface library. The fltk crate is a cross-platform lightweight gui library which can be staticall

Jun 22, 2022
The bindings to the Nuklear 2D immediate GUI library.

nuklear-rust The bindings to the Nuklear 2D immediate GUI library. Currently beta. Drawing backends: gfx-pre-ll for GFX 3D drawing engine (examples: O

Jun 2, 2022