Crate cushy

Cushy is an experimental Graphical User Interface (GUI) crate for the Rust programming language. It features a reactive data model and aims to enable easily creating responsive, efficient user interfaces. To enable easy cross-platform development, Cushy uses its own collection of consistently-styled Widgets.

Cushy is powered by:

• Kludgine, a 2d graphics library powered by:
  • winit for windowing/input
  • wgpu for graphics
  • cosmic_text for text layout + rasterization
• palette for OKLab-based HSL color calculations
• arboard for clipboard support
• figures for integer-based 2d math

Getting Started with Cushy

The Widget trait is the building block of Cushy: Every user interface element implements Widget. The Widget trait documentation has an overview of how Cushy works. A list of built-in widgets can be found in the cushy::widgets module.

Cushy uses a reactive data model. To see an example of how reactive data models work, consider this example that displays a button that increments its own label:

fn main() -> cushy::Result {
    // Create a dynamic usize.
    let count = Dynamic::new(0_isize);

    // Create a new label displaying `count`
    count
        .to_label()
        // Use the label as the contents of a button
        .into_button()
        // Set the `on_click` callback to a closure that increments the counter.
        .on_click(move |_| count.set(count.get() + 1))
        // Run the application
        .run()
}

Here are some ways to learn more about Cushy:

• Explore the examples directory. Nearly every feature in Cushy was initially tested by creating an example. Many are focused on demonstrating a single feature, but there are some complex example such as a theme editor/previewer:

  

• Browse the user’s guide. The user guide is a work in progress, but features CI-generated screenshots and animations for its examples:

  

• Ask questions in Discussions or on Discord.

Project Status

This project is early in development, but is quickly becoming a decent framework. It is considered alpha and unsupported at this time, and the primary focus for @ecton is to use this for his own projects. Feature requests and bug fixes will be prioritized based on @ecton’s own needs.

If you would like to contribute, bug fixes are always appreciated. Before working on a new feature, please open an issue proposing the feature and problem it aims to solve. Doing so will help prevent friction in merging pull requests, as it ensures changes fit the vision the maintainers have for Cushy.

Open-source Licenses

This project, like all projects from Khonsu Labs, is open-source. This repository is available under the MIT License or the Apache License 2.0.

To learn more about contributing, please see CONTRIBUTING.md.

Re-exports

• pub use figures;
• pub use kludgine;

Modules

• animation
  Types for creating animations.
• context
  Types that provide access to the Cushy runtime.
• debug
  Utililies to help debug Cushy apps.
• dialog
  Modal dialogs such as message boxes and file pickers.
• fonts
  Types for loading fonts to use in Cushy.
• styles
  Types for styling widgets.
• value
  Types for storing and interacting with values in Widgets.
• widget
  Types for creating reusable widgets (aka components or views).
• widgets
  Built-in Widget implementations.
• window
  Types for displaying a Widget inside of a desktop window.

Macros

• define_components
  Defines a set of style components for Cushy.
• example
• styles
  Creates a Styles instance with the given name/component pairs.

Structs

• App
  A handle to a Cushy application.
• Cushy
  Shared resources for a GUI application.
• DefaultRuntime
  A default application runtime.
• Graphics
  A 2d graphics context
• InputState
  The current state of input during the execution of a Tick.
• Lazy
  A OnceLock-based lazy initializer.
• Name
  A smart-string type that is used as a “name” in Cushy.
• PendingApp
  A Cushy application that has not started running yet.
• Tick
  A fixed-rate callback that provides access to tracked input on its associated widget.
• TokioRuntime
  A spawned tokio runtime.

Enums

• ConstraintLimit
  A limit used when measuring a widget.

Traits

• AppRuntime
  A runtime associated with the Cushy application.
• Application
  A type that is a Cushy application.
• FitMeasuredSize
  An extension trait for Size<ConstraintLimit>.
• ModifiersExt
  Helper functions for [Modifiers] and [ModifiersState].
• ModifiersStateExt
  Helper constants for [ModifiersState]
• Open
  A type that can be opened as a window in an application.
• RenderOperation
  A custom wgpu-powered rendering operation.
• Run
  A type that can be run as an application.
• SimpleRenderOperation
  A RenderOperation with no per-drawing-call state.
• WithClone
  Invokes a function with a clone of self.

Functions

• run
  Starts running a Cushy application, invoking app_init after the event loop has started.

Type Aliases

• Result
  A result alias that defaults to the result type commonly used throughout this crate.
• ShutdownGuard
  A guard preventing an App from shutting down.

Attribute Macros

• main
  A macro to create a main() function with less boilerplate.