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 →The universal app development framework
Build native apps for iOS, Android, macOS, Windows, and Linux from one Rust codebase. Day includes tools for testing, translation, and packaging.
Intuitive, declarative, and reactive
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…
View the app’s source →Learn about signals →Explore the Rust API →
Living in a polyglot world
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
That screenshot could not be loaded. Please try another selection.
All for one and one for all
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
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.
Embed a website or bundled HTML, control navigation, and call JavaScript from Rust.
Play Lottie motion graphics in your layouts, with playback and looping controls.
Read text aloud through the platform’s speech engine.
Build charts from bars, lines, points, and other marks, with scales and axes.
Show a live camera preview and capture photos on supported mobile targets.
Play media through platform players, with observable playback state and a timeline.
Connect accounts through OAuth, OpenID Connect, and native credential dialogs.
Connect to sensors and accessories, read and write values, and simulate peripherals in tests.
Find nearby services and advertise your app’s services using mDNS and DNS-SD.
Receive remote notifications through APNs and FCM, track device tokens, and handle notification taps.
Schedule mobile syncs and retries through the OS, or run delayed tasks while your app stays open.
Record crashes locally and let people review a report before sharing it.
Continuous verification across all platforms
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 →
Use the VS Code extension to choose targets, build, and launch your app from the editor.
Generate the Rust project and platform host files with day new app. Use day doctor to identify missing SDKs and build tools.
Write a DayScript walkthrough that finds controls by stable IDs. Reuse it across targets to check the same behavior.
Use screenshot steps in that walkthrough to capture the same screens in different languages and themes.
Build installers and mobile packages with day pack. Check the reported signing status before distributing them.
For native developers and library authors
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 →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 →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.