Public RC0.1.0-rc.2macOS · Windows · Linux

Rust-powered. Frontend-owned.

Your frontend.
Their files.
One native workflow.

Build local desktop tools in TypeScript or JavaScript. RustFrame owns typed SQLite, consent-scoped machine access, the native window, and real installers—until you decide to eject.

Install RustFrame Explore the framework RC

RC status: Framework CLI artifacts are public. The initial npm frontend package and signed Research Desk downloads remain open release gates.

TERMINAL / 00:01

$ rustframe new evidence-desk

✓ Vite + TypeScript

✓ SQLite types generated

✓ capability policy validated

$ rustframe dev

Research Desk indexing and reviewing local documents in a native desktop window

01 Embedded SQLite

02 Opaque file grants

03 Window capabilities

04 Native installers

05 Explicit eject

The missing middle

A browser tab is too small.
A native backend is too much.

RustFrame sits between them: a deliberately bounded native substrate for applications whose value lives in local structured data, user-selected files, and repeatable machine workflows.

01 / Research

Evidence desks

Index documents, search locally, annotate findings, and keep focused reader windows synchronized.

files + search + notes

02 / Review

Media queues

Attach a user-approved library, track decisions in SQLite, and export a portable review trail.

grants + records + export

03 / Operations

Offline workbenches

Ship a focused queue, catalog, runbook, or internal console without operating a mandatory server.

schema + jobs + package

One contract, end to end

Model the work.
RustFrame carries it.

You own ordinary frontend code and the product experience. RustFrame owns the repeatable native substrate and keeps it visible in one versioned manifest.

Declare

Schema + capabilities

Define tables, windows, permissions, file roots, commands, and package identity as reviewable source.

rustframe.json

Generate

Typed SQLite APIs

Record, insert, update, and table-map types stay deterministic and CI-checkable.

rustframe codegen

Develop

Vite + native window

One process supervisor runs the frontend and hidden native runner together.

rustframe dev

Prove

Validate the boundary

Unknown permissions, unsafe paths, weak CSPs, and stale generated types fail before shipping.

rustframe validate

Ship

Host-native packages

Create DMG, MSI, NSIS, AppImage, and Debian output with checksums and metadata.

rustframe package

Schema in. Types out.

Edit a real RustFrame data contract.

This browser tool mirrors the CLI’s deterministic TypeScript generator. Its golden fixture is checked against the Rust implementation in the test suite.

data/schema.jsonLoading verified example…

The ZIP is generated locally in your browser. It includes this schema, matching types, a minimal Vite app, and the current RC dependency. npm installation remains gated until the first public rustframe-api publication.

src/rustframe.generated.tsread-only output

Waiting for a valid schema…

Least privilege you can explain

The frontend never gets a master key.

A person chooses a folder. RustFrame returns an opaque grant. Every read, write, watch, dialog, database call, command, and window action is authorized inside native IPC.

✓ per-window permissions
✓ revocable file grants
✓ bounded command arguments and output
✓ rate, size, timeout, and traversal limits
✓ no telemetry by default

Read the threat model

CAPABILITY LABmain windowinteractive

Toggle effective permissions Read SQLite Write SQLite Read chosen folder Write chosen folder Run bounded indexer

effective policy3 permissions

narrow local policy

Research Desk local archive, review queue, and document preview

FLAGSHIP / 01Research DeskBuilt only with public RustFrame APIs

A real workflow, not a toy counter

Choose a folder.
Build a research memory.

Research Desk watches Markdown and text files, indexes them without Python, stores review state locally, synchronizes reader windows, exports queues, and protects recovery with SQLite backup and restore.

0required servers

3native hosts

1public API surface

View framework RC Read the benchmark receipt →Inspect the source →

Choose honestly

Use the smallest tool that owns your actual problem.

RustFrame wins by being opinionated, not by pretending to have the broadest desktop ecosystem.

Need	RustFrame	Tauri	Electron	Browser / PWA
App-owned native backend	No until eject	Usually Rust	Node main process	None
Typed embedded data by default	Yes · SQLite	Compose plugins	Choose a library	Browser storage
Consent-scoped local files	Opaque grants	Capability/plugin scopes	App-defined IPC	Limited picker APIs
Native API breadth	Intentionally small	Broad	Broad	Limited
Best fit	Local workbenches	Custom native apps	Large JS desktop apps	Connected products

Read the complete chooser →

Start from an empty folder

Install once.
Create anywhere.

Use the prebuilt CLI for the shortest path. Rust and the host WebView toolchain are still required to compile the stock native runner.

1Install the CLI
2Run rustframe doctor
3Create and open your workflow

curl --proto '=https' --tlsv1.2 -LsSf \
  https://github.com/OthmaneBlial/rustframe/releases/download/v0.1.0-rc.2/rustframe-cli-installer.sh | sh

powershell -ExecutionPolicy Bypass -c "irm https://github.com/OthmaneBlial/rustframe/releases/download/v0.1.0-rc.2/rustframe-cli-installer.ps1 | iex"

cargo install --git https://github.com/OthmaneBlial/rustframe \
  --tag v0.1.0-rc.2 rustframe-cli --locked

Thenrustframe doctor && rustframe new my-tool

RC registry note: dependency installation becomes public after the initial rustframe-api npm publication.

Read only what you need

From first window to trusted package.

Open all documentation

Build the workflow. Keep the data.

The desktop can be local
without becoming low-level.

Install RustFrame ↓Star or contribute on GitHub ↗

Your frontend.Their files.One native workflow.