Operad

A cross-platform GUI library for Rust.

Features

• Simple, renderer-neutral API.
• Retained UI tree with flexible layout.
• Built-in widgets and editor controls.
• Type-safe actions and commands.
• Accessibility and input handling.
• WGPU renderer support.
• Custom drawing surfaces.
• Headless testing utilities.

Overview

The shortest path to a native window is run:

use operad::{root_style, widgets, LayoutStyle, NativeWindowResult, UiDocument, UiSize};

fn main() -> NativeWindowResult {
    operad::run("app", view)
}

fn view(viewport: UiSize) -> UiDocument {
    let mut ui = UiDocument::new(root_style(viewport.width, viewport.height));
    let root = ui.root;

    widgets::button(
        &mut ui,
        root,
        "run",
        "Run",
        widgets::ButtonOptions::new(LayoutStyle::size(140.0, 36.0)),
    );

    ui
}

The runner opens the window, creates the renderer, lays out the document, and routes input. Use run_app when widget actions should update application state; the showcase example is a compact app built that way.

Web apps use the same retained document contract through the web-runtime feature:

#[cfg(target_arch = "wasm32")]
#[wasm_bindgen::prelude::wasm_bindgen]
pub async fn start() -> Result<(), wasm_bindgen::JsValue> {
    operad::web::run("app", view).await
}

For custom WGPU drawing, add a GPU canvas to the document and register a canvas renderer:

let mut canvases = operad::NativeWgpuCanvasRenderRegistry::new();
canvases.register("viewport", |state: &mut AppState, context| {
    state.renderer.render(&context.surface)?;
    Ok(operad::CanvasRenderOutput::new())
});

operad::run_app_with_canvas_renderers(options, state, update, view, canvases)?;

The renderer callback gets the canvas texture context, so it can record normal WGPU command buffers and render passes before Operad composites the UI.

Install

cargo add operad

Feature Flags

• widgets: widget helpers.
• native-window: native winit/WGPU windows.
• web-runtime: WASM/WebGPU runtime entry points with cosmic-text layout measurement.
• web-showcase: web runtime plus showcase widgets.
• wgpu: WGPU rendering.
• accesskit-winit: AccessKit support for winit hosts.
• text-cosmic: cosmic-text measurement and shaping.
• egui: egui host/input compatibility.
• egui-renderer-compat: egui renderer compatibility.
• audit: audit helpers.

Examples

Open a native window:

cargo run --example showcase

Starter templates are checked as ordinary examples:

cargo run --example minimal_native
cargo run --example simple_form
cargo run --example docked_workspace

For the web template, build minimal_web for wasm32-unknown-unknown, run wasm-bindgen, and serve web/minimal.

Development Checks

Use the fast gate while iterating:

scripts/test-fast.sh

That runs formatting, locked all-target/all-feature compilation, all-feature library tests, and the locked no-default compile gate without running perf smoke or WGPU snapshot integration tests.

Focused cargo aliases are available for common loops:

cargo test-native
cargo test-matrix
cargo test-wgpu-snap
cargo test-perf

Run the full local gate before release-level handoff:

scripts/test-full.sh

That adds the full all-feature test suite and the supported WASM showcase check for wasm32-unknown-unknown.

The release flow lives in docs/release_process.md.

Learn More

• API documentation
• Getting started
• Examples
• Documentation