
krate
tech.krate/krate
Make an app by asking. Krate builds and checks it, and its link opens in any browser, phones too.
Documentation
Krate
Make and send apps like pictures.
Describe an app and Krate makes it, or write it yourself in Rust. It is one .krate file.
Send it as a link and it opens in any browser, phones included, with nothing to install.
On macOS, Windows and Linux the same file runs natively. Every app is sandboxed: it reaches only
what it asks for and the person allows. Open source, built on Wasmtime.
Start from the template · Quickstart · Docs · Releases · Discussions
![]() Orbit · network globe | ![]() Aurora · simulation |
![]() Player · music player | ![]() Editor · code editor |
Each is one .krate file built with Krate, with its source in apps/. See them running at krate.tech.
In numbers
The same 50,000-line notes workload on the same Apple M4 Mac, against MarkText 0.17.1, an Electron editor. Both ARM64, measured 25 August 2026.
| MarkText (Electron) | Krate | |
|---|---|---|
| Memory with the document open | 2,299.4 MiB across four processes | 178.5 MiB, one process |
| Warm open to a visible window | 611.5 ms, median of 10 | 237.1 ms, median of 10 |
| The app on disk | 284.6 MiB installed | 36.6 KiB, plus the 88.6 MiB runtime installed once for every app |
That is one workload, and other apps will measure differently. The benchmark kit and this run's analysis say how it was measured.
Also in apps/: id Software's 1993 Doom, running
under Krate as one 2.8 MB .krate that asks for three permissions: a
window, printing its start-up lines, and reading its arguments. Runtimes
ship for macOS (Apple silicon, Intel), Windows (x64, ARM64) and Linux
(x86_64, arm64).
Start here
Send an app as a link. Publish any .krate and send the link:
krate publish my-app.krate
Whoever taps it sees the app open in their browser, on a phone, a tablet or a computer, with nothing to install. Publishing it again is the app's next version: the same link opens the update. A few abilities (working in a folder on the computer, Bluetooth) need Krate on a computer, and the app says so in words when it asks for one. Or make one in Krate Studio and press Share.
Build your own app. Press Use this template on
krate-app-template.
It is a small working app (a counter that keeps its value) whose CI builds
one .krate and then opens that same file on Linux, macOS and Windows.
To build it on your machine:
rustup target add wasm32-wasip1
curl -fsSL https://krate.tech/install.sh | sh
krate check-app .
check-app builds the app, confirms it imports only Krate's interfaces,
runs it once, and tells you which stage failed and how to fix it. In CI,
setup-krate installs Krate on
any GitHub runner.
Open an app someone sent you. A link opens in your browser. To run
.krate files natively on a computer, install Krate once:
curl -fsSL https://krate.tech/install.sh | sh
On Windows, use irm https://krate.tech/install.ps1 | iex. Read the
Unix script or PowerShell script
first if you prefer, or download an archive from
Releases.
Then try Chart, a small rainfall chart (source, checksum):
CHART=https://raw.githubusercontent.com/incyashraj/krate/c46d29500f2b894c89285b04e1b5e2f75184e972/evidence/ported/chart.krate
krate run "$CHART" --dump-caps
krate run "$CHART" --prompt
--dump-caps lists what the app asks for without running it. Chart asks
for a window and nothing on your files or the network. On Linux X11 you may
need one system library.
Build your app
| Your starting point | Next step |
|---|---|
| Start fresh in Rust | krate-app-template, then the Rust SDK |
| Bring an existing project | Porting guide; start with the read-only krate port ./my-project scan |
| Build with AI | Krate Studio, or krate create with the coding agent you already use |
| Judge the design | Portable format, distribution comparison and current limits |
To build with AI from the terminal, you need the Rust and component tools and an installed, signed-in coding agent. Its subscription or API costs are your own:
krate doctor
krate create "a regex tester with a pattern box and live matches" --agent claude --output regex.krate
krate run regex.krate --dump-caps
krate check-app checks the build, the imports and a first run. Use the app
yourself and try it on each system you plan to support before you send it.
Have an app in mind? Tell us what it does and which systems it needs in the welcome discussion.
Nothing installed? Start in the browser
krate.tech/app is Krate Studio in a tab. Sign in
with GitHub, Google or an email link, describe
the app you want and Krate AI writes it, builds it on our machines and
hands back a .krate you can download and run. No install, no toolchain, no
API key of your own.
Your first app is on us, and so is your first change to it. After that, Krate Studio on your own machine is free and unlimited when you point it at an AI you already have (Claude, Codex, Gemini, or an API key you hold). The session follows your account, so anything you start in the browser opens on the desktop ready to edit.
Why a file
Cross-platform frameworks can share source while still producing separate application packages for each platform. Krate moves the platform-specific part into a shared runtime and makes the application artifact portable.
- The app and the access it asks for go into one
.kratefile. - That same file opens on Mac, Windows, and Linux. The bytes do not change.
- Krate shows the person what it wants before it runs.
- Host operations are checked against the session's capabilities.
A Krate app is a WebAssembly component compiled from ordinary Rust. It
carries no browser engine or per-app native runtime. Package size depends on
code, source, dependencies and assets; there is no universal size promise.
The goal is to make .krate a standard way developers ship software.
Today, that depends on the app fitting Krate's supported interfaces.
Krate Studio
A real build, recorded in one take: one sentence in, a 24 KB app out. The AI's 2 min 47 s of work is sped up.
A session is a conversation beside a panel. On the left, what you asked,
the plan, and the AI's working (folded into one live line you can open).
On the right, the app itself: Preview runs it, Files lists what is
inside the .krate, Code shows the Rust it was built from, Details
says what it may use. Share gives a link, the file, or a one-click
installer for someone new to Krate.
Studio runs the same engine the CLI does: build, import-check, run and
pack, with the engine's real output on screen, not a summary of it. It uses
the coding AI you already have installed and pay for, and stays out of the
way if you would rather write the code yourself. Every .krate carries its
own source, so a build you shipped a year ago opens as a project you can
edit.
It runs in two places, and they are the same interface rather than two lookalikes:
- In a browser, at krate.tech/app. Krate AI does the writing and the build happens on our machines. Nothing to install, and your first app and first change are free.
- On your machine, from krate.tech/download.
Signed
.dmgon macOS, installer on Windows (unsigned for now, so SmartScreen asks once), AppImage on Linux. Free and unlimited with your own AI.
Sessions live on your account, so an app you start in the browser opens on the desktop with its conversation intact and editable.
For a team
krate.tech/orgs gives a company its own place
on Krate. Name the organisation, release its first app (Team Notes,
Expenses, Stock List, or a .krate you made) and invite your team by
email, all from one page. A developer sends an app, a reviewer approves its
exact bytes, and only your people can open it: a copied link alone opens
nothing. The apps' team data and the credentials for your company's APIs
are encrypted on members' computers, so Krate's hub stores them without
being able to read them.
For IT: company sign-in with OpenID Connect or SAML 2.0, people and groups kept in step by SCIM, a policy that says which apps may open on company computers, and an audit of every approval. Read Organisations and Running Krate in an organisation.
What it costs
Nothing, right now. The player is MIT and Apache licensed and always will be. The CLI and Krate Studio on your own machine are free and uncapped, and we will say so long before that changes.
The one thing with a limit is the inference we pay for. Krate AI in the browser writes your first app and your first change to it on us; after that, making is unlimited on your own machine with an AI you already have.
If you point Krate at your own coding AI, that stays your subscription and Krate never holds its keys.
The permission wall
A .krate holds a WebAssembly component, the app's name, the access it
requests, and a reason for each request. Opening the file grants nothing on
its own; Krate connects only the operations the person approved. Look
inside any app without running it:
krate run app.krate --dump-caps
fs.read:notes/**reads only inside thenotesfolder;store.kv/store.sqlgive an app private storage, so remembering things needs no access to your folders at all;- no network call works unless network access was declared and granted, and a redirect to a host you did not allow is not followed;
- an app downloaded from a URL gets no extra access for having come from one;
- the camera, the microphone, speech and sound sit behind the same wall, so an app that wants to see or hear you has to say so first;
- a file you pick or drag onto a window is handed over as a name and a token, never a path, so the app opens that one file and cannot walk to its folder or come back for it on a later run;
store.sharedandnet.wsare the multiplayer pair: a bucket two machines share through an invite code, and a live two-way connection.
The strong version of the claim is mechanical, not a promise: these apps
import zero wasi:* interfaces. There is no ambient access to leak
because the door was never built into the app. Check any app yourself with
wasm-tools component wit.
Work on it
Everything above is what Krate does. Everything below is the machinery:
the player, the .krate format, and krate check-app live in this
repository; Krate Studio and the hub are the product layer (studio/
and cloud/).
A terminal or your own AI tools
Studio is one front end for the engine, not the only one. Whichever you
pick, every path ends at the same .krate file:
- Claude Code plugin: in Claude Code, run
/plugin install krate --marketplace incyashraj/krate-claude-plugin(or, in a terminal,claude plugin marketplace add incyashraj/krate-claude-pluginand thenclaude plugin install krate@krate). It teaches Claude to make, check, package and publish Krate apps with Krate's own commands. Install Krate itself first. Source: krate-claude-plugin. - MCP:
krate mcpis a server Claude Desktop or Cursor can call; add{"mcpServers": {"krate": {"command": "krate", "args": ["mcp"]}}}to the app's MCP config and ask for the app in chat. Full setup: docs/mcp-setup.md. - Krate Mode: one paste-in prompt that teaches any AI chat to write
correct Krate code, generated from the real interface definitions.
krate krate-modeprints it; read it online. - One word:
krateasks what you want and builds it. In one line:krate create "a habit tracker" --output habit.krate --agent claude. Five agents are supported (claude,codex,gemini,copilot,grok);krate aisays which are ready, and--author-cmdis the seam for anything else.
Ask for something a sandboxed app cannot be, like "download my email", and
krate create refuses in about a second with the reason and a suggestion,
instead of spending five minutes building something convincing that could
never work.
krate check-app: the oracle behind AI authoring
An AI writing code needs a truthful, fast answer to "is this actually
correct?" check-app runs nine stages and prints one verdict; because the
failure text names the fix, an agent can loop on it without a human in the
middle.
| Stage | Exit | What it proves |
|---|---|---|
| layout | 10 | The directory has the files an app needs |
| manifest | 11 | The manifest is valid |
| build | 12 | It compiles, with the right toolchain |
| imports | 13 | It imports only krate:*, no wasi:* leak |
| run | 14 | It actually runs, headless |
| shoot | 15 | A GUI app paints a real frame |
| usability | 16 | Driven the way a person would: it stays open, follows a resize, answers a press |
| screens | 17 | It fits a phone, a tablet and a desktop window (from 0.5.5) |
| phone | 18 | It runs the way a phone runs it, on the interpreter iOS requires, and its first frame and scrolling are timed (from 0.5.5) |
--json gives the same verdict as a machine-readable object; --shoot frame.png writes the app's first frame to a PNG so output can be looked at
rather than guessed about.
Next release, on main now
Not in v0.5.5-rc9 yet; built, tested and merged:
- Make an app in your Claude chat. Add Krate to Claude as a connector
(
https://hub.krate.tech/mcp) and ask for an app in plain words: Claude writes it, Krate builds and checks it, and you get a link that opens on any phone or computer, with nothing to install. If a build fails, Claude gets Krate's own words and fixes it. In Claude Code, the Krate plugin adds the same connector. How it works. - Apps know the person's local time.
krate::locale::today()andlocal_now()give the local date and time as numbers, daylight saving included, on desktop and in a browser tab. - Apps reach the factory floor. Serial ports (
device.serial), label and receipt printers the person picks once (device.printer, raw ZPL, EPL or ESC/POS), and serving on the computer or the local network (net.listen:<port>), each behind the permission wall. - Every app you make is signed as you, from its first file. One publisher key per person per computer, made with no account and no question. Your app keeps its data through every rebuild, and no other app claiming its id can reach it.
- A new key without losing anything.
krate identity --new-keyhands over from your old key to a new one, signed by both; each app moves its data across the first time it opens.--report-compromisedtells Krate Cloud first: releases the old key signed since a date are blocked, and each app goes back to its last safe version. - Changing an app with AI is a transaction. The app you have is replaced only by a build that passed every check, and never over a file something else changed while the AI worked; that change is kept beside it instead.
- Installed apps are themselves. Finder, Spotlight, Launchpad and the Windows Start menu show the app's own name, and a Start menu entry opens with no console window.
- Krate Cloud keeps an update with its publisher (another key is refused unless the old one handed over), treats a re-packed release as the version it already is, ranks gallery search by relevance with the publisher's verified identity shown on every result (no placement is sold), and sends a blocked update's link back to the last safe version.
Where things stand
One .krate runs on Mac, Windows, and Linux, GPU-rendered with a CPU
fallback; files, network, storage, and clipboard sit behind the permission
wall; apps run from a file or straight from an HTTPS URL; publishing a
link works from Studio, krate publish, or
krate.tech/publish. Exact evidence:
STATUS.md.
Known limits, stated plainly:
- Apps use Krate's interfaces. Existing native binaries, Electron apps and Tauri apps need a port, not a file-extension change. Check capability limits and the porting guide.
- Windows and Linux studio builds are unsigned for now; macOS is signed and notarised by Apple.
- An AI has to write against the current Krate APIs, which are still changing.
- Permission review and desktop polish differ between operating systems.
- File formats and interfaces will change before 1.0.
- This is a young product, not a frozen API. Use it for your own apps and the published examples, not as a shield against hostile third-party code.
Build from source
git clone https://github.com/incyashraj/krate
cd krate
cargo build --workspace && cargo test --workspace
The workspace has over 2,300 Rust tests. You need the Rust toolchain named in
rust-toolchain.toml and cargo-component; check your machine with
krate doctor. Platform packages, the two Windows traps, and the
one-package Linux receiver note live in docs/build.md.
Repository map
apps/ Sample apps and apps used to test Krate
cloud/ The hub (hub.krate.tech) and the build service behind Studio in a browser
crates/ Runtime, CLI, policy, desktop/browser/phone adapters, MCP server, authoring, SDK
docs/ Website, book, design records, and technical documentation
evidence/ Measurements, claim records and release evidence behind the numbers above
scripts/ Build, install, test, evidence, and release tools
studio/ Krate Studio, the desktop app
test/ Integration fixtures and cross-language tests
wit/ Krate interface definitions
Documentation
| Start here | Link |
|---|---|
| Connect Krate to Claude Desktop or Cursor | docs/mcp-setup.md |
| The paste-in prompt for any AI chat | Krate Mode |
| Plain guide for making an app | Make an app with AI |
| Developer quickstart | Quickstart |
| Private apps for a company | Organisations |
| Bring an app you already have | Porting guide |
| Build from source | docs/build.md |
| Exact current evidence | Status |
Contributing
Contributions are welcome across code, documentation, design, examples, and testing. Start with CONTRIBUTING.md, then good first issues and Discussions. For a larger change, open an issue before writing the full implementation. Everyone is held to the Code of Conduct.
Questions, ideas, or something you made? Come say hi on the Krate Discord, where people share what they make and help each other.
What Krate counts
A random id made on your machine, the Krate version, the OS name, one of
install / make / open / publish, whether an AI wrote the app, and
whether it worked; when an app does not open, one word for why from a fixed
list (refused, not-found, bad-bundle and so on). Never: app names, prompts, paths, or anything about you.
krate telemetry off turns it off (DO_NOT_TRACK=1 is honoured too), and
it says so on first run rather than hiding here.
Project status
- Stage: public beta, works end to end, API not yet frozen
- Current release: the latest on the releases page
- Company: Krate Labs
- Maintainer: Yashraj Pardeshi
- License: MIT OR Apache-2.0 for the player, format and CLI; BSL 1.1 for Studio and the hub (details)
License
Open core, split by what each piece is for:
| Piece | License |
|---|---|
Player, .krate format, CLI, runtime: everything a receiver trusts | MIT OR Apache 2.0 |
Krate Studio (studio/) and the hub worker (cloud/worker/) | Business Source License 1.1, converts to Apache 2.0 in 2030 |
The BSL lets you read, build, and use Studio; it stops a competing hosted Studio. Versions published before the split remain under their original MIT OR Apache terms. Contributions to the player use the dual license.
Acknowledgements
Krate builds on work from the Bytecode Alliance, Wasmtime, the Rust community, and the wider WebAssembly community.
No installation packages available.



