Links: Tutorials — Wiki — Examples — 7GUIs — Blog — Design

The Kas GUI system strives to be both fast and follow Alan Kay's slogan:

Simple things should be simple, complex things should be possible.

An excerpt from examples/hello.rs:

let hello_ui = column![
    "Hello, world!",
    Button::label("&Close").with(|cx, _| cx.exit())
];

An excerpt from examples/counter.rs:

#[derive(Clone, Debug)]
struct Increment(i32);

fn counter() -> impl Widget<Data = ()> {
    let tree = column![
        format_label!("{}").align(AlignHints::CENTER),
        row![
            Button::label_msg("−", Increment(-1)),
            Button::label_msg("+", Increment(1)),
        ]
        .map_any(),
    ];

    tree.with_state(0)
        .on_message(|_, count, Increment(add)| *count += add)
}

On the more complex end, custom widgets can be fairly complex; check the Kas widget library (including source code) for examples.

• Fully keyboard-accessible
• Screen reader support (partial: #509)
• IME support (partial: #508)
• Integrated i18n support (not yet started; #7)
• Complex text support: use system fonts with glyph fallbacks, BiDi, common text effects (#13)
• Automatic margins and layout with pixel-perfect scaling
• Support for custom themes including theme-driven animations and sizing
• Virtual scrolling (list or grid), including support for async data access

Kas is designed to:

• Support stateful user-defined widgets with high-ish level of code
• Support the best user-interaction possible
• Support automatic layout and pixel-perfect scaling at any scale factor (i.e. margins and element sizes should be consistent, raster icons should have pixel-perfect rendering; layout is allowed to change as content is scaled).
• Support extremely fast, monolithic Rust binaries

Every approach has its limitations. Ours are:

• Stateful widgets imply invalid-state bugs are possible. There are some (dev-mode) guards against bad-initialisation order, but fundamentally this class of bugs cannot be prevented.
• Custom widgets have a lot of flexibility over management of child widgets; this comes with some expectations. Violating these expectations will result in a panic in debug builds.
• Custom widget definitions use macro-enhanced Rust (not a custom DSL), allowing the full power of Rust code but running the risk of confusing other tooling (both rustfmt and rust-analyzer have some issues here).

In development. Interfaces are not currently stable.

Enough functionality should be present to develop complex GUIs, however some features are still missing (see the Roadmap.

Crates in this repository:

• kas-core: the core library
• kas-macros: proc-macro crate (see kas-core documentation)
• kas-widgets: the main widget library
• kas-view: view widgets supporting virtual scrolling
• kas-image: scalable and raster image widgets and utilities
• kas-wgpu: rendering backend over wgpu
• kas-soft: basic CPU rendering backend over softbuffer
• kas-dylib: helper crate to support dynamic linking
• kas: a meta-package plus convenient driver covering most of the above

Significant external dependencies:

• winit: platform window integration
• wgpu: modern accelerated graphics API
• AccessKit: Accessibility infrastructure for UI toolkits
• kas-text: complex text support
• rustybuzz: a complete harfbuzz's shaping algorithm port to Rust
• fontique: Font enumeration and fallback
• resvg: an SVG rendering library
• tiny-skia: a tiny Skia subset ported to Rust
• Image: An Image Processing Library
• impl-tools: autoimpl and impl_scope (extensible) macros
• easy-cast: Type conversion, success expected

The kas crate enables a selection of important features by default while attempting to support most platforms. Other crates do not enable any features by default. See documentation in Cargo.toml.

The COPYRIGHT file includes a list of contributors who claim copyright on this project. This list may be incomplete; new contributors may optionally add themselves to this list.

The KAS library is published under the terms of the Apache License, Version 2.0. You may obtain a copy of this licence from the LICENSE file or on the following webpage: https://www.apache.org/licenses/LICENSE-2.0