Skip to content
alpha 0.1.0-alpha.7 is on crates.io. Install the CLI Start here

Auro 0.1.0-alpha.7 · native desktop

Desktop apps with a Rust frontend.

Auro keeps Tauri's app model - configuration, windows, capabilities, bundling, signed updates - and replaces the webview with GPUI, Zed's GPU-accelerated Rust UI toolkit. One Rust codebase, from window to command.

Pre-alpha. The CLI alpha is public; the framework is not production-ready. Hot reload is measured only for the documented data boundary. Platform status.

The shape of the work

One workspace from install to window.

  1. Scaffold a real app

    auro new writes a four-crate workspace: the bin, the view, the hot boundary and the shared data types.

  2. Run the native loop

    auro dev builds, launches and watches. The default loop rebuilds and restarts; the hot path is opt-in and has a narrower contract.

  3. Build and bundle

    auro build makes a release binary. auro bundle uses the platform packaging paths; support is documented, not assumed.

The boundary

A command is a Rust function.

The schema is derived from the Rust signature, and the call site is a Rust call. A renamed command or a wrong argument is a compile error, not a runtime string lookup.

Cheap mutation stays on the UI thread. File I/O and network calls run as commands on tokio; the result returns to the main thread, updates an entity, and the next frame renders it.

There is no invoke("name", {...}) in first-party code because there is no JavaScript bridge to invoke through. Read the threading contract.

#[auro::command]
async fn save_document(
    path: PathBuf,
    body: String,
) -> Result<Saved, AuroError> {
    tokio::fs::write(&path, body).await?;
    Ok(Saved { path, bytes: body.len() })
}
// The call site is typed too.
let saved = api::save_document(doc.path, doc.body).await?;
What you get

The app model, without the browser.

typed IPC

No stringly bridge

Commands, events and arguments are Rust types. The schema is generated from the same signature the compiler checks.

renderer

GPUI, not a webview

The app draws through GPUI on the GPU. The webview is a scoped Phase 4 escape hatch for OAuth and embedded docs, not the foundation.

capabilities

Fence the real boundary

Grants are deny-by-default and scoped to filesystem, network, shell, clipboard, notifications and keychain. Most UI code needs no runtime check.

application layer

Keep the boring parts

Config, window management, lifecycle, single-instance, tray, shortcuts and deep links stay in the framework, where Tauri already proved the shape.

release

Signed updates, opt-in

Update manifests are signed, artifacts are hashed and staged, and apply paths are platform-specific. The updater is a feature, not a default.

the loop

Hot reload, measured honestly

Edits in the documented data boundary measured 368 ms median on Linux. View, layout, type and dependency edits rebuild the host and restart the process.

Scope

What Auro is not.

  • Not a webview wrapper. The webview is a scoped Phase 4 escape hatch for OAuth and embedded docs, not the foundation.
  • Not a GUI toolkit. GPUI owns the widgets and the renderer. Auro is the application layer around it.
  • Not a GPUI fork. Upstream is pinned, with one thin compatibility module and no GPUI outside auro-ui.
  • Not "CSS for Rust". The UI is a builder API plus design tokens. There is no styling language in 1.0.
Choose a path

Build, inspect, or challenge it.

Alpha means alpha.

The CLI is published; the framework contract is not stable. Read the limits before choosing it for anything that matters.

  • 0.1.0-alpha.7 is on crates.io; there is no stable release.
  • Hot reload is measured on Linux for the data boundary; Windows and macOS are above the target.
  • Platform rows are published as verified or unverified, not as promises.