Desktop UI that only renders what changed.

A GPU-accelerated GUI framework for native desktop apps, in Rust or TypeScript. Familiar layout, real text, built-in accessibility — and zero CPU while your app is idle.

Get started

$cargo add quickgui

Everything a desktop app needs.

Zero CPU when idle

If nothing changes on screen, nothing runs. Idle windows draw no frames and stay off the battery.

Fast by default

Rendering happens on the GPU, and only the part of the window that changed is redrawn.

Layout you already know

Flexbox and CSS Grid, with Tailwind-style shorthands. If you can lay out a web page, you can lay out a window.

Components included

A large collection of accessible, unstyled components — menus, dialogs, popovers, selects, comboboxes, tabs, tables, trees — ready to make yours.

Text that just works

Selection, editing, undo, input methods, emoji, and right-to-left scripts behave like they do in every native app.

Accessible by default

Screen readers see real buttons, lists, and text — no extra code required.

Smooth at any size

Tables and lists with a million rows scroll without dropping frames.

Feels native, because it is

Real windows with native menus, dialogs, tray icons, and notifications — not a browser in a costume.

One CLI, dev to release

quickgui dev runs your app and reloads as you edit; quickgui build hands you a signed, installable release.

Write it in Rust or TypeScript.

Use whichever you like — both produce the same native app, with no webview.

main.rsRust

struct Counter {
    count: usize,
}

impl View for Counter {
    fn render(
        &mut self,
        cx: &mut ViewContext<'_, Self>,
    ) -> impl IntoElement {
        let increment = cx.listener("increment", |this, cx| {
            this.count += 1;
            cx.invalidate();
        });

        div()
            .size_full()
            .flex_col()
            .items_center()
            .justify_center()
            .gap_3()
            .child(text(format!("Count: {}", self.count)))
            .child(
                div()
                    .on_click(increment)
                    .px_4()
                    .py_2()
                    .rounded_lg()
                    .bg(Color::rgb8(24, 24, 27))
                    .text_color(Color::rgb8(250, 250, 250))
                    .hover(|s| s.bg(Color::rgb8(63, 63, 70)))
                    .child("Increment"),
            )
    }
}

app.tsxTypeScript · Solid

function Counter() {
  const [count, setCount] = createSignal(0);

  return (
    <View
      style={{
        display: "flex",
        flexDirection: "column",
        width: "100%",
        height: "100%",
        alignItems: "center",
        justifyContent: "center",
        gap: 12,
      }}
    >
      <Text>Count: {count()}</Text>
      <Button onClick={() => setCount((value) => value + 1)}>
        Increment
      </Button>
    </View>
  );
}

Start in a minute.

Rust

Add the crate

cargo add quickgui

Write a view

The counter above is a complete main.rs — copy it in.

Run it

cargo run --release

TypeScript · Solid

Create an app

bunx @quickgui/cli init my-app
cd my-app
bun run dev

Ship it

quickgui build --target darwin-arm64 \
  --sign "Developer ID Application: Example (TEAMID)" \
  --notarize quickgui-notary

You get a real, signed, self-contained app — installer included.

macOSavailable now

Windowsin progress

Linuxin progress

Build something native.

Write a view, ship a real app — and let idle windows actually idle.

Read the docs Star on GitHub