Close to your data.
Entirely in Rust.

A local-first web framework. Render on the server. Query in the browser. Write your app in one language.

Rust in. A living interface out.

One query, on the server and in the browser.

let issues = live_query! {
    IssueItem from i in IssueRow
    where if $(!search.get().is_empty()) {
        i.title contains $(search.get())
    }
    order by i.modified desc
    limit 50
    select { id: i.id, title: i.title }
};

Illustrative query. The complete example is in the repository.

Don't take a screenshot's word for it.

Try a real Hearth app: filter local rows, toggle an issue, and watch the Rust server validate the write.

Try the live demo

Illustrative data, isolated to your browser. Hosted separately on Fly.io; no third-party cookies or embedded app are needed to read these docs.

This page is static and served from Cloudflare Pages. The live demo is the real Rust/Hearth application, not a simulated interaction.

The first view comes from the server.
The next move is yours.

One source of truth.

Declare a table, authorize its rows, and write a query in Rust. Hearth uses the query for the initial render and the browser's live results.

#[derive(Table)]
live_query! { ... }

HTML, already useful.

The server sends rendered content. Client expressions become JavaScript functions. No client-side Rust or WebAssembly runtime download.

Rust → HTML + JavaScript

Keep the data close.

Indexed queries run against browser-local tables. Writes update the interface immediately, then the server validates them. Rejections roll back.

local query → update → sync

Less between
you and the app.

A framework for the page, the data, and the space between. Pure Rust application code. Generated JavaScript where the browser needs it.

Rust all the way down: Views, handlers, read scopes and write validation live together. You don't maintain a second JavaScript application.
Local queries, live results: Filter, join and sort without a request for every interaction. Declare browser data and indexes alongside the Rust model.
The server stays in charge: Read scopes are mandatory. Writes are explicitly allowed and checked on the server. Browser state is never authorization.
A high performance ceiling: Native Rust server execution, server-rendered startup, indexed local queries and a small JavaScript runtime. Architectural goals, not an unmeasured promise that every Rust app beats every JavaScript app.

Make yourself
at home.

Hearth 0.1.0 is available on crates.io. Start small, read the source, and tell us where it gets in your way.

Build your first page

cargo add hearth@=0.1.0
cargo install hearth-cli --version 0.1.0 --locked

Use the tested Rust 1.99.1 toolchain. No Node.js or pnpm required for your app.

Complete setup and running instructions →

An honest starting point.

Experimental APIs. Defined Rust expression vocabulary. IndexedDB caches server rows, not a durable offline write queue. Delta sync currently scans scoped server tables. Test with your own data and permissions.

Read the current boundaries →

Close to your data.Entirely in Rust.