The universal app development framework

One app.
Every platform.
All Day.

Build native apps for iOS, Android, macOS, Windows, and Linux from one Rust codebase. Day includes tools for testing, translation, and packaging.

See current platform support →

Desktop and mobile

Share more than just the business logic

Day lets you reuse the interface as well as the data model. Your layouts and event handlers are Rust code, backed by the UI toolkit on each platform. No bridging between disparate programming languages is required (although you can if you want to).

One place for UI changes

Compose screens with Rust functions. The same definitions can be used by your desktop and mobile builds.

Explore the app structure →

Packages for each target

Use the same project to prepare installers and mobile packages, then manage store listings and submissions.

See the release tools →

Native features when you need them

Extend the app with platform controls and services. Provide a fallback where the feature isn’t supported.

Add platform features →

Intuitive, declarative, and reactive

A high-level interface for your low-level Rust

Assemble controls declaratively with Rust functions and bind them to reactive signals. Try the browser version below; the same Rust UI uses each platform’s native toolkit when built for desktop or mobile.

pub fn root() -> impl Piece {
    let value = Signal::new(0.4);
    form((
        row((label(res::str::value(value)).font(Font::Title2), spacer(), progress(value))),
        labeled(res::str::slide(), slider(value).step(0.01)),
        labeled(res::str::step(), stepper(value).range(0.0..=1.0).step(0.01).format(NumberFormat::percent())),
        rectangle().height(32.0).fill(move || Color::hsl(value.get() * 360.0, 0.65, 0.5)),
        button(res::str::reset()).prominent().action(move || value.set(0.4)).aligned(Alignment::Center).grow(Dimension::Width),
    )).padding(Space::L)
}

Loading live demo…

Living in a polyglot world

First-class localization support

Translation are implemented through Mozilla Fluent catalogs, and Day generates typed Rust accessors so the UI and its message arguments are checked together at build time. Use the same UI walkthrough in several languages to verify translated screens.

See how localization works →

macOS · AppKit · English · Light

Day Travel · macOS · AppKit · English · Light · Full window

macOS · AppKit · English · Light

All for one and one for all

Native accessibility for an inclusive world

Help people use your app with a keyboard or screen reader. Day builds on the accessibility support of native controls, with a shared Rust API for localized labels, hints, and changing values. These tools help you address regional and government accessibility requirements.

Build accessible interfaces →

The Daybrite ecosystem

Everything you need to build a modern app

Add a web view, play an animation, or read a passage aloud. Daybrite’s optional pieces and parts are ordinary Cargo dependencies: add the ones your app needs and use them alongside Day’s built-in controls and services. Each guide covers setup and platform support.

Continuous verification across all platforms

Automation done right

DayScript is Day's testing and automation driver. The same walkthrough can exercise a feature on several targets and grab screenshots. Run it locally while developing your app, then fan out across all the targets and locales in CI to verify behavior and generate screenshots. DayScript overview →

  1. Edit →

    Use the VS Code extension to choose targets, build, and launch your app from the editor.

  2. Set up →

    Generate the Rust project and platform host files with day new app. Use day doctor to identify missing SDKs and build tools.

  3. Test →

    Write a DayScript walkthrough that finds controls by stable IDs. Reuse it across targets to check the same behavior.

  4. Capture →

    Use screenshot steps in that walkthrough to capture the same screens in different languages and themes.

  5. Package →

    Build installers and mobile packages with day pack. Check the reported signing status before distributing them.

For native developers and library authors

Package your platform expertise
as a reusable Day extension.

Native integrations in Cargo crates.

Wrap a native widget or platform service behind a Rust API. Your crate can include Swift, Java, ArkTS, or C++ code. Day’s build tools collect the declared sources and dependencies into the app’s platform builds.

Build an extension →

Share components across apps.

Combine existing Day controls into reusable components using Rust alone. A composed component uses the backends of its underlying controls, so you can publish it as a crate without writing a renderer for each platform.

Build a reusable component →

Rise and Shine

Get started in minutes with the tutorial, or run the Showcase app on your desktop or mobile device to experience first-hand the Day approach to building applications your users will love.